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

#include <calattachmentmanager.h>

#include <calcategory.h>

#include <calcategorymanager.h>

#include <calsession.h>

#include <calinstance.h>

#include <caliterator.h>

#include <calinstanceview.h>

#include <calrrule.h>

#include <e32test.h>

#include <s32file.h>

// Uncomment this line to test manually

// #define TEST_MANUALLY

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

_LIT(KRemovableMediaTestFile, "removable_media");

class CCalRemovableMediaTest : public CBase, public MCalProgressCallBack

	{

public:

	static CCalRemovableMediaTest* NewLC();

 	~CCalRemovableMediaTest();

	void DoTestsL();

	// from MCalProgressCallBack

	void Progress(TInt aPercentageCompleted);

	void Completed(TInt aError);

	TBool NotifyProgress();

private:

	CCalRemovableMediaTest();

	void ConstructL();

	void NextStepL(TInt aStep);

	void InitialiseFileL();

	void StoreEntriesL(TBool aTestStoreL);

	void UpdateEntriesL();

	void DeleteEntriesByUidL();

	void DeleteEntriesByLocalUidL();

	void DeleteEntriesAsynchronouslyByTimeL();

	void DeleteInstanceL();

	void AddCategoryL(TBool aTestAdd);

	void DeleteCategoryL();

	void GetNumEntriesL();

	void CheckUpdateL();

	void CheckDeleteAsynchronouslyByTime();

	void CheckNumEntriesL();

	void CheckNumAttachmentsL();

	void TestAfterMediaRemovedL();

	void CheckNumCategoriesL();

	void CheckDeleteCategory();

	void CheckDeleteInstanceL();

	void AddSecondCategoryL();

	void AddAttachmentL(TBool aTesting);

	void UpdateAttachmentL();

	void DeleteAttachmentL();

	void CheckDeleteAttachmentL();

	void ChangeAttachmentDriveL();

	TInt AttachmentFileCountL() const;

	void SetupTestLibL();

	void ClearTestLib();

	void FindEntriesWithTextL(RPointerArray<CCalInstance>& aInstances, const TDesC& aText);	

	void RemoveMedia();

	void ReplaceMedia();

	TBool MediaRemoved() const;

private:

	enum

		{

		ETestStore,

		ECheckStore,

		ETestUpdate,

		ECheckUpdate,

		ETestDeleteByTime,

		ECheckDeleteByTime,

		ETestDeleteByLocalUid,

		ECheckDeleteByLocalUid,

		ETestDeleteByUid,

		ECheckDeleteByUid,

		ETestAddCategory,

		ECheckAddCategory,

		ETestAddSecondCategory,

		ECheckAddSecondCategory,

		ETestDeleteCategory,

		ECheckDeleteCategory,

		ETestDeleteInstance,

		ECheckDeleteInstance,

		ETestAddAttachment,

		ECheckAddAttachment,

		ETestUpdateAttachment,

		ECheckUpdateAttachment,

		ETestDeleteAttachment,

		ECheckDeleteAttachment,

		EChangeAttachmentDrive,

		ETestAfterMediaRemoved,

		EFinishedTests,

		// edit this to change where the test starts

		EFirstStep = ETestStore,

		};

	CCalTestLibrary* iTestLib;

	CCalCategoryManager* iCatMan;

	CCalAttachmentManager* iAttMan;

	TBuf<32> iCalendarName;

	TInt iError;

	TInt iNumEntries;

	TInt iNumAttachments;

	TBool iMediaRemoved;

	};

void CCalRemovableMediaTest::Progress(TInt )

	{

	}

void CCalRemovableMediaTest::Completed(TInt aError)

	{

	iError = aError;

	test.Printf(_L("Completed with error %d \n"), aError);

	CActiveScheduler::Stop();

	}

TBool CCalRemovableMediaTest::NotifyProgress()

	{

	return EFalse;

	}

void CCalRemovableMediaTest::RemoveMedia()

	{

#ifdef TEST_MANUALLY

	test.Printf(_L("Remove the media and press any key.\n")); test.Getch();

#else

	iTestLib->FileSession().SetErrorCondition(KErrNotReady, 0);

	User::After(500000);

#endif

	iMediaRemoved = ETrue;

	}

void CCalRemovableMediaTest::ReplaceMedia()

	{

#ifdef TEST_MANUALLY

	test.Printf(_L("Reinsert the media and press any key...\n")); test.Getch();

#else

	User::After(500000);

#endif

	iMediaRemoved = EFalse;

	}

TBool CCalRemovableMediaTest::MediaRemoved() const

	{

	return iMediaRemoved;

	}

void CCalRemovableMediaTest::NextStepL(TInt aStep)

	{

	if (MediaRemoved())

		{

		ReplaceMedia();

		}

	TRAPD(err, SetupTestLibL());

	if (err != KErrNone)

		{

		test.Printf(_L("Failed to re-open calendar file, error %d\n"), err);

		test(0);

		}

	switch (aStep)

		{

		case ETestStore:

			StoreEntriesL(ETrue);

			break;

		case ECheckStore:

			CheckNumEntriesL();

			break;

		case ETestUpdate:

			UpdateEntriesL();

			break;

		case ECheckUpdate:

			CheckUpdateL();

			CheckNumEntriesL();

			break;

		case ETestDeleteByTime:

			DeleteEntriesAsynchronouslyByTimeL();

			break;

		case ECheckDeleteByTime:

			CheckDeleteAsynchronouslyByTime();

			CheckNumEntriesL();

			break;

		case ETestDeleteByLocalUid:

			DeleteEntriesByLocalUidL();

			break;

		case ECheckDeleteByLocalUid:

			CheckNumEntriesL();

			break;

		case ETestDeleteByUid:

			DeleteEntriesByUidL();

			break;

		case ECheckDeleteByUid:

			CheckNumEntriesL();

			break;

		case ETestAddCategory:

			AddCategoryL(ETrue);

			break;

		case ECheckAddCategory:

			CheckNumCategoriesL();

			break;

		case ETestAddSecondCategory:

			AddSecondCategoryL();

			break;

		case ECheckAddSecondCategory:

			CheckNumCategoriesL();

			break;

		case ETestDeleteCategory:

			DeleteCategoryL();

			break;

		case ECheckDeleteCategory:

			CheckDeleteCategory();

			CheckNumCategoriesL();

			break;

		case ETestDeleteInstance:

			DeleteInstanceL();

			break;

		case ECheckDeleteInstance:

			CheckDeleteInstanceL();

			break;

		case ETestAddAttachment:

			AddAttachmentL(ETrue);

			break;

		case ECheckAddAttachment:

			CheckNumAttachmentsL();

			break;

		case ETestUpdateAttachment:

			UpdateAttachmentL();

			break;

		case ECheckUpdateAttachment:

			CheckNumEntriesL();

			CheckNumAttachmentsL();

			break;

		case ETestDeleteAttachment:

			DeleteAttachmentL();

			break;

		case ECheckDeleteAttachment:

			CheckDeleteAttachmentL();

			break;

		case EChangeAttachmentDrive:

			ChangeAttachmentDriveL();

			break;

		case ETestAfterMediaRemoved:

			TestAfterMediaRemovedL();

			break;

		}

	ClearTestLib();

	}

void CCalRemovableMediaTest::InitialiseFileL()

	{

	// ensure there are at least 10 entries in file

	GetNumEntriesL();

	if (iNumEntries < 10)

		{

		StoreEntriesL(EFalse);

		GetNumEntriesL();

		}

	}

void CCalRemovableMediaTest::StoreEntriesL(TBool aTestStoreL)

	{

	if (aTestStoreL)

		{

		test.Next(_L("Test StoreL"));		

		}

	const TInt KNumEntries = 10;

	test.Printf(_L("Creating %d non-repeating entries \n"), KNumEntries);

	TTime time;

	time.HomeTime();

	GetNumEntriesL();

	test.Printf(_L("Number of entries before add is %d\n"), iNumEntries);

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

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

		{

		time -= TTimeIntervalDays(1);

		TBuf8<64> buf;

		iTestLib->RandomText8(buf);

		CCalEntry::TType type = CCalEntry::EAppt;

		if (i % 2 == 0)

			{

			type = CCalEntry::ETodo;

			}

		HBufC8* bufAlloc = buf.AllocLC();

		CCalEntry* entry = iTestLib->CreateCalEntryL(type, bufAlloc);

		CleanupStack::Pop(); // buf.AllocLC()

		CleanupStack::PushL(entry);

		iTestLib->SetEntryStartAndEndTimeL(entry, time, time);

		entryArray.AppendL(entry);

		CleanupStack::Pop(entry);

		}

	if (aTestStoreL)

		{

		RemoveMedia();

		}

	TInt success(0);

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

	TRAPD(err, iTestLib->SynCGetEntryViewL().StoreL(entryArray, success));

	test.Printf(_L("StoreL gave error %d, num successfully added=%d\n"), err, success);

	if (aTestStoreL)

		{

		test(err == KErrNotReady);

		test(success == 0);

		}

	else

		{

		User::LeaveIfError(err);

		test(success == KNumEntries);

		}

	CleanupStack::PopAndDestroy(&entryArray);

	}

void CCalRemovableMediaTest::FindEntriesWithTextL(RPointerArray<CCalInstance>& aInstances, const TDesC& aText)

	{

	CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll | CalCommon::EIncludeRptsNextInstanceOnly;

	TCalTime minTime;

	minTime.SetTimeUtcL(TCalTime::MinTime());

	TCalTime maxTime;

	maxTime.SetTimeUtcL(TCalTime::MaxTime());

	CalCommon::TCalTimeRange timeRange(minTime, maxTime);

	CCalInstanceView::TCalSearchParams searchParams(aText, CalCommon::EFoldedTextSearch);

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

	}

void CCalRemovableMediaTest::UpdateEntriesL()

	{

	test.Next(_L("Test UpdateL\n"));	

	InitialiseFileL();

	test.Printf(_L("Updating %d entries \n"), iNumEntries);

	RPointerArray<CCalInstance> instArray;

	CleanupResetAndDestroyPushL(instArray);

	FindEntriesWithTextL(instArray, KNullDesC);

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	for (TInt i = 0; i < instArray.Count(); ++i)

		{

		CCalEntry* entry = &instArray[i]->Entry();

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

		entryArray.AppendL(entry);

		}

	RemoveMedia();

	TInt success(0);

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

	TRAPD(err, iTestLib->SynCGetEntryViewL().UpdateL(entryArray, success));

	test.Printf(_L("UpdateL gave error %d, num successfully updated=%d\n"), err, success);

	test(err == KErrNotReady);

	test(success == 0);

	CleanupStack::PopAndDestroy(&entryArray); // Close()

	CleanupStack::PopAndDestroy(&instArray); // ResetAndDestroy()

	}

void CCalRemovableMediaTest::CheckUpdateL()

	{

	RPointerArray<CCalInstance> instArray;

	CleanupResetAndDestroyPushL(instArray);

	// check that no entries were updated

	test.Printf(_L("Checking no entries were updated..."));

	FindEntriesWithTextL(instArray, _L("updated summary"));

	test.Printf(_L("%d entries were updated\n"), instArray.Count());

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

	CleanupStack::PopAndDestroy(&instArray); // ResetAndDestroy

	}

void CCalRemovableMediaTest::GetNumEntriesL()

	{

	RArray<TCalLocalUid> localUids;

	CleanupClosePushL(localUids);

	TCalTime minTime;

	minTime.SetTimeUtcL(TCalTime::MinTime());

	iTestLib->SynCGetEntryViewL().GetIdsModifiedSinceDateL(minTime, localUids);

	iNumEntries = localUids.Count();

	CleanupStack::PopAndDestroy(&localUids); // Close()

	iNumAttachments = AttachmentFileCountL();

	}

TInt CCalRemovableMediaTest::AttachmentFileCountL() const

	{

	CCalAttachmentIterator* attachments = iAttMan->FetchAttachmentsL(CCalAttachmentManager::ESortBySizeLargestFirst);

	TInt count = attachments->Count();

	delete attachments;

	return count;

	}

void CCalRemovableMediaTest::CheckNumEntriesL()

	{

	RArray<TCalLocalUid> localUids;

	CleanupClosePushL(localUids);

	TCalTime minTime;

	minTime.SetTimeUtcL(TCalTime::MinTime());

	test.Printf(_L("Checking number of entries: expected=%d..."), iNumEntries);

	iTestLib->SynCGetEntryViewL().GetIdsModifiedSinceDateL(minTime, localUids);

	test.Printf(_L("Number of entries found=%d\n"), localUids.Count());

	test(iNumEntries == localUids.Count());

	CleanupStack::PopAndDestroy(&localUids); // Close()

	}

void CCalRemovableMediaTest::CheckNumAttachmentsL()

	{

	if (iNumAttachments > 0)

		{

		test.Printf(_L("Checking number of attachments: expected=%d...Number of entries found=%d\n"), iNumAttachments, AttachmentFileCountL());

		test(iNumAttachments == AttachmentFileCountL());

		}

	}

void CCalRemovableMediaTest::DeleteEntriesByLocalUidL()

	{

	test.Next(_L("Test DeleteL by local UID\n"));	

	InitialiseFileL();

	test.Printf(_L("Deleting all entries by local uid \n"));

	test.Printf(_L("Number of entries before delete is %d\n"), iNumEntries);

	RArray<TCalLocalUid> localUids;

	CleanupClosePushL(localUids);

	TCalTime minTime;

	minTime.SetTimeUtcL(TCalTime::MinTime());

	iTestLib->SynCGetEntryViewL().GetIdsModifiedSinceDateL(minTime, localUids);

	test(localUids.Count() == iNumEntries); // check all local uids found

	RemoveMedia();

	TInt success = 0;

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

	TRAPD(err, iTestLib->SynCGetEntryViewL().DeleteL(localUids, success));

	test.Printf(_L("DeleteL gave err %d, num successfully deleted=%d\n"), err, success);

	test(err == KErrNotReady);

	test(success == 0);

	CleanupStack::PopAndDestroy(&localUids); // Close()

	}

void CCalRemovableMediaTest::DeleteEntriesByUidL()

	{

	test.Next(_L("Test DeleteL by GUID\n"));

	InitialiseFileL();

	RPointerArray<CCalEntry> entries;

	CleanupResetAndDestroyPushL(entries);

	CDesC8Array* uidArray = new (ELeave) CDesC8ArraySeg(8);

	CleanupStack::PushL(uidArray);

	CCalIter& iter = iTestLib->GetIterL();

	TPtrC8 uid = iter.FirstL();

	while (uid.Length() > 0)

		{

		uidArray->AppendL(uid);

		uid.Set(iter.NextL());

		}

	test(iNumEntries == uidArray->Count());

	test.Printf(_L("Found %d entries before delete\n"), iNumEntries);

	RemoveMedia();

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

	TRAPD(err, iTestLib->SynCGetEntryViewL().DeleteL(*uidArray));

	test(err == KErrNotReady);

	test.Printf(_L("DeleteL gave error %d...\n"), err);

	CleanupStack::PopAndDestroy(uidArray);

	CleanupStack::PopAndDestroy(&entries);

	}

void CCalRemovableMediaTest::DeleteEntriesAsynchronouslyByTimeL()

	{

	test.Next(_L("Test DeleteL by time\n"));