diff -r 000000000000 -r f979ecb2b13e pimappservices/calendar/tsrc/tcal_iterator.cpp --- /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 +#include +#include +#include +#include +#include + +// 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 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 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 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 entryList; + CleanupResetAndDestroyPushL(entryList); + iTestLibrary->SynCGetEntryViewL().FetchL(Uid, entryList); + CleanupStack::PopAndDestroy(&entryList); + } + + TestAddEntryL(aNumToAdd); + + for( ; Uid != KNullDesC8(); Uid.Set(iter.NextL()), ++i ) + { + RPointerArray 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 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 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 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); + }