// 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 <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <test/tmockltsydata.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/ltsy/cphonebookentry.h>

#include <ctsy/ltsy/mltsydispatchsiminterface.h>

#include <ctsy/ltsy/mltsydispatchsmsinterface.h>

#include "mockltsyindicatorids.h"

#include <ctsy/ltsy/cctsydispatchercallback.h>

#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<DispatcherPhonebook::TPhonebook> 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<KReadBufLength> adnData;

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

		TRequestStatus fdnRequestStatus;

		TBuf8<KReadBufLength> fdnData;

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

		TRequestStatus bdnRequestStatus;

		TBuf8<KReadBufLength> bdnData;

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

		TRequestStatus sdnRequestStatus;

		TBuf8<KReadBufLength> sdnData;

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

		TRequestStatus vmbRequestStatus;

		TBuf8<KReadBufLength> vmbData;

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

		TRequestStatus mbdnRequestStatus;

		TBuf8<KReadBufLength> 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);