diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/test/component/src/cctsysmsmessagingfu.cpp --- /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 +#include +#include +#include +#include +#include "tmockltsydata.h" +#include + +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("$CTSYKnownFailure: defect id = %d"), 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 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 smsMsg(KMessage); + + TMockLtsyData2 > 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 expTsyData(dataAndAttr); + expTsyData.SerialiseL(data); + + //------------------------------------------------------------------------- + // Test cancelling of RMobileSmsMessaging::SendMessage + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data); + + const TInt16 KMsgRef(25); + TInt16 msgRef(KMsgRef); + TBuf8 smsMsg(KMessage); + TMockLtsyData2 > 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 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 expTsyData(dataAndAttr); + expTsyData.SerialiseL(data); + + + iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data); + + const TInt16 KMsgRef(25); + TInt16 msgRef(KMsgRef); + TBuf8 smsMsg(KMessage); + TMockLtsyData2 > 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 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(&KMessage); + + TMockLtsyData1 expTsyData(msgPtr); + + TDesC8* zeroPtr(NULL); + TMockLtsyData1 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 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 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 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 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(&KMessage); + + TMockLtsyData1 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 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 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(&KMessage); + + TMockLtsyData1 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 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 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(&KMessage); + + TMockLtsyData1 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(&KMessage); + TInt rpCause(0); + TMockLtsyData2 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 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 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(&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 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 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 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 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 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(&KMessage); + TInt rpCause(0); + + TMockLtsyData2 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 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 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(&KMessage); + TInt rpCause(0); + + + TMockLtsyData2 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 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 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(&KMessage); + + TMockLtsyData1 expAckTsyData(msgPtr); + + data.Close(); + expAckTsyData.SerialiseL(data); + + smsMsg.iSmsClass2 = ETrue; + smsMsg.iDeleteAfterClientAck = EFalse; + smsMsg.iSmsMsg.Copy(KMessage); + + TMockLtsyData2 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 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 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 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 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 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 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 normalBuf; + TInt8 tmp; + TPckg 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 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 compTsyData(ind, smsMsgPtr); + compTsyData.SerialiseL(data); + + iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data); + + iMockLTSY.ExpectL(EMmTsyActivateSmsRouting); + + + + TSmsMsg smsMsg2; + TSmsMsg* smsMsgPtr2(&smsMsg2); + TBool ind2(EFalse); + + TMockLtsyData2 compTsyData2(ind2, smsMsgPtr2); + data.Close(); + compTsyData2.SerialiseL(data); + + iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data); + + iMockLTSY.ExpectL(EMmTsyActivateSmsRouting); + + + ERR_PRINTF2(_L("$CTSYKnownFailure: defect id = %d"), 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 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("$CTSYKnownFailure: defect id = %d"), 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 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 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("$CTSYKnownFailure: defect id = %d"), 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 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 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 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 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 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 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 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 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 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 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 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 smsMsg(KMessage); + + TMockLtsyData2 > 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 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 smsMsg(KMessage); + TMockLtsyData2 > 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 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 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 smsMsg(KMessage); + TMockLtsyData2 > 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 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 badCapsPckg(badCaps); + + err = messaging.GetCaps(badCapsPckg); + + ASSERT_EQUALS(KErrArgument, err); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); + + } + + + +