// Copyright (c) 2002-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:

//

#include <e32test.h>

#include "te_cntsyncbase.h"

#include "te_cntsyncdelete.h"

_LIT(KDeletedNameInADN, "ADN Delete Test");

_LIT(KDeletedNameInSDN, "SDN Delete Test");

_LIT(KDeletedNameInLND, "LND Delete Test");

_LIT(KDeletedNameInUsim,"Usim Delete Test");

_LIT(KDeletedNameInFDN, "FDN Delete Test");

_LIT(KDeletedNumberInADN, "0202020323909094394");

_LIT(KDeletedNumberInSDN, "1212121323919194394");

_LIT(KDeletedNumberInLND, "2222222323929294394");

_LIT(KDeletedNumberInUsim,"3232323323939394394");

_LIT(KDeletedNumberInFDN, "4242424343949494394");

_LIT(KDeletedEmailInUsim,"example@here");

_LIT(KSearchStringInADN, "AAAAAAAAAAAAAAAAA");

_LIT(KSearchStringInSDN, "BBBBBBBBBBBBBBBBB");

_LIT(KSearchStringInLND, "CCCCCCCCCCCCCCCCC");

_LIT(KSearchStringInUsim,"DDDDDDDDDDDDDDDDD");

_LIT(KSearchStringInFDN, "EEEEEEEEEEEEEEEEE");

_LIT(KSearchNameInADN, "ADN Name");

_LIT(KSearchNameInSDN, "SDN Name");

_LIT(KSearchNameInLND, "LND Name");

_LIT(KSearchNameInUsim,"Usim Name");

_LIT(KSearchNameInFDN, "FDN Name");

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteICCContactTest object

 */

CPhbkDeleteICCContactTest* CPhbkDeleteICCContactTest::NewL()

	{

	CPhbkDeleteICCContactTest* self = new(ELeave) CPhbkDeleteICCContactTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteICCContactTest::CPhbkDeleteICCContactTest()

	{

	SetTestStepName(_L("DeleteICCContactTest"));

	}

/** Delete an ICC entry - normal case */

enum TVerdict CPhbkDeleteICCContactTest::doTestStepL()

	{

	SetSimTsyTestNumberL(0);

	DoSyncL();

	DeleteContactL(KUidIccGlobalAdnPhonebook);

	DeleteContactL(KUidIccGlobalSdnPhonebook);

	DeleteContactL(KUidIccGlobalLndPhonebook);

	DeleteContactL(KUidUsimAppAdnPhonebook);

	DeleteContactL(KUidIccGlobalFdnPhonebook);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteEntryInvalidUIDTest object

 */

CPhbkDeleteEntryInvalidUIDTest* CPhbkDeleteEntryInvalidUIDTest::NewL()

	{

	CPhbkDeleteEntryInvalidUIDTest* self = new(ELeave) CPhbkDeleteEntryInvalidUIDTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteEntryInvalidUIDTest::CPhbkDeleteEntryInvalidUIDTest()

	{

	SetTestStepName(_L("DeleteEntryInvalidUIDTest"));

	}

/** Delete an ICC entry - invalid UID */

enum TVerdict CPhbkDeleteEntryInvalidUIDTest::doTestStepL()

	{

	TContactItemId id(1500); // Exceeded max number on ICC

	TRAPD(err, iDb->DeleteContactL(id));

	TESTCHECKL(err, KErrNotFound);

	id = -2; // Negative UID

	TRAP(err, iDb->DeleteContactL(id));

	TESTCHECKL(err, KErrNotFound);

	id = 6789; // Out-of-range UID

	TRAP(err, iDb->DeleteContactL(id));

	TESTCHECKL(err, KErrNotFound);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteAllEntriesTest object

 */

CPhbkDeleteAllEntriesTest* CPhbkDeleteAllEntriesTest::NewL()

	{

	CPhbkDeleteAllEntriesTest* self = new(ELeave) CPhbkDeleteAllEntriesTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteAllEntriesTest::CPhbkDeleteAllEntriesTest()

	{

	SetTestStepName(_L("DeleteAllEntriesTest"));

	}

/** Delete all ICC entries one at a time */

enum TVerdict CPhbkDeleteAllEntriesTest::doTestStepL()

	{

	SetSimTsyTestNumberL(0);

	DoSyncL();

	iDb->SetDbViewContactType(KUidContactICCEntry);

	const CContactIdArray* sortedItems = iDb->SortedItemsL();

	TContactItemId id(KNullContactId);

	TInt count = sortedItems->Count();

	TInt err(KErrNone);

	for(TInt i=0; i<=count-1;i++)

		{

		id = (*sortedItems)[0];

		iDb->DeleteContactL(id);

		CContactItem* item=NULL; //check the item has been removed from the database

		TRAP(err, item = iDb->ReadContactL(id));

		TESTCHECKL(err, KErrNotFound);

		delete item;

		}

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteEntryICCLockedTest object

 */

CPhbkDeleteEntryICCLockedTest* CPhbkDeleteEntryICCLockedTest::NewL()

	{

	CPhbkDeleteEntryICCLockedTest* self = new(ELeave) CPhbkDeleteEntryICCLockedTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteEntryICCLockedTest::CPhbkDeleteEntryICCLockedTest()

	{

	SetTestStepName(_L("DeleteEntryICCLockedTest"));

	}

/** Delete an ICC entry - ICC locked */

enum TVerdict CPhbkDeleteEntryICCLockedTest::doTestStepL()

	{

	SetSimTsyTestNumberL(2);

	DoSyncL();

	// Access ICC and wait for it to be locked

	iDb->SetDbViewContactType(KUidContactICCEntry);

	const CContactIdArray* sortedItems = iDb->SortedItemsL();

	TContactItemId id = (*sortedItems)[0];

	TInt err(KErrNone);

	while(err==KErrNone) // Wait for ICC to become locked 

		{

		User::After(1000000);	// Wait a second and try again.

		CContactICCEntry* failEntry=NULL;

		TRAP(err, failEntry = (CContactICCEntry*)iDb->ReadContactL(id, *iDb->AllFieldsView())); // Entry unavailable due to ICC being locked

		delete failEntry;

		}

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidIccGlobalAdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidIccGlobalSdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidIccGlobalLndPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidUsimAppAdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidIccGlobalFdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteEntryICCDeleteFailsTest object

 */

CPhbkDeleteEntryICCDeleteFailsTest* CPhbkDeleteEntryICCDeleteFailsTest::NewL()

	{

	CPhbkDeleteEntryICCDeleteFailsTest* self = new(ELeave) CPhbkDeleteEntryICCDeleteFailsTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteEntryICCDeleteFailsTest::CPhbkDeleteEntryICCDeleteFailsTest()

	{

	SetTestStepName(_L("DeleteEntryICCDeleteFailsTest"));

	}

/** Delete an ICC entry - ICC delete fails */

enum TVerdict CPhbkDeleteEntryICCDeleteFailsTest::doTestStepL()

	{

	SetSimTsyTestNumberL(4);

	DoSyncL();

	TRAPD(err, DeleteContactL(KUidIccGlobalAdnPhonebook));

	TESTCHECKL(err, KErrBadHandle);

	TRAP(err, DeleteContactL(KUidIccGlobalSdnPhonebook));

	TESTCHECKL(err, KErrBadHandle);

	TRAP(err, DeleteContactL(KUidIccGlobalLndPhonebook));

	TESTCHECKL(err, KErrBadHandle);

	TRAP(err, DeleteContactL(KUidUsimAppAdnPhonebook));

	TESTCHECKL(err, KErrBadHandle);

	TRAP(err, DeleteContactL(KUidIccGlobalFdnPhonebook));

	TESTCHECKL(err, KErrBadHandle);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteEntryReadOnlyAccessTest object

 */

CPhbkDeleteEntryReadOnlyAccessTest* CPhbkDeleteEntryReadOnlyAccessTest::NewL()

	{

	CPhbkDeleteEntryReadOnlyAccessTest* self = new(ELeave) CPhbkDeleteEntryReadOnlyAccessTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteEntryReadOnlyAccessTest::CPhbkDeleteEntryReadOnlyAccessTest()

	{

	SetTestStepName(_L("DeleteEntryReadOnlyAccessTest"));

	}

/** Delete an ICC entry - read-only phonebook */

enum TVerdict CPhbkDeleteEntryReadOnlyAccessTest::doTestStepL()

	{

	SetSimTsyTestNumberL(12);

	DoSyncL();

	TRAPD(err, DeleteContactL(KUidIccGlobalAdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidIccGlobalSdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidIccGlobalLndPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidUsimAppAdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	TRAP(err, DeleteContactL(KUidIccGlobalFdnPhonebook));

	TESTCHECKL(err, KErrAccessDenied);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteArrayOneEntryTest object

 */

CPhbkDeleteArrayOneEntryTest* CPhbkDeleteArrayOneEntryTest::NewL()

	{

	CPhbkDeleteArrayOneEntryTest* self = new(ELeave) CPhbkDeleteArrayOneEntryTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteArrayOneEntryTest::CPhbkDeleteArrayOneEntryTest()

	{

	SetTestStepName(_L("DeleteArrayOneEntryTest"));

	}

/** Delete an array of ICC entries - one entry in the array */

enum TVerdict CPhbkDeleteArrayOneEntryTest::doTestStepL()

	{

	SetSimTsyTestNumberL(10);

	DoSyncL();

	// *

	// * MJH  - 12 Sept 2002

	// * Assumptions for test data:

	// * 

	// * Each phonebook must use a unique number format in order that the array 

	// * of entries to be deleted only contains a single entry.

	// * 

	DeleteArrayWithOneEntryL(KDeletedNumberInADN, KDeletedNameInADN, KUidIccGlobalAdnPhonebook);

	DeleteArrayWithOneEntryL(KDeletedNumberInSDN, KDeletedNameInSDN, KUidIccGlobalSdnPhonebook);

	DeleteArrayWithOneEntryL(KDeletedNumberInLND, KDeletedNameInLND, KUidIccGlobalLndPhonebook);

	DeleteArrayWithOneEntryL(KDeletedNumberInUsim, KDeletedNameInUsim, KUidUsimAppAdnPhonebook, KDeletedEmailInUsim);

	DeleteArrayWithOneEntryL(KDeletedNumberInFDN, KDeletedNameInFDN, KUidIccGlobalFdnPhonebook);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteArrayInvalidIdTest object

 */

CPhbkDeleteArrayInvalidIdTest* CPhbkDeleteArrayInvalidIdTest::NewL()

	{

	CPhbkDeleteArrayInvalidIdTest* self = new(ELeave) CPhbkDeleteArrayInvalidIdTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteArrayInvalidIdTest::CPhbkDeleteArrayInvalidIdTest()

	{

	SetTestStepName(_L("DeleteArrayInvalidIdTest"));

	}

/** Delete an array of ICC entries - invalid ID added to the array */

enum TVerdict CPhbkDeleteArrayInvalidIdTest::doTestStepL()

	{

	SetSimTsyTestNumberL(10);

	DoSyncL();

	// *

	// * MJH  - 12 Sept 2002

	// * Assumptions for test data:

	// * 

	// * Each phonebook must use a unique number format in order that the array 

	// * of entries to be deleted only relates to that phonebook.

	// *

	DeleteArrayWithInvalidIdL(KDeletedNumberInADN);

	DeleteArrayWithInvalidIdL(KDeletedNumberInSDN);

	DeleteArrayWithInvalidIdL(KDeletedNumberInLND);

	DeleteArrayWithInvalidIdL(KDeletedNumberInUsim);

	DeleteArrayWithInvalidIdL(KDeletedNumberInFDN);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteArrayMultipleEntriesTest object

 */

CPhbkDeleteArrayMultipleEntriesTest* CPhbkDeleteArrayMultipleEntriesTest::NewL()

	{

	CPhbkDeleteArrayMultipleEntriesTest* self = new(ELeave) CPhbkDeleteArrayMultipleEntriesTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteArrayMultipleEntriesTest::CPhbkDeleteArrayMultipleEntriesTest()

	{

	SetTestStepName(_L("DeleteArrayMultipleEntriesTest"));

	}

/** Delete an array of ICC entries - multiple entries in the array */

enum TVerdict CPhbkDeleteArrayMultipleEntriesTest::doTestStepL()

	{

	SetSimTsyTestNumberL(10);

	DoSyncL();

	// *

	// * MJH  - 12 Sept 2002

	// * Assumptions for test data:

	// * 

	// * Each phonebook must use a unique format of name for its entries in order 

	// * that the array of entries to be deleted only relates to that phonebook.

	// * 

	DeleteArrayWithMultEntryL(KDeletedNumberInADN, KSearchStringInADN, KUidIccGlobalAdnPhonebook);

	DeleteArrayWithMultEntryL(KDeletedNumberInSDN, KSearchStringInSDN, KUidIccGlobalSdnPhonebook);

	DeleteArrayWithMultEntryL(KDeletedNumberInLND, KSearchStringInLND, KUidIccGlobalLndPhonebook);

	DeleteArrayWithMultEntryL(KDeletedNumberInUsim, KSearchStringInUsim, KUidUsimAppAdnPhonebook, KDeletedEmailInUsim);

	DeleteArrayWithMultEntryL(KDeletedNumberInFDN, KSearchStringInFDN, KUidIccGlobalFdnPhonebook);

	return TestStepResult();

	}

/** Delete and then Add Multiple entries */

void CPhbkDeleteIntegrationTestBase::DeleteArrayWithMultEntryL(const TDesC& aNumber, const TDesC& aName, const TUid aPhoneBook, const TDesC& aEmail)

	{

	CContactItemFieldDef* def=new(ELeave) CContactItemFieldDef();

	CleanupStack::PushL(def);

	def->AppendL(KUidContactFieldFamilyName);

	CContactIdArray* array=iDb->FindLC(aName,def);

	TInt count(array->Count());

	TESTCHECKCONDITIONL(count != 0); // make sure there is at least one entry in array

	TRAPD(err, iDb->DeleteContactsL(*array));

	TESTCHECKL(err, KErrNone);

	// Now add same number of entries to Contacts DB

	CPhbkIntegrationTestUtility* add = CPhbkIntegrationTestUtility::NewL();

	CleanupStack::PushL(add);

	for(TInt i=0; i<count; i++)

		add->AddContactL(aName, aNumber, aPhoneBook, aEmail); // now write new entry

	CleanupStack::PopAndDestroy(3,def); //  array & def & add?

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteArrayICCLockedTest object

 */

CPhbkDeleteArrayICCLockedTest* CPhbkDeleteArrayICCLockedTest::NewL()

	{

	CPhbkDeleteArrayICCLockedTest* self = new(ELeave) CPhbkDeleteArrayICCLockedTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteArrayICCLockedTest::CPhbkDeleteArrayICCLockedTest()

	{

	SetTestStepName(_L("DeleteArrayICCLockedTest"));

	}

/** Delete an array of ICC entries - ICC locked */

enum TVerdict CPhbkDeleteArrayICCLockedTest::doTestStepL()

	{

	SetSimTsyTestNumberL(2);

	DoSyncL();

	// *

	// * MJH  - 12 Sept 2002

	// * Assumptions for test data:

	// * 

	// * Each phonebook must use a unique format of name for its entries in order 

	// * that the array of entries to be deleted only relates to that phonebook.

	// *

	// * The value of KTest2ICCSlots defines the total number of entries

	// * for ALL phonebooks.

	// *

	// Access ICC and wait for it to become locked

	iDb->SetDbViewContactType(KUidContactICCEntry);

	const CContactIdArray* sortedItems = iDb->SortedItemsL();

	TInt count(sortedItems->Count());

	TESTCHECKL(count, KTest2ICCSlots);

	TContactItemId id = (*sortedItems)[0];

	TInt err(KErrNone);

	while(err==KErrNone) // Wait for ICC to become locked 

		{

		User::After(1000000);	// Wait a second and try again.

		CContactICCEntry* failEntry=NULL;

		TRAP(err, failEntry = (CContactICCEntry*)iDb->ReadContactL(id, *iDb->AllFieldsView())); // Entry unavailable due to ICC being locked

		delete failEntry;

		}

	TESTCHECKCONDITIONL(err == KErrAccessDenied  ||  err == KErrNotReady);

	DeleteArrayWithICCLockedL(KSearchStringInADN, KErrAccessDenied);

	DeleteArrayWithICCLockedL(KSearchStringInSDN, KErrAccessDenied);

	DeleteArrayWithICCLockedL(KSearchStringInLND, KErrAccessDenied);

	DeleteArrayWithICCLockedL(KSearchStringInUsim, KErrAccessDenied);

	DeleteArrayWithICCLockedL(KSearchStringInFDN, KErrAccessDenied);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkDeleteArrayReadOnlyAccessTest object

 */

CPhbkDeleteArrayReadOnlyAccessTest* CPhbkDeleteArrayReadOnlyAccessTest::NewL()

	{

	CPhbkDeleteArrayReadOnlyAccessTest* self = new(ELeave) CPhbkDeleteArrayReadOnlyAccessTest();

	return self;

	}

/**

 *  Default constructor.  Each test step initialises it's own name.

 */

CPhbkDeleteArrayReadOnlyAccessTest::CPhbkDeleteArrayReadOnlyAccessTest()