1 // Copyright (c) 2008-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 //

    15 

    16 

    17 

    18 /**

    19  @file The TEFUnit test suite for PhonebookControl in the Common TSY.

    20 */

    21 

    22 #include "cctsyphonebookfu.h"

    23 #include <etel.h>

    24 #include <etelmm.h>

    25 #include <et_clsvr.h>

    26 

    27 #include <ctsy/mmtsy_names.h>

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

    29 #include <test/tmockltsydata.h>

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

    31 

    32 #include <ctsy/ltsy/cphonebookentry.h>

    33 

    34 #include <ctsy/ltsy/mltsydispatchsiminterface.h>

    35 #include <ctsy/ltsy/mltsydispatchsmsinterface.h>

    36 

    37 #include "mockltsyindicatorids.h"

    38 

    39 #include <ctsy/ltsy/cctsydispatchercallback.h>

    40 

    41 #include "listretrieverao.h"

    42 

    43 const TInt KReadBufLength = 400;

    44 const TInt KMaxTextLength = 50;

    45 const TInt KNewMaxTextLength = 55;

    46 const TInt KMaxNumberLength = 25;

    47 const TInt KNumberOfEnries = 100;

    48 

    49 CTestSuite* CCTsyPhonebookFU::CreateSuiteL(const TDesC& aName)

    50 	{

    51 	SUB_SUITE;

    52 

    53 	//add use-case tests

    54 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0001L);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0002L);

    56 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0003L);

    57 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0004L);

    58 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0005L);

    59 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0006L);

    60 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0007L);

    61 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0008L);

    62 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0009L);

    63 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0010L);

    64 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0011L);

    65 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0012L);

    66 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0013L);

    67 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0014L);

    68 	//add other unit tests

    69 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0001L);

    70 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0002L);

    71 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0003L);

    72 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0004L);

    73 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0005L);

    74 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0006L);

    75 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0007L);

    76 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0008L);

    77 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0009L);

    78 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0010L);

    79 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0011L);

    80 	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0012L);

    81 

    82 	END_SUITE;

    83 	}

    84 

    85 

    86 //

    87 // Use-case tests

    88 //

    89 

    90 /**

    91 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0001

    92 @SYMComponent telephony_ctsy

    93 @SYMTestCaseDesc Test support in CTSY for Opening all supported phonebooks

    94 @SYMTestPriority High

    95 @SYMTestActions Opens caching and non caching phonebooks in different orders

    96 @SYMTestExpectedResults Pass

    97 @SYMTestType CT

    98 */

    99 void CCTsyPhonebookFU::TestUseCase0001L()

   100 	{

   101 	CreateEntriesAndStoreDataL();

   102 	

   103 	/*********************Open all phone books - caching PB first*****************************/

   104 

   105 	OpenEtelServerL(EUseExtendedError);

   106 

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

   108 	OpenPhoneL();

   109 	

   110 	RArray<DispatcherPhonebook::TPhonebook> names;

   111 	CleanupClosePushL(names);

   112 	names.AppendL(DispatcherPhonebook::EIccAdn); 

   113 	names.AppendL(DispatcherPhonebook::EIccFdn);

   114 	names.AppendL(DispatcherPhonebook::EIccBdn); 

   115 	names.AppendL(DispatcherPhonebook::EIccSdn);

   116 	names.AppendL(DispatcherPhonebook::EIccVmb); 

   117 	names.AppendL(DispatcherPhonebook::EIccMbdn);

   118 

   119 	RMmCustomAPI customApi;

   120 	OpenCustomApiLC(customApi);

   121 	

   122 	TInt nameCount = names.Count();

   123 	for(TInt i = 0; i < nameCount; ++i)

   124 		{

   125 		RMobilePhoneBookStore phonebookStore;

   126 		CleanupClosePushL(phonebookStore);

   127 		OpenPhoneBookL(names[i], phonebookStore, customApi);

   128 		}

   129 

   130 	CleanupStack::PopAndDestroy(nameCount); //the phonebooks

   131 	CleanupStack::PopAndDestroy(&customApi);

   132 	CleanupStack::PopAndDestroy(&names);

   133 	CleanupStack::PopAndDestroy(this);

   134 

   135 	/*********************Open all phone books - non caching PB first*****************************/

   136 	

   137 	OpenEtelServerL(EUseExtendedError);

   138 

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

   140 	OpenPhoneL();

   141 	

   142 	

   143 	CleanupClosePushL(names);

   144 	names.AppendL(DispatcherPhonebook::EIccBdn); 

   145 	names.AppendL(DispatcherPhonebook::EIccFdn); 

   146 	names.AppendL(DispatcherPhonebook::EIccAdn); 

   147 	names.AppendL(DispatcherPhonebook::EIccSdn);

   148 	names.AppendL(DispatcherPhonebook::EIccVmb); 

   149 	names.AppendL(DispatcherPhonebook::EIccMbdn);

   150 

   151 	OpenCustomApiLC(customApi);

   152 	

   153 	nameCount = names.Count();

   154 	for(TInt j = 0; j < nameCount; ++j)

   155 		{

   156 		RMobilePhoneBookStore phonebookStore;

   157 		CleanupClosePushL(phonebookStore);

   158 		OpenPhoneBookL(names[j], phonebookStore, customApi);

   159 		}

   160 

   161 	CleanupStack::PopAndDestroy(nameCount); //the phonebooks

   162 	CleanupStack::PopAndDestroy(&customApi);

   163 	CleanupStack::PopAndDestroy(&names);

   164 	CleanupStack::PopAndDestroy(this);

   165 	}

   166 

   167 /**

   168 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0002

   169 @SYMComponent telephony_ctsy

   170 @SYMTestCaseDesc Test support in CTSY for Opening all supported phonebooks interleaving the cache completes

   171 @SYMTestPriority High

   172 @SYMTestActions Open several phonebooks completing the cache operations between non caching phonebooks

   173 being opened.

   174 @SYMTestExpectedResults Pass

   175 @SYMTestType CT

   176 */

   177 void CCTsyPhonebookFU::TestUseCase0002L()

   178 	{

   179 	OpenEtelServerL(EUseExtendedError);

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

   181 

   182 	OpenPhoneL();

   183 	

   184 	CreateEntriesAndStoreDataL();

   185 	

   186 	RMmCustomAPI customApi;

   187 	OpenCustomApiLC(customApi);

   188 

   189 	TRequestStatus requestStatus;

   190 

   191 	//repeat to test stored CTSY pointers are reset to NULL in the dispatcher

   192 	for(TInt i = 0; i < 2; ++i)

   193 		{

   194 		RMobilePhoneBookStore adnPhoneBookStore;

   195 		CleanupClosePushL(adnPhoneBookStore);

   196 

   197 		RMobilePhoneBookStore fdnPhoneBookStore;

   198 		CleanupClosePushL(fdnPhoneBookStore);

   199 

   200 		RMobilePhoneBookStore bdnPhoneBookStore;

   201 		CleanupClosePushL(bdnPhoneBookStore);

   202 

   203 		RMobilePhoneBookStore sdnPhoneBookStore;

   204 		CleanupClosePushL(sdnPhoneBookStore);

   205 

   206 		RMobilePhoneBookStore vmbPhoneBookStore;

   207 		CleanupClosePushL(vmbPhoneBookStore);

   208 

   209 		OpenCachingPhoneBookL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,KErrNone);

   210 

   211 		OpenNonCachingPhoneBookL(DispatcherPhonebook::EIccVmb,vmbPhoneBookStore,KErrNone);

   212 

   213 		OpenCachingPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,KErrNone);

   214 	

   215 		OpenNonCachingPhoneBookL(DispatcherPhonebook::EIccBdn,bdnPhoneBookStore,KErrNone);

   216 

   217 		//Custom API can only wait on one phonebook at a time.

   218 		TName adnPhonebookName(PhonebookName(DispatcherPhonebook::EIccAdn));

   219 		customApi.NotifyPndCacheReady(requestStatus,adnPhonebookName);

   220 		CompleteCacheL(DispatcherPhonebook::EIccAdn, KErrNone, EFalse);

   221 		User::WaitForRequest(requestStatus);

   222 		AssertMockLtsyStatusL();

   223 		

   224 		OpenNonCachingPhoneBookL(DispatcherPhonebook::EIccSdn,sdnPhoneBookStore,KErrNone);

   225 

   226 		TName fdnPhonebookName(PhonebookName(DispatcherPhonebook::EIccFdn));

   227 		customApi.NotifyPndCacheReady(requestStatus,fdnPhonebookName);

   228 		CompleteCacheL(DispatcherPhonebook::EIccFdn, KErrNone, EFalse);

   229 		User::WaitForRequest(requestStatus);

   230 		AssertMockLtsyStatusL();

   231 

   232 		CleanupStack::PopAndDestroy(&vmbPhoneBookStore);

   233 		CleanupStack::PopAndDestroy(&sdnPhoneBookStore);

   234 		CleanupStack::PopAndDestroy(&bdnPhoneBookStore);

   235 		CleanupStack::PopAndDestroy(&fdnPhoneBookStore);

   236 		CleanupStack::PopAndDestroy(&adnPhoneBookStore);

   237 		}

   238 

   239 	CleanupStack::PopAndDestroy(&customApi);

   240 	

   241 	CleanupStack::PopAndDestroy(this);

   242 	}

   243 	

   244 /**

   245 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0003

   246 @SYMComponent telephony_ctsy

   247 @SYMTestCaseDesc Test Read for all supported phonebooks

   248 @SYMTestPriority High

   249 @SYMTestActions Open the phone book and read all entries from caching and non-caching phonebooks - RMobilePhoneBookStore::Read()

   250 @SYMTestExpectedResults Pass

   251 @SYMTestType CT

   252 */

   253 void CCTsyPhonebookFU::TestUseCase0003L()

   254 	{

   255 	OpenEtelServerL(EUseExtendedError);

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

   257 

   258 	CreateEntriesAndStoreDataL();

   259 

   260 	OpenPhoneL();

   261 	

   262 	ReadL(DispatcherPhonebook::EIccAdn,KErrNone);

   263 	ReadL(DispatcherPhonebook::EIccAdn,KErrGeneral);

   264 

   265 	ReadL(DispatcherPhonebook::EIccFdn,KErrNone);

   266 	ReadL(DispatcherPhonebook::EIccFdn,KErrGeneral);

   267 

   268 	ReadL(DispatcherPhonebook::EIccBdn,KErrNone);

   269 	ReadL(DispatcherPhonebook::EIccBdn,KErrGeneral);

   270 

   271 	ReadL(DispatcherPhonebook::EIccSdn,KErrNone);

   272 	ReadL(DispatcherPhonebook::EIccSdn,KErrGeneral);

   273 

   274 	ReadL(DispatcherPhonebook::EIccVmb,KErrNone);

   275 	ReadL(DispatcherPhonebook::EIccVmb,KErrGeneral);

   276 

   277 	ReadL(DispatcherPhonebook::EIccMbdn,KErrNone);

   278 	ReadL(DispatcherPhonebook::EIccMbdn,KErrGeneral);

   279 	

   280 	CleanupStack::PopAndDestroy(this); // data, this

   281 	}

   282 

   283 /**

   284 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0004

   285 @SYMComponent telephony_ctsy

   286 @SYMTestCaseDesc Test Read for all supported phonebooks interleaving the non-cache reads

   287 @SYMTestPriority High

   288 @SYMTestActions Open all phonebooks and read enties interleaving the reads - RMobilePhoneBookStore::Read()

   289 @SYMTestExpectedResults Pass

   290 @SYMTestType CT

   291 */

   292 void CCTsyPhonebookFU::TestUseCase0004L()

   293 	{

   294 	OpenEtelServerL(EUseExtendedError);

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

   296 

   297 	CreateEntriesAndStoreDataL();

   298 

   299 	OpenPhoneL();

   300 	

   301 	RMmCustomAPI customApi;

   302 	OpenCustomApiLC(customApi);

   303 	

   304 	RMobilePhoneBookStore adnPhoneBookStore;

   305 	CleanupClosePushL(adnPhoneBookStore);

   306 	OpenPhoneBookL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,customApi);

   307 

   308 	RMobilePhoneBookStore fdnPhoneBookStore;

   309 	CleanupClosePushL(fdnPhoneBookStore);

   310 	OpenPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,customApi);

   311 

   312 	RMobilePhoneBookStore bdnPhoneBookStore;

   313 	CleanupClosePushL(bdnPhoneBookStore);

   314 	OpenPhoneBookL(DispatcherPhonebook::EIccBdn,bdnPhoneBookStore,customApi);

   315 

   316 	RMobilePhoneBookStore sdnPhoneBookStore;

   317 	CleanupClosePushL(sdnPhoneBookStore);

   318 	OpenPhoneBookL(DispatcherPhonebook::EIccSdn,sdnPhoneBookStore,customApi);

   319 

   320 	RMobilePhoneBookStore vmbPhoneBookStore;

   321 	CleanupClosePushL(vmbPhoneBookStore);

   322 	OpenPhoneBookL(DispatcherPhonebook::EIccVmb,vmbPhoneBookStore,customApi);

   323 

   324 	RMobilePhoneBookStore mbdnPhoneBookStore;

   325 	CleanupClosePushL(mbdnPhoneBookStore);

   326 	OpenPhoneBookL(DispatcherPhonebook::EIccMbdn,mbdnPhoneBookStore,customApi);

   327 

   328 	//repeat to test stored CTSY pointers are reset to NULL in the dispatcher

   329 	for(TInt i = 0; i < 2; ++i)

   330 		{

   331 		TRequestStatus adnRequestStatus;

   332 		TBuf8<KReadBufLength> adnData;

   333 		ExpectNonCacheReadL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,1,1,adnRequestStatus,adnData);

   334 	

   335 		TRequestStatus fdnRequestStatus;

   336 		TBuf8<KReadBufLength> fdnData;

   337 		ExpectNonCacheReadL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,1,1,fdnRequestStatus,fdnData);

   338 	

   339 		TRequestStatus bdnRequestStatus;

   340 		TBuf8<KReadBufLength> bdnData;

   341 		ExpectNonCacheReadL(DispatcherPhonebook::EIccBdn,bdnPhoneBookStore,1,1,bdnRequestStatus,bdnData);

   342 	

   343 		TRequestStatus sdnRequestStatus;

   344 		TBuf8<KReadBufLength> sdnData;

   345 		ExpectNonCacheReadL(DispatcherPhonebook::EIccSdn,sdnPhoneBookStore,1,1,sdnRequestStatus,sdnData);

   346 	

   347 		TRequestStatus vmbRequestStatus;

   348 		TBuf8<KReadBufLength> vmbData;

   349 		ExpectNonCacheReadL(DispatcherPhonebook::EIccVmb,vmbPhoneBookStore,1,1,vmbRequestStatus,vmbData);

   350 	

   351 		TRequestStatus mbdnRequestStatus;

   352 		TBuf8<KReadBufLength> mbdnData;

   353 		ExpectNonCacheReadL(DispatcherPhonebook::EIccMbdn,mbdnPhoneBookStore,1,1,mbdnRequestStatus,mbdnData);

   354 		

   355 		//we now have size outstanding reads (thus six CTSY pointers held in the dispatcher)

   356 		

   357 		CompleteNonCacheReadL(DispatcherPhonebook::EIccAdn,	1, 1, adnRequestStatus, adnData, KErrNone);

   358 		CompleteNonCacheReadL(DispatcherPhonebook::EIccFdn,	1, 1, fdnRequestStatus, fdnData, KErrNone);

   359 		CompleteNonCacheReadL(DispatcherPhonebook::EIccBdn,	1, 1, bdnRequestStatus, bdnData, KErrNone);

   360 		CompleteNonCacheReadL(DispatcherPhonebook::EIccSdn,	1, 1, sdnRequestStatus, sdnData, KErrNone);

   361 		CompleteNonCacheReadL(DispatcherPhonebook::EIccVmb,	1, 1, vmbRequestStatus, vmbData, KErrNone);

   362 		CompleteNonCacheReadL(DispatcherPhonebook::EIccMbdn,	1, 1, mbdnRequestStatus, mbdnData, KErrNone);

   363 		}

   364 

   365 	CleanupStack::PopAndDestroy(&mbdnPhoneBookStore); //phonebooks

   366 	CleanupStack::PopAndDestroy(&vmbPhoneBookStore); //phonebooks

   367 	CleanupStack::PopAndDestroy(&sdnPhoneBookStore); //phonebooks

   368 	CleanupStack::PopAndDestroy(&bdnPhoneBookStore); //phonebooks

   369 	CleanupStack::PopAndDestroy(&fdnPhoneBookStore); //phonebooks

   370 	CleanupStack::PopAndDestroy(&adnPhoneBookStore); //phonebooks

   371 

   372 	CleanupStack::PopAndDestroy(&customApi);

   373 	

   374 	CleanupStack::PopAndDestroy(this); // data, this

   375 

   376 	}

   377 

   378 /**

   379 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0005

   380 @SYMComponent telephony_ctsy

   381 @SYMTestCaseDesc Test support in CTSY for deleting entries from phonebooks

   382 @SYMTestPriority High

   383 @SYMTestActions Open all phone books (excluding SDN, can't be updated by user) and delete all entires one by one - RMobilePhoneBookStore::Delete()

   384 @SYMTestExpectedResults Pass

   385 @SYMTestType CT

   386 */

   387 void CCTsyPhonebookFU::TestUseCase0005L()

   388 	{

   389 	OpenEtelServerL(EUseExtendedError);

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

   391 

   392 	CreateEntriesAndStoreDataL();

   393 

   394 	OpenPhoneL();

   395 	

   396 	TInt indexToDelete = 1;

   397 	

   398 	DeleteL(DispatcherPhonebook::EIccAdn, indexToDelete, KErrNone);

   399 	DeleteL(DispatcherPhonebook::EIccAdn, indexToDelete, KErrNotFound);

   400 		

   401 	DeleteL(DispatcherPhonebook::EIccFdn, indexToDelete, KErrNone);

   402 	DeleteL(DispatcherPhonebook::EIccFdn, indexToDelete, KErrNotFound);

   403 

   404 	DeleteL(DispatcherPhonebook::EIccBdn, indexToDelete, KErrNone);

   405 	DeleteL(DispatcherPhonebook::EIccBdn, indexToDelete, KErrNotFound);

   406 

   407 	DeleteL(DispatcherPhonebook::EIccVmb, indexToDelete, KErrNone);

   408 	DeleteL(DispatcherPhonebook::EIccVmb, indexToDelete, KErrNotFound);

   409 

   410 	DeleteL(DispatcherPhonebook::EIccMbdn, indexToDelete, KErrNone);

   411 	DeleteL(DispatcherPhonebook::EIccMbdn, indexToDelete, KErrNotFound);

   412 

   413 	CleanupStack::PopAndDestroy(this);

   414 	}

   415 

   416 

   417 /**

   418 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0006

   419 @SYMComponent telephony_ctsy

   420 @SYMTestCaseDesc Test support in CTSY for deleting all entries from phonebooks

   421 @SYMTestPriority High

   422 @SYMTestActions Open all phonebooks (excluding SDN, can't be updated by user) and delete all the entries - RMobilePhoneBookStore::DeleteAll()

   423 @SYMTestExpectedResults Pass

   424 @SYMTestType CT

   425 */

   426 void CCTsyPhonebookFU::TestUseCase0006L()

   427 	{

   428 	OpenEtelServerL(EUseExtendedError);

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

   430 

   431 	CreateEntriesAndStoreDataL();

   432 

   433 	OpenPhoneL();

   434 	

   435 	DeleteAllL(DispatcherPhonebook::EIccAdn, KErrNone);

   436 	DeleteAllL(DispatcherPhonebook::EIccAdn, KErrNotFound);

   437 	

   438 	DeleteAllL(DispatcherPhonebook::EIccFdn, KErrNone);

   439 	DeleteAllL(DispatcherPhonebook::EIccFdn, KErrNotFound);

   440 

   441 	DeleteAllL(DispatcherPhonebook::EIccBdn, KErrNone);

   442 	DeleteAllL(DispatcherPhonebook::EIccBdn, KErrNotFound);

   443 

   444 	DeleteAllL(DispatcherPhonebook::EIccVmb, KErrNone);

   445 	DeleteAllL(DispatcherPhonebook::EIccVmb, KErrNotFound);

   446 

   447 	DeleteAllL(DispatcherPhonebook::EIccMbdn, KErrNone);

   448 	DeleteAllL(DispatcherPhonebook::EIccMbdn, KErrNotFound);

   449 

   450 	CleanupStack::PopAndDestroy(this);

   451 	}

   452 

   453 /**

   454 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0007

   455 @SYMComponent telephony_ctsy

   456 @SYMTestCaseDesc Test support in CTSY for writing entries to all phonebooks

   457 @SYMTestPriority High

   458 @SYMTestActions Open the phonebook and test successful and unsuccessful write operations - RMobilePhoneBookStore::Write()

   459 @SYMTestExpectedResults Pass

   460 @SYMTestType CT

   461 */

   462 void CCTsyPhonebookFU::TestUseCase0007L()

   463 	{

   464 	OpenEtelServerL(EUseExtendedError);

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

   466 

   467 	OpenPhoneL();

   468 	

   469 	CreateEntriesAndStoreDataL();

   470 

   471 	CPhoneBookEntry* phoneBookEntry = CPhoneBookEntry::NewLC();

   472 	phoneBookEntry->SetIndex(5);

   473 	phoneBookEntry->SetFirstName(_L("Symbian5"));

   474 	phoneBookEntry->SetDiallingNumber(_L("123456789"));

   475 	phoneBookEntry->AddEmailAddress(_L("a@a.com"));

   476 	phoneBookEntry->AddSecondName(_L("secondname"));

   477 	phoneBookEntry->AddAdditionalNumber(_L("3874387"));

   478 	

   479 	WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrNone);

   480 	WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrOverflow);

   481 	WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrGsmSimServSneFull);

   482 	WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrGsmSimServAnrFull);

   483 	WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrGsmSimServEmailFull);

   484 	

   485 	WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrNone);

   486 	WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrOverflow);

   487 	WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrGsmSimServSneFull);

   488 	WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrGsmSimServAnrFull);

   489 	WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrGsmSimServEmailFull);

   490 	

   491 	//text and number lengths are only set for adn, fdn, vmb, and mbdn phone books

   492 	//thus we can't do the below tests

   493 //	WriteL(DispatcherPhonebook::EIccBdn, *phoneBookEntry, KErrNone);

   494 //	WriteL(DispatcherPhonebook::EIccSdn, *phoneBookEntry, KErrNone);

   495 

   496 	WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrNone);

   497 	WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrOverflow);

   498 	WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrGsmSimServSneFull);

   499 	WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrGsmSimServAnrFull);

   500 	WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrGsmSimServEmailFull);

   501 

   502 	WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrNone);

   503 	WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrOverflow);

   504 	WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrGsmSimServSneFull);

   505 	WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrGsmSimServAnrFull);

   506 	WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrGsmSimServEmailFull);

   507 

   508 	CleanupStack::PopAndDestroy(phoneBookEntry);

   509 	CleanupStack::PopAndDestroy(this);

   510 	}

   511 

   512 /**

   513 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0008

   514 @SYMComponent telephony_ctsy

   515 @SYMTestCaseDesc Test support in CTSY for sending a Reset Cache IPC

   516 @SYMTestPriority High

   517 @SYMTestActions

   518 @SYMTestExpectedResults Pass

   519 @SYMTestType CT

   520 */

   521 void CCTsyPhonebookFU::TestUseCase0008L()

   522 	{

   523 	OpenEtelServerL(EUseExtendedError);

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

   525 

   526 	RBuf8 data;

   527 	CleanupClosePushL(data);

   528 	

   529 	TRequestStatus requestStatus;

   530 		

   531 	CreateEntriesAndStoreDataL();

   532 	

   533 	OpenPhoneL();

   534 	

   535 	RMmCustomAPI customApi;

   536 	OpenCustomApiLC(customApi);

   537 

   538 	//the custom API state to RMmCustomAPI::ECacheNotReady

   539 		

   540 	RArray<DispatcherPhonebook::TPhonebook> cachingPhonebooks;

   541 	CleanupClosePushL(cachingPhonebooks);

   542 	cachingPhonebooks.AppendL(DispatcherPhonebook::EIccAdn);

   543 	cachingPhonebooks.AppendL(DispatcherPhonebook::EIccFdn);

   544 		

   545 	// test all caching phonebooks

   546 	for(TInt i = 0; i < cachingPhonebooks.Count(); ++i)

   547 		{

   548 		RMobilePhoneBookStore phoneBookStore;

   549 		CleanupClosePushL(phoneBookStore);

   550 		

   551 		OpenPhoneBookL(cachingPhonebooks[i],phoneBookStore,customApi);

   552 		

   553 	    TMockLtsyData1<DispatcherPhonebook::TPhonebook> resetCacheCompLtsyData(cachingPhonebooks[i]);

   554 	    resetCacheCompLtsyData.SerialiseL(data);

   555 		iMockLTSY.CompleteL(KMockLtsyDispatchPhonebookStoreResetCacheIndId,KErrNone,data);

   556 		data.Close();

   557 		

   558 		WaitForMockLTSYTerminated();

   559 		AssertMockLtsyStatusL();

   560 			

   561 		RMmCustomAPI::TPndCacheStatus cacheStatus;

   562 		customApi.GetPndCacheStatus(requestStatus,cacheStatus,PhonebookName(cachingPhonebooks[i]));

   563 		User::WaitForRequest(requestStatus);

   564 		ASSERT_EQUALS(cacheStatus,RMmCustomAPI::ECacheNotReady);

   565 

   566 		// destroying the phonebook store, while one of the caching phonebooks

   567 		// ADN/FDN is in the not-ready state will result in a store cache cancel

   568 		// message being generated by the ctsy

   569 

   570 		TMockLtsyData1<DispatcherPhonebook::TPhonebook> expLtsyData(cachingPhonebooks[i]);

   571 		expLtsyData.SerialiseL(data);

   572 		iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data);

   573 		data.Close();

   574 			

   575 		CleanupStack::PopAndDestroy(&phoneBookStore);

   576 		}

   577 

   578 	CleanupStack::PopAndDestroy(&cachingPhonebooks);

   579 	CleanupStack::PopAndDestroy(&customApi);

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

   581 	}

   582 

   583 /**

   584 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0009

   585 @SYMComponent telephony_ctsy

   586 @SYMTestCaseDesc Test support in CTSY for setting the FDN settings

   587 @SYMTestPriority High

   588 @SYMTestActions

   589 @SYMTestExpectedResults Pass

   590 @SYMTestType CT

   591 */

   592 void CCTsyPhonebookFU::TestUseCase0009L()

   593 	{

   594 	OpenEtelServerL(EUseExtendedError);

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

   596 		

   597 	CreateEntriesAndStoreDataL();

   598 	

   599 	OpenPhoneL();

   600 	

   601 	RMmCustomAPI customApi;

   602 	OpenCustomApiLC(customApi);

   603 	

   604 	RMobilePhoneBookStore phoneBookStore;

   605 	CleanupClosePushL(phoneBookStore);

   606 		

   607 	OpenPhoneBookL(DispatcherPhonebook::EIccFdn,phoneBookStore,customApi);

   608 

   609 	SetFdnInfoL(phoneBookStore,KErrNone);

   610 

   611 	SetFdnInfoL(phoneBookStore,KErrGeneral);

   612 

   613 	// destroying the phonebook store, while one of the caching phonebooks

   614 	// ADN/FDN is in the not-ready state will result in a store cache cancel

   615 	// message being generated by the ctsy

   616 

   617 	RBuf8 data;

   618 	CleanupClosePushL(data);

   619 	

   620 	DispatcherPhonebook::TPhonebook pB = DispatcherPhonebook::EIccFdn;

   621 	TMockLtsyData1<DispatcherPhonebook::TPhonebook> expLtsyData(pB);

   622 	expLtsyData.SerialiseL(data);

   623 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data);

   624 	data.Close();

   625 	CleanupStack::PopAndDestroy(&data);

   626 	

   627 	CleanupStack::PopAndDestroy(&phoneBookStore);

   628 	CleanupStack::PopAndDestroy(&customApi);

   629 	CleanupStack::PopAndDestroy(this); 

   630 	}

   631 

   632 /**

   633 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0010

   634 @SYMComponent telephony_ctsy

   635 @SYMTestCaseDesc Test support in CTSY for getting phonebook store information

   636 @SYMTestPriority High

   637 @SYMTestActions Invokes RMobilePhoneBookStore::GetInfo()

   638 @SYMTestExpectedResults Pass

   639 @SYMTestType CT

   640 */

   641 void CCTsyPhonebookFU::TestUseCase0010L()

   642 	{

   643 	OpenEtelServerL(EUseExtendedError);

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

   645 

   646 	CreateEntriesAndStoreDataL();

   647 

   648 	OpenPhoneL();

   649 

   650 	GetInfoL(DispatcherPhonebook::EIccAdn,KErrNone);

   651 	GetInfoL(DispatcherPhonebook::EIccAdn,KErrGeneral);

   652 

   653 	GetInfoL(DispatcherPhonebook::EIccFdn,KErrNone);

   654 	GetInfoL(DispatcherPhonebook::EIccFdn,KErrGeneral);

   655 

   656 	GetInfoL(DispatcherPhonebook::EIccSdn,KErrNone);

   657 	GetInfoL(DispatcherPhonebook::EIccSdn,KErrGeneral);

   658 

   659 	//causes an ETel Panic - 5 (apparent known defect - Id 40502)

   660 	//GetInfoL(DispatcherPhonebook::EIccBdn,KErrNone);

   661 	//GetInfoL(DispatcherPhonebook::EIccBdn,KErrGeneral);

   662 

   663 	GetInfoL(DispatcherPhonebook::EIccVmb,KErrNone);

   664 	GetInfoL(DispatcherPhonebook::EIccVmb,KErrGeneral);

   665 

   666 	GetInfoL(DispatcherPhonebook::EIccMbdn,KErrNone);

   667 	GetInfoL(DispatcherPhonebook::EIccMbdn,KErrGeneral);

   668 	

   669 	CleanupStack::PopAndDestroy(this); 

   670 	}

   671 

   672 /**

   673 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0011

   674 @SYMComponent telephony_ctsy

   675 @SYMTestCaseDesc Test support in CTSY for getting store information

   676 @SYMTestPriority High

   677 @SYMTestActions RMobilePhone::GetPhoneStoreInfo()

   678 @SYMTestExpectedResults Pass

   679 @SYMTestType CT

   680 */

   681 void CCTsyPhonebookFU::TestUseCase0011L()

   682 	{

   683 	OpenEtelServerL(EUseExtendedError);

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

   685 

   686 	RBuf8 data;

   687 	CleanupClosePushL(data);

   688 

   689 	TRequestStatus requestStatus;

   690 	

   691 	CreateEntriesAndStoreDataL();

   692 	OpenPhoneL();

   693 

   694 	TName storeName(KETelIccAdnPhoneBook);

   695 	RMobilePhoneBookStore::TMobilePhoneStoreInfoV1 bookInfo;

   696 	RMobilePhoneBookStore::TMobilePhoneStoreInfoV1Pckg bookInfoPckg(bookInfo);

   697 

   698 	/********************Test Normal case******************************/

   699 

   700 	

   701 	TDesC* storeNamePtr = &storeName;

   702     TMockLtsyData1<TDesC*> getInfoExpLtsyData(storeNamePtr);

   703     getInfoExpLtsyData.SerialiseL(data);

   704 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,data);

   705 	data.Close();

   706 	

   707 	iPhone.GetPhoneStoreInfo(requestStatus,bookInfoPckg,storeName);

   708 

   709 	RMobilePhoneBookStore::TMobilePhoneStoreInfoV1 compBookInfo;

   710 	compBookInfo.iType 			= RMobilePhoneStore::EPhoneBookStore;

   711 	compBookInfo.iTotalEntries 	= iPhonebookStoreData.iAdnTotalEntries;

   712 	compBookInfo.iUsedEntries 	= iEntries.Count();

   713 	compBookInfo.iCaps 			= 0;

   714 	compBookInfo.iName 			= KETelIccAdnPhoneBook;

   715 	

   716     TMockLtsyData1<RMobilePhoneBookStore::TMobilePhoneStoreInfoV1> getInfoCompLtsyData(compBookInfo);

   717     getInfoCompLtsyData.SerialiseL(data);

   718 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,KErrNone,data);

   719 	data.Close();

   720 	

   721 	User::WaitForRequest(requestStatus);

   722 	ASSERT_EQUALS(requestStatus.Int(),KErrNone)

   723 

   724 	

   725 	ASSERT_EQUALS(compBookInfo.iType, 			bookInfo.iType);

   726 	ASSERT_EQUALS(compBookInfo.iTotalEntries, 	bookInfo.iTotalEntries);

   727 	ASSERT_EQUALS(compBookInfo.iUsedEntries, 	bookInfo.iUsedEntries);

   728 	ASSERT_EQUALS(compBookInfo.iCaps,		 	bookInfo.iCaps);

   729 	ASSERT_EQUALS(compBookInfo.iName, 			bookInfo.iName);

   730 	

   731 	AssertMockLtsyStatusL();

   732 

   733 	/********************Test Error case******************************/

   734 	

   735     getInfoExpLtsyData.SerialiseL(data);

   736 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,data);

   737 	data.Close();

   738 	

   739 	iPhone.GetPhoneStoreInfo(requestStatus,bookInfoPckg,storeName);

   740 

   741 	const TInt KError = KErrGeneral;

   742 	

   743     getInfoCompLtsyData.SerialiseL(data);

   744 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,KError,data);

   745 	data.Close();

   746 	

   747 	User::WaitForRequest(requestStatus);

   748 	ASSERT_EQUALS(requestStatus.Int(),KError)

   749 

   750 	AssertMockLtsyStatusL();

   751 	

   752 	

   753 	CleanupStack::PopAndDestroy(&data); 

   754 	CleanupStack::PopAndDestroy(this); 

   755 	}

   756 

   757 /**

   758 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0012

   759 @SYMComponent telephony_ctsy

   760 @SYMTestCaseDesc Test support in CTSY for a SIM refresh of the Cached phonebooks

   761 @SYMTestPriority High

   762 @SYMTestActions Invokes SIM refresh IPC, 

   763 @SYMTestExpectedResults Pass

   764 @SYMTestType CT

   765 */

   766 void CCTsyPhonebookFU::TestUseCase0012L()

   767 	{

   768 	OpenEtelServerL(EUseExtendedError);

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

   770 	

   771 	CreateEntriesAndStoreDataL();

   772 	OpenPhoneL();

   773 	

   774 	RMmCustomAPI customApi;

   775 	OpenCustomApiLC(customApi);

   776 	

   777 

   778 	//open the caching phonebooks

   779 	RMobilePhoneBookStore adnPhoneBookStore;

   780 	CleanupClosePushL(adnPhoneBookStore);

   781 	OpenPhoneBookL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,customApi);

   782 

   783 	RMobilePhoneBookStore fdnPhoneBookStore;

   784 	CleanupClosePushL(fdnPhoneBookStore);

   785 	OpenPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,customApi);

   786 

   787 	

   788 	//test the refresh

   789 	

   790 	//add a new entry

   791 	CPhoneBookEntry* phoneBookEntry = CPhoneBookEntry::NewLC();

   792 	iEntries.AppendL(phoneBookEntry);

   793 	CleanupStack::Pop(phoneBookEntry); //takes ownership

   794 	phoneBookEntry->SetIndex(5);

   795 	phoneBookEntry->SetFirstName(_L("Symbian4"));

   796 	phoneBookEntry->SetDiallingNumber(_L("897654321"));

   797 	phoneBookEntry->AddEmailAddress(_L("symbian1@symbian.com11"));

   798 	phoneBookEntry->AddSecondName(_L("Phone book311"));

   799 	phoneBookEntry->AddAdditionalNumber(_L("12311"));

   800 

   801 	iPhonebookStoreData.iAdnTotalEntries = iEntries.Count(); 

   802 	iPhonebookStoreData.iFdnTotalEntries = iEntries.Count();

   803 	

   804 	RefreshL(DispatcherPhonebook::EIccAdn);

   805 	//test the refresh changed the CTSY state

   806 	GetInfoFromCtsy(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,iEntries.Count());

   807 	ReadL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,KErrNone);

   808 	

   809 	RefreshL(DispatcherPhonebook::EIccFdn);	

   810 	//test the refresh changed the CTSY state

   811 	GetInfoFromCtsy(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,iEntries.Count());

   812 	ReadL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,KErrNone);

   813 	

   814 	CleanupStack::PopAndDestroy(&fdnPhoneBookStore); 

   815 	CleanupStack::PopAndDestroy(&adnPhoneBookStore);

   816 	CleanupStack::PopAndDestroy(&customApi);

   817 	CleanupStack::PopAndDestroy(this); // data, this

   818 	}

   819 

   820 /**

   821 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0013

   822 @SYMComponent telephony_ctsy

   823 @SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::Write(), RMobileSmsStore::Read(), RMobileSmsStore::GetInfo() and RMobileSmsStore::Delete() 

   824 @SYMTestPriority High

   825 @SYMTestActions Invokes RMobileSmsStore::Write(), RMobileSmsStore::Read(), RMobileSmsStore::GetInfo() and RMobileSmsStore::Delete()

   826 @SYMTestExpectedResults Pass

   827 @SYMTestType CT

   828 */

   829 void CCTsyPhonebookFU::TestUseCase0013L()

   830 	{

   831 	OpenEtelServerL(EUseExtendedError);

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

   833 	OpenPhoneL();

   834 

   835 	TRequestStatus requestStatus;

   836 

   837 	// open the message store

   838 	RMobileSmsMessaging messaging;

   839 	CleanupClosePushL(messaging);

   840 

   841 	RMobileSmsStore smsStore;

   842 	CleanupClosePushL(smsStore);

   843 

   844 	OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore);

   845 

   846 	RBuf8 expData;

   847 	CleanupClosePushL(expData);

   848 

   849 	RBuf8 completeData;

   850 	CleanupClosePushL(completeData);

   851 	

   852 	//-------------------------------------------------------------------------

   853 	// RMobileSmsStore::Write()

   854  	//-------------------------------------------------------------------------

   855 

   856 	TInt index = 0;

   857 

   858 	RMobileSmsStore::TMobileGsmSmsEntryV1 entryV1;

   859 	TPckg<RMobileSmsStore::TMobileGsmSmsEntryV1> pckgEntryV1(entryV1);

   860 		

   861 	entryV1.iServiceCentre.iNumberPlan   = RMobilePhone::ENationalNumberPlan;

   862 	entryV1.iServiceCentre.iTypeOfNumber = RMobilePhone::EAlphanumericNumber;

   863 	entryV1.iServiceCentre.iTelNumber    = _L("TelNumber1");

   864 	entryV1.iMsgData = _L8("Hello, World!");

   865 	entryV1.iMsgStatus = RMobileSmsStore::EStoredMessageUnread;

   866 	entryV1.iIndex = index;

   867 	

   868 	TMockLtsyData1<RMobileSmsStore::TMobileGsmSmsEntryV1> 

   869 			expMockData1(entryV1);

   870 

   871 	TInt location = 0;

   872 	TBool  receivedClass2ToBeResent = ETrue;

   873 

   874 	TMockLtsyData2<TInt, TBool> completeMockData2(location, receivedClass2ToBeResent);

   875 

   876 	expData.Close();

   877 	expMockData1.SerialiseL(expData);

   878 	completeData.Close();

   879 	completeMockData2.SerialiseL(completeData);

   880 

   881 

   882 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData);

   883 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData);

   884 	iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId);

   885 

   886 	smsStore.Write(requestStatus, pckgEntryV1);

   887 

   888     User::WaitForRequest(requestStatus);        

   889 	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

   890 	ASSERT_EQUALS(entryV1.iIndex, location);

   891 	AssertMockLtsyStatusL();

   892 

   893 	//-------------------------------------------------------------------------

   894 	// RMobileSmsStore::Read()

   895  	//-------------------------------------------------------------------------

   896 		

   897 	

   898 	TMockLtsyData1<TInt> mockIndex(index);

   899 	

   900 	DispatcherPhonebook::TSmsData smsData;

   901 	

   902 	smsData.iSmsMsg= _L8("Hello, World!"); 

   903 	smsData.iServiceCentre = _L("ServiceCenter1");

   904 	smsData.iMobileScTON = RMobilePhone::EAlphanumericNumber; 

   905 	smsData.iMobileScNPI = RMobilePhone::ENationalNumberPlan;

   906 	smsData.iMessageStatus = RMobileSmsStore::EStoredMessageUnread;

   907 		

   908 	TMockLtsyData1<DispatcherPhonebook::TSmsData> mockMsg(smsData);

   909 	

   910 	completeData.Close();

   911 	mockMsg.SerialiseL(completeData);

   912 	

   913 	RMobileSmsStore::TMobileGsmSmsEntryV1 entryV1Read;

   914 	entryV1Read.iIndex=index;

   915 	TPckg<RMobileSmsStore::TMobileGsmSmsEntryV1> pckgEntryV1Read(entryV1Read);

   916 	

   917 	TMockLtsyData1<TInt> mockIndexRead(index);

   918 	expData.Close();

   919 	mockIndexRead.SerialiseL(expData);

   920 	

   921 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, expData);

   922 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, KErrNone, completeData);

   923 	

   924 	smsStore.Read(requestStatus, pckgEntryV1Read);

   925 	User::WaitForRequest(requestStatus);        

   926 	AssertMockLtsyStatusL();

   927 	

   928 	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

   929 	ASSERT_EQUALS(0, smsData.iSmsMsg.Compare(entryV1Read.iMsgData));	

   930 	ASSERT_EQUALS(0, smsData.iServiceCentre.Compare(entryV1Read.iServiceCentre.iTelNumber));	

   931 	ASSERT_EQUALS(smsData.iMobileScTON, entryV1Read.iServiceCentre.iTypeOfNumber);	

   932 	ASSERT_EQUALS(smsData.iMobileScNPI, entryV1Read.iServiceCentre.iNumberPlan);	

   933 	ASSERT_EQUALS(RMobileSmsStore::EStoredMessageRead, entryV1Read.iMsgStatus);	

   934 	

   935  	//-------------------------------------------------------------------------

   936 	// RMobileSmsStore::GetInfo()

   937  	//-------------------------------------------------------------------------

   938 	

   939 	TInt totalEntries = 1;

   940 	TInt usedEntries = 0;

   941 	TMockLtsyData2<TInt,TInt> smsStoreGetInfoLtsyData(totalEntries, usedEntries);

   942 	completeData.Close();

   943 	smsStoreGetInfoLtsyData.SerialiseL(completeData);

   944 	

   945 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId);

   946 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, completeData);

   947 

   948 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfoV1;

   949 	TPckg<RMobilePhoneBookStore::TMobilePhoneBookInfoV1> pckgInfoV1(phoneBookInfoV1);

   950 	smsStore.GetInfo(requestStatus, pckgInfoV1);

   951 	User::WaitForRequest(requestStatus);

   952 	AssertMockLtsyStatusL();

   953 	

   954 	ASSERT_EQUALS(requestStatus.Int(),KErrNone);

   955 	ASSERT_EQUALS(phoneBookInfoV1.iTotalEntries, totalEntries);

   956 	ASSERT_EQUALS(phoneBookInfoV1.iUsedEntries, usedEntries);

   957 	

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

   959 	// RMobileSmsStore::Delete()

   960  	//-------------------------------------------------------------------------

   961 	

   962 	TMockLtsyData1<TInt> expMockData1Delete(index);

   963 	expMockData1Delete.SerialiseL(expData);

   964 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, expData);

   965 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, KErrNone);

   966 	

   967 	smsStore.Delete(requestStatus, index);

   968 

   969 	User::WaitForRequest(requestStatus);        

   970 	

   971 	AssertMockLtsyStatusL();

   972 	ASSERT_EQUALS(KErrNone, requestStatus.Int());

   973 	

   974 	CleanupStack::PopAndDestroy(5, this); // expData, completeData, 

   975 	                                      // smsStore, messaging, this

   976 	}

   977 

   978 /**

   979 @SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0014

   980 @SYMComponent telephony_ctsy

   981 @SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::Write(), RMobileSmsStore::Write(), RMobileSmsStore::GetInfo(), CRetrieveMobilePhoneSmsList::Start() and RMobileSmsStore::DealeteAll()  

   982 @SYMTestPriority High

   983 @SYMTestActions Invokes RMobileSmsStore::Write(), RMobileSmsStore::Write(), RMobileSmsStore::GetInfo(), CRetrieveMobilePhoneSmsList::Start() and RMobileSmsStore::DealeteAll() 

   984 @SYMTestExpectedResults Pass

   985 @SYMTestType CT

   986 */

   987 void CCTsyPhonebookFU::TestUseCase0014L()

   988 	{

   989 	OpenEtelServerL(EUseExtendedError);

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

   991 	OpenPhoneL();

   992 

   993 	TRequestStatus requestStatus;

   994 

   995 	// open the message store

   996 	RMobileSmsMessaging messaging;

   997 	CleanupClosePushL(messaging);

   998 

   999 	RMobileSmsStore smsStore;

  1000 	CleanupClosePushL(smsStore);

  1001 

  1002 	OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore);

  1003 

  1004 	RBuf8 expData;

  1005 	CleanupClosePushL(expData);

  1006 

  1007 	RBuf8 completeData;

  1008 	CleanupClosePushL(completeData);

  1009 	

  1010 	//-------------------------------------------------------------------------

  1011 	// RMobileSmsStore::Write()

  1012  	//-------------------------------------------------------------------------

  1013 

  1014 	TInt index1 = 0;

  1015 	RMobileSmsStore::TMobileGsmSmsEntryV1 entry1V1;

  1016 	TPckg<RMobileSmsStore::TMobileGsmSmsEntryV1> pckg1EntryV1(entry1V1);

  1017 		

  1018 	entry1V1.iServiceCentre.iNumberPlan   = RMobilePhone::ENationalNumberPlan;

  1019 	entry1V1.iServiceCentre.iTypeOfNumber = RMobilePhone::EAlphanumericNumber;

  1020 	entry1V1.iServiceCentre.iTelNumber    = _L("TelNumber1");

  1021 	entry1V1.iMsgData = _L8("Hello, World!");

  1022 	entry1V1.iMsgStatus = RMobileSmsStore::EStoredMessageUnread;

  1023 	entry1V1.iIndex = index1;

  1024 	

  1025 	TMockLtsyData1<RMobileSmsStore::TMobileGsmSmsEntryV1> 

  1026 			expMockData1Write1(entry1V1);

  1027 

  1028 	TInt location1 = 0;

  1029 	TBool  receivedClass2ToBeResent1 = EFalse;

  1030 

  1031 	TMockLtsyData2<TInt, TBool> completeMockData2Write1(location1, receivedClass2ToBeResent1);

  1032 

  1033 	expData.Close();

  1034 	expMockData1Write1.SerialiseL(expData);

  1035 	completeData.Close();

  1036 	completeMockData2Write1.SerialiseL(completeData);

  1037 

  1038 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData);

  1039 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData);

  1040 	

  1041 	smsStore.Write(requestStatus, pckg1EntryV1);

  1042 

  1043     User::WaitForRequest(requestStatus);        

  1044 	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

  1045 	ASSERT_EQUALS(entry1V1.iIndex, location1);

  1046 	AssertMockLtsyStatusL();

  1047 

  1048 	//-------------------------------------------------------------------------

  1049 	// RMobileSmsStore::Write()

  1050  	//-------------------------------------------------------------------------

  1051 	

  1052 	TInt index2 = 1;

  1053 	RMobileSmsStore::TMobileGsmSmsEntryV1 entry2V1;

  1054 	TPckg<RMobileSmsStore::TMobileGsmSmsEntryV1> pckg2EntryV1(entry2V1);

  1055 		

  1056 	entry2V1.iServiceCentre.iNumberPlan   = RMobilePhone::EServiceCentreSpecificPlan2;

  1057 	entry2V1.iServiceCentre.iTypeOfNumber = RMobilePhone::ESubscriberNumber;

  1058 	entry2V1.iServiceCentre.iTelNumber    = _L("TelNumber2");

  1059 	entry2V1.iMsgData = _L8("Hello, World number 2!");

  1060 	entry2V1.iMsgStatus = RMobileSmsStore::EStoredMessageUnread;

  1061 	entry2V1.iIndex = index2;

  1062 	

  1063 	TMockLtsyData1<RMobileSmsStore::TMobileGsmSmsEntryV1> 

  1064 			expMockData1Write2(entry2V1);

  1065 

  1066 	TInt location2 = 1;

  1067 	TBool  receivedClass2ToBeResent2 = ETrue;

  1068 

  1069 	TMockLtsyData2<TInt, TBool> completeMockData2Write2(location2, receivedClass2ToBeResent2);

  1070 

  1071 	expData.Close();

  1072 	expMockData1Write2.SerialiseL(expData);

  1073 	completeData.Close();

  1074 	completeMockData2Write2.SerialiseL(completeData);

  1075 

  1076 

  1077 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData);

  1078 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData);

  1079 	iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); //because receivedClass2ToBeResent1 = ETrue;

  1080 	

  1081 	smsStore.Write(requestStatus, pckg2EntryV1);

  1082 

  1083     User::WaitForRequest(requestStatus);        

  1084 	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

  1085 	ASSERT_EQUALS(entry2V1.iIndex, location2);

  1086 	AssertMockLtsyStatusL();

  1087 	

  1088  	//-------------------------------------------------------------------------

  1089 	// RMobileSmsStore::GetInfo()

  1090  	//-------------------------------------------------------------------------

  1091 	

  1092 	TInt totalEntries = 2;

  1093 	TInt usedEntries = 0;

  1094 	TMockLtsyData2<TInt,TInt> smsStoreGetInfoLtsyData(totalEntries, usedEntries);

  1095 	completeData.Close();

  1096 	smsStoreGetInfoLtsyData.SerialiseL(completeData);

  1097 	

  1098 	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId);

  1099 	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, completeData);

  1100 

  1101 	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfoV1;

  1102 	TPckg<RMobilePhoneBookStore::TMobilePhoneBookInfoV1> pckgInfoV1(phoneBookInfoV1);

  1103 	smsStore.GetInfo(requestStatus, pckgInfoV1);

  1104 	User::WaitForRequest(requestStatus);

  1105 	

  1106 	ASSERT_EQUALS(requestStatus.Int(),KErrNone);

  1107 	ASSERT_EQUALS(phoneBookInfoV1.iTotalEntries, totalEntries);

  1108 	ASSERT_EQUALS(phoneBookInfoV1.iUsedEntries, usedEntries);

  1109 

  1110 	AssertMockLtsyStatusL();

  1111 	

  1112  	//-------------------------------------------------------------------------

  1113 	// CRetrieveMobilePhoneSmsList::Start

  1114  	//-------------------------------------------------------------------------

  1115 	

  1116 	CGetSMSListAO* getSmsListAO = CGetSMSListAO::NewLC(smsStore);

  1117 

  1118 	TBool receivedClass2ToBeResent = ETrue;

  1119 	

  1120 	DispatcherPhonebook::TSmsData smsData1;

  1121 		

  1122 	smsData1.iSmsMsg= _L8("Hello, World!"); 

  1123 	smsData1.iServiceCentre = _L("TelNumber1");

  1124 	smsData1.iMobileScTON = RMobilePhone::EAlphanumericNumber;

  1125 	smsData1.iMobileScNPI = RMobilePhone::ENationalNumberPlan;

  1126 	smsData1.iMessageStatus = RMobileSmsStore::EStoredMessageUnread;

  1127 		

  1128 	TBool moreToCome1 = ETrue; 

  1129 	    

  1130 	TMockLtsyData4<DispatcherPhonebook::TSmsData, TInt, TBool, TBool> completeSmsMsgLtsyData1(smsData1, index1, moreToCome1, receivedClass2ToBeResent);

  1131 	

  1132 	DispatcherPhonebook::TSmsData smsData2;

  1133 		

  1134 	smsData2.iSmsMsg= _L8("Hello, World number 2!"); 

  1135 	smsData2.iServiceCentre = _L("TelNumber2");