1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // The TEFUnit test suite for SmsMessaging in the Common TSY.

    15 // 

    16 //

    17 

    18 /**

    19  @file 

    20 */

    21 

    22 #include "cctsysmsmessagingfu.h"

    23 #include <etel.h>

    24 #include <etelmm.h>

    25 #include <et_clsvr.h>

    26 #include <ctsy/mmtsy_names.h>

    27 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    28 #include "tmockltsydata.h"

    29 #include <ctsy/serviceapi/gsmerror.h>

    30 

    31 CTestSuite* CCTsySmsMessagingFU::CreateSuiteL(const TDesC& aName)

    32     {

    33     SUB_SUITE;

    34 

    35     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyMoSmsBearerChange0001L);

    36     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0001L);

    37     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0002L);

    38     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifyReceiveModeChange0004L);

    39     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0001L);

    40     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0002L);

    41     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0003L);

    42     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0004L);

    43     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessage0005L);

    44     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0001L);

    45     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0002L);

    46     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0004L);

    47     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestAckSmsStored0005L);

    48     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0001L);

    49     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0002L);

    50     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0004L);

    51     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNackSmsStored0005L);

    52     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMoSmsBearer0001L);

    53     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetReceiveMode0001L);

    54     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0001L);

    55     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0001AL);

    56     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0002L);

    57     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0003L);

    58     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestReceiveMessage0004L);

    59     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0001L);

    60     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0002L);

    61     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetMoSmsBearer0004L);

    62     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0001L);

    63     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0002L);

    64     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSetReceiveMode0004L);

    65     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0001L);

    66     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0002L);

    67     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0004L);

    68     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestStoreSmspListL0005L);

    69     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0001L);

    70     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0002L);

    71     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0004L);

    72     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestResumeSmsReception0005L);

    73     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0001L);

    74     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0002L);

    75     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0003L);

    76     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0004L);

    77     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetMessageStoreInfo0005L);

    78     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0001L);

    79     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0002L);

    80     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestNotifySmspListChange0004L);

    81     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0001L);

    82     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0002L);

    83     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0003L);

    84     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0004L);

    85     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestSendMessageNoFdnCheck0005L);

    86     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestEnumerateMessageStores0001L);

    87     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetCaps0001L);

    88     ADD_TEST_STEP_ISO_CPP(CCTsySmsMessagingFU, TestGetCaps0003L);

    89 

    90 

    91     END_SUITE;

    92     }

    93 

    94 

    95 //

    96 // Actual test cases

    97 //

    98 

    99 

   100 /**

   101 @SYMTestCaseID BA-CTSY-SMSM-SNMSBC-0001

   102 @SYMComponent  telephony_ctsy

   103 @SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NotifyMoSmsBearerChange

   104 @SYMTestPriority High

   105 @SYMTestActions Invokes RMobileSmsMessaging::NotifyMoSmsBearerChange

   106 @SYMTestExpectedResults Pass

   107 @SYMTestType CT

   108 */

   109 void CCTsySmsMessagingFU::TestNotifyMoSmsBearerChange0001L()

   110     {

   111 

   112     OpenEtelServerL(EUseExtendedError);

   113     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   114     OpenPhoneL();

   115 

   116     RMobileSmsMessaging messaging;

   117     TInt err = messaging.Open(iPhone);

   118     ASSERT_EQUALS(KErrNone, err);

   119     CleanupClosePushL(messaging);

   120 

   121     RMobileSmsMessaging::TMobileSmsBearer smsBearer;

   122     TRequestStatus reqStatus;

   123         

   124     //-------------------------------------------------------------------------

   125     // TEST A: failure to dispatch request to LTSY

   126     //-------------------------------------------------------------------------

   127 

   128     messaging.NotifyMoSmsBearerChange(reqStatus, smsBearer);

   129 

   130     User::WaitForRequest(reqStatus);

   131     ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

   132 

   133     AssertMockLtsyStatusL();

   134     CleanupStack::PopAndDestroy(2, this); 

   135     

   136     }

   137 

   138 

   139 

   140 /**

   141 @SYMTestCaseID BA-CTSY-SMSM-SNRMC-0001

   142 @SYMComponent  telephony_ctsy

   143 @SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::NotifyReceiveModeChange

   144 @SYMTestPriority High

   145 @SYMTestActions Invokes RMobileSmsMessaging::NotifyReceiveModeChange

   146 @SYMTestExpectedResults Pass

   147 @SYMTestType CT

   148 */

   149 void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0001L()

   150     {

   151 

   152     OpenEtelServerL(EUseExtendedError);

   153     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   154     OpenPhoneL();

   155 

   156 

   157     RMobileSmsMessaging messaging;

   158     TInt err = messaging.Open(iPhone);

   159     ASSERT_EQUALS(KErrNone, err);

   160     CleanupClosePushL(messaging);

   161 

   162     RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;

   163     RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);

   164     TRequestStatus reqStatus;

   165     TRequestStatus reqSetStatus;

   166 

   167     //-------------------------------------------------------------------------

   168     // TEST E: Unsolicited completion of RMobileSmsMessaging::NotifyReceiveModeChange

   169     // from LTSY.

   170     //-------------------------------------------------------------------------

   171 

   172     messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

   173 

   174     User::WaitForRequest(reqSetStatus);

   175     ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

   176     

   177     //-------------------------------------------------------------------------

   178     // TEST C: Successful completion request of

   179     // RMobileSmsMessaging::NotifyReceiveModeChange when result is not cached.

   180     //-------------------------------------------------------------------------

   181 

   182     messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);

   183 

   184     messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

   185 

   186     User::WaitForRequest(reqSetStatus);

   187     ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

   188 

   189     User::WaitForRequest(reqStatus);

   190     ASSERT_EQUALS(KErrNone, reqStatus.Int());

   191 

   192     ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode);

   193 

   194 

   195     //-------------------------------------------------------------------------

   196     // TEST E2: Unsolicited completion of RMobileSmsMessaging::NotifyReceiveModeChange

   197     // from LTSY.

   198     //-------------------------------------------------------------------------

   199 

   200     ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 360201); 

   201     ASSERT_TRUE(EFalse);

   202 

   203     //Request for EMobileSmsMessagingNotifyReceiveModeChange is self reposting. 

   204     //If it was completed somehow and then SetReceiveMode() was called without call of NotifyReceiveModeChange() - 

   205     //this result in getting wrong request handle for completion in CTelObject::ReqCompleted() 

   206     //{updatedReqEntry=PhoneOwner()->FindByTsyHandleAndPlacedRequest(aTsyReqHandle);

   207     //__ASSERT_ALWAYS(updatedReqEntry!=NULL, Fault(EEtelFaultCompletionReceivedWithNoReqPackage));}

   208 

   209     messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

   210 

   211     User::WaitForRequest(reqSetStatus);

   212     ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

   213     

   214 

   215     AssertMockLtsyStatusL();

   216     CleanupStack::PopAndDestroy(2, this); // data, this

   217     

   218     }

   219 

   220 

   221 /**

   222 @SYMTestCaseID BA-CTSY-SMSM-SNRMC-0002

   223 @SYMComponent  telephony_ctsy

   224 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::NotifyReceiveModeChange

   225 @SYMTestPriority High

   226 @SYMTestActions Invokes cancelling of RMobileSmsMessaging::NotifyReceiveModeChange

   227 @SYMTestExpectedResults Pass

   228 @SYMTestType CT

   229 */

   230 void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0002L()

   231     {

   232 

   233     OpenEtelServerL(EUseExtendedError);

   234     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   235     OpenPhoneL();

   236 

   237     RMobileSmsMessaging messaging;

   238     TInt err = messaging.Open(iPhone);

   239     ASSERT_EQUALS(KErrNone, err);

   240     CleanupClosePushL(messaging);

   241 

   242     RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;

   243     RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);

   244     TRequestStatus reqStatus;

   245     TRequestStatus reqSetStatus;

   246 

   247     //-------------------------------------------------------------------------

   248     // Test cancelling of RMobileSmsMessaging::NotifyReceiveModeChange

   249     //-------------------------------------------------------------------------

   250     

   251     messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);

   252 

   253     messaging.CancelAsyncRequest(EMobileSmsMessagingNotifyReceiveModeChange);

   254 

   255     messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

   256 

   257     User::WaitForRequest(reqSetStatus);

   258     ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

   259 

   260 

   261     User::WaitForRequest(reqStatus);

   262     ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   263 

   264     CleanupStack::PopAndDestroy(2);

   265     

   266     }

   267 

   268 

   269 

   270 /**

   271 @SYMTestCaseID BA-CTSY-SMSM-SNRMC-0004

   272 @SYMComponent  telephony_ctsy

   273 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::NotifyReceiveModeChange

   274 @SYMTestPriority High

   275 @SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::NotifyReceiveModeChange

   276 @SYMTestExpectedResults Pass

   277 @SYMTestType CT

   278 */

   279 void CCTsySmsMessagingFU::TestNotifyReceiveModeChange0004L()

   280     {

   281                     

   282     OpenEtelServerL(EUseExtendedError);

   283     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   284     OpenPhoneL();

   285 

   286 

   287     // Open second client

   288     RTelServer telServer2;

   289     TInt ret = telServer2.Connect();

   290     ASSERT_EQUALS(KErrNone, ret);

   291     CleanupClosePushL(telServer2);

   292 

   293     RMobilePhone phone2;

   294     ret = phone2.Open(telServer2,KMmTsyPhoneName);

   295     ASSERT_EQUALS(KErrNone, ret);

   296     CleanupClosePushL(phone2);

   297 

   298 

   299     RMobileSmsMessaging messaging;

   300     TInt err = messaging.Open(iPhone);

   301     ASSERT_EQUALS(KErrNone, err);

   302     CleanupClosePushL(messaging);

   303 

   304     RMobileSmsMessaging messaging2;

   305     err = messaging2.Open(phone2);

   306     ASSERT_EQUALS(KErrNone, err);

   307     CleanupClosePushL(messaging2);

   308 

   309     RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode;

   310     RMobileSmsMessaging::TMobileSmsReceiveMode smsSetReceiveMode(RMobileSmsMessaging::EReceiveUnstoredClientAck);

   311     TRequestStatus reqStatus;

   312     TRequestStatus reqSetStatus;

   313 

   314     RMobileSmsMessaging::TMobileSmsReceiveMode smsReceiveMode2;

   315     TRequestStatus reqStatus2;

   316     TRequestStatus reqSetStatus2;

   317 

   318     messaging.NotifyReceiveModeChange(reqStatus, smsReceiveMode);

   319     messaging2.NotifyReceiveModeChange(reqStatus2, smsReceiveMode2);

   320 

   321     messaging.SetReceiveMode(reqSetStatus, smsSetReceiveMode);

   322 

   323     User::WaitForRequest(reqSetStatus);

   324     ASSERT_EQUALS(KErrNone, reqSetStatus.Int());

   325 

   326     User::WaitForRequest(reqStatus);

   327     ASSERT_EQUALS(KErrNone, reqStatus.Int());

   328 

   329     User::WaitForRequest(reqStatus2);

   330     ASSERT_EQUALS(KErrNone, reqStatus2.Int());

   331 

   332     ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode);

   333     ASSERT_EQUALS(smsSetReceiveMode, smsReceiveMode2);

   334 

   335 

   336     CleanupStack::PopAndDestroy(5, this); 

   337 

   338     }

   339 

   340 

   341 

   342 /**

   343 @SYMTestCaseID BA-CTSY-SMSM-SSM-0001

   344 @SYMComponent  telephony_ctsy

   345 @SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessage

   346 @SYMTestPriority High

   347 @SYMTestActions Invokes RMobileSmsMessaging::SendMessage

   348 @SYMTestExpectedResults Pass

   349 @SYMTestType CT

   350 */

   351 void CCTsySmsMessagingFU::TestSendMessage0001L()

   352     {

   353 

   354     OpenEtelServerL(EUseExtendedError);

   355     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   356     OpenPhoneL();

   357 

   358     RBuf8 data;

   359     CleanupClosePushL(data);

   360 

   361     RMobileSmsMessaging messaging;

   362     TInt err = messaging.Open(iPhone);

   363     ASSERT_EQUALS(KErrNone, err);

   364     CleanupClosePushL(messaging);

   365         

   366     //-------------------------------------------------------------------------

   367     // TEST A: failure to dispatch request to LTSY

   368     //-------------------------------------------------------------------------

   369 

   370     _LIT8(KMessage, "Merry christmas");

   371     TBuf8<32> tmpName(KMessage);

   372     

   373     TRequestStatus reqStatus;

   374     RMobileSmsMessaging::TMobileSmsSendAttributesV1 expectSmsAttr;

   375     RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;

   376     RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);

   377 

   378     TSendSmsDataAndAttributes dataAndAttr;

   379     dataAndAttr.iIpc = EMobileSmsMessagingSendMessage; 

   380     dataAndAttr.iAttributes = &expectSmsAttr; 

   381     dataAndAttr.iMsgData = &tmpName; 

   382 

   383     TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);           

   384     expTsyData.SerialiseL(data);

   385 

   386     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data, KErrNotSupported);

   387     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   388 

   389     User::WaitForRequest(reqStatus);

   390     ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

   391 

   392     AssertMockLtsyStatusL();

   393 

   394     //-------------------------------------------------------------------------

   395     // TEST B1: failure on completion of pending request from LTSY->CTSY

   396     //-------------------------------------------------------------------------

   397 

   398     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   399 

   400     const TInt16 KMsgRef(25);

   401     TInt16 msgRef(KMsgRef);

   402     TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);

   403     

   404     TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);

   405     data.Close();

   406     compTsyData.SerialiseL(data);

   407     

   408     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

   409     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   410 

   411     data.Close();

   412     expTsyData.SerialiseL(data);

   413     

   414     // complete request by error passing to HandleRequest() in ResendSms()

   415     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data, KErrNotSupported);

   416 

   417     User::WaitForRequest(reqStatus);

   418     ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   419     

   420     AssertMockLtsyStatusL();

   421 

   422     //-------------------------------------------------------------------------

   423     // TEST B2: failure on completion of pending request from LTSY->CTSY

   424     //-------------------------------------------------------------------------

   425 

   426     // the API makes 3 attemps to make the EMobileSmsMessagingSendMessage request

   427     // we complete all of them with KErrGeneral

   428 

   429     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   430 

   431     data.Close();

   432     compTsyData.SerialiseL(data);

   433     

   434     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

   435     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   436 

   437     data.Close();

   438     expTsyData.SerialiseL(data);

   439 

   440     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   441 

   442     data.Close();

   443     compTsyData.SerialiseL(data);

   444 

   445     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

   446 

   447     data.Close();

   448     expTsyData.SerialiseL(data);

   449 

   450     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   451 

   452     data.Close();

   453     compTsyData.SerialiseL(data);

   454     

   455     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrGeneral, data, 10);

   456 

   457     User::WaitForRequest(reqStatus);

   458     ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   459 

   460     AssertMockLtsyStatusL();

   461 

   462     //-------------------------------------------------------------------------

   463     // TEST C: Successful completion request of

   464     // RMobileSmsMessaging::SendMessage when result is not cached.

   465     //-------------------------------------------------------------------------

   466 

   467     _LIT8(KSubmit, "Submit");

   468     _LIT(KNum, "+441632960000");

   469     

   470     smsAttr.iGsmServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;

   471     smsAttr.iGsmServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

   472     smsAttr.iGsmServiceCentre.iTelNumber.Copy(KNum);

   473     smsAttr.iCdmaServiceCategory = 0;

   474     smsAttr.iCdmaTeleservice = 0;

   475     smsAttr.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;

   476     smsAttr.iFlags = 0;

   477     smsAttr.iMsgRef = 0;

   478     smsAttr.iSubmitReport = KSubmit;

   479     smsAttr.iMore = EFalse;

   480     smsAttr.iDestination.iTypeOfNumber = RMobilePhone::EInternationalNumber;

   481     smsAttr.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

   482     smsAttr.iDestination.iTelNumber.Copy(KNum);

   483     

   484     expectSmsAttr = smsAttr;

   485     

   486     data.Close();

   487     expTsyData.SerialiseL(data);

   488 

   489     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   490 

   491     data.Close();

   492     compTsyData.SerialiseL(data);

   493 

   494     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);

   495     

   496     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   497 

   498     User::WaitForRequest(reqStatus);

   499     ASSERT_EQUALS(KErrNone, reqStatus.Int());

   500 

   501     ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iGsmServiceCentre.iTypeOfNumber);

   502     ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iGsmServiceCentre.iNumberPlan);

   503     ASSERT_EQUALS(0, smsAttr.iGsmServiceCentre.iTelNumber.Compare(KNum));

   504     ASSERT_EQUALS(0, smsAttr.iCdmaServiceCategory);

   505     ASSERT_EQUALS(0, smsAttr.iCdmaTeleservice);

   506     ASSERT_EQUALS(RMobileSmsMessaging::EFormatGsmTpdu, smsAttr.iDataFormat);

   507     ASSERT_TRUE((RMobileSmsMessaging::KMessageReference | RMobileSmsMessaging::KGsmSubmitReport)

   508          == smsAttr.iFlags);

   509     ASSERT_TRUE(msgRef == smsAttr.iMsgRef);

   510     ASSERT_EQUALS(0, smsAttr.iSubmitReport.Compare(smsMsg));

   511     ASSERT_TRUE(EFalse == smsAttr.iMore);

   512     ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iDestination.iTypeOfNumber);

   513     ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iDestination.iNumberPlan);

   514     ASSERT_EQUALS(0, smsAttr.iDestination.iTelNumber.Compare(KNum));

   515 

   516     AssertMockLtsyStatusL();

   517 

   518     //-------------------------------------------------------------------------

   519     // TEST C2: Successful completion request of

   520     // RMobileSmsMessaging::SendMessage when result is not cached.

   521     //-------------------------------------------------------------------------

   522 

   523     smsAttr.iGsmServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;

   524     smsAttr.iGsmServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

   525     smsAttr.iGsmServiceCentre.iTelNumber.Copy(KNum);

   526     smsAttr.iCdmaServiceCategory = 0;

   527     smsAttr.iCdmaTeleservice = 0;

   528     smsAttr.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;

   529     smsAttr.iFlags = 0;

   530     smsAttr.iMsgRef = 0;

   531     smsAttr.iSubmitReport = KSubmit;

   532     smsAttr.iMore = EFalse;

   533     smsAttr.iDestination.iTypeOfNumber = RMobilePhone::EInternationalNumber;

   534     smsAttr.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

   535     smsAttr.iDestination.iTelNumber.Copy(KNum);

   536 

   537     expectSmsAttr = smsAttr;

   538 

   539     tmpName.SetLength(0);

   540     smsMsg.SetLength(0);

   541 

   542     data.Close();

   543     expTsyData.SerialiseL(data);

   544 

   545     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   546 

   547     data.Close();

   548     compTsyData.SerialiseL(data);

   549 

   550     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);

   551     

   552     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   553 

   554     User::WaitForRequest(reqStatus);

   555     ASSERT_EQUALS(KErrNone, reqStatus.Int());

   556 

   557     ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iGsmServiceCentre.iTypeOfNumber);

   558     ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iGsmServiceCentre.iNumberPlan);

   559     ASSERT_EQUALS(0, smsAttr.iGsmServiceCentre.iTelNumber.Compare(KNum));

   560     ASSERT_EQUALS(0, smsAttr.iCdmaServiceCategory);

   561     ASSERT_EQUALS(0, smsAttr.iCdmaTeleservice);

   562     ASSERT_EQUALS(RMobileSmsMessaging::EFormatGsmTpdu, smsAttr.iDataFormat);

   563     ASSERT_TRUE(RMobileSmsMessaging::KMessageReference == smsAttr.iFlags);

   564     ASSERT_TRUE(KMsgRef == smsAttr.iMsgRef);

   565     ASSERT_EQUALS(0, smsAttr.iSubmitReport.Compare(KSubmit));

   566     ASSERT_TRUE(EFalse == smsAttr.iMore);

   567     ASSERT_EQUALS(RMobilePhone::EInternationalNumber, smsAttr.iDestination.iTypeOfNumber);

   568     ASSERT_EQUALS(RMobilePhone::EIsdnNumberPlan, smsAttr.iDestination.iNumberPlan);

   569     ASSERT_EQUALS(0, smsAttr.iDestination.iTelNumber.Compare(KNum));

   570 

   571     AssertMockLtsyStatusL();

   572 

   573     //-------------------------------------------------------------------------

   574     // TEST E: Unsolicited completion of RMobileSmsMessaging::SendMessage

   575     // from LTSY.

   576     //-------------------------------------------------------------------------

   577 

   578     TRequestStatus mockLtsyStatus;

   579     iMockLTSY.NotifyTerminated(mockLtsyStatus);

   580     

   581     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);

   582     

   583     User::WaitForRequest(mockLtsyStatus);

   584     ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   585 

   586     AssertMockLtsyStatusL();

   587     

   588     CleanupStack::PopAndDestroy(3, this); 

   589     

   590     }

   591 

   592 

   593 /**

   594 @SYMTestCaseID BA-CTSY-SMSM-SSM-0002

   595 @SYMComponent  telephony_ctsy

   596 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::SendMessage

   597 @SYMTestPriority High

   598 @SYMTestActions Invokes cancelling of RMobileSmsMessaging::SendMessage

   599 @SYMTestExpectedResults Pass

   600 @SYMTestType CT

   601 */

   602 void CCTsySmsMessagingFU::TestSendMessage0002L()

   603     {

   604 

   605     OpenEtelServerL(EUseExtendedError);

   606     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   607     OpenPhoneL();

   608 

   609     RMobileSmsMessaging messaging;

   610     TInt err = messaging.Open(iPhone);

   611     ASSERT_EQUALS(KErrNone, err);

   612     CleanupClosePushL(messaging);

   613 

   614     TRequestStatus mockLtsyStatus;

   615     iMockLTSY.NotifyTerminated(mockLtsyStatus);

   616 

   617     RBuf8 data;

   618     CleanupClosePushL(data);

   619 

   620     _LIT8(KMessage, "Merry christmas");

   621     TBuf8<32> tmpName(KMessage);

   622     

   623     TRequestStatus reqStatus;

   624     RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;

   625     RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);

   626 

   627     TSendSmsDataAndAttributes dataAndAttr;

   628     dataAndAttr.iIpc = EMobileSmsMessagingSendMessage; 

   629     dataAndAttr.iAttributes = &smsAttr; 

   630     dataAndAttr.iMsgData = &tmpName; 

   631 

   632     TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);           

   633     expTsyData.SerialiseL(data);

   634 

   635     //-------------------------------------------------------------------------

   636     // Test cancelling of RMobileSmsMessaging::SendMessage

   637     //-------------------------------------------------------------------------

   638     

   639     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   640 

   641     const TInt16 KMsgRef(25);

   642     TInt16 msgRef(KMsgRef);

   643     TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);

   644     TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);

   645     data.Close();

   646     compTsyData.SerialiseL(data);

   647     

   648     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data, 10);

   649 

   650     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   651 

   652     messaging.CancelAsyncRequest(EMobileSmsMessagingSendMessage);

   653     

   654     User::WaitForRequest(reqStatus);

   655     // cancel does not work for SendMessage(), this is correct

   656     ASSERT_EQUALS(KErrNone, reqStatus.Int());

   657 

   658     // Wait for completion of iMockLTSY.NotifyTerminated

   659     User::WaitForRequest(mockLtsyStatus);

   660     ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   661     

   662     AssertMockLtsyStatusL();

   663     

   664     CleanupStack::PopAndDestroy(3);

   665     

   666     }

   667 

   668 

   669 /**

   670 @SYMTestCaseID BA-CTSY-SMSM-SSM-0003

   671 @SYMComponent  telephony_ctsy

   672 @SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessage with bad parameter data

   673 @SYMTestPriority High

   674 @SYMTestActions Invokes RMobileSmsMessaging::SendMessage with bad parameter data

   675 @SYMTestExpectedResults Pass

   676 @SYMTestType CT

   677 */

   678 void CCTsySmsMessagingFU::TestSendMessage0003L()

   679     {

   680     OpenEtelServerL(EUseExtendedError);

   681     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   682     OpenPhoneL();

   683 

   684     RMobileSmsMessaging messaging;

   685     TInt err = messaging.Open(iPhone);

   686     ASSERT_EQUALS(KErrNone, err);

   687     CleanupClosePushL(messaging);

   688 

   689     TRequestStatus reqStatus;

   690     TBuf8<1> tmpName;

   691     TInt smsAttr(1);

   692     TPckg<TInt8> badSmsAttrPckg(smsAttr);

   693 

   694     messaging.SendMessage(reqStatus, tmpName, badSmsAttrPckg);

   695         

   696     User::WaitForRequest(reqStatus);

   697     ASSERT_EQUALS(KErrArgument, reqStatus.Int());

   698 

   699     AssertMockLtsyStatusL();

   700     CleanupStack::PopAndDestroy(2); // messaging, this

   701     }

   702 

   703 

   704 /**

   705 @SYMTestCaseID BA-CTSY-SMSM-SSM-0004

   706 @SYMComponent  telephony_ctsy

   707 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileSmsMessaging::SendMessage

   708 @SYMTestPriority High

   709 @SYMTestActions Invokes multiple client requests to RMobileSmsMessaging::SendMessage

   710 @SYMTestExpectedResults Pass

   711 @SYMTestType CT

   712 */

   713 void CCTsySmsMessagingFU::TestSendMessage0004L()

   714     {

   715 

   716     OpenEtelServerL(EUseExtendedError);

   717     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   718     OpenPhoneL();

   719 

   720     RMobileSmsMessaging messaging;

   721     TInt err = messaging.Open(iPhone);

   722     ASSERT_EQUALS(KErrNone, err);

   723     CleanupClosePushL(messaging);

   724 

   725     RTelServer telServer2;

   726     TInt ret = telServer2.Connect();

   727     ASSERT_EQUALS(KErrNone, ret);

   728     CleanupClosePushL(telServer2);

   729 

   730     RMobilePhone phone2;

   731     ret = phone2.Open(telServer2,KMmTsyPhoneName);

   732     ASSERT_EQUALS(KErrNone, ret);

   733     CleanupClosePushL(phone2);

   734 

   735     RMobileSmsMessaging messaging2;

   736     err = messaging2.Open(phone2);

   737     ASSERT_EQUALS(KErrNone, err);

   738     CleanupClosePushL(messaging2);

   739 

   740     RBuf8 data;

   741     CleanupClosePushL(data);

   742 

   743     RBuf8 data2;

   744     CleanupClosePushL(data2);

   745 

   746     _LIT8(KMessage, "Merry christmas");

   747     _LIT8(KMessage2, "Merry christmas2");

   748     TBuf8<32> tmpName(KMessage);

   749     TBuf8<32> tmpName2(KMessage2);

   750     

   751     TRequestStatus reqStatus;

   752     RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;

   753     RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);

   754 

   755     TRequestStatus reqStatus2;

   756     RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr2;

   757     RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg2(smsAttr2);

   758 

   759     TSendSmsDataAndAttributes dataAndAttr;

   760     dataAndAttr.iIpc = EMobileSmsMessagingSendMessage; 

   761     dataAndAttr.iAttributes = &smsAttr; 

   762     dataAndAttr.iMsgData = &tmpName; 

   763 

   764     TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);           

   765     expTsyData.SerialiseL(data);

   766 

   767     

   768     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   769 

   770     const TInt16 KMsgRef(25);

   771     TInt16 msgRef(KMsgRef);

   772     TBuf8<RMobileSmsMessaging::KGsmTpduSize> smsMsg(KMessage);

   773     TMockLtsyData2<TInt16, TBuf8<RMobileSmsMessaging::KGsmTpduSize> > compTsyData(msgRef, smsMsg);

   774     data.Close();

   775     compTsyData.SerialiseL(data);

   776     

   777     iMockLTSY.CompleteL(EMobileSmsMessagingSendMessage, KErrNone, data);

   778 

   779     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   780 

   781     messaging2.SendMessage(reqStatus2, tmpName2, smsAttrPckg2);

   782     

   783     User::WaitForRequest(reqStatus);

   784     ASSERT_EQUALS(KErrNone, reqStatus.Int());

   785 

   786     User::WaitForRequest(reqStatus2);

   787     ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());

   788 

   789     AssertMockLtsyStatusL();

   790 

   791     CleanupStack::PopAndDestroy(7);

   792 

   793     }

   794 

   795 

   796 /**

   797 @SYMTestCaseID BA-CTSY-SMSM-SSM-0005

   798 @SYMComponent  telephony_ctsy

   799 @SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::SendMessage with timeout

   800 @SYMTestPriority High

   801 @SYMTestActions Invokes RMobileSmsMessaging::SendMessage and tests for timeout

   802 @SYMTestExpectedResults Pass

   803 @SYMTestType CT

   804 */

   805 void CCTsySmsMessagingFU::TestSendMessage0005L()

   806     {

   807 

   808     OpenEtelServerL(EUseExtendedError);

   809     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   810     OpenPhoneL();

   811 

   812     RMobileSmsMessaging messaging;

   813     TInt err = messaging.Open(iPhone);

   814     ASSERT_EQUALS(KErrNone, err);

   815     CleanupClosePushL(messaging);

   816 

   817     RBuf8 data;

   818     CleanupClosePushL(data);

   819 

   820     _LIT8(KMessage, "Merry christmas");

   821     TBuf8<32> tmpName(KMessage);

   822     

   823     TRequestStatus reqStatus;

   824     RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsAttr;

   825     RMobileSmsMessaging::TMobileSmsSendAttributesV1Pckg smsAttrPckg(smsAttr);

   826 

   827     TSendSmsDataAndAttributes dataAndAttr;

   828     dataAndAttr.iIpc = EMobileSmsMessagingSendMessage; 

   829     dataAndAttr.iAttributes = &smsAttr; 

   830     dataAndAttr.iMsgData = &tmpName; 

   831 

   832     TMockLtsyData1<TSendSmsDataAndAttributes> expTsyData(dataAndAttr);           

   833     expTsyData.SerialiseL(data);

   834 

   835     iMockLTSY.ExpectL(EMobileSmsMessagingSendMessage, data);

   836 

   837     messaging.SendMessage(reqStatus, tmpName, smsAttrPckg);

   838 

   839     User::WaitForRequest(reqStatus);

   840     ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

   841 

   842     AssertMockLtsyStatusL();

   843 

   844     CleanupStack::PopAndDestroy(3);

   845 

   846     }

   847 

   848 

   849 /**

   850 @SYMTestCaseID BA-CTSY-SMSM-SASS-0001

   851 @SYMComponent  telephony_ctsy

   852 @SYMTestCaseDesc Test support in CTSY for RMobileSmsMessaging::AckSmsStored

   853 @SYMTestPriority High

   854 @SYMTestActions Invokes RMobileSmsMessaging::AckSmsStored

   855 @SYMTestExpectedResults Pass

   856 @SYMTestType CT

   857 */

   858 void CCTsySmsMessagingFU::TestAckSmsStored0001L()

   859     {

   860 

   861     OpenEtelServerL(EUseExtendedError);

   862     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   863     OpenPhoneL();

   864 

   865     RMobileSmsMessaging messaging;

   866     TInt err = messaging.Open(iPhone);

   867     ASSERT_EQUALS(KErrNone, err);

   868     CleanupClosePushL(messaging);

   869 

   870     RBuf8 data;

   871     CleanupClosePushL(data);

   872 

   873     

   874     _LIT8(KMessage, "Happy New Year");

   875 

   876     TRequestStatus reqStatus;

   877     TRequestStatus mockLtsyStatus;

   878     

   879     TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);

   880 

   881     TMockLtsyData1<TDesC8*> expTsyData(msgPtr);

   882     

   883     TDesC8* zeroPtr(NULL);

   884     TMockLtsyData1<TDesC8*> expZeroTsyData(zeroPtr);

   885     

   886     //-------------------------------------------------------------------------

   887     // TEST A1: check AckSmsStored() when acknoledgement is not expected

   888     //-------------------------------------------------------------------------

   889 

   890     expTsyData.SerialiseL(data);

   891  

   892     messaging.AckSmsStored(reqStatus, KMessage, ETrue);

   893 

   894     User::WaitForRequest(reqStatus);

   895     ASSERT_EQUALS(KErrNotReady, reqStatus.Int());

   896 

   897     AssertMockLtsyStatusL();

   898 

   899     //-------------------------------------------------------------------------

   900     // TEST A2: unsuccessful acknoledgement request to the network

   901     //-------------------------------------------------------------------------

   902     

   903     // make the server expect an acknowledgement

   904     TRequestStatus reqReceiveStatus;

   905     RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;

   906     RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);

   907 

   908     TUint8 smsRoutingStatus ( KSmsRoutingActivated );

   909     TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);

   910     data.Close();

   911     compSmsRoutingTsyData.SerialiseL(data);

   912 

   913     iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);    

   914     iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);

   915 

   916     TBuf8<100> forMsg;

   917 

   918     TSmsMsg smsMsg;

   919     TSmsMsg* smsMsgPtr(&smsMsg);

   920     TBool ind(EFalse);

   921     

   922     smsMsg.iSmsClass2 = ETrue;

   923     smsMsg.iDeleteAfterClientAck = ETrue;

   924     smsMsg.iSmsMsg.Copy(KMessage);

   925 

   926     TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);

   927     data.Close();

   928     compTsyData.SerialiseL(data);

   929     

   930     iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);

   931 

   932     messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);

   933     User::WaitForRequest(reqReceiveStatus);

   934     ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());

   935     

   936     // The server now is expecting the acknowledgement

   937     

   938     data.Close();

   939     expTsyData.SerialiseL(data);

   940     iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data, KErrGeneral);

   941 

   942     messaging.AckSmsStored(reqStatus, KMessage, EFalse);

   943     

   944     User::WaitForRequest(reqStatus);    

   945     ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   946  

   947     AssertMockLtsyStatusL();

   948 

   949     //-------------------------------------------------------------------------

   950     // TEST A3: unsuccessful acknoledgement completion

   951     //-------------------------------------------------------------------------

   952     

   953     // make the server expect an acknowledgement

   954     data.Close();

   955     compSmsRoutingTsyData.SerialiseL(data);

   956 

   957     iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);    

   958     iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);

   959 

   960     data.Close();

   961     compTsyData.SerialiseL(data);

   962     

   963     iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);

   964 

   965     messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);

   966     User::WaitForRequest(reqReceiveStatus);

   967     ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());

   968     

   969     // The server now is expecting the acknowledgement

   970     

   971     data.Close();

   972     expTsyData.SerialiseL(data);

   973     iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);

   974 

   975     iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrGeneral);

   976 

   977     messaging.AckSmsStored(reqStatus, KMessage, EFalse);

   978     

   979     User::WaitForRequest(reqStatus);    

   980     ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   981  

   982     AssertMockLtsyStatusL();    

   983     

   984     

   985     //-------------------------------------------------------------------------

   986     // TEST B1, test AckSmsStored() when there are sms received

   987     // that have iDeleteAfterClientAck = true

   988     //-------------------------------------------------------------------------

   989 

   990     // make the server expect an acknowledgement

   991     messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);

   992 

   993     data.Close();

   994     compTsyData.SerialiseL(data);

   995 

   996     iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);

   997 

   998     User::WaitForRequest(reqReceiveStatus);

   999     ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());

  1000 

  1001     // The server now is expecting the acknowledgement

  1002     

  1003     data.Close();

  1004     expTsyData.SerialiseL(data);

  1005 

  1006     iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);    

  1007     iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);

  1008 

  1009     messaging.AckSmsStored(reqStatus, KMessage, EFalse);

  1010     User::WaitForRequest(reqStatus);    

  1011     ASSERT_EQUALS(KErrNone, reqStatus.Int());

  1012 

  1013     AssertMockLtsyStatusL();           

  1014     

  1015 

  1016     //-------------------------------------------------------------------------

  1017     // TEST B2, check AckSmsStored() when there are sms received 

  1018     // but they have iDeleteAfterClientAck = false

  1019     //-------------------------------------------------------------------------

  1020 

  1021     // make the server expect an acknowledgement

  1022     messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);

  1023 

  1024     smsMsg.iSmsClass2 = ETrue;

  1025     smsMsg.iDeleteAfterClientAck = EFalse;

  1026     smsMsg.iSmsMsg.Copy(KMessage);

  1027 

  1028     data.Close();

  1029     compTsyData.SerialiseL(data);

  1030 

  1031     iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);

  1032 

  1033     User::WaitForRequest(reqReceiveStatus);

  1034     ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());

  1035 

  1036     // The server now is expecting the acknowledgement

  1037     

  1038     data.Close();

  1039     expTsyData.SerialiseL(data);

  1040 

  1041     iMockLTSY.ExpectL(EMobileSmsMessagingAckSmsStored, data);    

  1042     iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);

  1043 

  1044     messaging.AckSmsStored(reqStatus, KMessage, EFalse);

  1045     

  1046     User::WaitForRequest(reqStatus);    

  1047     ASSERT_EQUALS(KErrNone, reqStatus.Int());

  1048 

  1049     AssertMockLtsyStatusL();

  1050 

  1051     //-------------------------------------------------------------------------

  1052     // TEST E: Unsolicited completion of RMobileSmsMessaging::AckSmsStored

  1053     // from LTSY.

  1054     //-------------------------------------------------------------------------

  1055 

  1056     iMockLTSY.NotifyTerminated(mockLtsyStatus);

  1057 

  1058     iMockLTSY.CompleteL(EMobileSmsMessagingAckSmsStored, KErrNone);

  1059 

  1060     User::WaitForRequest(mockLtsyStatus);

  1061     ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

  1062 

  1063     AssertMockLtsyStatusL();

  1064     CleanupStack::PopAndDestroy(3, this); // data, messaging, this

  1065     

  1066     }

  1067 

  1068 

  1069 /**

  1070 @SYMTestCaseID BA-CTSY-SMSM-SASS-0002

  1071 @SYMComponent  telephony_ctsy

  1072 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobileSmsMessaging::AckSmsStored

  1073 @SYMTestPriority High

  1074 @SYMTestActions Invokes cancelling of RMobileSmsMessaging::AckSmsStored

  1075 @SYMTestExpectedResults Pass

  1076 @SYMTestType CT

  1077 */

  1078 void CCTsySmsMessagingFU::TestAckSmsStored0002L()

  1079     {

  1080 

  1081     OpenEtelServerL(EUseExtendedError);

  1082     CleanupStack::PushL(TCleanupItem(Cleanup,this));

  1083     OpenPhoneL();

  1084 

  1085     RMobileSmsMessaging messaging;

  1086     TInt err = messaging.Open(iPhone);

  1087     ASSERT_EQUALS(KErrNone, err);

  1088     CleanupClosePushL(messaging);

  1089 

  1090     RBuf8 data;

  1091     CleanupClosePushL(data);

  1092 

  1093     TRequestStatus mockLtsyStatus;

  1094     iMockLTSY.NotifyTerminated(mockLtsyStatus);

  1095     

  1096     _LIT8(KMessage, "Happy New Year");

  1097 

  1098     // make the server expect an acknowledgement

  1099     TRequestStatus reqReceiveStatus;

  1100     RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 receiveAttr;

  1101     RMobileSmsMessaging::TMobileSmsReceiveAttributesV1Pckg receiveAttrPckg(receiveAttr);

  1102 

  1103     TUint8 smsRoutingStatus ( KSmsRoutingActivated );

  1104     TMockLtsyData1<TUint8> compSmsRoutingTsyData(smsRoutingStatus);

  1105     data.Close();

  1106     compSmsRoutingTsyData.SerialiseL(data);

  1107 

  1108     iMockLTSY.ExpectL(EMmTsyActivateSmsRouting);    

  1109     iMockLTSY.CompleteL(EMmTsyActivateSmsRouting, KErrNone, data);

  1110 

  1111     TBuf8<100> forMsg;

  1112     

  1113     TSmsMsg smsMsg;

  1114     TSmsMsg* smsMsgPtr(&smsMsg);

  1115     TBool ind(EFalse);

  1116     

  1117     smsMsg.iSmsClass2 = ETrue;

  1118     smsMsg.iDeleteAfterClientAck = ETrue;

  1119     smsMsg.iSmsMsg.Copy(KMessage);

  1120 

  1121     TMockLtsyData2<TBool, TSmsMsg*> compTsyData(ind, smsMsgPtr);

  1122     data.Close();

  1123     compTsyData.SerialiseL(data);

  1124     

  1125     iMockLTSY.CompleteL(EMobileSmsMessagingReceiveMessage, KErrNone, data);

  1126 

  1127     messaging.ReceiveMessage(reqReceiveStatus, forMsg, receiveAttrPckg);

  1128     User::WaitForRequest(reqReceiveStatus);

  1129     ASSERT_EQUALS(KErrNone, reqReceiveStatus.Int());

  1130     

  1131     // The server now is expecting the acknowledgement

  1132     

  1133     TRequestStatus reqStatus;

  1134     TDesC8* msgPtr = const_cast<TDesC8*>(&KMessage);