diff -r 000000000000 -r f979ecb2b13e pimappservices/calendar/tsrc/tcal_delete.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimappservices/calendar/tsrc/tcal_delete.cpp Tue Feb 02 10:12:19 2010 +0200 @@ -0,0 +1,1367 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 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 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 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 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& aInstances); + void RepeatExceptedEntryEditInstancesL(RPointerArray& aInstances); + + TInt ProgressNotificationCount(); + void Add3ReminderAnd1ApptL(); + void AddFloatingEntryWithMinStartTimeL(); + +private: + + void ConstructL(); + + +private: // member data + + CCalEntryView* iLocalEntryView;// doesn't own + RPointerArray 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 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(); + + // wait untill the second thread is ready + TRequestStatus status; + thread.Rendezvous(status); + User::WaitForRequest(status); + + TCalTime start; + start.SetTimeLocalL(TDateTime(2005, ESeptember, 0, 0, 0, 0, 0)); + TCalTime end; + end.SetTimeLocalL(TDateTime(2006, EJanuary, 0, 0, 0, 0, 0)); + + CalCommon::TCalTimeRange timeRange(start, end); + + CProgressCallBack* progress = new(ELeave) CProgressCallBack; + CleanupStack::PushL(progress); + + test.Printf(_L("Start DeleteL\n")); + SynCGetEntryViewL().DeleteL(timeRange, CalCommon::EIncludeAll, *progress); + thread.Resume(); + // signal to the other thread that we have called delete + // and it should start testing that the file is locked + CActiveScheduler::Start(); + thread.Resume(); + + CleanupStack::PopAndDestroy(progress); + + // Wait for the other thread to exit + // and test that the exit reason was KErrNone + thread.Logon(status); + User::WaitForRequest(status); + + // If the other thread's testing was unsuccessful + // the exit reason will be KErrGeneral + test(status.Int() == KErrNone); + + CleanupStack::PopAndDestroy(&thread); + } + +void CDummyCalendarApp::Progress(TInt aPercentageCompleted) + { + test.Printf(_L("MCalProgress callback - Percent complete=%d"), aPercentageCompleted); + test.Printf( _L( "\n" ) ); + iProgressNotifications++; + if(iActive->GetStep() == CAppActive::EDeleteAllMemosMiddle && aPercentageCompleted > 50) + { + CActiveScheduler::Stop(); + } + } + + +void CDummyCalendarApp::Completed(TInt aError) + { + test.Printf(_L("MCalProgress callback - Completed, err=%d"), aError); + test.Printf( _L ( "\n") ); + iActive->Start(); + } + + +TBool CDummyCalendarApp::NotifyProgress() + { + return ETrue; + } + + +void CDummyCalendarApp::OpenModelL() + { + ReplaceFileL(KCalendarFile); + OpenFileL(KCalendarFile); + iLocalEntryView = &AsynCGetEntryViewL(); + } + + +TBool CDummyCalendarApp::CheckEntryNumL(TEntryType aType, TInt aNumEntry) + { + CCalIter& iter = GetIterL(); + + TPtrC8 Uid(iter.FirstL()); + + TInt ii=0; + while (Uid!=KNullDesC8()) + { + ++ii; + + RPointerArray entryList; + CleanupResetAndDestroyPushL(entryList); + iLocalEntryView->FetchL(Uid, entryList); + CCalEntry* entry = entryList[0]; + if(aType==EApp) + { + test(entry->EntryTypeL()==CCalEntry::EAppt); + } + else if (aType==ETodo) + { + test(entry->EntryTypeL()==CCalEntry::ETodo); + } + else if(aType == EReminder) + { + test(entry->EntryTypeL()==CCalEntry::EReminder); + } + + CleanupStack::PopAndDestroy(&entryList); + + Uid.Set(iter.NextL()); + } + + return (ii==aNumEntry); + } + + +void CDummyCalendarApp::StoreSimpleEntryL() + { + AddEntryL(KNumberOfEntries, ETrue, EFalse); + test(CheckEntryNumL(EAll,KNumberOfEntries)); + } + + +void CDummyCalendarApp::StoreRepeatEntryL() + { + AddEntryL(KNumberOfEntries, ETrue, ETrue); + test(CheckEntryNumL(EAll,KNumberOfEntries)); + AddEntryL(KNumberOfEntries, EFalse, ETrue); + test(CheckEntryNumL(EAll,KNumberOfEntries)); + } + + + +void CDummyCalendarApp::AddEntryL(TInt aNumToAdd, TBool isParent, TBool isRepeat) + { + test.Next(_L("Adding entries")); + + TBuf<50> summary; + TBuf<50> location; + TBuf<50> description; + + + + iEntries.ResetAndDestroy(); + for (TInt index=0; index buf; + buf.Append(_L("GuidId")); + buf.AppendNum(index); + HBufC8* guid = buf.AllocLC(); // need to be pushed to ... + + CCalEntry::TType entryType=(index%2==0)?CCalEntry::ETodo:CCalEntry::EAppt; + + CCalEntry* entry = NULL; + if(isParent) + { + entry = CreateCalEntryL(entryType, guid); + } + else + { + TTime localTime(KRecurrIdLocalTime); + TCalTime recurrenceId; + recurrenceId.SetTimeLocalL(localTime); + entry = CCalEntry::NewL(entryType, guid, CCalEntry::EMethodAdd, 1, recurrenceId, CalCommon::EThisAndFuture); + } + CleanupStack::Pop(guid); + iEntries.AppendL(entry); + + TInt year = -1; + TInt month = -1; + TInt day = -1; + + if (isParent) + { + year = index % 5 + 2001; // Any year in the range: 2001 - 2005 + month = index % 12; + day = index % 28; + } + else + { + // if this is a child entry, use the recurrence local time as the entry start time + // so it won't be out of range + TCalTime recurrId = entry->RecurrenceIdL(); + TDateTime localTime = recurrId.TimeLocalL().DateTime(); + year = localTime.Year(); + month = localTime.Month(); + day = localTime.Day(); + } + + TTime start(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0)); + TTime end(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0)); + end += TTimeIntervalDays(1); + + SetEntryStartAndEndTimeL(entry,start,end); + + RandomText(summary); + entry->SetSummaryL(summary); + + RandomText(location); + entry->SetLocationL(location); + + RandomText(description); + entry->SetDescriptionL(description); + + if(isRepeat) + { + //create a daily repeat rule and make sure its repeat start\end date is within the deleting time range + TCalRRule rpt(TCalRRule::EDaily); + rpt.SetInterval(1); + TCalTime repeatStart; + TCalTime repeatend; + if(isParent) + { + //make sure the repeat time is within the delete time range + repeatStart.SetTimeLocalL(TDateTime(2000, EJune, 0, 0, 0, 0, 0)); + repeatend.SetTimeLocalL(TDateTime(2006, EJune, 0, 0, 0, 0, 0)); + } + else if (indexRecurrenceIdL(); + + // make sure the repeat time is within the delete time range for the first half entries + repeatStart.SetTimeLocalL(recurrId.TimeLocalL()); // June 1, 2003 00:00:00 + repeatend.SetTimeLocalL(recurrId.TimeLocalL() + TTimeIntervalMonths(1)); // July 1, 2003 00:00:00 + } + else + { + //make sure the repeat time is out of the delete time range for the second half entries + repeatStart.SetTimeLocalL(TDateTime(2003, EJune, 0, 0, 0, 0, 0)); + repeatend.SetTimeLocalL(TDateTime(2007, EJune, 0, 0, 0, 0, 0)); + } + + rpt.SetDtStart(repeatStart); + rpt.SetUntil(repeatend); + entry->SetRRuleL(rpt); + } + } + + TInt entriesStored(0); + iLocalEntryView->StoreL(iEntries, entriesStored); //temp + test(entriesStored == iEntries.Count()); + } + + +void CDummyCalendarApp::DeleteEntryL(const TTime& aStart,const TTime& aEnd, CalCommon::TCalViewFilter aFilter) + { + TCalTime startTime; + TCalTime endTime; + startTime.SetTimeLocalL(aStart); + endTime.SetTimeLocalL(aEnd); + CalCommon::TCalTimeRange range(startTime,endTime); + iProgressNotifications = 0; + iLocalEntryView->DeleteL(range, aFilter, *this); + } + +void CDummyCalendarApp::DeleteAllTodosL() + { + delete iTestLib; + iTestLib = NULL; + + TBuf<60> dtBuf; + iTestLib = CCalTestLibrary::NewL(); + + TRAPD(err, iTestLib->PIMTestServer().DeleteFileL(KCalendarFile2)); + if(err != KErrNotFound || err != KErrPathNotFound) + { + User::LeaveIfError(err); + } + iTestLib->PIMTestServer().CopyFileL(KOriginalDeleteCalendar, _L("c:\\private\\10003A5B\\tcal_delete_calendar_copy")); + iTestLib->RegisterCalFileL(KCalendarFile2); + iTestLib->OpenFileL(KCalendarFile2); + iTestLib->PIMTestServer().SetTimeZoneL(_L8("Europe/Helsinki")); + + TCalTime minTime; + minTime.SetTimeUtcL(TCalTime::MinTime()); + TCalTime maxTime; + maxTime.SetTimeUtcL(TCalTime::MaxTime()); + CalCommon::TCalTimeRange timeRange(minTime, maxTime); + CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll; + + //DeleteL has to be placed in the end of the function + //because it is a long running operation and it needs + //to wait for callback in order to go to the next step. + iTestLib->SynCGetEntryViewL().DeleteL(timeRange, filter, *this); + } + +void CDummyCalendarApp::DeleteAllMemosBeginL() + { + test.Printf(_L("Test: DeleteAllMemosBeginL\r\n")); + //Add 1000 entries + test.Printf(_L("Adding 1000 Memos...\r\n")); + + const TInt KNumEntriesToAdd(1000); + + iTestLib->OpenFileL(KCalendarFile); + + for (TInt i(0) ; i < KNumEntriesToAdd ; ++i) + { + HBufC8* guid = NULL; + CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::EReminder, guid); + CleanupStack::PushL(entry); + + SetEntryStartAndEndTimeL(entry, + TDateTime(2005, ESeptember, 12, 0, 0, 0, 0), + TDateTime(2005, ESeptember, 12, 1, 0, 0, 0)); + + RPointerArray entryArray; + CleanupClosePushL(entryArray); + + entryArray.AppendL(entry); + TInt num; + iTestLib->SynCGetEntryViewL().StoreL(entryArray, num); + + CleanupStack::PopAndDestroy(&entryArray); + CleanupStack::PopAndDestroy(entry); + + test.Printf(_L(".")); + } + + TCalTime minTime; + minTime.SetTimeUtcL(TCalTime::MinTime()); + TCalTime maxTime; + maxTime.SetTimeUtcL(TCalTime::MaxTime()); + CalCommon::TCalTimeRange timeRange(minTime, maxTime); + + iActive->SetStep(CAppActive::EDeleteAllMemosMiddle); + + //Attempt to delete all the entries + test.Printf(_L("Deleting all the entries...\r\n")); + iTestLib->SynCGetEntryViewL().DeleteL(timeRange, CCalEntry::EReminder, *this); + CActiveScheduler::Start(); + delete iTestLib; + iTestLib = NULL; + } + +void CDummyCalendarApp::DeleteAllMemosEndL() + { + test.Printf(_L("Test: DeleteAllMemosEndL\r\n")); + test.Printf(_L("Interrupting the delete...\r\n")); + + //Get a time range + TCalTime minTime; + minTime.SetTimeUtcL(TCalTime::MinTime()); + TCalTime maxTime; + maxTime.SetTimeUtcL(TCalTime::MaxTime()); + CalCommon::TCalTimeRange timeRange(minTime, maxTime); + + test.Printf(_L("Done!\r\n")); + + iTestLib = CCalTestLibrary::NewL(EFalse); + iTestLib->OpenFileL(KCalendarFile); + + test.Printf(_L("Deleteing all the entiries again...\r\n")); + iTestLib->SynCGetEntryViewL().DeleteL(timeRange, CCalEntry::EReminder, *this); + } +void CDummyCalendarApp::StoreManyEntriesL(TInt aCount) + { + AddEntryL(aCount, ETrue, EFalse); + test(CheckEntryNumL(EAll,aCount)); + } + + + +void CDummyCalendarApp::RepeatExceptedEntryCreateL() + { + test.Next(_L("Add entry, repeat twice, set excepted and delete")); + + iEntries.ResetAndDestroy(); + + // Create new calendar entry. + CCalEntry* entry = NULL; + HBufC8* guid = KGUIDInc081869().AllocLC(); + entry = CreateCalEntryL(CCalEntry::EAppt, guid); + CleanupStack::Pop(guid); + + iEntries.AppendL(entry); + + // Set start and end date. + TTime start(TDateTime(2006, EMarch, 6, 10, 0, 0, 0)); + TTime end(TDateTime(2006, EMarch, 6, 14, 0, 0, 0)); + SetEntryStartAndEndTimeL(entry, start, end); + + TBuf<50> summary; + RandomText(summary); + entry->SetSummaryL(summary); + + TBuf<50> location; + RandomText(location); + entry->SetLocationL(location); + + TBuf<50> description; + RandomText(description); + entry->SetDescriptionL(description); + + // Create a daily repeating rule that occurs for 2 days. + TCalRRule rpt(TCalRRule::EDaily); + rpt.SetInterval(1); + rpt.SetCount(2); + + // Make sure the repeat time is within the delete time range. + TCalTime repeatStart; + TCalTime repeatEnd; + repeatStart.SetTimeLocalL(TDateTime(2006, EMarch, 6, 0, 0, 0, 0)); + repeatEnd.SetTimeLocalL(TDateTime(2006, EMarch, 8, 0, 0, 0, 0)); + rpt.SetDtStart(repeatStart); + rpt.SetUntil(repeatEnd); + entry->SetRRuleL(rpt); + + // Store the entry. Because it repeats over 2 days, there will + // be 2 entries. + TInt entriesStored(0); + SynCGetEntryViewL().StoreL(iEntries, entriesStored); + test(entriesStored == iEntries.Count()); + } + +void CDummyCalendarApp::RepeatExceptedEntryFetchInstancesL( + RPointerArray& aInstances ) + { + // Create a time range filter that returns all instances. + TCalTime minTime; + minTime.SetTimeUtcL(TCalTime::MinTime()); + TCalTime maxTime; + maxTime.SetTimeUtcL(TCalTime::MaxTime()); + CalCommon::TCalTimeRange timeRange(minTime, maxTime); + CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll; + + CleanupResetAndDestroyPushL(aInstances); + + // Get all instances. + AsynCGetInstanceViewL().FindInstanceL(aInstances, filter, timeRange); + test(aInstances.Count() >= 2); + CleanupStack::Pop(&aInstances); + } + +void CDummyCalendarApp::RepeatExceptedEntryEditInstancesL( + RPointerArray& aInstances ) + { + CleanupResetAndDestroyPushL(aInstances); + + // Delete all entries. + iEntries.ResetAndDestroy(); + + TTime start(TDateTime(2006, EMarch, 6, 10, 0, 0, 0)); + TTime end(TDateTime(2006, EMarch, 6, 14, 0, 0, 0)); + + // Re-create all the entries that previously existed. + CCalEntry* entry = NULL; + for (TUint i = 0; i < aInstances.Count(); ++i) + { + HBufC8* guid = KGUIDInc081869().AllocLC(); + entry = CCalEntry::NewL( CCalEntry::EAppt, guid, CCalEntry::EMethodAdd, + i, aInstances[i]->Time(), CalCommon::EThisOnly ); + CleanupStack::Pop( guid ); + iEntries.AppendL( entry ); + + SetEntryStartAndEndTimeL(entry, start, end); + } + + CleanupStack::PopAndDestroy(&aInstances); + + // Store the entries again, there should be 2. + TInt entriesStored = 0; + SynCGetEntryViewL().StoreL(iEntries, entriesStored); + test(entriesStored == iEntries.Count()); + } + +TInt CDummyCalendarApp::ProgressNotificationCount() + { + return iProgressNotifications; + } + + + +void CDummyCalendarApp::Add3ReminderAnd1ApptL() + { + test.Next(_L("Create some entries including day note and delete them")); + + +//Create entries + iEntries.ResetAndDestroy(); + //create reminder 1 + TBuf8<255> buf; + buf.Append(_L("GuidId_Reminder_1")); + HBufC8* guid = buf.AllocLC(); + CCalEntry* reminder1 = CCalEntry::NewL(CCalEntry::EReminder, guid, CCalEntry::EMethodAdd, 0); + CleanupStack::Pop(guid); + iEntries.AppendL(reminder1); + + TCalTime starttime; + starttime.SetTimeLocalL(TDateTime(2006, EMarch, 5, 0, 0, 0, 0)); + reminder1->SetStartAndEndTimeL(starttime, starttime); + + TBuf<50> summary; + RandomText(summary); + reminder1->SetSummaryL(summary); + + //create reminder 2 + buf.Delete(buf.Length()-1,1); + buf.Append(2); + guid = buf.AllocLC(); + CCalEntry* reminder2 = CCalEntry::NewL(CCalEntry::EReminder, guid, CCalEntry::EMethodAdd, 0); + CleanupStack::Pop(guid); + iEntries.AppendL(reminder2); + starttime.SetTimeLocalL(TDateTime(2006, EMarch, 6, 0, 0, 0, 0)); + reminder2->SetStartAndEndTimeL(starttime, starttime); + RandomText(summary); + reminder2->SetSummaryL(summary); + + //create reminder 3 + buf.Delete(buf.Length()-1,1); + buf.Append(3); + guid = buf.AllocLC(); + CCalEntry* reminder3 = CCalEntry::NewL(CCalEntry::EReminder, guid, CCalEntry::EMethodAdd, 0); + CleanupStack::Pop(guid); + iEntries.AppendL(reminder3); + starttime.SetTimeLocalL(TDateTime(2006, EMarch, 7, 0, 0, 0, 0)); + reminder3->SetStartAndEndTimeL(starttime, starttime); + RandomText(summary); + reminder3->SetSummaryL(summary); + + //Create appt + buf.Zero(); + buf.Append(_L("GuidId_Appt")); + guid = buf.AllocLC(); + CCalEntry* appt = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodAdd, 0); + CleanupStack::Pop(guid); + iEntries.AppendL(appt); + + starttime.SetTimeLocalL(TDateTime(2006, EMarch, 7, 14, 0, 0, 0)); + TTime endtimetime(TDateTime(2006, EMarch, 7, 14, 0, 0, 0)); + endtimetime +=TTimeIntervalHours(1); + TCalTime endtime; + endtime.SetTimeLocalL(endtimetime); + appt->SetStartAndEndTimeL(starttime, endtime); + + RandomText(summary); + appt->SetSummaryL(summary); + +//store 4 entries + TInt entriesStored(0); + SynCGetEntryViewL().StoreL(iEntries, entriesStored); + test(entriesStored == 4); + iEntries.ResetAndDestroy(); + } + + +void CDummyCalendarApp::AddFloatingEntryWithMinStartTimeL() + {//Defect fix for PDEF111562 - when a floating entry with miniman start time will never get deleted. + iEntries.ResetAndDestroy(); + + _LIT8(KUid, "UID_MinEntry"); + HBufC8* guid = KUid().AllocLC(); + CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::EReminder, guid); + CleanupStack::Pop(guid); + CleanupStack::PushL(entry); + TCalTime caltimestart,caltimeend; + TTime min(TDateTime(1900, EJanuary, 0, 0, 0, 0, 0)); + caltimestart.SetTimeLocalFloatingL(min); + entry->SetStartAndEndTimeL(caltimestart,caltimestart); + iEntries.AppendL(entry); + CleanupStack::Pop(entry); + TInt entriesStored(0); + SynCGetEntryViewL().StoreL(iEntries, entriesStored); //temp + iEntries.ResetAndDestroy(); + } + +void CAppActive::RunL() + { + TTime start(TDateTime(2000, EJanuary, 0, 0, 0, 0, 0)); + TTime end(TDateTime(2006, EDecember, 0, 0, 0, 0, 0)); + CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll; + switch (iStep) + { + case EStepOpenModel: + iApp.OpenModelL(); + iStep = ESimpleEntryDeleteAll; + break; + + case ESimpleEntryDeleteAll: + // Create half todos and half appointments and store the entries + // to the file. + iApp.StoreSimpleEntryL(); + iApp.DeleteEntryL(start, end, filter); + iStep = ESimpleEntryDeleteSome; + break; + + case ESimpleEntryDeleteSome: + // Check whether all entries have been deleted. + test(iApp.CheckEntryNumL(CDummyCalendarApp::EAll,0)); + + // Store entry back to the file. + iApp.StoreSimpleEntryL(); + + // Delete only Appointments from the file. + filter = CalCommon::EIncludeAppts; + iApp.DeleteEntryL(start, end, filter); + iStep = EDeleteRestEntry; + break; + + case EDeleteRestEntry: + //Check only Todos are left in file . + test(iApp.CheckEntryNumL(CDummyCalendarApp::ETodo,KNumberOfEntries/2)); + filter = CalCommon::EIncludeAll; + + //Delete the rest of entries + iApp.DeleteEntryL(start, end, filter); + iStep = ERepeatEntryDelete; + break; + + case ERepeatEntryDelete: + // Check all entries are deleted. + test(iApp.CheckEntryNumL(CDummyCalendarApp::EAll,0)); + + // Store KNumberOfEntries mumber of parent entries + // and KNumberOfEntries mumber of children entries + // half of children entries are within the delete time range + // The other half are not + iApp.StoreRepeatEntryL(); + + // Delete entries + iApp.DeleteEntryL(start, end, filter); + iStep = EDeleteAndCheckProgress; + break; + + case EDeleteAndCheckProgress: + // Check parent and its children entries have been deleted only if + // all of them are within the time range are not deleted. + test( iApp.CheckEntryNumL( CDummyCalendarApp::EAll, KNumberOfEntries/2 ) ); + + // Add enough entries to force Progress Notifications during delete + iApp.StoreManyEntriesL(50); + + // Delete all the entries + iApp.DeleteEntryL(TCalTime::MinTime(), TCalTime::MaxTime(), filter); + iStep = EDeleteAllTodos; + break; + + case EDeleteAllTodos: + // Check that we received some progress notifications. + test( iApp.ProgressNotificationCount() > 0 ); + + // Check all entries are deleted + test(iApp.CheckEntryNumL(CDummyCalendarApp::EAll,0)); + //Delete a thousand entries contained in the calendar file. + iApp.DeleteAllTodosL(); + iStep = ERepeatExceptedEntryCreate; + break; + + case ERepeatExceptedEntryCreate: + // Check all entries are deleted. + test( iApp.CheckEntryNumL( CDummyCalendarApp::EAll, 0 ) ); + + // Make sure the databse is clean for the next test case. + iApp.CleanDatabaseL(); + + // Create the entry with repeating rule. There will be 2 entries + // after this. + iApp.RepeatExceptedEntryCreateL(); + + // Being an active object, we need to kick it for the next loop. + Start(); + iStep = ERepeatExceptedEntryFetchInstances; + break; + + case ERepeatExceptedEntryFetchInstances: + // Fetch the 2 entries for modification. + iApp.RepeatExceptedEntryFetchInstancesL( iInstances ); + iStep = ERepeatExceptedEntryEditInstances; + break; + + case ERepeatExceptedEntryEditInstances: + // Modify the entries and commit. + iApp.RepeatExceptedEntryEditInstancesL( iInstances ); + Start(); + iStep = ERepeatExceptedEntryDelete; + break; + + case ERepeatExceptedEntryDelete: + // Delete all the entries. + iApp.DeleteEntryL( TCalTime::MinTime(), TCalTime::MaxTime(), CalCommon::EIncludeAll ); + iStep = EDeleteRemiderAndMore; + break; + + case EDeleteRemiderAndMore: + //Check all entries are deleted. + test(iApp.CheckEntryNumL(CDummyCalendarApp::EAll,0)); + + iApp.Add3ReminderAnd1ApptL(); + end = TDateTime(2006, EMarch, 7, 0, 0, 0, 0); + iApp.DeleteEntryL(TCalTime::MinTime(), end, filter); + iStep = ELockedInOtherThreadDuringDelete; + break; + case ELockedInOtherThreadDuringDelete: + iApp.DeleteWhileAnotherThreadAccessesCalendarL(); + iStep = EDeleteEntryWithMinTime; + Start(); + break; + + case EDeleteEntryWithMinTime: + test(iApp.CheckEntryNumL(CDummyCalendarApp::EApp, 1)); + _LIT8(KHong_Kong, "Asia/Hong_Kong"); + iApp.SetTimeZoneL(KHong_Kong); + iApp.AddFloatingEntryWithMinStartTimeL(); + iApp.DeleteEntryL(TCalTime::MinTime(), TCalTime::MaxTime(), filter); + iStep = EAddForDeleteBeforeDateWithException; + break; + + case EAddForDeleteBeforeDateWithException: + // Make sure the databse is clean for the next test case. + iApp.CleanDatabaseL(); + // Add a repeat entry; startdate 6 March 2006 - enddate 8 March 2006 + iApp.RepeatExceptedEntryCreateL(); + Start(); + iStep = EDeleteBeforeDateWithException; + break; + + case EDeleteBeforeDateWithException: + { + TTime startSingleDelete(TDateTime(2006, EMarch, 8, 0, 0, 0, 0)); + TTime endSingleDelete(TDateTime(2006, EMarch, 8, 23, 59, 0, 0)); + // Delete last instance + iApp.DeleteEntryL(startSingleDelete, endSingleDelete, filter); + iStep = EDeleteAllBeforeDateWithException; + } + break; + + case EDeleteAllBeforeDateWithException: + { + // Delete everything before 8th March 2006 + TTime startBeforeDelete(TCalTime::MinTime()); + TTime endBeforeDelete(TDateTime(TDateTime(2006, EMarch, 8, 23, 59, 0, 0)));//2006, EJune, 1, 1, 0, 0, 0)); + iApp.DeleteEntryL(startBeforeDelete, endBeforeDelete, filter); + iStep = EDeleteAllMemosBegin; + } + break; + case EDeleteAllMemosBegin: + { + iApp.CleanDatabaseL(); + iApp.DeleteAllMemosBeginL(); + iStep = EDeleteAllMemosEnd; + } + break; + case EDeleteAllMemosEnd: + { + iApp.DeleteAllMemosEndL(); + iStep = EEnd; + } + break; + + case EEnd: + test(iApp.CheckEntryNumL(CDummyCalendarApp::EAll, 0)); + iApp.SetTimeZoneL(KDefaultTimeZone); + iApp.Close(); + break; + + default: + break; + } + } + + +void CDummyCalendarApp::Close() + { + CActiveScheduler::Stop(); + } + + +void CDummyCalendarApp::AddAOAndStartL() + { + CActiveScheduler::Add(iActive); + iActive->Start(); + } + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * DoTestL() + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +static void DoTestL() + { + CDummyCalendarApp* testManager = CDummyCalendarApp::NewLC(); + + + TPerformanceTimer timer(test); + timer.Start(); + + + // Run the test suite + + testManager->AddAOAndStartL(); + CActiveScheduler::Start(); + + + timer.Stop(); + test.Printf(_L("Done\n")); + // printout performance time + timer.PrintOut(); + + + CleanupStack::PopAndDestroy(testManager); + } + + +/** + +@SYMTestCaseID PIM-TCAL-DELETE-0001 + +*/ + +TInt E32Main() + { + __UHEAP_MARK; + + test.Start(_L("@SYMTESTCaseID:PIM-TCAL-DELETE-0001 Calendar Interim API Delete 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); + }