// 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_cntsyncsync.h"

_LIT(KSatNameInADN, "SATNotify Entry ADN");

_LIT(KSatNameInSDN, "SATNotify Entry SDN");

_LIT(KSatNameInLND, "SATNotify Entry LND");

_LIT(KSatNameInUsim, "SATNotify Entry Usim");

_LIT(KSatNameInFDN, "SATNotify Entry FDN");

/** 

 * Factory construction method.

 * @return Pointer to CPhbkSyncAutomaticSameICCTest object

 */

CPhbkSyncAutomaticSameICCTest* CPhbkSyncAutomaticSameICCTest::NewL()

	{

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

	return self;

	}

/**

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

 */

CPhbkSyncAutomaticSameICCTest::CPhbkSyncAutomaticSameICCTest()

	{

	SetTestStepName(_L("SyncAutomaticSameICCTest"));

	}

/** 

 * If we are unsynchronised and we set the mode to automatic same ICC, we wait until

 * the next client to connect before synchronising. 

 */

enum TVerdict CPhbkSyncAutomaticSameICCTest::doTestStepL()

	{

	SetSimTsyTestNumberL(1);

	DoSyncL(); // First do initial synchronisation

	// Set sync mode to Automatic Same ICC for all phonebooks

	SetSyncModeL(RPhoneBookSession::EAutoSameIcc);

	// Check sync mode is set to Automatic Same ICC for all phonebooks

	CheckSyncModeL(RPhoneBookSession::EAutoSameIcc);

 	delete iDb;

 	iDb=NULL;

	iSession.Close();

	ConfigurePhbkSyncToIdleL();

	ConfigurePhbkSyncToFullL();

	iDb = OpenOrCreateContactDatabaseL();

	User::LeaveIfError(iSession.Connect()); // Re-connect again 

	User::After(3000000); // 3 seconds to ensure server has chance to fully startup

	// Check sync mode is still set to Automatic Same ICC for all phonebooks

	CheckSyncModeL(RPhoneBookSession::EAutoSameIcc);

	// Wait until cache becomes usable

	WaitForSyncToCompleteL();

	// Verify cache is valid for all phonebooks

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	SetSimTsyTestNumberL(0); // This configuration has different IMSI number to previous one, so

							 // this means that Auto Sync should NOT be started

	CContactDatabase* db = NULL; // Start an instance of contacts model and do some 

								 // operation to force a sync

	TRAPD(err, db = OpenOrCreateContactDatabaseL());

	TESTCHECKL(err, KErrNone);

	TRAP(err, db->ICCTemplateIdL()); // Connects to the server

	TESTCHECKL(err, KErrNone); // template ID can be retrieved

	delete db;

	// Verify cache is not valid for all phonebooks

	CheckCacheStateL(RPhoneBookSession::EUnsynchronised);

	User::After(5000000); // Wait 5s and then check that cache state has not changed

	CheckCacheStateL(RPhoneBookSession::EUnsynchronised);

	SetSimTsyTestNumberL(1); // Going back to last configuration with same IMSI number as previous

							 // one, so this means that Auto Sync should be started as soon as we 

							 // connect to the server

	// Wait until cache becomes usable

	WaitForSyncToCompleteL();

	// Verify cache is valid for all phonebooks

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkSyncAutomaticCurrentICCTest object

 */

CPhbkSyncAutomaticCurrentICCTest* CPhbkSyncAutomaticCurrentICCTest::NewL()

	{

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

	return self;

	}

/**

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

 */

CPhbkSyncAutomaticCurrentICCTest::CPhbkSyncAutomaticCurrentICCTest()

	{

	SetTestStepName(_L("SyncAutomaticCurrentICCTest"));

	}

/** 

 * If we are unsynchronised and we set the mode to automatic current, we wait until

 * the next client to connect before synchronising.

 */

enum TVerdict CPhbkSyncAutomaticCurrentICCTest::doTestStepL()

	{

	// Set sync mode to Automatic Same ICC for all phonebooks

	SetSyncModeL(RPhoneBookSession::EAutoCurrentIcc);

	CheckSyncModeL(RPhoneBookSession::EAutoCurrentIcc);

	delete iDb;

 	iDb=NULL;

	iSession.Close();

	ConfigurePhbkSyncToIdleL();

	ConfigurePhbkSyncToFullL();

	iDb = OpenOrCreateContactDatabaseL();

	User::LeaveIfError(iSession.Connect()); // Re-connect again 

	User::After(5000000); // 5 seconds to ensure server has chance to start up

	CheckSyncModeL(RPhoneBookSession::EAutoCurrentIcc); // Check sync mode is still Automatic 

	WaitForSyncToCompleteL();

	// Verify cache is valid

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	// Start an instance of contacts model and do some operation to force a sync

	CContactDatabase* db = NULL;

	TRAPD(err, db = OpenOrCreateContactDatabaseL());

	TESTCHECKL(err, KErrNone);

	TContactItemId templateId(0);					  

	TRAP(err, templateId = db->ICCTemplateIdL()); // Connects to the server

	TESTCHECKCONDITIONL(templateId != KNullContactId);

	delete db;

	// Wait until cache becomes usable

	WaitForSyncToCompleteL();

	// Verify cache is valid for all phonebooks

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkSyncManualTest object

 */

CPhbkSyncManualTest* CPhbkSyncManualTest::NewL()

	{

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

	return self;

	}

/**

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

 */

CPhbkSyncManualTest::CPhbkSyncManualTest()

	{

	SetTestStepName(_L("SyncManualTest"));

	}

/** Re-Synchronisation (Manual) */

enum TVerdict CPhbkSyncManualTest::doTestStepL()

	{

	DoSyncL();

	WaitForSyncToCompleteL();

	RPhoneBookSession::TSyncState state; // First check that initial Synchronisation was successful 

	iSession.GetPhoneBookCacheState(state); 

	TESTCHECKL(state, RPhoneBookSession::ECacheValid);

	// Set mode to Manual

	SetSyncModeL(RPhoneBookSession::EManual);

	CheckSyncModeL(RPhoneBookSession::EManual);

	DoSyncL();

	// Wait until cache becomes usable

	WaitForSyncToCompleteL();

	// Verify cache is valid for all phonebooks

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkSyncManualNotReadyTest object

 */

CPhbkSyncManualNotReadyTest* CPhbkSyncManualNotReadyTest::NewL()

	{

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

	return self;

	}

/**

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

 */

CPhbkSyncManualNotReadyTest::CPhbkSyncManualNotReadyTest()

	{

	SetTestStepName(_L("SyncManualNotReadyTest"));

	}

/** Try to open a new session and attempt a manual sync before the device has time to 

    get the SubscriberId. The Server should wait untill the SubscriberID is known before continuing */

enum TVerdict CPhbkSyncManualNotReadyTest::doTestStepL()

	{

	delete iDb;

 	iDb=NULL;

	iSession.Close();

	ConfigurePhbkSyncToIdleL();

	ConfigurePhbkSyncToFullL();

	iDb = OpenOrCreateContactDatabaseL();

	User::LeaveIfError(iSession.Connect()); // Re-connect again 

	// Set mode to Manual

	SetSyncModeL(RPhoneBookSession::EManual);

	CheckSyncModeL(RPhoneBookSession::EManual);

	User::After(3000000); // 3 seconds to ensure server has chance to fully startup

	TRAPD(err, DoSyncL()); // and try sync immediately (Timing window - when debugging, do not step through)

	TESTCHECKL(err, KErrNone);	

	// Wait until cache becomes usable

	WaitForSyncToCompleteL();

	// Verify cache is valid for all phonebooks

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkSyncManualDiffSizeSIMTest object

 */

CPhbkSyncManualDiffSizeSIMTest* CPhbkSyncManualDiffSizeSIMTest::NewL()

	{

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

	return self;

	}

/**

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

 */

CPhbkSyncManualDiffSizeSIMTest::CPhbkSyncManualDiffSizeSIMTest()

	{

	SetTestStepName(_L("SyncManualDiffSizeSIMTest"));

	}

/** 

 * Test synchronising a SIM with a different number of slots.

 */

enum TVerdict CPhbkSyncManualDiffSizeSIMTest::doTestStepL()

	{

	//

	// Sync with a SIM which has 22 entries used out of 25 for each of the 5 phonebooks...

	//

	SetSimTsyTestNumberL(24);	

	User::LeaveIfError(iSession.SetSyncMode(RPhoneBookSession::EManual));

	CheckSyncModeL(RPhoneBookSession::EManual);

	DoSyncL();

	WaitForSyncToCompleteL();

	iDb->SetDbViewContactType(KUidContactICCEntry);

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

	TInt  count(sortedItems->Count());

	TESTCHECKL(count, KTest24ICCSlotsUsed);

	//

	// Sync with a SIM which has 3 entries used out of 15 for each of the 5 phonebooks...//

	//

	SetSimTsyTestNumberL(25);

	DoSyncL();

	WaitForSyncToCompleteL();

	iDb->SetDbViewContactType(KUidContactICCEntry);

	sortedItems = iDb->SortedItemsL();

	count = sortedItems->Count();

	TESTCHECKL(count, KTest25ICCSlotsUsed);

	//

	// Check that all slots can be read successfully.  This used to leave in a defect case.

	//

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

		{ 

		TContactItemId  id = (*sortedItems)[index];

		CContactItemViewDef*  view = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,

			                                                    CContactItemViewDef::EMaskHiddenFields);

		view->AddL(KUidContactFieldPhoneNumber); 

		TESTCHECKL(view->Count(), 1);

		CContactICCEntry* entry = static_cast<CContactICCEntry*>(iDb->ReadContactL(id, *view)); 

		delete entry;

		CleanupStack::PopAndDestroy(1, view);

		} 

	//

	// Sync with a SIM which has 22 entries used out of 25 for each of the 5 phonebooks...

	//

	SetSimTsyTestNumberL(24);

	DoSyncL();

	WaitForSyncToCompleteL();

	iDb->SetDbViewContactType(KUidContactICCEntry);

	sortedItems = iDb->SortedItemsL();

	count = sortedItems->Count();

	TESTCHECKL(count, KTest24ICCSlotsUsed);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkSyncSATUpdatesTestBase object

 */

CPhbkSyncSATUpdatesTestBase* CPhbkSyncSATUpdatesTestBase::NewL()

	{

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

	return self;

	}

/**

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

 */

CPhbkSyncSATUpdatesTestBase::CPhbkSyncSATUpdatesTestBase()

	{

	SetTestStepName(_L("SyncSATUpdatesTest"));

	}

/** 

 * Re-Synchronisation (SIM Toolkit initiated).

 * SIM is OK. Synchronisation mode is "Auto Sync, Current ICC".

 * Test initial synchronisation is successful. Then test that

 * a subsequent "SIM toolkit refresh" notification leads to a 

 * second synchronisation.

 */

enum TVerdict CPhbkSyncSATUpdatesTestBase::doTestStepL()

	{

	//

	// Sync to a basic SIM to allow the following sync to complete quicky...

	//

	SetSyncModeL(RPhoneBookSession::EManual);

	CheckSyncModeL(RPhoneBookSession::EManual);

	SetSimTsyTestNumberL(0);

	DoSyncL();

	WaitForSyncToCompleteL();

	SetSyncModeL(RPhoneBookSession::EAutoCurrentIcc);

	CheckSyncModeL(RPhoneBookSession::EAutoCurrentIcc);

	//

	// Switch to a SIM TSY configuration which sends a "refresh" notification

	// at some point in the future and sync all phonebooks.

	//

	SetSimTsyTestNumberL(7);

	WaitForSyncToCompleteL();

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	TInt  numSlots, result;

	TContactItemId  aId0, aId1, aId2, aId3, aId4, aId5, aId6;

	result = iSession.GetNumSlots(numSlots, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNone);

	TESTCHECK(numSlots, 20);

	result = iSession.GetSlotId(0, aId0, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(1, aId1, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(2, aId2, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(3, aId3, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(4, aId4, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNone);

	result = iSession.GetSlotId(5, aId5, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNone);

	result = iSession.GetSlotId(6, aId6, KUidIccGlobalAdnPhonebook);

	TESTCHECK(result, KErrNone);

	result = iSession.GetSlotId(0, aId0, KUidUsimAppAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(1, aId1, KUidUsimAppAdnPhonebook);

	TESTCHECK(result, KErrNone);

	result = iSession.GetSlotId(2, aId2, KUidUsimAppAdnPhonebook);

	TESTCHECK(result, KErrNone);

	result = iSession.GetSlotId(3, aId3, KUidUsimAppAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(4, aId4, KUidUsimAppAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(5, aId5, KUidUsimAppAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	result = iSession.GetSlotId(6, aId6, KUidUsimAppAdnPhonebook);

	TESTCHECK(result, KErrNotFound);

	CheckNameInDBL(KSatNameInADN);

	CheckNameInDBL(KSatNameInSDN);

	CheckNameInDBL(KSatNameInLND);

	CheckNameInDBL(KSatNameInUsim);

	CheckNameInDBL(KSatNameInFDN);

	//

	// Wait for a notification that one of the phonebooks has changed state and

	// that they are all now unsynchronised...

	//

	SignalSimTsyToReduceTimersL();

	TRequestStatus  status1;

	iSession.NotifyPhBkCacheStateChange(status1, KUidIccGlobalAdnPhonebook);

	User::WaitForRequest(status1);

	TESTCHECK(status1.Int(), KErrNone);

	CheckCacheStateL(RPhoneBookSession::EUnsynchronised);//sat notification has been triggered

	//

	// Wait for SAT notified sync to finish and check they are all now valid...

	//

	WaitForSyncToCompleteL();

	CheckCacheStateL(RPhoneBookSession::ECacheValid);

	CheckNameInDBL(KSatNameInADN);

	CheckNameInDBL(KSatNameInSDN);

	CheckNameInDBL(KSatNameInLND);

	CheckNameInDBL(KSatNameInUsim);

	CheckNameInDBL(KSatNameInFDN);

	return TestStepResult();

	}

/** 

 * Factory construction method.

 * @return Pointer to CPhbkSyncICCLockedTestBase object

 */

CPhbkSyncICCLockedTestBase* CPhbkSyncICCLockedTestBase::NewL()

	{

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

	return self;

	}

/**

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

 */

CPhbkSyncICCLockedTestBase::CPhbkSyncICCLockedTestBase()

	{

	SetTestStepName(_L("SyncICCLockedTest"));

	}

/**

 * Synchronisation when ICC is locked. Synchroniser is initially unable to perform 

 * synchronisation because ICC is locked, but when ICC becomes unlocked the synchronisation 

 * completes successfully.

 */

enum TVerdict CPhbkSyncICCLockedTestBase::doTestStepL()

	{

	SetSimTsyTestNumberL(8); // ICC locked, so Synchronisation is not carried out 

	SetSyncModeL(RPhoneBookSession::EManual);

	CheckSyncModeL(RPhoneBookSession::EManual);

	TRAPD(err, DoSyncFailL());

	TESTCHECKL(err, KErrNone);

	// Verify cache is not in valid state for all phonebooks

	CheckCacheStateL(RPhoneBookSession::EErrorDuringSync);

	// Save test time by prompting the SIMTSY...

	SignalSimTsyToReduceTimersL();

	TInt err1(KErrAccessDenied), err2(KErrAccessDenied), err3(KErrAccessDenied), 

		err4(KErrAccessDenied), err5(KErrAccessDenied);

	while (err1==KErrAccessDenied  ||  err1==KErrInUse  ||

	       err2==KErrAccessDenied  ||  err2==KErrInUse  ||

	       err3==KErrAccessDenied  ||  err3==KErrInUse  ||

	       err4==KErrAccessDenied  ||  err4==KErrInUse  ||

	       err5==KErrAccessDenied  ||  err5==KErrInUse)

		{

		// Global ADN Phonebook

		TRequestStatus status1;

		iSession.DoSynchronisation(status1);

		User::WaitForRequest(status1);

		err1 = status1.Int();

		// Global SDN Phonebook

		TRequestStatus status2;

		iSession.DoSynchronisation(status2, KUidIccGlobalSdnPhonebook);

		User::WaitForRequest(status2);

		err2 = status2.Int();

		// Global LND Phonebook

		TRequestStatus status3;

		iSession.DoSynchronisation(status3, KUidIccGlobalLndPhonebook);

		User::WaitForRequest(status3);

		err3 = status3.Int();

		// Usim App ADN Phonebook