// 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:

//

#include <connect/sbeclient.h>

#include <e32test.h>

#include "tzuserdata.h"

#include <tzlocalizer.h>

#include "testserver.h"

#include <tzlocalizedcityrecord.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tzusernames.h>

#include <tzuserdefineddata.h>

#endif

#include "tzidinternal.h"

_LIT(KBackupTest, "Tz Backup");

RTest test(KBackupTest);

// Literal constants

_LIT(KTzTestBackupFile, "C:\\Backup__tzuserdata.db");

_LIT(KTzBackupFileFullPath, "C:\\private\\1020383e\\SQLite__tzuserdata.db");

_LIT(KTzTestBackupLocDb, "C:\\Backup__TzLocalization.db");

_LIT(KTzBackupLocDbFullPath, "C:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");

_LIT(KTimeZoneBackupRegistrationFullPath, "Z:\\private\\1020383E\\backup_registration.xml");

_LIT(KPerFile1,"c:\\private\\100012a5\\DBS_2000836D_DBS_DSC.db");

_LIT(KPerFile2,"c:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");

_LIT(KStandardName1, "UserTzName1");

_LIT(KShortStandardName1, "UserTzSh1");

_LIT(KDaylightSaveName1, "UserDLSaveName1");

_LIT(KShortDaylightSaveName1, "UserShDLS1");

_LIT(KCityNameName1, "UserCityName1");

_LIT(KRegionName1, "UserRegionName1");

_LIT(KStandardName2, "UserTzName2");

_LIT(KShortStandardName2, "UserTzSh2");

_LIT(KDaylightSaveName2, "UserDLSaveName2");

_LIT(KShortDaylightSaveName2, "UserShDLS2");

_LIT(KCityNameName2, "UserCityName2");

_LIT(KRegionName2, "UserRegionName2");

_LIT(KUserAddedCityName1, "UserAddedCity1");

_LIT(KUserAddedCityName2, "UserAddedCity2");

const TInt KLondonTzId = 2592;

const TInt KParisTzId = 2656;

static conn::CSBEClient* BackupClient;

static TDriveList DriveList;

class CTestUserDefinedBackupRestore : public CBase

	{

public:

	static CTestUserDefinedBackupRestore* NewL();

	~CTestUserDefinedBackupRestore();

enum TTest

	{

	EBackupTest,

	ERestoreTest

	};

	void RunTestsL();

	void TestBackupAndRestoreUserDbL(TTest aTest);

	void TestFrequentlyUsedZonesUpdateAfterRestoreDeleteL();

	void TestFrequentlyUsedZonesUpdateAfterRestoreUpdateL();

	void TestUserCitiesUpdateAfterRestoreL();

	void TestFrequentlyUsedCurrentZonesUpdateAfterRestoreUpdateL();

	void TestSystemRulesUpdateAfterRestoreL();

	void TestBackupAndRestoreLocDbL();

private:

	CTestUserDefinedBackupRestore();

	TBool CheckXMLRegistrationFileL();

	TBool SimulateTzBackup(const TDesC& aSrcfile, const TDesC& aDestfile);

	TBool SimulateTzRestore(const TDesC& aSrcfile, const TDesC& aDestfile);

	void ConstructL();

	void ResetTzUserDataL();

	TBool TestSystemRulesUpdateAfterRestoreL(TUint aExpectedTzId, TBool aRestoreEmptyFile);

	TBool LocDbWriteFunctionL(CTzLocalizer& aTzLocalizer, TInt aExpectedErr);

	TBool CompareFrequentlyUsedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare);

	TBool CompareFrequentlyUsedZone(const CTzLocalizedTimeZone& aZone, const CTzLocalizedTimeZone& aZoneToCompare);

	TBool CompareFrequentlyUsedCityAfterUpdate(TInt aId, const CTzLocalizedCity& aCity);

	TBool CompareFrequentlyUsedCityRestoredAfterUpdate(TInt aId, const CTzLocalizedCity& aCity);

	TBool CompareFrequentlyUsedZoneAfterUpdate(TInt aId, const CTzLocalizedTimeZone& aZone);

//Member

public:

	CTzUserData* iUserData;

	RFs iFs;

	RPIMTestServer iServ;

	RTz iTz;

	};

// building block test backup and restore functions

static void StartBackupL()

	{

	/* Use the Secure Backup Engine API to "start" a backup.  The backup

	 happens indirectly through CTzUserDataDb::BackupBeginningL()/

	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

	 These methods are implementations for MBackupRestoreNotificatioObserver

	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

	 This P&S property is changed by calling the Secure Backup Engine API

	 below.

	 */	

	test.Printf(_L("Starting Backup\n"));

	BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase);

	User::After(3000000);// Wait a bit to allow the server to close the database

	}

static void EndBackupL()

	{

	/* Use the Secure Backup Engine API to "end" a backup. The backup ends

	 indirectly through CTzUserDataDb::BackupBeginningL()/

	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

	 These methods are implementations for MBackupRestoreNotificatioObserver

	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

	 This P&S property is changed by calling the Secure Backup Engine API

	 below.

	 */

	test.Printf(_L("Finishing Backup\n"));

	BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);

	User::After(3000000);// Wait a bit to allow the server to open the database

	}

static void StartRestoreL()

	{

	/* Use the Secure Backup Engine API to "start" a restore.  

	 This happens indirectly through CTzUserDataDb::BackupBeginningL()/

	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

	 These methods are implementations for MBackupRestoreNotificatioObserver

	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

	 This P&S property is changed by calling the Secure Backup Engine API

	 below.

	 */

	test.Printf(_L("Starting restore\n"));

	BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase);

	User::After(3000000);// Wait a bit to allow the server to close the database

	}

static void EndRestoreL()

	{

	/* Use the Secure Backup Engine API to "end" a restore.

	 This happens indirectly through CTzUserDataDb::BackupBeginningL()/

	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

	 These methods are implementations for MBackupRestoreNotificatioObserver

	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

	 This P&S property is changed by calling the Secure Backup Engine API

	 below.

	 */

	test.Printf(_L("Finishing restore\n"));

	BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);

	User::After(3000000);// Wait a bit to allow the server to open and update the database

	}

LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr)

	{

	RPointerArray<CTzId>* ids = static_cast<RPointerArray<CTzId>*>(aPtr);

	if (ids)

		{

		ids->ResetAndDestroy();

		}

	}

LOCAL_D void CleanupCityPointerArray(TAny* aPtr)

	{

	RPointerArray<CTzLocalizedCityRecord>* ids = static_cast<RPointerArray<CTzLocalizedCityRecord>*>(aPtr);

	if (ids)

		{

		ids->ResetAndDestroy();

		}

	}

/** Access to user defined time zone data during backup or restore operation 

@SYMTestCaseID      PIM-TTZBACKUP-TZS-BR-0001

@SYMTestCaseDesc    The purpose of this test is to verify the behaviour of the 

					client APIs that access user defined time zones during a backup or restore operation.

@SYMTestActions    

1.	Create a user defined time zone.

2.	Simulate start of backup or restore operation.

3.	Access (read, update, delete) the user defined time zone created in action 1. 1

4.	Create a user defined time zone. 2

5.	Simulate end of backup or restore operation.

6.	Access (read, update, delete) the user defined time zone created in action 1. 3

7.	Create a user defined time zone. 4

@SYMTestExpectedResults In step 3 and 4, operation leaves with KErrLocked

						In step 6 and 7, operation completes without error	

@SYMTestType                CT

@SYMTestPriority            1

*/

CTestUserDefinedBackupRestore::CTestUserDefinedBackupRestore()

	{

	}

CTestUserDefinedBackupRestore* CTestUserDefinedBackupRestore::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTestUserDefinedBackupRestore::ConstructL()

	{

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iServ.Connect());

	iServ.CloseTzSession();

	}

CTestUserDefinedBackupRestore::~CTestUserDefinedBackupRestore()

	{

	delete iUserData;

	iFs.Delete(KTzTestBackupFile);

	// delete database file

	iFs.Delete(KTzBackupFileFullPath);

	iFs.Close();

	iServ.Close();

	}

void CTestUserDefinedBackupRestore::ResetTzUserDataL()

	{

	RPointerArray<CTzId> ids;

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids));

	iUserData->GetTzIdsL(ids);

	TInt count = ids.Count();

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

		{

		iUserData->DeleteL(*ids[ii]);	

		}

	CleanupStack::PopAndDestroy(&ids);	

	}

TBool CTestUserDefinedBackupRestore::CheckXMLRegistrationFileL()

	{

	TEntry entry;

	TInt error = iFs.Entry(KTimeZoneBackupRegistrationFullPath, 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 file

	return ETrue;

	}

TBool CTestUserDefinedBackupRestore::SimulateTzBackup(const TDesC& aSrcfile, const TDesC& aDestfile)

	{

    TRAPD(error, iServ.CopyFileL(aSrcfile, aDestfile));

	if (error != KErrNone)

		{

		test.Printf(_L("Copy failed with error %i"), error);

		return EFalse;

		}

	return ETrue;

	}

TBool CTestUserDefinedBackupRestore::SimulateTzRestore(const TDesC& aSrcfile, const TDesC& aDestfile)

	{

    // Backup tz user-defined database file.

    TRAPD(error, iServ.CopyFileL(aSrcfile ,aDestfile));

	if (error != KErrNone)

		{

		test.Printf(_L("Copy failed with error %i"), error);

		return EFalse;

		}

	return ETrue;

	}

TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare)

	{

	if(aCity.TimeZoneId() != aCityToCompare.TimeZoneId())

		{

		return EFalse;

		}

	if(aCity.GroupId() != aCityToCompare.GroupId())

		{

		return EFalse;

		}

	if(aCity.Name() != aCityToCompare.Name())

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedZone(const CTzLocalizedTimeZone& aZone, const CTzLocalizedTimeZone& aZoneToCompare)

	{

	if(aZone.TimeZoneId() != aZoneToCompare.TimeZoneId())

		{

		return EFalse;

		}

	if(aZone.StandardName() != aZoneToCompare.StandardName())

		{

		return EFalse;

		}

	if(aZone.ShortStandardName() != aZoneToCompare.ShortStandardName())

		{

		return EFalse;

		}

	if(aZone.DaylightName() != aZoneToCompare.DaylightName())

		{

		return EFalse;

		}

	if(aZone.ShortDaylightName() != aZoneToCompare.ShortDaylightName())

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCityAfterUpdate(TInt aId, const CTzLocalizedCity& aCity)

	{

	if(aCity.TimeZoneId() != aId)

		{

		return EFalse;

		}

	if(aCity.GroupId() != 0)

		{

		return EFalse;

		}

	if(aCity.Name() != KCityNameName2)

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCityRestoredAfterUpdate(TInt aId, const CTzLocalizedCity& aCity)

	{

	if(aCity.TimeZoneId() != aId)

		{

		return EFalse;

		}

	if(aCity.GroupId() != 0)

		{

		return EFalse;

		}

	if(aCity.Name() != KCityNameName1)

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedZoneAfterUpdate(TInt aId, const CTzLocalizedTimeZone& aZone)

	{

	if(aZone.TimeZoneId() != aId)

		{

		return EFalse;

		}

	if(aZone.StandardName() != KStandardName1)

		{

		return EFalse;

		}

	if(aZone.ShortStandardName() != KShortStandardName1)

		{

		return EFalse;

		}

	if(aZone.DaylightName() != KDaylightSaveName1)

		{

		return EFalse;

		}

	if(aZone.ShortDaylightName() != KShortDaylightSaveName1)

		{

		return EFalse;

		}

	return ETrue;

	}

void CTestUserDefinedBackupRestore::TestBackupAndRestoreUserDbL(TTest aTest)

	{

	TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust,  ETzFixedDate, 0,  0, ETzWallTimeReference, 120);

	TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);

	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

	CleanupStack::PushL(rules);

	rules->AddRuleL(rule1);

	rules->AddRuleL(rule2);

	TBuf<20> stdName;

	stdName.Format(_L("StdName1"));	

	TBuf<20> shortStdName;

	shortStdName.Format(_L("ShortStd1"));	

	TBuf<20> dstName;

	dstName.Format(_L("DstName1"));	

	TBuf<20> shortDstName;

	shortDstName.Format(_L("ShortDst1"));	

	TBuf<20> cityName;

	cityName.Format(_L("CityName1"));	

	TBuf<20> regionName;

	regionName.Format(_L("RegionName1"));

	CTzUserNames* names = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);

	CTzId* id = NULL;

	id = iUserData->CreateL(*rules, *names);

	CleanupStack::PopAndDestroy(2, rules);

	CleanupStack::PushL(id);

	TBool file = CheckXMLRegistrationFileL();

	test(file);

	if(aTest == EBackupTest)

		{

		TRAPD(err, StartBackupL());

		test(err==KErrNone);

		TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);

		test(result);

		}

	else

		{

		TRAPD(err, StartRestoreL());

		test(err == KErrNone);

		TBool result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;

		test(result);

		CleanupStack::PopAndDestroy(id);

		// Setting back to initial id as the database

		// copied during restore will not have all the changes

		// that happened afterwards

		id = CTzId::NewL(KUserTzIdMin);

		CleanupStack::PushL(id);

		}

	test.Printf(_L("Now try reading the names of the created zone\n"));

	CTzUserNames* readNames = NULL;

	TRAPD(err, readNames = iUserData->ReadNamesL(*id));

	delete readNames;

	test(err == KErrLocked);

	test.Printf(_L("Could not read names as backup/restore is in progress\n"));

	test.Printf(_L("Now try reading the rules of the created zone\n"));

	CTzRules* readRules = NULL;

	TRAP(err, readRules = iUserData->ReadRulesL(*id));

	delete readRules;

	test(err == KErrLocked);

	test.Printf(_L("Could not read rules as backup/restore is in progress\n"));

	test.Printf(_L(" @SYMTestCaseID PIM-TTZBACKUP-TZS-BR-0001  Now try reading the TZIDs of all user-defined time zone data\n"));

	RPointerArray<CTzId> tzIds;

	TRAP(err, iUserData->GetTzIdsL(tzIds));

	tzIds.ResetAndDestroy();

	tzIds.Close();

	test(err == KErrLocked);

	test.Printf(_L("Could not read TZIDs as backup/restore is in progress\n"));

	TTzRule rule3(1981,1996,0,60,EMarch,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

	TTzRule rule4(1981,1996,60,0,EOctober,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

	CTzRules* rulesAdd = CTzRules::NewL(0, KMaxTUint);

	CleanupStack::PushL(rulesAdd);

	rulesAdd->AddRuleL(rule3);

	rulesAdd->AddRuleL(rule4);

	stdName.Format(_L("StdName2"));	

	shortStdName.Format(_L("ShortStd2"));	

	dstName.Format(_L("DstName2"));	

	shortDstName.Format(_L("ShortDst2"));	

	cityName.Format(_L("CityName2"));	

	regionName.Format(_L("RegionName2"));

	CTzUserNames* namesAdd = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);

	CTzId* tzId = NULL;

	TRAP(err, tzId  = iUserData->CreateL(*rulesAdd, *namesAdd));

	delete tzId;

	test(err == KErrLocked);

	TRAP(err, iUserData->UpdateL(*id, *rulesAdd, *namesAdd));

	test(err == KErrLocked);

	test.Printf(_L("Could not update user-defined rules as backup/restore is in progress\n"));

	TRAP(err, iUserData->DeleteL((*id)));

	test(err == KErrLocked);

	test.Printf(_L("Could not delete user-defined rules as backup/restore is in progress\n"));

	CleanupStack::PopAndDestroy(namesAdd);

	CleanupStack::PopAndDestroy(rulesAdd);

	if(aTest == EBackupTest)

		{

		// backup complete

		TRAP(err, EndBackupL());

		test(err == KErrNone);

		}