--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/component/src/cctsysmsmessagingfu.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,4846 @@
+// Copyright (c) 2007-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:
+// The TEFUnit test suite for SmsMessaging in the Common TSY.
+//
+//
+
+/**
+ @file
+*/
+
+#include "cctsysmsmessagingfu.h"
+#include <etel.h>
+#include <etelmm.h>
+#include <et_clsvr.h>
+#include <ctsy/mmtsy_names.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include "tmockltsydata.h"
+#include <ctsy/serviceapi/gsmerror.h>
+
+CTestSuite* CCTsySmsMessagingFU::CreateSuiteL(const TDesC& aName)
+ {
+ SUB_SUITE;
+
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyMoSmsBearerChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMoSmsBearer0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetReceiveMode0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0001AL);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestEnumerateMessageStores0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetCaps0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetCaps0003L);
+
+
+ END_SUITE;
+ }
+
+
+//
+// Actual test cases
+//
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNMSBC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NotifyMoSmsBearerChange
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::NotifyMoSmsBearerChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNotifyMoSmsBearerChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging::TMobileSmsBearer smsBearer;
+ TRequestStatus reqStatus;
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ messaging.NotifyMoSmsBearerChange(reqStatus, smsBearer);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNRMC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NotifyReceiveModeChange
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::NotifyReceiveModeChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;
+ RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);
+ TRequestStatus reqStatus;
+ TRequestStatus reqSetStatus;
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::NotifyReceiveModeChange
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);
+
+ User::WaitForRequest(reqSetStatus);
+ ASSERT_EQUALS(KErrNone, reqSetStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::NotifyReceiveModeChange when result is not cached.
+ //-------------------------------------------------------------------------
+
+ messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);
+
+ messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);
+
+ User::WaitForRequest(reqSetStatus);
+ ASSERT_EQUALS(KErrNone, reqSetStatus.Int());
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode);
+
+
+ //-------------------------------------------------------------------------
+ // TEST E2: Unsolicited completion of RMobileSmsMessaging::NotifyReceiveModeChange
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 360201);
+ ASSERT_TRUE(EFalse);
+
+ //Request for EMobileSmsMessagingNotifyReceiveModeChange is self reposting.
+ //If it was completed somehow and then SetReceiveMode() was called without call of NotifyReceiveModeChange() -
+ //this result in getting wrong request handle for completion in CTelObject::ReqCompleted()
+ //{updatedReqEntry=PhoneOwner()->FindByTsyHandleAndPlacedRequest(aTsyReqHandle);
+ //__ASSERT_ALWAYS(updatedReqEntry!=NULL, Fault(EEtelFaultCompletionReceivedWithNoReqPackage));}
+
+ messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);
+
+ User::WaitForRequest(reqSetStatus);
+ ASSERT_EQUALS(KErrNone, reqSetStatus.Int());
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNRMC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::NotifyReceiveModeChange
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::NotifyReceiveModeChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;
+ RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);
+ TRequestStatus reqStatus;
+ TRequestStatus reqSetStatus;
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::NotifyReceiveModeChange
+ //-------------------------------------------------------------------------
+
+ messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingNotifyReceiveModeChange);
+
+ messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);
+
+ User::WaitForRequest(reqSetStatus);
+ ASSERT_EQUALS(KErrNone, reqSetStatus.Int());
+
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+ CleanupStack::PopAndDestroy(2);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNRMC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::NotifyReceiveModeChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::NotifyReceiveModeChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;
+ RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);
+ TRequestStatus reqStatus;
+ TRequestStatus reqSetStatus;
+
+ RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode2;
+ TRequestStatus reqStatus2;
+ TRequestStatus reqSetStatus2;
+
+ messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);
+ messaging2.NotifyReceiveModeChange(reqStatus2, smsReceiveMode2);
+
+ messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);
+
+ User::WaitForRequest(reqSetStatus);
+ ASSERT_EQUALS(KErrNone, reqSetStatus.Int());
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+
+ ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode);
+ ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode2);
+
+
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSM-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessage
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SendMessage
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessage0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ _LIT8(KMessage, "Merry christmas");
+ TBuf8<32> tmpName(KMessage);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 expectSmsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessage;
+ dataAndAttr.iAttributes = &expectSmsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data, KErrNotSupported);
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B1: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ const TInt16 KMsgRef(25);
+ TInt16 msgRef(KMsgRef);
+ TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);
+
+ TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ // complete request by error passing to HandleRequest() in ResendSms()
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data, KErrNotSupported);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B2: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ // the API makes 3 attemps to make the EMobileSmsMessagingSendMessage request
+ // we complete all of them with KErrGeneral
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::SendMessage when result is not cached.
+ //-------------------------------------------------------------------------
+
+ _LIT8(KSubmit, "Submit");
+ _LIT(KNum, "+441632960000");
+
+ smsAttr.iGsmServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iGsmServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iGsmServiceCentre.iTelNumber.Copy(KNum);
+ smsAttr.iCdmaServiceCategory = 0;
+ smsAttr.iCdmaTeleservice = 0;
+ smsAttr.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;
+ smsAttr.iFlags = 0;
+ smsAttr.iMsgRef = 0;
+ smsAttr.iSubmitReport = KSubmit;
+ smsAttr.iMore = EFalse;
+ smsAttr.iDestination.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iDestination.iTelNumber.Copy(KNum);
+
+ expectSmsAttr = smsAttr;
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);
+
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iGsmServiceCentre.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iGsmServiceCentre.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iGsmServiceCentre.iTelNumber.Compare(KNum));
+ ASSERT_EQUALS(0, smsAttr.iCdmaServiceCategory);
+ ASSERT_EQUALS(0, smsAttr.iCdmaTeleservice);
+ ASSERT_EQUALS(RMobileSmsMessaging::EFormatGsmTpdu, smsAttr.iDataFormat);
+ ASSERT_TRUE((RMobileSmsMessaging::KMessageReference | RMobileSmsMessaging::KGsmSubmitReport)
+ == smsAttr.iFlags);
+ ASSERT_TRUE(msgRef == smsAttr.iMsgRef);
+ ASSERT_EQUALS(0, smsAttr.iSubmitReport.Compare(smsMsg));
+ ASSERT_TRUE(EFalse == smsAttr.iMore);
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iDestination.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iDestination.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iDestination.iTelNumber.Compare(KNum));
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C2: Successful completion request of
+ // RMobileSmsMessaging::SendMessage when result is not cached.
+ //-------------------------------------------------------------------------
+
+ smsAttr.iGsmServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iGsmServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iGsmServiceCentre.iTelNumber.Copy(KNum);
+ smsAttr.iCdmaServiceCategory = 0;
+ smsAttr.iCdmaTeleservice = 0;
+ smsAttr.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;
+ smsAttr.iFlags = 0;
+ smsAttr.iMsgRef = 0;
+ smsAttr.iSubmitReport = KSubmit;
+ smsAttr.iMore = EFalse;
+ smsAttr.iDestination.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iDestination.iTelNumber.Copy(KNum);
+
+ expectSmsAttr = smsAttr;
+
+ tmpName.SetLength(0);
+ smsMsg.SetLength(0);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);
+
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iGsmServiceCentre.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iGsmServiceCentre.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iGsmServiceCentre.iTelNumber.Compare(KNum));
+ ASSERT_EQUALS(0, smsAttr.iCdmaServiceCategory);
+ ASSERT_EQUALS(0, smsAttr.iCdmaTeleservice);
+ ASSERT_EQUALS(RMobileSmsMessaging::EFormatGsmTpdu, smsAttr.iDataFormat);
+ ASSERT_TRUE(RMobileSmsMessaging::KMessageReference == smsAttr.iFlags);
+ ASSERT_TRUE(KMsgRef == smsAttr.iMsgRef);
+ ASSERT_EQUALS(0, smsAttr.iSubmitReport.Compare(KSubmit));
+ ASSERT_TRUE(EFalse == smsAttr.iMore);
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iDestination.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iDestination.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iDestination.iTelNumber.Compare(KNum));
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::SendMessage
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSM-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::SendMessage
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::SendMessage
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessage0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT8(KMessage, "Merry christmas");
+ TBuf8<32> tmpName(KMessage);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessage;
+ dataAndAttr.iAttributes = &smsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+ expTsyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::SendMessage
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ const TInt16 KMsgRef(25);
+ TInt16 msgRef(KMsgRef);
+ TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);
+ TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);
+
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingSendMessage);
+
+ User::WaitForRequest(reqStatus);
+ // cancel does not work for SendMessage(), this is correct
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSM-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessage with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SendMessage with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessage0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ TBuf8<1> tmpName;
+ TInt smsAttr(1);
+ TPckg<TInt8> badSmsAttrPckg(smsAttr);
+
+ messaging.SendMessage(reqStatus, tmpName, badSmsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2); // messaging, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSM-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::SendMessage
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::SendMessage
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessage0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ _LIT8(KMessage, "Merry christmas");
+ _LIT8(KMessage2, "Merry christmas2");
+ TBuf8<32> tmpName(KMessage);
+ TBuf8<32> tmpName2(KMessage2);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TRequestStatus reqStatus2;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr2;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg2(smsAttr2);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessage;
+ dataAndAttr.iAttributes = &smsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+ expTsyData.SerialiseL(data);
+
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ const TInt16 KMsgRef(25);
+ TInt16 msgRef(KMsgRef);
+ TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);
+ TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data);
+
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ messaging2.SendMessage(reqStatus2, tmpName2, smsAttrPckg2);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(7);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSM-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessage with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SendMessage and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessage0005L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT8(KMessage, "Merry christmas");
+ TBuf8<32> tmpName(KMessage);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessage;
+ dataAndAttr.iAttributes = &smsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);
+
+ messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SASS-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::AckSmsStored
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::AckSmsStored
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestAckSmsStored0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+
+ _LIT8(KMessage, "Happy New Year");
+
+ TRequestStatus reqStatus;
+ TRequestStatus mockLtsyStatus;
+
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+
+ TMockLtsyData1<TDesC8*> expTsyData(msgPtr);
+
+ TDesC8* zeroPtr(NULL);
+ TMockLtsyData1<TDesC8*> expZeroTsyData(zeroPtr);
+
+ //-------------------------------------------------------------------------
+ // TEST A1: check AckSmsStored() when acknoledgement is not expected
+ //-------------------------------------------------------------------------
+
+ expTsyData.SerialiseL(data);
+
+ messaging.AckSmsStored(reqStatus, KMessage, ETrue);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotReady, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST A2: unsuccessful acknoledgement request to the network
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data, KErrGeneral);
+
+ messaging.AckSmsStored(reqStatus, KMessage, EFalse);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST A3: unsuccessful acknoledgement completion
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrGeneral);
+
+ messaging.AckSmsStored(reqStatus, KMessage, EFalse);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST B1, test AckSmsStored() when there are sms received
+ // that have iDeleteAfterClientAck = true
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);
+
+ messaging.AckSmsStored(reqStatus, KMessage, EFalse);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST B2, check AckSmsStored() when there are sms received
+ // but they have iDeleteAfterClientAck = false
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = EFalse;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);
+
+ messaging.AckSmsStored(reqStatus, KMessage, EFalse);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::AckSmsStored
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data, messaging, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SASS-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::AckSmsStored
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::AckSmsStored
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestAckSmsStored0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ _LIT8(KMessage, "Happy New Year");
+
+ // make the server expect an acknowledgement
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ TRequestStatus reqStatus;
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+
+ TMockLtsyData1<TDesC8*> expTsyData(msgPtr);
+
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);
+
+ messaging.AckSmsStored(reqStatus, KMessage, ETrue);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingAckSmsStored);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SASS-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::AckSmsStored
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::AckSmsStored
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestAckSmsStored0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+
+ _LIT8(KMessage, "Happy New Year");
+ _LIT8(KMessage2, "Happy New Year2");
+
+ // make the server expect an acknowledgement
+
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+
+ TMockLtsyData1<TDesC8*> expTsyData(msgPtr);
+
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone, 10);
+
+ messaging.AckSmsStored(reqStatus, KMessage, ETrue);
+
+ messaging2.AckSmsStored(reqStatus2, KMessage2, ETrue);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SASS-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::AckSmsStored with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::AckSmsStored and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestAckSmsStored0005L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+
+ _LIT8(KMessage, "Happy New Year");
+
+ // make the server expect an acknowledgement
+
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ TRequestStatus reqStatus;
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+
+ TMockLtsyData1<TDesC8*> expTsyData(msgPtr);
+
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+
+ messaging.AckSmsStored(reqStatus, KMessage, ETrue);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNSS-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NackSmsStored
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::NackSmsStored
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNackSmsStored0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+
+ _LIT8(KMessage, "Happy New Year");
+
+ TRequestStatus reqStatus;
+ TRequestStatus mockLtsyStatus;
+
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+ TInt rpCause(0);
+ TMockLtsyData2<TDesC8*, TInt> expTsyData(msgPtr, rpCause);
+
+
+ //-------------------------------------------------------------------------
+ // TEST A1: check NackSmsStored() when acknoledgement is not expected
+ //-------------------------------------------------------------------------
+
+ expTsyData.SerialiseL(data);
+
+ messaging.NackSmsStored(reqStatus, KMessage, rpCause);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotReady, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST A2: unsuccessful completion
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingNackSmsStored, KErrGeneral);
+
+ messaging.NackSmsStored(reqStatus, KMessage, rpCause);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST B1, test NackSmsStored() when there are sms received
+ // that have iDeleteAfterClientAck = true
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingNackSmsStored, KErrNone);
+
+ messaging.NackSmsStored(reqStatus, KMessage, rpCause);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST B2, check NackSmsStored() when there are sms received
+ // but they have iDeleteAfterClientAck = false
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = EFalse;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingNackSmsStored, KErrNone);
+
+ messaging.NackSmsStored(reqStatus, KMessage, rpCause);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::AckSmsStored
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingNackSmsStored, KErrNone);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // data, messaging, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNSS-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::NackSmsStored
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::NackSmsStored
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNackSmsStored0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT8(KMessage, "Happy New Year");
+
+ TRequestStatus reqStatus;
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+ TInt rpCause(0);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::NackSmsStored
+ //-------------------------------------------------------------------------
+
+ // make the server expect an acknowledgement
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ TMockLtsyData2<TDesC8*, TInt> expTsyData(msgPtr, rpCause);
+
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingNackSmsStored, KErrNone);
+
+ messaging.NackSmsStored(reqStatus, KMessage, rpCause);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingNackSmsStored);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNSS-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::NackSmsStored
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::NackSmsStored
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNackSmsStored0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+
+ _LIT8(KMessage, "Happy New Year");
+ _LIT8(KMessage2, "Happy New Year2");
+
+ // make the server expect an acknowledgement
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+ TInt rpCause(0);
+
+ TMockLtsyData2<TDesC8*, TInt> expTsyData(msgPtr, rpCause);
+
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingNackSmsStored, KErrNone, 10);
+
+ messaging.NackSmsStored(reqStatus, KMessage, rpCause);
+
+ TInt rpCause2(0);
+
+ messaging2.NackSmsStored(reqStatus2, KMessage2, rpCause2);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNSS-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NackSmsStored with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::NackSmsStored and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNackSmsStored0005L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT8(KMessage, "Happy New Year");
+
+ // make the server expect an acknowledgement
+ TRequestStatus reqReceiveStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ TBuf8<100> forMsg;
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);
+ User::WaitForRequest(reqReceiveStatus);
+ ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());
+
+ // The server now is expecting the acknowledgement
+
+ TRequestStatus reqStatus;
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+ TInt rpCause(0);
+
+
+ TMockLtsyData2<TDesC8*, TInt> expTsyData(msgPtr, rpCause);
+
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ messaging.NackSmsStored(reqStatus, KMessage, rpCause);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGMSB-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetMoSmsBearer
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::GetMoSmsBearer
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetMoSmsBearer0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging::TMobileSmsBearer bearer;
+
+ err = messaging.GetMoSmsBearer(bearer);
+ ASSERT_EQUALS(KErrNotSupported, err);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGRM-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetReceiveMode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::GetReceiveMode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetReceiveMode0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging::TMobileSmsReceiveMode mode;
+
+ err = messaging.GetReceiveMode(mode);
+ ASSERT_EQUALS(KErrNone, err);
+ ASSERT_EQUALS(RMobileSmsMessaging::EReceiveUnstoredClientAck, mode);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveMode modeToSet(RMobileSmsMessaging::EReceiveStored);
+
+ messaging.SetReceiveMode(reqStatus, modeToSet);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ err = messaging.GetReceiveMode(mode);
+ ASSERT_EQUALS(KErrNone, err);
+ ASSERT_EQUALS(RMobileSmsMessaging::EReceiveUnstoredClientAck, mode);
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRM-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::ReceiveMessage
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::ReceiveMessage
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestReceiveMessage0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsStore store;
+
+ err = store.Open(messaging, KETelMeSmsStore);
+ ASSERT_EQUALS(KErrNotSupported, err);
+
+
+ iMockLTSY.ExpectL(EMobilePhoneStoreGetInfo, KErrNone);
+ err = store.Open(messaging, KETelIccSmsStore);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(store);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus reqStatus;
+ TRequestStatus mockLtsyStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ _LIT8(KMessage, "Happy New Year");
+ TBuf8<100> forMsg;
+
+ //-------------------------------------------------------------------------
+ // TEST A1: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting, KErrNotSupported);
+
+ messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+ messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = ETrue;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrGeneral, data);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::ReceiveMessage
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ TDesC8* zeroPtr(NULL);
+ TInt rpCause(KErrGsmSMSUnspecifiedProtocolError);
+ TMockLtsyData2<TDesC8*, TInt> expTsyData(zeroPtr, rpCause);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);
+
+ TMockLtsyData1<TDesC8*> expAckTsyData(msgPtr);
+
+ data.Close();
+ expAckTsyData.SerialiseL(data);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = EFalse;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compRecTsyData(ind, smsMsgPtr);
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // successful completion of RMobileSmsMessaging::ReceiveMessage
+ // in case when iClientStorageFull = false
+ //-------------------------------------------------------------------------
+
+ data.Close();
+ expAckTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //completion with KErrGsmSMSUnspecifiedProtocolError and iClientStorageFull = false
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrGsmSMSUnspecifiedProtocolError, data);
+
+ rpCause = KErrGsmSMSUnspecifiedProtocolError;
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // successful completion of RMobileSmsMessaging::ReceiveMessage
+ // in case when iClientStorageFull = false and iSmsClass2 = EFalse
+ //-------------------------------------------------------------------------
+
+
+ data.Close();
+ expAckTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+
+ TRequestStatus reqAckStatus;
+
+ messaging.AckSmsStored(reqAckStatus, KMessage, EFalse);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);
+
+ User::WaitForRequest(reqAckStatus);
+ ASSERT_EQUALS(KErrNone, reqAckStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ smsMsg.iSmsClass2 = EFalse;
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+ messaging.CancelAsyncRequest(EMobileSmsMessagingReceiveMessage);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // Unsolicited completion of RMobileSmsMessaging::ReceiveMessage
+ // in case when (iClientStorageFull && smsClass2)
+ //-------------------------------------------------------------------------
+
+ data.Close();
+ expAckTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+ messaging.AckSmsStored(reqStatus, KMessage, ETrue);
+ iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ smsMsg.iSmsClass2 = ETrue;
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ TMockLtsyData1<TDesC8*> expZeroAckTsyData(zeroPtr);
+ data.Close();
+ expZeroAckTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::ReceiveMessage when result is not cached.
+ //-------------------------------------------------------------------------
+
+ // smsStoreArray is not zero, complete ReceiveMessage() from DeliverClass2ToSmsStack()
+
+ TRequestStatus reqResumeStatus;
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingResumeSmsReception, KErrNone);
+ messaging.ResumeSmsReception(reqResumeStatus);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+ User::WaitForRequest(reqResumeStatus);
+ ASSERT_EQUALS(KErrNone, reqResumeStatus.Int());
+
+ TRequestStatus reqRecStatus;
+ messaging.ReceiveMessage(reqRecStatus, forMsg, receiveAttrPckg);
+
+ User::WaitForRequest(reqRecStatus);
+ ASSERT_EQUALS(KErrNone, reqRecStatus.Int());
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ TUint8 smsRoutingStatus1 ( KSmsRoutingActivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData1(smsRoutingStatus1);
+ data.Close();
+ compSmsRoutingTsyData1.SerialiseL(data);
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ messaging.AckSmsStored(reqAckStatus, KMessage, ETrue);
+
+ User::WaitForRequest(reqAckStatus);
+ ASSERT_EQUALS(KErrNone, reqAckStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //completion of receive request with rpError = KErrGsmSMSMemoryCapacityExceeded
+
+
+ smsMsg.iSmsClass2 = EFalse;
+ smsMsg.iDeleteAfterClientAck = EFalse;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ rpCause = KErrGsmSMSMemoryCapacityExceeded;
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //completion using KErrGsmSMSUnspecifiedProtocolError
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrGsmSMSUnspecifiedProtocolError, data);
+
+ rpCause = KErrGsmSMSMemoryCapacityExceeded;
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //completion using KErrGsmSMSMemoryCapacityExceeded and
+ // setting iServerRoutingActivity = ERoutingNotActivated
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrGsmSMSMemoryCapacityExceeded, data);
+
+ rpCause = KErrGsmSMSMemoryCapacityExceeded;
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data, KErrNotSupported);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //completion of EMobileSmsMessagingReceiveMessage with KErrGeneral
+ ind = ETrue;
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrGeneral, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //completion of EMmTsyActivateSmsRouting with KErrGeneral
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ TUint8 smsRoutingStatus ( KSmsRoutingDeactivated );
+ TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);
+ data.Close();
+ compSmsRoutingTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrGeneral, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //Unsolicited completion of EMobileSmsMessagingReceiveMessage with KErrGeneral
+
+ data.Close();
+ compRecTsyData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrGeneral, data);
+
+ rpCause = KErrGsmSMSMemoryCapacityExceeded; // set to mem capacity exceeded so that base will resend the message later.
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRM-0001A
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::ReceiveMessage before modem is ready
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::ReceiveMessage
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestReceiveMessage0001AL()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+
+
+ RTelServer telServer;
+ TInt ret = telServer.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer);
+
+ RMobilePhone phone;
+ ret = phone.Open(telServer,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(phone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ err=iMockLTSY.Connect();
+ ASSERT_EQUALS(KErrNone, err);
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ //-------------------------------------------------------------------------
+ // Test activation of RMobileSmsMessaging::ReceiveMessage
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ TBuf8<100> forMsg;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ CleanupStack::PopAndDestroy(5);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRM-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::ReceiveMessage
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::ReceiveMessage
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestReceiveMessage0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::ReceiveMessage
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ TBuf8<100> forMsg;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrGeneral, data);
+
+ messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingReceiveMessage);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+ // this is used for proper processing of unsolicited complete for EMobileSmsMessagingReceiveMessage
+ TDesC8* zeroPtr(NULL);
+ TInt rpCause(KErrGsmSMSUnspecifiedProtocolError);
+ TMockLtsyData2<TDesC8*, TInt> expTsyData(zeroPtr, rpCause);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingNackSmsStored, data);
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRM-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::ReceiveMessage with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::ReceiveMessage with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestReceiveMessage0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ //-------------------------------------------------------------------------
+ // Failure of completion with bad MsgAttribute
+ //-------------------------------------------------------------------------
+
+ TRequestStatus status1;
+ const TInt KSmsBufLength = 231;
+ TBuf8<KSmsBufLength> normalBuf;
+ TInt8 tmp;
+ TPckg<TInt8> badPckg(tmp);
+
+ messaging.ReceiveMessage(status1, normalBuf, badPckg);
+
+ User::WaitForRequest(status1);
+ ASSERT_EQUALS(KErrArgument, status1.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //-------------------------------------------------------------------------
+ // Failure of completion with too small data buffer
+ //-------------------------------------------------------------------------
+
+ TRequestStatus status2;
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TBuf8<1> badBuf;
+
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+
+ _LIT8(KMessage, "Happy New Year");
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ smsMsg.iSmsClass2 = ETrue;
+ smsMsg.iDeleteAfterClientAck = EFalse;
+ smsMsg.iSmsMsg.Copy(KMessage);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ messaging.ReceiveMessage(status2, badBuf, receiveAttrPckg);
+
+ User::WaitForRequest(status2);
+ ASSERT_EQUALS(KErrArgument, status2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRM-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::ReceiveMessage
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::ReceiveMessage
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestReceiveMessage0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileSmsMessaging::ReceiveMessage
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+ TBuf8<100> forMsg;
+ TBuf8<100> forMsg2;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr2;
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);
+ RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg2(receiveAttr2);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+ messaging.ReceiveMessage(reqStatus, forMsg, receiveAttrPckg);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+ messaging2.ReceiveMessage(reqStatus2, forMsg2, receiveAttrPckg2);
+
+
+
+ TSmsMsg smsMsg;
+ TSmsMsg* smsMsgPtr(&smsMsg);
+ TBool ind(EFalse);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+
+
+ TSmsMsg smsMsg2;
+ TSmsMsg* smsMsgPtr2(&smsMsg2);
+ TBool ind2(EFalse);
+
+ TMockLtsyData2<TBool, TSmsMsg*> compTsyData2(ind2, smsMsgPtr2);
+ data.Close();
+ compTsyData2.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);
+
+ iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);
+
+
+ ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 360502);
+ //request for EMobileSmsMessagingReceiveMessage in case of mutiple clients hangs on
+ //User::WaitForRequest() untill testexecute aborts the test with timeout
+
+ ASSERT_TRUE(EFalse);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMSB-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SetMoSmsBearer
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SetMoSmsBearer
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSetMoSmsBearer0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsBearer smsBearer;
+
+
+ TMockLtsyData1<RMobileSmsMessaging::TMobileSmsBearer> expTsyData(smsBearer);
+
+ //-------------------------------------------------------------------------
+ // TEST A1: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ // -1 means an invalid value, which is out of bounds of enum TMobileSmsBearer
+ smsBearer = (RMobileSmsMessaging::TMobileSmsBearer) -1;
+ messaging.SetMoSmsBearer(reqStatus, smsBearer);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+ smsBearer = RMobileSmsMessaging::ESmsBearerPacketOnly;
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSetMoSmsBearer, data);
+
+ messaging.SetMoSmsBearer(reqStatus, smsBearer);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSetMoSmsBearer, KErrGeneral);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::SetMoSmsBearer when result is not cached.
+ //-------------------------------------------------------------------------
+
+ smsBearer = RMobileSmsMessaging::ESmsBearerPacketPreferred;
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSetMoSmsBearer, data);
+
+ messaging.SetMoSmsBearer(reqStatus, smsBearer);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSetMoSmsBearer, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::SetMoSmsBearer
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSetMoSmsBearer, KErrNone);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST A2: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+ smsBearer = RMobileSmsMessaging::ESmsBearerCircuitOnly;
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSetMoSmsBearer, data, KErrNotSupported);
+
+
+ ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 360601);
+
+ //Test A for EMobileSmsMessagingSetMoSmsBearer (failure to dispatch request to LTSY)
+ //result in unknown exception in request completion in ETel::CompleteAndDestroyReq(),
+ //more concrete - in Deque() function
+
+ ASSERT_TRUE(EFalse);
+
+ messaging.SetMoSmsBearer(reqStatus, smsBearer);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMSB-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::SetMoSmsBearer
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::SetMoSmsBearer
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSetMoSmsBearer0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsBearer smsBearer(RMobileSmsMessaging::ESmsBearerCircuitPreferred);
+
+
+ TMockLtsyData1<RMobileSmsMessaging::TMobileSmsBearer> expTsyData(smsBearer);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::SetMoSmsBearer
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSetMoSmsBearer, data);
+ iMockLTSY.CompleteL(EMobileSmsMessagingSetMoSmsBearer, KErrNone, 10);
+
+ messaging.SetMoSmsBearer(reqStatus, smsBearer);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingSetMoSmsBearer);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3); // data, this
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMSB-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::SetMoSmsBearer
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::SetMoSmsBearer
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSetMoSmsBearer0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+ RMobileSmsMessaging::TMobileSmsBearer smsBearer(RMobileSmsMessaging::ESmsBearerCircuitPreferred);
+ RMobileSmsMessaging::TMobileSmsBearer smsBearer2(RMobileSmsMessaging::ESmsBearerPacketOnly);
+
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileSmsMessaging::SetMoSmsBearer
+ //-------------------------------------------------------------------------
+
+ TMockLtsyData1<RMobileSmsMessaging::TMobileSmsBearer> expTsyData(smsBearer);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSetMoSmsBearer, data);
+
+ messaging.SetMoSmsBearer(reqStatus, smsBearer);
+
+ messaging2.SetMoSmsBearer(reqStatus2, smsBearer2);
+
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSetMoSmsBearer, KErrNone);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSRM-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SetReceiveMode
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SetReceiveMode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSetReceiveMode0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveMode recMode(RMobileSmsMessaging::EReceiveModeUnspecified);
+
+ //-------------------------------------------------------------------------
+ // TEST A1: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ messaging.SetReceiveMode(reqStatus, recMode);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::SetReceiveMode when result is not cached.
+ //-------------------------------------------------------------------------
+
+ recMode = RMobileSmsMessaging::EReceiveUnstoredClientAck;
+
+ messaging.SetReceiveMode(reqStatus, recMode);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSRM-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::SetReceiveMode
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::SetReceiveMode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSetReceiveMode0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsReceiveMode recMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::SetReceiveMode
+ //-------------------------------------------------------------------------
+ messaging.SetReceiveMode(reqStatus, recMode);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingSetReceiveMode);
+
+ User::WaitForRequest(reqStatus);
+
+ ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 360701);
+ //SetReceiveModeCancel() is never called, the request cancel can't be completed
+ // Remove the function and correct comment in mm_messaging.cpp
+
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ CleanupStack::PopAndDestroy(2);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSRM-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::SetReceiveMode
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::SetReceiveMode
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSetReceiveMode0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+ RMobileSmsMessaging::TMobileSmsReceiveMode recMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);
+ RMobileSmsMessaging::TMobileSmsReceiveMode recMode2(RMobileSmsMessaging::EReceiveEither);
+
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileSmsMessaging::SetReceiveMode
+ //-------------------------------------------------------------------------
+
+ messaging.SetReceiveMode(reqStatus, recMode);
+
+ messaging2.SetReceiveMode(reqStatus2, recMode2);
+
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSSL-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::StoreSmspListL
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::StoreSmspListL
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestStoreSmspListL0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ CMobilePhoneSmspList* smspListPtr = CMobilePhoneSmspList::NewL();
+ CleanupStack::PushL(smspListPtr);
+
+ //-------------------------------------------------------------------------
+ // TEST A0: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ RMobileSmsMessaging::TMobileSmspEntryV1 smspEntry;
+
+ smspListPtr->AddEntryL(smspEntry);
+
+ TMockLtsyData1<CMobilePhoneSmspList*> expTsyData(smspListPtr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data, KErrNotSupported);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingStoreSmspList, KErrGeneral);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::StoreSmspListL when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingStoreSmspList, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::StoreSmspListL
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingStoreSmspList, KErrNone);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSSL-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::StoreSmspListL
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::StoreSmspListL
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestStoreSmspListL0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ CMobilePhoneSmspList* smspListPtr = CMobilePhoneSmspList::NewL();
+ CleanupStack::PushL(smspListPtr);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging::TMobileSmspEntryV1 smspEntry;
+
+ smspListPtr->AddEntryL(smspEntry);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::StoreSmspListL
+ //-------------------------------------------------------------------------
+
+ TMockLtsyData1<CMobilePhoneSmspList*> expTsyData(smspListPtr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data, KErrNone);
+ iMockLTSY.CompleteL(EMobileSmsMessagingStoreSmspList, KErrNone, 20);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingStoreSmspList);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSSL-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::StoreSmspListL
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::StoreSmspListL
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestStoreSmspListL0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+ CMobilePhoneSmspList* smspListPtr = CMobilePhoneSmspList::NewL();
+ CleanupStack::PushL(smspListPtr);
+
+ RMobileSmsMessaging::TMobileSmspEntryV1 smspEntry;
+ smspListPtr->AddEntryL(smspEntry);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileSmsMessaging::StoreSmspListL
+ //-------------------------------------------------------------------------
+
+ TMockLtsyData1<CMobilePhoneSmspList*> expTsyData(smspListPtr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data, KErrNone);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+
+ messaging2.StoreSmspListL(reqStatus2, smspListPtr);
+
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingStoreSmspList, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(7, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSSL-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::StoreSmspListL with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::StoreSmspListL and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestStoreSmspListL0005L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ CMobilePhoneSmspList* smspListPtr = CMobilePhoneSmspList::NewL();
+ CleanupStack::PushL(smspListPtr);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging::TMobileSmspEntryV1 smspEntry;
+
+ smspListPtr->AddEntryL(smspEntry);
+
+ TMockLtsyData1<CMobilePhoneSmspList*> expTsyData(smspListPtr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data, KErrNone);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRSR-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::ResumeSmsReception
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::ResumeSmsReception
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestResumeSmsReception0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception, KErrNotSupported);
+
+ messaging.ResumeSmsReception(reqStatus);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception);
+
+ messaging.ResumeSmsReception(reqStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingResumeSmsReception, KErrGeneral);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::ResumeSmsReception when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception);
+
+ messaging.ResumeSmsReception(reqStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingResumeSmsReception, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::ResumeSmsReception
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingResumeSmsReception, KErrNone);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // additional test
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ TRfStateInfo rfInfo = ERfsStateInfoInactive;
+ TMockLtsyData1<TRfStateInfo> mockData1(rfInfo);
+
+ mockData1.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ messaging.ResumeSmsReception(reqStatus);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ rfInfo = ERfsStateInfoNormal;
+
+ data.Close();
+ mockData1.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ AssertMockLtsyStatusL();
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ rfInfo = ERfsStateInfoInactive;
+ data.Close();
+ mockData1.SerialiseL(data);
+ iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ AssertMockLtsyStatusL();
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ rfInfo = ERfsStateInfoNormal;
+ data.Close();
+ mockData1.SerialiseL(data);
+ iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRSR-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::ResumeSmsReception
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::ResumeSmsReception
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestResumeSmsReception0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::ResumeSmsReception
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception);
+ iMockLTSY.CompleteL(EMobileSmsMessagingResumeSmsReception, KErrNone, 10);
+
+ messaging.ResumeSmsReception(reqStatus);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingResumeSmsReception);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRSR-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::ResumeSmsReception
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::ResumeSmsReception
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestResumeSmsReception0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileSmsMessaging::ResumeSmsReception
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception);
+
+ messaging.ResumeSmsReception(reqStatus);
+
+ messaging2.ResumeSmsReception(reqStatus2);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingResumeSmsReception, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SRSR-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::ResumeSmsReception with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::ResumeSmsReception and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestResumeSmsReception0005L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingResumeSmsReception);
+
+ messaging.ResumeSmsReception(reqStatus);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(2);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGMSI-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetMessageStoreInfo
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::GetMessageStoreInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetMessageStoreInfo0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo(info);
+ TInt index(0);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingGetMessageStoreInfo, KErrNotSupported);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingGetMessageStoreInfo);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ TInt total(0);
+ TInt used(0);
+
+ TMockLtsyData2<TInt, TInt> compData(total, used);
+
+ compData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingGetMessageStoreInfo, KErrGeneral, data);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::GetMessageStoreInfo when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingGetMessageStoreInfo);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ total = 2;
+ used = 1;
+
+ data.Close();
+ compData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingGetMessageStoreInfo, KErrNone, data);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ ASSERT_EQUALS(0, info.iName.Compare(KETelIccSmsStore));
+ ASSERT_EQUALS(RMobilePhoneStore::EShortMessageStore, info.iType);
+ ASSERT_TRUE(total == info.iTotalEntries);
+ ASSERT_TRUE(used == info.iUsedEntries);
+ ASSERT_EQUALS(KSmsMessageStoreInfoCaps, info.iCaps);
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C2: Successful completion request of
+ // RMobileSmsMessaging::GetMessageStoreInfo when result is not cached.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingGetMessageStoreInfo);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingGetMessageStoreInfo, KErrNotFound, data);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ ASSERT_EQUALS(0, info.iName.Compare(KETelIccSmsStore));
+ ASSERT_EQUALS(RMobilePhoneStore::EShortMessageStore, info.iType);
+ ASSERT_TRUE(total == info.iTotalEntries);
+ ASSERT_TRUE(used == info.iUsedEntries);
+ ASSERT_EQUALS(KSmsMessageStoreInfoCaps, info.iCaps);
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::GetMessageStoreInfo
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingGetMessageStoreInfo, KErrNone, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGMSI-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::GetMessageStoreInfo
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::GetMessageStoreInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetMessageStoreInfo0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo(info);
+ TInt index(0);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::GetMessageStoreInfo
+ //-------------------------------------------------------------------------
+ iMockLTSY.ExpectL(EMobileSmsMessagingGetMessageStoreInfo);
+
+ TInt total(5);
+ TInt used(2);
+
+ TMockLtsyData2<TInt, TInt> compData(total, used);
+
+ compData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingGetMessageStoreInfo, KErrNone, data, 10);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingGetMessageStoreInfo);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGMSI-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetMessageStoreInfo with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::GetMessageStoreInfo with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetMessageStoreInfo0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo(info);
+ TInt index(KSmsStoreNumber + 1);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //
+ index = -1;
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3); // messaging, data, this
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGMSI-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::GetMessageStoreInfo
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::GetMessageStoreInfo
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetMessageStoreInfo0004L()
+ {
+
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 info2;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo(info);
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo2(info2);
+ TInt index(0);
+ TInt index2(0);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingGetMessageStoreInfo);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ messaging2.GetMessageStoreInfo(reqStatus2, index2, pckgInfo2);
+
+ TInt total(5);
+ TInt used(2);
+
+ TMockLtsyData2<TInt, TInt> compData(total, used);
+
+ compData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingGetMessageStoreInfo, KErrNone, data);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGMSI-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetMessageStoreInfo with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::GetMessageStoreInfo and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetMessageStoreInfo0005L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;
+ RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg pckgInfo(info);
+ TInt index(0);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingGetMessageStoreInfo);
+
+ messaging.GetMessageStoreInfo(reqStatus, index, pckgInfo);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNSLC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NotifySmspListChange
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::NotifySmspListChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNotifySmspListChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::NotifySmspListChange when result is not cached.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqNotifyStatus;
+
+ messaging.NotifySmspListChange(reqNotifyStatus);
+
+
+ TRequestStatus reqStatus;
+ CMobilePhoneSmspList* smspListPtr = CMobilePhoneSmspList::NewL();
+ CleanupStack::PushL(smspListPtr);
+
+ RMobileSmsMessaging::TMobileSmspEntryV1 smspEntry;
+
+ smspListPtr->AddEntryL(smspEntry);
+
+ TMockLtsyData1<CMobilePhoneSmspList*> expTsyData(smspListPtr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data, KErrNone);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingStoreSmspList, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqNotifyStatus);
+ ASSERT_EQUALS(KErrNone, reqNotifyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNSLC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::NotifySmspListChange
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::NotifySmspListChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNotifySmspListChange0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::NotifySmspListChange
+ //-------------------------------------------------------------------------
+ TRequestStatus reqNotifyStatus;
+
+ messaging.NotifySmspListChange(reqNotifyStatus);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingNotifySmspListChange);
+
+ User::WaitForRequest(reqNotifyStatus);
+ ASSERT_EQUALS(KErrCancel, reqNotifyStatus.Int());
+
+ CleanupStack::PopAndDestroy(2); // data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SNSLC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::NotifySmspListChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::NotifySmspListChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestNotifySmspListChange0004L()
+ {
+
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileSmsMessaging::NotifySmspListChange
+ //-------------------------------------------------------------------------
+ TRequestStatus reqNotifyStatus;
+ TRequestStatus reqNotifyStatus2;
+
+ messaging.NotifySmspListChange(reqNotifyStatus);
+ messaging2.NotifySmspListChange(reqNotifyStatus2);
+
+
+ TRequestStatus reqStatus;
+ CMobilePhoneSmspList* smspListPtr = CMobilePhoneSmspList::NewL();
+ CleanupStack::PushL(smspListPtr);
+
+ RMobileSmsMessaging::TMobileSmspEntryV1 smspEntry;
+
+ smspListPtr->AddEntryL(smspEntry);
+
+ TMockLtsyData1<CMobilePhoneSmspList*> expTsyData(smspListPtr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingStoreSmspList, data, KErrNone);
+
+ messaging.StoreSmspListL(reqStatus, smspListPtr);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingStoreSmspList, KErrNone);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqNotifyStatus);
+ ASSERT_EQUALS(KErrNone, reqNotifyStatus.Int());
+
+ User::WaitForRequest(reqNotifyStatus2);
+ ASSERT_EQUALS(KErrNone, reqNotifyStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(7, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMNFC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessageNoFdnCheck
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SendMessageNoFdnCheck
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessageNoFdnCheck0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+
+ _LIT8(KMessage, "Merry christmas");
+ TBuf8<32> tmpName(KMessage);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessageNoFdnCheck;
+ dataAndAttr.iAttributes = &smsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+
+ expTsyData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST B1: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ const TInt16 KMsgRef(25);
+ TInt16 msgRef(KMsgRef);
+ TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);
+
+ TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrGeneral, data, 10);
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data, KErrNotSupported);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B2: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrGeneral, data, 10);
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrGeneral, data, 10);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrGeneral, data, 10);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::SendMessage when result is not cached.
+ //-------------------------------------------------------------------------
+
+ _LIT8(KSubmit, "Submit");
+ _LIT(KNum, "+441632960000");
+
+ smsAttr.iGsmServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iGsmServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iGsmServiceCentre.iTelNumber.Copy(KNum);
+ smsAttr.iCdmaServiceCategory = 0;
+ smsAttr.iCdmaTeleservice = 0;
+ smsAttr.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;
+ smsAttr.iFlags = 0;
+ smsAttr.iMsgRef = 0;
+ smsAttr.iSubmitReport = KSubmit;
+ smsAttr.iMore = EFalse;
+ smsAttr.iDestination.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iDestination.iTelNumber.Copy(KNum);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrNone, data, 10);
+
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iGsmServiceCentre.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iGsmServiceCentre.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iGsmServiceCentre.iTelNumber.Compare(KNum));
+ ASSERT_EQUALS(0, smsAttr.iCdmaServiceCategory);
+ ASSERT_EQUALS(0, smsAttr.iCdmaTeleservice);
+ ASSERT_EQUALS(RMobileSmsMessaging::EFormatGsmTpdu, smsAttr.iDataFormat);
+ ASSERT_TRUE((RMobileSmsMessaging::KMessageReference | RMobileSmsMessaging::KGsmSubmitReport)
+ == smsAttr.iFlags);
+ ASSERT_TRUE(KMsgRef == smsAttr.iMsgRef);
+ ASSERT_EQUALS(0, smsAttr.iSubmitReport.Compare(KMessage));
+ ASSERT_TRUE(EFalse == smsAttr.iMore);
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iDestination.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iDestination.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iDestination.iTelNumber.Compare(KNum));
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C2: Successful completion request of
+ // RMobileSmsMessaging::SendMessage when result is not cached.
+ //-------------------------------------------------------------------------
+
+ tmpName.SetLength(0);
+ smsMsg.SetLength(0);
+
+ smsAttr.iGsmServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iGsmServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iGsmServiceCentre.iTelNumber.Copy(KNum);
+ smsAttr.iCdmaServiceCategory = 0;
+ smsAttr.iCdmaTeleservice = 0;
+ smsAttr.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;
+ smsAttr.iFlags = 0;
+ smsAttr.iMsgRef = 0;
+ smsAttr.iSubmitReport = KSubmit;
+ smsAttr.iMore = EFalse;
+ smsAttr.iDestination.iTypeOfNumber = RMobilePhone::EInternationalNumber;
+ smsAttr.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
+ smsAttr.iDestination.iTelNumber.Copy(KNum);
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrNone, data, 10);
+
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iGsmServiceCentre.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iGsmServiceCentre.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iGsmServiceCentre.iTelNumber.Compare(KNum));
+ ASSERT_EQUALS(0, smsAttr.iCdmaServiceCategory);
+ ASSERT_EQUALS(0, smsAttr.iCdmaTeleservice);
+ ASSERT_EQUALS(RMobileSmsMessaging::EFormatGsmTpdu, smsAttr.iDataFormat);
+ ASSERT_TRUE(RMobileSmsMessaging::KMessageReference == smsAttr.iFlags);
+ ASSERT_TRUE(KMsgRef == smsAttr.iMsgRef);
+ ASSERT_EQUALS(0, smsAttr.iSubmitReport.Compare(KSubmit));
+ ASSERT_TRUE(EFalse == smsAttr.iMore);
+ ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iDestination.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iDestination.iNumberPlan);
+ ASSERT_EQUALS(0, smsAttr.iDestination.iTelNumber.Compare(KNum));
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileSmsMessaging::SendMessage
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrNone, data, 10);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ data.Close();
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data, KErrNotSupported);
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMNFC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::SendMessageNoFdnCheck
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileSmsMessaging::SendMessageNoFdnCheck
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessageNoFdnCheck0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT8(KMessage, "Merry christmas");
+ TBuf8<32> tmpName(KMessage);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessageNoFdnCheck;
+ dataAndAttr.iAttributes = &smsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+ expTsyData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileSmsMessaging::SendMessageNoFdnCheck
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ const TInt16 KMsgRef(25);
+ TInt16 msgRef(KMsgRef);
+ TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);
+ TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrNone, data, 10);
+
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ messaging.CancelAsyncRequest(EMobileSmsMessagingSendMessageNoFdnCheck);
+
+ // Wait for completion of iMockLTSY.NotifyTerminated
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMNFC-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessageNoFdnCheck with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SendMessageNoFdnCheck with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessageNoFdnCheck0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TRequestStatus reqStatus;
+ TBuf8<1> tmpName;
+ TInt smsAttr(1);
+ TPckg<TInt8> badSmsAttrPckg(smsAttr);
+
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, badSmsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2); // messaging, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMNFC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::SendMessageNoFdnCheck
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::SendMessageNoFdnCheck
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessageNoFdnCheck0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RMobileSmsMessaging messaging2;
+ err = messaging2.Open(phone2);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging2);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 data2;
+ CleanupClosePushL(data2);
+
+ _LIT8(KMessage, "Merry christmas");
+ _LIT8(KMessage2, "Merry christmas2");
+ TBuf8<32> tmpName(KMessage);
+ TBuf8<32> tmpName2(KMessage2);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TRequestStatus reqStatus2;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr2;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg2(smsAttr2);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessageNoFdnCheck;
+ dataAndAttr.iAttributes = &smsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+ expTsyData.SerialiseL(data);
+
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ messaging2.SendMessageNoFdnCheck(reqStatus2, tmpName2, smsAttrPckg2);
+
+
+ const TInt16 KMsgRef(25);
+ TInt16 msgRef(KMsgRef);
+ TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);
+ TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);
+ data.Close();
+ compTsyData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileSmsMessagingSendMessageNoFdnCheck, KErrNone, data);
+
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(7);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SSMNFC-0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessageNoFdnCheck with timeout
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::SendMessageNoFdnCheck and tests for timeout
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestSendMessageNoFdnCheck0005L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ _LIT8(KMessage, "Merry christmas");
+ TBuf8<32> tmpName(KMessage);
+
+ TRequestStatus reqStatus;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;
+ RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);
+
+ TSendSmsDataAndAttributes dataAndAttr;
+ dataAndAttr.iIpc = EMobileSmsMessagingSendMessageNoFdnCheck;
+ dataAndAttr.iAttributes = &smsAttr;
+ dataAndAttr.iMsgData = &tmpName;
+
+ TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);
+ expTsyData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(EMobileSmsMessagingSendMessageNoFdnCheck, data);
+
+ messaging.SendMessageNoFdnCheck(reqStatus, tmpName, smsAttrPckg);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3);
+
+ }
+
+
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SEMS-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::EnumerateMessageStores
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::EnumerateMessageStores
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestEnumerateMessageStores0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TInt count;
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::EnumerateMessageStores when result is not cached.
+ //-------------------------------------------------------------------------
+
+ err = messaging.EnumerateMessageStores(count);
+ ASSERT_EQUALS(KErrNone, err);
+ ASSERT_TRUE(KSmsStoreNumber == count);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetCaps
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::GetCaps
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetCaps0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ RMobileSmsMessaging::TMobileSmsCapsV1 caps;
+ RMobileSmsMessaging::TMobileSmsCapsV1Pckg pckgCaps(caps);
+
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileSmsMessaging::GetCaps when result is not cached.
+ //-------------------------------------------------------------------------
+
+ err = messaging.GetCaps(pckgCaps);
+
+ ASSERT_EQUALS(KErrNone, err);
+
+ ASSERT_TRUE( caps.iSmsMode == KSmsGsmModeCaps);
+ ASSERT_TRUE( caps.iSmsControl == KSmsControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-SMSM-SGC-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::GetCaps with bad parameter data
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileSmsMessaging::GetCaps with bad parameter data
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsySmsMessagingFU::TestGetCaps0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RMobileSmsMessaging messaging;
+ TInt err = messaging.Open(iPhone);
+ ASSERT_EQUALS(KErrNone, err);
+ CleanupClosePushL(messaging);
+
+ TInt8 badCaps;
+ TPckg<TInt8> badCapsPckg(badCaps);
+
+ err = messaging.GetCaps(badCapsPckg);
+
+ ASSERT_EQUALS(KErrArgument, err);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this);
+
+ }
+
+
+
+