--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappservices/calendar/tsrc/tcal_iterator.cpp	Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,449 @@
+// 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);
+    }