// 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 <calentry.h>

#include <calentryview.h>

#include <calalarm.h>

#include <calcategory.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calrrule.h>

#include <caliterator.h>

#include <tz.h>

#include <vtzrules.h>

#include <e32test.h>

#include <s32file.h>

static RTest test(_L("tcal_entryattributes"));

_LIT8(KGUID1, "A_Global_UID1");

_LIT8(KGUID2, "A_Global_UID2");

_LIT8(KGUID3, "A_Global_UID3");

_LIT8(KGUID4, "A_Global_UID4");

_LIT8(KGUID5, "A_Global_UID5");

_LIT(KCalName, "TestCalendar");

_LIT(KSummary1, "dummy summary text");

_LIT(KDescription1, "dummy description text");

class CEntryAttributesTestManager : public CBase

	{

public:

	static CEntryAttributesTestManager* NewLC();

	~CEntryAttributesTestManager();

	void CreateEntriesL(TBool aFloating = EFalse);

	void TestFetchAndDeleteNonExistentEntryL();

	void TestLiteEntriesL();

	void TestLastChangedDateL();

	void TestLastChangedDateWithStoreL();

	void StoreLastChangedDatesL();

	void CheckForValuesL(TBool aFlip);

	void UpdateEntriesL();

	void TestCopySummaryAndDescriptionL();

	void TestAlarmedCompletedTodoL();

	void FindSummaryL();

	void TestEndTimeBeforeStartTimeL();

	void TestEndTimeNullL();

	void TestEndTimeForeverL();

	void TestAlarmedTodoWithoutDueDateL();

	void TestGEOAttributesL();

	void TestGEOValueSetAndGetL();

	void TestGEOEntrySetAndGetL();

	void TestGEOVerifySetAndGetL(const TReal& aSetLat, const TReal& aSetLong, const TReal& aExpLat, const TReal& aExpLong, CCalGeoValue& aCalGeoValue) const;

	void TestGEOInternalizeAndExternalizeL();

	void TestGEOCompareAndCopyFromL();

	void UpdateEntryHaveRdateOnlyL();

	void TestStartDateTestL();

	void TestStoreEntryWithTzL();

	void TestRdateL();

	void TestDeleteInstancesL(TInt aLoop=0);

	void GetInstanceCrossDstL();

	void FindInstancesL(TInt aExpectedNumInstances);

	// from former tcal_CopyEntryImpl

	void CreateEntriesForCopyL();

	void CreateEventForCopyPasteL();

	// for DEF080249: Addition of additional child entry with repeat rule should fail

	void AddTwoRepeatingChildL();

	void StoreAndExportL();

private:

	CEntryAttributesTestManager();

	void TestEndTimeNullL(CCalEntry::TType aType);

	// no copy constructor and assignment operator

	CEntryAttributesTestManager(CEntryAttributesTestManager& );

	CEntryAttributesTestManager& operator = (const CEntryAttributesTestManager& );

	void ConstructL();

	void TestCalEntryL(CCalEntry* aEntry, TBool aFloating = EFalse);

	void TestThisLiteEntryL(CCalEntry* aEntry);

	// from former tcal_CopyEntryImpl

	void CopyEventForCopyPasteL(const CCalEntry& aEntry);

	void CopyEntryL(const CCalEntry& aEntry);

private:

	CCalTestLibrary* iTestLib;

	CArrayFix<TTime>* iDateArray;

	};

// Constructor/Destructor

CEntryAttributesTestManager* CEntryAttributesTestManager::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

CEntryAttributesTestManager::CEntryAttributesTestManager()

	{

	}

void CEntryAttributesTestManager::ConstructL()

	{

	iDateArray = new(ELeave) CArrayFixFlat<TTime>(5);

	iTestLib = CCalTestLibrary::NewL(EFalse);

	iTestLib->ReplaceFileL(KCalName());

	iTestLib->OpenFileL(KCalName());

	}

CEntryAttributesTestManager::~CEntryAttributesTestManager()

	{

	TRAP_IGNORE(iTestLib->DeleteFileL(KCalName));

	delete iDateArray;

	delete iTestLib;

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Test cases forming the Entry Attributes test suite

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void CEntryAttributesTestManager::TestDeleteInstancesL(TInt aLoop)

	{

	test.Printf(_L("Test TestDeleteInstancesL started\n"));

	_LIT8(KRnzLine1, "BEGIN:VCALENDAR\r\n"

					 "VERSION:1.0\r\n"

					 "TZ:+00\r\n"

					 "DAYLIGHT:TRUE;+01;20010325T010000Z;20011028T010000Z;;\r\n"

					 "DAYLIGHT:TRUE;+01;20070325T010000Z;20071028T010000Z;;\r\n"

					 "DAYLIGHT:TRUE;+01;20080330T010000Z;20081026T010000Z;;\r\n"

					 "DAYLIGHT:TRUE;+01;20090329T010000Z;20091025T010000Z;;\r\n"

					 "DAYLIGHT:TRUE;+01;20100328T010000Z;20101031T010000Z;;\r\n"

					 "DAYLIGHT:TRUE;+01;20110327T010000Z;20111030T010000Z;;\r\n"

					 "BEGIN:VEVENT\r\n"

					 "UID:5\r\n"

					 "DUE:19990416T230000Z\r\n"

					 "DTSTART:20010925T170000Z\r\n"

					 "DTEND:20010925T170000Z\r\n"

					 "X-EPOCAGENDAENTRYTYPE:ANNIVERSARY\r\n"

					 "CLASS:PUBLIC\r\n"

					 "SEQUENCE:0\r\n"

					 "X-METHOD:ADD\r\n"

					 "RRULE:YM1 9 #2\r\n"

					 "END:VEVENT\r\n"

					 "END:VCALENDAR\r\n");	

	RPointerArray<CCalEntry> importedEntryArr;

	CleanupResetAndDestroyPushL(importedEntryArr);

	iTestLib->ImportL(KRnzLine1, importedEntryArr);

	test.Printf(_L("File imported\n"));

	// store in the cal file

	TInt success = 0;

	iTestLib->SynCGetEntryViewL().StoreL(importedEntryArr, success);

	test(success == 1);

	CleanupStack::PopAndDestroy(&importedEntryArr);

	// fetch instances

	TTime		startDate(TDateTime(2000, EJanuary, 0, 12, 0, 0, 0));

	TCalTime	start;

	start.SetTimeUtcL(startDate);

	TTime		endDate(TDateTime(2098, EJanuary, 0, 12, 0, 0, 0));

	TCalTime	end;

	end.SetTimeUtcL(endDate);

	CalCommon::TCalTimeRange	timeRange(start, end);

	CalCommon::TCalViewFilter	filter=CalCommon::EIncludeAll;

	RPointerArray<CCalInstance> fetchedInstanceArr;

	CleanupClosePushL(fetchedInstanceArr);	

	iTestLib->SynCGetInstanceViewL().FindInstanceL(fetchedInstanceArr, filter, timeRange);

	TInt countInstances=fetchedInstanceArr.Count();

	// try to delete one-by-one

	if( aLoop==0 )

		{

		// one way to do it

		for(TInt i=countInstances-1;i>=0;i--)

			{

			iTestLib->SynCGetInstanceViewL().DeleteL(fetchedInstanceArr[i], CalCommon::EThisAndFuture); 

			}

		test.Printf(_L("TestDeleteInstances1 Finished\n"));

		}

	else

		{

		// another way to delete instaces

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

			{

			iTestLib->SynCGetInstanceViewL().DeleteL(fetchedInstanceArr[i], CalCommon::EThisAndPrior); 

			}

		// cleanup

		test.Printf(_L("TestDeleteInstances2 Finished\n"));

		}

	CleanupStack::PopAndDestroy(&fetchedInstanceArr);

}

/* Set and get each property on a CCalEntry and check the two match. */ 	

void CEntryAttributesTestManager::TestCalEntryL(CCalEntry* aEntry, TBool aFloating)

	{

	TTime time1;

	time1.HomeTime();

	TTime time2(time1);

	time2 += TTimeIntervalHours(2);

	time2 += TTimeIntervalYears(1);

	TCalTime calTime1;

	TCalTime calTime2;

	if (aFloating)

		{

		calTime1.SetTimeLocalFloatingL(time1);

		calTime2.SetTimeLocalFloatingL(time2);

		}

	else

		{

		calTime1.SetTimeUtcL(time1);

		calTime2.SetTimeUtcL(time2);		

		}

	aEntry->SetStartAndEndTimeL(calTime1, calTime2);

	test.Next(_L("Start date"));

	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

		{

		if (aFloating)

			{

			test(aEntry->StartTimeL().TimeLocalL().DaysFrom(time1).Int() == 0);

			}

		else

			{

			test(aEntry->StartTimeL().TimeUtcL().DaysFrom(time1).Int() == 0);

			}

		}

	else

		{

		if (aFloating)

			{

			test(aEntry->StartTimeL().TimeLocalL() == time1);

			}

		else

			{

			test(aEntry->StartTimeL().TimeUtcL() == time1);

			}

		}

	if (aEntry->EntryTypeL() == CCalEntry::EReminder)

		{

		test.Next(_L("End date"));

		if (aFloating)

			{

			test(aEntry->EndTimeL().TimeLocalL() == Time::NullTTime());	

			}

		else

			{

			test(aEntry->EndTimeL().TimeUtcL() == Time::NullTTime());

			}

		}

	else 

		{

		test.Next(_L("End date"));

		if (aFloating)

			{

			test(aEntry->EndTimeL().TimeLocalL() == time2);

			}

		else

			{

			test(aEntry->EndTimeL().TimeUtcL() == time2);

			}

		}

	if (aFloating)

		{

		test.Next(_L("time mode"));

		test(aEntry->StartTimeL().TimeMode() == TCalTime::EFloating);

		if (aEntry->EntryTypeL() != CCalEntry::EReminder)

			{

			test(aEntry->EndTimeL().TimeMode() == TCalTime::EFloating);

			}

		}

	test.Next(_L("alarm setting"));

	CCalAlarm* alarm = aEntry->AlarmL();

	test(alarm == NULL);

	TTime time4(time1);

	time4 += TTimeIntervalHours(5);

	alarm = CCalAlarm::NewL();

	const TInt KAlarmOffset(600);

	alarm->SetTimeOffset(KAlarmOffset);

	alarm->SetAlarmSoundNameL(KNullDesC());

	aEntry->SetAlarmL(alarm);

	delete alarm;

	alarm = NULL;

	TTimeIntervalHours hours2(0);

	alarm = aEntry->AlarmL();

	test(alarm->TimeOffset().Int() == KAlarmOffset);

	test(alarm->AlarmSoundNameL().Length() == 0);

	alarm->SetAlarmSoundNameL(_L("dummy"));

	test(alarm->AlarmSoundNameL().Compare(_L("dummy")) == 0);

	delete alarm;

	alarm = NULL;

	aEntry->SetAlarmL(NULL);

	test(aEntry->AlarmL() == NULL);

	const TInt KHugeAlarmOffset(600000);

	alarm = CCalAlarm::NewL();

	alarm->SetTimeOffset(KHugeAlarmOffset);

	aEntry->SetAlarmL(alarm);

	delete alarm;

	alarm = NULL;

	alarm = aEntry->AlarmL();

	test(alarm->TimeOffset().Int() == KHugeAlarmOffset);

	delete alarm;

	TTime time5(time1);

	time5 += TTimeIntervalHours(2);

	time5 += TTimeIntervalDays(5);

	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

		{

		test.Next(_L("status"));

		aEntry->SetStatusL(CCalEntry::ETodoNeedsAction);

		test(aEntry->StatusL() == CCalEntry::ETodoNeedsAction);

		aEntry->SetStatusL(CCalEntry::ETodoInProcess);

		test(aEntry->StatusL() == CCalEntry::ETodoInProcess);

		test.Next(_L("complete date"));

		TCalTime completedCalTime;

		completedCalTime.SetTimeUtcL(time5);

		aEntry->SetCompletedL(ETrue, completedCalTime);

		test(aEntry->StatusL() == CCalEntry::ETodoCompleted);

		test(aEntry->CompletedTimeL().TimeUtcL() == time5);

		aEntry->SetCompletedL(EFalse, completedCalTime);

		test(aEntry->StatusL() != CCalEntry::ETodoCompleted);

		}

	else 

		{

		test.Next(_L("status"));

		aEntry->SetStatusL(CCalEntry::EConfirmed);

		test(aEntry->StatusL() == CCalEntry::EConfirmed);

		aEntry->SetStatusL(CCalEntry::ETentative);

		test(aEntry->StatusL() == CCalEntry::ETentative);

		}

	test.Next(_L("priority"));

	aEntry->SetPriorityL(5);

	test(aEntry->PriorityL() == 5);

	aEntry->SetPriorityL(9);

	test(aEntry->PriorityL() == 9);

	test.Next(_L("summary"));

	TBuf<32> buf1;

	buf1.Copy(KSummary1);

	aEntry->SetSummaryL(buf1);

	test(aEntry->SummaryL().Compare(buf1) == 0);

	test.Next(_L("Description"));

	TBuf<32> buf2;

	buf2.Copy(KDescription1);

	aEntry->SetDescriptionL(buf2);

	test(aEntry->DescriptionL().Compare(buf2) == 0);

	test.Next(_L("Location"));

	TBuf<32> buf3;

	buf3.Copy(_L("dummy Location text"));

	aEntry->SetLocationL(buf3);

	test(aEntry->LocationL().Compare(buf3) == 0);

	test.Next(_L("Category"));

	const RPointerArray<CCalCategory> categoryList = aEntry->CategoryListL();

	test(categoryList.Count() == 0);

	TBuf<32> buf4;

	buf4.Copy(_L("dummy Category text"));

	CCalCategory* category = CCalCategory::NewL(buf4);

	CleanupStack::PushL(category);

	aEntry->AddCategoryL(category);

	CleanupStack::Pop(category);

	const RPointerArray<CCalCategory> categoryList1 = aEntry->CategoryListL();

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

	test(categoryList1[0]->ExtendedCategoryName().Compare(buf4) == 0);

	test.Next(_L("DTSTAMP"));

	TTime now;

	now.UniversalTime();

	TCalTime dTStampTime;

	dTStampTime.SetTimeUtcL(now);

	aEntry->SetDTStampL(dTStampTime);

	test(dTStampTime.TimeUtcL() == aEntry->DTStampL().TimeUtcL());

	// copy this entry

	test.Next(_L("entry copying"));

	HBufC8* uid = aEntry->UidL().AllocLC();

	CCalEntry* entryCopy = CCalEntry::NewL(aEntry->EntryTypeL(), uid, aEntry->MethodL(), 

		aEntry->SequenceNumberL(), aEntry->RecurrenceIdL(), aEntry->RecurrenceRangeL());

	CleanupStack::Pop(uid);

	CleanupStack::PushL(entryCopy);

	entryCopy->CopyFromL(*aEntry);

	test(entryCopy->CompareL(*aEntry));

	CleanupStack::PopAndDestroy(entryCopy);

	test.Next(_L("last modified date"));

	now.UniversalTime();

	aEntry->SetLastModifiedDateL();

	TTimeIntervalSeconds secs;

	aEntry->LastModifiedDateL().TimeUtcL().SecondsFrom(now, secs);

	test(secs.Int() < 2);

	test.Next(_L("method"));

		{

		// positive testing	

		aEntry->SetMethodL(CCalEntry::EMethodAdd);

		test(aEntry->MethodL() == CCalEntry::EMethodAdd);

		aEntry->SetMethodL(CCalEntry::EMethodCancel);

		test(aEntry->MethodL() == CCalEntry::EMethodCancel);

		aEntry->SetMethodL(CCalEntry::EMethodNone);

		test(aEntry->MethodL() == CCalEntry::EMethodNone);	

		aEntry->SetMethodL(CCalEntry::EMethodPublish);

		test(aEntry->MethodL() == CCalEntry::EMethodPublish);

		aEntry->SetMethodL(CCalEntry::EMethodRequest);

		test(aEntry->MethodL() == CCalEntry::EMethodRequest);

		aEntry->SetMethodL(CCalEntry::EMethodReply);

		test(aEntry->MethodL() == CCalEntry::EMethodReply);

		aEntry->SetMethodL(CCalEntry::EMethodRefresh);

		test(aEntry->MethodL() == CCalEntry::EMethodRefresh);

		aEntry->SetMethodL(CCalEntry::EMethodCounter);

		test(aEntry->MethodL() == CCalEntry::EMethodCounter);

		aEntry->SetMethodL(CCalEntry::EMethodDeclineCounter);

		test(aEntry->MethodL() == CCalEntry::EMethodDeclineCounter);

		// negative testing	

		TRAPD(err1, aEntry->SetMethodL(CCalEntry::TMethod(CCalEntry::EMethodNone-1)) );

		test(err1 == KErrArgument);

		TRAPD(err2, aEntry->SetMethodL(CCalEntry::TMethod(CCalEntry::EMethodDeclineCounter+1)) );

		test(err2 == KErrArgument);

		}	

		test.Next(_L("sequence number"));

		{

		aEntry->SetSequenceNumberL(1);

		test(aEntry->SequenceNumberL() == 1);

		}	

	test.Next(_L("replication status"));

		{

		// positive testing

		aEntry->SetReplicationStatusL(CCalEntry::EOpen);

		test(aEntry->ReplicationStatusL() == CCalEntry::EOpen);

		aEntry->SetReplicationStatusL(CCalEntry::EPrivate);

		test(aEntry->ReplicationStatusL() == CCalEntry::EPrivate);

		aEntry->SetReplicationStatusL(CCalEntry::ERestricted);

		test(aEntry->ReplicationStatusL() == CCalEntry::ERestricted);

		// negative testing	

		TRAPD(err1, aEntry->SetReplicationStatusL(CCalEntry::TReplicationStatus(CCalEntry::EOpen-1)) );

		test(err1 == KErrArgument);

		TRAPD(err2, aEntry->SetReplicationStatusL(CCalEntry::TReplicationStatus(CCalEntry::ERestricted+1)) );

		test(err2 == KErrArgument);

		}