// Copyright (c) 1997-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 <calentry.h>

#include <calentryview.h>

#include <calinstanceview.h>

#include <calsession.h>

#include <e32test.h>

#include <caliterator.h>

#include <caluser.h>

#include <calrrule.h>

#include <calcategorymanager.h>

#include <calcategory.h>

#include <calinstance.h>

#include "caltestlib.h"

RTest test(_L("tcal_delete"));

_LIT(KCalendarFile,"tcal_delete");

_LIT(KCalendarFile2, "tcal_delete_calendar_copy");

_LIT(KOriginalDeleteCalendar, "z:\\private\\10003A5B\\tcal_delete_calendar");

_LIT8( KGUIDInc081869, "Guid081869" );

_LIT(KRecurrIdLocalTime, "20030500:000000.");   // June 1, 2003 00:00:00

// This number must be even and greater than the highest defined value in 

// KTidyCallbackRate, currently 24.  

// This would ensure the callback feature gets triggered for testing.

const TInt KNumberOfEntries = 26;

class CDummyCalendarApp;

// Progress call back utility class

class CProgressCallBack : public CBase, public MCalProgressCallBack

	{

public:

	void Progress(TInt aPercentageCompleted);	

	void Completed(TInt aError);	

	TBool NotifyProgress();

	};

void CProgressCallBack::Progress(TInt aPercentageCompleted)

	{

	test.Printf(_L("DeleteL is %d%% complete\n"), aPercentageCompleted);

	}

void CProgressCallBack::Completed(TInt aError)

	{

	test.Printf(_L("DeleteL has completed with error code %d\n"), aError);

	__ASSERT_ALWAYS(aError == KErrNone, User::Invariant());

	CActiveScheduler::Stop();

	}

TBool CProgressCallBack::NotifyProgress()

	{

	return ETrue;

	}

// a dummy test app that runs in a different thread

class CSecondThreadApp : public CBase

	{

public:

	static CSecondThreadApp* NewL();

	~CSecondThreadApp();

	void RunTestL();

	void TestFileLockL(TInt aError);

private:

	void ConstructL();

	CSecondThreadApp();

public:

	CCalTestLibrary* iCalTestLib;

	TInt iNumEntriesAdded;

	};

CSecondThreadApp* CSecondThreadApp::NewL()

	{

	CSecondThreadApp* self = new(ELeave) CSecondThreadApp;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CSecondThreadApp::ConstructL()

	{

	iCalTestLib = CCalTestLibrary::NewL();

	iCalTestLib->OpenFileL(KCalendarFile);

	}

CSecondThreadApp::CSecondThreadApp()

	{

	}

CSecondThreadApp::~CSecondThreadApp()

	{

	delete iCalTestLib;

	}

void CSecondThreadApp::RunTestL()

	{

	RThread thread;

	thread.Rendezvous(KErrNone);

	// wait for the other thread to call DeleteL

	thread.Suspend();

	// test that the file is locked

	TestFileLockL(KErrLocked);

	// wait for the DeleteL to finish

	thread.Suspend();

	// test that the file is now unlocked

	TestFileLockL(KErrNone);

	}

void CSecondThreadApp::TestFileLockL(TInt aError)

	{

	TCalTime from;

	from.SetTimeLocalL(TDateTime(2005, ESeptember, 11, 0, 0, 0, 0));

	TCalTime resultTime;

	// NextInstanceL

	RDebug::Printf("Test NextInstanceL");

	TInt error(KErrNone);

	TRAP(error, resultTime = iCalTestLib->SynCGetInstanceViewL().NextInstanceL(CalCommon::EIncludeAll, from));

	if (error != aError) 

		{

		User::Leave(KErrGeneral);

		}

	// PreviousInstanceL

	RDebug::Printf("Test PreviousInstanceL");

	error = KErrNone;

	TRAP(error, resultTime = iCalTestLib->SynCGetInstanceViewL().PreviousInstanceL(CalCommon::EIncludeAll, from));

	if (error != aError) 

		{

		User::Leave(KErrGeneral);

		}

	// GetIdsModifiedSinceDateL

	RDebug::Printf("Test GetIdsModifiedSinceDateL");

	RArray<TCalLocalUid> uids;

	CleanupClosePushL(uids);

	error = KErrNone;

	TRAP(error, iCalTestLib->SynCGetEntryViewL().GetIdsModifiedSinceDateL(from, uids));

	if (error != aError) 

		{

		User::Leave(KErrGeneral);

		}

	if (aError != KErrNone && uids.Count() != 0)

		{

		User::Leave(KErrGeneral);

		}

	CleanupStack::PopAndDestroy(&uids);

	// FindInstanceL

	RDebug::Printf("Test FindInstanceL");

	RPointerArray<CCalInstance> instanceList;

	CleanupResetAndDestroyPushL(instanceList);

	TCalTime start;

	start.SetTimeLocalL(TDateTime(2004, EMay, 12, 10, 30, 0, 0));

	TCalTime end;

	end.SetTimeLocalL(TDateTime(2007, EMay, 12, 10, 30, 0, 0));

	CalCommon::TCalTimeRange timeRange(start, end);

	error = KErrNone;

	TRAP(error, iCalTestLib->SynCGetInstanceViewL().FindInstanceL(instanceList, CalCommon::EIncludeAll, timeRange));

	if (error != aError)

		{

		User::Leave(KErrGeneral);

		}

	if (aError != KErrNone && instanceList.Count() != 0)

		{

		User::Leave(KErrGeneral);

		}

	CleanupStack::PopAndDestroy(&instanceList);

	// StoreL

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	HBufC8* guid = NULL;

	CCalEntry* entry = iCalTestLib->CreateCalEntryL(CCalEntry::EAppt, guid);

	CleanupStack::PushL(entry);

	iCalTestLib->SetEntryStartAndEndTimeL(entry, TDateTime(2005, EMay, 23, 10, 30, 0, 0),

													TDateTime(2005, EMay, 23, 11, 0, 0, 0));

	entryArray.AppendL(entry);

	CleanupStack::Pop(entry);

	TInt numSuc;

	error = KErrNone;

	TRAP(error, iCalTestLib->SynCGetEntryViewL().StoreL(entryArray, numSuc));

	if (error != aError)

		{

		User::Leave(KErrGeneral);

		}

	// UpdateL

	error = KErrNone;

	TRAP(error, iCalTestLib->SynCGetEntryViewL().UpdateL(entryArray, numSuc));

	if (error != aError && error != KErrNotFound)

		{

		User::Leave(KErrGeneral);

		}

	// FetchL

	error = KErrNone;

	TRAP(error, iCalTestLib->SynCGetEntryViewL().FetchL(*guid, entryArray));

	if (error != aError)

		{

		User::Leave(KErrGeneral);

		}

	// DeleteL

	error = KErrNone;

	TRAP(error, iCalTestLib->SynCGetEntryViewL().DeleteL(*entry));

	if (error != aError)

		{

		User::Leave(KErrGeneral);

		}

	CleanupStack::PopAndDestroy(&entryArray);

	// CategoryManager

	CCalCategoryManager* categoryManager = CCalCategoryManager::NewL(iCalTestLib->GetSession());

	CleanupStack::PushL(categoryManager);

	CCalCategory* funCategory = CCalCategory::NewL(_L("Fun"));

	CleanupStack::PushL(funCategory);

	error = KErrNone;

	TRAP(error, categoryManager->AddCategoryL(*funCategory));

	if (error != aError)

		{

		User::Leave(KErrGeneral);

		}

	CleanupStack::PopAndDestroy(funCategory);

	error = KErrNone;

	TRAP(error, delete categoryManager->CategoryL(0));

	if (error != aError)

		{

		User::Leave(KErrGeneral);

		}

	CleanupStack::PopAndDestroy(categoryManager);

	// CCalIter

	CCalIter* calIter = CCalIter::NewL(iCalTestLib->GetSession());

	CleanupStack::PushL(calIter);

	error = KErrNone;

	TRAP(error, const TDesC8& guidRefFirst = calIter->FirstL());

	if (error != aError)

		{

		User::Leave(KErrGeneral);

		}

	error = KErrNone;

	TRAP(error, const TDesC8& guidRefNext = calIter->NextL());

	if (error != aError && error != KErrCorrupt)

		{

		User::Leave(KErrGeneral);

		}

	CleanupStack::PopAndDestroy(calIter);

	//	

	}

static void DoSecondThreadMainL()

	{

	CSecondThreadApp* secondThreadApp = CSecondThreadApp::NewL();

	CleanupStack::PushL(secondThreadApp);

	secondThreadApp->RunTestL();

	CleanupStack::PopAndDestroy(secondThreadApp);

	}

// The entry point for the other thread

static TInt SecondThreadMain(TAny* /*aRef*/)

	{

	__UHEAP_MARK;

	CTrapCleanup* trapCleanup = CTrapCleanup::New();

	if (!trapCleanup)

		{

		return KErrNoMemory;

		}

	CActiveScheduler* scheduler = new CActiveScheduler();

	if (!scheduler)

		{

		delete trapCleanup;

		return KErrNoMemory;

		}

	CActiveScheduler::Install(scheduler);

	TRAPD(ret, DoSecondThreadMainL());

	delete scheduler;

	delete trapCleanup;		

	__UHEAP_MARKEND;

	return (ret);

	}

class CAppActive : public CActive

	{

public:

	enum TDummyAppStep

		{

		EStepOpenModel,

		ESimpleEntryDeleteAll,

		ESimpleEntryDeleteSome,

		EDeleteRestEntry,

		ERepeatEntryDelete,

		EDeleteAllTodos,

		EDeleteAndCheckProgress,

		ERepeatExceptedEntryCreate,

		ERepeatExceptedEntryFetchInstances,

		ERepeatExceptedEntryEditInstances,

		ERepeatExceptedEntryDelete,

		ELockedInOtherThreadDuringDelete,

		EDeleteRemiderAndMore,

		EDeleteEntryWithMinTime,

		EAddForDeleteBeforeDateWithException,

		EDeleteBeforeDateWithException,

		EDeleteAllBeforeDateWithException,

		EDeleteAllMemosBegin,

		EDeleteAllMemosMiddle,

		EDeleteAllMemosEnd,

		EEnd

		};

	CAppActive(CDummyCalendarApp& aApp);

	~CAppActive();

	void DoCancel();

	void RunL();

	void Start();

	TInt GetStep();

	void SetStep(TDummyAppStep aStep);

private:

	CDummyCalendarApp& iApp;

	TDummyAppStep iStep;

	RPointerArray<CCalInstance>	iInstances;

	};

class CDummyCalendarApp : public CCalTestLibrary

	{

public:

	enum TEntryType

		{

		EApp,

		ETodo,

		EReminder,

		EAll

		};

	static CDummyCalendarApp* NewLC();

	~CDummyCalendarApp();

	void Progress(TInt aPercentageCompleted);

	void Completed(TInt aError);

	TBool NotifyProgress();

	void Close();

	void OpenModelL();

	void AddAOAndStartL();

	void AddEntryL(TInt aNumToAdd, TBool isParent, TBool isRepeat);

	void StoreSimpleEntryL();

	void StoreRepeatEntryL();

	void DeleteEntryL(const TTime& aStart, const TTime& aEnd, CalCommon::TCalViewFilter aFilter);

	void DeleteAllTodosL();

	void DeleteAllMemosBeginL();

	void DeleteAllMemosEndL();

	TBool CheckEntryNumL(TEntryType aType, TInt aNumEntry);

	void DeleteWhileAnotherThreadAccessesCalendarL();

	void StoreManyEntriesL(TInt aCount);

	void RepeatExceptedEntryCreateL();

	void RepeatExceptedEntryFetchInstancesL(RPointerArray<CCalInstance>& aInstances);

	void RepeatExceptedEntryEditInstancesL(RPointerArray<CCalInstance>& aInstances);		

	TInt ProgressNotificationCount();

	void Add3ReminderAnd1ApptL();

	void AddFloatingEntryWithMinStartTimeL();

private:

	void ConstructL();

private: // member data

	CCalEntryView*           iLocalEntryView;// doesn't own

	RPointerArray<CCalEntry> iEntries;

	CAppActive*              iActive;

	TInt 					 iProgressNotifications;

	CCalTestLibrary* 			iTestLib;

	};

CDummyCalendarApp* CDummyCalendarApp::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

CDummyCalendarApp::~CDummyCalendarApp()

	{

	delete iActive;

	delete iTestLib;

	iEntries.ResetAndDestroy();

	iEntries.Close();

	}

CAppActive::CAppActive(CDummyCalendarApp& aApp)

	: CActive(EPriorityHigh),iApp(aApp)

	{

	iStep = EStepOpenModel;

	}

CAppActive::~CAppActive()

	{

	iInstances.Close();

	Cancel();

	}

void CAppActive::Start()

	{

	if (!IsActive())

		{

		SetActive();

		}

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

void CAppActive::DoCancel()

	{

	iApp.Close();

	}

TInt CAppActive::GetStep()

	{

	return iStep;

	}

void CAppActive::SetStep(TDummyAppStep aStep)

	{

	iStep = aStep;

	}

void CDummyCalendarApp::ConstructL()

	{

	BaseConstructL();

	iActive = new (ELeave) CAppActive(*this);

	}

void CDummyCalendarApp::DeleteWhileAnotherThreadAccessesCalendarL()

	{

	test.Printf(_L("Adding 1000 entries"));

	const TInt KNumEntriesToAdd(1000);

	for (TInt i(0) ; i < KNumEntriesToAdd ; ++i)

		{

		HBufC8* guid = NULL;

		CCalEntry* entry = CreateCalEntryL(CCalEntry::EAppt, guid);

		CleanupStack::PushL(entry);

		SetEntryStartAndEndTimeL(entry,

									TDateTime(2005, ESeptember, 12, 0, 0, 0, 0),

									TDateTime(2005, ESeptember, 12, 1, 0, 0, 0));

		RPointerArray<CCalEntry> entryArray;

		CleanupClosePushL(entryArray);

		entryArray.AppendL(entry);

		TInt num;

		SynCGetEntryViewL().StoreL(entryArray, num);

		CleanupStack::PopAndDestroy(&entryArray);

		CleanupStack::PopAndDestroy(entry);

		test.Printf(_L("."));

		}

	// start the second thread and wait for it to signal

	// that it is ready to recieve notifications

	RThread thread;

	CleanupClosePushL(thread);

	User::LeaveIfError(thread.Create(_L("SecondThread"), SecondThreadMain,

															KDefaultStackSize,

															KDefaultStackSize * 20, // this is the minimum heap size

															KDefaultStackSize * 40, // this is the maximum heap size

															NULL));

	thread.SetPriority(EPriorityMore);

	thread.Resume();