diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsyphonebookfu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsyphonebookfu.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,3601 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + + + +/** + @file The TEFUnit test suite for PhonebookControl in the Common TSY. +*/ + +#include "cctsyphonebookfu.h" +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include +#include + +#include "mockltsyindicatorids.h" + +#include + +#include "listretrieverao.h" + +const TInt KReadBufLength = 400; +const TInt KMaxTextLength = 50; +const TInt KNewMaxTextLength = 55; +const TInt KMaxNumberLength = 25; +const TInt KNumberOfEnries = 100; + +CTestSuite* CCTsyPhonebookFU::CreateSuiteL(const TDesC& aName) + { + SUB_SUITE; + + //add use-case tests + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0003L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0007L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0008L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0009L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0010L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0011L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0012L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0013L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUseCase0014L); + //add other unit tests + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0001L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0002L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0003L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0004L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0005L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0006L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0007L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0008L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0009L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0010L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0011L); + ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFU, TestUnit0012L); + + END_SUITE; + } + + +// +// Use-case tests +// + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Opening all supported phonebooks +@SYMTestPriority High +@SYMTestActions Opens caching and non caching phonebooks in different orders +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0001L() + { + CreateEntriesAndStoreDataL(); + + /*********************Open all phone books - caching PB first*****************************/ + + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RArray names; + CleanupClosePushL(names); + names.AppendL(DispatcherPhonebook::EIccAdn); + names.AppendL(DispatcherPhonebook::EIccFdn); + names.AppendL(DispatcherPhonebook::EIccBdn); + names.AppendL(DispatcherPhonebook::EIccSdn); + names.AppendL(DispatcherPhonebook::EIccVmb); + names.AppendL(DispatcherPhonebook::EIccMbdn); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TInt nameCount = names.Count(); + for(TInt i = 0; i < nameCount; ++i) + { + RMobilePhoneBookStore phonebookStore; + CleanupClosePushL(phonebookStore); + OpenPhoneBookL(names[i], phonebookStore, customApi); + } + + CleanupStack::PopAndDestroy(nameCount); //the phonebooks + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&names); + CleanupStack::PopAndDestroy(this); + + /*********************Open all phone books - non caching PB first*****************************/ + + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + + CleanupClosePushL(names); + names.AppendL(DispatcherPhonebook::EIccBdn); + names.AppendL(DispatcherPhonebook::EIccFdn); + names.AppendL(DispatcherPhonebook::EIccAdn); + names.AppendL(DispatcherPhonebook::EIccSdn); + names.AppendL(DispatcherPhonebook::EIccVmb); + names.AppendL(DispatcherPhonebook::EIccMbdn); + + OpenCustomApiLC(customApi); + + nameCount = names.Count(); + for(TInt j = 0; j < nameCount; ++j) + { + RMobilePhoneBookStore phonebookStore; + CleanupClosePushL(phonebookStore); + OpenPhoneBookL(names[j], phonebookStore, customApi); + } + + CleanupStack::PopAndDestroy(nameCount); //the phonebooks + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&names); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Opening all supported phonebooks interleaving the cache completes +@SYMTestPriority High +@SYMTestActions Open several phonebooks completing the cache operations between non caching phonebooks +being opened. +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0002L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + TRequestStatus requestStatus; + + //repeat to test stored CTSY pointers are reset to NULL in the dispatcher + for(TInt i = 0; i < 2; ++i) + { + RMobilePhoneBookStore adnPhoneBookStore; + CleanupClosePushL(adnPhoneBookStore); + + RMobilePhoneBookStore fdnPhoneBookStore; + CleanupClosePushL(fdnPhoneBookStore); + + RMobilePhoneBookStore bdnPhoneBookStore; + CleanupClosePushL(bdnPhoneBookStore); + + RMobilePhoneBookStore sdnPhoneBookStore; + CleanupClosePushL(sdnPhoneBookStore); + + RMobilePhoneBookStore vmbPhoneBookStore; + CleanupClosePushL(vmbPhoneBookStore); + + OpenCachingPhoneBookL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,KErrNone); + + OpenNonCachingPhoneBookL(DispatcherPhonebook::EIccVmb,vmbPhoneBookStore,KErrNone); + + OpenCachingPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,KErrNone); + + OpenNonCachingPhoneBookL(DispatcherPhonebook::EIccBdn,bdnPhoneBookStore,KErrNone); + + //Custom API can only wait on one phonebook at a time. + TName adnPhonebookName(PhonebookName(DispatcherPhonebook::EIccAdn)); + customApi.NotifyPndCacheReady(requestStatus,adnPhonebookName); + CompleteCacheL(DispatcherPhonebook::EIccAdn, KErrNone, EFalse); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + + OpenNonCachingPhoneBookL(DispatcherPhonebook::EIccSdn,sdnPhoneBookStore,KErrNone); + + TName fdnPhonebookName(PhonebookName(DispatcherPhonebook::EIccFdn)); + customApi.NotifyPndCacheReady(requestStatus,fdnPhonebookName); + CompleteCacheL(DispatcherPhonebook::EIccFdn, KErrNone, EFalse); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&vmbPhoneBookStore); + CleanupStack::PopAndDestroy(&sdnPhoneBookStore); + CleanupStack::PopAndDestroy(&bdnPhoneBookStore); + CleanupStack::PopAndDestroy(&fdnPhoneBookStore); + CleanupStack::PopAndDestroy(&adnPhoneBookStore); + } + + CleanupStack::PopAndDestroy(&customApi); + + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test Read for all supported phonebooks +@SYMTestPriority High +@SYMTestActions Open the phone book and read all entries from caching and non-caching phonebooks - RMobilePhoneBookStore::Read() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0003L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + CreateEntriesAndStoreDataL(); + + OpenPhoneL(); + + ReadL(DispatcherPhonebook::EIccAdn,KErrNone); + ReadL(DispatcherPhonebook::EIccAdn,KErrGeneral); + + ReadL(DispatcherPhonebook::EIccFdn,KErrNone); + ReadL(DispatcherPhonebook::EIccFdn,KErrGeneral); + + ReadL(DispatcherPhonebook::EIccBdn,KErrNone); + ReadL(DispatcherPhonebook::EIccBdn,KErrGeneral); + + ReadL(DispatcherPhonebook::EIccSdn,KErrNone); + ReadL(DispatcherPhonebook::EIccSdn,KErrGeneral); + + ReadL(DispatcherPhonebook::EIccVmb,KErrNone); + ReadL(DispatcherPhonebook::EIccVmb,KErrGeneral); + + ReadL(DispatcherPhonebook::EIccMbdn,KErrNone); + ReadL(DispatcherPhonebook::EIccMbdn,KErrGeneral); + + CleanupStack::PopAndDestroy(this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test Read for all supported phonebooks interleaving the non-cache reads +@SYMTestPriority High +@SYMTestActions Open all phonebooks and read enties interleaving the reads - RMobilePhoneBookStore::Read() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + CreateEntriesAndStoreDataL(); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore adnPhoneBookStore; + CleanupClosePushL(adnPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,customApi); + + RMobilePhoneBookStore fdnPhoneBookStore; + CleanupClosePushL(fdnPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,customApi); + + RMobilePhoneBookStore bdnPhoneBookStore; + CleanupClosePushL(bdnPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccBdn,bdnPhoneBookStore,customApi); + + RMobilePhoneBookStore sdnPhoneBookStore; + CleanupClosePushL(sdnPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccSdn,sdnPhoneBookStore,customApi); + + RMobilePhoneBookStore vmbPhoneBookStore; + CleanupClosePushL(vmbPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccVmb,vmbPhoneBookStore,customApi); + + RMobilePhoneBookStore mbdnPhoneBookStore; + CleanupClosePushL(mbdnPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccMbdn,mbdnPhoneBookStore,customApi); + + //repeat to test stored CTSY pointers are reset to NULL in the dispatcher + for(TInt i = 0; i < 2; ++i) + { + TRequestStatus adnRequestStatus; + TBuf8 adnData; + ExpectNonCacheReadL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,1,1,adnRequestStatus,adnData); + + TRequestStatus fdnRequestStatus; + TBuf8 fdnData; + ExpectNonCacheReadL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,1,1,fdnRequestStatus,fdnData); + + TRequestStatus bdnRequestStatus; + TBuf8 bdnData; + ExpectNonCacheReadL(DispatcherPhonebook::EIccBdn,bdnPhoneBookStore,1,1,bdnRequestStatus,bdnData); + + TRequestStatus sdnRequestStatus; + TBuf8 sdnData; + ExpectNonCacheReadL(DispatcherPhonebook::EIccSdn,sdnPhoneBookStore,1,1,sdnRequestStatus,sdnData); + + TRequestStatus vmbRequestStatus; + TBuf8 vmbData; + ExpectNonCacheReadL(DispatcherPhonebook::EIccVmb,vmbPhoneBookStore,1,1,vmbRequestStatus,vmbData); + + TRequestStatus mbdnRequestStatus; + TBuf8 mbdnData; + ExpectNonCacheReadL(DispatcherPhonebook::EIccMbdn,mbdnPhoneBookStore,1,1,mbdnRequestStatus,mbdnData); + + //we now have size outstanding reads (thus six CTSY pointers held in the dispatcher) + + CompleteNonCacheReadL(DispatcherPhonebook::EIccAdn, 1, 1, adnRequestStatus, adnData, KErrNone); + CompleteNonCacheReadL(DispatcherPhonebook::EIccFdn, 1, 1, fdnRequestStatus, fdnData, KErrNone); + CompleteNonCacheReadL(DispatcherPhonebook::EIccBdn, 1, 1, bdnRequestStatus, bdnData, KErrNone); + CompleteNonCacheReadL(DispatcherPhonebook::EIccSdn, 1, 1, sdnRequestStatus, sdnData, KErrNone); + CompleteNonCacheReadL(DispatcherPhonebook::EIccVmb, 1, 1, vmbRequestStatus, vmbData, KErrNone); + CompleteNonCacheReadL(DispatcherPhonebook::EIccMbdn, 1, 1, mbdnRequestStatus, mbdnData, KErrNone); + } + + CleanupStack::PopAndDestroy(&mbdnPhoneBookStore); //phonebooks + CleanupStack::PopAndDestroy(&vmbPhoneBookStore); //phonebooks + CleanupStack::PopAndDestroy(&sdnPhoneBookStore); //phonebooks + CleanupStack::PopAndDestroy(&bdnPhoneBookStore); //phonebooks + CleanupStack::PopAndDestroy(&fdnPhoneBookStore); //phonebooks + CleanupStack::PopAndDestroy(&adnPhoneBookStore); //phonebooks + + CleanupStack::PopAndDestroy(&customApi); + + CleanupStack::PopAndDestroy(this); // data, this + + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for deleting entries from phonebooks +@SYMTestPriority High +@SYMTestActions Open all phone books (excluding SDN, can't be updated by user) and delete all entires one by one - RMobilePhoneBookStore::Delete() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + CreateEntriesAndStoreDataL(); + + OpenPhoneL(); + + TInt indexToDelete = 1; + + DeleteL(DispatcherPhonebook::EIccAdn, indexToDelete, KErrNone); + DeleteL(DispatcherPhonebook::EIccAdn, indexToDelete, KErrNotFound); + + DeleteL(DispatcherPhonebook::EIccFdn, indexToDelete, KErrNone); + DeleteL(DispatcherPhonebook::EIccFdn, indexToDelete, KErrNotFound); + + DeleteL(DispatcherPhonebook::EIccBdn, indexToDelete, KErrNone); + DeleteL(DispatcherPhonebook::EIccBdn, indexToDelete, KErrNotFound); + + DeleteL(DispatcherPhonebook::EIccVmb, indexToDelete, KErrNone); + DeleteL(DispatcherPhonebook::EIccVmb, indexToDelete, KErrNotFound); + + DeleteL(DispatcherPhonebook::EIccMbdn, indexToDelete, KErrNone); + DeleteL(DispatcherPhonebook::EIccMbdn, indexToDelete, KErrNotFound); + + CleanupStack::PopAndDestroy(this); + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for deleting all entries from phonebooks +@SYMTestPriority High +@SYMTestActions Open all phonebooks (excluding SDN, can't be updated by user) and delete all the entries - RMobilePhoneBookStore::DeleteAll() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0006L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + CreateEntriesAndStoreDataL(); + + OpenPhoneL(); + + DeleteAllL(DispatcherPhonebook::EIccAdn, KErrNone); + DeleteAllL(DispatcherPhonebook::EIccAdn, KErrNotFound); + + DeleteAllL(DispatcherPhonebook::EIccFdn, KErrNone); + DeleteAllL(DispatcherPhonebook::EIccFdn, KErrNotFound); + + DeleteAllL(DispatcherPhonebook::EIccBdn, KErrNone); + DeleteAllL(DispatcherPhonebook::EIccBdn, KErrNotFound); + + DeleteAllL(DispatcherPhonebook::EIccVmb, KErrNone); + DeleteAllL(DispatcherPhonebook::EIccVmb, KErrNotFound); + + DeleteAllL(DispatcherPhonebook::EIccMbdn, KErrNone); + DeleteAllL(DispatcherPhonebook::EIccMbdn, KErrNotFound); + + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for writing entries to all phonebooks +@SYMTestPriority High +@SYMTestActions Open the phonebook and test successful and unsuccessful write operations - RMobilePhoneBookStore::Write() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0007L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + CPhoneBookEntry* phoneBookEntry = CPhoneBookEntry::NewLC(); + phoneBookEntry->SetIndex(5); + phoneBookEntry->SetFirstName(_L("Symbian5")); + phoneBookEntry->SetDiallingNumber(_L("123456789")); + phoneBookEntry->AddEmailAddress(_L("a@a.com")); + phoneBookEntry->AddSecondName(_L("secondname")); + phoneBookEntry->AddAdditionalNumber(_L("3874387")); + + WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrNone); + WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrOverflow); + WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrGsmSimServSneFull); + WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrGsmSimServAnrFull); + WriteL(DispatcherPhonebook::EIccAdn, *phoneBookEntry, KErrGsmSimServEmailFull); + + WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrNone); + WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrOverflow); + WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrGsmSimServSneFull); + WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrGsmSimServAnrFull); + WriteL(DispatcherPhonebook::EIccFdn, *phoneBookEntry, KErrGsmSimServEmailFull); + + //text and number lengths are only set for adn, fdn, vmb, and mbdn phone books + //thus we can't do the below tests +// WriteL(DispatcherPhonebook::EIccBdn, *phoneBookEntry, KErrNone); +// WriteL(DispatcherPhonebook::EIccSdn, *phoneBookEntry, KErrNone); + + WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrNone); + WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrOverflow); + WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrGsmSimServSneFull); + WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrGsmSimServAnrFull); + WriteL(DispatcherPhonebook::EIccVmb, *phoneBookEntry, KErrGsmSimServEmailFull); + + WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrNone); + WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrOverflow); + WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrGsmSimServSneFull); + WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrGsmSimServAnrFull); + WriteL(DispatcherPhonebook::EIccMbdn, *phoneBookEntry, KErrGsmSimServEmailFull); + + CleanupStack::PopAndDestroy(phoneBookEntry); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for sending a Reset Cache IPC +@SYMTestPriority High +@SYMTestActions +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0008L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + CreateEntriesAndStoreDataL(); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + //the custom API state to RMmCustomAPI::ECacheNotReady + + RArray cachingPhonebooks; + CleanupClosePushL(cachingPhonebooks); + cachingPhonebooks.AppendL(DispatcherPhonebook::EIccAdn); + cachingPhonebooks.AppendL(DispatcherPhonebook::EIccFdn); + + // test all caching phonebooks + for(TInt i = 0; i < cachingPhonebooks.Count(); ++i) + { + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + + OpenPhoneBookL(cachingPhonebooks[i],phoneBookStore,customApi); + + TMockLtsyData1 resetCacheCompLtsyData(cachingPhonebooks[i]); + resetCacheCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchPhonebookStoreResetCacheIndId,KErrNone,data); + data.Close(); + + WaitForMockLTSYTerminated(); + AssertMockLtsyStatusL(); + + RMmCustomAPI::TPndCacheStatus cacheStatus; + customApi.GetPndCacheStatus(requestStatus,cacheStatus,PhonebookName(cachingPhonebooks[i])); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(cacheStatus,RMmCustomAPI::ECacheNotReady); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + TMockLtsyData1 expLtsyData(cachingPhonebooks[i]); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + CleanupStack::PopAndDestroy(&phoneBookStore); + } + + CleanupStack::PopAndDestroy(&cachingPhonebooks); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for setting the FDN settings +@SYMTestPriority High +@SYMTestActions +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0009L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + CreateEntriesAndStoreDataL(); + + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + + OpenPhoneBookL(DispatcherPhonebook::EIccFdn,phoneBookStore,customApi); + + SetFdnInfoL(phoneBookStore,KErrNone); + + SetFdnInfoL(phoneBookStore,KErrGeneral); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + RBuf8 data; + CleanupClosePushL(data); + + DispatcherPhonebook::TPhonebook pB = DispatcherPhonebook::EIccFdn; + TMockLtsyData1 expLtsyData(pB); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + CleanupStack::PopAndDestroy(&data); + + CleanupStack::PopAndDestroy(&phoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for getting phonebook store information +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0010L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + CreateEntriesAndStoreDataL(); + + OpenPhoneL(); + + GetInfoL(DispatcherPhonebook::EIccAdn,KErrNone); + GetInfoL(DispatcherPhonebook::EIccAdn,KErrGeneral); + + GetInfoL(DispatcherPhonebook::EIccFdn,KErrNone); + GetInfoL(DispatcherPhonebook::EIccFdn,KErrGeneral); + + GetInfoL(DispatcherPhonebook::EIccSdn,KErrNone); + GetInfoL(DispatcherPhonebook::EIccSdn,KErrGeneral); + + //causes an ETel Panic - 5 (apparent known defect - Id 40502) + //GetInfoL(DispatcherPhonebook::EIccBdn,KErrNone); + //GetInfoL(DispatcherPhonebook::EIccBdn,KErrGeneral); + + GetInfoL(DispatcherPhonebook::EIccVmb,KErrNone); + GetInfoL(DispatcherPhonebook::EIccVmb,KErrGeneral); + + GetInfoL(DispatcherPhonebook::EIccMbdn,KErrNone); + GetInfoL(DispatcherPhonebook::EIccMbdn,KErrGeneral); + + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for getting store information +@SYMTestPriority High +@SYMTestActions RMobilePhone::GetPhoneStoreInfo() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0011L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + CreateEntriesAndStoreDataL(); + OpenPhoneL(); + + TName storeName(KETelIccAdnPhoneBook); + RMobilePhoneBookStore::TMobilePhoneStoreInfoV1 bookInfo; + RMobilePhoneBookStore::TMobilePhoneStoreInfoV1Pckg bookInfoPckg(bookInfo); + + /********************Test Normal case******************************/ + + + TDesC* storeNamePtr = &storeName; + TMockLtsyData1 getInfoExpLtsyData(storeNamePtr); + getInfoExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,data); + data.Close(); + + iPhone.GetPhoneStoreInfo(requestStatus,bookInfoPckg,storeName); + + RMobilePhoneBookStore::TMobilePhoneStoreInfoV1 compBookInfo; + compBookInfo.iType = RMobilePhoneStore::EPhoneBookStore; + compBookInfo.iTotalEntries = iPhonebookStoreData.iAdnTotalEntries; + compBookInfo.iUsedEntries = iEntries.Count(); + compBookInfo.iCaps = 0; + compBookInfo.iName = KETelIccAdnPhoneBook; + + TMockLtsyData1 getInfoCompLtsyData(compBookInfo); + getInfoCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,KErrNone,data); + data.Close(); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(),KErrNone) + + + ASSERT_EQUALS(compBookInfo.iType, bookInfo.iType); + ASSERT_EQUALS(compBookInfo.iTotalEntries, bookInfo.iTotalEntries); + ASSERT_EQUALS(compBookInfo.iUsedEntries, bookInfo.iUsedEntries); + ASSERT_EQUALS(compBookInfo.iCaps, bookInfo.iCaps); + ASSERT_EQUALS(compBookInfo.iName, bookInfo.iName); + + AssertMockLtsyStatusL(); + + /********************Test Error case******************************/ + + getInfoExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,data); + data.Close(); + + iPhone.GetPhoneStoreInfo(requestStatus,bookInfoPckg,storeName); + + const TInt KError = KErrGeneral; + + getInfoCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,KError,data); + data.Close(); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(),KError) + + AssertMockLtsyStatusL(); + + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0012 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for a SIM refresh of the Cached phonebooks +@SYMTestPriority High +@SYMTestActions Invokes SIM refresh IPC, +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0012L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + CreateEntriesAndStoreDataL(); + OpenPhoneL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + + //open the caching phonebooks + RMobilePhoneBookStore adnPhoneBookStore; + CleanupClosePushL(adnPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,customApi); + + RMobilePhoneBookStore fdnPhoneBookStore; + CleanupClosePushL(fdnPhoneBookStore); + OpenPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,customApi); + + + //test the refresh + + //add a new entry + CPhoneBookEntry* phoneBookEntry = CPhoneBookEntry::NewLC(); + iEntries.AppendL(phoneBookEntry); + CleanupStack::Pop(phoneBookEntry); //takes ownership + phoneBookEntry->SetIndex(5); + phoneBookEntry->SetFirstName(_L("Symbian4")); + phoneBookEntry->SetDiallingNumber(_L("897654321")); + phoneBookEntry->AddEmailAddress(_L("symbian1@symbian.com11")); + phoneBookEntry->AddSecondName(_L("Phone book311")); + phoneBookEntry->AddAdditionalNumber(_L("12311")); + + iPhonebookStoreData.iAdnTotalEntries = iEntries.Count(); + iPhonebookStoreData.iFdnTotalEntries = iEntries.Count(); + + RefreshL(DispatcherPhonebook::EIccAdn); + //test the refresh changed the CTSY state + GetInfoFromCtsy(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,iEntries.Count()); + ReadL(DispatcherPhonebook::EIccAdn,adnPhoneBookStore,KErrNone); + + RefreshL(DispatcherPhonebook::EIccFdn); + //test the refresh changed the CTSY state + GetInfoFromCtsy(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,iEntries.Count()); + ReadL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,KErrNone); + + CleanupStack::PopAndDestroy(&fdnPhoneBookStore); + CleanupStack::PopAndDestroy(&adnPhoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0013 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::Write(), RMobileSmsStore::Read(), RMobileSmsStore::GetInfo() and RMobileSmsStore::Delete() +@SYMTestPriority High +@SYMTestActions Invokes RMobileSmsStore::Write(), RMobileSmsStore::Read(), RMobileSmsStore::GetInfo() and RMobileSmsStore::Delete() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0013L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + + // open the message store + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + RBuf8 expData; + CleanupClosePushL(expData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + //------------------------------------------------------------------------- + // RMobileSmsStore::Write() + //------------------------------------------------------------------------- + + TInt index = 0; + + RMobileSmsStore::TMobileGsmSmsEntryV1 entryV1; + TPckg pckgEntryV1(entryV1); + + entryV1.iServiceCentre.iNumberPlan = RMobilePhone::ENationalNumberPlan; + entryV1.iServiceCentre.iTypeOfNumber = RMobilePhone::EAlphanumericNumber; + entryV1.iServiceCentre.iTelNumber = _L("TelNumber1"); + entryV1.iMsgData = _L8("Hello, World!"); + entryV1.iMsgStatus = RMobileSmsStore::EStoredMessageUnread; + entryV1.iIndex = index; + + TMockLtsyData1 + expMockData1(entryV1); + + TInt location = 0; + TBool receivedClass2ToBeResent = ETrue; + + TMockLtsyData2 completeMockData2(location, receivedClass2ToBeResent); + + expData.Close(); + expMockData1.SerialiseL(expData); + completeData.Close(); + completeMockData2.SerialiseL(completeData); + + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); + + smsStore.Write(requestStatus, pckgEntryV1); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(entryV1.iIndex, location); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // RMobileSmsStore::Read() + //------------------------------------------------------------------------- + + + TMockLtsyData1 mockIndex(index); + + DispatcherPhonebook::TSmsData smsData; + + smsData.iSmsMsg= _L8("Hello, World!"); + smsData.iServiceCentre = _L("ServiceCenter1"); + smsData.iMobileScTON = RMobilePhone::EAlphanumericNumber; + smsData.iMobileScNPI = RMobilePhone::ENationalNumberPlan; + smsData.iMessageStatus = RMobileSmsStore::EStoredMessageUnread; + + TMockLtsyData1 mockMsg(smsData); + + completeData.Close(); + mockMsg.SerialiseL(completeData); + + RMobileSmsStore::TMobileGsmSmsEntryV1 entryV1Read; + entryV1Read.iIndex=index; + TPckg pckgEntryV1Read(entryV1Read); + + TMockLtsyData1 mockIndexRead(index); + expData.Close(); + mockIndexRead.SerialiseL(expData); + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, KErrNone, completeData); + + smsStore.Read(requestStatus, pckgEntryV1Read); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(0, smsData.iSmsMsg.Compare(entryV1Read.iMsgData)); + ASSERT_EQUALS(0, smsData.iServiceCentre.Compare(entryV1Read.iServiceCentre.iTelNumber)); + ASSERT_EQUALS(smsData.iMobileScTON, entryV1Read.iServiceCentre.iTypeOfNumber); + ASSERT_EQUALS(smsData.iMobileScNPI, entryV1Read.iServiceCentre.iNumberPlan); + ASSERT_EQUALS(RMobileSmsStore::EStoredMessageRead, entryV1Read.iMsgStatus); + + //------------------------------------------------------------------------- + // RMobileSmsStore::GetInfo() + //------------------------------------------------------------------------- + + TInt totalEntries = 1; + TInt usedEntries = 0; + TMockLtsyData2 smsStoreGetInfoLtsyData(totalEntries, usedEntries); + completeData.Close(); + smsStoreGetInfoLtsyData.SerialiseL(completeData); + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, completeData); + + RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfoV1; + TPckg pckgInfoV1(phoneBookInfoV1); + smsStore.GetInfo(requestStatus, pckgInfoV1); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + + ASSERT_EQUALS(requestStatus.Int(),KErrNone); + ASSERT_EQUALS(phoneBookInfoV1.iTotalEntries, totalEntries); + ASSERT_EQUALS(phoneBookInfoV1.iUsedEntries, usedEntries); + + //------------------------------------------------------------------------- + // RMobileSmsStore::Delete() + //------------------------------------------------------------------------- + + TMockLtsyData1 expMockData1Delete(index); + expMockData1Delete.SerialiseL(expData); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, KErrNone); + + smsStore.Delete(requestStatus, index); + + User::WaitForRequest(requestStatus); + + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CleanupStack::PopAndDestroy(5, this); // expData, completeData, + // smsStore, messaging, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UC0014 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::Write(), RMobileSmsStore::Write(), RMobileSmsStore::GetInfo(), CRetrieveMobilePhoneSmsList::Start() and RMobileSmsStore::DealeteAll() +@SYMTestPriority High +@SYMTestActions Invokes RMobileSmsStore::Write(), RMobileSmsStore::Write(), RMobileSmsStore::GetInfo(), CRetrieveMobilePhoneSmsList::Start() and RMobileSmsStore::DealeteAll() +@SYMTestExpectedResults Pass +@SYMTestType CT +*/ +void CCTsyPhonebookFU::TestUseCase0014L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + + // open the message store + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + RBuf8 expData; + CleanupClosePushL(expData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + //------------------------------------------------------------------------- + // RMobileSmsStore::Write() + //------------------------------------------------------------------------- + + TInt index1 = 0; + RMobileSmsStore::TMobileGsmSmsEntryV1 entry1V1; + TPckg pckg1EntryV1(entry1V1); + + entry1V1.iServiceCentre.iNumberPlan = RMobilePhone::ENationalNumberPlan; + entry1V1.iServiceCentre.iTypeOfNumber = RMobilePhone::EAlphanumericNumber; + entry1V1.iServiceCentre.iTelNumber = _L("TelNumber1"); + entry1V1.iMsgData = _L8("Hello, World!"); + entry1V1.iMsgStatus = RMobileSmsStore::EStoredMessageUnread; + entry1V1.iIndex = index1; + + TMockLtsyData1 + expMockData1Write1(entry1V1); + + TInt location1 = 0; + TBool receivedClass2ToBeResent1 = EFalse; + + TMockLtsyData2 completeMockData2Write1(location1, receivedClass2ToBeResent1); + + expData.Close(); + expMockData1Write1.SerialiseL(expData); + completeData.Close(); + completeMockData2Write1.SerialiseL(completeData); + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData); + + smsStore.Write(requestStatus, pckg1EntryV1); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(entry1V1.iIndex, location1); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // RMobileSmsStore::Write() + //------------------------------------------------------------------------- + + TInt index2 = 1; + RMobileSmsStore::TMobileGsmSmsEntryV1 entry2V1; + TPckg pckg2EntryV1(entry2V1); + + entry2V1.iServiceCentre.iNumberPlan = RMobilePhone::EServiceCentreSpecificPlan2; + entry2V1.iServiceCentre.iTypeOfNumber = RMobilePhone::ESubscriberNumber; + entry2V1.iServiceCentre.iTelNumber = _L("TelNumber2"); + entry2V1.iMsgData = _L8("Hello, World number 2!"); + entry2V1.iMsgStatus = RMobileSmsStore::EStoredMessageUnread; + entry2V1.iIndex = index2; + + TMockLtsyData1 + expMockData1Write2(entry2V1); + + TInt location2 = 1; + TBool receivedClass2ToBeResent2 = ETrue; + + TMockLtsyData2 completeMockData2Write2(location2, receivedClass2ToBeResent2); + + expData.Close(); + expMockData1Write2.SerialiseL(expData); + completeData.Close(); + completeMockData2Write2.SerialiseL(completeData); + + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); //because receivedClass2ToBeResent1 = ETrue; + + smsStore.Write(requestStatus, pckg2EntryV1); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(entry2V1.iIndex, location2); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // RMobileSmsStore::GetInfo() + //------------------------------------------------------------------------- + + TInt totalEntries = 2; + TInt usedEntries = 0; + TMockLtsyData2 smsStoreGetInfoLtsyData(totalEntries, usedEntries); + completeData.Close(); + smsStoreGetInfoLtsyData.SerialiseL(completeData); + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, completeData); + + RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfoV1; + TPckg pckgInfoV1(phoneBookInfoV1); + smsStore.GetInfo(requestStatus, pckgInfoV1); + User::WaitForRequest(requestStatus); + + ASSERT_EQUALS(requestStatus.Int(),KErrNone); + ASSERT_EQUALS(phoneBookInfoV1.iTotalEntries, totalEntries); + ASSERT_EQUALS(phoneBookInfoV1.iUsedEntries, usedEntries); + + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // CRetrieveMobilePhoneSmsList::Start + //------------------------------------------------------------------------- + + CGetSMSListAO* getSmsListAO = CGetSMSListAO::NewLC(smsStore); + + TBool receivedClass2ToBeResent = ETrue; + + DispatcherPhonebook::TSmsData smsData1; + + smsData1.iSmsMsg= _L8("Hello, World!"); + smsData1.iServiceCentre = _L("TelNumber1"); + smsData1.iMobileScTON = RMobilePhone::EAlphanumericNumber; + smsData1.iMobileScNPI = RMobilePhone::ENationalNumberPlan; + smsData1.iMessageStatus = RMobileSmsStore::EStoredMessageUnread; + + TBool moreToCome1 = ETrue; + + TMockLtsyData4 completeSmsMsgLtsyData1(smsData1, index1, moreToCome1, receivedClass2ToBeResent); + + DispatcherPhonebook::TSmsData smsData2; + + smsData2.iSmsMsg= _L8("Hello, World number 2!"); + smsData2.iServiceCentre = _L("TelNumber2"); + smsData2.iMobileScTON = RMobilePhone::ESubscriberNumber; + smsData2.iMobileScNPI = RMobilePhone::EServiceCentreSpecificPlan2; + smsData2.iMessageStatus = RMobileSmsStore::EStoredMessageUnread; + + TBool moreToCome2 = EFalse; + + TMockLtsyData4 completeSmsMsgLtsyData2(smsData2, index2, moreToCome2, receivedClass2ToBeResent); + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone); + //complete with 1st sms data + completeData.Close(); + completeSmsMsgLtsyData1.SerialiseL(completeData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone, completeData); + //complete with 2nd sms data + completeData.Close(); + completeSmsMsgLtsyData2.SerialiseL(completeData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); + + getSmsListAO->TestRetrieveL(); + ASSERT_EQUALS(KErrNone, getSmsListAO->RetrieveLastError()); + //assert: + RMobileSmsStore::TMobileGsmSmsEntryV1 retrievedSmsMsg; + CMobilePhoneGsmSmsList* gsmSmsList; + gsmSmsList=getSmsListAO->RetrieveListL(); + retrievedSmsMsg=gsmSmsList->GetEntryL(0); + + ASSERT_EQUALS(0, smsData1.iSmsMsg.Compare(retrievedSmsMsg.iMsgData)); + ASSERT_EQUALS(0, smsData1.iServiceCentre.Compare(retrievedSmsMsg.iServiceCentre.iTelNumber)); + ASSERT_EQUALS(retrievedSmsMsg.iServiceCentre.iTypeOfNumber, smsData1.iMobileScTON); + ASSERT_EQUALS(retrievedSmsMsg.iServiceCentre.iNumberPlan, smsData1.iMobileScNPI); + ASSERT_EQUALS(retrievedSmsMsg.iMsgStatus, RMobileSmsStore::EStoredMessageRead); + ASSERT_EQUALS(retrievedSmsMsg.iIndex, index1); + + retrievedSmsMsg=gsmSmsList->GetEntryL(1); + + ASSERT_EQUALS(0, smsData2.iSmsMsg.Compare(retrievedSmsMsg.iMsgData)); + ASSERT_EQUALS(0, smsData2.iServiceCentre.Compare(retrievedSmsMsg.iServiceCentre.iTelNumber)); + ASSERT_EQUALS(retrievedSmsMsg.iServiceCentre.iTypeOfNumber, smsData2.iMobileScTON); + ASSERT_EQUALS(retrievedSmsMsg.iServiceCentre.iNumberPlan, smsData2.iMobileScNPI); + ASSERT_EQUALS(retrievedSmsMsg.iMsgStatus, RMobileSmsStore::EStoredMessageRead); + ASSERT_EQUALS(retrievedSmsMsg.iIndex, index2); + + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // RMobileSmsStore::DeleteAll() + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId, KErrNone); + + smsStore.DeleteAll(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + CleanupStack::PopAndDestroy(6, this); // getSmsListAO, completeData, expData, + // smsStore, messaging, this + } + + +// +// Other unit tests +// + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for a cache cancel +@SYMTestPriority High +@SYMTestActions Open the caching phonebooks and close before the cache has completed +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsyPhonebookFU::TestUnit0001L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + RBuf8 data; + CleanupClosePushL(data); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + //repeat for all caching PBs + for(TInt i = 0; i < 2; ++i) + { + DispatcherPhonebook::TPhonebook phonebook + = ( i == 0 ? DispatcherPhonebook::EIccAdn : DispatcherPhonebook::EIccFdn); + + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + + //just the open, don't complete the cache + OpenCachingPhoneBookL(phonebook,phoneBookStore,KErrNone); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + TMockLtsyData1 expLtsyData(phonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + //close them without the cache yet completed + CleanupStack::PopAndDestroy(&phoneBookStore); + + AssertMockLtsyStatusL(); + } + + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Opening a caching phonebook with initialisation failure +@SYMTestPriority High +@SYMTestActions +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsyPhonebookFU::TestUnit0002L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + TRequestStatus requestStatus; + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore fdnPhoneBookStore; + CleanupClosePushL(fdnPhoneBookStore); + + OpenCachingPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,KErrGeneral); + + //can't read + TBuf8 phonebookReadData; + fdnPhoneBookStore.Read(requestStatus,1,1,phonebookReadData); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(),KErrInUse) + + //can't write + RBuf8 writeData; + CleanupClosePushL(writeData); + CreateTlvFromEntryL(*iEntries[1],writeData); + TInt index = 1; + fdnPhoneBookStore.Write(requestStatus,writeData,index); + User::WaitForRequest(requestStatus); + ASSERT_TRUE(requestStatus.Int() != KErrNone); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(&writeData); + CleanupStack::PopAndDestroy(&fdnPhoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Opening a non caching phonebook with initialisation failure +@SYMTestPriority High +@SYMTestActions +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsyPhonebookFU::TestUnit0003L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + TRequestStatus requestStatus; + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + RMobilePhoneBookStore vmbPhoneBookStore; + CleanupClosePushL(vmbPhoneBookStore); + + OpenNonCachingPhoneBookL(DispatcherPhonebook::EIccVmb,vmbPhoneBookStore,KErrGeneral); + + //cannot read, increased error checking in C-TSY result in this read being stopped. + RBuf8 readBuf; + CleanupClosePushL(readBuf); + readBuf.CreateL(KReadBufLength * 1); + + vmbPhoneBookStore.Read(requestStatus,1,1,readBuf); + ASSERT_EQUALS(requestStatus.Int(),KErrNotFound); + + //can't write + RBuf8 writeData; + CleanupClosePushL(writeData); + CreateTlvFromEntryL(*iEntries[1],writeData); + TInt index = 1; + vmbPhoneBookStore.Write(requestStatus,writeData,index); + User::WaitForRequest(requestStatus); + ASSERT_TRUE(requestStatus.Int() != KErrNone); + + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&writeData); + CleanupStack::PopAndDestroy(&readBuf); + CleanupStack::PopAndDestroy(&vmbPhoneBookStore); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Opening a caching phonebook with cache failure +@SYMTestPriority High +@SYMTestActions +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsyPhonebookFU::TestUnit0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore fdnPhoneBookStore; + CleanupClosePushL(fdnPhoneBookStore); + + TRequestStatus requestStatus; + OpenCachingPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,KErrNone); + + //cache completed with a failure + CompleteCacheL(DispatcherPhonebook::EIccFdn, KErrGeneral, EFalse); + WaitForMockLTSYTerminated(); + + //can't read + TBuf8 readBuf; + fdnPhoneBookStore.Read(requestStatus,1,1,readBuf); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(),KErrInUse); + + CompleteCacheL(DispatcherPhonebook::EIccFdn, KErrNone, EFalse); + WaitForMockLTSYTerminated(); + + //can read + ReadL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,KErrNone); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + RBuf8 data; + CleanupClosePushL(data); + + DispatcherPhonebook::TPhonebook pB = DispatcherPhonebook::EIccFdn; + TMockLtsyData1 expLtsyData(pB); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + CleanupStack::PopAndDestroy(&data); + + + CleanupStack::PopAndDestroy(&fdnPhoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Gets the stores info using the Custom API +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::Get3GPBInfo() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsyPhonebookFU::TestUnit0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + TRequestStatus requestStatus; + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore fdnPhoneBookStore; + CleanupClosePushL(fdnPhoneBookStore); + + OpenPhoneBookL(DispatcherPhonebook::EIccFdn,fdnPhoneBookStore,customApi); + + RMmCustomAPI::T3GPBInfo info3GPB; + customApi.Get3GPBInfo(requestStatus,info3GPB); + + User::WaitForRequest(requestStatus); + + ASSERT_TRUE(info3GPB.iMaxLenEmail == iPhonebookStoreData.iEmailMaximumLength); + ASSERT_TRUE(info3GPB.iMaxLenSne == iPhonebookStoreData.iSecondNameMaximumLength); + ASSERT_TRUE(info3GPB.iMaxLenAnr == iPhonebookStoreData.iAdditionalNumberMaximumLength); + + ASSERT_TRUE(info3GPB.iMaxNumEmail == iPhonebookStoreData.iEmailMaximumFieldsPerEntry); + ASSERT_TRUE(info3GPB.iMaxNumSne == iPhonebookStoreData.iSecondNameMaximumFieldsPerEntry); + ASSERT_TRUE(info3GPB.iMaxNumAnr == iPhonebookStoreData.iAdditionalNumberMaximumFieldsPerEntry); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + RBuf8 data; + CleanupClosePushL(data); + + DispatcherPhonebook::TPhonebook pB = DispatcherPhonebook::EIccFdn; + TMockLtsyData1 expLtsyData(pB); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + CleanupStack::PopAndDestroy(&data); + + CleanupStack::PopAndDestroy(&fdnPhoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test correct function of dispatcher when sending a junk TLV from the LTSY on a read request +@SYMTestPriority High +@SYMTestActions Invokes RMobilePhone::Read() +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsyPhonebookFU::TestUnit0006L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + RBuf8 data; + CleanupClosePushL(data); + + OpenPhoneL(); + + CreateEntriesAndStoreDataL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore fdnPhoneBookStore; + CleanupClosePushL(fdnPhoneBookStore); + + DispatcherPhonebook::TPhonebook phonebook = DispatcherPhonebook::EIccFdn; + + OpenPhoneBookL(phonebook,fdnPhoneBookStore,customApi); + + TRequestStatus requestStatus; + TBuf8 readBuf; + + ExpectNonCacheReadL(phonebook,fdnPhoneBookStore,1,1,requestStatus,readBuf); + + TBuf8 tlvEntry = _L8("Junk Data"); + + TDesC8* tlvEntryPtr = &tlvEntry; + TMockLtsyData2 readEntryLtsyData(phonebook,tlvEntryPtr); + readEntryLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreReadEntry::KLtsyDispatchPhonebookStoreReadEntryApiId,KErrNone,data); + data.Close(); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(),KErrArgument); //KErrArgument generated from CPhoneBookEntry::InternalizeFromTlvEntry() + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + TMockLtsyData1 expLtsyData(phonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + CleanupStack::PopAndDestroy(&fdnPhoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::GetInfo() +@SYMTestPriority High +@SYMTestActions Invokes RMobileSmsStore::GetInfo() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhonebookFU::TestUnit0007L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RBuf8 data; + CleanupClosePushL(data); + + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + TInt totalEntries = 100; + TInt usedEntries = 10; + TMockLtsyData2 smsStoreGetInfoLtsyData(totalEntries, usedEntries); + data.Close(); + smsStoreGetInfoLtsyData.SerialiseL(data); + + TRequestStatus getInfoStatus; + TRequestStatus mockLtsyStatus; + + RMobilePhoneBookStore::TMobilePhoneBookInfoV1 phoneBookInfoV1; + TPckg pckgInfoV1(phoneBookInfoV1); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNotSupported); + + smsStore.GetInfo(getInfoStatus, pckgInfoV1); + + User::WaitForRequest(getInfoStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, getInfoStatus.Int()); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrGeneral, data); + + smsStore.GetInfo(getInfoStatus, pckgInfoV1); + + User::WaitForRequest(getInfoStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, getInfoStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileSmsStore::GetInfo() when result is not cached. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, data); + + smsStore.GetInfo(getInfoStatus, pckgInfoV1); + User::WaitForRequest(getInfoStatus); + AssertMockLtsyStatusL(); + + ASSERT_EQUALS(getInfoStatus.Int(),KErrNone); + ASSERT_EQUALS(phoneBookInfoV1.iTotalEntries, totalEntries); + ASSERT_EQUALS(phoneBookInfoV1.iUsedEntries, usedEntries); + + + //------------------------------------------------------------------------- + // TEST D: Unsolicited completion of RMobileSmsStore::GetInfo() + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, data); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // smsStore, messaging, data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::Read() +@SYMTestPriority High +@SYMTestActions Invokes RMobileSmsStore::Read() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhonebookFU::TestUnit0008L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + RBuf8 expData; + CleanupClosePushL(expData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + //------------------------------------------------------------------------- + TInt index = 5; + + RMobileSmsStore::TMobileGsmSmsEntryV1 entryV1; + entryV1.iIndex=index; + TPckg pckgEntryV1(entryV1); + + TMockLtsyData1 mockIndex(index); + + DispatcherPhonebook::TSmsData smsData; + + smsData.iSmsMsg= _L8("Hello, World!"); + smsData.iServiceCentre = _L("ServiceCenter1"); + smsData.iMobileScTON = RMobilePhone::ENetworkSpecificNumber; + smsData.iMobileScNPI = RMobilePhone::EServiceCentreSpecificPlan2; + smsData.iMessageStatus = KSimSmsMtRead; + + TMockLtsyData1 mockMsg(smsData); + + expData.Close(); + mockIndex.SerialiseL(expData); + completeData.Close(); + mockMsg.SerialiseL(completeData); + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, expData, KErrNotSupported); + + smsStore.Read(requestStatus, pckgEntryV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, KErrGeneral, completeData); + + smsStore.Read(requestStatus, pckgEntryV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileSmsStore::Read() when result is not cached. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, KErrNone, completeData); + + smsStore.Read(requestStatus, pckgEntryV1); + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(0, smsData.iSmsMsg.Compare(entryV1.iMsgData)); + ASSERT_EQUALS(0, smsData.iServiceCentre.Compare(entryV1.iServiceCentre.iTelNumber)); + ASSERT_EQUALS(smsData.iMobileScTON, entryV1.iServiceCentre.iTypeOfNumber); + ASSERT_EQUALS(smsData.iMobileScNPI, entryV1.iServiceCentre.iNumberPlan); + ASSERT_EQUALS(RMobileSmsStore::EStoredMessageRead, entryV1.iMsgStatus); + + //------------------------------------------------------------------------- + // TEST D: Unsolicited completion of RMobileSmsStore::Read() + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(5, this); // completeData, expData, smsStore, messaging, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::Write() +@SYMTestPriority High +@SYMTestActions Invokes RMobileSmsStore::Write() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhonebookFU::TestUnit0009L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open the message store + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + RBuf8 expData; + CleanupClosePushL(expData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + //------------------------------------------------------------------------- + + TInt index = 5; + + RMobileSmsStore::TMobileGsmSmsEntryV1 entryV1; + TPckg pckgEntryV1(entryV1); + + entryV1.iServiceCentre.iNumberPlan = RMobilePhone::ENationalNumberPlan; + entryV1.iServiceCentre.iTypeOfNumber = RMobilePhone::EAlphanumericNumber; + entryV1.iServiceCentre.iTelNumber = _L("TelNumber1"); + entryV1.iMsgData = _L8("Hello, World!"); + entryV1.iMsgStatus = RMobileSmsStore::EStoredMessageUnsent; + entryV1.iIndex = index; + + TMockLtsyData1 + expMockData1(entryV1); + + TInt location = 100; + TBool receivedClass2ToBeResent = ETrue; + + TMockLtsyData2 completeMockData2(location, receivedClass2ToBeResent); + + expData.Close(); + expMockData1.SerialiseL(expData); + completeData.Close(); + completeMockData2.SerialiseL(completeData); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData, KErrNotSupported); + + smsStore.Write(requestStatus, pckgEntryV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrGeneral, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); + + smsStore.Write(requestStatus, pckgEntryV1); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileSmsStore::Write() when result is not cached. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); + + smsStore.Write(requestStatus, pckgEntryV1); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(entryV1.iIndex, location); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST D: Unsolicited completion of RMobileSmsStore::Write() + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(5, this); // expData, completeData, this + // smsStore, messaging + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::Delete() +@SYMTestPriority High +@SYMTestActions Invokes RMobileSmsStore::Delete() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhonebookFU::TestUnit0010L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open the message store + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + RBuf8 expData; + CleanupClosePushL(expData); + + //------------------------------------------------------------------------- + + TInt index = 1; + + TMockLtsyData1 expMockData1(index); + expMockData1.SerialiseL(expData); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, expData, KErrNotSupported); + + smsStore.Delete(requestStatus, index); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, KErrGeneral); + + smsStore.Delete(requestStatus, index); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileSmsStore::Delete() when result is not cached. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, expData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, KErrNone); + + smsStore.Delete(requestStatus, index); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST D: Unsolicited completion of RMobileSmsStore::Delete() + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId, KErrNone); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(4, this); // expData, smsStore, messaging, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMobileSmsStore::DeleteAll() +@SYMTestPriority High +@SYMTestActions Invokes RMobileSmsStore::DeleteAll() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhonebookFU::TestUnit0011L() + { + + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open the message store + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId, KErrNotSupported); + + smsStore.DeleteAll(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId, KErrGeneral); + + smsStore.DeleteAll(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // RMobileSmsStore::DeleteAll() when result is not cached. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId, KErrNone); + + smsStore.DeleteAll(requestStatus); + + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + + //------------------------------------------------------------------------- + // TEST D: Unsolicited completion of RMobileSmsStore::DeleteAll() + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId, KErrNone); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + CleanupStack::PopAndDestroy(3, this); // smsStore, messaging, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-UN0012 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for CRetrieveMobilePhoneSmsList::Start() +@SYMTestPriority High +@SYMTestActions Invokes CRetrieveMobilePhoneSmsList::Start() +@SYMTestExpectedResults Pass +@SYMTestType UT +*/ +void CCTsyPhonebookFU::TestUnit0012L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + + TRequestStatus requestStatus; + TRequestStatus mockLtsyStatus; + + // open the message store + RMobileSmsMessaging messaging; + CleanupClosePushL(messaging); + + RMobileSmsStore smsStore; + CleanupClosePushL(smsStore); + + OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + CGetSMSListAO* getSmsListAO = CGetSMSListAO::NewLC(smsStore); + + //------------------------------------------------------------------------- + DispatcherPhonebook::TSmsData smsData; + TInt index = 0; + + smsData.iSmsMsg= _L8("Hello, World!"); + smsData.iServiceCentre = _L("ServiceCenter"); + smsData.iMobileScTON = RMobilePhone::ENetworkSpecificNumber; + smsData.iMobileScNPI = RMobilePhone::EServiceCentreSpecificPlan2; + smsData.iMessageStatus = KSimSmsMtRead; + + TBool moreToCome = ETrue; + TBool receivedClass2ToBeResent = ETrue; + + TMockLtsyData4 completeSmsMsgLtsyData(smsData, index, moreToCome, receivedClass2ToBeResent); + + TInt totalEntries(1); + TInt usedEntries(0); + + TMockLtsyData2 dataGetInfo(totalEntries, usedEntries); + completeData.Close(); + dataGetInfo.SerialiseL(completeData); + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, completeData); + User::WaitForRequest(mockLtsyStatus); + AssertMockLtsyStatusL(); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + + //------------------------------------------------------------------------- + // TEST A: failure to dispatch request to LTSY + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNotSupported); + + getSmsListAO->TestRetrieveL(); + ASSERT_EQUALS(KErrNotSupported, getSmsListAO->RetrieveLastError()); + + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST B: failure on completion of pending request from LTSY->CTSY + //------------------------------------------------------------------------- + //failure when there are no more entries to be returned + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone); + completeData.Close(); + completeSmsMsgLtsyData.SerialiseL(completeData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrGeneral, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); + + getSmsListAO->TestRetrieveL(); + ASSERT_EQUALS(KErrGeneral, getSmsListAO->RetrieveLastError()); + AssertMockLtsyStatusL(); + + //failure when there are more entries to be returned + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrGeneral, completeData); + moreToCome = EFalse; + TMockLtsyData4 completeSmsMsgLtsyData2(smsData, index, moreToCome, receivedClass2ToBeResent); + completeData.Close(); + completeSmsMsgLtsyData2.SerialiseL(completeData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); + + getSmsListAO->TestRetrieveL(); + ASSERT_EQUALS(KErrGeneral, getSmsListAO->RetrieveLastError()); + AssertMockLtsyStatusL(); + + //------------------------------------------------------------------------- + // TEST C: Successful completion request of + // CRetrieveMobilePhoneSmsList::Start when result is not cached. + //------------------------------------------------------------------------- + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone, completeData); + iMockLTSY.ExpectL(MLtsyDispatchSmsResumeSmsReception::KLtsyDispatchSmsResumeSmsReceptionApiId); + + getSmsListAO->TestRetrieveL(); + ASSERT_EQUALS(KErrNone, getSmsListAO->RetrieveLastError()); + + //assert: + RMobileSmsStore::TMobileGsmSmsEntryV1 retrievedSmsMsg; + CMobilePhoneGsmSmsList* gsmSmsList; + gsmSmsList=getSmsListAO->RetrieveListL(); + retrievedSmsMsg=gsmSmsList->GetEntryL(0); + + ASSERT_EQUALS(0, smsData.iSmsMsg.Compare(retrievedSmsMsg.iMsgData)); + ASSERT_EQUALS(0, smsData.iServiceCentre.Compare(retrievedSmsMsg.iServiceCentre.iTelNumber)); + ASSERT_EQUALS(retrievedSmsMsg.iServiceCentre.iTypeOfNumber, smsData.iMobileScTON); + ASSERT_EQUALS(retrievedSmsMsg.iServiceCentre.iNumberPlan, smsData.iMobileScNPI); + ASSERT_EQUALS(retrievedSmsMsg.iMsgStatus, RMobileSmsStore::EStoredMessageRead); + ASSERT_EQUALS(retrievedSmsMsg.iIndex, index); + + AssertMockLtsyStatusL(); + + + //------------------------------------------------------------------------- + // TEST D: Unsolicited completion of CRetrieveMobilePhoneSmsList::Start + // from LTSY. + //------------------------------------------------------------------------- + + iMockLTSY.NotifyTerminated(mockLtsyStatus); + completeSmsMsgLtsyData.SerialiseL(completeData); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, KErrNone, completeData); + + User::WaitForRequest(mockLtsyStatus); + ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(5, this); // gsmSmsList, completeData, store, messaging, this + } + +/***********************************************Helper functions***************************************/ + +/** + * Helper funtion to open a phonebook + * + * @param aPhonebook The phonebook being tested + * @param aPhoneBookStore The opened store + * @param aCustomApi The open custome API + */ +void CCTsyPhonebookFU::OpenPhoneBookL( DispatcherPhonebook::TPhonebook aPhonebook, + RMobilePhoneBookStore& aPhoneBookStore, + RMmCustomAPI& aCustomApi) + { + TRequestStatus requestStatus; + + if(CachingPhonebook(aPhonebook)) + { + //so we are notified when the cache is ready + TName phonebookName(PhonebookName(aPhonebook)); + aCustomApi.NotifyPndCacheReady(requestStatus,phonebookName); + + OpenCachingPhoneBookL(aPhonebook,aPhoneBookStore,KErrNone); + CompleteCacheL(aPhonebook, KErrNone, EFalse); + + //wait for the cache to become ready, then the phonebook is fully open + User::WaitForRequest(requestStatus); + AssertMockLtsyStatusL(); + + RMmCustomAPI::TPndCacheStatus cacheStatus; + aCustomApi.GetPndCacheStatus(requestStatus,cacheStatus,PhonebookName(aPhonebook)); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(cacheStatus,RMmCustomAPI::ECacheReady); + + } + else + { + OpenNonCachingPhoneBookL(aPhonebook,aPhoneBookStore,KErrNone); + + RMmCustomAPI::TPndCacheStatus cacheStatus; + aCustomApi.GetPndCacheStatus(requestStatus,cacheStatus,PhonebookName(aPhonebook)); + User::WaitForRequest(requestStatus); + + if(aPhonebook != DispatcherPhonebook::EIccMbdn) + { + ASSERT_EQUALS(cacheStatus,RMmCustomAPI::ECacheNotUsed); + } + } + } + +/** + * Helper funtion to open a phonebook, this expects and completes the initialisation phase + * + * @param aPhonebook The phonebook being tested + * @param aPhoneBookStore The opened store + * @param aError the Error to return from the LTSY + */ +void CCTsyPhonebookFU::OpenPhoneBookWithInitialisationL(DispatcherPhonebook::TPhonebook aPhonebook, + RMobilePhoneBookStore& aPhoneBookStore, + TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + //initialise IPC generated from phonebook store open + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId); + + ASSERT_EQUALS(aPhoneBookStore.Open(iPhone,PhonebookName(aPhonebook)),KErrNone); + + AssertMockLtsyStatusL(); + + //complete initialise IPC + TMockLtsyData1 phonebookCompLtsyData(iPhonebookStoreData); + phonebookCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,aError,data); + data.Close(); + + CleanupStack::PopAndDestroy(&data); + + iInititalised = ETrue; + } + +/** + * Helper funtion to open a caching phonebook (without the cache being completed) + * + * @param aPhonebook The phonebook being tested + * @param aPhoneBookStore The opened store + * @param aError the Error to return from the LTSY + */ +void CCTsyPhonebookFU::OpenCachingPhoneBookL( DispatcherPhonebook::TPhonebook aPhonebook, + RMobilePhoneBookStore& aPhoneBookStore, + TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + if(!iInititalised && InitialisationRequired(aPhonebook)) + { + OpenPhoneBookWithInitialisationL(aPhonebook,aPhoneBookStore,aError); + + if(aError == KErrNone) + { + //cache IPC generated from complete initialise IPC + TMockLtsyData1 cacheExpLtsyData(aPhonebook); + cacheExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCache::KLtsyDispatchPhonebookStoreCacheApiId,data); + data.Close(); + } + + //fire up the initialise complete + WaitForMockLTSYTerminated(); + } + else + { + //here the expect needs to be queued before the phone book open as if initialised then the open + //generated the cache + TMockLtsyData1 cacheExpLtsyData(aPhonebook); + cacheExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCache::KLtsyDispatchPhonebookStoreCacheApiId,data); + data.Close(); + + ASSERT_EQUALS(aPhoneBookStore.Open(iPhone,PhonebookName(aPhonebook)),KErrNone); + } + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + } + +/** + * Helper funtion to complete the cache phase of a cache request + * + * @param aPhonebook The phonebook being tested + * @param aError the Error to return from the LTSY + * @param aIsRefresh If the cache request came from a SIM refresh request + */ +void CCTsyPhonebookFU::CompleteCacheL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aError, TBool aIsRefresh) + { + //generate the TLV + RBuf8 tlv; + CleanupClosePushL(tlv); + + CPhoneBookBuffer* pbBuffer = new (ELeave) CPhoneBookBuffer(); + CleanupStack::PushL(pbBuffer); + + pbBuffer->Set(&tlv); + + TInt tlvLength = 0; + for(TInt i = 0; i < iEntries.Count(); ++i) + { + tlvLength += iEntries[i]->TlvLength(); + } + + tlv.ReAllocL(tlv.Length() + tlvLength); + + for(TInt j = 0; j < iEntries.Count(); ++j) + { + ASSERT_EQUALS(iEntries[j]->ExternalizeToTlvEntry(*pbBuffer),KErrNone); + } + + RBuf8 data; + CleanupClosePushL(data); + + TDesC8* tlvPtr = &tlv; + TMockLtsyData2 phonebookLtsyData(aPhonebook,tlvPtr); + phonebookLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreCache::KLtsyDispatchPhonebookStoreCacheApiId,aError,data); + CleanupStack::PopAndDestroy(&data); + + + CleanupStack::PopAndDestroy(pbBuffer); + CleanupStack::PopAndDestroy(&tlv); + + /********************************************************************************/ + + if(aIsRefresh) + { + //the Refresh is complete + + RBuf8 data2; + CleanupClosePushL(data2); + + TRequestStatus reqStatusTerminated; + iMockLTSY.NotifyTerminated(reqStatusTerminated); + + TMockLtsyData1 simRefreshDoneExpLtsyData(aError); + simRefreshDoneExpLtsyData.SerialiseL(data2); + iMockLTSY.ExpectL(MLtsyDispatchSimSimRefreshDone::KLtsyDispatchSimSimRefreshDoneApiId,data2); + CleanupStack::PopAndDestroy(&data2); + + User::WaitForRequest(reqStatusTerminated); + ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int()); + + //no notification when refresh is originated from the SIM + AssertMockLtsyStatusL(); + } + + //in the open case wait via a RMmCustomAPI::NotifyPndCacheReady() + + } + +/** + * Helper funtion to Open a non-caching phonebook + * + * @param aPhonebook The phonebook being tested + * @param aPhoneBookStore The opened store + * @param aError the Error to return from the LTSY + */ +void CCTsyPhonebookFU::OpenNonCachingPhoneBookL(DispatcherPhonebook::TPhonebook aPhonebook, RMobilePhoneBookStore& aPhoneBookStore, TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + if(!iInititalised && InitialisationRequired(aPhonebook)) + { + OpenPhoneBookWithInitialisationL(aPhonebook,aPhoneBookStore,aError); + + //fire up the initialise complete + WaitForMockLTSYTerminated(); + } + else + { + ASSERT_EQUALS(aPhoneBookStore.Open(iPhone,PhonebookName(aPhonebook)),KErrNone); + } + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + } + +/** + * Function to create the test data, this should be called at the start of a test case + */ +void CCTsyPhonebookFU::CreateEntriesAndStoreDataL() + { + ASSERT_EQUALS(iEntries.Count(),0); + ASSERT_TRUE(iInititalised == EFalse); + + //for CPhoneBookEntry::NewL coverage + CPhoneBookEntry* phoneBookEntry = CPhoneBookEntry::NewL(); + delete phoneBookEntry; + phoneBookEntry = NULL; + + /************************Add Entry 0***********************************/ + phoneBookEntry = CPhoneBookEntry::NewLC(); + iEntries.AppendL(phoneBookEntry); + CleanupStack::Pop(phoneBookEntry); //takes ownership + phoneBookEntry->SetIndex(1); + phoneBookEntry->SetFirstName(_L("Symbian0")); + phoneBookEntry->SetDiallingNumber(_L("123456789")); + phoneBookEntry->AddEmailAddress(_L("symbian1@symbian.com")); + phoneBookEntry->AddSecondName(_L("Phone book3")); + phoneBookEntry->AddAdditionalNumber(_L("123")); + + /************************Add Entry 1***********************************/ + phoneBookEntry = CPhoneBookEntry::NewLC(); + iEntries.AppendL(phoneBookEntry); + CleanupStack::Pop(phoneBookEntry); //takes ownership + phoneBookEntry->SetIndex(2); + phoneBookEntry->SetFirstName(_L("Symbian1")); + phoneBookEntry->SetDiallingNumber(_L("12345678910")); + phoneBookEntry->AddEmailAddress(_L("symbian3@symbian.com")); + phoneBookEntry->AddEmailAddress(_L("symbian4@symbian.com")); + phoneBookEntry->AddSecondName(_L("Phone book3")); + phoneBookEntry->AddSecondName(_L("Phone book4")); + phoneBookEntry->AddAdditionalNumber(_L("789")); + phoneBookEntry->AddAdditionalNumber(_L("101112")); + + /************************Add Entry 2***********************************/ + phoneBookEntry = CPhoneBookEntry::NewLC(); + iEntries.AppendL(phoneBookEntry); + CleanupStack::Pop(phoneBookEntry); //takes ownership + phoneBookEntry->SetIndex(3); + phoneBookEntry->SetFirstName(_L("Symbian2")); + phoneBookEntry->SetDiallingNumber(_L("12345678910")); + phoneBookEntry->AddEmailAddress(_L("symbian3@symbian.com")); + phoneBookEntry->AddEmailAddress(_L("symbian4@symbian.com")); + phoneBookEntry->AddEmailAddress(_L("symbian4@symbian.com")); + phoneBookEntry->AddSecondName(_L("Phone book3")); + phoneBookEntry->AddSecondName(_L("Phone book4")); + phoneBookEntry->AddSecondName(_L("Phone book4")); + phoneBookEntry->AddAdditionalNumber(_L("789")); + phoneBookEntry->AddAdditionalNumber(_L("101112")); + phoneBookEntry->AddAdditionalNumber(_L("101112")); + + /************************Add Entry 3***********************************/ + phoneBookEntry = CPhoneBookEntry::NewLC(); + iEntries.AppendL(phoneBookEntry); + CleanupStack::Pop(phoneBookEntry); //takes ownership + phoneBookEntry->SetIndex(4); + phoneBookEntry->SetFirstName(_L("Symbian3")); + phoneBookEntry->SetDiallingNumber(_L("12345678910")); + + /************************Test TLV creation*********************************/ + + for(TInt i = 0; i < iEntries.Count(); ++i) + { + TestTlvWriteReadL(*iEntries[i]); + } + + /************************************************************************/ + + + iPhonebookStoreData.iAdnTotalEntries = iEntries.Count(); + iPhonebookStoreData.iAdnMaximumNumberLength = KMaxNumberLength; + iPhonebookStoreData.iAdnMaximumTextLength = KMaxTextLength; + + iPhonebookStoreData.iFdnTotalEntries = iEntries.Count(); + iPhonebookStoreData.iFdnMaximumNumberLength = KMaxNumberLength; + iPhonebookStoreData.iFdnMaximumTextLength = KMaxTextLength; + + iPhonebookStoreData.iSdnTotalEntries = KNumberOfEnries; + iPhonebookStoreData.iSdnMaximumTextLength = KMaxTextLength; + iPhonebookStoreData.iSdnMaximumNumberLength = KMaxNumberLength; + + iPhonebookStoreData.iVmbTotalEntries = KNumberOfEnries; + iPhonebookStoreData.iVmbMaximumTextLength = KMaxTextLength; + iPhonebookStoreData.iVmbMaximumNumberLength = KMaxNumberLength; + iPhonebookStoreData.iVmbCapabilities = 0; + + iPhonebookStoreData.iMbdnTotalEntries = KNumberOfEnries; + iPhonebookStoreData.iMbdnMaximumTextLength = KMaxTextLength; + iPhonebookStoreData.iMbdnMaximumNumberLength = KMaxNumberLength; + iPhonebookStoreData.iMbdnCapabilities = 0; + + iPhonebookStoreData.iEmailMaximumFieldsPerEntry = 101; + iPhonebookStoreData.iEmailMaximumLength = KMaxTextLength; + + iPhonebookStoreData.iAdditionalNumberMaximumFieldsPerEntry = 102; + iPhonebookStoreData.iAdditionalNumberMaximumLength = KMaxNumberLength; + + iPhonebookStoreData.iSecondNameMaximumFieldsPerEntry = 103; + iPhonebookStoreData.iSecondNameMaximumLength = KMaxTextLength; + + + iInititalised = EFalse; + } + +/** + * Helper funtion to test the Read functionality + * + * @param aPhonebook The phonebook being tested + * @param aPhoneBookStore The opened store + * @param aError the Error to return from the LTSY + */ +void CCTsyPhonebookFU::ReadL(DispatcherPhonebook::TPhonebook aPhonebook, const RMobilePhoneBookStore& aPhonebookStore, TInt aError) + { + if(CachingPhonebook(aPhonebook)) + { + //read one entry, when one entry is read this does a non-cache read + //thus down to the LTSY + for(TInt i = 1; i <= iEntries.Count(); ++i) + { + NonCacheReadL(aPhonebook,aPhonebookStore,i,1,aError); + } + + //read two entries, (> 1) thus a cache read + CacheReadL(aPhonebookStore,1,iEntries.Count()); + } + else //non caching phonebook + { + + //test a single entry + for(TInt i = 1; i <= iEntries.Count(); ++i) + { + NonCacheReadL(aPhonebook,aPhonebookStore,i,1,aError); + } + + //test all entries + NonCacheReadL(aPhonebook,aPhonebookStore,1,iEntries.Count(),aError); + + } + } + +/** + * Helper funtion to test the Read functionality + * + * @param aPhonebook The phonebook being tested + * @param aError the Error to return from the LTSY + */ +void CCTsyPhonebookFU::ReadL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aError) + { + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + OpenPhoneBookL(aPhonebook,phoneBookStore,customApi); + + ReadL(aPhonebook,phoneBookStore,aError); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + if (CachingPhonebook(aPhonebook)) + { + RBuf8 data; + CleanupClosePushL(data); + + TMockLtsyData1 expLtsyData(aPhonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + CleanupStack::PopAndDestroy(&data); + } + + CleanupStack::PopAndDestroy(&phoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + } + +/** + * Helper funtion to do a cache read + * + * @param aPhoneBookStore The opened store + * @param aIndex The index being read + * @param aNumberOfSlots The number of slots being read + */ +void CCTsyPhonebookFU::CacheReadL(const RMobilePhoneBookStore& aPhoneBookStore, TInt aIndex, TInt aNumberOfSlots) + { + TRequestStatus requestStatus; + + RBuf8 phonebookTlv; + CleanupClosePushL(phonebookTlv); + phonebookTlv.CreateL(KReadBufLength * aNumberOfSlots); + + //the cache read + aPhoneBookStore.Read(requestStatus,aIndex,aNumberOfSlots,phonebookTlv); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(),KErrNone) + + RPointerArray phonebookArray; + TCleanupItem arrayCleanup( PhoneBookEntryArrayCleanup, &phonebookArray); + CleanupStack::PushL(arrayCleanup); + + //convert TLV -> CPhoneBookEntry(s) + FillPhonebookEntryArrayFromTlvL(phonebookTlv,phonebookArray); + + //check the TLV is the what we expect + ASSERT_EQUALS(aNumberOfSlots,phonebookArray.Count()); + for(TInt i = 0; i < phonebookArray.Count(); ++i) + { + ASSERT_EQUALS(*phonebookArray[i],*iEntries[aIndex + i -1]); + } + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&phonebookArray); + CleanupStack::PopAndDestroy(&phonebookTlv); + } + +/** + * Helper funtion to do a complete non-cache read + * + * @param aPhonebook The phonebook being tested + * @param aPhoneBookStore The opened store + * @param aIndex The index being read + * @param aNumberOfSlots The number of slots being read + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::NonCacheReadL( DispatcherPhonebook::TPhonebook aPhonebook, + const RMobilePhoneBookStore& aPhoneBookStore, + TInt aIndex, + TInt aNumberOfSlots, + TInt aError) + { + TRequestStatus requestStatus; + + RBuf8 readBuf; + CleanupClosePushL(readBuf); + readBuf.CreateL(KReadBufLength * aNumberOfSlots); + + ExpectNonCacheReadL(aPhonebook,aPhoneBookStore,aIndex,aNumberOfSlots,requestStatus,readBuf); + CompleteNonCacheReadL(aPhonebook,aIndex,aNumberOfSlots,requestStatus,readBuf,aError); + + CleanupStack::PopAndDestroy(&readBuf); + } + +/** + * Helper funtion to start the non-cache read + * + * @param aPhonebook The phonebook being tested + * @param aPhoneBookStore The opened store + * @param aIndex The index being read + * @param aNumberOfSlots The number of slots being read + * @param aRequestStatus The pending TRequestStatus to wait on + * @param aReadData The data read (Returned to ETel) + * + */ +void CCTsyPhonebookFU::ExpectNonCacheReadL( DispatcherPhonebook::TPhonebook aPhonebook, + const RMobilePhoneBookStore& aPhoneBookStore, + TInt aIndex, + TInt aNumberOfSlots, + TRequestStatus& aRequestStatus, + TDes8& aReadData) + { + RBuf8 data; + CleanupClosePushL(data); + + TMockLtsyData3 readEntryData(aPhonebook,aIndex,aNumberOfSlots); + readEntryData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreReadEntry::KLtsyDispatchPhonebookStoreReadEntryApiId,data); + data.Close(); + + aPhoneBookStore.Read(aRequestStatus,aIndex,aNumberOfSlots,aReadData); + ASSERT_EQUALS(aRequestStatus.Int(),KRequestPending); + + CleanupStack::PopAndDestroy(&data); + } + +/** + * Helper funtion to complete the non-cache read + * + * @param aPhonebook The phonebook being tested + * @param aIndex The index being read + * @param aNumberOfSlots The number of slots being read + * @param aRequestStatus The pending TRequestStatus to wait on + * @param aReadData The data read (Returned to ETel) + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::CompleteNonCacheReadL( DispatcherPhonebook::TPhonebook aPhonebook, + TInt aIndex, + TInt aNumberOfSlots, + TRequestStatus& aRequestStatus, + const TDesC8& aReadData, + TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + RPointerArray phonebook; + CleanupClosePushL(phonebook); + + for(TInt i = 0; i < aNumberOfSlots; ++i) + { + phonebook.AppendL(iEntries[i + aIndex - 1]); //not owned + } + + RBuf8 tlvEntry; + CleanupClosePushL(tlvEntry); + + CreateTlvFromPhonebookL(phonebook,tlvEntry); + + TDesC8* tlvEntryPtr = &tlvEntry; + TMockLtsyData2 readEntryLtsyData(aPhonebook,tlvEntryPtr); + readEntryLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreReadEntry::KLtsyDispatchPhonebookStoreReadEntryApiId,aError,data); + data.Close(); + + User::WaitForRequest(aRequestStatus); + + ASSERT_EQUALS(aRequestStatus.Int(),aError) + if(aError == KErrNone) + { + ASSERT_TRUE(tlvEntry == aReadData); + } + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&tlvEntry); + CleanupStack::PopAndDestroy(&phonebook); + CleanupStack::PopAndDestroy(&data); + } + +/** + * Helper funtion to Test the Delete function on a phonebook + * + * @param aPhonebook The phonebook to test + * @param aIndexToDelete The index to remove + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::DeleteL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aIndexToDelete, TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + + OpenPhoneBookL(aPhonebook,phoneBookStore,customApi); + + TMockLtsyData2 deleteExpLtsyData(aPhonebook,aIndexToDelete); + deleteExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreDeleteEntry::KLtsyDispatchPhonebookStoreDeleteEntryApiId,data); + data.Close(); + + phoneBookStore.Delete(requestStatus,aIndexToDelete); + + TInt newMaxNumberLength = ( aPhonebook == DispatcherPhonebook::EIccFdn || + aPhonebook == DispatcherPhonebook::EIccAdn || + aPhonebook == DispatcherPhonebook::EIccVmb ) ? KNewMaxTextLength : KErrNotFound; + + TMockLtsyData2 deleteCompLtsyData(aPhonebook,newMaxNumberLength); + deleteCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreDeleteEntry::KLtsyDispatchPhonebookStoreDeleteEntryApiId, aError, data); + data.Close(); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(aError, requestStatus.Int()); + + AssertMockLtsyStatusL(); + + //now check newMaxNumberLength is correct in the CTSY + + switch(aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + iPhonebookStoreData.iAdnMaximumNumberLength = newMaxNumberLength; + break; + case DispatcherPhonebook::EIccFdn: + iPhonebookStoreData.iFdnMaximumNumberLength = newMaxNumberLength; + break; + case DispatcherPhonebook::EIccVmb: + iPhonebookStoreData.iVmbMaximumNumberLength = newMaxNumberLength; + break; + default: + break; + } + + CheckPhonebookDetailsL(aPhonebook,phoneBookStore,iEntries.Count() - ((aError == KErrNone) ? 1 : 0),aError); + + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + if (CachingPhonebook(aPhonebook)) + { + TMockLtsyData1 expLtsyData(aPhonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + } + + CleanupStack::PopAndDestroy(&phoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&data); + } + +/** + * Helper funtion to Test DeleteAll function on a phonebook + * + * @param aPhonebook The phonebook to test + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::DeleteAllL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + + OpenPhoneBookL(aPhonebook,phoneBookStore,customApi); + + TMockLtsyData1 deleteAllExpLtsyData(aPhonebook); + deleteAllExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreDeleteAll::KLtsyDispatchPhonebookStoreDeleteAllApiId,data); + data.Close(); + + phoneBookStore.DeleteAll(requestStatus); + + TInt newMaxNumberLength = ( aPhonebook == DispatcherPhonebook::EIccFdn || + aPhonebook == DispatcherPhonebook::EIccAdn || + aPhonebook == DispatcherPhonebook::EIccVmb ) ? KNewMaxTextLength : KErrNotFound; + + + TMockLtsyData2 deleteAllCompLtsyData(aPhonebook,newMaxNumberLength); + deleteAllCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreDeleteAll::KLtsyDispatchPhonebookStoreDeleteAllApiId,aError,data); + data.Close(); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(aError, requestStatus.Int()); + + AssertMockLtsyStatusL(); + + //now check newMaxNumberLength is correct in the CTSY + + switch(aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + iPhonebookStoreData.iAdnMaximumNumberLength = newMaxNumberLength; + break; + case DispatcherPhonebook::EIccFdn: + iPhonebookStoreData.iFdnMaximumNumberLength = newMaxNumberLength; + break; + case DispatcherPhonebook::EIccVmb: + iPhonebookStoreData.iVmbMaximumNumberLength = newMaxNumberLength; + break; + default: + break; + } + + CheckPhonebookDetailsL(aPhonebook,phoneBookStore,(aError == KErrNone) ? 0 : iEntries.Count(),aError); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + if (CachingPhonebook(aPhonebook)) + { + TMockLtsyData1 expLtsyData(aPhonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + } + + CleanupStack::PopAndDestroy(&phoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(&data); + } + +/** + * Helper funtion to Test the writing to a phonebook + * + * @param aPhonebook The phonebook to test + * @param aPhoneBookEntry The entry to write + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::WriteL(DispatcherPhonebook::TPhonebook aPhonebook, const CPhoneBookEntry& aPhoneBookEntry, TInt aError) + { + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + + OpenPhoneBookL(aPhonebook,phoneBookStore,customApi); + WriteL(aPhonebook,phoneBookStore,aPhoneBookEntry,aError); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + if (CachingPhonebook(aPhonebook)) + { + RBuf8 data; + CleanupClosePushL(data); + + TMockLtsyData1 expLtsyData(aPhonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + CleanupStack::PopAndDestroy(&data); + } + + CleanupStack::PopAndDestroy(&phoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + } + +/** + * Helper funtion to Test the writing to a phonebook + * + * @param aPhonebook The phonebook to test + * @param aPhoneBookStore The opened store + * @param aPhoneBookEntry The entry to write + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::WriteL( DispatcherPhonebook::TPhonebook aPhonebook, + const RMobilePhoneBookStore& aPhonebookStore, + const CPhoneBookEntry& aPhoneBookEntry, + TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + RBuf8 buf; + CleanupClosePushL(buf); + buf.CreateL(aPhoneBookEntry.TlvLength()); + CreateTlvFromEntryL(aPhoneBookEntry,buf); + + TDesC8* bufPtr = &buf; + TMockLtsyData2 writeEntryExpLtsyData(aPhonebook,bufPtr); + writeEntryExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreWriteEntry::KLtsyDispatchPhonebookStoreWriteEntryApiId,data); + data.Close(); + + TInt index = aPhoneBookEntry.GetIndex(); + aPhonebookStore.Write(requestStatus,buf,index); + + TUint16 writtenIndex = aPhoneBookEntry.GetIndex(); + + TInt newMaxNumberLength = ( aPhonebook == DispatcherPhonebook::EIccFdn || + aPhonebook == DispatcherPhonebook::EIccAdn || + aPhonebook == DispatcherPhonebook::EIccVmb ) ? KNewMaxTextLength : KErrNotFound; + + TMockLtsyData3 writeEntryCompLtsyData(aPhonebook,writtenIndex,newMaxNumberLength); + writeEntryCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreWriteEntry::KLtsyDispatchPhonebookStoreWriteEntryApiId,aError,data); + data.Close(); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(aError, requestStatus.Int()); + + //index is passed in as a reference and returned where the entry was written + ASSERT_TRUE(index == writtenIndex); + + AssertMockLtsyStatusL(); + + //now check newMaxNumberLength is correct in the CTSY + + switch(aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + iPhonebookStoreData.iAdnMaximumNumberLength = newMaxNumberLength; + break; + case DispatcherPhonebook::EIccFdn: + iPhonebookStoreData.iFdnMaximumNumberLength = newMaxNumberLength; + break; + case DispatcherPhonebook::EIccVmb: + iPhonebookStoreData.iVmbMaximumNumberLength = newMaxNumberLength; + break; + default: + break; + } + + const TInt newEntryCount = (aError == KErrNone || + aError == KErrGsmSimServSneFull || + aError == KErrGsmSimServAnrFull || + aError == KErrGsmSimServEmailFull) ? 1 : 0; + CheckPhonebookDetailsL(aPhonebook,aPhonebookStore,iEntries.Count() + newEntryCount,aError); + + CleanupStack::PopAndDestroy(&buf); + CleanupStack::PopAndDestroy(&data); + } + + +/** + * Helper funtion to check the phonebook store details. + * + * @param aPhonebook The phonebook to test + * @param aPhonebookStore The open store + * @param aEntries The number of entries expected in the store + * @param + */ +void CCTsyPhonebookFU::CheckPhonebookDetailsL( DispatcherPhonebook::TPhonebook aPhonebook, + const RMobilePhoneBookStore& aPhonebookStore, + TInt aEntries, + TInt aError) + { + switch(aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + case DispatcherPhonebook::EIccFdn: + case DispatcherPhonebook::EIccMbdn: + { + GetInfoFromCtsy(aPhonebook,aPhonebookStore,aEntries); + } + break; + case DispatcherPhonebook::EIccSdn: + case DispatcherPhonebook::EIccVmb: + { + GetInfoFromLtsyL(aPhonebook,aPhonebookStore,aEntries,aError); + } + default: + { + } + break; + } + } + +/** + * Helper funtion to Test getting the phonebook store info from the CTSY & LTSY + * + * @param aPhonebook The phonebook to test + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::GetInfoL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aError) + { + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RMobilePhoneBookStore phoneBookStore; + CleanupClosePushL(phoneBookStore); + + OpenPhoneBookL(aPhonebook,phoneBookStore,customApi); + + CheckPhonebookDetailsL(aPhonebook,phoneBookStore,iEntries.Count(),aError); + + // destroying the phonebook store, while one of the caching phonebooks + // ADN/FDN is in the not-ready state will result in a store cache cancel + // message being generated by the ctsy + + if (CachingPhonebook(aPhonebook)) + { + RBuf8 data; + CleanupClosePushL(data); + + TMockLtsyData1 expLtsyData(aPhonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + CleanupStack::PopAndDestroy(&data); + } + + CleanupStack::PopAndDestroy(&phoneBookStore); + CleanupStack::PopAndDestroy(&customApi); + } + + +/** + * Helper funtion to Test getting the phonebook store info from the CTSY + * + * @param aPhonebook The phonebook to test + */ +void CCTsyPhonebookFU::GetInfoFromCtsy(DispatcherPhonebook::TPhonebook aPhonebook, + const RMobilePhoneBookStore& aPhonebookStore, + TInt aUsedEntries) + { + TRequestStatus requestStatus; + + RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo; + RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookInfoPckg(bookInfo); + + aPhonebookStore.GetInfo(requestStatus,bookInfoPckg); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(bookInfo.iType, RMobilePhoneStore::EPhoneBookStore); + ASSERT_EQUALS(bookInfo.iLocation, RMobilePhoneBookStore::ELocationIccMemory); + + switch(aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + { + ASSERT_EQUALS(bookInfo.iTotalEntries, iPhonebookStoreData.iAdnTotalEntries); + ASSERT_EQUALS(bookInfo.iUsedEntries, aUsedEntries); + ASSERT_EQUALS(bookInfo.iMaxNumLength, iPhonebookStoreData.iAdnMaximumNumberLength); + ASSERT_EQUALS(bookInfo.iMaxTextLength,iPhonebookStoreData.iAdnMaximumTextLength); + } + break; + + case DispatcherPhonebook::EIccFdn: + { + ASSERT_EQUALS(bookInfo.iTotalEntries, iPhonebookStoreData.iFdnTotalEntries); + ASSERT_EQUALS(bookInfo.iUsedEntries, aUsedEntries); + ASSERT_EQUALS(bookInfo.iMaxNumLength, iPhonebookStoreData.iFdnMaximumNumberLength); + ASSERT_EQUALS(bookInfo.iMaxTextLength, iPhonebookStoreData.iFdnMaximumTextLength); + } + break; + + case DispatcherPhonebook::EIccMbdn: + { + ASSERT_EQUALS(bookInfo.iTotalEntries, iPhonebookStoreData.iMbdnTotalEntries); + //The CTSY does not cache Mbdn entires but does not sent a request down to the LTSY + //like other non cached phonebooks for the used entires count, possible CTSY defect? + //ASSERT_EQUALS(bookInfo.iUsedEntries, aUsedEntries); + ASSERT_EQUALS(bookInfo.iMaxNumLength, iPhonebookStoreData.iMbdnMaximumNumberLength); + ASSERT_EQUALS(bookInfo.iMaxTextLength, iPhonebookStoreData.iMbdnMaximumTextLength); + + } + break; + + default: + { + } + break; + } + } + +/** + * Helper funtion to Test getting the phonebook store info from the LTSY + * + * @param aPhonebook The phonebook to test + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::GetInfoFromLtsyL(DispatcherPhonebook::TPhonebook aPhonebook, + const RMobilePhoneBookStore& aPhonebookStore, + TInt aUsedEntries, + TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + TMockLtsyData1 getInfoExpLtsyData(aPhonebook); + getInfoExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreGetPhonebookInfo::KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId,data); + data.Close(); + + + RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo; + RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookInfoPckg(bookInfo); + aPhonebookStore.GetInfo(requestStatus,bookInfoPckg); + + TMockLtsyData2 getInfoCompLtsyData(aPhonebook,aUsedEntries); + getInfoCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreGetPhonebookInfo::KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId,aError,data); + data.Close(); + + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(aError,requestStatus.Int()); + ASSERT_EQUALS(bookInfo.iType, RMobilePhoneStore::EPhoneBookStore); + ASSERT_EQUALS(bookInfo.iLocation, RMobilePhoneBookStore::ELocationIccMemory); + + if(aError == KErrNone) + { + ASSERT_EQUALS(bookInfo.iUsedEntries,aUsedEntries); + } + + switch(aPhonebook) + { + case DispatcherPhonebook::EIccSdn: + { + ASSERT_EQUALS(bookInfo.iTotalEntries,iPhonebookStoreData.iSdnTotalEntries); + ASSERT_EQUALS(bookInfo.iMaxNumLength,iPhonebookStoreData.iSdnMaximumNumberLength); + ASSERT_EQUALS(bookInfo.iMaxTextLength,iPhonebookStoreData.iSdnMaximumTextLength); + } + break; + + case DispatcherPhonebook::EIccVmb: + { + ASSERT_EQUALS(bookInfo.iTotalEntries,iPhonebookStoreData.iVmbTotalEntries); + ASSERT_EQUALS(bookInfo.iMaxNumLength,iPhonebookStoreData.iVmbMaximumNumberLength); + ASSERT_EQUALS(bookInfo.iMaxTextLength,iPhonebookStoreData.iVmbMaximumTextLength); + } + break; + + default: + { + + } + break; + } + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + } + +/** + * Helper funtion to Test the Set Fdn Info IPC + * + * @param aError The error to return from the LTSY + */ +void CCTsyPhonebookFU::SetFdnInfoL(RMobilePhoneBookStore& aPhoneBookStore, TInt aError) + { + RBuf8 data; + CleanupClosePushL(data); + + TInt totalEntries = iEntries.Count(); + TInt maximumTextLength = KMaxTextLength; + TInt maximumNumberLength = KMaxNumberLength; + + TMockLtsyData3 phonebookDataCompLtsyData(totalEntries,maximumTextLength,maximumNumberLength); + phonebookDataCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchPhonebookStoreSetFdnPhonebookInfoIndId,aError,data); + data.Close(); + + WaitForMockLTSYTerminated(); + + AssertMockLtsyStatusL(); + + //now check the info + + if(aError == KErrNone) + { + iPhonebookStoreData.iFdnTotalEntries = totalEntries; + iPhonebookStoreData.iFdnMaximumTextLength = maximumTextLength; + iPhonebookStoreData.iFdnMaximumNumberLength = maximumNumberLength; + } + + TRequestStatus requestStatus; + RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo; + RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookInfoPckg(bookInfo); + aPhoneBookStore.GetInfo(requestStatus,bookInfoPckg); + User::WaitForRequest(requestStatus); + + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + ASSERT_EQUALS(bookInfo.iType, RMobilePhoneStore::EPhoneBookStore); + ASSERT_EQUALS(bookInfo.iLocation, RMobilePhoneBookStore::ELocationIccMemory); + ASSERT_EQUALS(bookInfo.iTotalEntries, iPhonebookStoreData.iFdnTotalEntries); + ASSERT_EQUALS(bookInfo.iUsedEntries, iEntries.Count()); + ASSERT_EQUALS(bookInfo.iMaxNumLength, iPhonebookStoreData.iFdnMaximumNumberLength); + ASSERT_EQUALS(bookInfo.iMaxTextLength, iPhonebookStoreData.iFdnMaximumTextLength); + + CleanupStack::PopAndDestroy(&data); + } + +/** + * Helper funtion to Test the Refresh IPC + * + * @param aPhonebook The phonebook to test + */ +void CCTsyPhonebookFU::RefreshL(DispatcherPhonebook::TPhonebook aPhonebook) + { + RBuf8 data; + CleanupClosePushL(data); + + //KCacheAdn KCacheFdn KCacheServiceTable KCacheALSline + TUint16 refreshFileList = 0; + + switch(aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + refreshFileList = KCacheAdn; + break; + case DispatcherPhonebook::EIccFdn: + refreshFileList = KCacheFdn; + break; + default: + break; + } + + TMockLtsyData1 refreshFileListData(refreshFileList); + refreshFileListData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSimRefreshSimFilesIndId, KErrNone, data); + data.Close(); + + iMockLTSY.ExpectL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId); + + // Prepare data for the mockLtsy's CompleteL Note the CTSY expects the data in 8-bit format. + _LIT8 (KIMSI8, "012012012012999"); + TBuf8 idComp(KIMSI8); + TMockLtsyData1 > idCompData(idComp); + idCompData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSimGetSubscriberId::KLtsyDispatchSimGetSubscriberIdApiId, KErrNone, data); + data.Close(); + + TMockLtsyData1 expLtsyData(aPhonebook); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,data); + data.Close(); + + + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId); + + //complete initialise IPC + TMockLtsyData1 phonebookCompLtsyData(iPhonebookStoreData); + phonebookCompLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,KErrNone,data); + data.Close(); + + TMockLtsyData1 cacheExpLtsyData(aPhonebook); + cacheExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreCache::KLtsyDispatchPhonebookStoreCacheApiId,data); + data.Close(); + + CompleteCacheL(aPhonebook, KErrNone, ETrue); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + } + +/** + * @param aPhonebook The phonebook to check + * @return True if the phonebook sends down the initialise IPC on the first phonebook opened + */ +TBool CCTsyPhonebookFU::InitialisationRequired(DispatcherPhonebook::TPhonebook aPhonebook) const + { + switch (aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + case DispatcherPhonebook::EIccFdn: + case DispatcherPhonebook::EIccVmb: + case DispatcherPhonebook::EIccMbdn: + case DispatcherPhonebook::EIccSdn: + case DispatcherPhonebook::EIccBdn: + return ETrue; + + default: + return EFalse; + } + } + +/** + * @param aPhonebook The phonebook to check + * @return True if the phonebook caches the entries, false otherwise + */ + +TBool CCTsyPhonebookFU::CachingPhonebook(DispatcherPhonebook::TPhonebook aPhonebook) const + { + switch (aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + case DispatcherPhonebook::EIccFdn: + return ETrue; + default: + return EFalse; + + } + } + +/** + * Creates a TLV phonebook entry from a CPhoneBookEntry + * + * @param aPhoneBookEntry The entry to create the TLV from + * @param aBuf The buffer to write the TLV to + */ +void CCTsyPhonebookFU::CreateTlvFromEntryL(const CPhoneBookEntry& aPhoneBookEntry, RBuf8& aBuf) + { + RPointerArray phonebook; + CleanupClosePushL(phonebook); + + phonebook.AppendL(&aPhoneBookEntry); + + CreateTlvFromPhonebookL(phonebook,aBuf); + + CleanupStack::Pop(&phonebook); + phonebook.Close(); + } + +/** + * Creates a TLV phonebook entry from a CPhoneBookEntry array + * + * @param aPhonebook The phonebook entries to create the TLV from + * @param aBuf The buffer to write the TLV to + */ +void CCTsyPhonebookFU::CreateTlvFromPhonebookL(const RPointerArray& aPhonebook, RBuf8& aBuf) + { + TInt tlvSize = 0; + for(TInt i = 0; i < aPhonebook.Count(); ++i) + { + tlvSize += aPhonebook[i]->TlvLength(); + } + + aBuf.ReAllocL(tlvSize); + + CPhoneBookBuffer* pbBuffer = new (ELeave) CPhoneBookBuffer(); + CleanupStack::PushL(pbBuffer); + + pbBuffer->Set(&aBuf); + + for(TInt j = 0; j < aPhonebook.Count(); ++j) + { + aPhonebook[j]->ExternalizeToTlvEntry(*pbBuffer); + } + + CleanupStack::PopAndDestroy(pbBuffer); + } + +/** + * Fills a CPhoneBookEntry array from a phonebook TLV + * + * @param aEntry The entry in TLV form + * @param aPhoneBook The entry array to be filled + */ +void CCTsyPhonebookFU::FillPhonebookEntryArrayFromTlvL(const TDesC8& aEntry, RPointerArray& aPhoneBook) + { + CPhoneBookBuffer* pbBuffer = new (ELeave) CPhoneBookBuffer(); + CleanupStack::PushL(pbBuffer); + + RBuf8 buf; + CleanupClosePushL(buf); + + buf.CreateL(aEntry); + + pbBuffer->Set(&buf); + pbBuffer->StartRead(); + + TInt entriesCount = 0; + while(pbBuffer->RemainingReadLength() > 0) + { + entriesCount++; + CPhoneBookEntry* entry = CPhoneBookEntry::NewLC(); + aPhoneBook.AppendL(entry); + CleanupStack::Pop(entry); + + ASSERT_EQUALS(entry->InternalizeFromTlvEntry(*pbBuffer,entriesCount > 1),KErrNone); + } + + + CleanupStack::PopAndDestroy(&buf); + CleanupStack::PopAndDestroy(pbBuffer); + } + +/** + * Test the CPhoneBookEntry ExternalizeToTlvEntry and InternalizeFromTlvEntry functions + * + * @param aPhoneBookEntry The entry to test + */ + +void CCTsyPhonebookFU::TestTlvWriteReadL(const CPhoneBookEntry& aPhoneBookEntry) + { + RBuf8 tlv; + CleanupClosePushL(tlv); + tlv.CreateL(aPhoneBookEntry.TlvLength()); + + CPhoneBookBuffer* phonebookBuffer = new (ELeave) CPhoneBookBuffer(); + CleanupStack::PushL(phonebookBuffer); + phonebookBuffer->Set(&tlv); + + //convert to a TLV + ASSERT_EQUALS(aPhoneBookEntry.ExternalizeToTlvEntry(*phonebookBuffer),KErrNone); + + //the length should equal the maxlength if CPhoneBookEntry::TlvLength() is correct + //(with 3 spare slots for worst case padding) + ASSERT_EQUALS(tlv.Length() + 3,tlv.MaxLength()); + + CPhoneBookEntry* phonebookEntry = CPhoneBookEntry::NewLC(); + + phonebookBuffer->StartRead(); + + //convert the TLV back to a phone book entry + ASSERT_EQUALS(phonebookEntry->InternalizeFromTlvEntry(*phonebookBuffer),KErrNone); + + ASSERT_EQUALS(aPhoneBookEntry,*phonebookEntry); + + CleanupStack::PopAndDestroy(phonebookEntry); + CleanupStack::PopAndDestroy(phonebookBuffer); + CleanupStack::PopAndDestroy(&tlv); + } + +/** + * Converts a Phone enum type to the ETel name + * + * @param aPhonebook The phonebook type + * @return The ETel store name + */ +TName CCTsyPhonebookFU::PhonebookName(DispatcherPhonebook::TPhonebook aPhonebook) const + { + + TName phonebookName; + + switch(aPhonebook) + { + case DispatcherPhonebook::EIccAdn: + { + phonebookName = KETelIccAdnPhoneBook; + } + break; + + case DispatcherPhonebook::EIccBdn: + { + phonebookName = KETelIccBdnPhoneBook; + } + break; + + case DispatcherPhonebook::EIccSdn: + { + phonebookName = KETelIccSdnPhoneBook; + } + break; + + case DispatcherPhonebook::EIccFdn: + { + phonebookName = KETelIccFdnPhoneBook; + } + break; + + case DispatcherPhonebook::EIccVmb: + { + phonebookName = KETelIccVoiceMailBox; + } + break; + + case DispatcherPhonebook::EIccMbdn: + { + phonebookName = KETelIccMbdnPhoneBook; + } + break; + + case DispatcherPhonebook::EUnknown: + default: + { + //do nothing; + } + } + + return phonebookName; + } + +void CCTsyPhonebookFU::PhoneBookEntryArrayCleanup(TAny* aArray) + { + static_cast*>(aArray)->ResetAndDestroy(); + } + +void CCTsyPhonebookFU::OpenSmsStoreL(RMobileSmsMessaging& aSmsMessaging, RMobileSmsStore& aSmsStore, const TDesC& aSmsStoreName) + { + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId); + + User::LeaveIfError(aSmsMessaging.Open(iPhone)); + User::LeaveIfError(aSmsStore.Open(aSmsMessaging, aSmsStoreName)); + + RBuf8 data; + CleanupClosePushL(data); + + TInt totalEntries = 0; + TInt usedEntries = 0; + TMockLtsyData2 smsStoreGetInfoLtsyData(totalEntries, usedEntries); + data.Close(); + smsStoreGetInfoLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrGeneral, data); + + WaitForMockLTSYTerminated(); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + } + +void CCTsyPhonebookFU::DoCleanup() + { + iInititalised = EFalse; + iEntries.ResetAndDestroy(); + CCtsyComponentTestBase::DoCleanup(); + } + +