// 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);