--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/multimodetsy/test/Te_Sms/Te_Sms.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,949 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Tests the Sms functionality of the Basic MMTsy.
+//
+//
+
+/**
+ @file
+*/
+
+#include "Te_Sms.h"
+
+
+const TInt KOneSecond = 1000000;
+
+
+
+CTestSendSms::CTestSendSms()
+ {
+ SetTestStepName(_L("TestSendSms"));
+ }
+
+enum TVerdict CTestSendSms::doTestStepL()
+ {
+ SendSms();
+
+ return EPass;
+ }
+
+CTestAckSmsStored::CTestAckSmsStored()
+ {
+ SetTestStepName(_L("TestAckSmsStored"));
+ }
+
+enum TVerdict CTestAckSmsStored::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+ TRequestStatus status;
+ TBuf8<400> buf;
+ TBuf8<400> *NULLbuf =NULL;
+
+ // Create a PDU
+
+ RMobilePhone::TMobileAddress addr;
+ addr.iTypeOfNumber=RMobilePhone::EInternationalNumber;
+ addr.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+ addr.iTelNumber.Copy(_L("44 7785 016 005"));
+ buf.Zero();
+ AppendAddressToAscii(buf,addr);
+ iSms.AckSmsStored(status, buf);
+ User::WaitForRequest(status);
+ if(status.Int() == KErrNotSupported)
+ {
+ iSms.AckSmsStored(status, *NULLbuf);
+ User::WaitForRequest(status);
+ TESTL(status.Int() == KErrNotSupported);
+ }
+
+ return TestStepResult();
+ }
+
+CTestAckSmsStoredCancel::CTestAckSmsStoredCancel()
+ {
+ SetTestStepName(_L("TestAckSmsStoredCancel"));
+ }
+
+enum TVerdict CTestAckSmsStoredCancel::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.AckSmsStoredCancel(); // This API doesn't exist anymore
+
+ return EPass;
+ }
+
+CTestNackSmsStored::CTestNackSmsStored()
+ {
+ SetTestStepName(_L("TestNackSmsStored"));
+ }
+
+enum TVerdict CTestNackSmsStored::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+ TRequestStatus status;
+ TBuf8<400> buf;
+
+ // Create a PDU
+
+ RMobilePhone::TMobileAddress addr;
+ addr.iTypeOfNumber=RMobilePhone::EInternationalNumber;
+ addr.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+ addr.iTelNumber.Copy(_L("44 7785 016 005"));
+ buf.Zero();
+ AppendAddressToAscii(buf,addr);
+ iSms.NackSmsStored(status, buf, KErrGsmRRInvalidMessage);
+ User::WaitForRequest(status);
+ TEST(status.Int() == KErrNotSupported);
+
+ return TestStepResult();
+ }
+
+CTestNackSmsStoredCancel::CTestNackSmsStoredCancel()
+ {
+ SetTestStepName(_L("TestNackSmsStoredCancel"));
+ }
+
+enum TVerdict CTestNackSmsStoredCancel::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.NackSmsStoredCancel(); // API doesn't exist anymore
+
+ return EPass;
+ }
+
+CTestAckSmsStoredWithResponse::CTestAckSmsStoredWithResponse()
+ {
+ SetTestStepName(_L("TestAckSmsStoredWithResponse"));
+ }
+
+enum TVerdict CTestAckSmsStoredWithResponse::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.AckSmsStoredWithResponse(); // API doesn't exist anymore
+
+ return EPass;
+ }
+
+CTestAckSmsStoredWithResponseCancel::CTestAckSmsStoredWithResponseCancel()
+ {
+ SetTestStepName(_L("TestAckSmsStoredWithResponseCancel"));
+ }
+
+enum TVerdict CTestAckSmsStoredWithResponseCancel::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.AckSmsStoredWithResponseCancel(); // API doesn't exist anymore
+
+ return EPass;
+ }
+
+CTestNackSmsStoredWithResponse::CTestNackSmsStoredWithResponse()
+ {
+ SetTestStepName(_L("TestNackSmsStoredWithResponse"));
+ }
+
+enum TVerdict CTestNackSmsStoredWithResponse::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.NackSmsStoredWithResponse(); // API doesn't exist anymore
+
+ return EPass;
+ }
+
+CTestNackSmsStoredWithResponseCancel::CTestNackSmsStoredWithResponseCancel()
+ {
+ SetTestStepName(_L("TestNackSmsStoredWithResponseCancel"));
+ }
+
+enum TVerdict CTestNackSmsStoredWithResponseCancel::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.NackSmsStoredWithResponseCancel(); // API doesn't exist anymore
+
+ return EPass;
+ }
+
+CTestResumeSmsReception::CTestResumeSmsReception()
+ {
+ SetTestStepName(_L("TestResumeSmsReception"));
+ }
+
+enum TVerdict CTestResumeSmsReception::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+ TRequestStatus status;
+ iSms.ResumeSmsReception(status);
+ User::WaitForRequest(status);
+ TESTL(status.Int() == KErrNotSupported);
+
+ return TestStepResult();
+ }
+
+CTestNotifySmsEvent::CTestNotifySmsEvent()
+ {
+ SetTestStepName(_L("TestNotifySmsEvent"));
+ }
+
+enum TVerdict CTestNotifySmsEvent::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.NotifySmsEvent(); // API doesn't exist anymore
+
+ return EPass;
+ }
+
+CTestNotifySmsEventCancel::CTestNotifySmsEventCancel()
+ {
+ SetTestStepName(_L("TestNotifySmsEventCancel"));
+ }
+
+enum TVerdict CTestNotifySmsEventCancel::doTestStepL()
+/**
+ * This function Tests an API that should return
+ * KErrNotSupported
+ */
+ {
+// iSms.NotifySmsEventCancel(); // API doesn't exist anymore
+
+ return EPass;
+ }
+
+
+CTestGetCaps::CTestGetCaps()
+ {
+ SetTestStepName(_L("TestGetCaps"));
+ }
+
+enum TVerdict CTestGetCaps::doTestStepL()
+/**
+ * This function tests the capabilities API of the Messaging subssession.
+ */
+ {
+ INFO_PRINTF1(_L("Get Capabilities."));
+ RMobileSmsMessaging::TMobileSmsCapsV1Pckg smsCapsPckg(iSmsCaps);
+ INFO_PRINTF1(_L(".."));
+
+ TESTL(iSms.GetCaps(smsCapsPckg)==KErrNone);
+ INFO_PRINTF1(_L("test(s) passed"));
+
+ return TestStepResult();
+ }
+
+CTestSmspList::CTestSmspList()
+ {
+ SetTestStepName(_L("TestSmspList"));
+ }
+
+enum TVerdict CTestSmspList::doTestStepL()
+/**
+ * This function tests get/set service centre address
+ */
+ {
+ INFO_PRINTF1(_L("Check TSY's SMSP capabilities.."));
+ if ((iSmsCaps.iSmsControl & RMobileSmsMessaging::KCapsGetSmspList) &&
+ (iSmsCaps.iSmsControl & RMobileSmsMessaging::KCapsSetSmspList))
+ {
+ INFO_PRINTF1(_L("Caps - KCapsGetSmspList supported"));
+ INFO_PRINTF1(_L("Caps - KCapsSetSmspList supported"));
+ RMobileSmsMessaging::TMobileSmspEntryV1 defaultSmspEntry;
+ RMobileSmsMessaging::TMobileSmspEntryV1 newSmspEntry;
+ RMobileSmsMessaging::TMobileSmspEntryV1 checkSmspEntry;
+ INFO_PRINTF1(_L("Retrieve default SMSP list"));
+ TRAPD(ret, GetSmspListL(defaultSmspEntry));
+ TESTL(ret == KErrNone);
+ INFO_PRINTF1(_L("Store new SMSP list"));
+ newSmspEntry.iValidParams = RMobileSmsMessaging::KSCAIncluded;
+ newSmspEntry.iServiceCentre.iTypeOfNumber=RMobilePhone::EInternationalNumber;
+ newSmspEntry.iServiceCentre.iNumberPlan=RMobilePhone:: EIsdnNumberPlan;
+ newSmspEntry.iServiceCentre.iTelNumber.Copy(_L("01632960000"));
+ TRAP(ret, SetSmspListL(newSmspEntry));
+ TESTL(ret == KErrNone);
+ INFO_PRINTF1(_L("Check SMSP list contains new entry"));
+ TRAP(ret, GetSmspListL(checkSmspEntry));
+ TESTL(ret == KErrNone);
+ INFO_PRINTF1(_L("Rewrite default SMSP list"));
+ TRAP(ret, SetSmspListL(defaultSmspEntry));
+ TESTL(ret == KErrNone);
+ INFO_PRINTF1(_L("Check SMSP list contains default entry"));
+ TRAP(ret, GetSmspListL(checkSmspEntry));
+ TESTL(ret == KErrNone);
+ }
+
+ return TestStepResult();
+ }
+
+CTestMessageStoreInfo::CTestMessageStoreInfo()
+ {
+ SetTestStepName(_L("TestMessageStoreInfo"));
+ }
+
+enum TVerdict CTestMessageStoreInfo::doTestStepL()
+/**
+ * This function retrieves the number of message stores supported by the iPhone. It
+ * also gets the details of the supported message stores. It then gets and sets the
+ * Default Service Center Address (SCA) and performs some Cancel Requests.
+ */
+ {
+ INFO_PRINTF1(_L("Test RMobileSmsMessaging::EnumerateMessageStores.."));
+ TInt ret=KErrNone;
+ TInt count=0;
+ TInt i;
+ ret=iSms.EnumerateMessageStores(count);
+ TEST_CHECKL(ret, KErrNone, _L("Error retrieving message store count"));
+ INFO_PRINTF2(_L("There are %d SMS message stores"), count);
+ INFO_PRINTF1(_L("Test RMobileSmsMessaging::GetMessageStoreInfo..."));
+ TRequestStatus reqStatus;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 smsInfo;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg smsInfoPckg(smsInfo);
+ for (i=0; i<count; i++)
+ {
+ iSms.GetMessageStoreInfo(reqStatus, i, smsInfoPckg);
+ User::WaitForRequest(reqStatus);
+ TESTL(reqStatus==KErrNone);
+ TEST(smsInfo.iType==RMobilePhoneStore::EShortMessageStore);
+ // Print the result
+ INFO_PRINTF1(_L("Information retrieved about the message store"));
+ INFO_PRINTF2(_L("Name : %S"), &smsInfo.iName);
+ INFO_PRINTF2(_L("Total number of entries : %d"), smsInfo.iTotalEntries);
+ INFO_PRINTF2(_L("Number of used entries : %d"), smsInfo.iUsedEntries);
+ INFO_PRINTF2(_L("Capabilities(in hex) : %X"), smsInfo.iCaps);
+ PrintMessageStoreCaps(smsInfo.iCaps);
+ User::After(10000000); // Give user time to see the test results
+ }
+ // Test immediate cancelling of request
+ if (count>0)
+ {
+ INFO_PRINTF1(_L("Test cancelling of GetMessageStoreInfo request"));
+ iSms.GetMessageStoreInfo(reqStatus, 0, smsInfoPckg);
+ iSms.CancelAsyncRequest(EMobileSmsMessagingGetMessageStoreInfo);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else if (reqStatus==KErrNone)
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+ else
+ {
+ INFO_PRINTF2(_L("Request failed with: %d"), reqStatus.Int());
+ SetTestStepResult(EFail);
+ }
+ }
+
+ // Test delayed cancelling of request
+ if (count>1)
+ {
+ INFO_PRINTF1(_L("Test cancelling of GetMessageStoreInfo request..."));
+ iSms.GetMessageStoreInfo(reqStatus, 1, smsInfoPckg);
+ // User::After(500000);
+ iSms.CancelAsyncRequest(EMobileSmsMessagingGetMessageStoreInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrCancel || reqStatus==KErrNone);
+ if (reqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+ }
+
+ return TestStepResult();
+ }
+
+CTestMessageStoreOps::CTestMessageStoreOps()
+ {
+ SetTestStepName(_L("TestMessageStoreOps"));
+ }
+
+enum TVerdict CTestMessageStoreOps::doTestStepL()
+/**
+ * This function performs Message Store Operations.
+ * It opens the SIM and ME Stores, writes & reads sms' to these stores, performs
+ * appropriate Cancel operations and gets information on the SIM and ME stores.
+ */
+ {
+ // Test open message store and get info
+ RMobileSmsStore simStore;
+ // Nokia 9210 doesn't support ME SMS storage.
+ // This flag is used to skip the related tests.
+ TBool meSupported;
+ TInt ret=simStore.Open(iSms, KETelIccSmsStore);
+ TESTL(ret==KErrNone);
+ CleanupClosePushL(simStore);
+ INFO_PRINTF1(_L("SIM message store opened..."));
+ TRequestStatus reqStatus;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 simSmsInfo;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg simSmsInfoPckg(simSmsInfo);
+ INFO_PRINTF1(_L("Retrieving SIM message store info..."));
+ simStore.GetInfo(reqStatus, simSmsInfoPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrNone);
+ if (reqStatus!=KErrNone)
+ INFO_PRINTF2(_L("Error %d retrieving SIM message store info"), ret);
+ else
+ {
+ TEST(simSmsInfo.iType==RMobilePhoneStore::EShortMessageStore);
+ // Print the result
+ INFO_PRINTF1(_L("Information retrieved about the message store"));
+ INFO_PRINTF2(_L("Name : %S"), &simSmsInfo.iName);
+ INFO_PRINTF2(_L("Total number of entries : %d"), simSmsInfo.iTotalEntries);
+ INFO_PRINTF2(_L("Number of used entries : %d"), simSmsInfo.iUsedEntries);
+ INFO_PRINTF2(_L("Capabilities(in hex) : %X"), simSmsInfo.iCaps);
+ PrintMessageStoreCaps(simSmsInfo.iCaps);
+ User::After(10000000); // Give user time to see the test results
+ }
+ // Test immediate cancelling of request
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 simSmsInfo2;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg simSmsInfoPckg2(simSmsInfo2);
+ INFO_PRINTF1(_L("Test immediate cancelling of GetInfo request..."));
+ simStore.GetInfo(reqStatus, simSmsInfoPckg2);
+ simStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrCancel || reqStatus==KErrNone);
+ if (reqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+ // Test delayed cancelling of request
+ INFO_PRINTF1(_L("Test delayed cancelling of GetInfo request"));
+ simStore.GetInfo(reqStatus, simSmsInfoPckg2);
+ User::After(500000);
+ simStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrCancel || reqStatus==KErrNone);
+ if (reqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+ // Test the same information retrieval for ME SMS store
+ RMobileSmsStore meStore;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 meSmsInfo;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg meSmsInfoPckg(meSmsInfo);
+ ret=meStore.Open(iSms, KETelMeSmsStore);
+ TESTL(ret==KErrNone);
+ CleanupClosePushL(meStore);
+ INFO_PRINTF1(_L("ME message store opened."));
+ INFO_PRINTF1(_L("Retrieving ME message store info..."));
+ meStore.GetInfo(reqStatus, meSmsInfoPckg);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus!=KErrNone)
+ {
+ INFO_PRINTF2(_L("Error %d retrieving ME message store info."), reqStatus.Int());
+ INFO_PRINTF1(_L("*** Please retry test with another phone ***"));
+ meSupported=FALSE;
+ if(TestStepResult() == EPass)
+ SetTestStepResult(EInconclusive);
+ }
+ else
+ {
+ TEST(meSmsInfo.iType==RMobilePhoneStore::EShortMessageStore);
+ // Print the result
+ INFO_PRINTF1(_L("Information retrieved about the message store"));
+ INFO_PRINTF2(_L("Name : %S"), &meSmsInfo.iName);
+ INFO_PRINTF2(_L("Total number of entries : %d"), meSmsInfo.iTotalEntries);
+ INFO_PRINTF2(_L("Number of used entries : %d"), meSmsInfo.iUsedEntries);
+ INFO_PRINTF2(_L("Capabilities(in hex) : %X"), meSmsInfo.iCaps);
+ PrintMessageStoreCaps(meSmsInfo.iCaps);
+ User::After(10000000); // Give user time to see the test results
+ meSupported=TRUE;
+ }
+
+ // Test immediate cancelling of request
+ if (meSupported==TRUE)
+ {
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 meSmsInfo2;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg meSmsInfoPckg2(meSmsInfo2);
+ INFO_PRINTF1(_L("Test immediate cancelling of GetInfo request..."));
+ meStore.GetInfo(reqStatus, meSmsInfoPckg2);
+ meStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrCancel || reqStatus==KErrNone);
+ if (reqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+
+ // Test delayed cancelling of request
+ INFO_PRINTF1(_L("Test delayed cancelling of GetInfo request"));
+ meStore.GetInfo(reqStatus, meSmsInfoPckg2);
+ User::After(500000);
+ meStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrCancel || reqStatus==KErrNone);
+ if (reqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+ }
+
+ // Test reading all the messages in SIM store
+ // Print details of each message
+ INFO_PRINTF1(_L("Reading Messages from SIM Store..."));
+ RMobileSmsStore::TMobileGsmSmsEntryV1 smsEntry;
+ RMobileSmsStore::TMobileGsmSmsEntryV1Pckg smsEntryPckg(smsEntry);
+ for (TInt i=1; i<=simSmsInfo.iUsedEntries; i++)
+ {
+ smsEntry.iIndex=i; // Entry to read
+ simStore.Read(reqStatus, smsEntryPckg);
+ User::WaitForRequest(reqStatus);
+ TESTL(reqStatus==KErrNone || reqStatus==KErrNotFound);
+ if (reqStatus == KErrNotFound)
+ INFO_PRINTF2((_L("The entry was not found, request status = %d")), reqStatus.Int());
+ else
+ {
+ INFO_PRINTF2(_L("Entry %d: Successfully read"),smsEntry.iIndex);
+ INFO_PRINTF2(_L("Status of entry = %d"),smsEntry.iMsgStatus);
+ INFO_PRINTF2(_L("Length of PDU in octets = %d"),smsEntry.iMsgData.Size());
+ }
+ }
+ // Test reading and cancelling
+ INFO_PRINTF1(_L("Test Cancel Read from SIM Store"));
+ TRequestStatus cancelReqStatus;
+ smsEntry.iIndex=simSmsInfo.iUsedEntries;
+ simStore.Read(cancelReqStatus, smsEntryPckg);
+ simStore.CancelAsyncRequest(EMobilePhoneStoreRead);
+ User::WaitForRequest(cancelReqStatus);
+ TEST(cancelReqStatus==KErrCancel || reqStatus==KErrNone || reqStatus==KErrNotFound);
+ if (cancelReqStatus==KErrCancel)
+ {
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Request completed with %d before it could be cancelled"), reqStatus.Int());
+ }
+ // Test writing a dummy PDU to SIM store
+ // And then test reading it out and comparing it
+ INFO_PRINTF1(_L("Test Write to SIM Store"));
+ const TText8 MyPdu[] = {0x1d,0x00,0x0c,0x91,0x44,0x77,0x74,0x60,0x45,0x95,0x00,0x00,0x50,0x80,0x80,0x31,0x92,0x80,0x00,0x04,0xf4,0xf2,0x9c,0x0e};
+ smsEntry.iMsgStatus=RMobileSmsStore::EStoredMessageUnsent;
+ smsEntry.iMsgData.Copy(MyPdu, sizeof(MyPdu));
+ simStore.Write(reqStatus, smsEntryPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrNone);
+ if (reqStatus==KErrNone)
+ {
+ INFO_PRINTF2(_L("Write request successfully completed to index %d"), smsEntry.iIndex);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Error %d writing message to SIM store"), reqStatus.Int());
+ }
+ if (reqStatus==KErrNone)
+ {
+ INFO_PRINTF1(_L("Test Read of entry just written to SIM Store"));
+ RMobileSmsStore::TMobileGsmSmsEntryV1 smsReadEntry;
+ RMobileSmsStore::TMobileGsmSmsEntryV1Pckg smsReadEntryPckg(smsReadEntry);
+ smsReadEntry.iIndex=smsEntry.iIndex;
+ simStore.Read(reqStatus, smsReadEntryPckg);
+ User::WaitForRequest(reqStatus);
+ TESTL(reqStatus==KErrNone);
+ if (reqStatus != KErrNone)
+ {
+ INFO_PRINTF2((_L("The entry was not found, request status = %d")), reqStatus.Int());
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Entry %d: Successfully read"),smsReadEntry.iIndex);
+ INFO_PRINTF2(_L("Status of entry = %d"),smsReadEntry.iMsgStatus);
+ INFO_PRINTF2(_L("Length of PDU in octets = %d"),smsReadEntry.iMsgData.Size());
+ if (smsReadEntry.iMsgData.Compare(smsEntry.iMsgData)==0)
+ {
+ INFO_PRINTF1(_L("Read entry successfully compared with Write entry"));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("*** Read entry NOT matched with Write entry! ***"));
+ INFO_PRINTF1(_L("*** This test is known to fail with Ericsson phones ***"));
+ INFO_PRINTF1(_L("*** Please retry test with a different make of phone ***"));
+
+ if(TestStepResult() == EPass)
+ SetTestStepResult(EInconclusive);
+ }
+ }
+ }
+ // Test writing and cancelling to ME store first
+ if (meSupported==TRUE)
+ {
+ INFO_PRINTF1(_L("Test Cancel Write to ME Store"));
+ meStore.Write(cancelReqStatus, smsEntryPckg);
+ meStore.CancelAsyncRequest(EMobilePhoneStoreWrite);
+ User::WaitForRequest(cancelReqStatus);
+ TEST(cancelReqStatus==KErrCancel || reqStatus==KErrNone);
+ if (cancelReqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+
+ // Test writing the same PDU to ME store
+ // And then test reading it out and comparing it again
+ INFO_PRINTF1(_L("Test Write to ME Store"));
+
+ meStore.Write(reqStatus, smsEntryPckg);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus==KErrNone)
+ {
+ INFO_PRINTF2(_L("Write request successfully completed to index %d"), smsEntry.iIndex);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Error %d writing message to ME store"), reqStatus.Int());
+ INFO_PRINTF1(_L("*** Please try running this test with another phone.***"));
+ if(TestStepResult() == EPass)
+ {
+ SetTestStepResult(EInconclusive);
+ }
+ }
+ if (reqStatus==KErrNone)
+ {
+ INFO_PRINTF1(_L("Test Read of entry just written to ME Store"));
+ RMobileSmsStore::TMobileGsmSmsEntryV1 smsReadEntry2;
+ RMobileSmsStore::TMobileGsmSmsEntryV1Pckg smsReadEntryPckg2(smsReadEntry2);
+ smsReadEntry2.iIndex=smsEntry.iIndex;
+ meStore.Read(reqStatus, smsReadEntryPckg2);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus != KErrNone)
+ {
+ INFO_PRINTF2((_L("The entry was not found, request status = %d")), reqStatus.Int());
+ SetTestStepResult(EFail);
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Entry %d: Successfully read"),smsReadEntry2.iIndex);
+ INFO_PRINTF2(_L("Status of entry = %d"),smsReadEntry2.iMsgStatus);
+ INFO_PRINTF2(_L("Length of PDU in octets = %d"),smsReadEntry2.iMsgData.Size());
+ if (smsReadEntry2.iMsgData.Compare(smsEntry.iMsgData)==0)
+ {
+ INFO_PRINTF1(_L("Read entry successfully compared with Write entry"));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("*** Read entry NOT matched with Write entry! ***"));
+ INFO_PRINTF1(_L("*** This test is known to fail with Ericsson phones ***"));
+ INFO_PRINTF1(_L("*** Please retry test with a different make of phone ***"));
+
+ if(TestStepResult() == EPass)
+ SetTestStepResult(EInconclusive);
+ }
+ }
+ }
+ }
+ // Now test deletion of entries - test deletion of last entry
+ // Get info again in order to get up-to-date number of used entries
+ simStore.GetInfo(reqStatus, simSmsInfoPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrNone);
+ if (simSmsInfo.iUsedEntries > 0)
+ {
+ simStore.Delete(reqStatus, simSmsInfo.iUsedEntries);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus == KErrNotFound)
+ {
+ INFO_PRINTF2((_L("The entry was not found, request status = %d")), reqStatus.Int());
+ SetTestStepResult(EFail);
+ }
+ else
+ INFO_PRINTF2(_L("Entry %d: Successfully deleted"),simSmsInfo.iUsedEntries);
+ }
+ if (meSupported==TRUE)
+ {
+ meStore.GetInfo(reqStatus, meSmsInfoPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus==KErrNone);
+ if(reqStatus==KErrNone)
+ {
+ if (meSmsInfo.iUsedEntries > 0)
+ {
+ meStore.Delete(reqStatus, meSmsInfo.iUsedEntries);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus == KErrNotFound)
+ {
+ INFO_PRINTF2((_L("The entry was not found, request status = %d")), reqStatus.Int());
+ SetTestStepResult(EFail);
+ }
+ else
+ INFO_PRINTF2(_L("Entry %d: Successfully deleted"),meSmsInfo.iUsedEntries);
+ }
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Failed to get ME store info"));
+ SetTestStepResult(EFail);
+ }
+ }
+
+ // Test deleting and cancelling
+ INFO_PRINTF1(_L("Test Cancel Delete from SIM Store"));
+
+ // Write an entry to be deleted first
+ simStore.Write(reqStatus, smsEntryPckg);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus==KErrNone)
+ {
+ simStore.Delete(cancelReqStatus,smsEntry.iIndex);
+ simStore.CancelAsyncRequest(EMobilePhoneStoreDelete);
+ User::WaitForRequest(cancelReqStatus);
+ if (cancelReqStatus==KErrCancel)
+ INFO_PRINTF1(_L("Request successfully cancelled"));
+ else if (cancelReqStatus==KErrNone)
+ INFO_PRINTF1(_L("Request completed before it could be cancelled"));
+ else
+ {
+ INFO_PRINTF2(_L("Request failed with: %d"), reqStatus.Int());
+ SetTestStepResult(EFail);
+ }
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Error %d writing message to SIM store"), reqStatus.Int());
+ SetTestStepResult(EFail);
+ }
+
+ CleanupStack::PopAndDestroy(&meStore);
+ CleanupStack::PopAndDestroy(&simStore);
+
+ return TestStepResult();
+ }
+
+CTestReceiveUnstoredSms::CTestReceiveUnstoredSms()
+ {
+ SetTestStepName(_L("TestReceiveUnstoredSms"));
+ }
+
+enum TVerdict CTestReceiveUnstoredSms::doTestStepL()
+/**
+ * Receive an unstored Sms test.
+ * Currently the MMTSY does not support receive unstored mode, so that is what this test
+ * tests for.
+ */
+ {
+ TRequestStatus status;
+ INFO_PRINTF1(_L("Setting receive mode to EReceiveUnstoredPhoneAck."));
+ User::After(2000000); // Gives a bit of time
+ iSms.SetReceiveMode(status, RMobileSmsMessaging::EReceiveUnstoredPhoneAck);
+ User::WaitForRequest(status);
+ //
+ // Only continue if we successfully set the SMS receive mode
+ TESTL(status == KErrNotSupported || status == KErrNone);
+ if(status==KErrNone)
+ {
+ INFO_PRINTF1(_L("Verifying that receive mode has changed ..."));
+ RMobileSmsMessaging::TMobileSmsReceiveMode mode;
+ TInt ret=iSms.GetReceiveMode(mode);
+// TESTL(ret!=KErrNone || mode!=RMobileSmsMessaging::EReceiveUnstoredPhoneAck);
+ TESTL(ret==KErrNone && mode ==RMobileSmsMessaging::EReceiveUnstoredPhoneAck);
+ INFO_PRINTF1(_L("Calling Receive API ..."));
+ RMobileSmsMessaging::TMobileSmsGsmTpdu gsmMsg;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 recAtt;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg recAttPckg(recAtt);
+ iSms.ReceiveMessage(status, gsmMsg, recAttPckg);
+ INFO_PRINTF1(_L("Sending out a SMS ..."));
+ TRAP(ret, SendSms(ETrue));
+ TESTL(ret == KErrNone);
+ // Wait for the sent SMS to return to this phone with a timout of 30 s
+ WaitWithTimeout(status,30*KOneSecond);
+ TESTL(status.Int() == KErrNone);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("*** Receive unstored mode not supported by this phone *** "));
+ INFO_PRINTF1(_L("*** Please retry test with another phone! *** "));
+
+ if(TestStepResult()==EPass)
+ SetTestStepResult(EInconclusive);
+ }
+
+ return TestStepResult();
+ }
+
+CTestReceiveStoredSms::CTestReceiveStoredSms()
+ {
+ SetTestStepName(_L("TestReceiveStoredSms"));
+ }
+
+enum TVerdict CTestReceiveStoredSms::doTestStepL()
+/**
+ * Receive a stored Sms test.
+ * Currently the MMTSY does not support receive unstored mode, so that is what this test
+ * tests for.
+ */
+ {
+ TRequestStatus status;
+ INFO_PRINTF1(_L("Setting receive mode to EReceiveStored."));
+ User::After(2000000); // Gives a bit of time
+ iSms.SetReceiveMode(status, RMobileSmsMessaging::EReceiveStored);
+ User::WaitForRequest(status);
+ if(status==KErrNone)
+ {
+ INFO_PRINTF1(_L("Verifying that receive mode has changed ..."));
+ RMobileSmsMessaging::TMobileSmsReceiveMode mode;
+ TInt ret=iSms.GetReceiveMode(mode);
+ TESTL(ret == KErrNone && mode == RMobileSmsMessaging::EReceiveStored);
+ INFO_PRINTF1(_L("Calling Receive API ..."));
+ RMobileSmsMessaging::TMobileSmsGsmTpdu gsmMsg;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 recAtt;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg recAttPckg(recAtt);
+ iSms.ReceiveMessage(status, gsmMsg, recAttPckg);
+ INFO_PRINTF1(_L("Sending out a SMS ..."));
+ TRAP(ret, SendSms(ETrue));
+ TESTL(ret == KErrNone);
+ // Wait for the sent SMS to return to this phone with a timout of 30 s
+ WaitWithTimeout(status,30*KOneSecond);
+ TESTL(status.Int() == KErrNone);
+ }
+ else
+ {
+ return EFail;
+ }
+
+ return TestStepResult();
+ }
+
+CTestReceiveStoredSmsAndCancel::CTestReceiveStoredSmsAndCancel()
+ {
+ SetTestStepName(_L("TestReceiveStoredSmsAndCancel"));
+ }
+
+enum TVerdict CTestReceiveStoredSmsAndCancel::doTestStepL()
+ {
+ TRequestStatus status;
+ INFO_PRINTF1(_L("Setting receive mode to EReceiveStored."));
+ User::After(2000000); // Gives a bit of time
+ iSms.SetReceiveMode(status, RMobileSmsMessaging::EReceiveStored);
+ User::WaitForRequest(status);
+ if(status==KErrNone)
+ {
+ INFO_PRINTF1(_L("Verifying that receive mode has changed ..."));
+ RMobileSmsMessaging::TMobileSmsReceiveMode mode;
+ TInt ret=iSms.GetReceiveMode(mode);
+ TESTL(ret==KErrNone && mode==RMobileSmsMessaging::EReceiveStored);
+ INFO_PRINTF1(_L("Calling Receive API ..."));
+ RMobileSmsMessaging::TMobileSmsGsmTpdu gsmMsg;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 recAtt;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg recAttPckg(recAtt);
+ iSms.ReceiveMessage(status, gsmMsg, recAttPckg);
+ INFO_PRINTF1(_L("Sending out a SMS ..."));
+ TRAP(ret, SendSms(ETrue));
+ TESTL(ret == KErrNone);
+ iSms.CancelAsyncRequest(EMobileSmsMessagingReceiveMessage); // Cancels ...
+ // Wait for the sent SMS to return to this phone with a timout of 30 s
+ WaitWithTimeout(status,30*KOneSecond);
+ TESTL((status.Int() == KErrCancel) || (status.Int() == KErrNone)) ;
+ }
+ else
+ {
+ return EFail;
+ }
+
+ return TestStepResult();
+ }
+
+CTestSendSmsAndCancel::CTestSendSmsAndCancel()
+ {
+ SetTestStepName(_L("TestSendSmsAndCancel"));
+ }
+
+enum TVerdict CTestSendSmsAndCancel::doTestStepL()
+ {
+ TInt i;
+ INFO_PRINTF1(_L("Sending SMS and cancelling."));
+ // Create message PDU and convert to binary
+ _LIT8(KMsgDataBeforeTargetAddress,"1d00");
+
+ // This data is taken from CSmsTestStep::SendSms, since this
+ // method should be attempting the same send functionality.
+ _LIT8(KMsgDataAfterTargetAddress,"00005080803192800004f4f29c0e");
+
+ TBuf8<400> msgData;
+ TLex8 lex;
+ TUint8 val;
+ msgData.Zero();
+ const TInt count_before((&KMsgDataBeforeTargetAddress)->Length()/2); // Assume length of pdu is always even
+ for(i=0;i<count_before;++i)
+ {
+ lex=(&KMsgDataBeforeTargetAddress)->Mid(i*2,2);
+ LEAVE_IF_ERROR(lex.Val(val,EHex));
+ msgData.Append(TChar(val));
+ }
+ TBuf8<20> targetAddressAscii;
+ targetAddressAscii.Zero();
+ RMobilePhone::TMobileAddress targetAddress;
+ targetAddress.iTypeOfNumber=RMobilePhone::EInternationalNumber;
+ targetAddress.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+ targetAddress.iTelNumber.Copy(iTelNumber);
+ TInt ret = AppendAddressToAscii(targetAddressAscii,targetAddress);
+ TESTL(ret == KErrNone);
+ const TInt count_address(targetAddressAscii.Length()/2); // Assume length is always even
+ for(i=0;i<count_address;++i)
+ {
+ lex=targetAddressAscii.Mid(i*2,2);
+ lex.Val(val,EHex);
+ msgData.Append(TChar(val));
+ }
+ const TInt count_after((&KMsgDataAfterTargetAddress)->Length()/2); // Assume length of pdu is always even
+ for(i=0;i<count_after;++i)
+ {
+ lex=(&KMsgDataAfterTargetAddress)->Mid(i*2,2);
+ lex.Val(val,EHex);
+ msgData.Append(TChar(val));
+ }
+ // Create message attibutes
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 msgAttr;
+ msgAttr.iFlags=RMobileSmsMessaging::KSmsDataFormat | RMobileSmsMessaging::KGsmServiceCentre;
+ msgAttr.iDataFormat=RMobileSmsMessaging::EFormatGsmTpdu;
+ msgAttr.iGsmServiceCentre.iTypeOfNumber=RMobilePhone::EInternationalNumber;
+ msgAttr.iGsmServiceCentre.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+ msgAttr.iGsmServiceCentre.iTelNumber.Copy(iSCANumber);
+ // Package up data ready for sending to etel
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg msgAttrPkg(msgAttr);
+ // Send the message
+ INFO_PRINTF1(_L(".."));
+ iSms.SendMessage(iStatus,msgData,msgAttrPkg);
+ // Wait for a bit
+ User::After(1000000);
+ // Cancel sending, then wait for sending operation to complete
+ iSms.CancelAsyncRequest(EMobileSmsMessagingSendMessage);
+ User::WaitForRequest(iStatus);
+ INFO_PRINTF2(_L("Status = %d"),iStatus.Int());
+ TESTL(iStatus==KErrCancel || iStatus==KErrNone);
+ INFO_PRINTF1(_L("test(s) passed")); // If we don't cause a panic or leave the test has passed
+
+ return TestStepResult();
+ }