// 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:

//

#include "caltestlib.h"

#include <e32std.h>

#include <e32test.h>

#include <asclisession.h>

#include <asshdalarm.h>

#include <tz.h>

#include <calalarm.h>

#include <calentry.h>

#include <calentryview.h>

#include <calprogresscallback.h>

#include <calsession.h>

#include <calrrule.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caliterator.h>

RTest test(_L("tcal_recur"));

_LIT(KCalendarFile, "tcal_recur");

_LIT8(KGUID, "A_Global_UID");

//useful for debugging purposes, allows you to view the instances of an entry

// Timezone constants

_LIT8(KEuropeBerlin, "Europe/Berlin");

class CTestApp : public CBase

	{

public:

	CTestApp();

	~CTestApp();

	static CTestApp *NewLC() ;

	void ConstructL();

	void RunTestL();

	void TestRecurrenceIdPanicL();	

	void ClearAllAlarmsL() ;

    void RunRecurrenceTestL();

    void RecurrenceTestL(TDateTime aParentStartTime, TDateTime aParentEndTime, TDateTime aChildStartTime, TDateTime aChildEndTime, TDateTime aRecurrenceId);

	void ChildRecurrenceIdTestL();

	void ClearDatabaseL();

	void CheckRRangeL( RArray<CalCommon::TRecurrenceRange> &aRanges );

	void CheckWithFindInstanceL(TCalTime& aStartRange,TCalTime& aEndRange,CalCommon::TCalViewFilter aFilter,TInt aExpectedInstances);

	TInt CreateRepeatingChildL(TCalTime& aChildRptStart,TCalTime& aChildRptEnd,TCalTime& aRecurId, CalCommon::TRecurrenceRange& aRange, TCalRRule::TType& aRType );

	void CreateParentL(TCalTime& aParentRptStart,TCalTime& aParentRptEnd, TCalRRule::TType& aRType );

	void TestRecurrenceRangeL();

	void MultipleChildsWithRRulesL();

	void TestRDatesForParentChildL();

	void TestSingleDayRepeatL();

	void VerifyInstancesAfterLeaveWhileAddingChildL();

	void MiscellaneousTestCasesL();

public:

	CCalTestLibrary*	iTestLibrary;	

	RTz iTzServer;

private:		

	RASCliSession iAlarmServer;

	CTzId*				iTzID;

	CCalEntryView*		iEntryView;	// not owned

	CCalInstanceView*	iInstanceView;// not owned

	};

CTestApp::CTestApp()

	{

	}

CTestApp::~CTestApp()

	{

 	if (iTzID && iTestLibrary)

		{

		TRAP_IGNORE(iTestLibrary->SetTimeZoneL(iTzID->TimeZoneNameID()));

		}

	iAlarmServer.Close();	

	iTzServer.Close();

	delete iTestLibrary;

	delete iTzID;

	}

void CTestApp::ClearAllAlarmsL()

	{

	// Delete all alarms

	RArray<TAlarmCategory> categories;

	iAlarmServer.GetAvailableCategoryListL(categories);

	TInt count = categories.Count();

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

		{

		const TAlarmCategory category = categories[i];

		test(iAlarmServer.AlarmDeleteAllByCategory(category, EFalse) == KErrNone);

		}

	categories.Close();

	// Restore alarm sound

	iAlarmServer.SetAlarmSoundState(EAlarmGlobalSoundStateOn);

	}

CTestApp* CTestApp::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

void CTestApp::ConstructL()

	{

	iTestLibrary = CCalTestLibrary::NewL();

	iTestLibrary->SetTimeZoneL(KEuropeBerlin);

	iTestLibrary->ReplaceFileL(KCalendarFile());

	iTestLibrary->OpenFileL(KCalendarFile());

	iInstanceView = &iTestLibrary->SynCGetInstanceViewL();

	iEntryView = &iTestLibrary->SynCGetEntryViewL();

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

	iTzID = iTzServer.GetTimeZoneIdL();

	// Connect to the alarm server

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

	// Make sure that the alarm queue is empty.

	ClearAllAlarmsL();

	}

void CTestApp::RunTestL()

	{

// create repeating parent entry	

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

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

	CleanupStack::Pop(guid);	

	CleanupStack::PushL(entry);

	TCalTime startTime;

	TCalTime endTime;	

	startTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 8, 10, 1, 0, 0))) ;

	endTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 14, 10, 0, 0, 0))) ;		

	entry->SetStartAndEndTimeL(startTime, endTime) ;

	TCalRRule rrule(TCalRRule::EDaily);

	rrule.SetDtStart(startTime);

	rrule.SetUntil(endTime);

	rrule.SetInterval(1);	

	entry->SetRRuleL(rrule);				

	CCalAlarm *alarm = CCalAlarm::NewL();

	CleanupStack::PushL(alarm);			

	alarm->SetTimeOffset(TTimeIntervalMinutes(0)) ;

	entry->SetAlarmL(alarm);

	RPointerArray<CCalEntry> entryarr;

	CleanupClosePushL(entryarr);

	entryarr.AppendL(entry);

	TInt num = 0;

	iEntryView->StoreL(entryarr, num);

	test(entryarr.Count() == num);

	CleanupStack::PopAndDestroy(&entryarr);

	CleanupStack::PopAndDestroy(alarm);	

	CleanupStack::PopAndDestroy(entry);	

// Create child entry with exception

	TTime ttime1(TDateTime(2006, EJanuary, 9, 10, 1, 0, 0));

	TCalTime recId;

	recId.SetTimeUtcL(ttime1); // creating recurrence id

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

	CCalEntry *entry1 = CCalEntry::NewL(CCalEntry::EReminder, guid1, CCalEntry::EMethodNone, 0, recId, CalCommon::EThisOnly);

	CleanupStack::Pop(guid1);			

	CleanupStack::PushL(entry1);	

	TCalTime startTime1;

	TCalTime endTime1;	

	startTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 9, 10, 2, 0, 0)));

	endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 11, 10, 0, 0, 0)));		

	entry1->SetStartAndEndTimeL(startTime1, endTime1);

	CCalAlarm* alarm1 = CCalAlarm::NewL();

	CleanupStack::PushL(alarm1) ;			

	alarm1->SetTimeOffset(TTimeIntervalMinutes(0));

	entry1->SetAlarmL(alarm1);

	RPointerArray<CCalEntry> entryarr1;	

	CleanupClosePushL(entryarr1);

	entryarr1.AppendL(entry1);	

	iEntryView->StoreL(entryarr1, num);

	test(entryarr1.Count() == num);

	CleanupStack::PopAndDestroy(&entryarr1);

	CleanupStack::PopAndDestroy(alarm1);

	CleanupStack::PopAndDestroy(entry1);	

	// for debugging

	RPointerArray<CCalInstance> ins_arr;

	CleanupResetAndDestroyPushL(ins_arr);

	CalCommon::TCalTimeRange trange(startTime, endTime);

	iInstanceView->FindInstanceL(ins_arr, CalCommon::EIncludeAll, trange);

	const TInt KCount = ins_arr.Count();

	for(int i = 0; i < KCount; i++)

		{

		CCalEntry &ent = ins_arr[i]->Entry();

		TCalTime tt = ent.RecurrenceIdL();		

		}		

	CleanupStack::PopAndDestroy(&ins_arr);

	// now check what we have got in alarm servers

	for(int i = 0; i < 2; i++)

		{	

		TTime time(TDateTime(2006, EJanuary, 8 + i, 10, 0, 0, 0)); // how to set recurrance rule?

		User::SetUTCTime(time);	

		User::After(1000000);

		TAlarmId id;

		iAlarmServer.GetNextDueAlarmId(id);	

		HBufC8* alarmData = NULL;

		TInt err = iAlarmServer.GetAlarmData(id, alarmData);

		if( (err != KErrNone) || (!alarmData))

    		{

    		User::Leave(-1);

    		}

		CleanupStack::PushL( alarmData );

		CCalEntryId* entryId = CCalEntryId::NewL( alarmData );

		CleanupStack::Pop(alarmData); 

		CleanupStack::PushL(entryId);

		TPtrC8 id1 = entryId->IdL();

		TPtrC name = entryId->StoreFileNameL();

		TTime recurrenceId = entryId->RecurrenceIdL().TimeUtcL(); 

		TTime instanceTime = entryId->InstanceTimeL().TimeLocalL(); // OK, has start time of the child

		if (i == 0)

			{

			test(recurrenceId == Time::NullTTime()); // for the parent

			}

		else if (i == 1)

			{

			test(recurrenceId != Time::NullTTime()); // for one child

			}

		CleanupStack::PopAndDestroy(entryId);	

		}

	}

void CTestApp::TestRecurrenceIdPanicL()

	{

    RPointerArray<CCalEntry> entries;

    CleanupResetAndDestroyPushL(entries);

	// Create an entry

	_LIT8(KUid, "12345");

	CCalEntry *entry = CCalEntry::NewL(CCalEntry::EAppt, KUid().AllocLC(), CCalEntry::EMethodRequest, 0);

	CleanupStack::Pop(); // uid

	CleanupStack::PushL(entry);

	TDateTime dtStart, dtEnd;

	dtStart.Set(2006, EApril, 19, 15, 30, 0, 0);

	dtEnd.Set(2006, EApril, 19, 15, 40, 0, 0);

	TCalTime startTime,endTime;

	startTime.SetTimeUtcL(TTime(dtStart));

	endTime.SetTimeUtcL(TTime(dtEnd));

	entry->SetStartAndEndTimeL(startTime, endTime);

	entry->SetSummaryL(_L("summary"));

	//Add a daily repeat

	TCalRRule rule;

	rule.SetType(TCalRRule::EDaily);

	rule.SetDtStart(startTime);

	rule.SetCount(10);

	entry->SetRRuleL(rule);

	entries.AppendL(entry);

	CleanupStack::Pop(entry);

	    //Create an exception

	CCalEntry *child = CCalEntry::NewL(entry->EntryTypeL(),

	                                               entry->UidL().AllocL(),

	                                               entry->MethodL(),

	                                               entry->SequenceNumberL(),

	                                               startTime,

	                                               CalCommon::EThisOnly);

	CleanupStack::PushL(child);

	child->SetSummaryL(_L("EXEX"));

	child->SetLocationL(_L("EXEX"));

	child->SetStartAndEndTimeL(startTime, endTime);

	entries.AppendL(child);

	CleanupStack::Pop(child);

    TInt success = 0;

    iTestLibrary->SynCGetEntryViewL().StoreL(entries, success);

    entries.ResetAndDestroy();

    // Refetch entries from db

    iTestLibrary->SynCGetEntryViewL().FetchL(KUid, entries);

    TInt entryCount = entries.Count();

    ASSERT(entryCount == 2);

    CCalEntry* ex = entries[1];    //0 = parent, 1 = child

	HBufC8* guid = ex->UidL().AllocLC();

	CCalEntry* copy = CCalEntry::NewL( ex->EntryTypeL(),

		                            guid,

		                            ex->MethodL(),

		                            ex->SequenceNumberL(),

		                            ex->RecurrenceIdL(),

		                            ex->RecurrenceRangeL() );

	CleanupStack::Pop( guid ); // ownership was passed 

	CleanupStack::PushL( copy );

	copy->CopyFromL( *ex );

    //Access the recurrence id fields

    TCalTime exTime1 = ex->RecurrenceIdL();

    TCalTime cpTime1 = copy->RecurrenceIdL();

    //Delete all from db

    iTestLibrary->CleanDatabaseL();

    //Access the recurrence id fields again

    TCalTime exTime2 = ex->RecurrenceIdL();

    TCalTime cpTime2 = copy->RecurrenceIdL();   //Causes KERN-EXEC-3

	CleanupStack::PopAndDestroy( copy );

    CleanupStack::PopAndDestroy(&entries);

	}

/**

@SYMTestCaseID  PIM-CALENDAR-RECUR-0001

@SYMDEF DEF078776

@SYMTestType UT

@SYMTestPriority Critical

@SYMDEF DEF078776

@SYMTestCaseDesc Create a parent calendar entry with a child entry.

@SYMTestActions

1. Tests a parent entry and child entry with a standard valid recurrence ID with date and time

2. Tests a parent entry and child entry with a recurrence ID with date but no time

3. Tests a parent entry and child entry with a recurrence ID with a date and time. The time is set so it that is not within the parents occurence.

4. Tests a parent entry and child entry with a recurrence ID with a date that is not within the parent occurence.

@SYMTestExpectedResults For the above tests:

1. No leaves or panics should occur

2. No leaves or panics should occur

3. Should leave with KErrNotFound

4. Should leave with KErrNotFound

*/

void CTestApp::RunRecurrenceTestL()

    {

    // Test normal recurrenceId with date and time:

    TDateTime parentStartTime(2006, EJanuary, 8, 10, 0, 0, 0);

    TDateTime parentEndTime(2006, EJanuary, 14, 10, 0, 0, 0);

    TDateTime childStartTime(2006, EJanuary, 9, 10, 0, 0, 0);

    TDateTime childEndTime(2006, EJanuary, 11, 10, 0, 0, 0);

    TDateTime recurrenceId(2006, EJanuary, 9, 10, 0, 0, 0);

    RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId);

    // Test recurrenceId that has a date but no time:

    recurrenceId = TDateTime(2006, EJanuary, 9, 0, 0, 0, 0);

    RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId);

    // Test recurrenceId that has a date but no time but is not within the same date as the parent occurence

    recurrenceId = TDateTime(2006, EJune, 9, 0, 0, 0, 0);

    TRAPD(ret, RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId));

    test(ret == KErrNotFound); // ret should be KErrNotFound as the recurrenceId is not valid

    // Test recurrenceId that has a date and time which is not within the same date as the parent occurence

    recurrenceId = TDateTime(2006, EJanuary, 9, 10, 30, 0, 0);

    TRAP(ret, RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId));

    test(ret == KErrNotFound); // ret should be KErrNotFound as the recurrenceId is not valid

    }

void CTestApp::RecurrenceTestL(TDateTime aParentStartTime, TDateTime aParentEndTime, TDateTime aChildStartTime, TDateTime aChildEndTime, TDateTime aRecurrenceId)

    {  

// Create repeating parent entry

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

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

    CleanupStack::Pop(guid);   

    CleanupStack::PushL(entry);

    TCalTime startTime;

    TCalTime endTime;

    startTime.SetTimeUtcL(TTime(aParentStartTime));

    endTime.SetTimeUtcL(TTime(aParentEndTime));

    entry->SetStartAndEndTimeL(startTime, endTime);

    TCalRRule rrule(TCalRRule::EDaily);

    rrule.SetDtStart(startTime);

    rrule.SetUntil(endTime);

    rrule.SetInterval(1);   

    entry->SetRRuleL(rrule);

    RPointerArray<CCalEntry> entryarr;

    CleanupClosePushL(entryarr);

    entryarr.AppendL(entry);

    TInt num = 0;

    iEntryView->StoreL(entryarr, num);

    test(entryarr.Count() == num);

    CleanupStack::PopAndDestroy(&entryarr);

    CleanupStack::PopAndDestroy(entry);

// Create child entry with recurrence Id

    TTime ttime1(aRecurrenceId);

    TCalTime recId;

    recId.SetTimeUtcL(ttime1); // creating recurrence id

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

    CCalEntry *entry1 = CCalEntry::NewL(CCalEntry::EReminder, guid1, CCalEntry::EMethodNone, 0, recId, CalCommon::EThisOnly);

    CleanupStack::Pop(guid1);           

    CleanupStack::PushL(entry1);

    TCalTime startTime1;

    TCalTime endTime1;   

    startTime1.SetTimeUtcL(TTime(aChildStartTime));

    endTime1.SetTimeUtcL(TTime(aChildEndTime));

    entry1->SetStartAndEndTimeL(startTime1, endTime1);

    RPointerArray<CCalEntry> entryarr1;

    CleanupClosePushL(entryarr1);

    entryarr1.AppendL(entry1);

    iEntryView->StoreL(entryarr1, num);

    test(entryarr1.Count() == num);    

    CleanupStack::PopAndDestroy(&entryarr1);

    CleanupStack::PopAndDestroy(entry1);

    }

/**

@SYMTestCaseID PIM-TCAL-RECUR-0002

@SYMDEF DEF080989

@SYMTestType UT

@SYMTestPriority Critical

@SYMDEF DEF080989

@SYMTestCaseDesc RecurrenceIdL() returns NullTTime for new CCalEntry

@SYMTestActions

1) create a  REPEATING Parent

2) create a Child Entry with a Recurrence Id which wud be an instance of the parent entry.

3) call ChildEntry->CopyFromL(Parent);

4) check for Recurrence ID using ChildEntry->RecurrenceIdL()

@SYMTestExpectedResults For the above tests:

Recurrence ID using ChildEntry->RecurrenceIdL() should not equal null

*/

void CTestApp::ChildRecurrenceIdTestL()

	{

	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-RECUR-0002 Child Recurrance Id test"));

	HBufC8 *uid = NULL;

	CCalEntry* entry = iTestLibrary->CreateCalEntryL(CCalEntry::EReminder, uid);

	CleanupStack::PushL( entry );

	TCalTime timeStart;

	TCalTime timeEnd;

	TCalTime entryEnd;

	timeStart.SetTimeUtcL( TDateTime(2006,EJanuary,2,3,4,5,6) );

	timeEnd.SetTimeUtcL( TDateTime(2006,EJanuary,10,3,4,5,6) );

	entryEnd.SetTimeUtcL( TDateTime(2006,EJanuary,2,4,4,5,6) );

	TCalRRule rule(TCalRRule::EDaily) ;

	rule.SetDtStart(timeStart);

	rule.SetUntil(timeEnd);

	rule.SetInterval(1);