// Copyright (c) 2005-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 "caltestlib.h"

#include <calentry.h>

#include <calentryview.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calrrule.h>

#include <calsession.h>

#include <e32test.h>

#include <vtzrules.h>

#include <calalarm.h>

#include <s32file.h>

#include <caliterator.h>

#include <caldataexchange.h>

#include <caldataformat.h>

RTest test(_L("tcal_tz"));

_LIT(KCalendarFile, "tcal_tz");

// Timezone constants

_LIT8(KEuropeLondon, "Europe/London");

_LIT8(KAsiaTokyo, "Asia/Tokyo");

_LIT8(KAsiaTaiwan, "Asia/Taiwan");

_LIT8(KAsiaBangkok, "Asia/Bangkok");

_LIT8(KEuropeStockholm, "Europe/Stockholm");

_LIT8(KEuropeHelsinki, "Europe/Helsinki");

_LIT8(KUsNewYork, "America/New_York");

_LIT8(KUsCentral, "US/Central");

_LIT8(KUsLosAngeles, "US/LosAngeles");

_LIT8(KEuropeTirane, "Europe/Tirane");

_LIT8(KPacificHonolulu, "Pacific/Honolulu");

// Watch out for confusion between this and

// the custom rule we create that matches this zone.

_LIT8(KPacificAuckland, "Pacific/Auckland");

// Time constants

const TDateTime KTokyoEntryTime(2005,EMarch,6,2,45,15,0);

const TDateTime KExpectedTokyoEntryTime(2005,EMarch,7,2,45,15,0);

class CTzTestManager : public CActive

	{

public:

	static CTzTestManager* NewLC();

	~CTzTestManager();

	void Start();

private:

	CTzTestManager();

	void ConstructL();

	void TestSetTimeZoneL(const TDesC8& aTimeZoneName);

	void TestSetAndGetTzRulesL();

	void TestRemoteRepeatL();

	void TestRepeatRuleTzSetupL(TBool aFloating, TBool aException = EFalse, TBool aRDate = EFalse);

	void TestRepeatRuleLocalTimeL();

	void TestRepeatRuleTzStartEndTimeL();

	void TestRepeatRuleTzStartEndTzRulesL();

	void TestRepeatRuleTzRulesL();

	void DefectTestL();

	void TestRDatesTzSetupL();

	void TestFloatingEntrySetupL(); // Create a floating entry in calendar

	void TestFloatingEntryCheckL(const TTime& aExpectedTime); // Check the previously stored floating entry

	void TestFloatingRepeatCheckL(); // Check the previously stored floating repeating entry

	void TestFloatingExceptionCheckL(); // Check the previously stored floating repeating entry with exception date

	void TestFloatingRDateCheckL(); // Check the previously stored floating repeating entry with RDate

	void TestForeignZoneRepeatRule1L();

	void TestForeignZoneRepeatRule2L();

	void TestLocalRepeatRuleL();

	void TestLocalRepeatRule2L();

	void TestLocalTimeZoneL();

	void TestAlarmTzUpdateSetupL();

	void TestAlarmTzUpdateCheckL();

	void SetupEventCrossingMidnightL();

	void CheckEventCrossingMidnightL();

	void CheckDSTThresholdL();

	void TestCopyRepeatRulesL();

	void TestExportTzRulesInHemisphereL(TBool aSouthernHemisphere);

	void ImportFloatingEntryL();

	void TestTimeModeL();

	void TestAlarmOffsetL();

	void CheckVcalImportFromS40L();

	void CheckUtcOffsetL(TCalTime& aTestLocalTime, TInt aExpectedOffset);

	void CheckEntryInTimeZoneL(const TTime& aExpectedTime);

	void TestCreateEntryWithMidnightInHomeTimeL(TBool aFloating = EFalse);

	void TestCreateEntryWithDstChangeL(TBool aFloating = EFalse);	

	// no copy constructor and assignment operator

	CTzTestManager(CTzTestManager& );

	CTzTestManager& operator = (const CTzTestManager& );

	void CheckIsAnInstanceInTimeModeL(const TTime& aLocalTime, TBool aFound = ETrue, TCalTime::TTimeMode aTimeMode = TCalTime::EFixedTimeZone);

	void CheckIsAnInstanceInSpecifiedZoneL(const TTime& aTime);

	void VerifyRulesL(const CTzRules& aRules,const TCalTime& aStartRange, const TCalTime& aEndRange);

	// from CActive

	void RunL();

	void DoCancel();

private:

	CCalTestLibrary*	iTestLibrary; // need a connection to a session to create a CCalEntry

	CCalEntry*			iCalEntry;

	TBuf8<256>			iCurrentTimeZone;

	TInt 				iTestStep;

	};

// Constructor/Destructor

CTzTestManager::CTzTestManager() : CActive(EPriorityLow)

	{

	CActiveScheduler::Add(this);

	}

CTzTestManager* CTzTestManager::NewLC()

	{

	CTzTestManager* self = new (ELeave) CTzTestManager;

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

void CTzTestManager::ConstructL()

	{

	iTestLibrary = CCalTestLibrary::NewL();

	iTestLibrary->ReplaceFileL(KCalendarFile());

	iTestLibrary->OpenFileL(KCalendarFile());

	iTestLibrary->PIMTestServer().GetTimeZoneL(iCurrentTimeZone);

	}

CTzTestManager::~CTzTestManager()

	{

	if (iTestLibrary && iCurrentTimeZone.Length())

		{

		TRAP_IGNORE(TestSetTimeZoneL(iCurrentTimeZone));

		}

	delete iCalEntry;

	delete iTestLibrary;

	}

void CTzTestManager::Start()

	{

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	if ( ! IsActive())

		{

		SetActive();

		}

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Test cases forming the Time Zone test suite

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void CTzTestManager::TestSetTimeZoneL(const TDesC8& aTimeZoneName)

	{

	iTestLibrary->SetTimeZoneL(aTimeZoneName);

	}

// TestRulesProvided: Creates a collection of TTzRule's and with it a CAgnTzZone. 

// Then it tests the time conversion methods in CAgnTzZone.

/** @SYMTestCaseID     PIM-TCAL-TZ-0002 */

void CTzTestManager::TestSetAndGetTzRulesL()

	{

	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0002 Running tcal_tz - TestSetAndGetTzRulesL")); 

	HBufC8* dummy = NULL;

	delete iCalEntry;

	iCalEntry = NULL;

	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

	// Create arbitrary tz rule - add one hour between March 81 and October 96

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

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

	TTzRule tRule3(0,KMaxTUint16,0,0,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,0);	

	CTzRules* tzRules = CTzRules::NewL(2003,2007);

	CleanupStack::PushL(tzRules); // PUSH

	tzRules->AddRuleL(tRule1);

	tzRules->AddRuleL(tRule2);

	tzRules->AddRuleL(tRule3);	

	// create weekly repeat rule every Tuesday from 1 May 05 to 1 Dec 05

	TDateTime dtStart(2005,EMay,0,10,0,0,0);

	TDateTime dtEnd(2005,EDecember,0,10,0,0,0);

	TTime dtStart1(dtStart);

	TTime dtEnd1(dtEnd);

	TCalTime startCalTime;

	TCalTime endCalTime;

	tzRules->ConvertToUtcL(dtStart1);

	startCalTime.SetTimeUtcL(dtStart1);

	tzRules->ConvertToUtcL(dtEnd1);

	startCalTime.SetTimeUtcL(dtEnd1);

	iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

	TCalRRule calRule(TCalRRule::EWeekly);

	calRule.SetDtStart(startCalTime);

	calRule.SetUntil(endCalTime);

	calRule.SetInterval(1);

	RArray<TDay> days;

	days.AppendL(ETuesday);

	calRule.SetByDay(days);

	iCalEntry->SetRRuleL(calRule);

	days.Reset();

	iCalEntry->SetTzRulesL(*tzRules);

	CTzRules* tzRules2 = iCalEntry->TzRulesL();

	CleanupStack::PushL(tzRules2);

	test(tzRules->Count() == tzRules2->Count());

	// Compare rules stored (tzRules) with rules retrieved (tzRules2)

	TInt count = tzRules->Count();

	TTzRule oneRule;

	TTzRule anotherRule;

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

		{

		oneRule = (*tzRules)[i];

		anotherRule = (*tzRules2)[i];

		test(oneRule.iFrom == anotherRule.iFrom);

		test(oneRule.iTo == anotherRule.iTo);

		test(oneRule.iOldLocalTimeOffset == anotherRule.iOldLocalTimeOffset);

		test(oneRule.iNewLocalTimeOffset == anotherRule.iNewLocalTimeOffset);

		test(oneRule.iMonth == anotherRule.iMonth);

		test(oneRule.iDayRule == anotherRule.iDayRule);

		test(oneRule.iDayOfMonth == anotherRule.iDayOfMonth);

		test(oneRule.iDayOfWeek == anotherRule.iDayOfWeek);

		test(oneRule.iTimeReference == anotherRule.iTimeReference);

		test(oneRule.iTimeOfChange == anotherRule.iTimeOfChange);

		}

	CleanupStack::PopAndDestroy(tzRules2);

	CleanupStack::PopAndDestroy(tzRules);

	delete iCalEntry;

	iCalEntry = NULL;

	}

void CTzTestManager::CheckEntryInTimeZoneL(const TTime& aExpectedTime)

	{

	// Check that instance dates and times are properly converted to local times

	TTime newTime = iCalEntry->StartTimeL().TimeLocalL();

	test(newTime == aExpectedTime);

	}

// Tests that the start time of an entry changes correctly in different time zones

// (using zone extracted from TZ server)

/** @SYMTestCaseID     PIM-TCAL-TZ-0003 */

void CTzTestManager::TestRemoteRepeatL()

	{

	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0003 Running tcal_tz - TestRemoteRepeatL")); 	

	HBufC8* dummy = NULL;

	delete iCalEntry;

	iCalEntry = NULL;

	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

	// create rule repeating every Monday from 7 Mar 05 to 7 Dec 05

	TDateTime dtEnd(2005,EDecember,6,10,0,0,0);

	TCalTime startCalTime;

	TCalTime endCalTime;

	// OK to use SetTimeLocal, since we are using SetTzRulesL();

	startCalTime.SetTimeLocalL(KTokyoEntryTime);

	endCalTime.SetTimeLocalL(dtEnd);

	iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

	TCalRRule calRule(TCalRRule::EWeekly);

	calRule.SetDtStart(startCalTime);

	calRule.SetUntil(endCalTime);

	calRule.SetInterval(1);

	RArray<TDay> days;

	days.AppendL(EMonday);

	calRule.SetByDay(days);

	days.Reset();

	iCalEntry->SetRRuleL(calRule);	

	iCalEntry->SetTzRulesL();

	}

/** @SYMTestCaseID     PIM-TCAL-TZ-0004 */

void CTzTestManager::TestFloatingEntrySetupL()

	{

	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0004 Running tcal_tz - TestFloatingEntrySetupL")); 

	iTestLibrary->CleanDatabaseL();

	delete iCalEntry;

	iCalEntry = NULL;

	HBufC8* dummy = NULL;

	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

	// create rule repeating every Tuesday from 7 Mar 05 to 7 Dec 05

	TDateTime dtEnd(2005,EDecember,6,10,0,0,0);

	TCalTime startCalTime;

	TCalTime endCalTime;

	startCalTime.SetTimeLocalFloatingL(KTokyoEntryTime);

	endCalTime.SetTimeLocalFloatingL(dtEnd);

	iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	entryArray.AppendL(iCalEntry);

	TInt entriesAdded = 0;

	iTestLibrary->SynCGetEntryViewL().StoreL(entryArray, entriesAdded);

	CleanupStack::PopAndDestroy(&entryArray);	

	}

void CTzTestManager::TestFloatingEntryCheckL(const TTime& aExpectedTime)

	{

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iTestLibrary->SynCGetEntryViewL().FetchL(iCalEntry->UidL(), entryArray);

	// Check that entry dates and times are properly converted to local times

	test(entryArray.Count() == 1);

	TTime newTime = entryArray[0]->StartTimeL().TimeLocalL();

	test(newTime == aExpectedTime);

	CleanupStack::PopAndDestroy(&entryArray);

	}

/** @SYMTestCaseID     PIM-TCAL-TZ-0005 */

void CTzTestManager::TestRepeatRuleTzSetupL(TBool aFloating, TBool aException, TBool aRDate)

	{

	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0005 Running tcal_tz - TestRepeatRuleTzL")); 	

	CCalEntryView& entryView = iTestLibrary->SynCGetEntryViewL();

	if (aFloating)

		{

		entryView.DeleteL(*iCalEntry);

		}

	delete iCalEntry;

	iCalEntry = NULL;

	HBufC8* dummy = NULL;

	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

	TTime dtStart(TDateTime(2005, EJanuary, 0, 9, 0, 0, 0));

	TTime dtEnd(TDateTime(2005, EDecember, 30, 9, 0, 0, 0));

	TCalTime startCalTime;

	TCalTime endCalTime;

	if (aFloating)

		{

		// Create a floating repeat entry in Auckland timezone

		// create rule repeating every 2 days from 9am (local time)

		startCalTime.SetTimeLocalFloatingL(dtStart);

		endCalTime.SetTimeLocalFloatingL(dtEnd);

		TCalRRule rpt(TCalRRule::EDaily);

		rpt.SetDtStart(startCalTime);

		rpt.SetUntil(endCalTime);

		rpt.SetInterval(2);

		iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

		// add the repeat rule and the timezone rules to the entry

		iCalEntry->SetRRuleL(rpt);

		TRAPD(err, iCalEntry->SetTzRulesL());

		test(err == KErrArgument);

		}

	else

		{

		// set time zone to Auckland, NZ

		// DST ends on Sunday, 20 March 2005, 03:00 local daylight time 

		// DST starts on Sunday, 2 October 2005, 02:00 local standard time

		// create rule repeating every 2 days from 9am (NZ time)

		// fetch foreign rules from TZ server for Auckland

		RTz tz;

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

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

		CleanupStack::PushL(id);

		CTzRules* rules = tz.GetTimeZoneRulesL(*id, TDateTime(2000, EJanuary, 0, 0, 0, 0, 0), TDateTime(2010, EJanuary, 0, 0, 0, 0, 0), ETzUtcTimeReference);

		CleanupStack::PopAndDestroy(id);

		CleanupStack::PushL(rules);

		tz.Close();

		// convert to UTC for setting the calendar entry, because this is a foreign rule

		rules->ConvertToUtcL(dtStart);

		rules->ConvertToUtcL(dtEnd);

		startCalTime.SetTimeUtcL(dtStart);

		endCalTime.SetTimeUtcL(dtEnd);

		iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

		// create repeat rule

		TCalRRule rpt(TCalRRule::EDaily);

		rpt.SetDtStart(startCalTime);

		rpt.SetUntil(endCalTime);

		rpt.SetInterval(2);

		iCalEntry->SetRRuleL(rpt);

		iCalEntry->SetTzRulesL(*rules); // set tz rules to be local

		CleanupStack::PopAndDestroy(rules);

		}

	if (aException)

		{

		// Set 2 exceptions on the parent

		RArray<TCalTime> exArray;

		CleanupClosePushL(exArray);		

		TCalTime exTime1;

		exTime1.SetTimeLocalFloatingL(TDateTime(2005, EMarch, 23, 9, 0, 0, 0));	// March 24rd 9am

		exArray.Append(exTime1);

		TCalTime exTime2;

		exTime2.SetTimeLocalFloatingL(TDateTime(2005, ESeptember, 29, 9, 0, 0, 0));	// September 30th 9am

		exArray.Append(exTime2);

		iCalEntry->SetExceptionDatesL(exArray);

		RArray<TCalTime> exArray2;

		CleanupClosePushL(exArray2);

		iCalEntry->GetExceptionDatesL(exArray2);

		test(exArray.Count() == exArray2.Count());

		for (TInt i = 0; i < exArray.Count(); i++)

			{

			test(exArray[i].TimeMode() == exArray2[i].TimeMode());

			test(exArray[i].TimeLocalL() == exArray2[i].TimeLocalL());

			}

		CleanupStack::PopAndDestroy(); // reset exArray2

		CleanupStack::PopAndDestroy(); // reset exArray

		}

	if (aRDate)

		{

		// Set 2 sporadic dates on the parent

		RArray<TCalTime> rDateArray;

		CleanupClosePushL(rDateArray);

		TCalTime rDate1;

		rDate1.SetTimeLocalFloatingL(TDateTime(2004, EDecember, 2, 9, 0, 0, 0));

		rDateArray.Append(rDate1);

		TCalTime rDate2;

		rDate2.SetTimeLocalFloatingL(TDateTime(2006, EMarch, 23, 9, 0, 0, 0));

		rDateArray.Append(rDate2);

		iCalEntry->SetRDatesL(rDateArray);			

		CleanupStack::PopAndDestroy(); // reset rDateArray

		}

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	entryArray.AppendL(iCalEntry);

	TInt entriesAdded = 0;

	entryView.StoreL(entryArray, entriesAdded);

	CleanupStack::PopAndDestroy(&entryArray);

	}

/** @SYMTestCaseID     PIM-TCAL-TZ-0006 */

void CTzTestManager::TestRepeatRuleLocalTimeL()

	{

	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0006 Running tcal_tz - TestRepeatRuleLocalTimeL")); 

	//

	// Check instances are correct in local London time

	//

	// Local time zone is London, Repeat Rule has TzRules

	// similar to Pacific/Auckland.

	// London DST starts on 

	//  Sunday, 27 March 2005, 01:00 local daylight time 

	// London DST ends on 

	//  Sunday, 30 October 2005, 02:00 local standard time