// 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 <e32test.h>

#include <tz.h>

#include <vtzrules.h>

#include <e32math.h>

#include <tzconverter.h>

#include "testserver.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tzusernames.h>

#include <tzuserdefineddata.h>

#endif

#include <tzlocalizedcityrecord.h>

#include <tzlocalizedtimezonerecord.h>

#include "tzidinternal.h"

_LIT(KTzUserDataDb, "c:\\private\\1020383e\\SQLite__tzuserdata.db");

const TInt KPrintFreq=500;

static RPIMTestServer Serv;

// Forward class references.	

class CTzUserDataTest;

_LIT(KTestName,"User-Defined TZ Data Test Suite");

RTest test(KTestName);

_LIT8(KTzLondon, "Europe/London");

typedef void (CTzUserDataTest::*OOMTestFunction)();

class CTzUserDataTest : public CBase

	{

public:

	enum TOOMTest  

		{

		EClientOOM,

		EServerOOM 

		};

	enum TTest

		{

		ETimeConversion,

		EDayLightSave,

		EDeleteCurrentUserRule,

		EUpdateCachedTz,

		EDeleteCachedTz,

		EPersistence

		};

    static CTzUserDataTest* NewLC();

	~CTzUserDataTest();

	// Basic test - client operations on user-defined time zones.

	void TestBasicUserDataL();

	void TestOutOfMemoryBehaviourL(TOOMTest aOOMTest);

	void TestTimeZoneRulesL(TTest aWhatToTest);	

	void TestServerResponseToChangesL();

	void TestReadIdsL(RTz& aRTz);

	void TestIdsL(RTz& aRTz);

	void TestTimeConversionL();

	void TestDaylightSaveL();

	void TestDeleteCurrentTimeZoneL(RTz& aTz);

	void TestCurrentTimeZonePersistenceL(RTz& aTz);

	void TestUpdateCachedUserTimeZoneL(RTz& aTz);

	void TestDeletedCachedUserTimeZoneL(RTz& aTz);

	void BoundaryTestL();

	void TestTzIdReusabilityL();

	void NullTestL();

	void TestShortTzId(RTz& aRTz);

private:

	CTzUserDataTest();

	// Basic operations.

	void TestCreateUserDefinedTzL();

	void TestUpdateUserDefinedTzL();

	void TestDeleteUserDefinedTzL();

	void ReadIdsAndTestL(RTz& aRTz, TBool aCheckId);

	// Create user-defined time zone.

	void CreateTzAndCheckL(TInt aOldOffset, TInt aNewOffset, RTz& aRTz, TTest aWhatToTest);	

	CTzId* CreateUserDefinedTzL(TInt16 aStandardOffset,TInt16 aDSTOffset, TBool aCheck);

	void CreateUserTzBasedOnLondonRuleL(RTz& aRTz, TTest aWhatToTest);

	void CreateUserTzBasedOnShanghaiRuleL(RTz& aRTz, TTest aWhatToTest);

	CTzUserNames* CreateUserDefinedTzNamesLC();

	CTzRules* CreateUserDefinedTzLC(TInt16 aStandardOffset,TInt16 aDSTOffset);

	// OOM tests.

	void CreateOOML();

	void ReadOOML();

	void GetIdsOOML();

	void UpdateOOML();

	void DeleteOOML();

	void OOMTestL(OOMTestFunction aFunction, TOOMTest  aOOMTest);

	// TZ Server response to changes.

	void DeleteCurrentTzL(RTz& aTz);

	void UpdateCurrentTzL(RTz& aTz,TInt aOldOffSet, TInt aNewOffSet);

	void DeleteCurrentUserTzL(RTz& aTz, TTest aWhatToTest);

	void UpdateCurrentUserTzL(RTz& aTz);

	void CreateUserTzAndSetCurrentTimeToL(RTz& aTz, TInt aStandardOffSet, TInt aDSTOffset);

	void CachedUserTimeZoneL(RTz& aRTz, TTest aWhatToTest);

	// Utility methods.

	void CreateString(TDes& aString);

	TBool CompareArray(const RPointerArray<CTzId>& aIds1, const RPointerArray<CTzId>& aIds2);

	TBool CompareNames(const CTzUserNames& aName1, const CTzUserNames& aNames);

	void TestDaylightSavingStateL(CTzId& aTzId, const RArray<TTime>& times, TBool aIsOn, RTz& aRTz);

	void TestUtcOffsetL(CTzId& aTzId,const CTzRules& rules, const RArray<TTime>& times, TInt aOffset, RTz& aRTz);

	void CheckTimeZoneL(const CTzId& aId, const CTzRules& aRules, const CTzUserNames& aNames);

	void ResetTzUserDataL();

private:

	RPointerArray<CTzId> 	iTzIds;	//Used for transfering time zone IDs in delete and update test.

	CTzUserData*			iUserData;

	TInt64					iSeed;

	};

CTzUserDataTest* CTzUserDataTest::NewLC()

	{

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

	CleanupStack::PushL(self);

	return (self);

	}

CTzUserDataTest::CTzUserDataTest()

	:iSeed(100)

	{

	}	

CTzUserDataTest::~CTzUserDataTest()	

	{

	TRAP_IGNORE(ResetTzUserDataL());

	delete iUserData;

	}

LOCAL_D void ResetTimeZoneToLondonL()

	{

	RTz tz;

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

	CleanupClosePushL(tz);

	CTzId* id = CTzId::NewL(KTzLondon);

	CleanupStack::PushL(id);

	tz.SetTimeZoneL(*id);

	CleanupStack::PopAndDestroy(2, &tz);

	}

LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr)

	{

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

	if (ids)

		{

		ids->ResetAndDestroy();

		}

	}

void CTzUserDataTest::CreateString(TDes& aString)

	{

	for (TInt i(0) ; i < 10 ; ++i)

		{

		// Add random upper and lower case letters

		aString.Append( 'A' + (Math::Rand(iSeed) % 26) );

		}

	}

TBool CTzUserDataTest::CompareArray(const RPointerArray<CTzId>& aIds1, const RPointerArray<CTzId>& aIds2)

	{

	TInt count1 = aIds1.Count();

	TInt count2 = aIds2.Count();

	test(count1 == count2);

	TBool isEqual = ETrue;

	TInt ii=0;

	while(ii<count1 && isEqual)

		{

		isEqual = EFalse;

		for (TInt jj=0; jj<count2; ++jj)

			{

			if(aIds1[ii]==aIds2[jj])

				{

				isEqual = ETrue;

				break;	

				}

			}

		++ii;

		}

	return isEqual;

	}

TBool CTzUserDataTest::CompareNames(const CTzUserNames& aNames1, const CTzUserNames& aNames2)

	{

	if (aNames1.StandardName() !=  aNames2.StandardName())

		return EFalse; 

	if (aNames1.ShortStandardName() != aNames2.ShortStandardName())

		return EFalse;

	if (aNames1.DaylightSaveName() != aNames2.DaylightSaveName())

		return EFalse;

	if (aNames1.ShortDaylightSaveName() != aNames2.ShortDaylightSaveName())

		return EFalse;

	if (aNames1.CityName() != aNames2.CityName())

		return EFalse;

	if (aNames1.RegionName() != aNames2.RegionName())

		return EFalse;

	return ETrue;

	}

void CTzUserDataTest::TestUtcOffsetL(CTzId& aTzId, const CTzRules& rules, const RArray<TTime>& times, TInt aOffset, RTz& aRTz )

	{

	aRTz.SetTimeZoneL(aTzId);

	TInt count = times.Count();

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

		{

		test (aOffset == rules.GetOffsetL(times[ii], ETzUtcTimeReference));	

		TTime utc = times[ii];

		aRTz.ConvertToUniversalTime(utc);

		TTimeIntervalMinutes minutes;

		times[ii].MinutesFrom(utc, minutes);

		test (minutes == TTimeIntervalMinutes(aOffset));	

		}

	}

void CTzUserDataTest::TestDaylightSavingStateL(CTzId& aTzId, const RArray<TTime>& times, TBool aIsOn, RTz& aRTz)

	{

	aRTz.SetTimeZoneL(aTzId);

	TInt count = times.Count();

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

		{

		test (aIsOn == aRTz.IsDaylightSavingOnL(aTzId, times[ii]));

		}

	}

void CTzUserDataTest::ResetTzUserDataL()

	{

	RTz tz;

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

	CleanupClosePushL(tz);

	CTzUserData* userdata = CTzUserData::NewL(tz);

	CleanupStack::PushL(userdata);

	userdata->GetTzIdsL(iTzIds);

	TInt count = iTzIds.Count();

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

		{

		if(ii%KPrintFreq == 0)

			{

			test.Printf(_L("Deleted %d time zones in the database\n"), ii);

			}

		userdata->DeleteL(*iTzIds[ii]);	

		}

	CleanupStack::PopAndDestroy(2, &tz);

	iTzIds.ResetAndDestroy();

	}

CTzId* CTzUserDataTest::CreateUserDefinedTzL(TInt16 aStandardOffset,TInt16 aDSTOffset, TBool aCheck)

	{

	CTzRules* rules = CreateUserDefinedTzLC(aStandardOffset, aDSTOffset);

	CTzUserNames* names = CreateUserDefinedTzNamesLC();

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

	CleanupStack::PushL(id);

	if(aCheck)

		{

		CheckTimeZoneL(*id, *rules, *names);

		}

	CleanupStack::Pop(id);

	CleanupStack::PopAndDestroy(2, rules);

	return id;

	}

void CTzUserDataTest::CheckTimeZoneL(const CTzId& aId, const CTzRules& aRules, const CTzUserNames& aNames)

	{

	CTzRules* rulesGet = iUserData->ReadRulesL(aId);

	CleanupStack::PushL(rulesGet);

	test(aRules.IsEqualTo(*rulesGet));

	CleanupStack::PopAndDestroy(rulesGet);

	CTzUserNames* namesGet = iUserData->ReadNamesL(aId);

	CleanupStack::PushL(namesGet);

	test (CompareNames(aNames, *namesGet));

	CleanupStack::PopAndDestroy(namesGet);

	}

void CTzUserDataTest::CreateUserTzBasedOnLondonRuleL(RTz& aRTz, TTest aWhatToTest)

	{

	test.Next(_L("Test Creation user-defined time zone based on London rules"));

	//create a new rule which doesn't have DST saving.

	TTime start (TDateTime(2010, ESeptember, 0, 0, 0, 0, 0));

	TInt year = start.DateTime().Year();

	TMonth month = start.DateTime().Month();

	TInt day = start.DateTime().Day();

	TTzRule newrule(year, 9999, 0, 0, month,  ETzFixedDate, day,  0, ETzWallTimeReference, 120);

	//Get the existing london rule

	_LIT8(KTimeNone, "Europe/London");

	CTzId* londonId = CTzId::NewL(KTimeNone());

	CleanupStack::PushL(londonId);

	CTzRules* userrule = aRTz.GetTimeZoneRulesL(*londonId, 0, 9999, ETzUtcTimeReference);

	CleanupStack::PopAndDestroy(londonId); 

	//Use London rule to create a new user-defined rule

	TInt count = userrule->Count();

	//Since the last two rules (TTzRule objects one for summer rule one for winter rule) in existing database covers the years in which a new rule starts.

	//The client has to amend the ending years of those two rules before adding a new rule.

	//We set the ending year for last two rules to 2009 since the new rule starts on 2010

	TTzRule lastRule = (*userrule)[count-1];

	TDateTime dateTimeLast = lastRule.iTo.iTime.DateTime();

	dateTimeLast.SetYear(2009);

	lastRule.iTo.iTime = dateTimeLast;

	TTzRule lastSecondRule = (*userrule)[count-2];

	TDateTime dateTimeLastSecond = lastSecondRule.iTo.iTime.DateTime();

	dateTimeLastSecond.SetYear(2009);

	lastSecondRule.iTo.iTime = dateTimeLastSecond;

	CleanupStack::PushL(userrule);

	//Remove last two existing rules

	userrule->RemoveRule(count-1);

	userrule->RemoveRule(count-2);

	//Add two rules whoes ending years have been amended

	userrule->AddRuleL(lastRule);

	userrule->AddRuleL(lastSecondRule);

	//Add the new rule

	userrule->AddRuleL(newrule);

	//userrule->AddRuleL(newrule);//add the new rule which doesn't have DST

	CTzUserNames* newRuleNames = CreateUserDefinedTzNamesLC();

	CTzId* id = iUserData->CreateL(*userrule, *newRuleNames);

	CleanupStack::PushL(id);

	iTzIds.AppendL(id);

	CleanupStack::Pop(id);

	CheckTimeZoneL(*id, *userrule, *newRuleNames);

	CleanupStack::PopAndDestroy(newRuleNames);

	RArray<TTime> timesOn;

	CleanupClosePushL(timesOn);

	RArray<TTime> timesOff;

	CleanupClosePushL(timesOff);

	// Check UTC offset and DST.

	TTime check = TDateTime(1998, ESeptember, 0, 0, 0, 0, 0); 

	timesOn.AppendL(check);

	check = TDateTime(2005, ESeptember, 0, 0, 0, 0, 0);

	timesOn.AppendL(check);	

	check = TDateTime(2009, ESeptember, 0, 0, 0, 0, 0);

	timesOn.AppendL(check);

	check = TDateTime(2010, ESeptember, 0, 3, 0, 0, 0); 

	timesOff.AppendL(check);

	check = TDateTime(2015, ESeptember, 0, 3, 0, 0, 0);

	timesOff.AppendL(check);	

	check = TDateTime(2020, ESeptember, 0, 3, 0, 0, 0);

	timesOff.AppendL(check);

	if(aWhatToTest==ETimeConversion)

		{

		TestUtcOffsetL(*id,*userrule, timesOn, 60, aRTz);

		TestUtcOffsetL(*id,*userrule, timesOff, 0, aRTz);

		}

	else if(aWhatToTest==EDayLightSave)

		{

		TestDaylightSavingStateL(*id, timesOn, ETrue, aRTz);

		TestDaylightSavingStateL(*id, timesOff, EFalse, aRTz);

		}

	CleanupStack::PopAndDestroy(3, userrule);	

	}

void CTzUserDataTest::CreateUserTzBasedOnShanghaiRuleL(RTz& aRTz, TTest aWhatToTest)

	{

	_LIT8(KTimeNone, "Asia/Shanghai");

	CTzId* shanghaiId = CTzId::NewL(KTimeNone());

	CleanupStack::PushL(shanghaiId);

	CTzRules* shanghaiRule = aRTz.GetTimeZoneRulesL(*shanghaiId, 0, 9999, ETzUtcTimeReference);

	CleanupStack::PopAndDestroy(shanghaiId); 

	// Last rule: 00:00:000 Date:1/01/1987  Time: 23:59:59:000 Date:31/12/1991  Old=480 New=540 Ch=0  

	TTime dston (TDateTime(2010, EMarch, 0, 0, 0, 0, 0)); 

	TTime dstoff (TDateTime(2010, ESeptember, 0, 0, 0, 0, 0));

	TMonth monthOn = dston.DateTime().Month();

	TInt dayOn = dston.DateTime().Day();

	TMonth monthOff = dstoff.DateTime().Month();

	TInt dayOff = dstoff.DateTime().Day();

	test.Next(_L("Test Creation user-defined time zone based on Shanghai rules"));

	TTzRule dstOn(2010, 9999, 480, 540, monthOn,  ETzFixedDate, dayOn,  0, ETzWallTimeReference, 120);

	TTzRule dstOff (2010, 9999, 540, 480, monthOff, ETzFixedDate, dayOff, 0, ETzWallTimeReference, 120);

	CleanupStack::PushL(shanghaiRule);

	shanghaiRule->AddRuleL(dstOff);//add the new rule which have DST

	shanghaiRule->AddRuleL(dstOn);

	CTzUserNames* newRuleNames = CreateUserDefinedTzNamesLC();

	CTzId* id = iUserData->CreateL(*shanghaiRule, *newRuleNames);

	CleanupStack::PushL(id);

	iTzIds.AppendL(id);

	CleanupStack::Pop(id);

	CheckTimeZoneL(*id, *shanghaiRule, *newRuleNames);

	// Check UTC offset and DST.

	RArray<TTime> timesOn;

	CleanupClosePushL(timesOn);

	RArray<TTime> timesOff;

	CleanupClosePushL(timesOff);

	TTime check = TDateTime(1998, ESeptember, 0, 3, 0, 0, 0); 

	timesOff.AppendL(check);

	check = TDateTime(2005, ESeptember, 0, 3, 0, 0, 0);

	timesOff.AppendL(check);	

	check = TDateTime(2020, ESeptember, 0, 3, 0, 0, 0);

	timesOff.AppendL(check);

	check = TDateTime(2011, EAugust, 0, 0, 0, 0, 0); 

	timesOn.AppendL(check);

	check = TDateTime(2015, EAugust, 0, 0, 0, 0, 0);

	timesOn.AppendL(check);	

	check = TDateTime(2020, EAugust, 0, 0, 0, 0, 0);

	timesOn.AppendL(check);

	if(aWhatToTest==ETimeConversion)

		{

		TestUtcOffsetL(*id,*shanghaiRule, timesOn, 540, aRTz);

		TestUtcOffsetL(*id,*shanghaiRule, timesOff, 480, aRTz);

		}

	else if(aWhatToTest==EDayLightSave)

		{

		TestDaylightSavingStateL(*id, timesOn, ETrue, aRTz);

		TestDaylightSavingStateL(*id, timesOff, EFalse, aRTz);

		}

	CleanupStack::PopAndDestroy(4, shanghaiRule);

	}	

CTzRules* CTzUserDataTest::CreateUserDefinedTzLC(TInt16 aStandardOffset,TInt16 aDSTOffset)

	{

	TTime dston (TDateTime(2005, EMarch, 0, 0, 0, 0, 0)); 

	TTime dstoff (TDateTime(2005, ESeptember, 0, 0, 0, 0, 0));

	TMonth monthOn = dston.DateTime().Month();

	TInt dayOn = dston.DateTime().Day();

	TMonth monthOff = dstoff.DateTime().Month();

	TInt dayOff = dstoff.DateTime().Day();

	TTzRule dstOff(0, 9999, aStandardOffset, aDSTOffset, monthOn,  ETzFixedDate, dayOn,  0, ETzWallTimeReference, 120);

	TTzRule dstOn (0, 9999, aDSTOffset, aStandardOffset, monthOff, ETzFixedDate, dayOff, 0, ETzWallTimeReference, 120);

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

	CleanupStack::PushL(rules);

	rules->AddRuleL(dstOff);

	rules->AddRuleL(dstOn);

	return rules;

	}

CTzUserNames* CTzUserDataTest::CreateUserDefinedTzNamesLC()

	{

	TBuf<10> standardName;

	CreateString(standardName);

	TBuf<10> shortStandardName;

	CreateString(shortStandardName);

	TBuf<10> dayLightSaveName;

	CreateString(dayLightSaveName);

	TBuf<10> shortDayLightSaveName;

	CreateString(shortDayLightSaveName);

	TBuf<10> cityName;

	CreateString(cityName);

	TBuf<10> regionName;

	CreateString(regionName);

	return CTzUserNames::NewLC(standardName, shortStandardName, dayLightSaveName, shortDayLightSaveName, cityName, regionName);

	}

void CTzUserDataTest::CreateTzAndCheckL(TInt aOldOffset, TInt aNewOffset, RTz& aRTz, TTest aWhatToTest)