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

#include "caltestlib.h"

#include <calentry.h>

#include <calentryview.h>

#include <calsession.h>

#include <calrrule.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <vtzrules.h> 

#include <vcal.h>

_LIT(KTestName,"tcal_tz_basic");

_LIT8(KLondon,"Europe/London");

_LIT8(KTokyo,"Asia/Tokyo");

_LIT8(KHelsinki,"Europe/Helsinki");

GLDEF_C RTest test(KTestName);

// The tests use the following start and end times so put them here

TDateTime startTime(2007, ENovember, 15, 19, 0, 0, 0);

TDateTime endTime(2007, ENovember, 15, 20, 0, 0, 0);

class CTCalBasicTest : public CBase

	{

public:

    static CTCalBasicTest* NewL();

	void RunAllTestsL();

	~CTCalBasicTest();	

private:

	void ConstructL();

	TCalLocalUid StoreEntryL(const TDesC8& aGuid, const TDesC8& aTimeZone, TBool aIsRepeating);

	CTzRules* GetTimeZoneRuleL(const TDesC8& aGuid);

	CTzRules* GetSystemTimeZoneRuleL();

	CCalEntry* CreateCalEntryCopyL(const TDesC8& aGuid, const TDesC8& aGuidCopy, CCalEntry::TCopyType aCopyType=CCalEntry::ECopyAll);

	void GetEntryTzRuleAndCheckL(CTzRules& aTzRule, const TDesC8& aGuid);

	void DeleteEntryL(const TDesC8& aGuid);

//test cases

	void TestSettingTzRuleL();

	void TestCopyEntryL(CCalEntry::TCopyType aCopyType);

	void TestUpdateEntryL();

	void TestInstanceViewL(TDateTime& aStartTime, TDateTime& aEndTime, TInt aNumInstance);

	void TestTzInstancesL();

	void TestImportExportL();

private:

	CCalTestLibrary* iTestLib;

	RTz iTz;

	};

CTCalBasicTest* CTCalBasicTest::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTCalBasicTest::ConstructL()

	{

	iTestLib = CCalTestLibrary::NewL();

	iTestLib->ReplaceFileL(KTestName);

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

	}

CTCalBasicTest::~CTCalBasicTest()	

	{

	iTz.Close();

	TRAPD(err, iTestLib->DeleteFileL(KTestName, ETrue));

	delete iTestLib;

	}

TCalLocalUid  CTCalBasicTest::StoreEntryL(const TDesC8& aGuid, const TDesC8& aTimeZone, TBool aIsRepeating)

	{

	iTestLib->SetTimeZoneL(aTimeZone);

	RPointerArray<CCalEntry> entries;

	CleanupResetAndDestroyPushL(entries);

	HBufC8* guid = aGuid.AllocLC();

	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0); //non-repeating entry NewL

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	entries.AppendL(entry);

	CleanupStack::Pop(entry);

	//set Calendar times with values local to the current system time zone

	TCalTime startCalTime;

	TCalTime endCalTime;

	startCalTime.SetTimeLocalL(startTime);

	endCalTime.SetTimeLocalL(endTime);

	//Set Entry Times

	entry->SetStartAndEndTimeL(startCalTime, endCalTime);

	// Set Summary(200characters)

	_LIT(KSummary,"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqr");

	entry->SetSummaryL(KSummary);

	// Set Description(600characters)

	_LIT(KDescription,"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzab");

	entry->SetDescriptionL(KDescription);

	if(aIsRepeating)

		{

		// Set the repeat rule

		TCalRRule rptRule(TCalRRule::EDaily);

		rptRule.SetDtStart(startCalTime);

		entry->SetRRuleL(rptRule);

		}

	//Save the entry into the view

	TInt entriesStored(0);

	iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);

	test(entries.Count()==entriesStored);

	TCalLocalUid calLocalUid =  entries[0]->LocalUidL();

    CleanupStack::PopAndDestroy(&entries);

    return calLocalUid;

	}

CTzRules* CTCalBasicTest::GetSystemTimeZoneRuleL()

	{

	CTzId*  tzId = iTz.GetTimeZoneIdL();

	CleanupStack::PushL(tzId);

	CTzRules* systemTimeZoneRules = iTz.GetTimeZoneRulesL(*tzId, 0, 9999, ETzUtcTimeReference);

	CleanupStack::PopAndDestroy(tzId);

	return systemTimeZoneRules;

	}

CTzRules* CTCalBasicTest::GetTimeZoneRuleL(const TDesC8& aGuid)

	{

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iTestLib->SynCGetEntryViewL().FetchL(aGuid, entryArray);

	CTzRules* tzRules = entryArray[0]->TzRulesL();

	CleanupStack::PopAndDestroy(&entryArray);

	return tzRules;

	}

CCalEntry* CTCalBasicTest::CreateCalEntryCopyL(const TDesC8& aGuid, const TDesC8& aGuidCopy, CCalEntry::TCopyType aCopyType)

	{

	HBufC8* guid = aGuidCopy.AllocLC();

	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0); //non-repeating entry NewL

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iTestLib->SynCGetEntryViewL().FetchL(aGuid, entryArray);

	CCalEntry* storedEntry = entryArray[0];

	entry->CopyFromL(*storedEntry, aCopyType);

	CleanupStack::PopAndDestroy(&entryArray);

	CleanupStack::Pop(entry);

	return entry;

	}

void CTCalBasicTest::DeleteEntryL(const TDesC8& aGuid)

	{

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iTestLib->SynCGetEntryViewL().FetchL(aGuid, entryArray);

	test (entryArray.Count() == 1); //There should only be a single entry

	CCalEntry* calEntry = entryArray[0];

	iTestLib->SynCGetEntryViewL().DeleteL(*calEntry);

	CleanupStack::PopAndDestroy(&entryArray);

	}

void CTCalBasicTest::TestSettingTzRuleL()

	{

	test.Next(_L("Test setting a Tz rule"));

//	Create and store an entry

//	Fetch the entry and store its time zone rule

//	shutdown server

//	change the time zone

//	open the calendar and fetch the entry and check its time zone rule

	_LIT8(KEntryTz, "Check Tz Entry");

	iTestLib->OpenFileL(KTestName);

	TCalLocalUid  calLocalUid = StoreEntryL(KEntryTz(), KTokyo(), ETrue);

	CTzRules* systemTimeZoneRules = GetSystemTimeZoneRuleL();

	CleanupStack::PushL(systemTimeZoneRules);

	GetEntryTzRuleAndCheckL(*systemTimeZoneRules, KEntryTz());

	iTestLib->CloseAgendaServer();

	iTestLib->SetTimeZoneL(KLondon());

	iTestLib->OpenFileL(KTestName);

	GetEntryTzRuleAndCheckL(*systemTimeZoneRules, KEntryTz());

	CleanupStack::PopAndDestroy(systemTimeZoneRules);

	}

void CTCalBasicTest::TestCopyEntryL(CCalEntry::TCopyType aCopyType)

	{

	test.Next(_L("Test copying entries with Tz rules"));

	_LIT8(KEntryTzOrig, "An appointment");

	_LIT8(KEntryTzCopy, "An appointment copy");

	iTestLib->CleanDatabaseL();

	iTestLib->OpenFileL(KTestName);

	TCalLocalUid  calLocalUid = StoreEntryL(KEntryTzOrig(), KTokyo(), ETrue);

	//Make a copy of the time zone rules from the system

	CTzRules* systemTimeZoneRules = GetSystemTimeZoneRuleL();

	CleanupStack::PushL(systemTimeZoneRules);

	//Change the time zone

	iTestLib->SetTimeZoneL(KLondon());

	CCalEntry* calEntry = CreateCalEntryCopyL(KEntryTzOrig(), KEntryTzCopy(), aCopyType);

	CleanupStack::PushL(calEntry);

	iTestLib->StoreEntryL(*calEntry);

	CleanupStack::PopAndDestroy(calEntry);

	iTestLib->CloseAgendaServer();

	iTestLib->OpenFileL(KTestName);

	GetEntryTzRuleAndCheckL(*systemTimeZoneRules, KEntryTzOrig());

	TDateTime startTimeInstance(2007, ENovember, 15, 0, 0, 0, 0);

    TDateTime endTimeInstance(2007, ENovember, 25, 0, 0, 0, 0);

	if (aCopyType == CCalEntry::EDontCopyId)

		{

		test.Printf(_L("EDontCopyId is tested, there should be 20 instances\n"));

		GetEntryTzRuleAndCheckL(*systemTimeZoneRules, KEntryTzCopy());

		TestInstanceViewL(startTimeInstance, endTimeInstance, 20);

		}

	else

		{

		test.Printf(_L("ECopyAll is tested, there should be 10 instances\n"));

		GetEntryTzRuleAndCheckL(*systemTimeZoneRules, KEntryTzOrig());

		TestInstanceViewL(startTimeInstance, endTimeInstance, 10);

		}

	CleanupStack::PopAndDestroy(systemTimeZoneRules);

	}

void CTCalBasicTest::GetEntryTzRuleAndCheckL(CTzRules& aTzRule, const TDesC8& aGuid)

	{

	CTzRules* timeZoneRulesCopy = GetTimeZoneRuleL(aGuid);

	if (timeZoneRulesCopy)

		{

		CleanupStack::PushL(timeZoneRulesCopy);

		test (aTzRule.IsEqualTo(*timeZoneRulesCopy));

		CleanupStack::PopAndDestroy(timeZoneRulesCopy);

		}

	else

		{

		test (EFalse);

		}

	}

void CTCalBasicTest::TestInstanceViewL(TDateTime& aStartTime, TDateTime& aEndTime, TInt aNumInstance)

	{

	RPointerArray<CCalInstance> calInstances;

	CleanupResetAndDestroyPushL(calInstances);

	//set Calendar times with values local to the current system time zone

	TCalTime startCalTime;

	TCalTime endCalTime;

	startCalTime.SetTimeLocalL(aStartTime);

	endCalTime.SetTimeLocalL(aEndTime);

	CalCommon::TCalTimeRange timeRange(startCalTime, endCalTime);

	iTestLib->SynCGetInstanceViewL().FindInstanceL(calInstances, CalCommon::EIncludeAll, timeRange);

	test (calInstances.Count() == aNumInstance);

	CleanupStack::PopAndDestroy(&calInstances);

	}

void CTCalBasicTest::TestUpdateEntryL()

	{

	test.Next(_L("Test updating entries with Tz rules"));

	_LIT8(KUpdateEntry, "Entry to be Updated");

	iTestLib->CleanDatabaseL();

	CTzRules* systemTimeZoneRules = GetSystemTimeZoneRuleL();

	CleanupStack::PushL(systemTimeZoneRules);

	iTestLib->OpenFileL(KTestName);

	TCalLocalUid  calLocalUid = StoreEntryL(KUpdateEntry(), KTokyo(), EFalse); 

	//Change the time zone

	iTestLib->SetTimeZoneL(KLondon());

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iTestLib->SynCGetEntryViewL().FetchL(KUpdateEntry(), entryArray);

	TInt numEntries(0);

	//set Calendar times with values local to the current system time zone

	TCalTime startCalTime;

	startCalTime.SetTimeLocalL(startTime);

	TCalRRule rptRule(TCalRRule::EDaily);

	rptRule.SetDtStart(startCalTime);

	entryArray[0]->SetRRuleL(rptRule);// Set the repeat rule

	iTestLib->SynCGetEntryViewL().UpdateL(entryArray, numEntries);

	CleanupStack::PopAndDestroy(&entryArray);

	iTestLib->CloseAgendaServer();

	iTestLib->OpenFileL(KTestName);

	GetEntryTzRuleAndCheckL(*systemTimeZoneRules, KUpdateEntry());

	CleanupStack::PopAndDestroy(systemTimeZoneRules);

	}

void CTCalBasicTest::TestTzInstancesL()

	{

	test.Next(_L("Test creating and fetching instances with Tz rules"));

	_LIT8(KUpdateEntry, "Instances and delete");

	iTestLib->CleanDatabaseL();

	iTestLib->OpenFileL(KTestName);

//	Store an entry

	TCalLocalUid  calLocalUid = StoreEntryL(KUpdateEntry(), KTokyo(), ETrue);

//	Test the number of instances, set the time up to cover the period when the instances were set up

	TDateTime startTime(2007, ENovember, 15, 0, 0, 0, 0);

	TDateTime endTime(2007, ENovember, 25, 0, 0, 0, 0);

	TestInstanceViewL(startTime, endTime, 10);

//	Update the entry start time

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iTestLib->SynCGetEntryViewL().FetchL(KUpdateEntry(), entryArray);

	TInt numEntries(0);

	test.Printf(_L("Update entry to start the appointment 30 minutes later\n"));

	TDateTime startTimeNew(2007, ENovember, 15, 19, 30, 0, 0);

	TDateTime endTimeNew(2007, ENovember, 15, 20, 0, 0, 0);

	TCalTime startCalTime;

	TCalTime endCalTime;

	startCalTime.SetTimeLocalL(startTimeNew);

	endCalTime.SetTimeLocalL(endTimeNew);

	entryArray[0]->SetStartAndEndTimeL(startCalTime, endCalTime);

	iTestLib->SynCGetEntryViewL().UpdateL(entryArray, numEntries);

	CleanupStack::PopAndDestroy(&entryArray);

	iTestLib->SetTimeZoneL(KHelsinki());

//	Test the number of instances

	test.Printf(_L("Testing the number of instances, which should be 10\n"));

	TestInstanceViewL(startTime, endTime, 10);

//  Delete the entry

	DeleteEntryL(KUpdateEntry());

	TestInstanceViewL(startTime, endTime, 0);

//	Shutdown server

	iTestLib->CloseAgendaServer();

//	Check that there are no instances		

	iTestLib->OpenFileL(KTestName);

	TestInstanceViewL(startTime, endTime, 0);

	}

void CTCalBasicTest::TestImportExportL()

	{

	test.Next(_L("Test importing and exporting entries with Tz rules"));

	_LIT8(KImportExportEntryTokyo, "Import export test Tokyo");

	_LIT8(KImportExportEntryHelsinki, "Import export test Helsinki");

	_LIT8(KImportExportEntryLondon, "Import export test London");

	_LIT(KExportTzExportFile, "tcal_tz_basic.vcs");

	iTestLib->OpenFileL(KTestName);

	iTestLib->CleanDatabaseL();

	test.Printf(_L("Store several entries with different time zones\n"));

	TCalLocalUid  calLocalUidTokyo = StoreEntryL(KImportExportEntryTokyo(), KTokyo(), ETrue);

	TCalLocalUid  calLocalUidHelsinki = StoreEntryL(KImportExportEntryHelsinki(), KHelsinki(), ETrue);

	TCalLocalUid  calLocalUidLondon = StoreEntryL(KImportExportEntryLondon(), KLondon(), ETrue);

	// Retrieve them and keep a record of their time zone rules

	CTzRules* TokyoTzRule = GetTimeZoneRuleL(KImportExportEntryTokyo());

	CleanupStack::PushL(TokyoTzRule);

	CTzRules* HelsinkiTzRule = GetTimeZoneRuleL(KImportExportEntryHelsinki());

	CleanupStack::PushL(HelsinkiTzRule);

	CTzRules* LondonTzRule = GetTimeZoneRuleL(KImportExportEntryLondon());

	CleanupStack::PushL(LondonTzRule);

	// Export the entries

	test.Printf(_L("Export the entries\n"));

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	CCalEntry* calEntryTokyo = iTestLib->SynCGetEntryViewL().FetchL(calLocalUidTokyo);

	TTime tokyoStartTimeUtc = calEntryTokyo->StartTimeL().TimeUtcL();

	TTime tokyoStartTimeLocal = calEntryTokyo->StartTimeL().TimeLocalL();

	entryArray.AppendL(calEntryTokyo);

	CCalEntry* calEntryHelsinki = iTestLib->SynCGetEntryViewL().FetchL(calLocalUidHelsinki);

	TTime helsinkiStartTimeUtc = calEntryHelsinki->StartTimeL().TimeUtcL();

	TTime helsinkiStartTimeLocal = calEntryHelsinki->StartTimeL().TimeLocalL();

	entryArray.AppendL(calEntryHelsinki);

	CCalEntry* calEntryLondon = iTestLib->SynCGetEntryViewL().FetchL(calLocalUidLondon);

	TTime londonStartTimeUtc = calEntryLondon->StartTimeL().TimeUtcL();

	TTime londonStartTimeLocal = calEntryLondon->StartTimeL().TimeLocalL();

	entryArray.AppendL(calEntryLondon);

	iTestLib->ExportL(KExportTzExportFile(), entryArray);

	CleanupStack::PopAndDestroy(&entryArray);

//	Reset the Db

	iTestLib->CleanDatabaseL();

//	Import data from the exported file into the Db

	test.Printf(_L("Import the entries\n"));

	RPointerArray<CCalEntry> entryImportArray;

	CleanupResetAndDestroyPushL(entryImportArray);

	iTestLib->ImportL(KExportTzExportFile(), entryImportArray);

	test (entryImportArray.Count() == 3);

	test.Printf(_L("Store the entries\n"));

	TInt entriesStored(0);

	iTestLib->SynCGetEntryViewL().StoreL(entryImportArray, entriesStored);

	test(entryImportArray.Count()==entriesStored);

	CleanupStack::PopAndDestroy(&entryImportArray);

	CleanupStack::PopAndDestroy(3); //TokyoTzRule, HelsinkiTzRule, LondonTzRule

	}

void CTCalBasicTest::RunAllTestsL()

	{

	TestSettingTzRuleL();

	TestTzInstancesL();

	TestCopyEntryL(CCalEntry::ECopyAll);

	TestCopyEntryL(CCalEntry::EDontCopyId);

	TestUpdateEntryL();

	TestImportExportL();

	}

LOCAL_C void doMainL()

	{

	CTCalBasicTest* testManager = CTCalBasicTest::NewL();

	TRAPD(ret, testManager->RunAllTestsL());

	test(ret == KErrNone);

	delete testManager;

	}

/**

@SYMTestCaseID     PIM-TCAL-TZ-BASIC-0001

*/

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-TZ-BASIC-0001 tcal_tz_basic"));

	test.Title();

	CTrapCleanup* theCleanup = CTrapCleanup::New();

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

	CActiveScheduler::Install(scheduler);

	TRAPD(ret, doMainL());

	delete scheduler;

	test(ret == KErrNone);

	delete theCleanup;	

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return(KErrNone);

	}