// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

// local includes

#include "caltestlib.h"

// System includes

#include <e32std.h>

#include <e32test.h>

#include <calalarm.h>

#include <calentry.h>

#include <calentryview.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calsession.h>

#include <calrrule.h>

#include "tcal_BadRRule.h"

RTest test(_L("tCal_RptRules"));

_LIT8(KGUID, "A_Global_UID");

_LIT(KCalendarFile, "tCal_RptRules");

_LIT(KFormatDate, "%D%M%Y%/0%1%/1%2%/2%3%/3");

const TInt KNudgeCount = 10;

// Further tests to add:

//  - test multiple overlapping repeat rules

//  - 

class CTestApp : public CBase

	{

public:

	static CTestApp* NewLC();

 	void DoTestL();

	~CTestApp();

private:

	enum {

		EDailyRptTest1,

		EDailyRptTest2,

		EDailyRptTest3,

		EWeeklyRptTest1,

		EWeeklyRptTest2,

		EWeeklyRptTest3,

		EMonthByDayRptTest1,

		EMonthByDayRptTest2,

		EMonthByDayRptTest3,

		EMonthByDateRptTest1,

		EMonthByDateRptTest2,

		EMonthByDateRptTest3,

		EYearByDateRptTest1,

		EYearByDateRptTest2,

		EYearByDayRptTest1,

		EYearByDayRptTest2,

		ENumberOfTests,

		};

	CTestApp();

	void ConstructL();

	void TestInvalidDataL();

	void SetUpTestL(TInt aTest);

	void AddEntryToDatabaseL(const TCalRRule& aRpt);

	void CheckThisTimeL(TTime aTime);

	void TestNextAndPreviousInstanceL();

 	void NegativeTestL();

	void TestRepeatRuleTypeChangeL();

	void TestNudgesL(CCalEntry::TType aType);

	void TestNudgingOnEntryL();

	void TestRDateNudgingOnEntryL();

	TTime TestNextInstanceL(TTime aTime);

	void TestPreviousInstanceL(TTime aTime);

	void TestDurationExtremeL();

 	void SetupDailyRpt1L();

	void SetupDailyRpt2L();

	void SetupDailyRpt3L();

	void SetupWeeklyRpt1L();

	void SetupWeeklyRpt2L();

	void SetupWeeklyRpt3L();

	void SetupMonthlyByDayRpt1L();

	void SetupMonthlyByDayRpt2L();

	void SetupMonthlyByDayRpt3L();

	void SetupMonthlyByDateRpt1L();

	void SetupMonthlyByDateRpt2L();

	void SetupMonthlyByDateRpt3L();

	void SetupYearlyByDateRpt1L();

	void SetupYearlyByDateRpt2L();

	void SetupYearlyByDayRpt1L();

	void SetupYearlyByDayRpt2L();

	void CheckRptExtremeL();

	void RDatesTestL();

	void NegativeTest2L();

	void UpdateOfEndDateInRepeatRuleTest();

public:

	CCalTestLibrary* iTestLib;

private:	

	CCalEntryView* iEntryView; // not owned

	CCalInstanceView* iInstanceView;  // not owned

	RArray<TTime> iOccurrenceArray;	// stores expected results

	TTime iPrevTime;

	TBuf<KMaxTimeFormatSpec> iBuffer;

	TInt iNudgeCount;

	CCalEntry::TType iType;

	};

CTestApp* CTestApp::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTestApp::CTestApp()

	{

	}

void CTestApp::ConstructL()

	{

	iTestLib = CCalTestLibrary::NewL();

	iTestLib->ReplaceFileL(KCalendarFile());

	iTestLib->OpenFileL(KCalendarFile());

	iEntryView = &iTestLib->SynCGetEntryViewL();

	iInstanceView = &iTestLib->SynCGetInstanceViewL();

	}

CTestApp::~CTestApp()

	{

	delete iTestLib;

	iOccurrenceArray.Reset();

	}

// Check that this time is in the expected results

void CTestApp::CheckThisTimeL(TTime aTime)

	{

	aTime.FormatL(iBuffer,KFormatDate());

	test.Printf(_L(" instance %d is %S\n"), iNudgeCount, &iBuffer);

	// check new instance is different from previous one

	if (iNudgeCount > 0)

		{

		if (iPrevTime == aTime)

			{

			test.Printf(_L("Failed: instance %d not different from previous one\n"), iNudgeCount);

			test(0);

			}

		}

	// check new instance is in the expected instances list

	TInt timeArrayCount = 0;

	TBool foundTime = EFalse;

	while (timeArrayCount < iOccurrenceArray.Count())

		{

		if (aTime == iOccurrenceArray[timeArrayCount])

			{

			foundTime = ETrue;

			break;

			}

		timeArrayCount++;

		}

	if (!foundTime)

		{

		test.Printf(_L("Failed: instance %d has unexpected date\n"), iNudgeCount);

		}

	test(foundTime);

	iPrevTime = aTime;

	}

// Find the next 10 instances and see if they are as expected

TTime CTestApp::TestNextInstanceL(TTime aTime)

	{

	aTime -= TTimeIntervalDays(1);

	test.Printf(_L("Finding next instance\n"));

	iNudgeCount = 0;

	while (iNudgeCount < KNudgeCount)

		{

		// get next instance and display it

		TCalTime calTimeForFnCall;

		TCalTime calTimeReturnVal;

		calTimeForFnCall.SetTimeLocalL(aTime);

		calTimeReturnVal = iInstanceView->NextInstanceL(CalCommon::EIncludeAll, calTimeForFnCall);

		aTime = calTimeReturnVal.TimeLocalL();

		CheckThisTimeL(aTime);

		iNudgeCount++;

		}

	return aTime;

	}

// Find the previous 10 instances and see if they are as expected

void CTestApp::TestPreviousInstanceL(TTime aTime)

	{	

	iNudgeCount = 0;

	test.Printf(_L("Finding previous instance\n"));

	while (iNudgeCount < KNudgeCount)

		{

		// get previous instance and display it

		TCalTime calTimeForFnCall;

		TCalTime calTimeReturnVal;

		calTimeForFnCall.SetTimeLocalL(aTime);

		calTimeReturnVal = iInstanceView->PreviousInstanceL(CalCommon::EIncludeAll, calTimeForFnCall);

		aTime = calTimeReturnVal.TimeLocalL();

		aTime.FormatL(iBuffer,KFormatDate());

		CheckThisTimeL(aTime);

		iNudgeCount++;

		}

	}

void CTestApp::TestNudgingOnEntryL()

	{

	ASSERT(iOccurrenceArray.Count() == 10); // 10 entries are expected, if they are not present the test will fail later

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iEntryView->FetchL(KGUID(), entryArray);

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

	CCalEntry* entry = entryArray[0];

	iPrevTime -= TTimeIntervalHours(1); // take off an hour before starting

	TCalTime calTime, nextTime;

	calTime.SetTimeLocalL(iPrevTime);

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

		{

		nextTime = entry->NextInstanceForLocalUIDL(calTime);

		CheckThisTimeL(nextTime.TimeLocalL());

		calTime = nextTime;

		}

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

		{

		nextTime = entry->PreviousInstanceForLocalUIDL(calTime);

		CheckThisTimeL(nextTime.TimeLocalL());

		calTime = nextTime;

		}

	CleanupStack::PopAndDestroy(&entryArray);

	// delete the entry from the calendar file

	RPointerArray<CCalInstance> instArray;

	CalCommon::TCalTimeRange timeRange(calTime, calTime);

	iInstanceView->FindInstanceL(instArray, CalCommon::EIncludeAll, timeRange);

	ASSERT(instArray.Count() > 0); // if this fails, lastInstanceTime doesn't point to an instance

	iInstanceView->DeleteL(instArray[0], CalCommon::EThisAndAll);

	instArray.Remove(0);

	instArray.ResetAndDestroy();

	}

void CTestApp::TestNextAndPreviousInstanceL()

	{

	ASSERT(iOccurrenceArray.Count() == 10); // 10 entries are expected, if they are not present the test will fail later

	TTime lastInstanceTime(TestNextInstanceL(iPrevTime));

	// go forward one day before nudging backwards

	TestPreviousInstanceL(lastInstanceTime + TTimeIntervalDays(1));

	// delete the entry from the calendar file

	RPointerArray<CCalInstance> instArray;

	TCalTime calTime;

	calTime.SetTimeLocalL(lastInstanceTime);

	CalCommon::TCalTimeRange timeRange(calTime, calTime);

	iInstanceView->FindInstanceL(instArray, CalCommon::EIncludeAll, timeRange);

	ASSERT(instArray.Count() > 0); // if this fails, lastInstanceTime doesn't point to an instance

	iInstanceView->DeleteL(instArray[0], CalCommon::EThisAndAll);

	instArray.Remove(0);

	instArray.ResetAndDestroy();

	}

// Create an entry with the specified repeat rule

void CTestApp::AddEntryToDatabaseL(const TCalRRule& aRpt)

	{

	//create an entry and set the repeating rule and set its start time with rule's start time

	HBufC8* guid = KGUID().AllocLC();

	CCalEntry* entry = CCalEntry::NewL(iType, guid, CCalEntry::EMethodNone, 0);

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	TTime localDtStart(aRpt.DtStart().TimeLocalL());

	TCalTime entryStartTime;

	TCalTime entryEndTime;

	if (iType == CCalEntry::ETodo)

		{

		entryStartTime.SetTimeLocalL(localDtStart - TTimeIntervalHours(1));

		entryEndTime.SetTimeLocalL(localDtStart);

		}

	else

		{

		entryStartTime.SetTimeLocalL(localDtStart);

		entryEndTime.SetTimeLocalL(localDtStart + TTimeIntervalHours(1));

		}

	entry->SetStartAndEndTimeL(entryStartTime, entryEndTime);

	entry->SetRRuleL(aRpt);

	// test getrrule function here

	TCalRRule ruleToCompare;

	entry->GetRRuleL(ruleToCompare);

	if (aRpt.Until().TimeUtcL() != Time::NullTTime())

		{

		test(ruleToCompare.Until().TimeUtcL() == aRpt.Until().TimeUtcL());	

		}

	test(ruleToCompare.Type() == aRpt.Type());

	test(ruleToCompare.Interval() == aRpt.Interval());

	RPointerArray<CCalEntry> array;

	array.Append(entry);

	TInt success(0);

	iEntryView->StoreL(array, success);

	test(success == array.Count());

	array.Reset();

	CleanupStack::PopAndDestroy(entry);

	}

void CTestApp::SetupDailyRpt1L()

	{

	test.Next(_L("--- Daily test, every 1 day ---"));

	TCalRRule rpt(TCalRRule::EDaily);

	TTime daily1start(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0));

	TTime daily1end(TDateTime(2006, EJanuary, 17, 0, 0, 0, 0));

	TCalTime startTime;

	startTime.SetTimeLocalL(daily1start);

	rpt.SetDtStart(startTime);

	TCalTime endTime;

	endTime.SetTimeLocalL(daily1end);

	rpt.SetUntil(endTime);

	rpt.SetInterval(1);

	iOccurrenceArray.Reset();

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 18, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 19, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 20, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 21, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 22, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 23, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 24, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 25, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 26, 0, 0, 0, 0)));

	iPrevTime = daily1start;

	AddEntryToDatabaseL(rpt);

	}

void CTestApp::SetupDailyRpt2L()

	{

	test.Next(_L("--- Daily test, every 5 days ---"));

	TCalRRule rpt(TCalRRule::EDaily);

	TTime daily1start(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0));

	TCalTime startTime;

	startTime.SetTimeLocalL(daily1start);

	rpt.SetDtStart(startTime);

	rpt.SetCount(100);

	rpt.SetInterval(5);

	iOccurrenceArray.Reset();

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 22, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 27, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 1, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 6, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 11, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 16, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 21, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 26, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 3, 0, 0, 0, 0)));

	iPrevTime = daily1start;

	AddEntryToDatabaseL(rpt);

	}

void CTestApp::SetupDailyRpt3L()

	{

	test.Next(_L("--- Daily test, every 32 days ---"));

	TCalRRule rpt(TCalRRule::EDaily);

	TTime daily1start(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0));

	TTime daily1end(TDateTime(2006, EJanuary, 17, 0, 0, 0, 0));

	TCalTime startTime;

	startTime.SetTimeLocalL(daily1start);

	rpt.SetDtStart(startTime);

	TCalTime endTime;

	endTime.SetTimeLocalL(daily1end);

	rpt.SetUntil(endTime);

	rpt.SetInterval(32);

	iOccurrenceArray.Reset();

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 18, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 22, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EApril, 23, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMay, 25, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJune, 26, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJuly, 28, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EAugust, 29, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EOctober, 0, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, ENovember, 1, 0, 0, 0, 0)));

	iPrevTime = daily1start;

	AddEntryToDatabaseL(rpt);

	}

void CTestApp::SetupWeeklyRpt1L()

	{

	test.Next(_L("--- Weekly test, every Monday every week ---"));

	TCalRRule rpt(TCalRRule::EWeekly);

	TTime weekly1start(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0));

	TTime weekly1end(TDateTime(2008, EJanuary, 17, 0, 0, 0, 0));

	TCalTime startTime;

	startTime.SetTimeLocalL(weekly1start);

	rpt.SetDtStart(startTime);

	TCalTime endTime;

	endTime.SetTimeLocalL(weekly1end);

	rpt.SetUntil(endTime);

	RArray<TDay> array;

	array.Append(EMonday);

	rpt.SetByDay(array);

	array.Reset();

	rpt.SetInterval(1);

	iOccurrenceArray.Reset();

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 23, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 30, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 6, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 13, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 20, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 27, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 6, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 13, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 20, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 27, 0, 0, 0, 0)));

	iPrevTime = weekly1start;

	AddEntryToDatabaseL(rpt);

	}

void CTestApp::SetupWeeklyRpt2L()

	{

	test.Next(_L("--- Weekly test, every Tuesday and Friday every 2 weeks ---"));

	TCalRRule rpt(TCalRRule::EWeekly);

	TTime weekly1start(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0));

	TCalTime startTime;

	startTime.SetTimeLocalL(weekly1start);

	rpt.SetDtStart(startTime);

	rpt.SetCount(100);

	RArray<TDay> array;

	array.Append(ETuesday);

	array.Append(EFriday);

	rpt.SetByDay(array);

	array.Reset();

	rpt.SetInterval(2);

	iOccurrenceArray.Reset();

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 17, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EJanuary, 20, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 0, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 3, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 14, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EFebruary, 17, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 0, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 3, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 14, 0, 0, 0, 0)));

	iOccurrenceArray.AppendL(TTime(TDateTime(2005, EMarch, 17, 0, 0, 0, 0)));

	iPrevTime = weekly1start;

	AddEntryToDatabaseL(rpt);

	}