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 BroadcastMessaging in the Common TSY.

    15 // 

    16 //

    17 

    18 /**

    19  @file 

    20 */

    21 

    22 #include "cctsybroadcastmessagingfu.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 #include <mmretrieve.h>

    31 #include "cctsyactiveretriever.h"

    32 #include <ctsy/serviceapi/cmmsmsutility.h>

    33 

    34 CTestSuite* CCTsyBroadcastMessagingFU::CreateSuiteL(const TDesC& aName)

    35 	{

    36 	SUB_SUITE;

    37 

    38 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0001L);

    39 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0002L);

    40 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0003L);

    41 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0004L);

    42 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStoreBroadcastIdListL0005L);

    43 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0001L);

    44 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0002L);

    45 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0004L);

    46 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestStart0005L);

    47 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0001L);

    48 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0002L);

    49 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0003L);

    50 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0004L);

    51 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestReceiveMessage0005L);

    52 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetFilterSetting0001L);

    53 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0001L);

    54 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0002L);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0003L);

    56 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0004L);

    57 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetFilterSetting0005L);

    58 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetLanguageFilter0001L);

    59 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestSetLanguageFilter0001L);

    60 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0001L);

    61 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0002L);

    62 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0003L);

    63 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyFilterSettingChange0004L);

    64 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyLanguageFilterChange0001L);

    65 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestNotifyBroadcastIdListChange0001L);

    66 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetCaps0001L);

    67 	ADD_TEST_STEP_ISO_CPP(CCTsyBroadcastMessagingFU, TestGetCaps0003L);

    68 

    69 	END_SUITE;

    70 	}

    71 

    72 

    73 void CCTsyBroadcastMessagingFU::FillInBroadcastIdListL(CMobilePhoneBroadcastIdList& aList)

    74 	{

    75 	

    76 	RMobileBroadcastMessaging::TMobileBroadcastIdEntryV1 entry;

    77 	

    78 	entry.iId = 7;

    79 	aList.AddEntryL(entry);

    80 	

    81 	entry.iId = 17;

    82 	aList.AddEntryL(entry);

    83 	

    84 	entry.iId = 37;

    85 	aList.AddEntryL(entry);

    86 	

    87 	}

    88 

    89 //

    90 // Actual test cases

    91 //

    92 

    93 

    94 /**

    95 @SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0001

    96 @SYMComponent  telephony_ctsy

    97 @SYMTestCaseDesc Test support in CTSY for RMobileBroadcastMessaging::StoreBroadcastIdListL

    98 @SYMTestPriority High

    99 @SYMTestActions Invokes RMobileBroadcastMessaging::StoreBroadcastIdListL

   100 @SYMTestExpectedResults Pass

   101 @SYMTestType CT

   102 */

   103 void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0001L()

   104 	{

   105 

   106 	OpenEtelServerL(EUseExtendedError);

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

   108 	OpenPhoneL();

   109 

   110 	RBuf8 data;

   111 	CleanupClosePushL(data);

   112 

   113 	RMobileBroadcastMessaging messaging;

   114 	TInt err = messaging.Open(iPhone);

   115 	ASSERT_EQUALS(KErrNone, err);

   116 	CleanupClosePushL(messaging);

   117 

   118 	TRequestStatus reqStatus;

   119 

   120 	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

   121 	CleanupStack::PushL(idList);

   122 

   123 	RMobileBroadcastMessaging::TMobileBroadcastIdType type

   124 	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

   125 	

   126 	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

   127 	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

   128 	                                             expectLtsyData(idList, type);

   129 	FillInBroadcastIdListL(*idList);

   130 	expectLtsyData.SerialiseL(data); 

   131 

   132  	//-------------------------------------------------------------------------

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

   134  	//-------------------------------------------------------------------------

   135 

   136     messaging.StoreBroadcastIdListL(reqStatus, idList, type);

   137 

   138 	User::WaitForRequest(reqStatus);

   139 	

   140 	AssertMockLtsyStatusL();

   141 

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

   143 

   144 

   145 	iMockLTSY.NotifyTerminated(reqStatus);

   146 	iMockLTSY.CompleteL(EMobileBroadcastMessagingStoreIdList, KErrNone);

   147 	User::WaitForRequest(reqStatus);

   148 	AssertMockLtsyStatusL();

   149 

   150 	CleanupStack::PopAndDestroy(4, this); // idList, messaging, data, this

   151 

   152 	}

   153 

   154 

   155 /**

   156 @SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0002

   157 @SYMComponent  telephony_ctsy

   158 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobileBroadcastMessaging::StoreBroadcastIdListL

   159 @SYMTestPriority High

   160 @SYMTestActions Invokes cancelling of RMobileBroadcastMessaging::StoreBroadcastIdListL

   161 @SYMTestExpectedResults Pass

   162 @SYMTestType CT

   163 */

   164 void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0002L()

   165 	{

   166 

   167 	OpenEtelServerL(EUseExtendedError);

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

   169 	OpenPhoneL();

   170 

   171 	RBuf8 data;

   172 	CleanupClosePushL(data);

   173 

   174 	RMobileBroadcastMessaging messaging;

   175 	TInt err = messaging.Open(iPhone);

   176 	ASSERT_EQUALS(KErrNone, err);

   177 	CleanupClosePushL(messaging);

   178 

   179 	TRequestStatus reqStatus;

   180 

   181 	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

   182 	CleanupStack::PushL(idList);

   183 

   184 	RMobileBroadcastMessaging::TMobileBroadcastIdType type

   185 	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

   186 	

   187 	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

   188 	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

   189 	                                             expectLtsyData(idList, type);

   190 	FillInBroadcastIdListL(*idList);

   191 	expectLtsyData.SerialiseL(data); 

   192 

   193 	//-------------------------------------------------------------------------

   194 	// Test cancelling of RMobileBroadcastMessaging::StoreBroadcastIdListL

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

   196 

   197 

   198     messaging.StoreBroadcastIdListL(reqStatus, idList, type);

   199 

   200 	messaging.CancelAsyncRequest(EMobileBroadcastMessagingStoreIdList);

   201 

   202 	User::WaitForRequest(reqStatus);

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

   204 

   205 	AssertMockLtsyStatusL();

   206 

   207 	CleanupStack::PopAndDestroy(4, this); // idList, messaging, data, this

   208 	

   209 	}

   210 

   211 

   212 /**

   213 @SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0003

   214 @SYMComponent  telephony_ctsy

   215 @SYMTestCaseDesc Test support in CTSY for RMobileBroadcastMessaging::StoreBroadcastIdListL with bad parameter data

   216 @SYMTestPriority High

   217 @SYMTestActions Invokes RMobileBroadcastMessaging::StoreBroadcastIdListL with bad parameter data

   218 @SYMTestExpectedResults Pass

   219 @SYMTestType CT

   220 */

   221 void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0003L()

   222 	{

   223 

   224 	OpenEtelServerL(EUseExtendedError);

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

   226 	OpenPhoneL();

   227 

   228 	RMobileBroadcastMessaging messaging;

   229 	TInt err = messaging.Open(iPhone);

   230 	ASSERT_EQUALS(KErrNone, err);

   231 	CleanupClosePushL(messaging);

   232 

   233 	//-------------------------------------------------------------------------

   234 	// Test A: Test passing wrong version of parameters to

   235 	// RMobileBroadcastMessaging::StoreBroadcastIdListL

   236  	//-------------------------------------------------------------------------

   237 

   238 	TRequestStatus reqStatus;

   239 	CMobilePhoneBroadcastIdList* idList(NULL);

   240 	messaging.StoreBroadcastIdListL(reqStatus, idList, RMobileBroadcastMessaging::EGsmBroadcastId);

   241 	

   242 	// should never get here because of etel panic

   243 	// so if it gets test fails with the assert below

   244 	ASSERT_TRUE(EFalse);

   245 	

   246 	User::WaitForRequest(reqStatus);

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

   248 

   249 	AssertMockLtsyStatusL();

   250 

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

   252 

   253 	}

   254 

   255 

   256 /**

   257 @SYMTestCaseID BA-CTSY-BRMSG-BSBIL-0004

   258 @SYMComponent  telephony_ctsy

   259 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileBroadcastMessaging::StoreBroadcastIdListL

   260 @SYMTestPriority High

   261 @SYMTestActions Invokes multiple client requests to RMobileBroadcastMessaging::StoreBroadcastIdListL

   262 @SYMTestExpectedResults Pass

   263 @SYMTestType CT

   264 */

   265 void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0004L()

   266 	{

   267 

   268 	OpenEtelServerL(EUseExtendedError);

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

   270 	OpenPhoneL();

   271 

   272 	RBuf8 data;

   273 	CleanupClosePushL(data);

   274 

   275 	RMobileBroadcastMessaging messaging;

   276 	TInt err = messaging.Open(iPhone);

   277 	ASSERT_EQUALS(KErrNone, err);

   278 	CleanupClosePushL(messaging);

   279 

   280 	TRequestStatus reqStatus;

   281 	TRequestStatus reqStatus2;

   282 

   283 	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

   284 	CleanupStack::PushL(idList);

   285 

   286 	CMobilePhoneBroadcastIdList* idList2 = CMobilePhoneBroadcastIdList::NewL();

   287 	CleanupStack::PushL(idList2);

   288 

   289 	RMobileBroadcastMessaging::TMobileBroadcastIdType type

   290 	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

   291 	

   292 	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

   293 	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

   294 	                                             expectLtsyData(idList, type);

   295 	FillInBroadcastIdListL(*idList);

   296 	expectLtsyData.SerialiseL(data); 

   297 

   298 	// Open second client

   299 	RTelServer telServer2;

   300 	TInt ret = telServer2.Connect();

   301 	ASSERT_EQUALS(KErrNone, ret);

   302 	CleanupClosePushL(telServer2);

   303 

   304 	RMobilePhone phone2;

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

   306 	ASSERT_EQUALS(KErrNone, ret);

   307 	CleanupClosePushL(phone2);

   308 

   309 	RMobileBroadcastMessaging messaging2;

   310 	err = messaging2.Open(phone2);

   311 	ASSERT_EQUALS(KErrNone, err);

   312 	CleanupClosePushL(messaging2);

   313 

   314 	//-------------------------------------------------------------------------

   315 	// Test A: Test multiple clients requesting RMobileBroadcastMessaging::StoreBroadcastIdListL

   316  	//-------------------------------------------------------------------------

   317 

   318     messaging.StoreBroadcastIdListL(reqStatus, idList, RMobileBroadcastMessaging::EGsmBroadcastId);

   319 	messaging2.StoreBroadcastIdListL(reqStatus2, idList2, RMobileBroadcastMessaging::EGsmBroadcastId);

   320 

   321 	User::WaitForRequest(reqStatus);

   322 	User::WaitForRequest(reqStatus2);

   323 

   324 	AssertMockLtsyStatusL();

   325 

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

   327 	ASSERT_EQUALS(KErrNotSupported, reqStatus2.Int());

   328 

   329 	CleanupStack::PopAndDestroy(8, this); // messaging2, phone2, telServer2, idList2, idList, messaging, data, this

   330 

   331 	}

   332 

   333 

   334 /**

   335 @SYMTestCaseID BA-CTSY-BRMSG-BRM-0005

   336 @SYMComponent  telephony_ctsy

   337 @SYMTestCaseDesc Test support in CTSY for RMobileBroadcastMessaging::StoreBroadcastIdListL with timeout

   338 @SYMTestPriority High

   339 @SYMTestActions Invokes RMobileBroadcastMessaging::StoreBroadcastIdListL and tests for timeout

   340 @SYMTestExpectedResults Pass

   341 @SYMTestType CT

   342 */

   343 void CCTsyBroadcastMessagingFU::TestStoreBroadcastIdListL0005L()

   344 	{

   345 

   346 	OpenEtelServerL(EUseExtendedError);

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

   348 	OpenPhoneL();

   349 

   350 	RBuf8 data;

   351 	CleanupClosePushL(data);

   352 

   353 	RMobileBroadcastMessaging messaging;

   354 	TInt err = messaging.Open(iPhone);

   355 	ASSERT_EQUALS(KErrNone, err);

   356 	CleanupClosePushL(messaging);

   357 

   358 	TRequestStatus reqStatus;

   359 

   360 	CMobilePhoneBroadcastIdList* idList = CMobilePhoneBroadcastIdList::NewL();

   361 	CleanupStack::PushL(idList);

   362 

   363 	RMobileBroadcastMessaging::TMobileBroadcastIdType type

   364 	                              = RMobileBroadcastMessaging::EGsmBroadcastId;

   365 	

   366 	TMockLtsyData2<CMobilePhoneBroadcastIdList*,

   367 	               RMobileBroadcastMessaging::TMobileBroadcastIdType>

   368 	                                             expectLtsyData(idList, type);

   369 	FillInBroadcastIdListL(*idList);

   370 	expectLtsyData.SerialiseL(data); 

   371 

   372 	//-------------------------------------------------------------------------

   373 	// Test A: Test timeout of RMobileBroadcastMessaging::StoreBroadcastIdListL

   374 	//-------------------------------------------------------------------------

   375 

   376 	iMockLTSY.ExpectL(EMobileBroadcastMessagingStoreIdList, data);

   377 

   378 	messaging.StoreBroadcastIdListL(reqStatus, idList, type);

   379 

   380 	User::WaitForRequest(reqStatus);

   381 

   382 	AssertMockLtsyStatusL();

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

   384 

   385 	CleanupStack::PopAndDestroy(4, this); // idList, messaging, data, this

   386 

   387 	}

   388 

   389 /**

   390 @SYMTestCaseID BA-CTSY-BRMSG-RMPBLN-0001

   391 @SYMComponent  telephony_ctsy

   392 @SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhoneBroadcastIdList::Start

   393 @SYMTestPriority High

   394 @SYMTestActions Invokes CRetrieveMobilePhoneBroadcastIdList::Start

   395 @SYMTestExpectedResults Pass

   396 @SYMTestType CT

   397 */

   398 void CCTsyBroadcastMessagingFU::TestStart0001L()

   399 	{

   400 

   401 	OpenEtelServerL(EUseExtendedError);

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

   403 	OpenPhoneL();

   404 

   405 	CFilteringActiveScheduler scheduler;

   406 	CActiveScheduler::Install(&scheduler);

   407 	

   408 	RMobileBroadcastMessaging messaging;

   409 	TInt err = messaging.Open(iPhone);

   410 	ASSERT_EQUALS(KErrNone, err);

   411 	CleanupClosePushL(messaging);

   412 	

   413 	CRetrieveMobilePhoneBroadcastIdList* retrieveMobilePhoneBroadcastIdList =

   414 	                                    CRetrieveMobilePhoneBroadcastIdList::NewL(messaging);

   415 	CleanupStack::PushL(retrieveMobilePhoneBroadcastIdList);

   416 

   417 	CActiveRetriever::ResetRequestsNumber();

   418 	CActiveRetriever activeMobilePhoneBroadcastIdListRetriever(*retrieveMobilePhoneBroadcastIdList);

   419 	scheduler.AddRetrieverL(activeMobilePhoneBroadcastIdListRetriever);

   420 

   421 	// prepare mockLtsy data

   422 	RMobileBroadcastMessaging::TMobileBroadcastIdType type(RMobileBroadcastMessaging::EGsmBroadcastId);

   423 	TMockLtsyData1<RMobileBroadcastMessaging::TMobileBroadcastIdType> expectLtsyData(type);

   424 	RBuf8 expData;

   425 	CleanupClosePushL(expData);

   426 	expectLtsyData.SerialiseL(expData);

   427 

   428 	CMobilePhoneBroadcastIdList* completeList = CMobilePhoneBroadcastIdList::NewL();

   429 	CleanupStack::PushL(completeList);

   430 	FillInBroadcastIdListL(*completeList);

   431 	

   432 	RBuf8 completeData;

   433 	CleanupClosePushL(completeData);

   434 	TSerializer<CMobilePhoneBroadcastIdList>::SerialiseL(*completeList, completeData);

   435 

   436 

   437 	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(), type);

   438 	activeMobilePhoneBroadcastIdListRetriever.Activate();

   439 	scheduler.StartScheduler();

   440 

   441 	AssertMockLtsyStatusL();

   442 

   443 	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

   444 	ASSERT_EQUALS(KErrNotSupported, activeMobilePhoneBroadcastIdListRetriever.iStatus.Int());

   445 

   446  	//-------------------------------------------------------------------------

   447 	// TEST E: Unsolicited completion of CAsyncRetrieveAuthorizationInfo::Start

   448 	// from LTSY.

   449  	//-------------------------------------------------------------------------

   450 

   451 	TRequestStatus mockLtsyStatus;

   452 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   453 	iMockLTSY.CompleteL(EMobileBroadcastMessagingGetIdListPhase1, KErrNone, completeData);

   454 	User::WaitForRequest(mockLtsyStatus);

   455 	AssertMockLtsyStatusL();

   456 	CleanupStack::PopAndDestroy(5, &messaging); // list, completeData, completeList, expData, retrieveMobilePhoneBroadcastIdList, messaging

   457 	CActiveScheduler::Install(NULL);

   458 	CleanupStack::PopAndDestroy(this);

   459 	

   460 	}

   461 

   462 

   463 /**

   464 @SYMTestCaseID BA-CTSY-BRMSG-RMPBLN-0002

   465 @SYMComponent  telephony_ctsy

   466 @SYMTestCaseDesc Test support in CTSY for cancelling of CRetrieveMobilePhoneBroadcastIdList::Start

   467 @SYMTestPriority High

   468 @SYMTestActions Invokes cancelling of CRetrieveMobilePhoneBroadcastIdList::Start

   469 @SYMTestExpectedResults Pass

   470 @SYMTestType CT

   471 */

   472 void CCTsyBroadcastMessagingFU::TestStart0002L()

   473 	{

   474 

   475 	OpenEtelServerL(EUseExtendedError);

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

   477 	OpenPhoneL();

   478 

   479 	CFilteringActiveScheduler scheduler;

   480 	CActiveScheduler::Install(&scheduler);

   481 	

   482 	RMobileBroadcastMessaging messaging;

   483 	TInt err = messaging.Open(iPhone);

   484 	ASSERT_EQUALS(KErrNone, err);

   485 	CleanupClosePushL(messaging);

   486 	

   487 	CRetrieveMobilePhoneBroadcastIdList* retrieveMobilePhoneBroadcastIdList =

   488 	                                      CRetrieveMobilePhoneBroadcastIdList::NewL(messaging);

   489 	CleanupStack::PushL(retrieveMobilePhoneBroadcastIdList);

   490 

   491 	CActiveRetriever::ResetRequestsNumber();

   492 	CActiveRetriever activeMobilePhoneBroadcastIdListRetriever(*retrieveMobilePhoneBroadcastIdList);

   493 	scheduler.AddRetrieverL(activeMobilePhoneBroadcastIdListRetriever);

   494 

   495 	// prepare mockLtsy data

   496 	RMobileBroadcastMessaging::TMobileBroadcastIdType type(RMobileBroadcastMessaging::EGsmBroadcastId);

   497 	TMockLtsyData1<RMobileBroadcastMessaging::TMobileBroadcastIdType> expectLtsyData(type);

   498 	RBuf8 expData;

   499 	CleanupClosePushL(expData);

   500 	expectLtsyData.SerialiseL(expData);

   501 

   502 	CMobilePhoneBroadcastIdList* completeList = CMobilePhoneBroadcastIdList::NewL();

   503 	CleanupStack::PushL(completeList);

   504 	FillInBroadcastIdListL(*completeList);

   505 	

   506 	RBuf8 completeData;

   507 	CleanupClosePushL(completeData);

   508 	TSerializer<CMobilePhoneBroadcastIdList>::SerialiseL(*completeList, completeData);

   509 

   510  	//-------------------------------------------------------------------------

   511 	// Test cancelling of CRetrieveMobilePhoneBroadcastIdList::Start

   512  	//-------------------------------------------------------------------------

   513  	

   514 	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(), type);

   515 	activeMobilePhoneBroadcastIdListRetriever.Activate(CActiveRetriever::ECaseGeneralCancelCase);

   516 	scheduler.StartScheduler();

   517 

   518 	AssertMockLtsyStatusL();

   519 

   520 	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

   521 	ASSERT_EQUALS(KErrCancel, activeMobilePhoneBroadcastIdListRetriever.iStatus.Int());

   522 	

   523 

   524 	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(),

   525 	                                          RMobileBroadcastMessaging::EGsmBroadcastId);

   526 	activeMobilePhoneBroadcastIdListRetriever.Activate(CActiveRetriever::ECasePhase2Cancel);

   527 	scheduler.StartScheduler();

   528 

   529 	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

   530 	ASSERT_EQUALS(KErrNotSupported, activeMobilePhoneBroadcastIdListRetriever.iStatus.Int());

   531 	

   532 	AssertMockLtsyStatusL();

   533 

   534 	CleanupStack::PopAndDestroy(5); // completeData, completeList, expData, retrieveMobilePhoneBroadcastIdList, messaging

   535 	CActiveScheduler::Install(NULL);

   536 	CleanupStack::PopAndDestroy(this);

   537 	

   538 	}

   539 

   540 

   541 /**

   542 @SYMTestCaseID BA-CTSY-BRMSG-RMPBLN-0004

   543 @SYMComponent  telephony_ctsy

   544 @SYMTestCaseDesc Test support in CTSY for multiple client requests to CRetrieveMobilePhoneBroadcastIdList::Start

   545 @SYMTestPriority High

   546 @SYMTestActions Invokes multiple client requests to CRetrieveMobilePhoneBroadcastIdList::Start

   547 @SYMTestExpectedResults Pass

   548 @SYMTestType CT

   549 */

   550 void CCTsyBroadcastMessagingFU::TestStart0004L()

   551 	{

   552 					

   553 	OpenEtelServerL(EUseExtendedError);

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

   555 	OpenPhoneL();

   556 

   557 	CFilteringActiveScheduler scheduler;

   558 	CActiveScheduler::Install(&scheduler);

   559 	

   560 	RMobileBroadcastMessaging messaging;

   561 	TInt err = messaging.Open(iPhone);

   562 	ASSERT_EQUALS(KErrNone, err);

   563 	CleanupClosePushL(messaging);

   564 	

   565 	CRetrieveMobilePhoneBroadcastIdList* retrieveMobilePhoneBroadcastIdList =

   566 	                                             CRetrieveMobilePhoneBroadcastIdList::NewL(messaging);

   567 	CleanupStack::PushL(retrieveMobilePhoneBroadcastIdList);

   568 

   569 	CActiveRetriever::ResetRequestsNumber();

   570 	CActiveRetriever activeMobilePhoneBroadcastIdListRetriever(*retrieveMobilePhoneBroadcastIdList);

   571 	scheduler.AddRetrieverL(activeMobilePhoneBroadcastIdListRetriever);

   572 

   573 	// Open second client

   574 	RTelServer telServer2;

   575 	TInt ret = telServer2.Connect();

   576 	ASSERT_EQUALS(KErrNone, ret);

   577 	CleanupClosePushL(telServer2);

   578 

   579 	RMobilePhone phone2;

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

   581 	ASSERT_EQUALS(KErrNone, ret);

   582 	CleanupClosePushL(phone2);

   583 

   584 	RMobileBroadcastMessaging messaging2;

   585 	err = messaging2.Open(phone2);

   586 	ASSERT_EQUALS(KErrNone, err);

   587 	CleanupClosePushL(messaging2);

   588 	

   589 	CRetrieveMobilePhoneBroadcastIdList* retrieveMobilePhoneBroadcastIdList2 =

   590 	                                              CRetrieveMobilePhoneBroadcastIdList::NewL(messaging2);

   591 	CleanupStack::PushL(retrieveMobilePhoneBroadcastIdList2);

   592 

   593 	CActiveRetriever::ResetRequestsNumber();

   594 	CActiveRetriever activeMobilePhoneBroadcastIdListRetriever2(*retrieveMobilePhoneBroadcastIdList2);

   595 	scheduler.AddRetrieverL(activeMobilePhoneBroadcastIdListRetriever2);

   596 

   597 	// prepare mockLtsy data

   598 	RMobileBroadcastMessaging::TMobileBroadcastIdType type(RMobileBroadcastMessaging::EGsmBroadcastId);

   599 	TMockLtsyData1<RMobileBroadcastMessaging::TMobileBroadcastIdType> expectLtsyData(type);

   600 	RBuf8 expData;

   601 	CleanupClosePushL(expData);

   602 	expectLtsyData.SerialiseL(expData);

   603 

   604 	CMobilePhoneBroadcastIdList* completeList = CMobilePhoneBroadcastIdList::NewL();

   605 	CleanupStack::PushL(completeList);

   606 	FillInBroadcastIdListL(*completeList);

   607 	

   608 	RBuf8 completeData;

   609 	CleanupClosePushL(completeData);

   610 	TSerializer<CMobilePhoneBroadcastIdList>::SerialiseL(*completeList, completeData);

   611 

   612 	//-------------------------------------------------------------------------

   613 	// Test A: Test multiple clients requesting CRetrieveMobilePhoneBroadcastIdList::Start

   614  	//-------------------------------------------------------------------------

   615 

   616 	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(),

   617 	                                          RMobileBroadcastMessaging::EGsmBroadcastId);

   618 	activeMobilePhoneBroadcastIdListRetriever.Activate();

   619 

   620 	retrieveMobilePhoneBroadcastIdList2->Start(activeMobilePhoneBroadcastIdListRetriever2.Status(),

   621 	                                           RMobileBroadcastMessaging::ECdmaBroadcastId);

   622 	activeMobilePhoneBroadcastIdListRetriever2.Activate();

   623 

   624 	scheduler.StartScheduler();

   625 

   626 	AssertMockLtsyStatusL();

   627 

   628 	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

   629 	ASSERT_EQUALS(KErrNotSupported, activeMobilePhoneBroadcastIdListRetriever.iStatus.Int());

   630 	ASSERT_EQUALS(KErrNotSupported, activeMobilePhoneBroadcastIdListRetriever2.iStatus.Int());

   631 	

   632 

   633 	CleanupStack::PopAndDestroy(9, &messaging); // completeData, completeList, expData

   634 	                    // retrieveMobilePhoneBroadcastIdList2, messaging2, phone2, telServer2

   635 	                    // retrieveMobilePhoneBroadcastIdList, messaging

   636 	CActiveScheduler::Install(NULL);

   637 	CleanupStack::PopAndDestroy(this);

   638 

   639 	}

   640 

   641 

   642 /**

   643 @SYMTestCaseID BA-CTSY-BRMSG-RMPBLN-0005

   644 @SYMComponent  telephony_ctsy

   645 @SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhoneBroadcastIdList::Start with timeout

   646 @SYMTestPriority High

   647 @SYMTestActions Invokes CRetrieveMobilePhoneBroadcastIdList::Start and tests for timeout

   648 @SYMTestExpectedResults Pass

   649 @SYMTestType CT

   650 */

   651 void CCTsyBroadcastMessagingFU::TestStart0005L()

   652 	{

   653 

   654 	OpenEtelServerL(EUseExtendedError);

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

   656 	OpenPhoneL();

   657 

   658 	CFilteringActiveScheduler scheduler;

   659 	CActiveScheduler::Install(&scheduler);

   660 	

   661 	RMobileBroadcastMessaging messaging;

   662 	TInt err = messaging.Open(iPhone);

   663 	ASSERT_EQUALS(KErrNone, err);

   664 	CleanupClosePushL(messaging);

   665 	

   666 	CRetrieveMobilePhoneBroadcastIdList* retrieveMobilePhoneBroadcastIdList =

   667 	                                    CRetrieveMobilePhoneBroadcastIdList::NewL(messaging);

   668 	CleanupStack::PushL(retrieveMobilePhoneBroadcastIdList);

   669 

   670 	CActiveRetriever::ResetRequestsNumber();

   671 	CActiveRetriever activeMobilePhoneBroadcastIdListRetriever(*retrieveMobilePhoneBroadcastIdList);

   672 	scheduler.AddRetrieverL(activeMobilePhoneBroadcastIdListRetriever);

   673 

   674 	// prepare mockLtsy data

   675 	RMobileBroadcastMessaging::TMobileBroadcastIdType type(RMobileBroadcastMessaging::EGsmBroadcastId);

   676 	TMockLtsyData1<RMobileBroadcastMessaging::TMobileBroadcastIdType> expectLtsyData(type);

   677 	RBuf8 expData;

   678 	CleanupClosePushL(expData);

   679 	expectLtsyData.SerialiseL(expData);

   680 

   681 	//-------------------------------------------------------------------------

   682 	// TEST C: Successful completion request of

   683 	// CRetrieveMobilePhoneBroadcastIdList::Start.

   684 	//-------------------------------------------------------------------------

   685 

   686 	retrieveMobilePhoneBroadcastIdList->Start(activeMobilePhoneBroadcastIdListRetriever.Status(), type);

   687 	activeMobilePhoneBroadcastIdListRetriever.Activate();

   688 	scheduler.StartScheduler();

   689 

   690 	AssertMockLtsyStatusL();

   691 

   692 	ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber());

   693 	ASSERT_EQUALS(KErrNotSupported, activeMobilePhoneBroadcastIdListRetriever.iStatus.Int());

   694 

   695 	CleanupStack::PopAndDestroy(3, &messaging); // expData, retrieveMobilePhoneBroadcastIdList, messaging

   696 	CActiveScheduler::Install(NULL);

   697 	CleanupStack::PopAndDestroy(this);

   698 	

   699 	}

   700 

   701 

   702 /**

   703 @SYMTestCaseID BA-CTSY-BRMSG-BRM-0001

   704 @SYMComponent  telephony_ctsy

   705 @SYMTestCaseDesc Test support in CTSY for RMobileBroadcastMessaging::ReceiveMessage

   706 @SYMTestPriority High

   707 @SYMTestActions Invokes RMobileBroadcastMessaging::ReceiveMessage

   708 @SYMTestExpectedResults Pass

   709 @SYMTestType CT

   710 */

   711 void CCTsyBroadcastMessagingFU::TestReceiveMessage0001L()

   712 	{

   713 

   714 	OpenEtelServerL(EUseExtendedError);

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

   716 	OpenPhoneL();

   717 

   718 	RBuf8 data;

   719 	CleanupClosePushL(data);

   720 

   721  	//-------------------------------------------------------------------------

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

   723  	//-------------------------------------------------------------------------

   724 

   725 	RMobileBroadcastMessaging messaging;

   726 	TInt err = messaging.Open(iPhone);

   727 	ASSERT_EQUALS(KErrNone, err);

   728 	CleanupClosePushL(messaging);

   729 

   730 	TCbsCbmiAndLangAndFilter expectData;

   731 	expectData.iSetting = RMobileBroadcastMessaging::EBroadcastAcceptAll;

   732 	expectData.iCbmiStorage = KNullDesC; // deprecated

   733 	expectData.iLanguageStorage = KNullDesC; // deprecated

   734 

   735 	TMockLtsyData1<TCbsCbmiAndLangAndFilter> expectLtsyData(expectData);

   736     expectLtsyData.SerialiseL(data); 

   737     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessage, data, KErrNotSupported);

   738 

   739 	TRequestStatus reqStatus;

   740 	RMobileBroadcastMessaging::TBroadcastPageData msgData;

   741 	RMobileBroadcastMessaging::TMobileBroadcastAttributesV1 attributes;

   742 	RMobileBroadcastMessaging::TMobileBroadcastAttributesV1Pckg msgAttributes(attributes);

   743 	messaging.ReceiveMessage(reqStatus, msgData, msgAttributes);

   744 	

   745 	User::WaitForRequest(reqStatus);

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

   747 

   748 	AssertMockLtsyStatusL();

   749 

   750 	//-------------------------------------------------------------------------

   751 	// TEST B: failure on completion of pending request from LTSY->CTSY

   752  	//-------------------------------------------------------------------------

   753 

   754     data.Close();

   755     expectLtsyData.SerialiseL(data); 

   756     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessage, data);

   757 

   758     iMockLTSY.CompleteL(EMobileBroadcastMessagingReceiveMessage, KErrGeneral);

   759 

   760 	messaging.ReceiveMessage(reqStatus, msgData, msgAttributes);

   761 	

   762 	User::WaitForRequest(reqStatus);

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

   764 

   765 	AssertMockLtsyStatusL();

   766 

   767 	//-------------------------------------------------------------------------

   768 	// TEST B: increase coverage (completion with EMmTsyGsmBroadcastNotifyMessageReceived IPC)

   769  	//-------------------------------------------------------------------------

   770 

   771     data.Close();

   772     expectLtsyData.SerialiseL(data); 

   773     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessage, data);

   774 

   775 	TGsmCbsMsg cbsMsg;

   776 	cbsMsg.iCbsMsg.Copy(_L("Cool!"));

   777 	TMockLtsyData1<TGsmCbsMsg> completeLtsyData(cbsMsg);

   778 	data.Close();

   779     completeLtsyData.SerialiseL(data); 

   780     iMockLTSY.CompleteL(EMmTsyGsmBroadcastNotifyMessageReceived, KErrGeneral, data);

   781 

   782 	messaging.ReceiveMessage(reqStatus, msgData, msgAttributes);

   783 	

   784 	User::WaitForRequest(reqStatus);

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

   786 

   787 	AssertMockLtsyStatusL();

   788 

   789 	//-------------------------------------------------------------------------

   790 	// TEST B: increase coverage (completion with EMmTsyWcdmaBroadcastNotifyMessageReceived IPC)

   791  	//-------------------------------------------------------------------------

   792 

   793     data.Close();

   794     expectLtsyData.SerialiseL(data); 

   795     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessage, data);

   796 

   797     iMockLTSY.CompleteL(EMmTsyWcdmaBroadcastNotifyMessageReceived, KErrGeneral, KNullDesC8);

   798 

   799 	RMobileBroadcastMessaging::TMobileBroadcastAttributesV2 wcdmaAttributes;

   800 	RMobileBroadcastMessaging::TMobileBroadcastAttributesV2Pckg wcdmaMsgAttributes(wcdmaAttributes);

   801 	messaging.ReceiveMessage(reqStatus, msgData, wcdmaMsgAttributes);

   802 	

   803 	User::WaitForRequest(reqStatus);

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

   805 

   806 	AssertMockLtsyStatusL();

   807 

   808  	//-------------------------------------------------------------------------

   809 	// TEST C: Successful completion request of

   810 	// RMobileBroadcastMessaging::ReceiveMessage when result is not cached.

   811  	//-------------------------------------------------------------------------

   812 

   813     data.Close();

   814     expectLtsyData.SerialiseL(data); 

   815     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessage, data);

   816 

   817     iMockLTSY.CompleteL(EMobileBroadcastMessagingReceiveMessage, KErrNone);

   818 

   819     data.Close();

   820     completeLtsyData.SerialiseL(data); 

   821     iMockLTSY.CompleteL(EMmTsyGsmBroadcastNotifyMessageReceived, KErrNone, data);

   822 

   823 	messaging.ReceiveMessage(reqStatus, msgData, msgAttributes);

   824 	

   825 	User::WaitForRequest(reqStatus);

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

   827 	ASSERT_EQUALS(cbsMsg.iCbsMsg, msgData);

   828 	TUint32 expectedFlags(RMobileBroadcastMessaging::KBroadcastDataFormat);

   829 	RMobileBroadcastMessaging::TMobileBroadcastDataFormat

   830 	                      expectedFormat(RMobileBroadcastMessaging::EFormatGsmTpdu);

   831 	ASSERT_EQUALS(expectedFlags, attributes.iFlags);

   832 	ASSERT_EQUALS(expectedFormat, attributes.iFormat);

   833 

   834 	AssertMockLtsyStatusL();

   835 

   836 	//-------------------------------------------------------------------------

   837 	// TEST C: increase coverage (completion with multypage message type)

   838  	//-------------------------------------------------------------------------

   839 

   840     expectData.iSetting = RMobileBroadcastMessaging::EBroadcastAcceptNone;

   841     data.Close();

   842     expectLtsyData.SerialiseL(data); 

   843     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessageCancel, data, KErrNotSupported);

   844     

   845     expectData.iSetting = RMobileBroadcastMessaging::EBroadcastAcceptAll;

   846     data.Close();

   847     expectLtsyData.SerialiseL(data);

   848     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessage, data);

   849 

   850 	messaging.ReceiveMessage(reqStatus, msgData, wcdmaMsgAttributes);

   851 

   852 	CArrayPtrFlat<TWcdmaCbsMsg>* wcdmaCbsMsgArray = new ( ELeave ) CArrayPtrFlat<TWcdmaCbsMsg>( 1 );

   853 	CleanupStack::PushL(wcdmaCbsMsgArray);

   854 

   855 	TWcdmaCbsMsg wcdmaCbsMsg0;

   856 	wcdmaCbsMsg0.iWcdmaCbsData.Copy(_L("0cool0"));

   857 	wcdmaCbsMsg0.iSbNumber = 1;

   858 	wcdmaCbsMsg0.iNumberOfPages = 2;

   859 	wcdmaCbsMsg0.iMessageType = 3;

   860 	wcdmaCbsMsg0.iMessageId = 4;

   861 	wcdmaCbsMsg0.iSerialNum = 5;

   862 	wcdmaCbsMsg0.iDCS = 6;

   863 	wcdmaCbsMsg0.iInfoLength = wcdmaCbsMsg0.iWcdmaCbsData.Length();

   864 	wcdmaCbsMsgArray->AppendL(&wcdmaCbsMsg0, 1);

   865     

   866 	TUint8 wcdmaPageNumber(1);

   867 	TMockLtsyData2<CArrayPtrFlat< TWcdmaCbsMsg >*, TUint8> completeWcdmaLtsyData(wcdmaCbsMsgArray, wcdmaPageNumber);

   868 	data.Close();

   869 	completeWcdmaLtsyData.SerialiseL(data);

   870 

   871 	iMockLTSY.CompleteL(EMobileBroadcastMessagingReceiveMessage, KErrNone);

   872 

   873 	TRequestStatus mockLtsyStatus;

   874 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   875 	iMockLTSY.CompleteL(EMmTsyWcdmaBroadcastNotifyMessageReceived, KErrNone, data);

   876 	User::WaitForRequest(mockLtsyStatus);

   877 	

   878 	User::WaitForRequest(reqStatus);

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

   880 	

   881 	// generate a message from the original message with the page number at the end

   882 	TBuf8<RMobileBroadcastMessaging::KBroadcastPageSize>  messageWithPageNumber;

   883 	messageWithPageNumber.Copy(wcdmaCbsMsg0.iWcdmaCbsData);

   884 	_LIT8(KFormat, "%c");

   885 	TBuf8<2> abc(KFormat);

   886 	// Append pagenumber to end of CBS message     

   887 	messageWithPageNumber.AppendFormat( abc, wcdmaPageNumber);

   888 

   889 	ASSERT_EQUALS(messageWithPageNumber,  msgData);

   890 

   891 	ASSERT_EQUALS(expectedFlags,               wcdmaAttributes.iFlags);

   892 	expectedFormat = RMobileBroadcastMessaging::EFormatWcdmaTpdu;

   893 	ASSERT_EQUALS(expectedFormat,              wcdmaAttributes.iFormat);

   894 	ASSERT_EQUALS(wcdmaCbsMsg0.iNumberOfPages, wcdmaAttributes.iNumberOfPages);

   895 	ASSERT_EQUALS(wcdmaCbsMsg0.iMessageType,   wcdmaAttributes.iMessageType);

   896 	ASSERT_EQUALS(wcdmaCbsMsg0.iMessageId,     wcdmaAttributes.iMessageId);

   897 	ASSERT_EQUALS(wcdmaCbsMsg0.iSerialNum,     wcdmaAttributes.iSerialNum);

   898 	ASSERT_EQUALS(wcdmaCbsMsg0.iDCS,           wcdmaAttributes.iDCS);

   899 

   900 	AssertMockLtsyStatusL();

   901 

   902 	//-------------------------------------------------------------------------

   903 	// TEST C: increase coverage (completion with multypage message type)

   904 	// this time 3 pages

   905  	//-------------------------------------------------------------------------

   906 

   907 	messaging.ReceiveMessage(reqStatus, msgData, wcdmaMsgAttributes);

   908 

   909 	TWcdmaCbsMsg wcdmaCbsMsg1;

   910 	wcdmaCbsMsg1.iWcdmaCbsData.Copy(_L("1cool1"));

   911 	wcdmaCbsMsg1.iSbNumber = 8;

   912 	wcdmaCbsMsg1.iNumberOfPages = 7;

   913 	wcdmaCbsMsg1.iMessageType = 6;

   914 	wcdmaCbsMsg1.iMessageId = 5;

   915 	wcdmaCbsMsg1.iSerialNum = 4;

   916 	wcdmaCbsMsg1.iDCS = 3;

   917 	wcdmaCbsMsg1.iInfoLength = wcdmaCbsMsg1.iWcdmaCbsData.Length();

   918 	wcdmaCbsMsgArray->AppendL(&wcdmaCbsMsg1, 1);

   919 	

   920 	TWcdmaCbsMsg wcdmaCbsMsg2;

   921 	wcdmaCbsMsg2.iWcdmaCbsData.Copy(_L("2cool2"));

   922 	wcdmaCbsMsg2.iSbNumber = 80;

   923 	wcdmaCbsMsg2.iNumberOfPages = 70;

   924 	wcdmaCbsMsg2.iMessageType = 60;

   925 	wcdmaCbsMsg2.iMessageId = 50;

   926 	wcdmaCbsMsg2.iSerialNum = 40;

   927 	wcdmaCbsMsg2.iDCS = 30;

   928 	wcdmaCbsMsg2.iInfoLength = wcdmaCbsMsg2.iWcdmaCbsData.Length();

   929 	wcdmaCbsMsgArray->AppendL(&wcdmaCbsMsg2, 1);

   930 

   931 	wcdmaPageNumber = 3;

   932     data.Close();

   933 	completeWcdmaLtsyData.SerialiseL(data); 

   934 

   935 	iMockLTSY.NotifyTerminated(mockLtsyStatus);	

   936     iMockLTSY.CompleteL(EMmTsyWcdmaBroadcastNotifyMessageReceived, KErrNone, data);

   937 	User::WaitForRequest(mockLtsyStatus);

   938     

   939 	User::WaitForRequest(reqStatus);

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

   941     

   942 	

   943 	ASSERT_EQUALS(messageWithPageNumber,  msgData);

   944 	ASSERT_EQUALS(expectedFlags,               wcdmaAttributes.iFlags);

   945 	expectedFormat = RMobileBroadcastMessaging::EFormatWcdmaTpdu;

   946 	ASSERT_EQUALS(expectedFormat,              wcdmaAttributes.iFormat);

   947 	ASSERT_EQUALS(wcdmaCbsMsg0.iNumberOfPages, wcdmaAttributes.iNumberOfPages);

   948 	ASSERT_EQUALS(wcdmaCbsMsg0.iMessageType,   wcdmaAttributes.iMessageType);

   949 	ASSERT_EQUALS(wcdmaCbsMsg0.iMessageId,     wcdmaAttributes.iMessageId);

   950 	ASSERT_EQUALS(wcdmaCbsMsg0.iSerialNum,     wcdmaAttributes.iSerialNum);

   951 	ASSERT_EQUALS(wcdmaCbsMsg0.iDCS,           wcdmaAttributes.iDCS);

   952 

   953 	AssertMockLtsyStatusL();

   954 

   955  	//-------------------------------------------------------------------------

   956 	// TEST D: RMobileBroadcastMessaging::ReceiveMessage again, this time CTSY

   957 	// will get result from the cache.

   958  	//-------------------------------------------------------------------------

   959 	//-------------------------------------------------------------------------

   960  	// recieve 2nd page

   961  	//-------------------------------------------------------------------------

   962 

   963 	messaging.ReceiveMessage(reqStatus, msgData, wcdmaMsgAttributes);

   964 

   965 	User::WaitForRequest(reqStatus);

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

   967 

   968     messageWithPageNumber.Copy(wcdmaCbsMsg1.iWcdmaCbsData);

   969     messageWithPageNumber.AppendFormat( abc, 2);

   970 

   971     ASSERT_EQUALS(messageWithPageNumber,  msgData);

   972 	ASSERT_EQUALS(expectedFlags,               wcdmaAttributes.iFlags);

   973 	ASSERT_EQUALS(expectedFormat,              wcdmaAttributes.iFormat);

   974 	ASSERT_EQUALS(wcdmaCbsMsg1.iNumberOfPages, wcdmaAttributes.iNumberOfPages);

   975 	ASSERT_EQUALS(wcdmaCbsMsg1.iMessageType,   wcdmaAttributes.iMessageType);

   976 	ASSERT_EQUALS(wcdmaCbsMsg1.iMessageId,     wcdmaAttributes.iMessageId);

   977 	ASSERT_EQUALS(wcdmaCbsMsg1.iSerialNum,     wcdmaAttributes.iSerialNum);

   978 	ASSERT_EQUALS(wcdmaCbsMsg1.iDCS,           wcdmaAttributes.iDCS);

   979 

   980 	AssertMockLtsyStatusL();

   981 

   982  	//-------------------------------------------------------------------------

   983  	// recieve 3rd page

   984  	//-------------------------------------------------------------------------

   985 

   986 	messaging.ReceiveMessage(reqStatus, msgData, wcdmaMsgAttributes);

   987 

   988 	User::WaitForRequest(reqStatus);

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

   990     messageWithPageNumber.Copy(wcdmaCbsMsg2.iWcdmaCbsData);

   991     messageWithPageNumber.AppendFormat( abc, 3);

   992 	ASSERT_EQUALS(messageWithPageNumber,  msgData);

   993 	ASSERT_EQUALS(expectedFlags,               wcdmaAttributes.iFlags);

   994 	ASSERT_EQUALS(expectedFormat,              wcdmaAttributes.iFormat);

   995 	ASSERT_EQUALS(wcdmaCbsMsg2.iNumberOfPages, wcdmaAttributes.iNumberOfPages);

   996 	ASSERT_EQUALS(wcdmaCbsMsg2.iMessageType,   wcdmaAttributes.iMessageType);

   997 	ASSERT_EQUALS(wcdmaCbsMsg2.iMessageId,     wcdmaAttributes.iMessageId);

   998 	ASSERT_EQUALS(wcdmaCbsMsg2.iSerialNum,     wcdmaAttributes.iSerialNum);

   999 	ASSERT_EQUALS(wcdmaCbsMsg2.iDCS,           wcdmaAttributes.iDCS);

  1000 

  1001 	AssertMockLtsyStatusL();

  1002 

  1003  	//-------------------------------------------------------------------------

  1004 	// TEST E: Unsolicited completion of RMobileBroadcastMessaging::ReceiveMessage

  1005 	// from LTSY.

  1006  	//-------------------------------------------------------------------------

  1007 

  1008 	iMockLTSY.NotifyTerminated(reqStatus);	

  1009     iMockLTSY.CompleteL(EMobileBroadcastMessagingReceiveMessage, KErrNone);

  1010 	User::WaitForRequest(reqStatus);

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

  1012 	AssertMockLtsyStatusL();

  1013 

  1014  	//-------------------------------------------------------------------------

  1015 	// TEST E: increase coverage (completion with EMmTsyGsmBroadcastNotifyMessageReceived IPC)

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

  1017 

  1018 	iMockLTSY.NotifyTerminated(reqStatus);	

  1019 	data.Close();

  1020     completeLtsyData.SerialiseL(data); 

  1021     iMockLTSY.CompleteL(EMmTsyGsmBroadcastNotifyMessageReceived, KErrNone, data);

  1022 	User::WaitForRequest(reqStatus);

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

  1024 	AssertMockLtsyStatusL();

  1025 

  1026  	//-------------------------------------------------------------------------

  1027 	// TEST E: increase coverage (completion with EMmTsyWcdmaBroadcastNotifyMessageReceived IPC)

  1028  	//-------------------------------------------------------------------------

  1029 

  1030 	iMockLTSY.NotifyTerminated(reqStatus);	

  1031 	data.Close();

  1032     completeWcdmaLtsyData.SerialiseL(data); 

  1033     iMockLTSY.CompleteL(EMmTsyWcdmaBroadcastNotifyMessageReceived, KErrNone, data);

  1034 	User::WaitForRequest(reqStatus);

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

  1036 	AssertMockLtsyStatusL();

  1037 

  1038 	CleanupStack::PopAndDestroy(4, this); // wcdmaCbsMsgArray, messaging, data, this

  1039 	

  1040 	}

  1041 

  1042 

  1043 /**

  1044 @SYMTestCaseID BA-CTSY-BRMSG-BRM-0002

  1045 @SYMComponent  telephony_ctsy

  1046 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobileBroadcastMessaging::ReceiveMessage

  1047 @SYMTestPriority High

  1048 @SYMTestActions Invokes cancelling of RMobileBroadcastMessaging::ReceiveMessage

  1049 @SYMTestExpectedResults Pass

  1050 @SYMTestType CT

  1051 */

  1052 void CCTsyBroadcastMessagingFU::TestReceiveMessage0002L()

  1053 	{

  1054 

  1055 	OpenEtelServerL(EUseExtendedError);

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

  1057 	OpenPhoneL();

  1058 

  1059 	TRequestStatus mockLtsyStatus;

  1060 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

  1061 

  1062 	RBuf8 data;

  1063 	CleanupClosePushL(data);

  1064 

  1065 	RMobileBroadcastMessaging messaging;

  1066 	TInt err = messaging.Open(iPhone);

  1067 	ASSERT_EQUALS(KErrNone, err);

  1068 	CleanupClosePushL(messaging);

  1069 

  1070  	//-------------------------------------------------------------------------

  1071 	// Test cancelling of RMobileBroadcastMessaging::ReceiveMessage

  1072  	//-------------------------------------------------------------------------

  1073  	

  1074 	TCbsCbmiAndLangAndFilter expectData;

  1075 	expectData.iSetting = RMobileBroadcastMessaging::EBroadcastAcceptAll;

  1076 	expectData.iCbmiStorage = KNullDesC; // deprecated

  1077 	expectData.iLanguageStorage = KNullDesC; // deprecated

  1078 

  1079 	TMockLtsyData1<TCbsCbmiAndLangAndFilter> expectLtsyData(expectData);

  1080     expectLtsyData.SerialiseL(data); 

  1081     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessage, data);

  1082 

  1083 	TGsmCbsMsg cbsMsg;

  1084 	cbsMsg.iCbsMsg.Copy(_L("Cool!"));

  1085 	TMockLtsyData1<TGsmCbsMsg> completeLtsyData(cbsMsg);

  1086 	data.Close();

  1087     completeLtsyData.SerialiseL(data); 

  1088     iMockLTSY.CompleteL(EMmTsyGsmBroadcastNotifyMessageReceived, KErrNone, data, 10);

  1089 

  1090 	TRequestStatus reqStatus;

  1091 	RMobileBroadcastMessaging::TBroadcastPageData msgData;

  1092 	RMobileBroadcastMessaging::TMobileBroadcastAttributesV1 attributes;

  1093 	RMobileBroadcastMessaging::TMobileBroadcastAttributesV1Pckg msgAttributes(attributes);

  1094 	messaging.ReceiveMessage(reqStatus, msgData, msgAttributes);

  1095 

  1096 	messaging.CancelAsyncRequest(EMobileBroadcastMessagingReceiveMessage);

  1097 	

  1098 	User::WaitForRequest(reqStatus);

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

  1100 

  1101 	// Wait for completion of iMockLTSY.NotifyTerminated

  1102 	User::WaitForRequest(mockLtsyStatus);

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

  1104 

  1105 	AssertMockLtsyStatusL();

  1106 

  1107  	//-------------------------------------------------------------------------

  1108 	// Test cancelling, increase coverage

  1109  	//-------------------------------------------------------------------------

  1110 

  1111 	// setting environement ( CMmBroadcastTsy::iCbRoutingActivated to ETrue)

  1112 	iMockLTSY.NotifyTerminated(reqStatus);	

  1113     iMockLTSY.CompleteL(EMobileBroadcastMessagingReceiveMessage, KErrNone);

  1114 	User::WaitForRequest(reqStatus);

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

  1116 	AssertMockLtsyStatusL();

  1117 

  1118 	// execute request

  1119 	messaging.ReceiveMessage(reqStatus, msgData, msgAttributes);

  1120 

  1121 	// setting cancel request

  1122 	expectData.iSetting = RMobileBroadcastMessaging::EBroadcastAcceptNone;

  1123 	data.Close();

  1124     expectLtsyData.SerialiseL(data); 

  1125     iMockLTSY.ExpectL(EMobileBroadcastMessagingReceiveMessageCancel, data, KErrNotSupported);

  1126   

  1127 	messaging.CancelAsyncRequest(EMobileBroadcastMessagingReceiveMessage);

  1128 

  1129 	// ReceiveMessage completion

  1130 	User::WaitForRequest(reqStatus);

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

  1132 

  1133 	AssertMockLtsyStatusL();

  1134 

  1135  	//-------------------------------------------------------------------------