--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappservices/calendar/tsrc/tcal_dc.cpp	Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,1770 @@
+// Copyright (c) 2006-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:
+// tcal_dc - Test to ensure backwards compatibility between 9.1 and 9.2 Calendar files.
+// This test loads in files from v9.1 and v9.2 and verifies that they are converted correctly to v9.5.
+// 
+//
+
+// local includes
+#include "caltestlib.h"
+#include <calalarm.h>
+#include <calcategory.h>
+#include <calcategorymanager.h>
+#include <calcontent.h>
+#include <caldataformat.h>
+#include <caldataexchange.h>
+#include <calentry.h>
+#include <calentryview.h>
+#include <calinstance.h>
+#include <calinstanceview.h>
+#include <caliterator.h>
+#include <calsession.h>
+#include <caltime.h>
+#include <caluser.h>
+
+// System includes
+#include <e32test.h>
+#include <s32file.h>
+#include <calrrule.h>
+#include <vtzrules.h>
+
+// Uncomment out one of these line to regenerate the DC file from scratch against either v9.1 or v9.2 code
+// When running the test in v9.3, comment out both these lines.
+
+// Note that the .mmp file needs updating too.
+//#define __REGENERATE_9_1_DC_FILE__
+//#define __REGENERATE_9_2_DC_FILE__
+//#define __REGENERATE_9_4_DC_FILE__
+//#define __REGENERATE_9_5_DC_FILE__
+
+#if defined(__REGENERATE_9_1_DC_FILE__) || defined(__REGENERATE_9_2_DC_FILE__) || defined(__REGENERATE_9_4_DC_FILE__) || defined(__REGENERATE_9_5_DC_FILE__)
+#define __REGENERATE_DC_FILE__
+#endif
+
+#ifdef __REGENERATE_DC_FILE__
+
+#ifndef __REGENERATE_9_5_DC_FILE__
+#include "agmentry.h"
+#include "agmmodel.h"
+#include "..\..\agnmodel\agtest\agntestlibrary.h"
+#include <txtfmlyr.h>
+#endif
+
+_LIT(KCalendarFileToGenerate,"c:tcal_dc");
+#else
+
+_LIT(KCalendar81File,"tcal_dc_81");
+_LIT(KCalendar91File,"tcal_dc_91");
+_LIT(KCalendar92File,"tcal_dc_92");
+_LIT(KCalendar94File,"tcal_dc_94");
+_LIT(KCalendar95File,"tcal_dc_95");
+_LIT(KCalendar91LargeFile,"tcal_dc_91_1200");
+_LIT(KCalendar92CorruptFile,"tcal_dc_92_corrupt");
+
+#endif
+
+LOCAL_D RTest test(_L("tcal_dc"));
+
+const TDateTime KParentStartTDateTime(2006, EJanuary, 0, 0, 0, 0, 0);
+const TInt KParentDurationInHours = 2;
+
+_LIT(KParentLocation, "location 1");
+_LIT(KParentSummary, "summary 1");
+_LIT(KParentDescription, "description 1");
+
+_LIT(KParentAlarmName, "alarm name 1");
+_LIT8(KParentAlarmContent, "alarm content 1");
+_LIT8(KParentAlarmContentMimeType, "text/http");
+
+_LIT(KChildLocation, "location 2");
+_LIT(KChildSummary, "summary 2");
+_LIT(KChildDescription, "description 2");
+
+_LIT8(KGUID, "GUID");
+_LIT8(KWeeklyGUID, "weekly");
+_LIT8(KMonthlyByDayGUID, "monthly1");
+_LIT8(KMonthlyByDateGUID, "monthly2");
+_LIT8(KYearlyByDayGUID, "yearly1");
+_LIT8(KYearlyByDateGUID, "yearly2");
+
+const TDateTime KWeeklyStartTDateTime(2006, EJanuary, 2, 9, 0, 0, 0); // Tuesday
+const TDateTime KWeeklyUntilTDateTime(2006, EMarch, 3, 9, 0, 0, 0);
+
+const TDateTime KMonthlyByDayStartTDateTime(2006, EJanuary, 10, 9, 0, 0, 0); // second Wednesday
+const TDateTime KMonthlyByDayUntilTDateTime(2006, EOctober, 10, 9, 0, 0, 0);
+
+const TDateTime KMonthlyByDateStartTDateTime(2006, EJanuary, 24, 9, 0, 0, 0);
+const TDateTime KMonthlyByDateUntilTDateTime(2006, EAugust, 24, 9, 0, 0, 0);
+
+const TDateTime KYearlyByDayStartTDateTime(2006, EFebruary, 2, 9, 0, 0, 0); // 1st Fri in Feb
+const TDateTime KYearlyByDayUntilTDateTime(2008, EFebruary, 2, 9, 0, 0, 0);
+
+const TDateTime KYearlyByDateStartTDateTime(2006, EFebruary, 11, 9, 0, 0, 0);
+const TDateTime KYearlyByDateUntilTDateTime(2009, EFebruary, 11, 9, 0, 0, 0);
+
+const TDateTime	KEntryWithoutGuidTDateTime(2006, EApril, 17, 9, 0, 0, 0);
+
+const TDateTime KEntryAllPropLastModTDateTime(2006, EApril, 15, 12, 30, 2, 0);
+const TDateTime KEntryAllPropDTStampTDateTime(2006, EApril, 15, 13, 45, 0, 3);
+const TDateTime KEntryAllPropCompleteTDateTime(2006, EApril, 15, 16, 58, 0, 0);
+const TDateTime KEntryAllPropRDate1TDateTime(2006, EMay, 0, 12, 0, 0, 0);
+const TDateTime KEntryAllPropRDate2TDateTime(2006, EMay, 1, 18, 0, 0, 0);
+	
+_LIT(KUserDefinedCategoryName, "user-defined category");
+_LIT(KUserDefinedCategoryName2, "another user-defined one");
+
+_LIT(KAttendeeAddress1, "address 1");
+_LIT(KAttendeeSentBy1, "me@me.com");
+
+_LIT(KAttendeeAddress2, "house");
+_LIT(KAttendeeSentBy2, "1234567890@zxcvbnm.com");
+
+_LIT(KAttendeeAddress3, "road");
+_LIT(KAttendeeSentBy3, "@@@@@");
+
+_LIT8(KPacificAuckland, "Pacific/Auckland");
+_LIT8(KGUIDAllProperties, "all-props");
+
+_LIT8(KNegativeAlarmGUID, "negative_alarm");
+const TDateTime KNegativeAlarmEventTime(2006, EApril, 12, 9, 0, 0, 0);
+const TInt KNegativeAlarmOffset = -180;
+
+_LIT8(KSamedayAlarmGUID, "sameday_alarm");
+const TDateTime KSamedayAlarmEventTime(2006, EApril, 12, 8, 0, 0, 0);
+const TInt KSamedayAlarmOffset = 180;
+
+_LIT8(KPreviousDayAlarmGUID, "prevday_alarm");
+const TDateTime KPreviousDayAlarmEventTime(2006, EApril, 12, 7, 0, 0, 0);
+const TInt KPreviousDayAlarmOffset = 1440;
+
+_LIT8(KLargeOffsetAlarmGUID, "largeoffset_alarm");
+const TDateTime KLargeOffsetAlarmEventTime(2006, EApril, 12, 5, 0, 0, 0);
+const TInt KLargeOffsetAlarmOffset = 12345;
+
+_LIT8(KMidnightAlarmGUID, "midnight_alarm");
+const TDateTime KMidnightAlarmEventTime(2006, EApril, 12, 6, 0, 0, 0);
+const TInt KMidnightAlarmOffset = 360;
+
+_LIT8(KFloatingAppt, "floating_appt");
+const TDateTime KFloatingApptStartTime(2005, EDecember, 0, 9, 0, 0, 0);
+const TDateTime KFloatingApptEndTime(2005, EDecember, 1, 9, 0, 0, 0);
+const TDateTime KFloatingApptUntilTime(2005, EDecember, 29, 9, 0, 0, 0);
+
+_LIT8(KFloatingTodo, "floating_todo");
+const TDateTime KFloatingTodoStartTime(2005, EDecember, 0, 12, 0, 0, 0);
+const TDateTime KFloatingTodoEndTime(2005, EDecember, 1, 12, 0, 0, 0);
+const TDateTime KFloatingTodoUntilTime(2005, EDecember, 29, 12, 0, 0, 0);
+
+//
+
+class CCalEntryTestApp : public CBase, public MCalProgressCallBack
+	{
+public:
+	~CCalEntryTestApp();
+
+	void DoTestsL();
+	
+	// from MCalProgressCallBack
+	void Progress(TInt aPercentageCompleted);
+	void Completed(TInt aError);
+	TBool NotifyProgress();
+	
+private:
+	void StoreEntryL(CCalEntry* aEntry);
+	void CopyToCDriveL(const TDesC& aFileName);
+	void OpenBlankFileL();
+
+ 	void CreateDCFileL();
+ 	void AddParentAndChildEntriesL(CCalEntry::TType aType); 	
+	void AddRepeatRuleTypesL();
+	void AddEntryWithoutGUIDL();
+	void AddEntryWithAllPropertiesSetL();
+	void AddAlarmedEntriesL();
+	void AddAlarmedEntryL(const TDesC8& aGuid, const TTime& aEventTime, TInt aOffset);
+	void AddFloatingEntriesL();
+	void AddFloatingEntryL(CCalEntry::TType aType, const TDesC8& aGuid, const TTime& aStartTime, const TTime& aEndTime, const TTime& aUntilTime);
+
+ 	void TestFileLoadedL(TBool aTestAlarmAction);
+ 	void TestFileLoadedV94L();
+ 	void TestFileLoadedV95L();
+ 	void TestParentAndChildEntriesL(TBool aTestAlarmAction, TBool aTodoStartTimeStored);
+ 	void TestRepeatRuleTypesL();
+	void TestEntryWithoutGUIDL();
+	void TestEntryWithAllPropertiesSetL(TBool aTestTimeZoneYears);
+	void TestAlarmedEntriesL();
+	void TestAlarmedEntryL(const TDesC8& aGuid, TInt aOffset);
+	void TestFloatingEntriesL();
+	void TestFloatingEntryL(const TDesC8& aGuid, const TTime& aStartTime, const TTime& aEndTime, const TTime& aUntilTime);
+
+#ifndef __REGENERATE_DC_FILE__
+	void TestCategoriesL(const TDesC& aFile);
+	void TestFilterCategoriesL();
+	void TestAddCategoriesL();
+	void TestDeleteCategoriesL();
+	void TestCategoryWithoutBuiltIndexesL();
+	void TestOpeningFileDuringConversionL();
+
+	// old v9.2 tests
+ 	void V92AddEntriesDCFileL();
+ 	void V92ReadEntriesDCFileL();
+ 	void V92AddEntriesL(CCalEntry::TType aType);
+ 	void V92UpdateEntriesL();
+ 	void V92Test92CalendarFileCleanL();
+	void V92Test92CalendarFileEntriesAddedL();
+	void V92Test91CalendarFileCleanL();
+	void V92Test91CalendarFileEntriesAddedL();
+#endif
+
+private:
+	CCalTestLibrary* iTestLib;
+	HBufC8* iFileName;
+	TInt iErr;
+	};
+	
+//
+
+void CCalEntryTestApp::Progress(TInt )
+	{
+	}
+	
+void CCalEntryTestApp::Completed(TInt aError)
+	{
+	iErr = aError;
+	CActiveScheduler::Stop();
+	}
+
+TBool CCalEntryTestApp::NotifyProgress()
+	{
+	return EFalse;
+	}
+	
+void CCalEntryTestApp::CreateDCFileL()
+	{
+	// Create a number of entries to test DC.
+	// Repeating alarmed entry of each type with summary, location, description and alarm action, and a child entry
+	
+	AddEntryWithoutGUIDL();
+	
+	AddParentAndChildEntriesL(CCalEntry::EAppt);
+	AddParentAndChildEntriesL(CCalEntry::EEvent);
+	AddParentAndChildEntriesL(CCalEntry::EAnniv);
+	AddParentAndChildEntriesL(CCalEntry::EReminder);
+	AddParentAndChildEntriesL(CCalEntry::ETodo);
+	
+	AddRepeatRuleTypesL();
+	AddEntryWithAllPropertiesSetL();
+	AddAlarmedEntriesL();
+	AddFloatingEntriesL();
+	
+	TestFileLoadedL(EFalse);
+	}
+
+CCalEntryTestApp::~CCalEntryTestApp()
+	{
+	delete iTestLib;
+	}
+	
+void CCalEntryTestApp::TestFileLoadedL(TBool aTestAlarmAction)
+	{
+	test.Printf(_L("Checking calendar entry data...\n"));
+ 	TestParentAndChildEntriesL(aTestAlarmAction, EFalse);
+ 	TestRepeatRuleTypesL();
+	TestEntryWithoutGUIDL();
+	TestEntryWithAllPropertiesSetL(ETrue);
+	TestAlarmedEntriesL();
+	TestFloatingEntriesL();
+	}
+
+void CCalEntryTestApp::TestFileLoadedV94L()
+	{
+	test.Printf(_L("Checking calendar entry data...\n"));
+ 	TestParentAndChildEntriesL(ETrue, EFalse);
+ 	TestRepeatRuleTypesL();
+	TestEntryWithoutGUIDL();
+	TestEntryWithAllPropertiesSetL(EFalse);
+	TestAlarmedEntriesL();
+	TestFloatingEntriesL();
+	}
+
+void CCalEntryTestApp::TestFileLoadedV95L()
+	{
+	test.Printf(_L("Checking calendar entry data...\n"));
+ 	TestParentAndChildEntriesL(ETrue, ETrue);
+ 	TestRepeatRuleTypesL();
+	TestEntryWithAllPropertiesSetL(EFalse);
+	TestAlarmedEntriesL();
+	TestFloatingEntriesL();
+	}
+
+void CCalEntryTestApp::StoreEntryL(CCalEntry* aEntry)
+	{
+	RPointerArray<CCalEntry> entryArray;
+	CleanupClosePushL(entryArray);
+	TInt success = 0;
+	entryArray.AppendL(aEntry);
+	iTestLib->SynCGetEntryViewL().StoreL(entryArray, success);
+	CleanupStack::PopAndDestroy(&entryArray);
+	}
+	
+void CCalEntryTestApp::AddParentAndChildEntriesL(CCalEntry::TType aType)
+	{
+	TTime startTime = TTime(KParentStartTDateTime) + TTimeIntervalDays(aType);
+	
+	TBuf8<64> buffer;
+	buffer.Copy(KGUID);
+	buffer.AppendNum(aType);
+	HBufC8* hBuf = buffer.AllocLC();
+	CCalEntry* parentEntry = iTestLib->CreateCalEntryL(aType, hBuf);
+	CleanupStack::Pop(hBuf);
+	CleanupStack::PushL(parentEntry);
+	
+	TCalTime calStartTime, calEndTime;
+	calStartTime.SetTimeLocalL(startTime);
+	calEndTime.SetTimeLocalL(startTime + TTimeIntervalHours(KParentDurationInHours));
+	parentEntry->SetStartAndEndTimeL(calStartTime, calEndTime);
+	
+	parentEntry->SetLocationL(KParentLocation);
+	parentEntry->SetSummaryL(KParentSummary);
+	parentEntry->SetDescriptionL(KParentDescription);
+
+	CCalAlarm* alarm = CCalAlarm::NewL();
+	CleanupStack::PushL(alarm);
+	alarm->SetAlarmSoundNameL(KParentAlarmName);
+	alarm->SetTimeOffset(TTimeIntervalMinutes(5));
+	
+#ifndef __REGENERATE_9_1_DC_FILE__
+	CCalContent* alarmContent = CCalContent::NewL();
+	CleanupStack::PushL(alarmContent);
+	
+	HBufC8* urlContentBuf = KParentAlarmContent().AllocLC();
+	HBufC8* urlTypeBuf = KParentAlarmContentMimeType().AllocLC();
+	
+	alarmContent->SetContentL(urlContentBuf, urlTypeBuf, CCalContent::EDispositionUrl);
+	
+	alarm->SetAlarmAction(alarmContent);
+	CleanupStack::Pop(urlTypeBuf);
+	CleanupStack::Pop(urlContentBuf);
+	CleanupStack::Pop(alarmContent);
+#endif // __REGENERATE_9_2_DC_FILE__
+	
+	parentEntry->SetAlarmL(alarm);
+	CleanupStack::PopAndDestroy(alarm);
+
+	TCalRRule rule(TCalRRule::EDaily);
+	rule.SetInterval(1);
+	rule.SetDtStart(calStartTime);
+	rule.SetCount(100);
+	parentEntry->SetRRuleL(rule);
+	
+	StoreEntryL(parentEntry);
+	CleanupStack::PopAndDestroy(parentEntry);
+	
+	// create child entry
+	hBuf = buffer.AllocLC();
+	CCalEntry* childEntry = CCalEntry::NewL(aType, hBuf, CCalEntry::EMethodNone, 0, calStartTime, CalCommon::EThisOnly);
+	CleanupStack::Pop(hBuf);
+	CleanupStack::PushL(childEntry);
+	
+	childEntry->SetStartAndEndTimeL(calStartTime, calStartTime);
+	childEntry->SetLocationL(KChildLocation);
+	childEntry->SetSummaryL(KChildSummary);
+	childEntry->SetDescriptionL(KChildDescription);
+	
+	StoreEntryL(childEntry);
+	CleanupStack::PopAndDestroy(childEntry);
+	}
+
+void CCalEntryTestApp::TestParentAndChildEntriesL(TBool aTestAlarmAction, TBool aTodoStartTimeStored)
+	{
+	// check parent / child entries
+	TCalTime startDate;
+	startDate.SetTimeLocalL(TCalTime::MinTime());
+	TCalTime endDate;
+	endDate.SetTimeLocalL(TCalTime::MaxTime());
+	
+	CalCommon::TCalTimeRange timeRange(startDate, endDate);
+	CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll|CalCommon::EIncludeRptsNextInstanceOnly;
+	
+	RPointerArray<CCalInstance> instanceArray;
+	iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceArray, filter, timeRange);
+	test(instanceArray.Count() > 0);
+	
+	TInt instancesChecked = 0;
+	for (TInt i = 0; i < instanceArray.Count(); i++)
+		{
+		CCalEntry* entry = &instanceArray[i]->Entry();
+		if (entry->UidL().Left(KGUID().Length()) == KGUID())
+			{
+			instancesChecked++;
+			TCalRRule rule;
+			if (entry->GetRRuleL(rule))
+				{
+				// must be parent entry
+				CCalEntry::TType type = entry->EntryTypeL();
+				
+				TTime expectedLocalStartTime = TTime(KParentStartTDateTime) + TTimeIntervalDays(type);
+				TTime expectedLocalEndTime = expectedLocalStartTime + TTimeIntervalHours(KParentDurationInHours);
+				
+				if (type == CCalEntry::ETodo && !aTodoStartTimeStored)
+					{
+					expectedLocalStartTime = expectedLocalEndTime;
+					}
+				else if (type == CCalEntry::EReminder)
+					{
+					expectedLocalEndTime = Time::NullTTime();
+					}
+				
+#ifndef __REGENERATE_9_5_DC_FILE__				
+				test(entry->StartTimeL().TimeLocalL() == expectedLocalStartTime);
+#endif
+				test(entry->EndTimeL().TimeLocalL() == expectedLocalEndTime);
+				
+				test(entry->LocationL() == KParentLocation());
+				test(entry->SummaryL() == KParentSummary());
+				test(entry->DescriptionL() == KParentDescription());
+				test(rule.Count() == 100);
+				CCalAlarm* alarm = entry->AlarmL();
+				test(alarm->AlarmSoundNameL() == KParentAlarmName());
+				test(alarm->TimeOffset() == TTimeIntervalMinutes(5)); 
+#ifndef __REGENERATE_9_1_DC_FILE__
+				if (aTestAlarmAction)
+					{
+					CCalContent* content = alarm->AlarmAction();
+					
+					test(content->Content() == KParentAlarmContent());
+					test(content->MimeType() == KParentAlarmContentMimeType());
+					}
+#endif
+				delete alarm;
+				}
+			else
+				{
+				test(entry->LocationL() == KChildLocation());
+				test(entry->SummaryL() == KChildSummary());
+				test(entry->DescriptionL() == KChildDescription());
+				}
+			}
+		}
+		
+	test(instancesChecked > 0);
+	test(instancesChecked == 10); // 5 of each entry type
+	
+	instanceArray.ResetAndDestroy();
+	}
+
+
+void CCalEntryTestApp::AddRepeatRuleTypesL()
+	{
+	// weekly
+	HBufC8* wkGuid = KWeeklyGUID().AllocLC();
+	CCalEntry* wkEntry = CCalEntry::NewL(CCalEntry::EAppt, wkGuid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(wkGuid);
+	CleanupStack::PushL(wkEntry);
+	
+	TCalTime wkStart, wkUntil;
+	wkStart.SetTimeLocalL(TTime(KWeeklyStartTDateTime));
+	wkUntil.SetTimeLocalL(TTime(KWeeklyUntilTDateTime));
+	wkEntry->SetStartAndEndTimeL(wkStart, wkStart);
+	
+	TCalRRule wkRule(TCalRRule::EWeekly);
+	wkRule.SetDtStart(wkStart);
+	wkRule.SetUntil(wkUntil);
+	
+	RArray<TDay> wkDays;
+	CleanupClosePushL(wkDays);
+	wkDays.AppendL(ETuesday);
+	wkRule.SetByDay(wkDays);
+	CleanupStack::PopAndDestroy(&wkDays); // wkDays.Close()
+
+	wkEntry->SetRRuleL(wkRule);
+	StoreEntryL(wkEntry);
+	CleanupStack::PopAndDestroy(wkEntry);
+	
+	// monthly by day
+	HBufC8* mn1Guid = KMonthlyByDayGUID().AllocLC();
+	CCalEntry* mn1Entry = CCalEntry::NewL(CCalEntry::EAppt, mn1Guid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(mn1Guid);
+	CleanupStack::PushL(mn1Entry);
+	
+	TCalTime mn1Start, mn1Until;
+	mn1Start.SetTimeLocalL(TTime(KMonthlyByDayStartTDateTime));
+	mn1Until.SetTimeLocalL(TTime(KMonthlyByDayUntilTDateTime));
+	mn1Entry->SetStartAndEndTimeL(mn1Start, mn1Start);
+	
+	TCalRRule mn1Rule(TCalRRule::EMonthly);
+	mn1Rule.SetDtStart(mn1Start);
+	mn1Rule.SetUntil(mn1Until);
+	
+	RArray<TCalRRule::TDayOfMonth> mn1Days;
+	CleanupClosePushL(mn1Days);
+	mn1Days.AppendL(TCalRRule::TDayOfMonth(EWednesday, 2));
+	mn1Rule.SetByDay(mn1Days);
+	CleanupStack::PopAndDestroy(&mn1Days); // mn1Days.Close()
+
+	mn1Entry->SetRRuleL(mn1Rule);
+	StoreEntryL(mn1Entry);
+	CleanupStack::PopAndDestroy(mn1Entry);
+	
+	// monthly by date
+	HBufC8* mn2Guid = KMonthlyByDateGUID().AllocLC();
+	CCalEntry* mn2Entry = CCalEntry::NewL(CCalEntry::EAppt, mn2Guid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(mn2Guid);
+	CleanupStack::PushL(mn2Entry);
+	
+	TCalTime mn2Start, mn2Until;
+	mn2Start.SetTimeLocalL(TTime(KMonthlyByDateStartTDateTime));
+	mn2Until.SetTimeLocalL(TTime(KMonthlyByDateUntilTDateTime));
+	mn2Entry->SetStartAndEndTimeL(mn2Start, mn2Start);
+	
+	TCalRRule mn2Rule(TCalRRule::EMonthly);
+	mn2Rule.SetDtStart(mn2Start);
+	mn2Rule.SetUntil(mn2Until);
+	
+	RArray<TInt> mn2Days;
+	CleanupClosePushL(mn2Days);
+	mn2Days.AppendL(24);
+	mn2Rule.SetByMonthDay(mn2Days);
+	CleanupStack::PopAndDestroy(&mn2Days); // mn2Days.Close()
+
+	mn2Entry->SetRRuleL(mn2Rule);
+	StoreEntryL(mn2Entry);
+	CleanupStack::PopAndDestroy(mn2Entry);
+	
+	// yearly by day
+	HBufC8* yr1Guid = KYearlyByDayGUID().AllocLC();
+	CCalEntry* yr1Entry = CCalEntry::NewL(CCalEntry::EAppt, yr1Guid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(yr1Guid);
+	CleanupStack::PushL(yr1Entry);
+	
+	TCalTime yr1Start, yr1Until;
+	yr1Start.SetTimeLocalL(TTime(KYearlyByDayStartTDateTime));
+	yr1Until.SetTimeLocalL(TTime(KYearlyByDayUntilTDateTime));
+	yr1Entry->SetStartAndEndTimeL(yr1Start, yr1Start);
+	
+	TCalRRule yr1Rule(TCalRRule::EYearly);
+	yr1Rule.SetDtStart(yr1Start);
+	yr1Rule.SetUntil(yr1Until);
+	
+	RArray<TCalRRule::TDayOfMonth> yr1Days;
+	CleanupClosePushL(yr1Days);
+	yr1Days.AppendL(TCalRRule::TDayOfMonth(EFriday, 1));
+	yr1Rule.SetByDay(yr1Days);
+	CleanupStack::PopAndDestroy(&yr1Days); // yr1Days.Close()
+
+	RArray<TMonth> yr1Months;
+	CleanupClosePushL(yr1Months);
+	yr1Months.AppendL(EFebruary);
+	yr1Rule.SetByMonth(yr1Months);
+	CleanupStack::PopAndDestroy(&yr1Months); // yr1Months.Close()
+	
+	yr1Entry->SetRRuleL(yr1Rule);
+	StoreEntryL(yr1Entry);
+	CleanupStack::PopAndDestroy(yr1Entry);
+	
+	// yearly by date
+	HBufC8* yr2Guid = KYearlyByDateGUID().AllocLC();
+	CCalEntry* yr2Entry = CCalEntry::NewL(CCalEntry::EAppt, yr2Guid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(yr2Guid);
+	CleanupStack::PushL(yr2Entry);
+	
+	TCalTime yr2Start, yr2Until;
+	yr2Start.SetTimeLocalL(TTime(KYearlyByDateStartTDateTime));
+	yr2Until.SetTimeLocalL(TTime(KYearlyByDateUntilTDateTime));
+	yr2Entry->SetStartAndEndTimeL(yr2Start, yr2Start);
+	
+	TCalRRule yr2Rule(TCalRRule::EYearly);
+	yr2Rule.SetDtStart(yr2Start);
+	yr2Rule.SetUntil(yr2Until);
+	
+	yr2Entry->SetRRuleL(yr2Rule);
+	StoreEntryL(yr2Entry);
+	CleanupStack::PopAndDestroy(yr2Entry);
+	}
+
+void CCalEntryTestApp::TestRepeatRuleTypesL()
+	{
+	// check repeat rule types
+	RPointerArray<CCalEntry> entries;
+	CleanupResetAndDestroyPushL(entries);
+	
+	iTestLib->SynCGetEntryViewL().FetchL(KWeeklyGUID, entries);
+	test(entries.Count() == 1);
+	TCalRRule weekly;
+	entries[0]->GetRRuleL(weekly);
+	test(weekly.Type() == TCalRRule::EWeekly);
+	test(weekly.DtStart().TimeLocalL() == KWeeklyStartTDateTime);
+	test(weekly.Until().TimeLocalL() == KWeeklyUntilTDateTime);
+	RArray<TDay> wkDays;
+	weekly.GetByDayL(wkDays);
+	test(wkDays.Count() == 1);
+	test(wkDays[0] == ETuesday);
+	wkDays.Close();
+	entries.ResetAndDestroy();
+	
+	iTestLib->SynCGetEntryViewL().FetchL(KMonthlyByDayGUID, entries);
+	test(entries.Count() == 1);
+	TCalRRule monthly1;
+	entries[0]->GetRRuleL(monthly1);
+	test(monthly1.Type() == TCalRRule::EMonthly);
+	test(monthly1.DtStart().TimeLocalL() == KMonthlyByDayStartTDateTime);
+	test(monthly1.Until().TimeLocalL() == KMonthlyByDayUntilTDateTime);
+	RArray<TCalRRule::TDayOfMonth> monthDays;
+	monthly1.GetByDayL(monthDays);
+	test(monthDays.Count() == 1);
+	test(monthDays[0].Day() == EWednesday);
+	test(monthDays[0].WeekInMonth() == 2);
+	monthDays.Close();
+	entries.ResetAndDestroy();
+	
+	iTestLib->SynCGetEntryViewL().FetchL(KMonthlyByDateGUID, entries);
+	test(entries.Count() == 1);
+	TCalRRule monthly2;
+	entries[0]->GetRRuleL(monthly2);
+	test(monthly2.Type() == TCalRRule::EMonthly);
+	test(monthly2.DtStart().TimeLocalL() == KMonthlyByDateStartTDateTime);
+	test(monthly2.Until().TimeLocalL() == KMonthlyByDateUntilTDateTime);
+	RArray<TInt> monthDates;
+	monthly2.GetByMonthDayL(monthDates);
+	test(monthDates.Count() == 1);
+	test(monthDates[0] == 24);
+	monthDates.Close();
+	entries.ResetAndDestroy();
+	
+	iTestLib->SynCGetEntryViewL().FetchL(KYearlyByDayGUID, entries);
+	test(entries.Count() == 1);
+	TCalRRule yearly1;
+	entries[0]->GetRRuleL(yearly1);
+	test(yearly1.Type() == TCalRRule::EYearly);
+	test(yearly1.DtStart().TimeLocalL() == KYearlyByDayStartTDateTime);
+	test(yearly1.Until().TimeLocalL() == KYearlyByDayUntilTDateTime);
+	RArray<TMonth> months;
+	yearly1.GetByMonthL(months);
+	test(months.Count() == 1);
+	test(months[0] == EFebruary);
+	months.Close();
+	RArray<TCalRRule::TDayOfMonth> yearlyDayOfMonths;
+	yearly1.GetByDayL(yearlyDayOfMonths);
+	test(yearlyDayOfMonths.Count() == 1);
+	test(yearlyDayOfMonths[0].Day() == EFriday);
+	test(yearlyDayOfMonths[0].WeekInMonth() == 1);
+	yearlyDayOfMonths.Close();
+	entries.ResetAndDestroy();
+	
+	iTestLib->SynCGetEntryViewL().FetchL(KYearlyByDateGUID, entries);
+	test(entries.Count() == 1);
+	TCalRRule yearly2;
+	entries[0]->GetRRuleL(yearly2);
+	test(yearly2.Type() == TCalRRule::EYearly);
+	test(yearly2.DtStart().TimeLocalL() == KYearlyByDateStartTDateTime);
+	test(yearly2.Until().TimeLocalL() == KYearlyByDateUntilTDateTime);
+	entries.ResetAndDestroy();
+
+	CleanupStack::PopAndDestroy(&entries);
+	}
+
+void CCalEntryTestApp::AddEntryWithoutGUIDL()
+	{
+#if defined(__REGENERATE_DC_FILE__) && !defined(__REGENERATE_9_5_DC_FILE__)
+	CAgnTest* agnTest = CAgnTest::NewLC();
+	CAgnEntryModel* model = agnTest->CreateModelL(CAgnTest::EEntry, KCalendarFileToGenerate());
+	model->OpenL(KCalendarFileToGenerate(), 0, 0, 0);
+	
+	CAgnAppt* appt = static_cast<CAgnAppt*>(agnTest->CreateEntryLC(CAgnEntry::EAppt));
+	appt->SetStartAndEndDateTime(KEntryWithoutGuidTDateTime, KEntryWithoutGuidTDateTime);
+	model->AddEntryL(appt);
+	CleanupStack::PopAndDestroy(appt);
+	
+	CleanupStack::PopAndDestroy(agnTest);
+#endif
+	}
+
+void CCalEntryTestApp::TestEntryWithoutGUIDL()
+	{
+#if ! defined(__REGENERATE_9_5_DC_FILE__)
+	// check entry without guid
+	TCalTime startDate;
+	startDate.SetTimeLocalL(TTime(KEntryWithoutGuidTDateTime));
+	RPointerArray<CCalInstance> instanceArray;
+	CleanupResetAndDestroyPushL(instanceArray);
+	iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceArray, CalCommon::EIncludeAll, CalCommon::TCalTimeRange(startDate, startDate));
+	test(instanceArray.Count() == 1);		
+	CCalEntry* entryWithoutGuid = &instanceArray[0]->Entry();
+	test(entryWithoutGuid != NULL);
+	TInt guidLength = entryWithoutGuid->UidL().Length();
+	test(guidLength > 0);
+	for (TInt i = 0; i < guidLength; i++)
+		{
+		TChar ch = entryWithoutGuid->UidL()[i];
+		test(ch >= '0' && ch <= '9');
+		}
+	test(entryWithoutGuid->StartTimeL().TimeLocalL() == KEntryWithoutGuidTDateTime);
+	CleanupStack::PopAndDestroy(); // instanceArray.ResetAndDestroy()
+#endif
+	}	
+
+void CCalEntryTestApp::AddEntryWithAllPropertiesSetL()
+	{
+	HBufC8* guid = KGUIDAllProperties().AllocLC();
+	CCalEntry* entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(guid);
+	CleanupStack::PushL(entry);
+	
+	TCalTime dtStamp, compTime, rDate1, rDate2;
+	dtStamp.SetTimeLocalL(TTime(KEntryAllPropDTStampTDateTime));
+	compTime.SetTimeLocalL(TTime(KEntryAllPropCompleteTDateTime));
+	rDate1.SetTimeLocalL(TTime(KEntryAllPropRDate1TDateTime));
+	rDate2.SetTimeLocalL(TTime(KEntryAllPropRDate2TDateTime));
+
+	entry->SetDTStampL(dtStamp);
+	entry->SetCompletedL(ETrue, compTime);
+	
+	RArray<TCalTime> rDateList;
+	CleanupClosePushL(rDateList);
+	rDateList.AppendL(rDate1);
+	rDateList.AppendL(rDate2);
+	entry->SetRDatesL(rDateList);
+	
+	rDateList.Remove(0);
+	entry->SetExceptionDatesL(rDateList);
+	CleanupStack::PopAndDestroy(&rDateList);
+	
+	CCalCategory* cat1 = CCalCategory::NewL(CCalCategory::ECalHoliday);
+	CleanupStack::PushL(cat1);
+	entry->AddCategoryL(cat1);
+	CleanupStack::Pop(cat1);
+
+	CCalCategory* cat2 = CCalCategory::NewL(KUserDefinedCategoryName());
+	CleanupStack::PushL(cat2);
+	entry->AddCategoryL(cat2);
+	CleanupStack::Pop(cat2);
+
+	CCalAttendee* att1 = CCalAttendee::NewL(KAttendeeAddress1(), KAttendeeSentBy1());
+	CleanupStack::PushL(att1);
+	entry->AddAttendeeL(att1);
+	CleanupStack::Pop(att1);
+
+	CCalAttendee* att2 = CCalAttendee::NewL(KAttendeeAddress2(), KAttendeeSentBy2());
+	CleanupStack::PushL(att2);
+	entry->AddAttendeeL(att2);
+	entry->SetPhoneOwnerL(att2);
+	CleanupStack::Pop(att2);
+
+	CCalAttendee* att3 = CCalAttendee::NewL(KAttendeeAddress3(), KAttendeeSentBy3());
+	CleanupStack::PushL(att3);
+	entry->SetOrganizerL(att3);
+	CleanupStack::Pop(att3);
+	
+	entry->SetReplicationStatusL(CCalEntry::ERestricted);
+	entry->SetPriorityL(66);
+	
+	TTime startTime = TDateTime(2003, EJanuary, 0, 0, 0, 0, 0);
+	TTime endTime = startTime + TTimeIntervalYears(5);
+	
+	RTz tzServer;
+	CleanupClosePushL(tzServer);
+	User::LeaveIfError(tzServer.Connect());
+	
+	CTzId* tzId = CTzId::NewL(KPacificAuckland());
+	CleanupStack::PushL(tzId);
+	
+	CTzRules* rules = tzServer.GetTimeZoneRulesL(*tzId, startTime, endTime, ETzWallTimeReference);
+	CleanupStack::PushL(rules);
+	entry->SetTzRulesL(*rules);
+	CleanupStack::PopAndDestroy(rules);
+	
+	CleanupStack::PopAndDestroy(tzId);
+	CleanupStack::PopAndDestroy(&tzServer);
+
+	StoreEntryL(entry);
+	CleanupStack::PopAndDestroy(entry);
+	}
+
+void CCalEntryTestApp::TestEntryWithAllPropertiesSetL(TBool aTestTimeZoneYears)
+	{
+	// check entry with all properties set
+	RPointerArray<CCalEntry> entries;
+	CleanupResetAndDestroyPushL(entries);
+	iTestLib->SynCGetEntryViewL().FetchL(KGUIDAllProperties(), entries);
+	test(entries.Count() == 1);
+	CCalEntry* entryAllProperties = entries[0];
+	TTime lastModTime = entryAllProperties->LastModifiedDateL().TimeLocalL();
+	test(lastModTime > TCalTime::MinTime() && lastModTime < TCalTime::MaxTime());
+	test(entryAllProperties->DTStampL().TimeLocalL() == TTime(KEntryAllPropDTStampTDateTime));
+	test(entryAllProperties->CompletedTimeL().TimeLocalL() == TTime(KEntryAllPropCompleteTDateTime));
+	
+	RArray<TCalTime> rdates;
+	CleanupClosePushL(rdates);
+	entryAllProperties->GetRDatesL(rdates);
+	test(rdates.Count() == 2);
+	test(rdates[0].TimeLocalL() == TTime(KEntryAllPropRDate1TDateTime));
+	test(rdates[1].TimeLocalL() == TTime(KEntryAllPropRDate2TDateTime));
+	rdates.Reset();
+	
+	entryAllProperties->GetExceptionDatesL(rdates);
+	test(rdates.Count() == 1);
+	test(rdates[0].TimeLocalL() == TTime(KEntryAllPropRDate2TDateTime));
+	CleanupStack::PopAndDestroy(&rdates);
+	
+	RPointerArray<CCalCategory> categories = entryAllProperties->CategoryListL();
+	test(categories.Count() == 2);
+	test(categories[0]->Category() == CCalCategory::ECalHoliday);
+	test(categories[1]->Category() == CCalCategory::ECalExtended);
+	test(categories[1]->ExtendedCategoryName() == KUserDefinedCategoryName());
+
+	RPointerArray<CCalAttendee> attendees = entryAllProperties->AttendeesL();
+	test(attendees.Count() == 2);
+	test(attendees[0]->Address() == KAttendeeAddress1());
+	test(attendees[0]->SentBy() == KAttendeeSentBy1());
+	test(attendees[1]->Address() == KAttendeeAddress2());
+	test(attendees[1]->SentBy() == KAttendeeSentBy2());
+
+	test(entryAllProperties->ReplicationStatusL() == CCalEntry::ERestricted);
+	test(entryAllProperties->PriorityL() == 66);
+	
+	if (aTestTimeZoneYears)
+		{
+#if !(defined(__REGENERATE_9_5_DC_FILE__) || defined(__REGENERATE_9_4_DC_FILE__))  
+		// years are different in PREQ1090
+		CTzRules* rules = entryAllProperties->TzRulesL();
+		CleanupStack::PushL(rules);
+		test(rules != NULL);
+		test(rules->StartYear() == 2003);
+		test(rules->EndYear() == 2008);
+		CleanupStack::PopAndDestroy(rules);
+#endif
+		}
+	CleanupStack::PopAndDestroy(&entries);
+	}
+
+void CCalEntryTestApp::AddAlarmedEntriesL()
+	{
+	AddAlarmedEntryL(KNegativeAlarmGUID, KNegativeAlarmEventTime, KNegativeAlarmOffset);
+	AddAlarmedEntryL(KSamedayAlarmGUID, KSamedayAlarmEventTime, KSamedayAlarmOffset);
+	AddAlarmedEntryL(KPreviousDayAlarmGUID, KPreviousDayAlarmEventTime, KPreviousDayAlarmOffset);
+	AddAlarmedEntryL(KLargeOffsetAlarmGUID, KLargeOffsetAlarmEventTime, KLargeOffsetAlarmOffset);
+	AddAlarmedEntryL(KMidnightAlarmGUID, KMidnightAlarmEventTime, KMidnightAlarmOffset);
+	}
+
+void CCalEntryTestApp::AddAlarmedEntryL(const TDesC8& aGuid, const TTime& aEventTime, TInt aOffset)
+	{
+	HBufC8* guid = aGuid.AllocLC();
+	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(guid);
+	CleanupStack::PushL(entry);
+	
+	TCalTime startTime;
+	if (aOffset < 0)
+		{
+		// negative offsets only valid on floating alarms
+		startTime.SetTimeLocalFloatingL(aEventTime);
+		}
+	else
+		{
+		startTime.SetTimeLocalL(aEventTime);
+		}
+	entry->SetStartAndEndTimeL(startTime, startTime);
+	
+	CCalAlarm* alarm = CCalAlarm::NewL();
+	CleanupStack::PushL(alarm);
+	alarm->SetTimeOffset(aOffset);
+	entry->SetAlarmL(alarm);
+	CleanupStack::PopAndDestroy(alarm);
+	
+	StoreEntryL(entry);
+	CleanupStack::PopAndDestroy(entry);
+	}
+	
+void CCalEntryTestApp::TestAlarmedEntriesL()
+	{
+	TestAlarmedEntryL(KNegativeAlarmGUID, KNegativeAlarmOffset);
+	TestAlarmedEntryL(KSamedayAlarmGUID, KSamedayAlarmOffset);
+	TestAlarmedEntryL(KPreviousDayAlarmGUID, KPreviousDayAlarmOffset);
+	TestAlarmedEntryL(KLargeOffsetAlarmGUID, KLargeOffsetAlarmOffset);
+	TestAlarmedEntryL(KMidnightAlarmGUID, KMidnightAlarmOffset);
+	}
+
+void CCalEntryTestApp::TestAlarmedEntryL(const TDesC8& aGuid, TInt aOffset)
+	{
+	RPointerArray<CCalEntry> entries;
+	CleanupResetAndDestroyPushL(entries);
+	
+	iTestLib->SynCGetEntryViewL().FetchL(aGuid, entries);
+	test(entries.Count() == 1);
+	CCalAlarm* alarm = entries[0]->AlarmL();
+	test(alarm->TimeOffset().Int()== aOffset);
+	delete alarm;
+	
+	CleanupStack::PopAndDestroy(&entries);
+	}
+
+void CCalEntryTestApp::AddFloatingEntriesL()
+	{
+	AddFloatingEntryL(CCalEntry::EAppt, KFloatingAppt(), KFloatingApptStartTime, KFloatingApptEndTime, KFloatingApptUntilTime);
+	AddFloatingEntryL(CCalEntry::ETodo, KFloatingTodo(), KFloatingTodoStartTime, KFloatingTodoEndTime, KFloatingTodoUntilTime);
+	}
+	
+void CCalEntryTestApp::AddFloatingEntryL(CCalEntry::TType aType, const TDesC8& aGuid, const TTime& aStartTime, const TTime& aEndTime, const TTime& aUntilTime)
+	{
+	HBufC8* guid = aGuid.AllocLC();
+	CCalEntry* entry = CCalEntry::NewL(aType, guid, CCalEntry::EMethodNone, 0);
+	CleanupStack::Pop(guid);
+	CleanupStack::PushL(entry);
+	
+	TCalTime startTime, endTime, untilTime;
+	startTime.SetTimeLocalFloatingL(aStartTime);
+	endTime.SetTimeLocalFloatingL(aEndTime);
+	untilTime.SetTimeLocalFloatingL(aUntilTime);
+	entry->SetStartAndEndTimeL(startTime, endTime);
+	
+	TCalRRule rule(TCalRRule::EDaily);
+	if (aType == CCalEntry::ETodo)
+		{
+		rule.SetDtStart(endTime);
+		}
+	else
+		{
+		rule.SetDtStart(startTime);
+		}
+	rule.SetUntil(untilTime);
+	entry->SetRRuleL(rule);
+	
+	StoreEntryL(entry);
+	CleanupStack::PopAndDestroy(entry);
+	}
+
+void CCalEntryTestApp::TestFloatingEntriesL()
+	{
+	TestFloatingEntryL(KFloatingAppt(), KFloatingApptStartTime, KFloatingApptEndTime, KFloatingApptUntilTime);
+	TestFloatingEntryL(KFloatingTodo(), KFloatingTodoStartTime, KFloatingTodoEndTime, KFloatingTodoUntilTime);	
+	}
+
+void CCalEntryTestApp::TestFloatingEntryL(const TDesC8& aGuid, const TTime& aStartTime, const TTime& aEndTime, const TTime& aUntilTime)
+	{
+	RPointerArray<CCalEntry> entries;
+	CleanupResetAndDestroyPushL(entries);
+	
+	iTestLib->SynCGetEntryViewL().FetchL(aGuid, entries);
+	test(entries.Count() == 1);
+	test(entries[0]->StartTimeL().TimeLocalL() == aStartTime);
+	test(entries[0]->EndTimeL().TimeLocalL() == aEndTime);
+	TCalRRule rule;
+	entries[0]->GetRRuleL(rule);
+	test(rule.Until().TimeLocalL() == aUntilTime);
+	
+	test(entries[0]->StartTimeL().TimeMode() == TCalTime::EFloating);
+	test(entries[0]->EndTimeL().TimeMode() == TCalTime::EFloating);
+#ifndef __REGENERATE_DC_FILE__
+	test(rule.Until().TimeMode() == TCalTime::EFloating);
+#endif 
+	
+	CleanupStack::PopAndDestroy(&entries);
+	}
+
+#ifndef __REGENERATE_DC_FILE__
+void CCalEntryTestApp::TestCategoriesL(const TDesC& aFile)
+	{
+	CalCommon::TCalFileVersionSupport status;
+	
+	CopyToCDriveL(aFile);
+	test.Printf(_L("Testing Using Categories without building indexes...\n"));
+	iTestLib->GetSession().OpenL(aFile, status);
+	TestCategoryWithoutBuiltIndexesL();
+	
+	CopyToCDriveL(aFile);
+	test.Printf(_L("Testing Filtering Categories...\n"));
+	iTestLib->GetSession().OpenL(aFile, status);
+	iTestLib->SynCGetEntryViewL();
+	TestFilterCategoriesL();
+
+	CopyToCDriveL(aFile);
+	test.Printf(_L("Testing Adding Categories...\n"));
+	iTestLib->DeleteViews();
+	iTestLib->GetSession().OpenL(aFile, status);
+	iTestLib->SynCGetEntryViewL();
+	TestAddCategoriesL();
+	
+	CopyToCDriveL(aFile);
+	test.Printf(_L("Testing Deleting Categories...\n"));
+	iTestLib->GetSession().OpenL(aFile, status);
+	iTestLib->SynCGetEntryViewL();
+	TestDeleteCategoriesL();
+	iTestLib->DeleteFileL(aFile, ETrue);
+	}
+
+void CCalEntryTestApp::TestFilterCategoriesL()
+	{
+	test.Printf(_L("Test opening an old file then filtering categories\n"));
+	CCalCategoryManager* catMan = CCalCategoryManager::NewL(iTestLib->GetSession());
+	CleanupStack::PushL(catMan);
+
+	RPointerArray<CCalEntry> entries;
+	CleanupResetAndDestroyPushL(entries);
+
+	CCalCategory* cat1 = CCalCategory::NewL(KUserDefinedCategoryName());
+	CleanupStack::PushL(cat1);
+
+	// find all entries in category
+	catMan->FilterCategoryL(*cat1, entries, *iTestLib);
+	CActiveScheduler::Start();
+	
+	test(entries.Count() == 1);
+	test(entries[0]->UidL() == KGUIDAllProperties());
+	entries.ResetAndDestroy();
+
+	CleanupStack::PopAndDestroy(cat1);
+	CleanupStack::PopAndDestroy(&entries); // entries.ResetAndDestroy()
+	CleanupStack::PopAndDestroy(catMan);
+	}
+
+void CCalEntryTestApp::TestCategoryWithoutBuiltIndexesL()
+	{
+	test.Printf(_L("Test filtering categories before building the indexes\n"));
+	CCalCategoryManager* catMan = CCalCategoryManager::NewL(iTestLib->GetSession());
+	CleanupStack::PushL(catMan);
+
+	RPointerArray<CCalEntry> entries;
+
+	CCalCategory* cat1 = CCalCategory::NewL(KUserDefinedCategoryName());
+	CleanupStack::PushL(cat1);
+
+	// find all entries in category
+	catMan->FilterCategoryL(*cat1, entries, *this);
+	CActiveScheduler::Start();
+	
+	test(iErr == KErrNotSupported);
+	test(entries.Count() == 0);
+
+	CleanupStack::PopAndDestroy(cat1);
+	CleanupStack::PopAndDestroy(catMan);
+	}
+
+void CCalEntryTestApp::TestAddCategoriesL()
+	{
+	test.Printf(_L("Test opening an old file then adding categories\n"));
+	CCalCategoryManager* catMan = CCalCategoryManager::NewL(iTestLib->GetSession());
+	CleanupStack::PushL(catMan);
+
+	RPointerArray<CCalEntry> entries;
+	CleanupResetAndDestroyPushL(entries);
+
+	CCalCategory* cat1 = CCalCategory::NewL(KUserDefinedCategoryName2());
+	CleanupStack::PushL(cat1);
+	catMan->AddCategoryL(*cat1);
+	
+	// find all entries in category
+	catMan->FilterCategoryL(*cat1, entries, *iTestLib);
+	CActiveScheduler::Start();
+	
+	test(entries.Count() == 0);
+
+	CleanupStack::PopAndDestroy(cat1);
+	CleanupStack::PopAndDestroy(&entries); // entries.ResetAndDestroy()
+	CleanupStack::PopAndDestroy(catMan);
+	}
+
+void CCalEntryTestApp::TestDeleteCategoriesL()
+	{
+	test.Printf(_L("Test opening an old file then deleting categories\n"));
+	CCalCategoryManager* catMan = CCalCategoryManager::NewL(iTestLib->GetSession());
+	CleanupStack::PushL(catMan);
+
+	RPointerArray<CCalEntry> entries;
+	CleanupResetAndDestroyPushL(entries);
+
+	CCalCategory* cat1 = CCalCategory::NewL(KUserDefinedCategoryName());
+	CleanupStack::PushL(cat1);
+
+	// delete category
+	catMan->DeleteCategoryL(*cat1, *iTestLib);
+	CActiveScheduler::Start();
+
+	// find all entries in category
+	TRAPD(err, catMan->FilterCategoryL(*cat1, entries, *iTestLib));
+	test(err == KErrNotFound);
+	test(entries.Count() == 0);
+
+	CleanupStack::PopAndDestroy(cat1);
+	CleanupStack::PopAndDestroy(&entries); // entries.ResetAndDestroy()
+	CleanupStack::PopAndDestroy(catMan);
+	}
+
+//
+// Tests written for v9.2 that should still work
+//
+// Add a parent and a child entry
+//
+void CCalEntryTestApp::V92AddEntriesL(CCalEntry::TType aType)
+	{
+	RPointerArray<CCalEntry> entryArray;
+	CleanupResetAndDestroyPushL(entryArray);
+	
+	TTime startTime;
+	startTime.HomeTime();
+	startTime += TTimeIntervalDays(aType);
+	
+	TBuf8<64> buffer;
+	iTestLib->RandomText8(buffer);
+	HBufC8* hBuf = buffer.AllocLC();
+	CCalEntry* parentEntry = iTestLib->CreateCalEntryL(aType, hBuf);
+	CleanupStack::Pop(hBuf);
+	
+	TCalTime calStartTime;
+	calStartTime.SetTimeLocalL(startTime);
+	parentEntry->SetStartAndEndTimeL(calStartTime, calStartTime);
+	
+	parentEntry->SetLocationL(KParentLocation);
+	parentEntry->SetSummaryL(KParentSummary);
+	parentEntry->SetDescriptionL(KParentDescription);
+
+	CCalAlarm* alarm = CCalAlarm::NewL();
+	CleanupStack::PushL(alarm);
+	alarm->SetAlarmSoundNameL(KParentAlarmName);
+	alarm->SetTimeOffset(TTimeIntervalMinutes(5));
+	
+	parentEntry->SetAlarmL(alarm);
+	CleanupStack::PopAndDestroy(alarm);
+
+	TCalRRule rule(TCalRRule::EDaily);
+	rule.SetInterval(1);
+	rule.SetDtStart(calStartTime);
+	rule.SetCount(100);
+	parentEntry->SetRRuleL(rule);
+	
+	entryArray.AppendL(parentEntry);
+	
+	// create child entry
+	hBuf = buffer.AllocLC();
+	CCalEntry* childEntry = CCalEntry::NewL(aType, hBuf, CCalEntry::EMethodNone, 0, calStartTime, CalCommon::EThisOnly);
+	CleanupStack::Pop(hBuf);
+	
+	entryArray.AppendL(childEntry);
+	
+	childEntry->SetStartAndEndTimeL(calStartTime, calStartTime);
+	childEntry->SetLocationL(KChildLocation);
+	childEntry->SetSummaryL(KChildSummary);
+	childEntry->SetDescriptionL(KChildDescription);
+		
+	TInt success = 0;
+	iTestLib->SynCGetEntryViewL().StoreL(entryArray, success);
+	CleanupStack::PopAndDestroy(&entryArray);
+	}
+
+void CCalEntryTestApp::V92AddEntriesDCFileL()
+	{
+	// Create a number of entries to test DC.
+	// Repeating alarmed entry of each type with summary, location, description and alarm action, and a child entry
+	V92AddEntriesL(CCalEntry::EAppt);
+	V92AddEntriesL(CCalEntry::EEvent);
+	V92AddEntriesL(CCalEntry::EAnniv);
+	V92AddEntriesL(CCalEntry::EReminder);
+	V92AddEntriesL(CCalEntry::ETodo);
+	}
+	
+void CCalEntryTestApp::V92ReadEntriesDCFileL()
+	{
+	TCalTime startDate;
+	startDate.SetTimeLocalL(TCalTime::MinTime());
+	TCalTime endDate;
+	endDate.SetTimeLocalL(TCalTime::MaxTime());
+	
+	CalCommon::TCalTimeRange timeRange(startDate, endDate);
+	CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll|CalCommon::EIncludeRptsNextInstanceOnly;
+	
+	RPointerArray<CCalInstance> instanceArray;
+	iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceArray, filter, timeRange);
+	
+	for (TInt i = 0; i < instanceArray.Count(); i++)
+		{
+		CCalEntry* entry = &instanceArray[i]->Entry();
+		TCalRRule rule;
+		if (entry->GetRRuleL(rule))
+			{
+			// must be parent entry
+			test(entry->LocationL() == KParentLocation());
+			test(entry->SummaryL() == KParentSummary());
+			test(entry->DescriptionL() == KParentDescription());
+			test(rule.Count() == 100);
+			CCalAlarm* alarm = entry->AlarmL();
+			test(alarm->AlarmSoundNameL() == KParentAlarmName());
+			delete alarm;
+			}
+		else
+			{
+			test(entry->LocationL() == KChildLocation());
+			test(entry->SummaryL() == KChildSummary());
+			test(entry->DescriptionL() == KChildDescription());
+			}
+		}
+	
+	// check stuff
+	instanceArray.ResetAndDestroy();
+	}
+
+// Fetch and update all the entries - parent and child in the Calendar file
+void CCalEntryTestApp::V92UpdateEntriesL()
+	{
+	CCalIter* entryIter = CCalIter::NewL(iTestLib->GetSession());
+	CleanupStack::PushL(entryIter);
+	TPtrC8 uidIter(entryIter->FirstL());
+
+	RPointerArray<CCalEntry> calEntryArray;
+	CleanupResetAndDestroyPushL(calEntryArray);
+	
+	RPointerArray<CCalEntry> tempEntryArray;
+	CleanupClosePushL(tempEntryArray);
+	
+	CCalEntry* entry = NULL;
+		
+	TInt successEntryCount=0;
+
+	// Iterate through all the entries' UIDs and fetch all the entries (parent and child) with the UID
+	// Call UpdateL on Parent Entries and StoreL on Child Entries
+	while (uidIter != KNullDesC8())
+		{
+		iTestLib->SynCGetEntryViewL().FetchL(uidIter,calEntryArray);
+		
+		for(TInt entryCount=0;entryCount<calEntryArray.Count();++entryCount)
+			{
+			entry = calEntryArray[entryCount];
+
+			tempEntryArray.AppendL(calEntryArray[entryCount]);
+			
+			if(entry->RecurrenceIdL().TimeUtcL()==Time::NullTTime())
+				{
+				// Parent Entry
+				entry->SetLocationL(_L("Updated Parent Location 1"));
+				entry->SetSummaryL(_L("Updated Parent Summary 1"));
+				entry->SetDescriptionL(_L("Updated Parent Description 1"));
+
+				successEntryCount=0;
+				iTestLib->SynCGetEntryViewL().UpdateL(tempEntryArray, successEntryCount);
+				test(successEntryCount==1);
+				}
+			else
+				{
+				// Child Entry
+				entry->SetLocationL(_L("Updated Child Location 1"));
+				entry->SetSummaryL(_L("Updated Child Summary 1"));
+				entry->SetDescriptionL(_L("Updated Child Description 1"));
+				
+				successEntryCount=0;
+				//iTestLib->SynCGetEntryViewL().StoreL(RPointerArray<CCalEntry>(&calEntryArray[entryCount],1),successEntryCount);
+				iTestLib->SynCGetEntryViewL().StoreL(tempEntryArray, successEntryCount);
+				test(successEntryCount==1);
+				}
+				
+			tempEntryArray.Reset();
+			}
+		calEntryArray.ResetAndDestroy();
+		uidIter.Set(entryIter->NextL());
+		}
+	CleanupStack::PopAndDestroy(&tempEntryArray);
+	CleanupStack::PopAndDestroy(&calEntryArray);
+	CleanupStack::PopAndDestroy(entryIter);
+	}
+	
+// ===========
+// 9.2 Calendar File - Clean / No entries
+// ===========
+
+
+void CCalEntryTestApp::V92Test92CalendarFileCleanL()
+	{
+	test.Next(_L("9.2 Calendar File - Clean / No entries"));
+
+	
+	_LIT(KOriginalCalendarFileBravoCleanFullPath, "z:\\private\\10003a5b\\tcal_dc_92_CalFile_Clean");
+	_LIT(KCalendarFileBravoCleanFullPath, "c:\\private\\10003a5b\\tcal_dc_92_CalFile_Clean");
+	_LIT(KCalendarFileBravoCleanTestFullPath, "c:\\private\\10003a5b\\tcal_dc_92_CalFile_Clean_Test");
+	
+	_LIT(KCalendarFileBravoCleanTest, "c:tcal_dc_92_CalFile_Clean_Test");
+
+	// Copy the 9.2 Calendar file from the ROM drive to the C: to enable writing into it
+	iTestLib->PIMTestServer().CopyFileL(KOriginalCalendarFileBravoCleanFullPath, KCalendarFileBravoCleanFullPath);
+	
+	// Step 1 = Create a copy of a clean (no entries) Bravo v9.2 Calendar file for test purposes
+	iTestLib->PIMTestServer().CopyFileL(KCalendarFileBravoCleanFullPath, KCalendarFileBravoCleanTestFullPath);
+	
+	// Step 2 = Open the 9.2 test Calendar file
+	iTestLib->OpenFileL(KCalendarFileBravoCleanTest());
+	
+	// Step 3 = Add multiple 9.2 parent and child entries to the 9.2 test Calendar file
+	V92AddEntriesDCFileL();
+	
+	// Step 4 = Read and verify previously added 9.2 multiple parent and child entries within the 9.2 test Calendar file
+	V92ReadEntriesDCFileL();
+	
+	// Step 5 = Update all entries in the 9.2 Calendar file	
+	V92UpdateEntriesL();
+	
+	// Step 6 = Delete all entries in the 9.2 Calendar file	
+	iTestLib->CleanDatabaseL();
+	
+	// Step 7 = Delete the 9.2 test Calendar files
+	iTestLib->DeleteFileL(KCalendarFileBravoCleanTest());
+	iTestLib->PIMTestServer().DeleteFileL(KCalendarFileBravoCleanFullPath());
+	}
+
+// ===========
+// 9.2 Calendar File - Previously Added Entries
+// ===========
+
+
+void CCalEntryTestApp::V92Test92CalendarFileEntriesAddedL()
+	{
+	test.Next(_L("Calendar File - Previously Added Entries"));
+
+	
+	_LIT(KOriginalCalendarFileBravoEntriesAddedFullPath, "z:\\private\\10003a5b\\tcal_dc_92_CalFile_EntriesAdded");
+	_LIT(KCalendarFileBravoEntriesAddedFullPath, "c:\\private\\10003a5b\\tcal_dc_92_CalFile_EntriesAdded");
+	_LIT(KCalendarFileBravoTestEntriesAddedFullPath, "c:\\private\\10003a5b\\tcal_dc_92_CalFile_EntriesAdded_Test");
+	
+	_LIT(KCalendarFileBravoTestEntriesAdded,"c:tcal_dc_92_CalFile_EntriesAdded_Test");
+	
+	// Copy the 9.2 Calendar file from the ROM drive to the C: to enable writing into it
+	iTestLib->PIMTestServer().CopyFileL(KOriginalCalendarFileBravoEntriesAddedFullPath, KCalendarFileBravoEntriesAddedFullPath);
+	
+	// Step 1 = Create a copy of Bravo v9.2 Calendar file saved earlier with 9.2 entries for test purposes
+	iTestLib->PIMTestServer().CopyFileL(KCalendarFileBravoEntriesAddedFullPath, KCalendarFileBravoTestEntriesAddedFullPath);
+	
+	// Step 2 = Open the 9.2 test Calendar file
+	iTestLib->OpenFileL(KCalendarFileBravoTestEntriesAdded());
+	
+	// Step 3 = Read and verify previously added 9.2 multiple parent and child entries within the 9.2 test environment
+	V92ReadEntriesDCFileL();
+	
+	// Step 4 = Delete all entries in the 9.2 Calendar file	
+	iTestLib->CleanDatabaseL();
+	
+	// Step 5 = Add multiple 9.2 parent and child entries to the 9.2 test Calendar file
+	V92AddEntriesDCFileL();
+	
+	// Step 6 = Read and verify previously added 9.2 multiple parent and child entries within the 9.2 test Calendar file
+	V92ReadEntriesDCFileL();
+	
+	// Step 7 = Update all entries in the 9.2 Calendar file	
+	V92UpdateEntriesL();
+	
+	// Step 8 = Delete all entries in the 9.2 Calendar file	
+	iTestLib->CleanDatabaseL();
+
+	// Step 9 = Delete the 9.2 test Calendar files
+	iTestLib->DeleteFileL(KCalendarFileBravoTestEntriesAdded());
+	iTestLib->PIMTestServer().DeleteFileL(KCalendarFileBravoEntriesAddedFullPath());
+	}
+
+// ===========
+// 9.1 Calendar File - Clean / No entries
+// ===========
+
+
+void CCalEntryTestApp::V92Test91CalendarFileCleanL()
+	{
+	test.Next(_L("9.1 Calendar File - Clean / No Entries"));
+
+	
+	_LIT(KOriginalCalendarFileMikeCleanFullPath, "z:\\private\\10003a5b\\tcal_dc_91_CalFile_Clean");
+	_LIT(KCalendarFileMikeCleanFullPath, "c:\\private\\10003a5b\\tcal_dc_91_CalFile_Clean");
+	_LIT(KCalendarFileMikeCleanTestFullPath, "c:\\private\\10003a5b\\tcal_dc_91_CalFile_Clean_Test");
+	
+	_LIT(KCalendarFileMikeCleanTest, "c:tcal_dc_91_CalFile_Clean_Test");
+	
+	// Copy 9.1 Calendar file from the ROM drive to the C: to enable writing into it
+	iTestLib->PIMTestServer().CopyFileL(KOriginalCalendarFileMikeCleanFullPath, KCalendarFileMikeCleanFullPath);
+	
+	// Step 1 = Create a copy of a clean (no entries) Mike v9.1 Calendar file for test purposes
+	iTestLib->PIMTestServer().CopyFileL(KCalendarFileMikeCleanFullPath, KCalendarFileMikeCleanTestFullPath);
+	
+	// Step 2 = Open the 9.1 Calendar file for test purposes
+	iTestLib->OpenFileL(KCalendarFileMikeCleanTest());
+		
+	// Step 3 = Add multiple 9.2 parent and child entries to the 9.1 test Calendar file
+	V92AddEntriesDCFileL();
+	
+	// Step 4 = Read and verify previously added 9.2 multiple parent and child entries within the 9.1 test Calendar file
+	V92ReadEntriesDCFileL();
+
+	// Step 5 = Update all entries in the 9.1 Calendar file	
+	V92UpdateEntriesL();
+	
+	// Step 6 = Delete all entries in the 9.1 Calendar file	
+	iTestLib->CleanDatabaseL();
+
+	// Step 7 = Delete the 9.1 test Calendar files
+	iTestLib->DeleteFileL(KCalendarFileMikeCleanTest());
+	iTestLib->PIMTestServer().DeleteFileL(KCalendarFileMikeCleanFullPath());
+	}
+	
+// ===========
+// 9.1 Calendar File - Previously Added Entries
+// ===========
+
+
+void CCalEntryTestApp::V92Test91CalendarFileEntriesAddedL()
+	{
+	test.Next(_L("9.1 Calendar File - Previously Added Entries"));
+
+	
+	_LIT(KOriginalCalendarFileMikeEntriesAddedFullPath, "z:\\private\\10003a5b\\tcal_dc_91_CalFile_EntriesAdded");
+	_LIT(KCalendarFileMikeEntriesAddedFullPath, "c:\\private\\10003a5b\\tcal_dc_91_CalFile_EntriesAdded");
+	_LIT(KCalendarFileMikeTestEntriesAddedFullPath, "c:\\private\\10003a5b\\tcal_dc_91_CalFile_EntriesAdded_Test");
+	
+	_LIT(KCalendarFileMikeTestEntriesAdded,"c:tcal_dc_91_CalFile_EntriesAdded_Test");
+	
+	// Copy the 9.1 Calendar file from the ROM drive to the C: to enable writing into it
+	iTestLib->PIMTestServer().CopyFileL(KOriginalCalendarFileMikeEntriesAddedFullPath, KCalendarFileMikeEntriesAddedFullPath);
+	
+	// Step 1 = Create a copy of Mike v9.1 Calendar file saved earlier with 9.1 entries for test purposes
+	iTestLib->PIMTestServer().CopyFileL(KCalendarFileMikeEntriesAddedFullPath, KCalendarFileMikeTestEntriesAddedFullPath);
+	
+	// Step 2 = Open the 9.1 test Calendar file
+	iTestLib->OpenFileL(KCalendarFileMikeTestEntriesAdded());
+	
+	// Step 3 = Read and verify previously added 9.1 multiple parent and child entries within the 9.2 test environment
+	V92ReadEntriesDCFileL();
+	
+	// Step 4 = Delete all entries in the 9.1 Calendar file	
+	iTestLib->CleanDatabaseL();
+	
+	// Step 5 = Add multiple 9.2 parent and child entries to the 9.1 test Calendar file
+	V92AddEntriesDCFileL();
+	
+	// Step 6 = Read and verify previously added 9.2 multiple parent and child entries within the 9.1 test Calendar file
+	V92ReadEntriesDCFileL();
+	
+	// Step 7 = Update all entries in the 9.1 Calendar file	
+	V92UpdateEntriesL();
+	
+	// Step 8 = Delete all entries in the 9.1 Calendar file	
+	iTestLib->CleanDatabaseL();
+	
+	// Step 9 = Delete the 9.1 test Calendar files
+	iTestLib->DeleteFileL(KCalendarFileMikeTestEntriesAdded());
+	iTestLib->PIMTestServer().DeleteFileL(KCalendarFileMikeEntriesAddedFullPath());
+	}
+#endif 
+
+void CCalEntryTestApp::OpenBlankFileL()
+	{
+	TBuf<8> buf;
+	buf.AppendNum(0);
+	iTestLib->ReplaceFileL(buf);
+	iTestLib->DeleteViews();
+	iTestLib->OpenFileL(buf);
+	}
+	
+void CCalEntryTestApp::CopyToCDriveL(const TDesC& aFileName)
+	{
+	iTestLib->DeleteViews();
+	
+	_LIT(KCalendarDirectory,"\\private\\10003a5b\\");
+	
+	TFileName originalLocation, newLocation;
+	originalLocation.Copy(_L("z:"));
+	originalLocation.Append(KCalendarDirectory);
+	originalLocation.Append(aFileName);
+	newLocation.Copy(_L("c:"));
+	newLocation.Append(KCalendarDirectory);
+	newLocation.Append(aFileName);
+	TRAPD(err, iTestLib->DeleteFileL(aFileName));
+	if (err == KErrInUse)
+		{
+		OpenBlankFileL();
+		iTestLib->DeleteFileL(aFileName);
+		}
+	TRAP(err, iTestLib->PIMTestServer().CopyFileL(originalLocation, newLocation));
+	if (err != KErrNone)
+		{
+		test.Printf(_L("Failed to copy from %S to %S, err=%d\n"), &originalLocation, &newLocation, err);
+		}
+	}
+
+#ifndef __REGENERATE_DC_FILE__
+static void DoOpenCalendarFileL()
+	{
+	TInt err = KErrNotFound;
+	while (err != KErrNone)
+		{
+		CCalTestLibrary* testLib = CCalTestLibrary::NewLC(ETrue);
+		testLib->OpenFileL(KCalendar91File);
+		TRAP(err, testLib->SynCGetEntryViewL());
+		test(err == KErrInUse || err == KErrNone);
+		CleanupStack::PopAndDestroy(testLib);
+		}	
+	}
+
+static TInt OpenCalendarFile(TAny*)
+	{
+	CTrapCleanup* trapCleanup = CTrapCleanup::New();
+	if (!trapCleanup)
+		{
+		return KErrNoMemory;
+		}
+
+	CActiveScheduler* scheduler = new CActiveScheduler();
+	if (!scheduler)
+		{
+		delete trapCleanup;
+		return KErrNoMemory;
+		}
+	CActiveScheduler::Install(scheduler);
+
+	TRAPD(err, DoOpenCalendarFileL());
+
+	delete scheduler;
+	delete trapCleanup;
+
+	return err;
+	}
+
+void CCalEntryTestApp::TestOpeningFileDuringConversionL()
+	{
+	test.Printf(_L("Loading v9.1 calendar file in two threads at once...\n"));
+	CopyToCDriveL(KCalendar91File);
+	CalCommon::TCalFileVersionSupport status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->GetSession().OpenL(KCalendar91File, status);
+	test(status == CalCommon::EFileNeedsConverting);
+	iTestLib->AsynCGetEntryViewL();
+
+	//
+	const TInt KMaxHeapSize = 0x20000;
+	RThread otherThread;
+	TName threadName = _L("TestOpenCalendarThread");
+	TInt err = otherThread.Create(threadName, OpenCalendarFile, KDefaultStackSize, 
+							      KMinHeapSize, KMaxHeapSize, NULL, EOwnerProcess);
+	if (err != KErrNone)
+		{
+		User::Panic(_L("Thread's not been created"), err);
+		}
+
+	TRequestStatus threadStatus;
+	otherThread.Logon(threadStatus);
+	otherThread.Resume(); 
+	//wait until the other thread is dead?
+	User::WaitForRequest(threadStatus);
+	test(threadStatus.Int() == KErrNone);
+	
+	CActiveScheduler::Start();
+	}
+#endif
+
+void CCalEntryTestApp::DoTestsL()
+	{
+	iTestLib = CCalTestLibrary::NewL(ETrue);
+
+#ifdef __REGENERATE_DC_FILE__
+
+	iTestLib->ReplaceFileL(KCalendarFileToGenerate());
+	iTestLib->OpenFileL(KCalendarFileToGenerate());
+	CreateDCFileL();
+	
+#else
+
+	CalCommon::TCalFileVersionSupport status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	
+	CopyToCDriveL(KCalendar81File);
+	iTestLib->RegisterCalFileL(KCalendar81File);
+	test.Printf(_L("Loading v8.1 calendar file...\n"));
+	TRAPD(err, iTestLib->GetSession().OpenL(KCalendar81File, status));
+	test(err == KErrNotSupported);
+	test(status == CalCommon::EUnsupportedFileVersion);
+	
+	CopyToCDriveL(KCalendar91File);
+	iTestLib->RegisterCalFileL(KCalendar91File);
+	test.Printf(_L("Loading v9.1 calendar file...\n"));
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->GetSession().OpenL(KCalendar91File, status);
+	test(status == CalCommon::EFileNeedsConverting);
+	TestFileLoadedL(EFalse);
+	
+	CopyToCDriveL(KCalendar92File);
+	iTestLib->RegisterCalFileL(KCalendar92File);
+	test.Printf(_L("Loading v9.2 calendar file...\n"));
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->GetSession().OpenL(KCalendar92File, status);
+	test(status == CalCommon::EFileNeedsConverting);
+	TestFileLoadedL(ETrue);
+
+	CopyToCDriveL(KCalendar94File);
+	iTestLib->RegisterCalFileL(KCalendar94File);
+	test.Printf(_L("Loading v9.4 compacted calendar file...\n"));
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->GetSession().OpenL(KCalendar94File, status);
+	test(status == CalCommon::EFileNeedsConverting);
+	TestFileLoadedV94L();
+	
+	CopyToCDriveL(KCalendar95File);
+	iTestLib->RegisterCalFileL(KCalendar95File);
+	test.Printf(_L("Loading v9.5 calendar file...\n"));
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->GetSession().OpenL(KCalendar95File, status);
+	test(status == CalCommon::EFileIsCurrentVersion);
+	TestFileLoadedV95L();
+	
+	test.Printf(_L("Loading v9.2 calendar file from read-only drive...\n"));
+	TFileName fileOnZDrive;
+	fileOnZDrive.Copy(_L("z:"));
+	fileOnZDrive.Append(KCalendar92File);
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->DeleteViews();
+	TRAP(err, iTestLib->GetSession().OpenL(fileOnZDrive, status));
+	test(err == KErrAccessDenied);
+	test(status == CalCommon::EFileNeedsConverting);
+	
+	test.Printf(_L("Loading converted 9.2 calendar file...\n"));
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->DeleteViews();
+	iTestLib->GetSession().OpenL(KCalendar92File, status);
+	test(status == CalCommon::EFileIsCurrentVersion);
+	TestFileLoadedL(ETrue);
+
+	test.Printf(_L("Loading converted 9.4 calendar file ...\n"));
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->DeleteViews();
+	iTestLib->GetSession().OpenL(KCalendar94File, status);
+	test(status == CalCommon::EFileIsCurrentVersion);
+	TestFileLoadedV94L();
+	
+	test.Printf(_L("Loading large v9.1 calendar file...\n"));
+	CopyToCDriveL(KCalendar91LargeFile);
+	iTestLib->RegisterCalFileL(KCalendar91LargeFile);
+	TTime start, end;
+	start.UniversalTime();
+	status = static_cast<CalCommon::TCalFileVersionSupport>(-1);
+	iTestLib->GetSession().OpenL(KCalendar91LargeFile, status);
+	test(status == CalCommon::EFileNeedsConverting);
+	iTestLib->SynCGetEntryViewL(); // build indexes
+	end.UniversalTime();
+	TTimeIntervalMicroSeconds microseconds = end.MicroSecondsFrom(start);
+	TInt32 milliseconds = microseconds.Int64() / 1000;
+	test.Printf(_L("Time to convert 1200 entries from v9.1 to v9.3: %d milliseconds\n"), milliseconds);
+
+	CopyToCDriveL(KCalendar92CorruptFile);
+	iTestLib->RegisterCalFileL(KCalendar92CorruptFile);
+	test.Printf(_L("Loading corrupt v9.2 calendar file...\n"));
+	iTestLib->GetSession().OpenL(KCalendar92CorruptFile, status);
+	test(status == CalCommon::EFileNeedsConverting);
+	TRAP(err, iTestLib->SynCGetEntryViewL()); // build indexes
+	test(err == KErrCorrupt);
+	
+	TestCategoriesL(KCalendar91File);
+	TestCategoriesL(KCalendar92File);
+	
+	TestOpeningFileDuringConversionL();
+	
+	OpenBlankFileL();
+	// Old v9.2 tests:
+	
+	// 9.2 Calendar File - Clean / No Entries
+	V92Test92CalendarFileCleanL();
+
+	// 9.2 Calendar File - Previously Added Entries
+	V92Test92CalendarFileEntriesAddedL();
+
+	// 9.1 Calendar File - Clean / No Entries
+	V92Test91CalendarFileCleanL();
+
+	// 9.1 Calendar File - Previously Added Entries
+	V92Test91CalendarFileEntriesAddedL();
+
+	//there are still converted files left
+	//manual delete of them
+	TRAP_IGNORE(iTestLib->DeleteFileL( _L("tcal_dc_91"), 1) );
+	TRAP_IGNORE(iTestLib->DeleteFileL( _L("tcal_dc_91_calfile_clean_test_converted"), 1) );
+	TRAP_IGNORE(iTestLib->DeleteFileL( _L("tcal_dc_91Idx"), 1) );
+	TRAP_IGNORE(iTestLib->DeleteFileL( _L("tcal_dc_92_calfile_clean_test_converted"), 1) );
+	TRAP_IGNORE(iTestLib->DeleteFileL( _L("tcal_dc_92_corrupt_converted"), 1) ); // will not be deleted because in use
+	
+#endif
+	}
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * DoTestL()
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+	
+static void DoTestL()
+	{
+	CCalEntryTestApp* testManager = new (ELeave) CCalEntryTestApp;
+	CleanupStack::PushL(testManager);
+
+
+	TPerformanceTimer timer(test);
+	timer.Start();
+
+
+	// Run the test suite
+
+	testManager->DoTestsL();
+	
+	
+	timer.Stop();
+	test.Printf(_L("Done\n"));
+	// printout performance time
+	timer.PrintOut();
+
+	
+	CleanupStack::PopAndDestroy(testManager);
+	}
+
+void MyCleanL(void)
+	{
+	CCalTestLibrary	*pTestLib = CCalTestLibrary::NewLC(ETrue);
+	pTestLib->DeleteFileL(_L("tcal_dc_92_corrupt_converted"), ETrue);
+	CleanupStack::PopAndDestroy(pTestLib);
+	}
+
+/**
+
+@SYMTestCaseID     PIM-TCAL-DC-0001
+
+*/
+
+TInt E32Main()
+    {
+	__UHEAP_MARK;
+
+	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-DC-0001 Calendar Interim API Data Conversion test suite"));
+
+	test.Title();
+
+	CTrapCleanup* trapCleanup = CTrapCleanup::New();
+	if (!trapCleanup)
+		{
+		return KErrNoMemory;
+		}
+
+	CActiveScheduler* scheduler = new CActiveScheduler();
+	if (!scheduler)
+		{
+		delete trapCleanup;
+		return KErrNoMemory;
+		}
+	CActiveScheduler::Install(scheduler);	
+
+	TRAPD(ret, DoTestL());
+	test(ret == KErrNone);
+	
+	TRAP_IGNORE(MyCleanL());
+
+	test.End();
+	test.Close();
+
+	delete scheduler;
+	delete trapCleanup;	
+	
+	__UHEAP_MARKEND;
+
+	return (KErrNone);
+    }