--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappservices/calendar/tsrc/tcal_tz_basic.cpp	Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,492 @@
+// 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);
+	}
+