// Copyright (c) 2004-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 <f32file.h>

#include <s32file.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <coreappstest/testserver.h>

#include <connect/sbeclient.h>

#include "T_UTILS.H"

#include "t_utils2.h"

#include "t_cnt_backup.h"

// cleanup version of test macro

LOCAL_C void TestCondition(TBool aCondition, TInt aLineNumber);

#define TEST_CONDITION(x) TestCondition(x, __LINE__)

// test databases to create, for use by Contacts test clients

_LIT(KBackupDatabaseFile1,"c:BackupTest1.cdb");

_LIT(KBackupDatabaseFile2,"c:BackupTest2.cdb");

_LIT(KBackupDatabaseFile3,"c:BackupTest3.cdb"); 

// real location of Contacts db files

#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__

_LIT(KBackupDatabaseFileFullPath1,"c:\\private\\10003A73\\BackupTest1.cdb");

_LIT(KBackupDatabaseFileFullPath2,"c:\\private\\10003A73\\BackupTest2.cdb");

_LIT(KBackupDatabaseFileFullPath3,"c:\\private\\10003A73\\BackupTest3.cdb"); 

_LIT(KBackupDestinationDatabasePath1,"c:\\t_cnt_backup\\BackupTest1.cdb");

_LIT(KBackupDestinationDatabasePath2,"c:\\t_cnt_backup\\BackupTest2.cdb");

_LIT(KBackupDestinationDatabasePath3,"c:\\t_cnt_backup\\BackupTest3.cdb"); 

_LIT(KContactsBackupRegistrationDefaultDbFileFullPath, "c:\\private\\10003A73\\backup_registrationcontacts_cdb.xml");

#else

_LIT(KBackupDatabaseFileFullPath1,"c:\\private\\10003A73\\SQLite__BackupTest1.cdb");

_LIT(KBackupDatabaseFileFullPath2,"c:\\private\\10003A73\\SQLite__BackupTest2.cdb");

_LIT(KBackupDatabaseFileFullPath3,"c:\\private\\10003A73\\SQLite__BackupTest3.cdb"); 

_LIT(KBackupDestinationDatabasePath1,"c:\\t_cnt_backup\\SQLite__BackupTest1.cdb");

_LIT(KBackupDestinationDatabasePath2,"c:\\t_cnt_backup\\SQLite__BackupTest2.cdb");

_LIT(KBackupDestinationDatabasePath3,"c:\\t_cnt_backup\\SQLite__BackupTest3.cdb"); 

_LIT(KContactsBackupRegistrationDefaultDbFileFullPath, "c:\\private\\10003A73\\backup_registrationSQLite__contacts_cdb.xml");

#endif

// Contact model backup files

_LIT(KContactsBackupRegistrationIniFileFullPath, "c:\\private\\10003A73\\backup_registration.xml");

_LIT(KContactsIniBackupFileFullPath, "c:\\private\\10003A73\\Cntmodel.ini");

_LIT(KBackupDestinationDirectory, "c:\\t_cnt_backup\\");

_LIT(KBackupDestinationContactsIniPath,"c:\\t_cnt_backup\\Cntmodel.ini");

_LIT(KRestoreDamagedDatabasePath,"z:\\t_cnt_backup_Corrupted_100065FF.cdb");

// delays between Backup/Restoretest steps, to allow notifications to propagate to all components

static const TInt KWaitForBackupNotification(15000000);

static const TInt KWaitForClientToSettle(2000000);

static const TInt KWaitForSystemToSettle(20000000);

// Test databases have 10 contacts created, various contact Ids are used for different purposes

static const TInt KNumContactsInDatabase= 10;

static const TContactItemId KOpenContactId1 = 1;

static const TContactItemId KOpenContactId2 = 2;

static const TContactItemId KOpenContactId3 = 3;

static const TContactItemId KSpeedDialContactId = 4;

static const TContactItemId KReadContactId = 5;

static const TInt KSpeedDialPositionOne = 1;

_LIT(KAsyncFindMatch,"a");

// global data for unit test

_LIT(KTestName, "t_cnt_backup");

static RTest test(KTestName);

static RFs TheFsSession;

/*

 Class CBackupTestConductor drives the whole set of tests

 1. Check the Backup Registration file is present

 2. Check the Secure Backup Engine has processed it as we expect

 3. ... various Backup / Restore scenarios for contacts clients

 */

CBackupTestConductor* CBackupTestConductor::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CBackupTestConductor::~CBackupTestConductor()

	{

	// ensure test databases are deleted

	CBackupTestConductor::DeleteDatabases();

	// cleanup backup files

	TheFsSession.Delete(KBackupDestinationContactsIniPath);

	TheFsSession.Delete(KBackupDestinationDatabasePath1);

	TheFsSession.Delete(KBackupDestinationDatabasePath2);

	TheFsSession.Delete(KBackupDestinationDatabasePath3);

	TheFsSession.RmDir(KBackupDestinationDirectory);

	}

CBackupTestConductor::CBackupTestConductor()

	{

	}

void CBackupTestConductor::ConstructL()

	{

	const TInt err = TheFsSession.MkDirAll(KBackupDestinationDirectory);

	if ((err != KErrNone) && (err != KErrAlreadyExists))

		{

		test.Printf(_L("Unable to create the directory %S\n"), &KBackupDestinationDirectory);

		User::Leave(err);

		}

	}

void CBackupTestConductor::RunTestsL()

	{

	// need databases for B&R testing

	CreateDatabasesL();

	// 1.x Check Backup Registration files

	test.Start(_L("Backup registration files exist"));

	TEST_CONDITION(CheckXMLBackupRegistrationExistsL());

	test.End();

	// framework that runs a Backup & Restore test cycle

	CBackupTestFramework* backupFramework = CBackupTestFramework::NewLC();

	CleanupStack::Check(backupFramework);

	// 2. ... run all Backup / Restore test situations

	backupFramework->DoBackupRestoreTestsL();

	// delete framework

	CleanupStack::PopAndDestroy(backupFramework);

	}

// demonstrates that database is populated correctly

#ifdef _DEBUG

void CBackupTestConductor::ShowFieldsL(CContactDatabase* aDb)

#else

void CBackupTestConductor::ShowFieldsL(CContactDatabase* /*aDb*/)

#endif

	{

#if _DEBUG

	CContactItem* contact = aDb->ReadContactLC(iFirstContactId);

	CContactItemFieldSet& fields = contact->CardFields();

	const TInt fieldCount = fields.Count();

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

		{

		CContactItemField &field = fields[i];

		if (field.StorageType() == KStorageTypeText)

			{

			TPtrC fieldText = field.TextStorage()->Text();

			TPtrC labelText = field.Label();

		    test.Printf(_L("--Field(%d) %S: %S \n\r"), i, &labelText, &fieldText);

			}

		}

	CleanupStack::PopAndDestroy(contact);	

#endif

	}

/*

 Populate the database - add TEN contacts, based on the default template,

 setting FOUR fields. (Given name, Family name, phone number + Company name.)

 Set the Company Name field to be the same as the name of the database.

 @param aDb the CContactDatabase instance to add contacts to.

 @param aFileName Database file name to put in the Company name field

 */

void CBackupTestConductor::PopulateDatabaseL(CContactDatabase* aDb,const TDesC& aFileName)

	{

	test.Printf(_L("Populating database %S\n"), &aFileName);

	TInt index = 0;

	TBool allDone = EFalse;

	const TContactItemId templateId = aDb->TemplateId();

	CContactItem* templateCard = aDb->ReadContactLC(templateId);

	do

	{

		CContactCard* card = CContactCard::NewLC(templateCard);

		CContactItemFieldSet& cardFields = card->CardFields();

		TInt posLastName = cardFields.Find(KUidContactFieldGivenName);

		TInt posFirstName = cardFields.Find(KUidContactFieldFamilyName);

		switch (index)

			{ // (famous writers on computer topics)

			case 0:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test1"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name1"));

				break;

			case 1:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test2"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name2"));

				break;

			case 2:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Thompson10"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name3"));

				break;

			case 3:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test3"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name4"));

				break;

			case 4:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test4"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name5"));

				break;

			case 5:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test5"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name6"));

				break;

			case 6:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test6"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name7"));

				break;

			case 7:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test7"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name8"));

				break;

			case 8:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test8"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name9"));

				break;

			case 9:

				cardFields[posLastName].TextStorage()->SetTextL(_L("Test9"));

				cardFields[posFirstName].TextStorage()->SetTextL(_L("Name10"));

				// last contact

				allDone = ETrue;

				break;

			}

		// Set the telephone number

		TInt posNumber = cardFields.Find(KUidContactFieldPhoneNumber);

		if (posNumber != KErrNotFound)

			{

			cardFields[posNumber].SetMapping(KUidContactFieldVCardMapTEL);

			cardFields[posNumber].TextStorage()->SetTextL(_L("1234"));

			}

		// set database file name as company name

		TInt posCompanyName = cardFields.Find(KUidContactFieldCompanyName);

		if (posCompanyName != KErrNotFound)

			{

			cardFields[posCompanyName].TextStorage()->SetTextL(aFileName);

			}

		iLastContactId = aDb->AddNewContactL(*card);

		if (index == 0)

			{

			iFirstContactId = iLastContactId;

			}

		CleanupStack::PopAndDestroy(card);

		++index;

		test.Printf(_L("."));

		}

		while (!allDone);

	CleanupStack::PopAndDestroy(templateCard);

	ShowFieldsL(aDb);

	}

// create THREE empty contacts databases then populate each

void CBackupTestConductor::CreateDatabasesL()

	{

	// Create & close databases

	CContactDatabase* db;

	// Need to create the default data base if it does not exist to enusre

	// prescence of backup registration file.

	if (!CContactDatabase::DefaultContactDatabaseExistsL())

		{

		db = CContactDatabase::CreateL();

		delete db;		

		}

	test.Printf(_L("Creating database %S\n"), &KBackupDatabaseFile1);

	db = CContactDatabase::ReplaceL(KBackupDatabaseFile1);

	PopulateDatabaseL(db, KBackupDatabaseFile1);

	delete db;

	test.Printf(_L("Creating database %S\n"), &KBackupDatabaseFile2);

	db = CContactDatabase::ReplaceL(KBackupDatabaseFile2);

	PopulateDatabaseL(db, KBackupDatabaseFile2);

	delete db;

	test.Printf(_L("Creating database %S\n"), &KBackupDatabaseFile3);

	db = CContactDatabase::ReplaceL(KBackupDatabaseFile3);

	PopulateDatabaseL(db, KBackupDatabaseFile3);

	delete db;

	}

void CBackupTestConductor::DeleteDatabases()

	{

	// Delete databases

	TRAP_IGNORE(CContactDatabase::DeleteDatabaseL(KBackupDatabaseFile1));

	TRAP_IGNORE(CContactDatabase::DeleteDatabaseL(KBackupDatabaseFile2));

	TRAP_IGNORE(CContactDatabase::DeleteDatabaseL(KBackupDatabaseFile3));

	}

/*

 Check that the Contact Model's Backup Registration files are present and > 0 bytes length

 */

TBool CBackupTestConductor::CheckXMLBackupRegistrationExistsL()

	{

	// Check the Contacts private area for the expected registration files

	TEntry entry;

	// See if initialisation registration file is in the directory on drive Z:

	TInt error = TheFsSession.Entry(KContactsBackupRegistrationIniFileFullPath, entry);

	if (error == KErrNotFound)

		{

		return EFalse;

		}

	User::LeaveIfError(error);

	if(entry.iSize == 0)

		{

		// file is present but is empty

		User::Leave(KErrCorrupt);

		}

	// See if default database registration file is in the directory on drive Z:

	error = TheFsSession.Entry(KContactsBackupRegistrationDefaultDbFileFullPath, entry);

	if (error == KErrNotFound)

		{

		return EFalse;

		}

	User::LeaveIfError(error);

	if(entry.iSize == 0)

		{

		// file is present but is empty

		User::Leave(KErrCorrupt);

		}

	// Found the registration files

	return ETrue;

	}

//

/*

 Framework for simulating Contact Model clients

 @param aDatabaseName database file name to open

 @param aObserver Observer in Backup / Restore test framework to count Backup and Restore notifications

 @param aContactViewObserver Observer in Backup / Restore test framework to count View Ready and Unavailable notifications

 */

CContactsClient* CContactsClient::NewLC(const TDesC& aDatabaseName, MBackupRestoreObserver* aObserver, MContactViewObserver& aContactViewObserver, TBool aCloseForBackup)

	{

	CContactsClient* self = new (ELeave) CContactsClient(aObserver, aContactViewObserver, aCloseForBackup);

	CleanupStack::PushL(self);

	self->ConstructL(aDatabaseName);

	return self;

	}

CContactsClient::CContactsClient(MBackupRestoreObserver* aObserver, MContactViewObserver& aContactViewObserver, TBool aCloseForBackup)

	: CActive(EPriorityStandard), iObserver(aObserver), iContactViewObserver(aContactViewObserver), iDatabaseIsOpen(EFalse), iCloseForBackup(aCloseForBackup), iOpenContacts(4)

	{

	CActiveScheduler::Add(this);

	}

CContactsClient::~CContactsClient()

	{

	Cancel();

	CloseViews();

	CloseDatabase();

	iOpenContacts.ResetAndDestroy();

	delete iDbName;

	}

void CContactsClient::StartActiveClose()

	{

	// start active object to close contact/view/database

	// required as these can't be closed directly from the event handlers

	if (!IsActive() && iDatabaseIsOpen)

		{

		TRequestStatus* pS = &iStatus;

		User::RequestComplete(pS,0);

		SetActive();

		}

	}

void CContactsClient::DoCancel()

	{

	}

void CContactsClient::RunL()

	{

	if (iStatus.Int() != KErrCancel)

		{

		CloseDatabase();

		}

	}

void CContactsClient::CloseDatabase()

	{

	CloseContacts();

	CloseViews();

	iDatabaseIsOpen = EFalse;

	if (iIdleFinder)

		{

		delete iIdleFinder;

		iIdleFinder = NULL;

		}

	if (iItemFieldDef)

		{

		delete iItemFieldDef;

		iItemFieldDef = NULL;

		}

	if (iActiveCompress)

		{

		delete iActiveCompress;

		iActiveCompress = NULL;

		}

	if (iActiveRecover)

		{

		delete iActiveRecover;

		iActiveRecover = NULL;

		}

	delete iNotifier;

	iNotifier = NULL;

	delete iDb;

	iDb = NULL;

	}

void CContactsClient::ConstructL(const TDesC& aDatabaseName)

	{

	// remember the database name

	iDbName = aDatabaseName.AllocL();

	// open it

	OpenDatabaseL();

	}

void CContactsClient::OpenDatabaseL()

	{

	// can only open once

	if (iDatabaseIsOpen)

		{

		User::Leave(KErrInUse);

		}

	test.Printf(_L("Open database %S\n"), iDbName);

	iDb = CContactDatabase::OpenL(iDbName->Des());

	iDatabaseIsOpen = ETrue;

	iNotifier = CContactChangeNotifier::NewL(*iDb,this);

	}

const TDesC& CContactsClient::DatabaseName()

	{

	return *iDbName;

	}

TBool CContactsClient::IsOpen()

	{

	return iDatabaseIsOpen;

	}

TBool CContactsClient::IsCloseForBackup()

	{

	return iCloseForBackup;

	}