// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

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

*/

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <test/tmockltsydata.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/ltsy/mltsydispatchphonebookinterface.h>

#include "listretrieverao.h"

#include "config.h"

#include "cctsyphonebookfunegative.h"

// Taken from cctsyphonebookfu.cpp

const TInt KReadBufLength = 400;

const TInt KMaxTextLength = 50;

//const TInt KNewMaxTextLength = 55;

const TInt KMaxNumberLength = 25;

const TInt KNumberOfEnries = 100;

void CCTsyPhonebookFUNegative::CreatePhonebookStoreDataL()

	{

	iPhonebookStoreData.iAdnTotalEntries 			= 4;

	iPhonebookStoreData.iAdnMaximumNumberLength 	= KMaxNumberLength;

	iPhonebookStoreData.iAdnMaximumTextLength 		= KMaxTextLength;

	iPhonebookStoreData.iFdnTotalEntries 			= 4;

	iPhonebookStoreData.iFdnMaximumNumberLength 	= KMaxNumberLength;

	iPhonebookStoreData.iFdnMaximumTextLength 		= KMaxTextLength;

	iPhonebookStoreData.iSdnTotalEntries			= KNumberOfEnries;

	iPhonebookStoreData.iSdnMaximumTextLength		= KMaxTextLength;

	iPhonebookStoreData.iSdnMaximumNumberLength		= KMaxNumberLength;

	iPhonebookStoreData.iVmbTotalEntries			= KNumberOfEnries;

	iPhonebookStoreData.iVmbMaximumTextLength		= KMaxTextLength;

	iPhonebookStoreData.iVmbMaximumNumberLength		= KMaxNumberLength;

	iPhonebookStoreData.iVmbCapabilities			= 0;

	iPhonebookStoreData.iMbdnTotalEntries			= KNumberOfEnries;

	iPhonebookStoreData.iMbdnMaximumTextLength		= KMaxTextLength;

	iPhonebookStoreData.iMbdnMaximumNumberLength	= KMaxNumberLength;

	iPhonebookStoreData.iMbdnCapabilities			= 0;

	iPhonebookStoreData.iEmailMaximumFieldsPerEntry				= 101;

	iPhonebookStoreData.iEmailMaximumLength						= KMaxTextLength;

	iPhonebookStoreData.iAdditionalNumberMaximumFieldsPerEntry	= 102;

	iPhonebookStoreData.iAdditionalNumberMaximumLength			= KMaxNumberLength;

	iPhonebookStoreData.iSecondNameMaximumFieldsPerEntry		= 103;

	iPhonebookStoreData.iSecondNameMaximumLength				= KMaxTextLength;

	}

void CCTsyPhonebookFUNegative::OpenSmsStoreL(RMobileSmsMessaging& aSmsMessaging, RMobileSmsStore& aSmsStore, const TDesC& aSmsStoreName)

	{

	iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId);	

	User::LeaveIfError(aSmsMessaging.Open(iPhone));

	User::LeaveIfError(aSmsStore.Open(aSmsMessaging, aSmsStoreName));

	RBuf8 data;

	CleanupClosePushL(data);

	TInt totalEntries = 0;

	TInt usedEntries = 0;

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

	data.Close();

	smsStoreGetInfoLtsyData.SerialiseL(data);

	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrGeneral, data);

	WaitForMockLTSYTerminated();

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(&data);

	}

CTestSuite* CCTsyPhonebookFUNegative::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

  	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0004L);	

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0012L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0013L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0014L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPhonebookFUNegative, TestUnit0015L);

	END_SUITE;

	}

//

// 'Negative' unit tests

//

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0001

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMmTsyPhoneBookStoreReadIPC is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhoneBookStore::Read()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0001L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookStoreReadEntry::KLtsyDispatchPhonebookStoreReadEntryApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobilePhoneBookStore phonebookStore;

	CleanupClosePushL(phonebookStore);

	//initialise IPC generated from phonebook store open

	iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId);

	TName phonebook(KETelIccBdnPhoneBook); //(Bdn - noncaching)

	ASSERT_EQUALS(phonebookStore.Open(iPhone, phonebook), KErrNone);

    AssertMockLtsyStatusL();

    RBuf8 data;

    CleanupClosePushL(data);

    //complete initialise IPC

    TMockLtsyData1<DispatcherPhonebook::TPhonebookStoreInfoV1> phonebookCompLtsyData(iPhonebookStoreData);

    phonebookCompLtsyData.SerialiseL(data);

    iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,KErrNone,data);

    data.Close();

    //fire up the initialise complete

    WaitForMockLTSYTerminated();

	TRequestStatus requestStatus;

	TBuf8<KReadBufLength> phonebookReadData;

	phonebookStore.Read(requestStatus, 1, 1, phonebookReadData);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);

	AssertMockLtsyStatusL();

	config.Reset();

	CleanupStack::PopAndDestroy(3, this); // data, phonebookStore, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0002

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMmTsyPhoneBookStoreDeleteIPC is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhoneBookStore::Delete()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0002L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookStoreDeleteEntry::KLtsyDispatchPhonebookStoreDeleteEntryApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobilePhoneBookStore phonebookStore;

	CleanupClosePushL(phonebookStore);

    //initialise IPC generated from phonebook store open

    iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId);

	TName phonebook(KETelIccBdnPhoneBook); //(Bdn - noncaching)

	ASSERT_EQUALS(phonebookStore.Open(iPhone, phonebook), KErrNone);

    RBuf8 data;

    CleanupClosePushL(data);

    //complete initialise IPC

    TMockLtsyData1<DispatcherPhonebook::TPhonebookStoreInfoV1> phonebookCompLtsyData(iPhonebookStoreData);

    phonebookCompLtsyData.SerialiseL(data);

    iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,KErrNone,data);

    data.Close();

    //fire up the initialise complete

    WaitForMockLTSYTerminated();

	TRequestStatus requestStatus;

	TInt indexToDelete = 0;

	phonebookStore.Delete(requestStatus, indexToDelete);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);

	AssertMockLtsyStatusL();

	config.Reset();

	CleanupStack::PopAndDestroy(3, this); // data, phonebookStore, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0003

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMmTsyPhoneBookStoreCacheIPC is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhoneBookStore::Open()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0003L() 

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookStoreCache::KLtsyDispatchPhonebookStoreCacheApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	CreatePhonebookStoreDataL();

	RMobilePhoneBookStore phonebookStore;

	CleanupClosePushL(phonebookStore);

	TName phonebook(KETelIccFdnPhoneBook);

	//initialise IPC generated from phonebook store open

	iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId);

	ASSERT_EQUALS(phonebookStore.Open(iPhone, phonebook),KErrNone); 

	AssertMockLtsyStatusL();

    config.Reset();

	CleanupStack::PopAndDestroy(2, this); // phonebookStore, this	

	}	

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0004

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMmTsyPhoneBookStoreGetInfoIPC is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhoneBookStore::GetInfo()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0004L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookStoreGetPhonebookInfo::KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobilePhoneBookStore phonebookStore;

	CleanupClosePushL(phonebookStore);

    //initialise IPC generated from phonebook store open

    iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId);

	TName phonebook(KETelIccSdnPhoneBook); //(Sdn - noncaching)

	ASSERT_EQUALS(phonebookStore.Open(iPhone, phonebook), KErrNone);

	AssertMockLtsyStatusL();

    RBuf8 data;

    CleanupClosePushL(data);

    //complete initialise IPC

    TMockLtsyData1<DispatcherPhonebook::TPhonebookStoreInfoV1> phonebookCompLtsyData(iPhonebookStoreData);

    phonebookCompLtsyData.SerialiseL(data);

    iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,KErrNone,data);

    data.Close();

    //fire up the initialise complete

    WaitForMockLTSYTerminated();

	RMmCustomAPI customApi;

	OpenCustomApiLC(customApi);

	TRequestStatus cacheRequestStatus;

	RMmCustomAPI::TPndCacheStatus cacheStatus;

	customApi.GetPndCacheStatus(cacheRequestStatus, cacheStatus, phonebook);

	User::WaitForRequest(cacheRequestStatus);

	TRequestStatus requestStatus;

	RMobilePhoneBookStore::TMobilePhoneBookInfoV1 bookInfo;

	RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg bookPckg(bookInfo);

	phonebookStore.GetInfo(requestStatus, bookPckg);

	User::WaitForRequest(requestStatus); 

	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);

	AssertMockLtsyStatusL();

	config.Reset();

	CleanupStack::PopAndDestroy(4, this); // customApi, data, phonebookStore, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0005

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMmTsyPhoneBookStoreInitIPC is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhoneBookStore::Open()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0005L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobilePhoneBookStore phonebookStore;

	CleanupClosePushL(phonebookStore);

	TName phonebook(KETelIccAdnPhoneBook); //(Adn - caching, init required)

	// in CMmPhoneBookStoreTsy::ConstructL( TName aName )

	// iMmPhoneBookStoreExtInterface->InitPhonebook(

	// EMmTsyPhoneBookStoreInitIPC, iPhoneBookName );

	// return code never checked, tests fails

	TInt err = phonebookStore.Open(iPhone, phonebook); // still returns KErrNone

	ASSERT_EQUALS(err, KErrNone);

	AssertMockLtsyStatusL();

	config.Reset();

	CleanupStack::PopAndDestroy(2, this); // phonebookStore, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0006

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMmTsyPhoneBookStoreDeleteAllIPC is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhoneBookStore::DeleteAll()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0006L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookStoreDeleteAll::KLtsyDispatchPhonebookStoreDeleteAllApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobilePhoneBookStore phonebookStore;

	CleanupClosePushL(phonebookStore);

	//initialise IPC generated from phonebook store open

    iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId);

	TName phonebook(KETelIccBdnPhoneBook); //(Bdn - noncaching)

	ASSERT_EQUALS(phonebookStore.Open(iPhone, phonebook),KErrNone);

    RBuf8 data;

    CleanupClosePushL(data);

    //complete initialise IPC

    TMockLtsyData1<DispatcherPhonebook::TPhonebookStoreInfoV1> phonebookCompLtsyData(iPhonebookStoreData);

    phonebookCompLtsyData.SerialiseL(data);

    iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,KErrNone,data);

    data.Close();

    //fire up the initialise complete

    WaitForMockLTSYTerminated();

	TRequestStatus requestStatus;

	phonebookStore.DeleteAll(requestStatus);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);	

	AssertMockLtsyStatusL();

	config.Reset();

	CleanupStack::PopAndDestroy(3, this); // data, phonebookStore, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0007

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMobilePhoneStoreReadAllPhase1 is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes CRetrieveMobilePhoneSmsList::Start()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0007L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobileSmsMessaging messaging;

	CleanupClosePushL(messaging);

	RMobileSmsStore smsStore;

	CleanupClosePushL(smsStore);

	OpenSmsStoreL(messaging, smsStore, KETelIccSmsStore);

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus mockLtsyStatus;

	TInt totalEntries = 1;

	TInt usedEntries = 0;

	TMockLtsyData2<TInt, TInt> dataGetInfo(totalEntries, usedEntries);

	data.Close();

	dataGetInfo.SerialiseL(data);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId, KErrNone, data);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());	

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

	getSmsListAO->TestRetrieveL();

    ASSERT_EQUALS(KErrNotSupported, getSmsListAO->RetrieveLastError());

	AssertMockLtsyStatusL();

	config.Reset();

	CleanupStack::PopAndDestroy(5, this); // getSmsListAO, data, messaging, smsStore, this	

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0004

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMmTsyPhoneBookStoreWriteIPC is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhoneBookStore::Write()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/

void CCTsyPhonebookFUNegative::TestUnit0008L()

	{

	TConfig config;

	config.SetSupportedValue(MLtsyDispatchPhonebookStoreWriteEntry::KLtsyDispatchPhonebookStoreWriteEntryApiId, EFalse);

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RMobilePhoneBookStore phonebookStore;

	CleanupClosePushL(phonebookStore);

	//initialise IPC generated from phonebook store open

    iMockLTSY.ExpectL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId);

	TName phonebook(KETelIccBdnPhoneBook); //(Bdn - noncaching)

	ASSERT_EQUALS(phonebookStore.Open(iPhone, phonebook), KErrNone);

    RBuf8 data;

    CleanupClosePushL(data);

    //complete initialise IPC

    TMockLtsyData1<DispatcherPhonebook::TPhonebookStoreInfoV1> phonebookCompLtsyData(iPhonebookStoreData);

    phonebookCompLtsyData.SerialiseL(data);

    iMockLTSY.CompleteL(MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,KErrNone,data);

    data.Close();

    //fire up the initialise complete

    WaitForMockLTSYTerminated();

	TRequestStatus requestStatus;

	TInt index(-1); 

	TBuf8<200> buf;	

    TUint16 location = 0;

    CPhoneBookBuffer* pbBuffer = new(ELeave) CPhoneBookBuffer();

    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set(&buf);    

    TInt ret = pbBuffer->AddNewEntryTag();

    ret = pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBAdnIndex, location);

	phonebookStore.Write(requestStatus, buf, index);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(requestStatus.Int(), KErrNotSupported);	

	AssertMockLtsyStatusL();

	config.Reset();

	CleanupStack::PopAndDestroy(4, this); // pbBuffer, data, phonebookStore, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-PHONEBOOK-NEGATIVE-UN0009

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test returned value if EMobilePhoneGetPhoneStoreInfo is not supported by LTSY

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::GetPhoneStoreInfo()

@SYMTestExpectedResults Pass

@SYMTestType UT

*/