// 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 <calsession.h>
#include <e32test.h>
#include <caliterator.h>
#include <caluser.h>

// the objective of this test suite is to test the CCalIter interface and object behaviour

_LIT(KTestName,"tcal_iterator");

RTest test(KTestName);


const TInt KNumberOfEntries = 20;

class CIteratorTestManager : public CBase
	{
public:

    static CIteratorTestManager* NewLC();
	~CIteratorTestManager();
	
	inline void CleanDatabaseL();
	void TestEmptyIteratorL();
	void TestAddEntryL(const TInt aNumToAdd);	
	void TestIterEntryAndFetchL(const TInt aNumOfEntries);
	void IterEntryAndFetchL(const TInt aNumOfIterations);
	void TestIterEntryAndFetchAndAddL(const TInt aNumOfIterations, const TInt aNumToAdd, const TInt aNumOfEntries);
	void TestIterEntryAndFetchAndDeleteL(const TInt aNumOfIterations, const TInt aNumToRemove, const TInt aNumOfEntries);
	
	
private:

	// avoid any method but NewL instancing the class
	CIteratorTestManager() {	}
	// no copy constructor and assignment operator
	CIteratorTestManager(CIteratorTestManager& );
	CIteratorTestManager& operator = (const CIteratorTestManager& );

	void ConstructL();

	
private:

	CCalTestLibrary* iTestLibrary;
	};


// Constructor/Destructor

CIteratorTestManager* CIteratorTestManager::NewLC()
	{
	CIteratorTestManager* self = new (ELeave) CIteratorTestManager();
	
	CleanupStack::PushL(self);
	self->ConstructL();
	
	return (self);
	}


void CIteratorTestManager::ConstructL()
	{
	iTestLibrary = CCalTestLibrary::NewL();
	
	iTestLibrary->ReplaceFileL(KTestName);
	iTestLibrary->OpenFileL(KTestName);	
	}	


CIteratorTestManager::~CIteratorTestManager()	
	{
	delete iTestLibrary;
	}


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Test cases forming the Iterator test suite
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	
inline void CIteratorTestManager::CleanDatabaseL()
	{
	iTestLibrary->CleanDatabaseL();
	}


void CIteratorTestManager::TestEmptyIteratorL()
	{
	// Test Empty Iterator Returns NULL Des	
	test.Next(_L("Test Empty Iterator"));

	
	CCalIter& iter = iTestLibrary->GetIterL();
	
	TPtrC8 Uid(iter.FirstL());
	test(Uid == KNullDesC8()); 
	
	// Try and iterate beyond the end of the iterator
	TRAPD(err, Uid.Set(iter.NextL()));  
	test(err == KErrCorrupt);
	}



void CIteratorTestManager::TestAddEntryL(const TInt aNumToAdd)
	{
	// Add Entries for Test
	test.Next(_L("Adding entries"));

	
	TBuf<50> summary;
	TBuf<50> location;
	TBuf<50> description;


	RPointerArray<CCalEntry> entriesToStore;
	CleanupResetAndDestroyPushL(entriesToStore);
	
	for (TInt index = 0; index < aNumToAdd; ++index)
		{
		CCalEntry* entry;
		HBufC8*    guid = HBufC8::NewL(255);
		TPtr8      uidP = guid->Des();
		
		iTestLibrary->RandomText8(uidP);
		
		if( (index %2) == 0 )
			{
			entry = iTestLibrary->CreateCalEntryL(CCalEntry::ETodo, guid);
			}
		else
			{
			entry = iTestLibrary->CreateCalEntryL(CCalEntry::EAppt, guid);
			}
	
		TInt err = entriesToStore.Append(entry);
		test(err == KErrNone);
		
		iTestLibrary->SetEntryStartAndEndTimeL(entry);
				
		iTestLibrary->RandomText(summary);
		entry->SetSummaryL(summary);
		
		iTestLibrary->RandomText(location);
		entry->SetLocationL(location);
		
		iTestLibrary->RandomText(description);
		entry->SetDescriptionL(description);
		}

	TInt entriesStored(0);
	iTestLibrary->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored); //temp
	test(entriesStored == aNumToAdd);
	
	CleanupStack::PopAndDestroy(&entriesToStore);
	}


void CIteratorTestManager::TestIterEntryAndFetchL(const TInt aNumOfEntries)
	{
	test.Next(_L("Check Iterator entries"));

	
	CCalIter& iter = iTestLibrary->GetIterL();
	
	TInt i = 0;
		
	for( TPtrC8 Uid(iter.FirstL()); Uid != KNullDesC8(); Uid.Set(iter.NextL()), ++i )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);
		iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList);
		CleanupStack::PopAndDestroy(&entryList);			
		}
		
  	test(i == aNumOfEntries);
	}


void CIteratorTestManager::IterEntryAndFetchL(const TInt aNumOfIterations)
	{
	test.Next(_L("Iterate entries"));

	
	CCalIter& iter = iTestLibrary->GetIterL();
	
	TInt i = 0;
	
	for( TPtrC8 Uid(iter.FirstL()); Uid != KNullDesC8() || i < aNumOfIterations; Uid.Set(iter.NextL()), ++i )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);
		iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList);
		CleanupStack::PopAndDestroy(&entryList);			
		}
	}



void CIteratorTestManager::TestIterEntryAndFetchAndAddL(const TInt aNumOfIterations, const TInt aNumToAdd, const TInt aNumOfEntries)
	{
	test.Next(_L("Iterate entries and Add new"));

		
	CCalIter& iter = iTestLibrary->GetIterL();
	
	TInt   i = 0;
	TPtrC8 Uid(iter.FirstL());

	for( ; Uid != KNullDesC8() && i < aNumOfIterations; Uid.Set(iter.NextL()), ++i )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);
		iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList);
		CleanupStack::PopAndDestroy(&entryList);			
		}		
	
	TestAddEntryL(aNumToAdd);
	
	for( ; Uid != KNullDesC8(); Uid.Set(iter.NextL()), ++i )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);
		iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList);
		CleanupStack::PopAndDestroy(&entryList);			
		}

	test(i == aNumOfEntries);
	}


void CIteratorTestManager::TestIterEntryAndFetchAndDeleteL(const TInt aNumOfIterations, const TInt aNumToRemove, const TInt aNumOfEntries)
	{
	test.Next(_L("Iterate entries and Delete some"));

		
	CCalIter& iter = iTestLibrary->GetIterL();
	
	TInt   i = 0;	
	TPtrC8 Uid(iter.FirstL());

	for( ; Uid != KNullDesC8() && i < aNumOfIterations; Uid.Set(iter.NextL()), ++i )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);
		iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList);
		CleanupStack::PopAndDestroy(&entryList);			
		}		


	for( TInt j = 0; Uid != KNullDesC8() && j < aNumToRemove; Uid.Set(iter.NextL()), ++j )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);
		iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList);
		for( TInt k = 0; k < entryList.Count(); ++k )
			{
			iTestLibrary->SynCGetEntryViewL().DeleteL( *(entryList[k]) );
			}
		CleanupStack::PopAndDestroy(&entryList);			
		}	


	for( ; Uid != KNullDesC8(); Uid.Set(iter.NextL()), ++i )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);
		iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList);
		CleanupStack::PopAndDestroy(&entryList);			
		}

	test(i == aNumOfEntries);
	}
	

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * DoTestL()
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	
static void DoTestL()
	{
	CIteratorTestManager* testManager = CIteratorTestManager::NewLC();
	
	
	TPerformanceTimer timer(test);
	timer.Start();


	// Run the test suite

	// case 1: test the iterator when the database is empty
	
	testManager->TestEmptyIteratorL();


	// case 2: test the iterator twice with some parent entries in the database

	testManager->TestAddEntryL(KNumberOfEntries);

	// iterate once to verify all the parent entries are seen
	testManager->TestIterEntryAndFetchL(KNumberOfEntries);
	// iterate again to verify all the parent entries are seen a second time
	testManager->TestIterEntryAndFetchL(KNumberOfEntries);


	// case 3: test the iterator twice with some parent entries add on top
	//         of the previous ones in the database

	testManager->TestAddEntryL(KNumberOfEntries);

	// make sure the parent entries are the double now...
	testManager->TestIterEntryAndFetchL(KNumberOfEntries * 2);
	// and check a second time
	testManager->TestIterEntryAndFetchL(KNumberOfEntries * 2);


	// case 4: cleanup and restart from scratch the test of the iterator twice
	//         with some parent entries in the database; making sure the iterator
	//         behaves correctly working on a clean database

	testManager->CleanDatabaseL();

	testManager->TestEmptyIteratorL();

	testManager->TestAddEntryL(KNumberOfEntries);

	// iterate once to verify all the parent entries are seen
	testManager->TestIterEntryAndFetchL(KNumberOfEntries);
	// iterate again to verify all the parententries are seen a second time
	testManager->TestIterEntryAndFetchL(KNumberOfEntries);	
	
	
	// case 5: cleanup and restart from scratch the test of the iterator 
	//         stopping half way, adding some entries in the database and
	//         running again

	testManager->CleanDatabaseL();

	testManager->TestEmptyIteratorL();

	testManager->TestAddEntryL(KNumberOfEntries);

	// just iterate half of the parent entries
	testManager->IterEntryAndFetchL(KNumberOfEntries / 2);
	
	// add some more parent entries
	testManager->TestAddEntryL(KNumberOfEntries);	

	// make sure the parent entries are the double now...
	testManager->TestIterEntryAndFetchL(KNumberOfEntries * 2);
	// and check a second time
	testManager->TestIterEntryAndFetchL(KNumberOfEntries * 2);
	
	
	// case 6: cleanup and restart from scratch the test of the iterator 
	//         stopping half way, adding some parent entries in the database
	//         and continue running
	
	testManager->CleanDatabaseL();

	testManager->TestEmptyIteratorL();

	testManager->TestAddEntryL(KNumberOfEntries);	
/*** TODO: This test is failing at the moment, it just gets a partial number of new total entries
	testManager->TestIterEntryAndFetchAndAddL(KNumberOfEntries / 2, KNumberOfEntries, KNumberOfEntries * 2);
***/


	// case 7: cleanup and restart from scratch the test of the iterator 
	//         stopping half way, deleting some parent entries in the database
	//         and continue running

	testManager->CleanDatabaseL();

	testManager->TestEmptyIteratorL();

	testManager->TestAddEntryL(KNumberOfEntries);	

	testManager->TestIterEntryAndFetchAndDeleteL( (KNumberOfEntries / 2), (KNumberOfEntries / 4), (KNumberOfEntries - (KNumberOfEntries / 4)) );	


	timer.Stop();
	test.Printf(_L("Done\n"));
	// printout performance time
	timer.PrintOut();


	CleanupStack::PopAndDestroy(testManager);
	}


/**

@SYMTestCaseID     PIM-TCAL-ITERATOR-0001

*/

TInt E32Main()
    {
	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-ITERATOR-0001 Calendar Interim API Iterator test suite"));

	test.Title();

	CTrapCleanup* trapCleanup = CTrapCleanup::New();
	if (!trapCleanup)
		{
		return KErrNoMemory;
		}

	CActiveScheduler* scheduler = new CActiveScheduler();
	if (!scheduler)
		{
		delete trapCleanup;
		return KErrNoMemory;
		}
	CActiveScheduler::Install(scheduler);	

	TRAPD(ret, DoTestL());
	test(ret == KErrNone);
	
	delete scheduler;
	delete trapCleanup;	

	test.End();
	test.Close();

	__UHEAP_MARKEND;

	return (KErrNone);
    }