// Copyright (c) 2007-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 PhoneBookStore in the Common TSY.
*/

#include "cctsyphonebookstorefu.h"
#include <etel.h>
#include <etelmm.h>
#include <et_clsvr.h>
#include <ctsy/rmmcustomapi.h>
#include <ctsy/mmtsy_names.h>
#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
#include "tmockltsydata.h"
#include <ctsy/serviceapi/gsmerror.h>

const TInt KOneSecond=1000000;  // Used in a time out function, 1 second (in microSeconds)

CTestSuite* CCTsyPhoneBookStoreFU::CreateSuiteL(const TDesC& aName)
	{
	SUB_SUITE;
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0001bL);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0004bL);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0005L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00010L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00013L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00015L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00016L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00017L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00018L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00019L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00020L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00021L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00022L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00023L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00024L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00025L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00026L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00027L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00028L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00029L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestRead00030L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0005L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00010L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00016L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00017L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00018L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00019L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00020L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00021L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00022L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00023L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00024L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00025L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00026L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00027L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00028L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00029L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestWrite00030L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent0007L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent0009L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00010L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00016L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00017L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00018L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00019L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00020L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00021L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00022L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00023L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00024L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00025L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00026L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00027L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00028L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00029L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestNotifyStoreEvent00030L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0005L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00010L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00016L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00017L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00018L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00019L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00020L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00021L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00022L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00023L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00024L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00025L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00026L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00027L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00028L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00029L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDelete00030L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0001L);     //adn
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0004L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0005L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0006L);     //fdn
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0006bL);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0007L);  
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo0009L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00010L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00011L);   //sdn
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00013L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00015L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00016L);    //vmbx
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00017L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00018L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00019L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00020L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00021L);    //bdn
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00022L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00023L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00024L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00025L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00026L);    //mbdn
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00027L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00028L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00029L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestGetInfo00030L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0002L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0005L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0007L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00010L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00016L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00017L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00018L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00019L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00020L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00021L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00022L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00023L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00024L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00025L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00026L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00027L);
	//ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00028L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00029L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestDeleteAll00030L);
	
	// test for coverage increasing
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Read0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Read0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Read0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Read0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Read0005L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Read0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test3Read0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test3Read0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test3Read0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Write0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Write0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Write0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Write0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Write0005L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, Test2Write0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyPhoneBookStoreFU, TestOpen0001L);

	END_SUITE;
	}


//
// Actual test cases
//


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0001L()
	{
	AuxRead1L(KETelIccAdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0001b
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support for SIM refresh register Off in CTSY for RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0001bL()
	{
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));

    // SIM refresh register OFF
    OpenPhone2L(KErrGeneral);

    RBuf8 data;
    CleanupClosePushL(data);

    RBuf8 data2;
    CleanupClosePushL(data2);
    
    RBuf8 data3;
	CleanupClosePushL(data3);

    // For CustomAPI
    iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
    RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
    currentlyRetrievedCache.iCacheId	= 1;
    currentlyRetrievedCache.iRecordId	= 0;		
    TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyDataCustomAPI(currentlyRetrievedCache);
    data.Close();
    ltsyDataCustomAPI.SerialiseL(data);			
    iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, data);

    // Open CustomAPI
    RMmCustomAPI customAPI;
    customAPI.Open(iPhone);
    CleanupClosePushL(customAPI);
    AssertMockLtsyStatusL();

    // Open ADN phonebook
    TName name(KETelIccAdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    OpenPhoneBookStoreL(bookStore, name, iPhone);
    CleanupClosePushL(bookStore);

    TRequestStatus requestStatus;

    TInt index(1);
    TInt numEntries(1);	
    TBuf8<200> buf;			 
    
    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
	CleanupStack::PushL(entryPtr);
	entryPtr->ConstructL();	
	FillPBEntry(entryPtr);
	CleanupStack::Pop(entryPtr);
	
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);

    //-------------------------------------------------------------------------
    // TEST  checking failure of EMmTsyPhoneBookStoreInitIPC
    //-------------------------------------------------------------------------

    // EMmTsyPhoneBookStoreInitIPC
    data.Close();
    TMockLtsyPhoneBookData0 storeInitData(name);
    storeInitData.SerialiseL(data);	

    //storeInit
    CStorageInfoData storageData;       
    SetPhonebookNumOfEntries( storageData, 10 );

    TMockLtsyPhoneBookData1< CStorageInfoData > retStore(name, storageData); 
    retStore.SerialiseL(data2);

    // InitPhonebook return value is ignored in CTSY
    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data, KErrNotSupported);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);

    // EMmTsyPhoneBookStoreCacheIPC            
    cache->AppendL(entryPtr);
    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(name, cache);
    data3.Close();
    storeCacheData.SerialiseL(data3);	
	data.Close();
	storeInitData.SerialiseL(data);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrNone, data3, 0);

    // EMmTsyPhoneBookStoreReadIPC
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
    
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  readData(name, indexAndEntries);
    data.Close();
    readData.SerialiseL(data);
    	
    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrGeneral, data3);

    // EMmTsySimRefreshRegisterIPC
    iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
    iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);

    bookStore.Read(requestStatus, index, numEntries, buf); 
           	
    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

    	    
    //-------------------------------------------------------------------------
    // TEST B: failure to dispatch request to LTSY
    //-------------------------------------------------------------------------

    //EMmTsyPhoneBookStoreInitIPC
    TMockLtsyPhoneBookData0 storeInitData2(name);
    data.Close();
    storeInitData2.SerialiseL(data);	

    TMockLtsyPhoneBookData1< CStorageInfoData > retStore2(name, storageData); 
    data2.Close();
    retStore2.SerialiseL(data2);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);

    //EMmTsyPhoneBookStoreCacheIPC                            
    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData2(name, cache);
    data3.Close();
    storeCacheData2.SerialiseL(data3);	
    data.Close();
	storeInitData.SerialiseL(data);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrNone, data3, 0);

    //EMmTsyPhoneBookStoreReadIPC    
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries >  readData2(name, indexAndEntries);
	data.Close();
	readData2.SerialiseL(data);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrGeneral, data3);

    // EMmTsySimRefreshRegisterIPC
    iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
    iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);

    bookStore.Read(requestStatus, index, numEntries, buf); 
           	
    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrGeneral, requestStatus.Int());	


    //-------------------------------------------------------------------------
    // TEST C: 
    //-------------------------------------------------------------------------

    //EMmTsyPhoneBookStoreInitIPC
    TMockLtsyPhoneBookData0 storeInitData3(name);
    data.Close();
    storeInitData3.SerialiseL(data);	

    TMockLtsyPhoneBookData1< CStorageInfoData > retStore3(name, storageData); 
    data2.Close();
    retStore3.SerialiseL(data2);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);


    //EMmTsyPhoneBookStoreCacheIPC                            
    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData3(name, cache);
    data3.Close();
    storeCacheData3.SerialiseL(data3);	
    data.Close();
	storeInitData.SerialiseL(data);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrNone, data3, 0);

    //EMmTsyPhoneBookStoreReadIPC
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  readData3(name, indexAndEntries);
	data.Close();
	readData3.SerialiseL(data);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, data3);

    // EMmTsySimRefreshRegisterIPC
    iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
    iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);

    bookStore.Read(requestStatus, index, numEntries, buf); 
           	
    User::WaitForRequest(requestStatus);        

    ASSERT_EQUALS(KErrNone, requestStatus.Int()); 

    AssertMockLtsyStatusL();

    CleanupStack::PopAndDestroy(7, this); // data, data2, data3, customAPI, bookStore, cache, this

    }


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0002L()
	{
	AuxRead2L(KETelIccAdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with bad parameter data for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read with bad parameter data for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0003L()
	{
    AuxRead3L(KETelIccAdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc 
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0004L()
	{
    AuxRead4L(KETelIccAdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0004b
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Read for ADN phonebook while SIM refresh register is off
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Read for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0004bL()
	{
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));

    // SIM refresh register OFF
    OpenPhone2L(KErrGeneral);
    
    // Open second client
    RTelServer telServer2;
    TInt ret = telServer2.Connect();
    ASSERT_EQUALS(KErrNone, ret);
    CleanupClosePushL(telServer2);

    RMobilePhone phone2;
    ret = phone2.Open(telServer2,KMmTsyPhoneName);
    ASSERT_EQUALS(KErrNone, ret);
    CleanupClosePushL(phone2);

    RBuf8 data;
    CleanupClosePushL(data);

    RBuf8 data2;
    CleanupClosePushL(data2);

    // For CustomAPI
    iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
    RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
    currentlyRetrievedCache.iCacheId	= 1;
    currentlyRetrievedCache.iRecordId	= 0;		
    TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyDataCustomAPI(currentlyRetrievedCache);
    data.Close();
    ltsyDataCustomAPI.SerialiseL(data);			
    iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, data);

    // Open CustomAPI
    RMmCustomAPI customAPI;
    customAPI.Open(iPhone);
    CleanupClosePushL(customAPI);
    AssertMockLtsyStatusL();

    // Open ADN phonebook 1
    TName name(KETelIccAdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    OpenPhoneBookStoreL(bookStore, name, iPhone);
    CleanupClosePushL(bookStore);

    // Open ADN phonebook 2
    RMobilePhoneBookStore bookStore2;   	
    ret = bookStore2.Open(phone2, name);
    ASSERT_EQUALS(KErrNone, ret);	
    CleanupClosePushL(bookStore2);	
    AssertMockLtsyStatusL();     
    	
    TRequestStatus requestStatus;

    TInt index(1);
    TInt numEntries(1);	
    TBuf8<200> buf, buf2;			 
    
    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
	CleanupStack::PushL(entryPtr);
	entryPtr->ConstructL();	
	FillPBEntry(entryPtr);
	CleanupStack::Pop(entryPtr);
  
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
        
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);

    // EMmTsyPhoneBookStoreInitIPC
    data.Close();
    TMockLtsyPhoneBookData0 storeInitData(name);
    storeInitData.SerialiseL(data);	

    //storeInit
    CStorageInfoData storageData;       
    SetPhonebookNumOfEntries( storageData, 10 );

    TMockLtsyPhoneBookData1< CStorageInfoData > retStore(name, storageData); 
    retStore.SerialiseL(data2);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);

	// EMmTsySimRefreshRegisterIPC
	//iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
	//iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);	
	
    //EMmTsyPhoneBookStoreCacheIPC         
    cache->AppendL(entryPtr);
    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(name, cache);
    data2.Close();
    storeCacheData.SerialiseL(data2);
    data.Close();
	storeInitData.SerialiseL(data);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrNone, data2, 0);

    //EMmTsyPhoneBookStoreReadIPC
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  readData(name, indexAndEntries);
	data.Close();
	readData.SerialiseL(data);

    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, data2);

    // EMmTsySimRefreshRegisterIPC
    iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
    iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);

    // First read
    bookStore.Read(requestStatus, index, numEntries, buf); 
    // Second read
    TRequestStatus requestStatus2;
    //User::After(50000); 
    bookStore2.Read(requestStatus2, index, numEntries, buf2);
    
    User::WaitForRequest(requestStatus);        
    ASSERT_EQUALS(KErrNone, requestStatus.Int()); 
    
    User::WaitForRequest(requestStatus2);        
    ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int()); 
    
    AssertMockLtsyStatusL();

    CleanupStack::PopAndDestroy(9, this); // this, telServer2, phone2, data, data2, customAPI, bookStore, bookStore2, cache

    }


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0005
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with timeout for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read and tests for timeout for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0005L()
	{
    AuxRead5L(KETelIccAdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0006L()
	{
    AuxRead1L(KETelIccFdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Read for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Read for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0007L()
	{
    AuxRead2L(KETelIccFdnPhoneBook);
	}




/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with bad parameter data for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read with bad parameter data for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0008L()
	{
    AuxRead3L(KETelIccFdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Read for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Read for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead0009L()
	{
    AuxRead4L(KETelIccFdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00010
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with timeout for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read and tests for timeout for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00010L()
	{
    AuxRead5L(KETelIccFdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00011L()
	{
    AuxRead1L(KETelIccSdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Read for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Read for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00012L()
	{
	AuxRead2L(KETelIccSdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00013
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with bad parameter data for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read with bad parameter data for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00013L()
	{
    AuxRead3L(KETelIccSdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Read for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Read for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00014L()
	{
    AuxRead4L(KETelIccSdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00015
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with timeout for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read and tests for timeout for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00015L()
	{
    AuxRead5L(KETelIccSdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00016
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00016L()
	{
    AuxRead1L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00017
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Read for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Read for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00017L()
	{
	AuxRead2L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00018
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with bad parameter data for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read with bad parameter data for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00018L()
	{
	AuxRead3L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00019
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Read for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Read for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00019L()
	{
    AuxRead4L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00020
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with timeout for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read and tests for timeout for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00020L()
	{
    AuxRead5L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00021
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00021L()
	{
    AuxRead1L(KETelIccBdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00022
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Read for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Read for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00022L()
	{
	AuxRead2L(KETelIccBdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00023
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with bad parameter data for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read with bad parameter data for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00023L()
	{
	AuxRead3L(KETelIccBdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00024
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Read for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Read for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00024L()
	{
    AuxRead4L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00025
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with timeout for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read and tests for timeout for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00025L()
	{
    AuxRead5L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00026
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00026L()
	{
    AuxRead1L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00027
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Read for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Read for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00027L()
	{
	AuxRead2L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00028
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with bad parameter data for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read with bad parameter data for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00028L()
	{
	AuxRead3L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00029
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Read for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Read for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00029L()
	{
    AuxRead4L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR-00030
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Read with timeout for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Read and tests for timeout for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestRead00030L()
	{
    AuxRead5L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0001L()
	{	
	AuxWrite1L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Write for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Write for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0002L()
	{
	AuxWrite2L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with bad parameter data for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write with bad parameter data for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0003L()
	{
	AuxWrite3L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Write for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Write for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0004L()
	{
	AuxWrite4L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0005
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with timeout for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write and tests for timeout for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0005L()
	{
	AuxWrite5L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0006L()
	{
	AuxWrite1L(KETelIccFdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Write for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Write for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0007L()
	{
	AuxWrite2L(KETelIccFdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with bad parameter data for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write with bad parameter data for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0008L()
	{
	AuxWrite3L(KETelIccFdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Write for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Write for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite0009L()
	{
	AuxWrite4L(KETelIccFdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00010
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with timeout for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write and tests for timeout for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00010L()
	{
	AuxWrite5L(KETelIccFdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00011L()
	{
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));
    OpenPhone2L();
    
    TName name(KETelIccSdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    
    OpenPhoneBookStoreL(bookStore, name, iPhone);
    CleanupClosePushL(bookStore);
    
    TRequestStatus requestStatus;
    TInt index(-1); 
    TBuf8<200> buf;

    bookStore.Write(requestStatus, buf, index);
    
    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrAccessDenied, requestStatus.Int());

    CleanupStack::PopAndDestroy(2, this);   //bookStore, this
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00016
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00016L()
	{
	AuxWrite1L(KETelIccVoiceMailBox );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00017
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Write for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Write for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00017L()
	{
	AuxWrite2L(KETelIccVoiceMailBox );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00018
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with bad parameter data for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write with bad parameter data for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00018L()
	{
	AuxWrite3L(KETelIccVoiceMailBox );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00019
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Write for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Write for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00019L()
	{
	AuxWrite4L(KETelIccVoiceMailBox );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00020
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with timeout for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write and tests for timeout for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00020L()
	{
	AuxWrite5L(KETelIccVoiceMailBox );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00021
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00021L()
	{
	// This test will fails since the CStorageInfoData dosn't have the BDN store information 
	//	(since this store is not supported by NTSY). So we can't check the size of the text and number, since we don't have max's. 
	// If and when the NTSY will support this store, we will need to add support in the CTSY, and enable the test again.
	ERR_PRINTF2(_L("<font color=Orange>@CTSYKnownFailure: defect id = %d</font>"), 40201);
	AuxWrite1L(KETelIccBdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00022
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Write for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Write for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00022L()
	{
	AuxWrite2L(KETelIccBdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00023
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with bad parameter data for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write with bad parameter data for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00023L()
	{
	AuxWrite3L(KETelIccBdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00024
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Write for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Write for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00024L()
	{
	AuxWrite4L(KETelIccBdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00025
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with timeout for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write and tests for timeout for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00025L()
	{
	AuxWrite5L(KETelIccBdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00026
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00026L()
	{
	AuxWrite1L(KETelIccMbdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00027
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Write for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Write for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00027L()
	{
	AuxWrite2L(KETelIccMbdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00028
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with bad parameter data for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write with bad parameter data for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00028L()
	{
	AuxWrite3L(KETelIccMbdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00029
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Write for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Write for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00029L()
	{
	AuxWrite4L(KETelIccMbdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW-00030
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Write with timeout for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Write and tests for timeout for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestWrite00030L()
	{
	AuxWrite5L(KETelIccMbdnPhoneBook );	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::NotifyStoreEvent for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::NotifyStoreEvent for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent0001L()
	{
	AuxNotifyStoreEvent1L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::NotifyStoreEvent for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::NotifyStoreEvent for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent0002L()
	{
	AuxNotifyStoreEvent2L(KETelIccAdnPhoneBook);		
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent0004L()
	{
	AuxNotifyStoreEvent4L(KETelIccAdnPhoneBook);		
	}



/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::NotifyStoreEvent for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::NotifyStoreEvent for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent0006L()
	{
	AuxNotifyStoreEvent1L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::NotifyStoreEvent for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::NotifyStoreEvent for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent0007L()
	{
	AuxNotifyStoreEvent2L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent0009L()
	{
	AuxNotifyStoreEvent4L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::NotifyStoreEvent for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::NotifyStoreEvent for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00011L()
	{
	AuxNotifySDNStoreEvent1L();	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::NotifyStoreEvent for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::NotifyStoreEvent for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00012L()
	{
	AuxNotifySDNStoreEvent1L();	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00016
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::NotifyStoreEvent for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::NotifyStoreEvent for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00016L()
	{
	AuxNotifyStoreEvent1L(KETelIccVoiceMailBox);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00017
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::NotifyStoreEvent for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::NotifyStoreEvent for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00017L()
	{
	AuxNotifyStoreEvent2L(KETelIccVoiceMailBox);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00019
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00019L()
	{
	AuxNotifyStoreEvent4L(KETelIccVoiceMailBox);	
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00021
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::NotifyStoreEvent for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::NotifyStoreEvent for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00021L()
	{
	AuxNotifyStoreEvent1L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00022
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::NotifyStoreEvent for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::NotifyStoreEvent for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00022L()
	{
	AuxNotifyStoreEvent2L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00024
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00024L()
	{
	AuxNotifyStoreEvent4L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00026
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::NotifyStoreEvent for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::NotifyStoreEvent for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00026L()
	{
	AuxNotifyStoreEvent1L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00027
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::NotifyStoreEvent for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::NotifyStoreEvent for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00027L()
	{
	AuxNotifyStoreEvent2L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSNSE-00029
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::NotifyStoreEvent for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestNotifyStoreEvent00029L()
	{
	AuxNotifyStoreEvent4L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0001L()
	{
	AuxDelete1L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Delete for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Delete for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0002L()
	{
	AuxDelete2L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with bad parameter data for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete with bad parameter data for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0003L()
	{
	AuxDelete3L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Delete for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Delete for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0004L()
	{
	AuxDelete4L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0005
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with timeout for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete and tests for timeout for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0005L()
	{
	AuxDelete5L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0006L()
	{
	AuxDelete1L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Delete for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Delete for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0007L()
	{
	AuxDelete2L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with bad parameter data for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete with bad parameter data for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0008L()
	{
	AuxDelete3L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Delete for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Delete for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete0009L()
	{
	AuxDelete4L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00010
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with timeout for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete and tests for timeout for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00010L()
	{
	AuxDelete5L(KETelIccFdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00011L()
	{
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));
    OpenPhone2L();
    
    TName name(KETelIccSdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    
    OpenPhoneBookStoreL(bookStore, name, iPhone);
    CleanupClosePushL(bookStore);
    
    TRequestStatus requestStatus;
    TInt index(0);

    bookStore.Delete(requestStatus, index);

    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrAccessDenied, requestStatus.Int());

    CleanupStack::PopAndDestroy(2, this);   //bookStore, this
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00016
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00016L()
	{
	AuxDelete1L(KETelIccVoiceMailBox);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00017
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Delete for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Delete for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00017L()
	{
	AuxDelete2L(KETelIccVoiceMailBox);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00018
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with bad parameter data for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete with bad parameter data for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00018L()
	{
	AuxDelete3L(KETelIccVoiceMailBox);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00019
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Delete for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Delete for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00019L()
	{
	AuxDelete4L(KETelIccVoiceMailBox);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00020
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with timeout for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete and tests for timeout for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00020L()
	{
	AuxDelete5L(KETelIccVoiceMailBox);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00021
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00021L()
	{
	AuxDelete1L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00022
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Delete for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Delete for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00022L()
	{
	AuxDelete2L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00023
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with bad parameter data for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete with bad parameter data for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00023L()
	{
	AuxDelete3L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00024
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Delete for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Delete for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00024L()
	{	
	AuxDelete4L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00025
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with timeout for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete and tests for timeout for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00025L()
	{
	AuxDelete5L(KETelIccBdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00026
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00026L()
	{
	AuxDelete1L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00027
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::Delete for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::Delete for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00027L()
	{
	AuxDelete2L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00028
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with bad parameter data for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete with bad parameter data for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00028L()
	{
	AuxDelete3L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00029
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::Delete for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::Delete for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00029L()
	{
	AuxDelete4L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSD-00030
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::Delete with timeout for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::Delete and tests for timeout for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDelete00030L()
	{
	AuxDelete5L(KETelIccMbdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo0001L()
	{
    AuxGetInfo1L(KETelIccAdnPhoneBook);	
	}



/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo with bad parameter data for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo with bad parameter data for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo0003L()
	{
    AuxGetInfo3L(KETelIccAdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::GetInfo for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::GetInfo for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo0004L()
	{
    AuxGetInfo4L(KETelIccAdnPhoneBook);	    
	}



/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo0006L()
	{
    AuxGetInfo1L(KETelIccFdnPhoneBook);	    
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-0006b
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo for FDN phonebook when ADN is de-activated and ADN phonebook name is returned
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo0006bL()
    {
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));
    OpenPhone2L();
    
    RBuf8 data;
    CleanupClosePushL(data);
    
    RBuf8 completeData;
    CleanupClosePushL(data);
    
    TName name(KETelIccFdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    
    OpenPhoneBookStoreL(bookStore, name, iPhone);
    CleanupClosePushL(bookStore);
    
    SetPhonebookNumOfEntriesAndInitPhonebookL( name, 50 );
    
    TPBFdnInfo fdnInfo;
    fdnInfo.iFDNNumOfEntries = 1;
    fdnInfo.iFDNNumberLengthMax = 10;
    fdnInfo.iFDNTextLengthMax = 50;
    
    TName nameAdn(KETelIccAdnPhoneBook);
    TMockLtsyPhoneBookData1<TPBFdnInfo> tsyData(nameAdn, fdnInfo);           
    tsyData.SerialiseL(data);
    
    TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);        
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreFdnInfoIPC,KErrNone,data,0);    
    User::WaitForRequest(mockLtsyStatus);        
    AssertMockLtsyStatusL(); 
    
    TRequestStatus requestStatus;
    RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo;
    RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg(bookInfo);
    
    bookStore.GetInfo(requestStatus, bookPckg); 
    
    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, requestStatus.Int());   
    ASSERT_TRUE(0 == bookInfo.iName.Compare(name));   
    ASSERT_EQUALS(0, bookInfo.iUsedEntries);  
    ASSERT_EQUALS(1, bookInfo.iTotalEntries); 
    ASSERT_EQUALS(50, bookInfo.iMaxTextLength);
    ASSERT_EQUALS(10, bookInfo.iMaxNumLength);  
    ASSERT_EQUALS(RMobilePhoneBookStore::ELocationIccMemory, bookInfo.iLocation);   
    ASSERT_EQUALS((TUint16)0, bookInfo.iChangeCounter); 
      
    CleanupStack::PopAndDestroy(4, this); // this, data, completeData, bookStore, cache   
    }

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo with bad parameter data for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo with bad parameter data for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo0008L()
	{	
    AuxGetInfo3L(KETelIccFdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::GetInfo for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::GetInfo for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo0009L()
	{
    AuxGetInfo4L(KETelIccFdnPhoneBook);	    
	}



/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00011L()
	{
    AuxGetInfo1L(KETelIccSdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support cancelling in CTSY for RMobilePhoneBookStore::GetInfo for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo cancell for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00012L()
	{
    AuxGetInfo2L(KETelIccSdnPhoneBook);	    
	}




/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00013
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo with bad parameter data for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo with bad parameter data for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00013L()
	{
    AuxGetInfo3L(KETelIccSdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::GetInfo for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::GetInfo for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00014L()
	{
    AuxGetInfo4L(KETelIccSdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00015
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support for timeout in CTSY for RMobilePhoneBookStore::GetInfo for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo timeout for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00015L()
	{
    AuxGetInfo5L(KETelIccSdnPhoneBook);	    
	}





/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00016
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00016L()
	{
    AuxGetInfo1L(KETelIccVoiceMailBox);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00017
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support for cancelling in CTSY for RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancel of RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00017L()
	{
    AuxGetInfo2L(KETelIccVoiceMailBox);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00018
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo with bad parameter data for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo with bad parameter data for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00018L()
	{
    AuxGetInfo3L(KETelIccVoiceMailBox);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00019
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00019L()
	{
    AuxGetInfo4L(KETelIccVoiceMailBox);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00020
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for timeout requests to RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes timeuot of multiple client requests to RMobilePhoneBookStore::GetInfo for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00020L()
	{
    AuxGetInfo5L(KETelIccVoiceMailBox);	    
	}



/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00021
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00021L()
	{
    AuxGetInfo1L(KETelIccBdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00023
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo with bad parameter data for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo with bad parameter data for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00023L()
	{
    AuxGetInfo3L(KETelIccBdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00024
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::GetInfo for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::GetInfo for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00024L()
	{
    AuxGetInfo4L(KETelIccBdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00026
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00026L()
	{
    AuxGetInfo1L(KETelIccMbdnPhoneBook);	    
	}



/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00028
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::GetInfo with bad parameter data for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo with bad parameter data for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00028L()
	{
    AuxGetInfo3L(KETelIccMbdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSGI-00029
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::GetInfo for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::GetInfo for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestGetInfo00029L()
	{
    AuxGetInfo4L(KETelIccMbdnPhoneBook);	    
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll0001L()
	{
	AuxDeleteAll1L(KETelIccAdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::DeleteAll for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::DeleteAll for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll0002L()
	{
	AuxDeleteAll2L(KETelIccAdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::DeleteAll for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::DeleteAll for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll0004L()
	{
	AuxDeleteAll4L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-0005
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll with timeout for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll and tests for timeout for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll0005L()
	{
	AuxDeleteAll5L(KETelIccAdnPhoneBook);	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll0006L()
	{
	AuxDeleteAll1L(KETelIccFdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::DeleteAll for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::DeleteAll for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll0007L()
	{
	AuxDeleteAll2L(KETelIccFdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::DeleteAll for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::DeleteAll for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll0009L()
	{
	AuxDeleteAll4L(KETelIccFdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00010
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll with timeout for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll and tests for timeout for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00010L()
	{
	AuxDeleteAll5L(KETelIccFdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00011L()
	{
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));
    OpenPhone2L();
    
    TName name(KETelIccSdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    
    OpenPhoneBookStoreL(bookStore, name, iPhone);
    CleanupClosePushL(bookStore);
    
    TRequestStatus requestStatus;

    bookStore.DeleteAll(requestStatus);

    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrAccessDenied, requestStatus.Int());

    CleanupStack::PopAndDestroy(2, this);   //bookStore, this
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00016
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00016L()
	{
	AuxDeleteAll1L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00017
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::DeleteAll for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::DeleteAll for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00017L()
	{
	AuxDeleteAll2L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00019
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::DeleteAll for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::DeleteAll for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00019L()
	{
	AuxDeleteAll4L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00020
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll with timeout for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll and tests for timeout for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00020L()
	{
	AuxDeleteAll5L(KETelIccVoiceMailBox);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00021
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00021L()
	{
	AuxDeleteAll1L(KETelIccBdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00022
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::DeleteAll for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::DeleteAll for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00022L()
	{
	AuxDeleteAll2L(KETelIccBdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00024
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::DeleteAll for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::DeleteAll for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00024L()
	{
	AuxDeleteAll4L(KETelIccBdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00025
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll with timeout for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll and tests for timeout for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00025L()
	{
	AuxDeleteAll5L(KETelIccBdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00026
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00026L()
	{
	AuxDeleteAll1L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00027
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhoneBookStore::DeleteAll for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobilePhoneBookStore::DeleteAll for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00027L()
	{
	AuxDeleteAll2L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00029
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhoneBookStore::DeleteAll for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobilePhoneBookStore::DeleteAll for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00029L()
	{
	AuxDeleteAll4L(KETelIccMbdnPhoneBook);
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSDA-00030
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneBookStore::DeleteAll with timeout for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll and tests for timeout for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestDeleteAll00030L()
	{
	AuxDeleteAll5L(KETelIccMbdnPhoneBook);
	}


//-------------------------------------------------------------------


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR2-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Read for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Read for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Read0001L()
	{
	Aux2ReadL(KETelIccAdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR2-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Read for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Read for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Read0002L()
	{
	Aux2ReadL(KETelIccFdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR2-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Read for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Read for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Read0003L()
	{
	Aux2ReadL(KETelIccSdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR2-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Read for VBMX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Read for VBMX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Read0004L()
	{
	Aux2ReadL(KETelIccVoiceMailBox);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR2-0005
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Read for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Read for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Read0005L()
	{
	Aux2ReadL(KETelIccBdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR2-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Read for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Read for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Read0006L()
	{
	Aux2ReadL(KETelIccMbdnPhoneBook);
	}



/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW2-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Write for ADN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Write for ADN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Write0001L()
	{	
	Aux2WriteL(KETelIccAdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW2-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Write for FDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Write for FDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Write0002L()
	{	
	Aux2WriteL(KETelIccFdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW2-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Write for SDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Write for SDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Write0003L()
	{	
	Aux2WriteL(KETelIccSdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW2-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Write for VMBX phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Write for VMBX phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Write0004L()
	{	
	Aux2WriteL(KETelIccVoiceMailBox);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW2-0005
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Write for BDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Write for BDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Write0005L()
	{	
	Aux2WriteL(KETelIccBdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSW2-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Write for MBDN phonebook
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Write for MBDN phonebook
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test2Write0006L()
	{	
	Aux2WriteL(KETelIccMbdnPhoneBook);
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSO2-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhoneStore::Open 2 phonebooks of different types
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhoneStore::Open 2 phonebooks of different types
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::TestOpen0001L()
    {
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));

    // SIM refresh register OFF
    OpenPhone2L(KErrGeneral);

    // Open ADN phonebook
    TName name1(KETelIccAdnPhoneBook);
    TName name2(KETelIccFdnPhoneBook);
    
    RMobilePhoneBookStore bookStore1;
    RMobilePhoneBookStore bookStore2;
    
    OpenPhoneBookStoreL(bookStore1, name1, iPhone);
    CleanupClosePushL(bookStore1);
    
    TMockLtsyPhoneBookData0 storeInitData(name1);
    TMockLtsyPhoneBookData0 storeInitData2(name2);
    
    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();	
    FillPBEntry(entryPtr);
    CleanupStack::Pop(entryPtr);

    // Open the second phonebook store - this won't need the phonebook be initialized
    // EMmTsyPhoneBookStoreCacheIPC
    
    TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    
    RBuf8 data;
    CleanupClosePushL(data);
    RBuf8 data2;
	CleanupClosePushL(data2);
    
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);
    cache->AppendL(entryPtr);
    
    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(name2, cache);
    data2.Close();
    storeCacheData.SerialiseL(data2);
    data.Close();
    storeInitData2.SerialiseL(data);
                  
    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrNone, data2, 0);
    
    // Open the phonebook store
    TInt ret = bookStore2.Open(iPhone, name2);
    CleanupClosePushL(bookStore2);
    ASSERT_EQUALS(KErrNone, ret);   
    
    User::WaitForRequest(mockLtsyStatus);           
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());  
    AssertMockLtsyStatusL();
    
    CleanupStack::PopAndDestroy(6,this);	//this, bookstore1, data, data2, cache, bookstore2    
    }


//-------------------------------------------------------------------



/**
Standard function to open the phone up to the end of the boot sequence
Based on OpenPhoneL() from CCtsyComponentTestBase 
with changes for sim refresh register
*/
void CCTsyPhoneBookStoreFU::OpenPhone2L(TInt aSimError)
	{
	RBuf8 data;
	CleanupClosePushL(data);

	TInt err = iPhone.Open(iTelServer,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, err);
	
	TRequestStatus modemDetectedStatus;
	RPhone::TModemDetection modemDetection;
	iPhone.NotifyModemDetected(modemDetectedStatus,modemDetection);
	
	err=iMockLTSY.Connect();
	ASSERT_EQUALS(KErrNone, err);
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	
	// EMmTsyBootNotifyModemStatusReadyIPC
	iMockLTSY.CompleteL(EMmTsyBootNotifyModemStatusReadyIPC,KErrNone);

	// EMobilePhoneGetNetworkRegistrationStatus
	iMockLTSY.ExpectL(EMobilePhoneGetNetworkRegistrationStatus);
	iMockLTSY.CompleteL(EMobilePhoneGetNetworkRegistrationStatus,KErrNone,0);
	
	// EMmTsyBootNotifySimStatusReadyIPC
	iMockLTSY.ExpectL(EMmTsyBootNotifySimStatusReadyIPC);
	iMockLTSY.CompleteL(EMmTsyBootNotifySimStatusReadyIPC,KErrNone,0);

	// EMobilePhoneGetHomeNetwork
	iMockLTSY.ExpectL(EMobilePhoneGetHomeNetwork);
	RMobilePhone::TMobilePhoneNetworkInfoV5 homeNetwork;
	homeNetwork.iMode = RMobilePhone::ENetworkModeWcdma;
	homeNetwork.iStatus = RMobilePhone::ENetworkStatusCurrent;
	homeNetwork.iBandInfo = RMobilePhone::EBandUnknown;
	homeNetwork.iCountryCode = _L("234");
	homeNetwork.iCdmaSID = _L("");
	homeNetwork.iAnalogSID = _L("");
	homeNetwork.iNetworkId = _L("23499");
	homeNetwork.iDisplayTag = _L("symbian");
	homeNetwork.iShortName = _L("symbian");
	homeNetwork.iLongName = _L("symbian mobile");
	homeNetwork.iAccess = RMobilePhone::ENetworkAccessUtran;
	homeNetwork.iEgprsAvailableIndicator = ETrue;
	homeNetwork.iHsdpaAvailableIndicator = ETrue;
	TMockLtsyData1<RMobilePhone::TMobilePhoneNetworkInfoV5> homeNetworkData(homeNetwork);
	homeNetworkData.SerialiseL(data);
	iMockLTSY.CompleteL(EMobilePhoneGetHomeNetwork,KErrNone,data,0);

	// EMmTsyPhoneGetPin1DisableSupportedIPC
 	iMockLTSY.ExpectL(EMmTsyPhoneGetPin1DisableSupportedIPC);
	TBool pin1DisableSupport = ETrue;
	TMockLtsyData1<TBool> pin1DisableSupportData(pin1DisableSupport);
	data.Close();
	pin1DisableSupportData.SerialiseL(data);
	iMockLTSY.CompleteL(EMmTsyPhoneGetPin1DisableSupportedIPC,KErrNone,data,0);

	// EMmTsySimRefreshRegisterIPC
	iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);
	iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, aSimError, 0);		

	// EMobilePhoneGetServiceTable
	RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::ESIMServiceTable;
	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTable> serviceTableData(serviceTable);
	data.Close();
	serviceTableData.SerialiseL(data);
	iMockLTSY.ExpectL(EMobilePhoneGetServiceTable, data);
	RMobilePhone::TMobilePhoneServiceTableV1 serviceTableResult;
	serviceTableResult.iServices1To8  = 0xFF;
	serviceTableResult.iServices9To16 = 0xFF;
	serviceTableResult.iServices17To24= 0xFF;
	serviceTableResult.iServices25To32= 0xFF;
	serviceTableResult.iServices33To40= 0xFF;
	serviceTableResult.iServices41To48= 0xFF;
	serviceTableResult.iServices49To56= 0xFF;
	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTableV1> serviceTableResultData(serviceTableResult);
	data.Close();
	serviceTableResultData.SerialiseL(data);
	iMockLTSY.CompleteL(EMobilePhoneGetServiceTable,KErrNone,data,0);
	
	// EMobilePhoneGetALSLine
	iMockLTSY.ExpectL(EMobilePhoneGetALSLine);

	RMobilePhone::TMobilePhoneALSLine alsLine = RMobilePhone::EAlternateLinePrimary;
	TMockLtsyData1<RMobilePhone::TMobilePhoneALSLine> alsLineData(alsLine);
	data.Close();
	alsLineData.SerialiseL(data);
	iMockLTSY.CompleteL(EMobilePhoneGetALSLine,KErrNone,data,0);
	
	iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);    
	
	// EMobilePhoneGetIccMessageWaitingIndicators
	iMockLTSY.ExpectL(EMobilePhoneGetIccMessageWaitingIndicators);

	RMobilePhone::TMobilePhoneMessageWaitingV1 expectedMessageIndicators;
	TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1>
	                                indicatorsData(expectedMessageIndicators);
    data.Close();
    indicatorsData.SerialiseL(data); 
	iMockLTSY.CompleteL(EMobilePhoneGetIccMessageWaitingIndicators, KErrNone, data);
	
	iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);
	iMockLTSY.ExpectL(EMobilePhoneGetCustomerServiceProfile);
	
	User::WaitForRequest(mockLtsyStatus);

	CleanupStack::PopAndDestroy(); // data
	}


void CCTsyPhoneBookStoreFU::ValidateReadEntryL(TInt aNumEntries, TInt aStartIndex, CPhoneBookBuffer& aPBBuffer, const TDesC& aPBName, CPhoneBookStoreEntry* aEntryPtr)
	{
	TUint8 tagValue;
    CPhoneBookBuffer::TPhBkTagType tagType; 
    TUint16 adnIndex;
    TInt ret (KErrNone);
    TInt index (aStartIndex);
    
	for(TInt i=0; i<aNumEntries; ++i) // aEntriesNum entries are supposed to be read.
		{
		INFO_PRINTF2(_L("Entry %d is being read."), i);
		ret = aPBBuffer.GetTagAndType( tagValue, tagType ); 
		ASSERT_EQUALS(KErrNone, ret);		
		ASSERT_TRUE(RMobilePhoneBookStore::ETagPBNewEntry == tagValue);   
	
		ret = aPBBuffer.GetTagAndType( tagValue, tagType ); 
		ASSERT_EQUALS(KErrNone, ret);	
		ASSERT_TRUE(RMobilePhoneBookStore::ETagPBAdnIndex == tagValue);   
	
		ret = aPBBuffer.GetValue( adnIndex ); 
		ASSERT_EQUALS(KErrNone, ret);	
		ASSERT_TRUE(index++ == adnIndex);	
	
		if(aPBName.CompareF( KETelIccBdnPhoneBook ))   // write of text does not succeed in BDN
			{            
			ret = aPBBuffer.GetTagAndType( tagValue, tagType ); 
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_TRUE(RMobilePhoneBookStore::ETagPBText == tagValue);   
			TPtrC16 textPtr;
			ret = aPBBuffer.GetValue( textPtr );
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_EQUALS(0, textPtr.Compare(*aEntryPtr->iText));
	
			ret = aPBBuffer.GetTagAndType( tagValue, tagType ); 
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_TRUE(RMobilePhoneBookStore::ETagPBNumber == tagValue);   
			ret = aPBBuffer.GetValue( textPtr );
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_EQUALS(0, textPtr.Compare(*aEntryPtr->iNumber));
	
			ret = aPBBuffer.GetTagAndType( tagValue, tagType ); 
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_TRUE(RMobilePhoneBookStore::ETagPBEmailAddress == tagValue);   
			ret = aPBBuffer.GetValue( textPtr );
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_EQUALS(0, textPtr.Compare((*aEntryPtr->iEmail)[0]));
	
			ret = aPBBuffer.GetTagAndType( tagValue, tagType ); 
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_TRUE(RMobilePhoneBookStore::ETagPBSecondName == tagValue);   
			ret = aPBBuffer.GetValue( textPtr );
			ASSERT_EQUALS(KErrNone, ret);	
			ASSERT_EQUALS(0, textPtr.Compare((*aEntryPtr->iSne)[0]));	
			}
		if(aPBName.CompareF( KETelIccAdnPhoneBook ) && aPBName.CompareF( KETelIccFdnPhoneBook ))
			{
			// Terminate the loop as only one entry has been read from SDN, BDN, MBDN and VMBX phonebooks.
			break;
			}
		}
	ret = aPBBuffer.GetTagAndType( tagValue, tagType );    // TON is skipped
	if(KErrNotFound != ret)
		{
		ERR_PRINTF1(_L("An unexpected entry has been returned!"));
		User::Leave(KErrTEFUnitFail);
		}
	}

void CCTsyPhoneBookStoreFU::AuxRead1L(const TDesC& aName)   
    {
    INFO_PRINTF1(_L("Start initialisation"));
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data1;
	CleanupClosePushL(data1);
	
	RBuf8 completeData;
	CleanupClosePushL(completeData);

	RBuf8 data;
	CleanupClosePushL(data);
		
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(1);
	TInt numEntries(1);	
	TBuf8<400> buf;	
	  
	SetPhonebookNumOfEntriesAndInitPhonebookL( name, 10 );
	INFO_PRINTF1(_L("Initialisation complete"));
	
	INFO_PRINTF1(_L("TEST A: Failure to dispatch request to LTSY"));
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);  
    
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData1(name, indexAndEntries);
    ltsyData1.SerialiseL(data1);
            

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1, KErrNotSupported);	

    bookStore.Read(requestStatus, index, numEntries, buf); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	

	INFO_PRINTF1(_L("TEST B: failure on completion of pending request from LTSY->CTSY"));

    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData(name, cache);
    ArrayData.SerialiseL(completeData);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrGeneral, completeData, 0);
    
    bookStore.Read(requestStatus, index, numEntries, buf); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());	
	
	INFO_PRINTF1(_L("TEST E: Unsolicited completion of RMobilePhoneBookStore::Read from LTSY."));

	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData, 0);
    User::WaitForRequest(mockLtsyStatus);        
    
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();

	INFO_PRINTF1(_L("TEST C: Successful completion request of RMobilePhoneBookStore::Read."));
    
    // now read 1entry when there is no data writen
    index = 1;
    indexAndEntries.iIndex = index;
    
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData(name, indexAndEntries);
    data1.Close();
    ltsyData.SerialiseL(data1);
    
    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData2(name, cache);
    completeData.Close();
    ArrayData2.SerialiseL(completeData);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData, 0);
    
	TBuf8<200> buf2;	 		 
    bookStore.Read(requestStatus, index, numEntries, buf2); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

	TUint8 tagValue;
    CPhoneBookBuffer::TPhBkTagType tagType;    
    
    // check received buffer
    CPhoneBookBuffer bookBuffer;    
    bookBuffer.Set(&buf2);
    bookBuffer.StartRead();
    TInt ret = bookBuffer.GetTagAndType( tagValue, tagType ); 
    ASSERT_EQUALS(KErrNotFound, ret); // there is no data in buffer

    // multiple entries 1 ( number of entries in phoneBook set to 10)

    //set data for storeInit
	RBuf8 data2;
	CleanupClosePushL(data2);
    
    CStorageInfoData storageData;       
    
	SetStorageInfoData(storageData);
    SetPhonebookNumOfEntries( storageData, 10 );
           
    storageData.iEmailNumOfEntries = 3;
    storageData.iEmailNumOfEntriesPerEntry = 3;
    storageData.iEmailTextLengthMax = 50;
    storageData.iSNENumOfEntries = 3;
    storageData.iSNENumOfEntriesPerEntry = 3;
    storageData.iSNETextLengthMax = 50;
    
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreAndName(name, storageData); 
	retStoreAndName.SerialiseL(data2);	
	
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        

    INFO_PRINTF1(_L("Read 2 entries when there is no data writen"));
    numEntries = 2;
    indexAndEntries.iIndex = index;
    indexAndEntries.iNumSlots = numEntries;

    if ( name.CompareF( KETelIccAdnPhoneBook ) && name.CompareF( KETelIccFdnPhoneBook ))
        {        
		TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData2(name, indexAndEntries);
		data1.Close();
		ltsyData2.SerialiseL(data1);
                
        TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData3(name, cache);
        completeData.Close();
        ArrayData3.SerialiseL(completeData);

    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);	
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData, 10);

        bookStore.Read(requestStatus, index, numEntries, buf); 
    	
        User::WaitForRequest(requestStatus);        
    	AssertMockLtsyStatusL();
    	ASSERT_EQUALS(KErrNone, requestStatus.Int());   
    	
    	// check recieved buffer
    	bookBuffer.Set(&buf);
    	bookBuffer.StartRead();
    	ret = bookBuffer.GetTagAndType( tagValue, tagType ); 
    	ASSERT_EQUALS(KErrNotFound, ret);    	
        }
    else
        {
        bookStore.Read(requestStatus, index, numEntries, buf); 
    	
        User::WaitForRequest(requestStatus);        
    	AssertMockLtsyStatusL();
    	ASSERT_EQUALS(KErrNotFound, requestStatus.Int());   
        }
            
	AssertMockLtsyStatusL();
	
	//If the Phonebook is SDN type, then we can't write SDN entries into SDN phonebook.
	if (name.CompareF( KETelIccSdnPhoneBook ) != 0)
	    {
        INFO_PRINTF1(_L("Write 3 entries into the phonebook."));
        TRequestStatus writeStatus;
        TInt writeIndex(-1); 
        TBuf8<200> writeBuf;	 		 	    	    
        
        CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
        CleanupStack::PushL(entryPtr);
        entryPtr->ConstructL();
    
        CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
        CleanupStack::PushL(pbBuffer);
    
        pbBuffer->Set( &writeBuf );    
        ret = pbBuffer->AddNewEntryTag();
        TUint16 location(0);
        ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );
    
        _LIT(KPBText, "PBText");
        _LIT(KPBNumber, "PBNumber");
        _LIT(KPBEmailAddress, "PBEmailAddress");
        _LIT(KPBSecondName, "PBSecondName");
        const TUint8 KPBToNpi(0);
    
        if(name.CompareF( KETelIccBdnPhoneBook ))   // write of text does not succeed in BDN
            {            
            entryPtr->iText = HBufC::NewLC( KPBText().Length() );	
            entryPtr->iText->Des() = KPBText;
            CleanupStack::Pop();
            ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBText, KPBText);
    
            entryPtr->iNumber = HBufC::NewLC( KPBNumber().Length() );	
            entryPtr->iNumber->Des() = KPBNumber;
            CleanupStack::Pop();
            ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBNumber, KPBNumber);
    
            HBufC* hbuf = HBufC::NewLC( KPBEmailAddress().Length() );
            hbuf->Des() = KPBEmailAddress;
            CleanupStack::Pop();
            entryPtr->iEmail->AppendL( hbuf->Des() );
            ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBEmailAddress, KPBEmailAddress);
    
            HBufC* hbuf2 = HBufC::NewLC( KPBSecondName().Length() );
            hbuf2->Des() = KPBSecondName;
            CleanupStack::Pop();
            entryPtr->iSne->AppendL( hbuf2->Des() );
            ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBSecondName, KPBSecondName);
            
            ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBTonNpi, KPBToNpi);
            }
        
        
        TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyDataW(name, writeIndex, entryPtr);           
        tsyDataW.SerialiseL(data);
        
        TPBEntryInfo pbEntryInfo = {1, 50};
        TMockLtsyPhoneBookData1< TPBEntryInfo > styDataW2(name, pbEntryInfo);
        styDataW2.SerialiseL(data2);    
        
        // 1st entry    
        iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 4);
    
        bookStore.Write(writeStatus, writeBuf, writeIndex);
        
        User::WaitForRequest(writeStatus); 
        ASSERT_EQUALS(KErrNone, writeStatus.Int());	
    
        // 2nd entry
        pbEntryInfo.iLocation = 2;
        TMockLtsyPhoneBookData1< TPBEntryInfo > styData4(name, pbEntryInfo);
        data2.Close();
        styData4.SerialiseL(data2);
        
        writeIndex = -1;
    
        iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 4);
    
        bookStore.Write(writeStatus, writeBuf, writeIndex);
        
        User::WaitForRequest(writeStatus); 
        ASSERT_EQUALS(KErrNone, writeStatus.Int());	
        
        // 3rd entry
        pbEntryInfo.iLocation = 3;
        TMockLtsyPhoneBookData1< TPBEntryInfo > styData5(name, pbEntryInfo);
        data2.Close();
        styData5.SerialiseL(data2);
        
        writeIndex = -1;
    
        iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 4);
    
        bookStore.Write(writeStatus, writeBuf, writeIndex);
        
        User::WaitForRequest(writeStatus); 
        ASSERT_EQUALS(KErrNone, writeStatus.Int());	
        
        // read 2 entry, there is enough data to read ------------------	
        index = 1;
        numEntries = 2;
        indexAndEntries.iIndex = index;
        indexAndEntries.iNumSlots = numEntries;
    
        buf.Delete(0, buf.Length());
        
        if ( name.CompareF( KETelIccAdnPhoneBook ) && name.CompareF( KETelIccFdnPhoneBook ))
            {
            INFO_PRINTF1(_L("Read a single entry from the phonebook."));
            index = 1;
            numEntries = 1;
            indexAndEntries.iIndex = index;
            indexAndEntries.iNumSlots = numEntries;
            
            TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData5(name, indexAndEntries);
            data1.Close();
            ltsyData5.SerialiseL(data1);
    
            iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);	
            
            entryPtr->iLocation = index;
            cache->AppendL(entryPtr); 
                    
            TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData5(name, cache);
            completeData.Close();
            ArrayData5.SerialiseL(completeData);
    
            iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData, 0);
            }
        else
            {
            INFO_PRINTF1(_L("Read 2 entries from the phonebook."));
            }
            
        bookStore.Read(requestStatus, index, numEntries, buf); 
        
        User::WaitForRequest(requestStatus);        
        AssertMockLtsyStatusL();
        ASSERT_EQUALS(KErrNone, requestStatus.Int());   
            
        //check the buffer received
        bookBuffer.Set(&buf);
        bookBuffer.StartRead();
    
        ValidateReadEntryL(numEntries, index, bookBuffer, name, entryPtr);
        
        //Test: Read 2 entries when client does not send sufficient buffer.
        // As the size of entry varies for different phone book so test
        // this condition if the phonebook type is ADN or FDN only.
        TBuf8<50> smallBuf;
        if ( !name.CompareF( KETelIccAdnPhoneBook ) || !name.CompareF( KETelIccFdnPhoneBook ))
            {
            bookStore.Read(requestStatus, index, numEntries, smallBuf);
            User::WaitForRequest(requestStatus);
            AssertMockLtsyStatusL();
            ASSERT_EQUALS(KErrArgument, requestStatus.Int());
            }
    
        // read 1 entry, if the phonebook type is ADN or FDN. 1-entry-read has already been done for other phonebooks.
        if ( !name.CompareF( KETelIccAdnPhoneBook ) || !name.CompareF( KETelIccFdnPhoneBook ))
            {
            INFO_PRINTF1(_L("Read a single entry from the phonebook."));	
            
            index = 1;
            numEntries = 1;
            indexAndEntries.iIndex = index;
            indexAndEntries.iNumSlots = numEntries;
            
            buf.Delete(0, buf.Length());
            
            TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData4(name, indexAndEntries);
            data1.Close();    
            ltsyData4.SerialiseL(data1);
                
            if ( !name.CompareF( KETelIccAdnPhoneBook ) || !name.CompareF( KETelIccFdnPhoneBook ))
                { 
                entryPtr->iLocation = 1;
                cache->AppendL(entryPtr);   //data read from cache in complete
                }
    
            TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData4(name, cache);
            completeData.Close();
            ArrayData4.SerialiseL(completeData);
        
            iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);	
            iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData, 0);
                
            bookStore.Read(requestStatus, index, numEntries, buf); 
            
            User::WaitForRequest(requestStatus);        
            AssertMockLtsyStatusL();
            ASSERT_EQUALS(KErrNone, requestStatus.Int());   
            
            //check the buffer received
            bookBuffer.Set(&buf);
            bookBuffer.StartRead();
    
            ValidateReadEntryL(numEntries, index, bookBuffer, name, entryPtr);
    
            //Read 1 entry when client does not send sufficient buffer.
            smallBuf.Delete(0, smallBuf.Length());
            iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);
            iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData, 0);
            bookStore.Read(requestStatus, index, numEntries, smallBuf);
            User::WaitForRequest(requestStatus);
            AssertMockLtsyStatusL();
            ASSERT_EQUALS(KErrArgument, requestStatus.Int());
            }
        CleanupStack::PopAndDestroy(2); //entryPtr, pbBuffer
	    }

	CleanupStack::PopAndDestroy(7, this); // this, data1, completedata, data, bookstore, cache, data2
    }


    
void CCTsyPhoneBookStoreFU::AuxRead2L(const TDesC& aName)
    {
// This test should test cancellation of Read
// If this API does not have a cancel, the test step should be completely removed.

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
	CleanupStack::PushL(entryPtr);
	entryPtr->ConstructL();	
	FillPBEntry(entryPtr);
	CleanupStack::Pop(entryPtr);

 	//-------------------------------------------------------------------------
	// Test cancelling of RMobilePhoneBookStore::Read
 	//-------------------------------------------------------------------------
 	
    SetPhonebookNumOfEntriesAndInitPhonebookL( name, 10 );
 		
	TRequestStatus requestStatus;
	TInt index(1);
	TInt numEntries(1);	
	TBuf8<200> buf;			 
	
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);
    cache->AppendL(entryPtr);
    
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData(name, indexAndEntries);
	ltsyData.SerialiseL(data);
            
    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData(name, cache);
    ArrayData.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data);	
    	        
    bookStore.Read(requestStatus, index, numEntries, buf); 
    
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, data2, 10);

    bookStore.CancelAsyncRequest(EMobilePhoneBookStoreRead);
	
    User::WaitForRequest(requestStatus);        
	
	ASSERT_EQUALS(KErrCancel, requestStatus.Int());	

	// Wait for completion of iMockLTSY.NotifyTerminated
	User::WaitForRequest(mockLtsyStatus);
	AssertMockLtsyStatusL();

    CleanupStack::PopAndDestroy(2); //bookStore, cache
	CleanupStack::PopAndDestroy(3); // data, data2, this	
    }
    
void CCTsyPhoneBookStoreFU::AuxRead3L(const TDesC& aName)
    {

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);

    //storeInit
    CStorageInfoData storageData;       
    //bdn num entries set to 0
    storageData.iADNNumOfEntries = 10;
    storageData.iFDNNumOfEntries = 10;
    storageData.iSDNNumOfEntries = 10;
    storageData.iVMBXNumOfEntries = 10;
    storageData.iMBDNNumOfEntries = 10;   
        
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreAndName(name, storageData); 
	data2.Close();    
	retStoreAndName.SerialiseL(data2);	
	
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        

	TRequestStatus requestStatus;
	TInt index(-1);
	TInt numEntries(1);	    	        
	
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);
	   
	//-------------------------------------------------------------------------
	// Test C: Test passing out of bounds parameters to
	// RMobilePhoneBookStore::Read
 	//------------------------------------------------------------------------- 	
 	// test with index = -1;
    index = -1;
    TBuf8<200> buf1;

    bookStore.Read(requestStatus, index, numEntries, buf1); 
    	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();	
	ASSERT_EQUALS(KErrArgument, requestStatus.Int()); 
    
    // test with index = 0 and numEntries = 1;
    index = 0;
    numEntries = 1;
    
    bookStore.Read(requestStatus, index, numEntries, buf1); 
        
    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();    
    ASSERT_EQUALS(KErrArgument, requestStatus.Int());
    
    // test with index = 1 and numEntries = 0;
    index = 1;
    numEntries = 0;
    
    bookStore.Read(requestStatus, index, numEntries, buf1); 
    	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();	
	ASSERT_EQUALS(KErrArgument, requestStatus.Int());
	
	// test with index = 1 and numEntries = 10000;
    index = 1;
    numEntries = 10000;

    // the size of the BDN phonebook is set to zero in CTSY
    // so there is no check for BDN phonebook size 
    if ( name.CompareF( KETelIccBdnPhoneBook ) )
        {
        bookStore.Read(requestStatus, index, numEntries, buf1); 	
        User::WaitForRequest(requestStatus);        
    	AssertMockLtsyStatusL();
    	ASSERT_EQUALS(KErrNotFound, requestStatus.Int());
        }
 	        
	//-------------------------------------------------------------------------
	// Test B: Test passing wrong descriptor size to parameter in
	// RMobilePhoneBookStore::Read
 	//-------------------------------------------------------------------------
	index = -1;
	numEntries = 1;	
	TBuf8<1> buf; // use very small buffer		 
 	        
    bookStore.Read(requestStatus, index, numEntries, buf); 
    	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();	
	ASSERT_EQUALS(KErrArgument, requestStatus.Int());

	CleanupStack::PopAndDestroy(5); // cache, bookStore, data, data2, this    
	}
	
    
void CCTsyPhoneBookStoreFU::AuxRead4L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);

    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);

	RMobilePhoneBookStore bookStore2;
	
	ret = bookStore2.Open(phone2, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
	AssertMockLtsyStatusL();      
    
	CleanupClosePushL(bookStore2);
	
	SetPhonebookNumOfEntriesAndInitPhonebookL( name, 10 );
	
	CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
	CleanupStack::PushL(entryPtr);
	entryPtr->ConstructL();	
	FillPBEntry(entryPtr);
	CleanupStack::Pop(entryPtr);
	
	//-------------------------------------------------------------------------
	// Test A: Test multiple clients requesting RMobilePhoneBookStore::Read
 	//-------------------------------------------------------------------------
	TInt index(1);
	TInt numEntries(1);	
	TBuf8<200> buf;			 
	TRequestStatus requestStatus;
	TBuf8<200> buf2;
	TRequestStatus requestStatus2;
	
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);

    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData(name, indexAndEntries);
	ltsyData.SerialiseL(data);
	
	cache->AppendL(entryPtr);
            
    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData(name, cache);
    ArrayData.SerialiseL(data2);
	
	// First Read
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, data2, 10);    	            
    bookStore.Read(requestStatus, index, numEntries, buf); 

	// Second Read
    bookStore2.Read(requestStatus2, index, numEntries, buf2); 
    
    // wait for first answer	
    User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

	// wait for second answer
    User::WaitForRequest(requestStatus2);        
	AssertMockLtsyStatusL();	
	ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());	

	CleanupStack::PopAndDestroy(cache);
	CleanupStack::PopAndDestroy(&bookStore2);
	CleanupStack::PopAndDestroy(&bookStore);
	CleanupStack::PopAndDestroy(&data2);
	CleanupStack::PopAndDestroy(&data);
	CleanupStack::PopAndDestroy(&phone2);
	CleanupStack::PopAndDestroy(&telServer2);
	CleanupStack::PopAndDestroy(this);     
    }
    
    
    
void CCTsyPhoneBookStoreFU::AuxRead5L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);

	RBuf8 data;
	CleanupClosePushL(data);

	//-------------------------------------------------------------------------
	// Test A: Test timeout of RMobilePhoneBookStore::Read
 	//-------------------------------------------------------------------------
 	
 	SetPhonebookNumOfEntriesAndInitPhonebookL( name, 10 );
 	
	TRequestStatus requestStatus;
	TInt index(1);
	TInt numEntries(1);	
	TBuf8<200> buf;			 

    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);

    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData(name, indexAndEntries);
	ltsyData.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data);	
    
    bookStore.Read(requestStatus, index, numEntries, buf); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());	

	CleanupStack::PopAndDestroy(2); //bookStore, cache
	CleanupStack::PopAndDestroy(2, this); // data, this
    }    


void CCTsyPhoneBookStoreFU::AuxWrite1L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(-1); 
	TBuf8<200> buf;	    	    

    //-------------------------------
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &buf );    
    TInt ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );
    
    //-------------------------------

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

    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();
    
    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, index, entryPtr);           
    tsyData.SerialiseL(data);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data, KErrNotSupported);

    bookStore.Write(requestStatus, buf, index);
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	


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

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrGeneral, data2, 0);
    
    bookStore.Write(requestStatus, buf, index);
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());	
	

	//-------------------------------------------------------------------------
	// TEST C: successful completion of request
 	//-------------------------------------------------------------------------

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 0);
    
    bookStore.Write(requestStatus, buf, index);
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	


	//-------------------------------------------------------------------------
	// try to write to the place, where there is entry without text
 	//-------------------------------------------------------------------------
 	index = 1;
 	entryPtr->iText = HBufC::NewLC( name.Length() );	
    entryPtr->iText->Des() = name;
    CleanupStack::Pop();

    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBText, name);
 	
 	
    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData3(name, index, entryPtr);           
    data.Close();    
    tsyData3.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 0);
    
    bookStore.Write(requestStatus, buf, index);
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

	//-------------------------------------------------------------------------
	// try to write to the place, where there is entry with text
 	//-------------------------------------------------------------------------
 	index = 1;
 	
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 0);
    
    bookStore.Write(requestStatus, buf, index);
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

 	//-------------------------------------------------------------------------
	// TEST E: Unsolicited completion of RMobilePhoneBookStore::Write
	// from LTSY.
 	//-------------------------------------------------------------------------

	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        
    
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();



	CleanupStack::PopAndDestroy(1); //pbBuffer
	CleanupStack::PopAndDestroy(1); //entryPtr
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this	
    }


void CCTsyPhoneBookStoreFU::AuxWrite2L(const TDesC& aName)
    {	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(-1); 
	TBuf8<200> buf;	 		 
	    	    

    //-------------------------------
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &buf );    
    TInt ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

 	//-------------------------------------------------------------------------
	// Test cancelling of RMobilePhoneBookStore::Write
 	//-------------------------------------------------------------------------
    
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();

    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, index, entryPtr);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 10);

    bookStore.Write(requestStatus, buf, index);
    
	bookStore.CancelAsyncRequest(EMobilePhoneBookStoreWrite);
	                             
	User::WaitForRequest(requestStatus); 
 	
    // These request can't be cancelled, because no
    // functionality for cancelling. So everything
    // to do, is let the request continue and return KErrNone.(CMmPhoneBookStoreTsy::CancelService)
 	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

    // to check branch with unknown request
    bookStore.CancelAsyncRequest(EMobilePhoneBookStoreWrite);
	 
	CleanupStack::PopAndDestroy(1); //pbBuffer
	CleanupStack::PopAndDestroy(1); //entryPtr
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this		
    }


void CCTsyPhoneBookStoreFU::AuxWrite3L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(0); 
	TBuf8<200> buf;	 		 
	    	    
    //--------------------------------------
    //  input bad index = 0
    //--------------------------------------
    
    bookStore.Write(requestStatus, buf, index);
    
	User::WaitForRequest(requestStatus); 
 	
	ASSERT_EQUALS(KErrArgument, requestStatus.Int());	

	AssertMockLtsyStatusL();

    //--------------------------------------
    //  input not buffer without TVL tags
    //--------------------------------------
    
    index = -2;
    
    bookStore.Write(requestStatus, buf, index);
    
	User::WaitForRequest(requestStatus); 
	 	
	ASSERT_EQUALS(KErrArgument, requestStatus.Int());	

	AssertMockLtsyStatusL();

    //  small buffer passing
    //-------------------------------------
        
    index = -1;
	TBuf8<1> buf2;
       
    bookStore.Write(requestStatus, buf2, index);
    
	User::WaitForRequest(requestStatus); 
 	
	ASSERT_EQUALS(KErrArgument, requestStatus.Int());	

	AssertMockLtsyStatusL();


    //---------------------------------------------
	TRequestStatus writeStatus;
	TInt writeIndex(-1); 
	TBuf8<200> writeBuf;	 		 	    	    
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &writeBuf );    
    TInt ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();

 	entryPtr->iText = HBufC::NewLC( name.Length() );	
    entryPtr->iText->Des() = name;
    CleanupStack::Pop();
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBText, name);

 	entryPtr->iNumber = HBufC::NewLC( name.Length() );	
    entryPtr->iNumber->Des() = name;
    CleanupStack::Pop();
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBNumber, name);

    HBufC* hbuf = HBufC::NewLC( name.Length() );
    hbuf->Des() = name;
    CleanupStack::Pop();
    entryPtr->iEmail->AppendL( hbuf->Des() );
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBEmailAddress, name);

    HBufC* hbuf2 = HBufC::NewLC( name.Length() );
    hbuf2->Des() = name;
    CleanupStack::Pop();
    entryPtr->iSne->AppendL( hbuf2->Des() );
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBSecondName, name);
    
    TUint8 tmp = 0;
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBTonNpi, tmp);

    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, writeIndex, entryPtr);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 10);
    bookStore.Write(writeStatus, writeBuf, writeIndex);
    
	User::WaitForRequest(writeStatus); 
    if ( !name.CompareF( KETelIccAdnPhoneBook ) || 
    		!name.CompareF( KETelIccFdnPhoneBook ) || 
    		!name.CompareF( KETelIccVoiceMailBox ) || 
    		!name.CompareF( KETelIccMbdnPhoneBook ))
        {
         // fail because email text length not set in phoneBookStoreOpen()
    	ASSERT_TRUE(KErrArgument == writeStatus.Int());
        }
    else
        {
        // fail because of textlength is set in phonebookStoreOpen only for Adn, Fdn, Vmbx, Mbdn
	    ASSERT_TRUE(0xFFFFEC48 == writeStatus.Int()); 
        }

	CleanupStack::PopAndDestroy(6, this); // data, data2, this, etc...
    }


void CCTsyPhoneBookStoreFU::AuxWrite4L(const TDesC& aName)
    {	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);


	RMobilePhoneBookStore bookStore2;
	
	ret = bookStore2.Open(phone2, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
	AssertMockLtsyStatusL();      
    
	CleanupClosePushL(bookStore2);
	
	TRequestStatus requestStatus;
	TRequestStatus requestStatus2;
	TInt index(-1); 
	TBuf8<200> buf;	 		 

    //-------------------------------
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &buf );    
    ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

	//-------------------------------------------------------------------------
	// Test A: Test multiple clients requesting RMobilePhoneBookStore::Write
 	//-------------------------------------------------------------------------

    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();

    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, index, entryPtr);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 10);

    bookStore.Write(requestStatus, buf, index);

    bookStore2.Write(requestStatus2, buf, index);

	User::WaitForRequest(requestStatus); 
 	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	


	User::WaitForRequest(requestStatus2); 
 	
	ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());	

	AssertMockLtsyStatusL();

	// Done !
	CleanupStack::PopAndDestroy(9, this); // phone2, telServer2, data, this...
    }


void CCTsyPhoneBookStoreFU::AuxWrite5L(const TDesC& aName)
    {	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(-1); 
	TBuf8<200> buf;	 		 
	    	    

    //-------------------------------
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &buf );    
    TInt ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

 	//-------------------------------------------------------------------------

    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();
       
    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, index, entryPtr);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);

    bookStore.Write(requestStatus, buf, index);
    
	User::WaitForRequest(requestStatus); 
 	
	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());	


	AssertMockLtsyStatusL();
	 
	CleanupStack::PopAndDestroy(1); //pbBuffer
	CleanupStack::PopAndDestroy(1); //entryPtr
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this			
    }


void CCTsyPhoneBookStoreFU::AuxNotifyStoreEvent1L(const TDesC& aName)
    {	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	
	TRequestStatus requestStatus;
	TUint32 event;
	TInt index(-1);

    //--------------------------------
    // notify on write
    //--------------------------------
    
	bookStore.NotifyStoreEvent(requestStatus, event, index );

    //--------------------------------
	TRequestStatus writeStatus;
	TInt writeIndex(-1); 
	TBuf8<200> buf;	 		 	    	    
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &buf );    
    TInt ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );
    
    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();
    
    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, writeIndex, entryPtr);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo;
    pbEntryInfo.iLocation = 0;
    pbEntryInfo.iMaxNumLength = 50;
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 0);

    bookStore.Write(writeStatus, buf, writeIndex);

	User::WaitForRequest(writeStatus);	
	ASSERT_EQUALS(KErrNone, writeStatus.Int());
    //--------------------------------

	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
	ASSERT_TRUE( RMobilePhoneStore::KStoreEntryAdded == event );
	ASSERT_EQUALS(writeIndex, index);
 
	AssertMockLtsyStatusL();

    //--------------------------------
    // notify on delete
    //--------------------------------
	TRequestStatus deleteStatus;
	TInt deleteIndex(writeIndex); 

	bookStore.NotifyStoreEvent(requestStatus, event, index );

    TMockLtsyPhoneBookData1<TInt> tsyData3(name, deleteIndex);           
    data.Close();    
    tsyData3.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2);
	
    bookStore.Delete(deleteStatus, deleteIndex);
    
	User::WaitForRequest(deleteStatus);	
	ASSERT_EQUALS(KErrNone, deleteStatus.Int());

	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
	
	//Event is KStoreEmpty because last entry was deleted from storage
	ASSERT_TRUE( RMobilePhoneStore::KStoreEmpty == event );
	ASSERT_EQUALS(deleteIndex, index);

    //--------------------------------
    // notify on deleteAll
    //--------------------------------
	bookStore.NotifyStoreEvent(requestStatus, event, index );
	
    TMockLtsyPhoneBookData0 tsyData4(name);           
    data.Close();    
    tsyData4.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrNone, data2);

    bookStore.DeleteAll(deleteStatus);
    
	User::WaitForRequest(deleteStatus);	
	ASSERT_EQUALS(KErrNone, deleteStatus.Int());
	
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
	ASSERT_TRUE( RMobilePhoneStore::KStoreEmpty == event );
	ASSERT_TRUE(-1 == index);
	
	 
	CleanupStack::PopAndDestroy(2); //pbBuffer, entryPtr 
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this		
    }


void CCTsyPhoneBookStoreFU::AuxNotifyStoreEvent2L(const TDesC& aName)
    {	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	
	TRequestStatus requestStatus;
	TUint32 event;
	TInt index(-1);


    //--------------------------------
    // cancell notify on write
    //--------------------------------

	bookStore.NotifyStoreEvent(requestStatus, event, index );

    bookStore.CancelAsyncRequest(EMobilePhoneStoreNotifyStoreEvent);
    
    //-------------------------------
	TRequestStatus writeStatus;
	TInt writeIndex(-1); 
	TBuf8<200> buf;	 		 	    	    
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &buf );    
    TInt ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );
    
    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();

    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, writeIndex, entryPtr);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 0);

    bookStore.Write(writeStatus, buf, writeIndex);

	User::WaitForRequest(writeStatus);	
	ASSERT_EQUALS(KErrNone, writeStatus.Int());
    //-------------------------------

	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrCancel, requestStatus.Int());
	 
	AssertMockLtsyStatusL();
	
    // to check branch with unknown request
    bookStore.CancelAsyncRequest(EMobilePhoneStoreNotifyStoreEvent);
	 
	CleanupStack::PopAndDestroy(2); //pbBuffer, entryPtr 
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this		
    }


void CCTsyPhoneBookStoreFU::AuxNotifyStoreEvent4L(const TDesC& aName)
    {	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);


	RMobilePhoneBookStore bookStore2;
	
	ret = bookStore2.Open(phone2, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
	AssertMockLtsyStatusL();      
    
	CleanupClosePushL(bookStore2);
	

	TRequestStatus requestStatus;
	TRequestStatus requestStatus2;
	TUint32 event;
	TUint32 event2;
	TInt index(-1);
	TInt index2(-1);
	
	bookStore.NotifyStoreEvent(requestStatus, event, index );
	bookStore2.NotifyStoreEvent(requestStatus2, event2, index2 );


    //- write ------------------------------
	TRequestStatus writeStatus;
	TInt writeIndex(-1); 
	TBuf8<200> buf;	 		 
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &buf );    
    ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();

    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData(name, writeIndex, entryPtr);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 10);

    bookStore.Write(writeStatus, buf, writeIndex);

	User::WaitForRequest(writeStatus); 
 	
	ASSERT_EQUALS(KErrNone, writeStatus.Int());	
	//------------------------------


	User::WaitForRequest(requestStatus); 
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
	ASSERT_TRUE( RMobilePhoneStore::KStoreEntryAdded == event );
	ASSERT_EQUALS(writeIndex, index);

	User::WaitForRequest(requestStatus2); 
	ASSERT_EQUALS(KErrNone, requestStatus2.Int());	
	ASSERT_TRUE( RMobilePhoneStore::KStoreEntryAdded == event2 );
	ASSERT_EQUALS(writeIndex, index2);
	

	AssertMockLtsyStatusL();

	// Done !
	CleanupStack::PopAndDestroy(9, this); // phone2, telServer2, data, this...
    }

void CCTsyPhoneBookStoreFU::AuxNotifySDNStoreEvent1L()
    {
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));
    OpenPhoneL();
    
    TName name(KETelIccSdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    
    OpenPhoneBookStoreL(bookStore, name, iPhone);
    CleanupClosePushL(bookStore);
    
    
    TRequestStatus requestStatus;
    TUint32 event;
    TInt index(-1);

    // The notification for SDN phonebook will never return.
    // User will get the notification through SAT that SDN phonebook
    // has been changed. Then user will read SDN entries.
    bookStore.NotifyStoreEvent(requestStatus, event, index );

    TRequestStatus timerStatus;
    RTimer timer;
    timer.CreateLocal();
    //Wait for 5 Seconds.
    timer.After(timerStatus, 5*KOneSecond);

    User::WaitForRequest(requestStatus, timerStatus);
    ASSERT_EQUALS(KErrNone, timerStatus.Int());

    bookStore.CancelAsyncRequest(EMobilePhoneStoreNotifyStoreEvent);
    User::WaitForRequest(requestStatus);    
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());
     
    AssertMockLtsyStatusL();
     
    CleanupStack::PopAndDestroy(2, this); // bookStore, this      
    
    }

void CCTsyPhoneBookStoreFU::AuxDelete1L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 data2;
	CleanupClosePushL(data2);

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(0);
	// Increase PopAndDestroy index (this, data, data2, bookStore)
	TInt popAndDestroyIndex(4);
	    	    
 	//-------------------------------------------------------------------------
	// TEST A: failure to dispatch request to LTSY
 	//-------------------------------------------------------------------------
    TMockLtsyPhoneBookData1<TInt> tsyData(name, index);           
    tsyData.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data, KErrNotSupported);
	
    bookStore.Delete(requestStatus, index);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());


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

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrGeneral, data2);

    bookStore.Delete(requestStatus, index);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

 	//-------------------------------------------------------------------------
	// TEST E: Unsolicited completion of RMobilePhoneBookStore::Delete
	// from LTSY.
 	//-------------------------------------------------------------------------

	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2, 4);
    User::WaitForRequest(mockLtsyStatus);        
    
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------
	// TEST C: Successful completion request of
	// RMobilePhoneBookStore::Delete
 	//-------------------------------------------------------------------------

    // delete of unwriten entry
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2, 4);

    bookStore.Delete(requestStatus, index);
    
	User::WaitForRequest(requestStatus);	
	// KErrNone cause delete() does not care about entries with number more than exist
	ASSERT_EQUALS(KErrNone, requestStatus.Int());

    // Write only in case of ADN or FDN phonebook. This is because CTSY supports 
    // phonebook cache only for ADN and FDN. 
    // With other phonebooks writing does not affect to CTSY's delete functionality.
    if ( !name.CompareF( KETelIccAdnPhoneBook ) || !name.CompareF( KETelIccFdnPhoneBook ))
        {
    	// first write something -----------------------
    	TRequestStatus writeStatus;
    	TInt writeIndex(-1); 
    	TBuf8<200> writeBuf;	 		 	    	    
        
        CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
        CleanupStack::PushL(pbBuffer);
        
        // Increase PopAndDestroy index (pbBuffer)
        popAndDestroyIndex++;
        
        pbBuffer->Set( &writeBuf );    
        TInt ret = pbBuffer->AddNewEntryTag();
        TUint16 location(0);
        ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

        CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
        CleanupStack::PushL(entryPtr);
        entryPtr->ConstructL();
        
        // Increase PopAndDestroy index (entryPtr)
        popAndDestroyIndex++;
        
        _LIT(KPBText, "PBText");
        entryPtr->iText = HBufC::NewLC( KPBText().Length() );	
        entryPtr->iText->Des() = KPBText;
        CleanupStack::Pop();
        ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBText, KPBText);

        TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyDataW(name, writeIndex, entryPtr);           
        tsyDataW.SerialiseL(data);
        
        // Write entry    
    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 4);

        bookStore.Write(writeStatus, writeBuf, writeIndex);
        
    	User::WaitForRequest(writeStatus); 
    	ASSERT_EQUALS(KErrNone, writeStatus.Int());
	    index = writeIndex;
        }

	//------------------------------------------------------	
	// Now delete entry
    TMockLtsyPhoneBookData1<TInt> tsyData4(name, index);           
    data.Close();    
    tsyData4.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2);

    bookStore.Delete(requestStatus, index);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
   
	AssertMockLtsyStatusL();
	
    // this, data, data2, bookStore, pbBuffer, entryPtr 	
	CleanupStack::PopAndDestroy(popAndDestroyIndex);	
    }


void CCTsyPhoneBookStoreFU::AuxDelete2L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 data2;
	CleanupClosePushL(data2);

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	
	TRequestStatus requestStatus;
	TInt index(0);
	    	    

    TMockLtsyPhoneBookData1<TInt> tsyData(name, index);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2);

    bookStore.Delete(requestStatus, index);
    bookStore.CancelAsyncRequest(EMobilePhoneStoreDelete);
    
	User::WaitForRequest(requestStatus);	
           // These request can't be cancelled, because no
            // functionality for cancelling. So everything
            // to do, is let the request continue and return KErrNone. 
            //(from CMmPhoneBookStoreTsy::CancelService)
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    User::WaitForRequest(mockLtsyStatus);        
	AssertMockLtsyStatusL();


    bookStore.CancelAsyncRequest(EMobilePhoneStoreDelete);
	
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this		
    }
    
void CCTsyPhoneBookStoreFU::AuxDelete3L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 data2;
	CleanupClosePushL(data2);

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(-1);

    // Increase PopAndDestroy index (this, data, data2, bookStore)
	TInt popAndDestroyIndex(4);
    	    
    //---------------------------------------------
    // check bad index < 0
    //---------------------------------------------
    // If user supplies index which is less than 0, complete with KErrArgument,
    // each record is numbered from 1 to 255 (or maximum number of records).->
    
    bookStore.Delete(requestStatus, index);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrArgument, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	

    //---------------------------------------------
    // delete when nothing was written
    //---------------------------------------------
	index = 0;	    	    
    
    TMockLtsyPhoneBookData1<TInt> tsyData_(name, index);           
    tsyData_.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);
    
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2, 4);

    bookStore.Delete(requestStatus, index);
    
    //TSY does not take the responsibility, if the location number is
    // greater than total numbers of records in this PBStore.
    // so we won't get error status
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
	AssertMockLtsyStatusL();

    // Write only in case of ADN or FDN phonebook. This is because CTSY supports 
    // phonebook cache only for ADN and FDN. 
    // With other phonebooks writing does not affect to CTSY's delete functionality.
    if ( !name.CompareF( KETelIccAdnPhoneBook ) || !name.CompareF( KETelIccFdnPhoneBook ))
        {
    	// first write something -----------------------
    	TRequestStatus writeStatus;
    	TInt writeIndex(-1); 
    	TBuf8<200> writeBuf;	 		 	    	    
        
        CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
        CleanupStack::PushL(pbBuffer);
        
        // Increase PopAndDestroy index (pbBuffer)
        popAndDestroyIndex++;
        
        pbBuffer->Set( &writeBuf );    
        TInt ret = pbBuffer->AddNewEntryTag();
        TUint16 location(0);
        ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

        CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
        CleanupStack::PushL(entryPtr);
        entryPtr->ConstructL();
        
        // Increase PopAndDestroy index (entryPtr)
        popAndDestroyIndex++;
        
        _LIT(KPBText, "PBText");
        entryPtr->iText = HBufC::NewLC( KPBText().Length() );	
        entryPtr->iText->Des() = KPBText;
        CleanupStack::Pop();
        ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBText, KPBText);

        TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData3(name, writeIndex, entryPtr);           
        tsyData3.SerialiseL(data);
        
        // 1 entry    
    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 4);

        bookStore.Write(writeStatus, writeBuf, writeIndex);
        
    	User::WaitForRequest(writeStatus); 
    	ASSERT_EQUALS(KErrNone, writeStatus.Int());	

        // 2 entry
        pbEntryInfo.iLocation = 1;
        TMockLtsyPhoneBookData1< TPBEntryInfo > styData4(name, pbEntryInfo);
        data2.Close();    
        styData4.SerialiseL(data2);
        
        writeIndex = -1;

    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 4);

        bookStore.Write(writeStatus, writeBuf, writeIndex);
        
    	User::WaitForRequest(writeStatus); 
    	ASSERT_EQUALS(KErrNone, writeStatus.Int());
        }

	// now delete the writen entry
	index = 0;
	
    TMockLtsyPhoneBookData1<TInt> tsyData4(name, index);           
    data.Close();    
    tsyData4.SerialiseL(data);

    pbEntryInfo.iLocation = 0;
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData5(name, pbEntryInfo);
    data2.Close();    
    styData5.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2, 4);

    bookStore.Delete(requestStatus, index);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
	AssertMockLtsyStatusL();

    // delete it again
	index = 0;
	
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNotFound, data2, 10);

    bookStore.Delete(requestStatus, index);
    
    // here KErrNotFound should be...
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNotFound, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	
    // this, data, data2, bookStore, pbBuffer, entryPtr 	
	CleanupStack::PopAndDestroy(popAndDestroyIndex);	
	
    }
    
    
void CCTsyPhoneBookStoreFU::AuxDelete4L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

	RBuf8 data2;
	CleanupClosePushL(data2);

	RBuf8 data3;
	CleanupClosePushL(data3);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);


	RMobilePhoneBookStore bookStore2;
	
	ret = bookStore2.Open(phone2, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
	AssertMockLtsyStatusL();      
    
	CleanupClosePushL(bookStore2);
	
	TRequestStatus requestStatus;
	TRequestStatus requestStatus2;
	TInt index(0); 
	TInt index2(1); 

    TMockLtsyPhoneBookData1<TInt> tsyData(name, index);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {1, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data2, 4);


    bookStore.Delete(requestStatus, index);

    TPBEntryInfo pbEntryInfo2 = {1, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData3(name, pbEntryInfo2);
    styData3.SerialiseL(data3);

    TMockLtsyPhoneBookData1<TInt> tsyData4(name, index2);           
    data.Close();    
    tsyData4.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteIPC, KErrNone, data3, 4);

    bookStore2.Delete(requestStatus2, index2);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	User::WaitForRequest(requestStatus2);	
	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    
	AssertMockLtsyStatusL();
	
	CleanupStack::PopAndDestroy(8, this); // data, data2, this...
    }
    
    
void CCTsyPhoneBookStoreFU::AuxDelete5L(const TDesC& aName)
    {	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 data2;
	CleanupClosePushL(data2);

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	TInt index(0);
	    	    

    TMockLtsyPhoneBookData1<TInt> tsyData(name, index);           
    tsyData.SerialiseL(data);

    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteIPC, data);

    bookStore.Delete(requestStatus, index);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this		
    }


void CCTsyPhoneBookStoreFU::AuxGetInfo1L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 data2;
	CleanupClosePushL(data2);

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
   	TRequestStatus mockLtsyStatus;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg(bookInfo);

    if ( !name.CompareF( KETelIccSdnPhoneBook ) )
        {
        CStorageInfoData storageData;       
        
		SetStorageInfoData(storageData);
            
    	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
    	retStoreInitC.SerialiseL(data2);
    		
    	iMockLTSY.NotifyTerminated(mockLtsyStatus);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
        User::WaitForRequest(mockLtsyStatus);        
		}

    if ( !name.CompareF( KETelIccSdnPhoneBook ) || !name.CompareF( KETelIccVoiceMailBox ))
        {
        TMockLtsyPhoneBookData0 tsyData(name);           
        tsyData.SerialiseL(data);

        TInt usedEntries(-1);
        TMockLtsyPhoneBookData1< TInt > styData2(name, usedEntries);
        data2.Close();    
        styData2.SerialiseL(data2);

        // test A
    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreGetInfoIPC, data, KErrNotSupported);
        bookStore.GetInfo(requestStatus, bookPckg); 
    	
        User::WaitForRequest(requestStatus);        
    	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	
    	AssertMockLtsyStatusL();

        // test B
    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreGetInfoIPC, data);
    	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreGetInfoIPC, KErrGeneral, data2);
    	
        bookStore.GetInfo(requestStatus, bookPckg); 
    	
        User::WaitForRequest(requestStatus);        
    	AssertMockLtsyStatusL();
    	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());	

        // TEST C, just get info
    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreGetInfoIPC, data);
    	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreGetInfoIPC, KErrNone, data2);
    	
        bookStore.GetInfo(requestStatus, bookPckg); 
    	
        User::WaitForRequest(requestStatus);        
    	AssertMockLtsyStatusL();
    	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
    	ASSERT_TRUE(0 == bookInfo.iName.Compare(name));   
    	ASSERT_EQUALS(-1, bookInfo.iUsedEntries);	
    	ASSERT_EQUALS(-1, bookInfo.iTotalEntries);	
    	ASSERT_EQUALS(50, bookInfo.iMaxTextLength);	
    	ASSERT_EQUALS(50, bookInfo.iMaxNumLength);	
    	ASSERT_EQUALS(RMobilePhoneBookStore::ELocationIccMemory, bookInfo.iLocation);	
    	ASSERT_EQUALS((TUint16)0, bookInfo.iChangeCounter);	
    	if(!name.CompareF( KETelIccVoiceMailBox ))
    		{
	    	ASSERT_EQUALS((TUint32)0, bookInfo.iCaps);	
    		}
    	else
    		{
	    	ASSERT_EQUALS((TUint32)RMobilePhoneStore::KCapsReadAccess, bookInfo.iCaps);	
    		}

        }
	else if ( !name.CompareF( KETelIccBdnPhoneBook ) )
        {
        bookStore.GetInfo(requestStatus, bookPckg); 
    	
        User::WaitForRequest(requestStatus);        
    	AssertMockLtsyStatusL();
    	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
    	ASSERT_TRUE(0 == bookInfo.iName.Compare(name));     	
    	ASSERT_EQUALS(0, bookInfo.iUsedEntries);	
    	ASSERT_EQUALS(-1, bookInfo.iTotalEntries);	
    	ASSERT_EQUALS(-1, bookInfo.iMaxTextLength);	
    	ASSERT_EQUALS(-1, bookInfo.iMaxNumLength);	
    	ASSERT_EQUALS(RMobilePhoneBookStore::ELocationUnknown, bookInfo.iLocation);	
    	ASSERT_EQUALS((TUint16)0, bookInfo.iChangeCounter);	
    	ASSERT_EQUALS((TUint32)0, bookInfo.iCaps);	
        }
    else    // ADN FDN
        {
        //TEST C
        bookStore.GetInfo(requestStatus, bookPckg); 
    	
        User::WaitForRequest(requestStatus);        
    	AssertMockLtsyStatusL();
    	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
    	ASSERT_TRUE(0 == bookInfo.iName.Compare(name));     	
    	ASSERT_EQUALS(0, bookInfo.iUsedEntries);	
    	ASSERT_EQUALS(-1, bookInfo.iTotalEntries);	
    	ASSERT_EQUALS(50, bookInfo.iMaxTextLength);	
    	ASSERT_EQUALS(50, bookInfo.iMaxNumLength);	
    	ASSERT_EQUALS(RMobilePhoneBookStore::ELocationIccMemory, bookInfo.iLocation);	
    	ASSERT_EQUALS((TUint16)0, bookInfo.iChangeCounter);	
    	if(!name.CompareF( KETelIccAdnPhoneBook ))
    		{
	    	ASSERT_EQUALS((TUint32)(RMobilePhoneStore::KCapsDeleteAll | 
	    		RMobilePhoneStore::KCapsNotifyEvent |
	    			RMobilePhoneStore::KCapsReadAccess |
	    				RMobilePhoneStore::KCapsWriteAccess),
	    		bookInfo.iCaps);	
    		}
    	else if( !name.CompareF( KETelIccFdnPhoneBook ))
    		{
	    	ASSERT_EQUALS((TUint32)(RMobilePhoneStore::KCapsDeleteAll | 
	    		RMobilePhoneStore::KCapsNotifyEvent |
	    			RMobilePhoneStore::KCapsReadAccess |
	    				RMobilePhoneStore::KCapsWriteAccess |
	    					RMobilePhoneBookStore::KCapsRestrictedWriteAccess),
	    		bookInfo.iCaps);	
    		}
    	else
    		{
	    	ASSERT_EQUALS((TUint32)0, bookInfo.iCaps);	
    		}

        }

    // change something ----------------------------------------------------
    
    CStorageInfoData storageData;       
    const TInt KMaxLen = 150;
    const TUint32 KCaps
    	= RMobilePhoneStore::KCapsReadAccess
    	| RMobilePhoneStore::KCapsWriteAccess
    	| RMobilePhoneStore::KCapsNotifyEvent;
    
	SetStorageInfoData(storageData, KMaxLen);

    storageData.iVMBXCaps =
     storageData.iMBDNCaps = KCaps;
    
    storageData.iVMBXNumOfEntries = 
     storageData.iMBDNNumOfEntries = 0;
    
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
	data2.Close();    
	retStoreInitC.SerialiseL(data2);
		
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        
    

    //now get changes ----------------------------------------    
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo2;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg2(bookInfo2);
	
    bookStore.GetInfo(requestStatus, bookPckg2); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	
	if ( !name.CompareF( KETelIccBdnPhoneBook ) )
    	{
		ASSERT_EQUALS(KErrNone, requestStatus.Int());	
		ASSERT_TRUE(name == bookInfo2.iName); 
		ASSERT_EQUALS(-1, bookInfo2.iMaxNumLength); 
		ASSERT_EQUALS(-1, bookInfo2.iMaxTextLength); 
		ASSERT_TRUE(bookInfo.iLocation == bookInfo2.iLocation); 
		ASSERT_TRUE(bookInfo.iIdentity == bookInfo2.iIdentity); 
		ASSERT_TRUE(bookInfo.iChangeCounter == bookInfo2.iChangeCounter);   // no write or delete was done
        }
    else
        {
    	ASSERT_EQUALS(KErrNone, requestStatus.Int());	
    	ASSERT_TRUE(name == bookInfo2.iName); 
    	ASSERT_EQUALS(KMaxLen, bookInfo2.iMaxNumLength); 
    	ASSERT_EQUALS(KMaxLen, bookInfo2.iMaxTextLength); 
    	ASSERT_TRUE(bookInfo.iLocation == bookInfo2.iLocation); 
    	ASSERT_TRUE(bookInfo.iIdentity == bookInfo2.iIdentity); 
    	ASSERT_TRUE(bookInfo.iChangeCounter == bookInfo2.iChangeCounter);   // no write or delete was done
        if ( !name.CompareF( KETelIccVoiceMailBox ) || 
        		!name.CompareF( KETelIccMbdnPhoneBook ) )
            {
        	ASSERT_EQUALS(KCaps, bookInfo2.iCaps);	
            }
        }

    // get info afer cache reset ----------------------------------------    

	//TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    TMockLtsyPhoneBookData0 tsyData4(name);
    data.Close();    
    tsyData4.SerialiseL(data);
	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreResetCacheIPC, KErrNone, data, 2);
    User::WaitForRequest(mockLtsyStatus);
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	        
	AssertMockLtsyStatusL();

	
    bookStore.GetInfo(requestStatus, bookPckg); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	
    if ( !name.CompareF( KETelIccAdnPhoneBook ) || !name.CompareF( KETelIccFdnPhoneBook ))
        {            
	    ASSERT_EQUALS(KErrNotReady, requestStatus.Int());	
        }
    else
        {
	    ASSERT_EQUALS(KErrNone, requestStatus.Int());	
        }


    // Test E
    TInt usedEntries(-1);
    TMockLtsyPhoneBookData1< TInt > styData2(name, usedEntries);
    data2.Close();    
    styData2.SerialiseL(data2);
    
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreGetInfoIPC, KErrNone, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        
	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this); // data, data2, this...	
    }
    


void CCTsyPhoneBookStoreFU::AuxGetInfo2L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 data2;
	CleanupClosePushL(data2);

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg(bookInfo);

    // this is only for SDN, VMBX !!!
    
    CStorageInfoData storageData;       
    
	SetStorageInfoData(storageData);
        
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
	retStoreInitC.SerialiseL(data2);
		
	TRequestStatus requestStatus;
	TRequestStatus mockLtsyStatus;
	
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        

    TMockLtsyPhoneBookData0 tsyData(name);           
    tsyData.SerialiseL(data);

    TInt usedEntries(-1);
    TMockLtsyPhoneBookData1< TInt > styData2(name, usedEntries);
    data2.Close();    
    styData2.SerialiseL(data2);


	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreGetInfoIPC, data);
	
    bookStore.GetInfo(requestStatus, bookPckg); 
    bookStore.CancelAsyncRequest(EMobilePhoneStoreGetInfo);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreGetInfoIPC, KErrNone, data2, 10);
        	
    User::WaitForRequest(requestStatus);        
	ASSERT_EQUALS(KErrCancel, requestStatus.Int());	
    
    User::WaitForRequest(mockLtsyStatus);        
	AssertMockLtsyStatusL();
	

	CleanupStack::PopAndDestroy(4, this); // data, data2, boookstore, this
    }


    
void CCTsyPhoneBookStoreFU::AuxGetInfo3L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;

	RMobilePhone::TMobilePhoneLockInfoV1 badBookInfo;
	RMobilePhone::TMobilePhoneLockInfoV1Pckg badBookPckg(badBookInfo);	

    bookStore.GetInfo(requestStatus, badBookPckg); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrArgument, requestStatus.Int());	

	CleanupStack::PopAndDestroy(2, this);   // bookStore, this
    }
    
    
void CCTsyPhoneBookStoreFU::AuxGetInfo4L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);


	RMobilePhoneBookStore bookStore2;
	
	ret = bookStore2.Open(phone2, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
	AssertMockLtsyStatusL();      
    
	CleanupClosePushL(bookStore2);
	
	TRequestStatus requestStatus;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg(bookInfo);
	
	TRequestStatus requestStatus2;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo2;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg2(bookInfo2);

    if ( !name.CompareF( KETelIccSdnPhoneBook ) || !name.CompareF( KETelIccVoiceMailBox ) )
        {
        CStorageInfoData storageData;       
        
		SetStorageInfoData(storageData);
            
    	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
    	retStoreInitC.SerialiseL(data2);
    		
    	TRequestStatus mockLtsyStatus;
    	iMockLTSY.NotifyTerminated(mockLtsyStatus);
        iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
        User::WaitForRequest(mockLtsyStatus);        

        TMockLtsyPhoneBookData0 tsyData(name);           
        tsyData.SerialiseL(data);

        TInt usedEntries(-1);
        TMockLtsyPhoneBookData1< TInt > styData2(name, usedEntries);
        data2.Close();    
        styData2.SerialiseL(data2);

    	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreGetInfoIPC, data);
    	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreGetInfoIPC, KErrNone, data2);
        }


    bookStore.GetInfo(requestStatus, bookPckg); 

    bookStore2.GetInfo(requestStatus2, bookPckg2); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	


    User::WaitForRequest(requestStatus2);        
	AssertMockLtsyStatusL();
	
    if ( !name.CompareF( KETelIccAdnPhoneBook ) 
        || !name.CompareF( KETelIccFdnPhoneBook )
            || !name.CompareF( KETelIccMbdnPhoneBook ) 
               || !name.CompareF( KETelIccBdnPhoneBook ) )
        {            
	    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
	    ASSERT_TRUE(bookInfo.iType == bookInfo2.iType);
	    ASSERT_TRUE(bookInfo.iTotalEntries == bookInfo2.iTotalEntries);
	    ASSERT_TRUE(bookInfo.iUsedEntries == bookInfo2.iUsedEntries);
	    ASSERT_TRUE(bookInfo.iCaps == bookInfo2.iCaps);
	    ASSERT_TRUE(bookInfo.iName == bookInfo2.iName);
	    ASSERT_TRUE(bookInfo.iMaxNumLength == bookInfo2.iMaxNumLength);
	    ASSERT_TRUE(bookInfo.iMaxTextLength == bookInfo2.iMaxTextLength);
	    ASSERT_TRUE(bookInfo.iLocation == bookInfo2.iLocation);
	    ASSERT_TRUE(bookInfo.iChangeCounter == bookInfo2.iChangeCounter);    	
	    ASSERT_TRUE(bookInfo.iIdentity == bookInfo2.iIdentity); 
	    }
    else
        {
	    ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());	
        }
    
	AssertMockLtsyStatusL();
	
	CleanupStack::PopAndDestroy(7, this); // data, data2, this...	    
    }
    
 
 void CCTsyPhoneBookStoreFU::AuxGetInfo5L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	

	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo;
	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg(bookInfo);

    // this is only for SDN !!
    
    CStorageInfoData storageData;       
    
	SetStorageInfoData(storageData);
        
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
	retStoreInitC.SerialiseL(data);
		
	TRequestStatus requestStatus;
	TRequestStatus mockLtsyStatus;
		
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data, 0);
    User::WaitForRequest(mockLtsyStatus);        

    data.Close();
    TMockLtsyPhoneBookData0 tsyData(name);           
    tsyData.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreGetInfoIPC, data);
	
    bookStore.GetInfo(requestStatus, bookPckg); 
        	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());	


	CleanupStack::PopAndDestroy(3, this); // bookStore, data, this
    }


 
 
    
    
void CCTsyPhoneBookStoreFU::AuxDeleteAll1L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 data2;
	CleanupClosePushL(data2);

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	    	    
 	//-------------------------------------------------------------------------
	// TEST A: failure to dispatch request to LTSY
 	//-------------------------------------------------------------------------
    TMockLtsyPhoneBookData0 tsyData(name);           
    tsyData.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data, KErrNotSupported);
	
    bookStore.DeleteAll(requestStatus);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());


	//-------------------------------------------------------------------------
	// TEST B: failure on completion of pending request from LTSY->CTSY
 	//-------------------------------------------------------------------------
    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrGeneral, data2);

    bookStore.DeleteAll(requestStatus);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

 	//-------------------------------------------------------------------------
	// TEST E: Unsolicited completion of RMobilePhoneBookStore::Delete
	// from LTSY.
 	//-------------------------------------------------------------------------

	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrNone, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        
    
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------
	// TEST C: Successful completion request of
	// RMobilePhoneBookStore::Delete
 	//-------------------------------------------------------------------------
    
    // delete when there are no entries
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrNone, data2);

    bookStore.DeleteAll(requestStatus);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    
	// now write something -----------------------
	
	TRequestStatus writeStatus;
	TInt writeIndex(-1); 
	TBuf8<200> writeBuf;	 		 	    	    
    
    CPhoneBookBuffer* pbBuffer = new( ELeave ) CPhoneBookBuffer();
    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set( &writeBuf );    
    TInt ret = pbBuffer->AddNewEntryTag();
    TUint16 location(0);
    ret = pbBuffer->PutTagAndValue( RMobilePhoneBookStore::ETagPBAdnIndex, location );

    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();

    TMockLtsyPhoneBookData2<TInt,CPhoneBookStoreEntry*> tsyData3(name, writeIndex, entryPtr);           
    data.Close();    
    tsyData3.SerialiseL(data);
            
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreWriteIPC, data);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreWriteIPC, KErrNone, data2, 10);

    bookStore.Write(writeStatus, writeBuf, writeIndex);
    
	User::WaitForRequest(writeStatus); 
	ASSERT_EQUALS(KErrNone, writeStatus.Int());	
	//----------------------------------------------------	
	
	// now delete the writen entry
	
    TMockLtsyPhoneBookData0 tsyData4(name);           
    data.Close();    
    tsyData4.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrNone, data2);

    bookStore.DeleteAll(requestStatus);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	
	
	CleanupStack::PopAndDestroy(2); //pbBuffer, entryPtr
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this		
    }
    
    
void CCTsyPhoneBookStoreFU::AuxDeleteAll2L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);

	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	
	TRequestStatus requestStatus;
	    	    
    TMockLtsyPhoneBookData0 tsyData(name);           
    tsyData.SerialiseL(data);
 	
    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);

    bookStore.DeleteAll(requestStatus);
    bookStore.CancelAsyncRequest(EMobilePhoneStoreDeleteAll);

	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrNone, data2, 10);
    
	User::WaitForRequest(requestStatus);	

    // These request can't be cancelled, because no
    // functionality for cancelling. So everything
    // to do, is let the request continue and return KErrNone.
	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	User::WaitForRequest(mockLtsyStatus);	
    
	AssertMockLtsyStatusL();
		
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this		
    }
    
    
void CCTsyPhoneBookStoreFU::AuxDeleteAll4L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);


	RMobilePhoneBookStore bookStore2;
	
	ret = bookStore2.Open(phone2, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
	AssertMockLtsyStatusL();      
    
	CleanupClosePushL(bookStore2);
	
	TRequestStatus requestStatus;
	TRequestStatus requestStatus2;

    TMockLtsyPhoneBookData0 tsyData(name);           
    tsyData.SerialiseL(data);
 	
    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);


	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrNone, data2, 4);

    bookStore.DeleteAll(requestStatus);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreDeleteAllIPC, KErrNone, data2, 4);

    bookStore2.DeleteAll(requestStatus2);
    
	User::WaitForRequest(requestStatus);	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	User::WaitForRequest(requestStatus2);	
	ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    
	AssertMockLtsyStatusL();
	
	CleanupStack::PopAndDestroy(7, this); // data, data2, this...
    }
    
    
void CCTsyPhoneBookStoreFU::AuxDeleteAll5L(const TDesC& aName)
    {
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	RBuf8 data;
	CleanupClosePushL(data);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
	    	    
    TMockLtsyPhoneBookData0 tsyData(name);           
    tsyData.SerialiseL(data);
 	
    TPBEntryInfo pbEntryInfo = {0, 50};
    TMockLtsyPhoneBookData1< TPBEntryInfo > styData2(name, pbEntryInfo);
    styData2.SerialiseL(data2);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreDeleteAllIPC, data);

    bookStore.DeleteAll(requestStatus);
    
	User::WaitForRequest(requestStatus);	

	ASSERT_EQUALS(KErrTimedOut, requestStatus.Int());
    
	AssertMockLtsyStatusL();
		
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(3, this); // data, data2, this
    }
    
    

void CCTsyPhoneBookStoreFU::Aux2ReadL(const TDesC& aName)
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	SetPhonebookNumOfEntriesAndInitPhonebookL( name, 10 );
	
	TRequestStatus requestStatus;
    RMobileONStore::TMobileONEntryV1 info;
    RMobileONStore::TMobileONEntryV1Pckg infoPckg(info);

 	//-------------------------------------------------------------------------
	// check if supported
 	//-------------------------------------------------------------------------

    bookStore.RMobilePhoneStore::Read(requestStatus, infoPckg); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	


    //-------------------------------------------------
    
    // just to shoot one more branch - ReceivedFdnData function
	RBuf8 data;
	CleanupClosePushL(data);
    
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	
	TPBFdnInfo fdnInfo;
	
    TMockLtsyPhoneBookData1<TPBFdnInfo> tsyData(name, fdnInfo);           
    tsyData.SerialiseL(data);

	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreFdnInfoIPC,KErrNone,data,0);    
    
    User::WaitForRequest(mockLtsyStatus);        
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();


	iMockLTSY.NotifyTerminated(mockLtsyStatus);	
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreFdnInfoIPC,KErrGeneral,data,0);        
    User::WaitForRequest(mockLtsyStatus);        
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();
	
	//--------------------------------------------
		

	CleanupStack::PopAndDestroy(1); //data
	CleanupStack::PopAndDestroy(1); //bookStore
	CleanupStack::PopAndDestroy(1, this); // this	
	}


void CCTsyPhoneBookStoreFU::Aux2WriteL(const TDesC& aName)
	{	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhone2L();

	TName name(aName);
	RMobilePhoneBookStore bookStore;
	
    OpenPhoneBookStoreL(bookStore, name, iPhone);
	CleanupClosePushL(bookStore);
	
	TRequestStatus requestStatus;
    RMobileONStore::TMobileONEntryV1 info;
    RMobileONStore::TMobileONEntryV1Pckg infoPckg(info);
    
    CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
    CleanupStack::PushL(entryPtr);
    entryPtr->ConstructL();	
    FillPBEntry(entryPtr);
    CleanupStack::Pop(entryPtr);

 	//-------------------------------------------------------------------------
	// check if supported
 	//-------------------------------------------------------------------------

    bookStore.RMobilePhoneStore::Write(requestStatus, infoPckg); 
	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	


    // just to check one more branch for cache init--------------------------------
	RBuf8 data;
	CleanupClosePushL(data);

    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);
    cache->AppendL(entryPtr);

    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(name, cache);
    storeCacheData.SerialiseL(data);
    
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrGeneral, data, 0);
    
    User::WaitForRequest(mockLtsyStatus);        
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();



    //-for storeInit------------------------------------------
	RBuf8 data2;
	CleanupClosePushL(data2);
	

    CStorageInfoData storageData;       
        
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
	retStoreInitC.SerialiseL(data2);
	
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrGeneral, data2, 0);
    User::WaitForRequest(mockLtsyStatus);        
    
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();
    //----------------------------------------------


	CleanupStack::PopAndDestroy(5, this); // this etc	
	}




/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR3-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for CMmPhoneBookStoreTsy::ContinueReadL()
@SYMTestPriority High
@SYMTestActions Invokes CMmPhoneBookStoreTsy::ContinueReadL()
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test3Read0001L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	
	OpenPhone2L(KErrGeneral);   // here SIM refresh register is OFF
	
	RBuf8 data;
	CleanupClosePushL(data);

	// prepare iMockLTSY.ExpectLs for RMmCustomAPI opening
	iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
	RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
	currentlyRetrievedCache.iCacheId	= 1;
	currentlyRetrievedCache.iRecordId	= 0;		
	TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyDataCustomAPI(currentlyRetrievedCache);
	ltsyDataCustomAPI.SerialiseL(data);			
	iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, data);
		
    RMmCustomAPI customAPI;  
    TInt r = customAPI.Open (iPhone); 
    ASSERT_EQUALS(KErrNone, r);  
    CleanupClosePushL(customAPI);	

	RBuf8 data1;
	CleanupClosePushL(data1);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	RBuf8 completeData;
	CleanupClosePushL(completeData);
	
	RBuf8 completeData2;
	CleanupClosePushL(completeData2);
		
	TName name(KETelIccAdnPhoneBook);
	RMobilePhoneBookStore bookStore;
	
	// open store with some changes for EMmTsyPhoneBookStoreInitIPC
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
            
    //EMmTsyPhoneBookStoreInitIPC
    TMockLtsyPhoneBookData0 storeInitData(name);
    data.Close();
    storeInitData.SerialiseL(data);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);	

    CStorageInfoData storageData;       
    
	SetStorageInfoData(storageData);

    storageData.iADNNumOfEntries = 10;
    storageData.iFDNNumOfEntries = 10;
    storageData.iSDNNumOfEntries = 10;
    storageData.iVMBXNumOfEntries = 10;
    storageData.iMBDNNumOfEntries = 10; 

	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
	retStoreInitC.SerialiseL(data2);

    // make the store not initialised	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrGeneral, data2, 0);


	//EMmTsyPhoneBookStoreCacheIPC
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);
                            
    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(name, cache);
    data.Close();    
    storeCacheData.SerialiseL(data);
    
	//Open
	TInt ret = bookStore.Open(iPhone, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
    CleanupClosePushL(bookStore);
	
    User::WaitForRequest(mockLtsyStatus);        	
	AssertMockLtsyStatusL();	
	
    // end of open store	
	
	TRequestStatus requestStatus;
	TInt index(0);
	TInt numEntries(1);	
	TBuf8<200> buf;	 		 
	    	    
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };

    TMockLtsyPhoneBookData2< RMobilePhoneBookStore::TPBIndexAndNumEntries, 
        CArrayPtrSeg<CPhoneBookStoreEntry>* >  ltsyData1(name, indexAndEntries, cache);
    ltsyData1.SerialiseL(data1);            


    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData(name, cache);
    ArrayData.SerialiseL(completeData);


 	//-------------------------------------------------------------------------
	// test leads to CMmPhoneBookStoreTsy::ContinueReadL() call
 	//-------------------------------------------------------------------------
	
    TMockLtsyPhoneBookData0 storeInitData2(name);
    data.Close();    
    storeInitData2.SerialiseL(data);

	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);

    
    // now read 1entry when there is no data writen
    index = 1;
    indexAndEntries.iIndex = index;
   
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData(name, indexAndEntries);
	data1.Close();    
	ltsyData.SerialiseL(data1);
    
    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData2(name, cache);
    completeData2.Close();    
    ArrayData2.SerialiseL(completeData2);
    completeData.Close();
	storeInitData.SerialiseL(completeData);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, completeData);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrNone, completeData2, 0);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData2, 0);
    
    
	iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);	
    iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrNone, 0);
    
    
	TBuf8<200> buf2;	 		 
    bookStore.Read(requestStatus, index, numEntries, buf2); 

	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	


    TUint8 tagValue;
    CPhoneBookBuffer::TPhBkTagType tagType;
    
    CPhoneBookBuffer bookBuffer;    
    bookBuffer.Set(&buf2);
    bookBuffer.StartRead();

    ret = bookBuffer.GetTagAndType( tagValue, tagType ); 
    ASSERT_EQUALS(KErrNotFound, ret);    

	
	CleanupStack::PopAndDestroy(9, this);		//this, data, customAPI, data1, data2, completeData, completeData2, cache, bookStore 
	
	}


/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR3-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for read without SIM register and caching
@SYMTestPriority High
@SYMTestActions Test support in CTSY for read without SIM register and caching
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test3Read0002L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	
	OpenPhone2L(KErrGeneral);   // here SIM refresh register is OFF

	RBuf8 data;
	CleanupClosePushL(data);

		
	// prepare iMockLTSY.ExpectLs for RMmCustomAPI opening
	iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
	RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
	currentlyRetrievedCache.iCacheId	= 1;
	currentlyRetrievedCache.iRecordId	= 0;		
	TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyDataCustomAPI(currentlyRetrievedCache);
	ltsyDataCustomAPI.SerialiseL(data);			
	iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, data);
		
    RMmCustomAPI customAPI;  
    TInt r = customAPI.Open (iPhone); 
    ASSERT_EQUALS(KErrNone, r);  
    CleanupClosePushL(customAPI);
        
	RBuf8 data1;
	CleanupClosePushL(data1);

	RBuf8 data2;
	CleanupClosePushL(data2);
	
	RBuf8 completeData;
	CleanupClosePushL(completeData);
	
	RBuf8 completeData2;
	CleanupClosePushL(completeData2);
		
	TName name(KETelIccAdnPhoneBook);
	RMobilePhoneBookStore bookStore;
	
	// open store with some changes for EMmTsyPhoneBookStoreInitIPC
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	
	CPhoneBookStoreEntry* entryPtr = new(ELeave) CPhoneBookStoreEntry;
	CleanupStack::PushL(entryPtr);
	entryPtr->ConstructL();	
	FillPBEntry(entryPtr);
	CleanupStack::Pop(entryPtr);
            
    //EMmTsyPhoneBookStoreInitIPC
    TMockLtsyPhoneBookData0 storeInitData(name);
    data.Close();
    storeInitData.SerialiseL(data);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);	

    CStorageInfoData storageData;       
    
	SetStorageInfoData(storageData);
	
    storageData.iADNNumOfEntries = 10;
    storageData.iFDNNumOfEntries = 10;
    storageData.iSDNNumOfEntries = 10;
    storageData.iVMBXNumOfEntries = 10;
    storageData.iMBDNNumOfEntries = 10; 
    
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
	retStoreInitC.SerialiseL(data2);

    // make the store not initialised	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrGeneral, data2, 0);

	//EMmTsyPhoneBookStoreCacheIPC    
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache1 = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
	CleanupStack::PushL(cache1);
    
	//Open
	TInt ret = bookStore.Open(iPhone, name);
	ASSERT_EQUALS(KErrNone, ret);	
	
    CleanupClosePushL(bookStore);
	
    User::WaitForRequest(mockLtsyStatus);        	
	AssertMockLtsyStatusL();	
		
    // end of open store	
	
	TRequestStatus requestStatus;
	TInt index(1);
	TInt numEntries(1);	
	TBuf8<200> buf;	 		 
	    	    
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
    
    cache1->AppendL(entryPtr);
    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData(name, cache1);
    ArrayData.SerialiseL(completeData2);
    completeData.Close();
	storeInitData.SerialiseL(completeData);

    // read without caching and SIM //
    
	RBuf8 data4;
	CleanupClosePushL(data4);
	
	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    TMockLtsyPhoneBookData0 tsyData4(name);
    tsyData4.SerialiseL(data4);
	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreResetCacheIPC, KErrNone, data4, 2);
    User::WaitForRequest(mockLtsyStatus);            
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	
	AssertMockLtsyStatusL();
	
    index = 1;
    numEntries = 1;


    TMockLtsyPhoneBookData0 storeInitData2(name);
    data.Close();
    storeInitData2.SerialiseL(data);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreCacheIPC, completeData);
	iMockLTSY.CompleteL(EMmTsyPhoneBookStoreCacheIPC, KErrNone, completeData2, 0);
	
	TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData(name, indexAndEntries);
	data1.Close();
	ltsyData.SerialiseL(data1);
    
	iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);	
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData2, 0);

    bookStore.Read(requestStatus, index, numEntries, buf); 
    	
	iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);	
    iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);
    	
    User::WaitForRequest(requestStatus);        
	AssertMockLtsyStatusL();	
	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

    ///////////////////////////////////////////////////
	
	CleanupStack::PopAndDestroy(10, this); 		//this, data, customAPI, data1, data2, completeData, completeData2, cache1, bookStore, data4
	
	}

/**
@SYMTestCaseID BA-CTSY-PBSTR-PBSR3-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for SDN entry read without SIM register and caching
@SYMTestPriority High
@SYMTestActions Test support in CTSY for SDN entry read without SIM register and caching
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyPhoneBookStoreFU::Test3Read0003L()
    {
    OpenEtelServerL(EUseExtendedError);
    CleanupStack::PushL(TCleanupItem(Cleanup,this));
    
    OpenPhone2L(KErrGeneral);   // here SIM refresh register is OFF

    RBuf8 data;
    CleanupClosePushL(data);

        
    // prepare iMockLTSY.ExpectLs for RMmCustomAPI opening
    iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);
    RMmCustomAPI::TViagCacheRecordId currentlyRetrievedCache;
    currentlyRetrievedCache.iCacheId    = 1;
    currentlyRetrievedCache.iRecordId   = 0;        
    TMockLtsyData1 <RMmCustomAPI::TViagCacheRecordId> ltsyDataCustomAPI(currentlyRetrievedCache);
    ltsyDataCustomAPI.SerialiseL(data);         
    iMockLTSY.ExpectL(EReadViagHomeZoneCacheIPC, data);
        
    RMmCustomAPI customAPI;  
    TInt r = customAPI.Open (iPhone); 
    ASSERT_EQUALS(KErrNone, r);  
    CleanupClosePushL(customAPI);
        
    RBuf8 data1;
    CleanupClosePushL(data1);

    RBuf8 data2;
    CleanupClosePushL(data2);
    
    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName name(KETelIccSdnPhoneBook);
    RMobilePhoneBookStore bookStore;
    
    // open store with some changes for EMmTsyPhoneBookStoreInitIPC
    TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);

            
    //EMmTsyPhoneBookStoreInitIPC
    TMockLtsyPhoneBookData0 storeInitData(name);
    data.Close();
    storeInitData.SerialiseL(data);
    
    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreInitIPC, data);   

    CStorageInfoData storageData;       
    
    SetStorageInfoData(storageData);
    
    storageData.iADNNumOfEntries = 10;
    storageData.iFDNNumOfEntries = 10;
    storageData.iSDNNumOfEntries = 10;
    storageData.iVMBXNumOfEntries = 10;
    storageData.iMBDNNumOfEntries = 10; 
    
    TMockLtsyPhoneBookData1< CStorageInfoData > retStoreInitC(name, storageData); 
    retStoreInitC.SerialiseL(data2);

    // make the store initialised   
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data2, 0);


    //EMmTsyPhoneBookStoreCacheIPC
    CArrayPtrSeg<CPhoneBookStoreEntry>* cache = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>( 1 );
    CleanupStack::PushL(cache);

    TMockLtsyPhoneBookData1<CArrayPtrSeg<CPhoneBookStoreEntry>*> storeCacheData(name, cache);
    data.Close();    
    storeCacheData.SerialiseL(data);
    
    //Open
    TInt ret = bookStore.Open(iPhone, name);
    ASSERT_EQUALS(KErrNone, ret);   
    
    CleanupClosePushL(bookStore);
    
    User::WaitForRequest(mockLtsyStatus);           
    AssertMockLtsyStatusL();    
        
    // end of open store

    TRequestStatus requestStatus;
    TInt index(1);
    TInt numEntries(1); 
    TBuf8<200> buf;          
                
    RMobilePhoneBookStore::TPBIndexAndNumEntries indexAndEntries = {index, numEntries };
     
    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData1(name, indexAndEntries);
	ltsyData1.SerialiseL(data1);


    TMockLtsyPhoneBookData1< CArrayPtrSeg<CPhoneBookStoreEntry>* > ArrayData(name, cache);
    ArrayData.SerialiseL(completeData);

    index = 1;
    numEntries = 1;

    TMockLtsyPhoneBookData0 storeInitData2(name);
    data.Close();
    storeInitData2.SerialiseL(data);

    TMockLtsyPhoneBookData1< RMobilePhoneBookStore::TPBIndexAndNumEntries>  ltsyData(name, indexAndEntries);
	data1.Close();
	ltsyData.SerialiseL(data1);
    
    iMockLTSY.ExpectL(EMmTsyPhoneBookStoreReadIPC, data1);
    iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);

    bookStore.Read(requestStatus, index, numEntries, buf); 
        
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreReadIPC, KErrNone, completeData, 0);
    iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);
        
    User::WaitForRequest(requestStatus);        
    AssertMockLtsyStatusL();    
    ASSERT_EQUALS(KErrNone, requestStatus.Int());   

    //
    
    CleanupStack::PopAndDestroy(8, this); 
    
    }

void CCTsyPhoneBookStoreFU::SetPhonebookNumOfEntries( CStorageInfoData& aStorageData, TInt aNumOfEntries )
    {
    //bdn num entries set to 0
    aStorageData.iADNNumOfEntries = aNumOfEntries;
    aStorageData.iFDNNumOfEntries = aNumOfEntries;
    aStorageData.iSDNNumOfEntries = aNumOfEntries;
    aStorageData.iVMBXNumOfEntries = aNumOfEntries;
    aStorageData.iMBDNNumOfEntries = aNumOfEntries; 
    }

void CCTsyPhoneBookStoreFU::SetPhonebookNumOfEntriesAndInitPhonebookL( TName aName, TInt aNumOfEntries )
    {
	RBuf8 data;
 	CleanupClosePushL(data);
    
    //storeInit
    CStorageInfoData storageData;       
    //bdn num entries set to 0
    storageData.iADNNumOfEntries = aNumOfEntries;
    storageData.iFDNNumOfEntries = aNumOfEntries;
    storageData.iSDNNumOfEntries = aNumOfEntries;
    storageData.iVMBXNumOfEntries = aNumOfEntries;
    storageData.iMBDNNumOfEntries = aNumOfEntries;     
        
	TMockLtsyPhoneBookData1< CStorageInfoData > retStoreAndName(aName, storageData); 
	data.Close();    
	retStoreAndName.SerialiseL(data);	
	
	TRequestStatus mockLtsyStatus;
	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMmTsyPhoneBookStoreInitIPC, KErrNone, data, 0);
    User::WaitForRequest(mockLtsyStatus);        

    CleanupStack::PopAndDestroy( &data );
    }

void CCTsyPhoneBookStoreFU::FillPBEntry(CPhoneBookStoreEntry* aEntryPtr)
	{
	_LIT(KPBText, "PBText");
	_LIT(KPBNumber, "PBNumber");
	_LIT(KPBEmailAddress, "PBEmailAddress");
	_LIT(KPBSecondName, "PBSecondName");
	
	aEntryPtr->iLocation = 1;
	
	aEntryPtr->iText = HBufC::NewLC( KPBText().Length() );
	*(aEntryPtr->iText) = KPBText();
	CleanupStack::Pop();

	aEntryPtr->iNumber = HBufC::NewLC( KPBNumber().Length() );	
	*(aEntryPtr->iNumber) = KPBNumber();
	CleanupStack::Pop();

	aEntryPtr->iEmail->AppendL( KPBEmailAddress() );

	aEntryPtr->iSne->AppendL( KPBSecondName() );
	}
