// 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 <e32base.h>
#include <e32test.h>
#include <d32dbms.h>
#include "testserver.h"
#include <tzlocalizationdatatypes.h>
#include <tzlocalizer.h>

// These literals are copied from the product code as we don't want to export them
_LIT(KTzLocalizationDbName, "c:TzLocalization.db");
_LIT(KTzLocalizationDbSecurityPolicy,"secure[10206A8B]");
_LIT(KlocDbStart_test_source, "z:\\testresourcefiles\\locDbStart_test.db");
_LIT(KlocDbStart_test_destination, "c:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");
_LIT(KTimeStamp, "c:\\private\\1020383e\\timestamps");

/**
This is a series of tests that check that the frequently used timezones table and
the user-defined cities table stored in the c:TzLocalization.db DBMS database are
created correctly when they don't exist, are corrupted or need to be upgraded from
an old format to a new format.
*/
class CTzLocalizationDbCreationTests : public CBase
	{
public:
	static CTzLocalizationDbCreationTests* NewLC(RTest& aTest);
	~CTzLocalizationDbCreationTests();
	
private:
	CTzLocalizationDbCreationTests(RTest& aTest);
	void ConstructL();
	
public:
	void RunL();
	
private:
	void RunTzLocalizationDbSchemaUpgradeTestL();
	void RunTzLocalizationDbStartUpdateTestL();
	
private:
	void CheckTzServerNotRunningL();
	void EnsureTzServerNotRunning();
	void EnsureAgendaServerNotRunning();
	void DeleteTzLocalizationDbL();
	void CreateTzLocalizationDbUsingOldSchemaL();
	void CreateFrequentlyUsedTimeZonesTableUsingOldSchemaL(RDbNamedDatabase& aDatabase);
	void CreateUserAddedCitiesTableL(RDbNamedDatabase& aDatabase);
	
private:
	RTest& iTest;
	RPIMTestServer iPIMTestServer;
	RDbs iDbsSession;
	};


CTzLocalizationDbCreationTests* CTzLocalizationDbCreationTests::NewLC(RTest& aTest)
	{
	CTzLocalizationDbCreationTests* self = new(ELeave) CTzLocalizationDbCreationTests(aTest);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CTzLocalizationDbCreationTests::~CTzLocalizationDbCreationTests()
	{
	iDbsSession.Close();
	iPIMTestServer.Close();
	}

CTzLocalizationDbCreationTests::CTzLocalizationDbCreationTests(RTest& aTest)
	: iTest(aTest)
	{
	}

void CTzLocalizationDbCreationTests::ConstructL()
	{
	User::LeaveIfError(iPIMTestServer.Connect());
	iPIMTestServer.CloseTzSession();
	User::LeaveIfError(iDbsSession.Connect());
	}

void CTzLocalizationDbCreationTests::RunL()
	{
	_LIT(KTestName, "@SYMTestCaseID:PIM-APPSERV-tzlocalizationdbcreationtests-0001 TzLocalizationDbSchemaUpgradeTest");
	
	iTest.Start(KTestName);
	TRAPD(err, RunTzLocalizationDbSchemaUpgradeTestL())
	if (err != KErrNone)
		{
		_LIT(KErrorMsg, "RunTzLocalizationDbSchemaUpgradeTestL with error code: %d\n");
		iTest.Printf(KErrorMsg, err);
		User::Leave(err);
		}

	_LIT(KTestName1, "RunTzLocalizationDbStartUpdateTestL");
	
	iTest.Next(KTestName1);
	TRAP(err, RunTzLocalizationDbStartUpdateTestL());
	if (err != KErrNone)
		{
		_LIT(KErrorMsg1, "RunTzLocalizationDbStartUpdateTestL with error code: %d\n");
		iTest.Printf(KErrorMsg1, err);
		User::Leave(err);
		}
	iTest.End();
	}

void CTzLocalizationDbCreationTests::RunTzLocalizationDbSchemaUpgradeTestL()
	{
	// Delete the current database and replace it with an old version
	DeleteTzLocalizationDbL();
	CreateTzLocalizationDbUsingOldSchemaL();
	
	// Create a CTzLocalizer object and check that the database
	// is upgraded correctly
	CTzLocalizer* localizer = 0;
	TRAPD(err, localizer = CTzLocalizer::NewL());
	if (err != KErrNone)
		{
		_LIT(KErrorMsg, "CTzLocalizer creation failed with error code: %d\n");
		iTest.Printf(KErrorMsg, err);
		User::Leave(err);
		}
	delete localizer;
	
	// Creation of the CTzLocalizer should have caused a database upgrade
	RDbNamedDatabase tzLocalizationDb;
	User::LeaveIfError(tzLocalizationDb.Open(iDbsSession,KTzLocalizationDbName,KTzLocalizationDbSecurityPolicy));
	CleanupClosePushL(tzLocalizationDb);
	RDbView zoneView;
	CleanupClosePushL(zoneView);
	_LIT(KReadZoneView,"SELECT * FROM FrequentlyUsedZones");
	User::LeaveIfError(zoneView.Prepare(tzLocalizationDb, TDbQuery(KReadZoneView), zoneView.EUpdatable));
	User::LeaveIfError(zoneView.EvaluateAll());
	zoneView.Reset();
	const TInt KExpectedNumberOfColumns = 9;
	_LIT(KMsg1, "Expected number of columns: %d\n");
	iTest.Printf(KMsg1, KExpectedNumberOfColumns);
	const TInt colCount = zoneView.ColCount();
	_LIT(KMsg2, "Actual number of columns: %d\n");
	iTest.Printf(KMsg2, colCount);
	if (colCount != KExpectedNumberOfColumns)
		{
		iTest(EFalse);
		}
	CleanupStack::PopAndDestroy(&zoneView);
	CleanupStack::PopAndDestroy(&tzLocalizationDb);
	
	// Cleanup database file
	DeleteTzLocalizationDbL();
	}
/* Localization Database start up
 * Verify that the localization database start-up copes well when it contains some
 * time zone infomation whose Tz ID no longer exists in the TZ database.
 */
void CTzLocalizationDbCreationTests::RunTzLocalizationDbStartUpdateTestL()
	{
	//Make sure the Tz server is not running.
	EnsureTzServerNotRunning();
	//Copy a localization DB contained few frequently used Tz zones which do not exist in the current Tz database.
	iTest.Printf(_L("Copy test file DBS_10206A8B_TzLocalization.db"));
	iPIMTestServer.CopyFileL(KlocDbStart_test_source ,KlocDbStart_test_destination);
	iPIMTestServer.DeleteFileL(KTimeStamp);
	
	//Connect to the Tz server which result in the localization DB updating its tables.
	iTest.Printf(_L("Connect to the Tz server"));
	RTz tz;
	CleanupClosePushL(tz);
	User::LeaveIfError(tz.Connect());
	CTzId* tzid = tz.GetTimeZoneIdL();
	TUint id = tzid->TimeZoneNumericID();
	delete tzid;
	
	//Carry some basic operations which access to the localization DB.
	iTest.Printf(_L("Access to the localization DB"));
	CTzLocalizer* localizer = CTzLocalizer::NewL();
	CleanupStack::PushL(localizer);
	
	CTzLocalizedTimeZone* locTzId = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::ECurrentZone);
	iTest (locTzId->TimeZoneId() == id);
	delete locTzId;
	
	CTzLocalizedCity* locCity = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::ECurrentZone);
	iTest (locCity->TimeZoneId() == id);
	delete locCity;

	//Disconnect to the Tz server and delete the localization DB
	CleanupStack::PopAndDestroy(2, &tz);
	iPIMTestServer.DeleteFileL(KlocDbStart_test_destination);
	}

void CTzLocalizationDbCreationTests::CheckTzServerNotRunningL()
	{
	_LIT(KTzServerProcessPattern, "tzserver.exe*");
	TFindProcess finder(KTzServerProcessPattern);
	TFileName foundName;
	while (finder.Next(foundName) == KErrNone)
		{
		RProcess proc;
		TInt err = proc.Open(foundName);
		if (err == KErrNone)
			{
			if (proc.ExitType() == EExitPending)
				{
				_LIT(KErrorMsg, "TzServer must not be running\n");
				iTest.Printf(KErrorMsg);
				User::Leave(KErrNotReady);
				}
			}
		}
	}


void CTzLocalizationDbCreationTests::EnsureAgendaServerNotRunning()
	{
	_LIT(KAgendaServerProcessPattern, "agsvexe.exe*");
	TFindProcess finder(KAgendaServerProcessPattern);
	TFileName foundName;
	while (finder.Next(foundName) == KErrNone)
		{
		RProcess proc;
		TInt err = proc.Open(foundName);
		if (err == KErrNone)
			{
			if (proc.ExitType() == EExitPending)
				{
				_LIT(KInfoMsg, "INFO: Agenda server must not be running - killing it now.\n");
				iTest.Printf(KInfoMsg);
				TRAP_IGNORE(iPIMTestServer.KillProcessL(KAgendaServerProcessPattern));
				}
			}
		}
	}

void CTzLocalizationDbCreationTests::EnsureTzServerNotRunning()
	{
	_LIT(KTzServerProcessPattern, "tzserver.exe*");
	TFindProcess finder(KTzServerProcessPattern);
	TFileName foundName;
	while (finder.Next(foundName) == KErrNone)
		{
		RProcess proc;
		TInt err = proc.Open(foundName);
		if (err == KErrNone)
			{
			if (proc.ExitType() == EExitPending)
				{
				_LIT(KInfoMsg, "INFO: TzServer must not be running - killing it now.\n");
				iTest.Printf(KInfoMsg);
				TRAP_IGNORE(iPIMTestServer.KillProcessL(KTzServerProcessPattern));
				}
			}
		}
	}

void CTzLocalizationDbCreationTests::DeleteTzLocalizationDbL()
	{
	EnsureAgendaServerNotRunning();
	EnsureTzServerNotRunning();
	
	_LIT(KTzLocalizationDbFilePath, "c:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");
	TRAPD(err, iPIMTestServer.DeleteFileL(KTzLocalizationDbFilePath));
	if (err != KErrNone)
		{
		_LIT(KErrorMsg, "Database deletion failed with error code: %d\n");
		iTest.Printf(KErrorMsg, err);
		User::Leave(err);
		}
	}

void CTzLocalizationDbCreationTests::CreateTzLocalizationDbUsingOldSchemaL()
	{
	EnsureAgendaServerNotRunning();
	EnsureTzServerNotRunning();
	
	RDbNamedDatabase tzLocalizationDb;
	CleanupClosePushL(tzLocalizationDb);
	TInt err = tzLocalizationDb.Create(iDbsSession, KTzLocalizationDbName, KTzLocalizationDbSecurityPolicy);
	if (err != KErrNone)
		{
		_LIT(KErrorMsg, "Database creation failed with error code: %d\n");
		iTest.Printf(KErrorMsg, err);
		User::Leave(err);
		}
	CreateFrequentlyUsedTimeZonesTableUsingOldSchemaL(tzLocalizationDb);
	CreateUserAddedCitiesTableL(tzLocalizationDb);
	CleanupStack::PopAndDestroy(&tzLocalizationDb);
	}

/**
This is mostly a copy/paste of CTzLocalizationDb::CreateFrequentlyUsedTimeZonesTableL() but 
modified so that it creates a database without the city index column.
*/
void CTzLocalizationDbCreationTests::CreateFrequentlyUsedTimeZonesTableUsingOldSchemaL(RDbNamedDatabase& aDatabase)
	{
	//Table and Column names for Cached Time Zone Table
	//These text strings are never visible and do not need localizing
	_LIT(KCZTableName, "FrequentlyUsedZones");
	_LIT(KCZTableTzIdCol, "TzId");
	_LIT(KCZTableStdCol, "StandardName");
	_LIT(KCZTableDSTCol, "DSTName");
	_LIT(KCZTableShortStdCol, "ShortStandardName");
	_LIT(KCZTableShortDSTCol, "ShortDSTName");
	_LIT(KCZTableCityCol, "City");
	_LIT(KCZTableCityGroupCol, "GroupId");
	_LIT(KCZTableResourceIdCol, "ResourceId");
	
	// Create the columns for the cached zones table
	RArray<TDbCol> cachedTableCols;
	CleanupClosePushL(cachedTableCols);
	cachedTableCols.AppendL(TDbCol(KCZTableTzIdCol,			EDbColUint16));
	cachedTableCols.AppendL(TDbCol(KCZTableStdCol, 			EDbColText));
	cachedTableCols.AppendL(TDbCol(KCZTableDSTCol, 			EDbColText));
	cachedTableCols.AppendL(TDbCol(KCZTableShortStdCol, 	EDbColText));
	cachedTableCols.AppendL(TDbCol(KCZTableShortDSTCol, 	EDbColText));
	cachedTableCols.AppendL(TDbCol(KCZTableCityCol, 		EDbColText));
	cachedTableCols.AppendL(TDbCol(KCZTableCityGroupCol, 	EDbColUint8));
	cachedTableCols.AppendL(TDbCol(KCZTableResourceIdCol, 	EDbColUint32));
	// We do not add the city index column as we want to create a database using
	// the old schema
    
	// Create the columnset - add the columns
	// Columns MUST be added in the same order they appear in TTzZoneColumn
	CDbColSet* frequentlyUsedTimeZonesColSet = CDbColSet::NewLC();
	TInt numCols = cachedTableCols.Count();
	for(TInt i = 0; i < numCols; ++i)
		{
		frequentlyUsedTimeZonesColSet->AddL(cachedTableCols[i]);
		}

	// Create the Cached Time Zone table
	User::LeaveIfError(aDatabase.CreateTable(KCZTableName, *frequentlyUsedTimeZonesColSet));

	//Open the newly created table
	RDbView zoneView;
	CleanupClosePushL(zoneView);
	_LIT(KReadZoneView,"SELECT * FROM FrequentlyUsedZones");
	User::LeaveIfError(zoneView.Prepare(aDatabase, TDbQuery(KReadZoneView), zoneView.EUpdatable));
	User::LeaveIfError(zoneView.EvaluateAll());
	zoneView.Reset();
	//Populate with initial (blank) data.

	_LIT(KEmptyString," ");

	enum TTzOldSchemaZoneColumn
		{
		// Enum will used as a DB column index, so it must start at 1
		ETzZoneId = 1,
		ETzZoneStdName,
		ETzZoneDSTName,
		ETzZoneShortStdName,
		ETzZoneShortDSTName,
		ETzZoneCity,
		ETzZoneGroupId,
		ETzZoneResourceId,
		};
	
	for (TInt x = 0; x < CTzLocalizedTimeZone::ECachedTimeZones; ++x)
		{
		// Insert empty row
		zoneView.InsertL();
		// Fill the table with blank data
		zoneView.SetColL(ETzZoneId,			0);
		zoneView.SetColL(ETzZoneStdName,		KEmptyString);
		zoneView.SetColL(ETzZoneDSTName,		KEmptyString);
		zoneView.SetColL(ETzZoneShortStdName,	KEmptyString);
		zoneView.SetColL(ETzZoneShortDSTName,	KEmptyString);
		zoneView.SetColL(ETzZoneCity,			KEmptyString);
		zoneView.SetColL(ETzZoneGroupId,		0);
		zoneView.SetColL(ETzZoneResourceId,	0);
		zoneView.PutL(); // Complete insertion
		}
	
	CleanupStack::PopAndDestroy(&zoneView);
	CleanupStack::PopAndDestroy(frequentlyUsedTimeZonesColSet);
	CleanupStack::PopAndDestroy(&cachedTableCols);
	}

/**
This is a copy/paste of CTzLocalizationDb::CreateUserAddedCitiesTableL() that 
we can't use as it is not exported.
*/
void CTzLocalizationDbCreationTests::CreateUserAddedCitiesTableL(RDbNamedDatabase& aDatabase)
	{
	//Table and Column names for User Added Cities Table
	//These text strings are never visible and do not need localizing
	_LIT(KUCTableName, "UserCities");
	_LIT(KUCTableTzId, "TzId");
	_LIT(KUCTableCity, "City");
	_LIT(KUCTableGroup, "GroupId");
	_LIT(KUCTableResourceId, "ResourceId");
	
	//Create the columns for the user aded cities table
	RArray<TDbCol> cityTableCols;
	CleanupClosePushL(cityTableCols);
	cityTableCols.AppendL(TDbCol(KUCTableTzId,			EDbColUint16));
	cityTableCols.AppendL(TDbCol(KUCTableCity,			EDbColText));
	cityTableCols.AppendL(TDbCol(KUCTableGroup,			EDbColUint8));
	cityTableCols.AppendL(TDbCol(KUCTableResourceId,	EDbColUint32));

	// Create the columnset - add the columns
	// Columns MUST be added in the same order they appear in TTzCityColumn
	CDbColSet* userAddedCitiesColSet = CDbColSet::NewLC();
	TInt numCols = cityTableCols.Count();
	for(TInt i = 0; i < numCols; ++i)
		{
		userAddedCitiesColSet->AddL(cityTableCols[i]);
		}

	// Create the User City table
	User::LeaveIfError(aDatabase.CreateTable(KUCTableName, *userAddedCitiesColSet));
	
	CleanupStack::PopAndDestroy(userAddedCitiesColSet);
	CleanupStack::PopAndDestroy(&cityTableCols);
	}

static void DoTestsL(RTest& aTest)
	{
	CTzLocalizationDbCreationTests* tests = CTzLocalizationDbCreationTests::NewLC(aTest);
	tests->RunL();
	CleanupStack::PopAndDestroy(tests);
	}

/**

@SYMTestCaseID	PIM-APPSERV-tzlocalizationdbcreationtests-0001

*/

TInt E32Main()
    {
	__UHEAP_MARK;

	CTrapCleanup* trapCleanup = CTrapCleanup::New();
	if(!trapCleanup)
		{
		return KErrNoMemory;
		}

	CActiveScheduler* scheduler = new CActiveScheduler;
	if(!scheduler)
		{
		return KErrNoMemory;
		}
	CActiveScheduler::Install(scheduler);	

	_LIT(KTestName, "t_tzlocalizationdbcreationtests");
	RTest test(KTestName);
	TRAPD(ret, DoTestsL(test));
	test.Printf(_L("Trapped return value from DoTestsL(): %d\n"), ret);
	test(ret == KErrNone);
	test.Close();
	
	delete scheduler;
	delete trapCleanup;	

	__UHEAP_MARKEND;

	return (KErrNone);
    }