diff -r 000000000000 -r f979ecb2b13e pimappservices/calendar/tsrc/tcal_recur.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimappservices/calendar/tsrc/tcal_recur.cpp Tue Feb 02 10:12:19 2010 +0200 @@ -0,0 +1,1194 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include + + +RTest test(_L("tcal_recur")); + +_LIT(KCalendarFile, "tcal_recur"); +_LIT8(KGUID, "A_Global_UID"); + +//useful for debugging purposes, allows you to view the instances of an entry +// Timezone constants + +_LIT8(KEuropeBerlin, "Europe/Berlin"); + +class CTestApp : public CBase + { +public: + CTestApp(); + ~CTestApp(); + + static CTestApp *NewLC() ; + void ConstructL(); + + void RunTestL(); + void TestRecurrenceIdPanicL(); + void ClearAllAlarmsL() ; + void RunRecurrenceTestL(); + void RecurrenceTestL(TDateTime aParentStartTime, TDateTime aParentEndTime, TDateTime aChildStartTime, TDateTime aChildEndTime, TDateTime aRecurrenceId); + + void ChildRecurrenceIdTestL(); + void ClearDatabaseL(); + void CheckRRangeL( RArray &aRanges ); + void CheckWithFindInstanceL(TCalTime& aStartRange,TCalTime& aEndRange,CalCommon::TCalViewFilter aFilter,TInt aExpectedInstances); + TInt CreateRepeatingChildL(TCalTime& aChildRptStart,TCalTime& aChildRptEnd,TCalTime& aRecurId, CalCommon::TRecurrenceRange& aRange, TCalRRule::TType& aRType ); + void CreateParentL(TCalTime& aParentRptStart,TCalTime& aParentRptEnd, TCalRRule::TType& aRType ); + void TestRecurrenceRangeL(); + void MultipleChildsWithRRulesL(); + void TestRDatesForParentChildL(); + void TestSingleDayRepeatL(); + void VerifyInstancesAfterLeaveWhileAddingChildL(); + void MiscellaneousTestCasesL(); + + +public: + CCalTestLibrary* iTestLibrary; + RTz iTzServer; + +private: + RASCliSession iAlarmServer; + CTzId* iTzID; + + CCalEntryView* iEntryView; // not owned + CCalInstanceView* iInstanceView;// not owned + }; + + +CTestApp::CTestApp() + { + } + + +CTestApp::~CTestApp() + { + if (iTzID && iTestLibrary) + { + TRAP_IGNORE(iTestLibrary->SetTimeZoneL(iTzID->TimeZoneNameID())); + } + + iAlarmServer.Close(); + iTzServer.Close(); + delete iTestLibrary; + delete iTzID; + } + + +void CTestApp::ClearAllAlarmsL() + { + // Delete all alarms + RArray categories; + iAlarmServer.GetAvailableCategoryListL(categories); + TInt count = categories.Count(); + for(TInt i=0; iConstructL(); + + return (self); + } + + +void CTestApp::ConstructL() + { + iTestLibrary = CCalTestLibrary::NewL(); + + iTestLibrary->SetTimeZoneL(KEuropeBerlin); + + iTestLibrary->ReplaceFileL(KCalendarFile()); + iTestLibrary->OpenFileL(KCalendarFile()); + + iInstanceView = &iTestLibrary->SynCGetInstanceViewL(); + iEntryView = &iTestLibrary->SynCGetEntryViewL(); + + User::LeaveIfError(iTzServer.Connect()); + iTzID = iTzServer.GetTimeZoneIdL(); + + // Connect to the alarm server + User::LeaveIfError(iAlarmServer.Connect()); + + // Make sure that the alarm queue is empty. + ClearAllAlarmsL(); + } + + +void CTestApp::RunTestL() + { +// create repeating parent entry + + HBufC8* guid = KGUID().AllocLC(); + CCalEntry *entry = CCalEntry::NewL(CCalEntry::EReminder, guid, CCalEntry::EMethodNone, 0); + CleanupStack::Pop(guid); + CleanupStack::PushL(entry); + + + TCalTime startTime; + TCalTime endTime; + startTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 8, 10, 1, 0, 0))) ; + endTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 14, 10, 0, 0, 0))) ; + + entry->SetStartAndEndTimeL(startTime, endTime) ; + + + TCalRRule rrule(TCalRRule::EDaily); + rrule.SetDtStart(startTime); + rrule.SetUntil(endTime); + rrule.SetInterval(1); + entry->SetRRuleL(rrule); + + CCalAlarm *alarm = CCalAlarm::NewL(); + CleanupStack::PushL(alarm); + alarm->SetTimeOffset(TTimeIntervalMinutes(0)) ; + entry->SetAlarmL(alarm); + + RPointerArray entryarr; + CleanupClosePushL(entryarr); + + entryarr.AppendL(entry); + + TInt num = 0; + iEntryView->StoreL(entryarr, num); + test(entryarr.Count() == num); + + CleanupStack::PopAndDestroy(&entryarr); + CleanupStack::PopAndDestroy(alarm); + CleanupStack::PopAndDestroy(entry); + + +// Create child entry with exception + + + TTime ttime1(TDateTime(2006, EJanuary, 9, 10, 1, 0, 0)); + TCalTime recId; + recId.SetTimeUtcL(ttime1); // creating recurrence id + + + HBufC8* guid1 = KGUID().AllocLC(); + CCalEntry *entry1 = CCalEntry::NewL(CCalEntry::EReminder, guid1, CCalEntry::EMethodNone, 0, recId, CalCommon::EThisOnly); + CleanupStack::Pop(guid1); + CleanupStack::PushL(entry1); + + TCalTime startTime1; + TCalTime endTime1; + startTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 9, 10, 2, 0, 0))); + endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 11, 10, 0, 0, 0))); + entry1->SetStartAndEndTimeL(startTime1, endTime1); + + CCalAlarm* alarm1 = CCalAlarm::NewL(); + CleanupStack::PushL(alarm1) ; + alarm1->SetTimeOffset(TTimeIntervalMinutes(0)); + entry1->SetAlarmL(alarm1); + + + RPointerArray entryarr1; + CleanupClosePushL(entryarr1); + + entryarr1.AppendL(entry1); + + iEntryView->StoreL(entryarr1, num); + test(entryarr1.Count() == num); + + CleanupStack::PopAndDestroy(&entryarr1); + CleanupStack::PopAndDestroy(alarm1); + CleanupStack::PopAndDestroy(entry1); + + // for debugging + RPointerArray ins_arr; + CleanupResetAndDestroyPushL(ins_arr); + + CalCommon::TCalTimeRange trange(startTime, endTime); + + iInstanceView->FindInstanceL(ins_arr, CalCommon::EIncludeAll, trange); + + const TInt KCount = ins_arr.Count(); + + for(int i = 0; i < KCount; i++) + { + CCalEntry &ent = ins_arr[i]->Entry(); + TCalTime tt = ent.RecurrenceIdL(); + } + + CleanupStack::PopAndDestroy(&ins_arr); + + // now check what we have got in alarm servers + for(int i = 0; i < 2; i++) + { + TTime time(TDateTime(2006, EJanuary, 8 + i, 10, 0, 0, 0)); // how to set recurrance rule? + User::SetUTCTime(time); + User::After(1000000); + + TAlarmId id; + iAlarmServer.GetNextDueAlarmId(id); + + HBufC8* alarmData = NULL; + TInt err = iAlarmServer.GetAlarmData(id, alarmData); + + if( (err != KErrNone) || (!alarmData)) + { + User::Leave(-1); + } + + CleanupStack::PushL( alarmData ); + + CCalEntryId* entryId = CCalEntryId::NewL( alarmData ); + CleanupStack::Pop(alarmData); + CleanupStack::PushL(entryId); + + TPtrC8 id1 = entryId->IdL(); + TPtrC name = entryId->StoreFileNameL(); + + TTime recurrenceId = entryId->RecurrenceIdL().TimeUtcL(); + TTime instanceTime = entryId->InstanceTimeL().TimeLocalL(); // OK, has start time of the child + + if (i == 0) + { + test(recurrenceId == Time::NullTTime()); // for the parent + } + else if (i == 1) + { + test(recurrenceId != Time::NullTTime()); // for one child + } + + CleanupStack::PopAndDestroy(entryId); + } + } + +void CTestApp::TestRecurrenceIdPanicL() + { + RPointerArray entries; + CleanupResetAndDestroyPushL(entries); + + // Create an entry + _LIT8(KUid, "12345"); + CCalEntry *entry = CCalEntry::NewL(CCalEntry::EAppt, KUid().AllocLC(), CCalEntry::EMethodRequest, 0); + CleanupStack::Pop(); // uid + CleanupStack::PushL(entry); + + TDateTime dtStart, dtEnd; + dtStart.Set(2006, EApril, 19, 15, 30, 0, 0); + dtEnd.Set(2006, EApril, 19, 15, 40, 0, 0); + TCalTime startTime,endTime; + startTime.SetTimeUtcL(TTime(dtStart)); + endTime.SetTimeUtcL(TTime(dtEnd)); + entry->SetStartAndEndTimeL(startTime, endTime); + entry->SetSummaryL(_L("summary")); + + //Add a daily repeat + TCalRRule rule; + rule.SetType(TCalRRule::EDaily); + rule.SetDtStart(startTime); + rule.SetCount(10); + + entry->SetRRuleL(rule); + + entries.AppendL(entry); + CleanupStack::Pop(entry); + + //Create an exception + CCalEntry *child = CCalEntry::NewL(entry->EntryTypeL(), + entry->UidL().AllocL(), + entry->MethodL(), + entry->SequenceNumberL(), + startTime, + CalCommon::EThisOnly); + CleanupStack::PushL(child); + + child->SetSummaryL(_L("EXEX")); + child->SetLocationL(_L("EXEX")); + child->SetStartAndEndTimeL(startTime, endTime); + + entries.AppendL(child); + CleanupStack::Pop(child); + + TInt success = 0; + iTestLibrary->SynCGetEntryViewL().StoreL(entries, success); + entries.ResetAndDestroy(); + + // Refetch entries from db + iTestLibrary->SynCGetEntryViewL().FetchL(KUid, entries); + + TInt entryCount = entries.Count(); + + ASSERT(entryCount == 2); + CCalEntry* ex = entries[1]; //0 = parent, 1 = child + + HBufC8* guid = ex->UidL().AllocLC(); + CCalEntry* copy = CCalEntry::NewL( ex->EntryTypeL(), + guid, + ex->MethodL(), + ex->SequenceNumberL(), + ex->RecurrenceIdL(), + ex->RecurrenceRangeL() ); + CleanupStack::Pop( guid ); // ownership was passed + CleanupStack::PushL( copy ); + copy->CopyFromL( *ex ); + + //Access the recurrence id fields + TCalTime exTime1 = ex->RecurrenceIdL(); + TCalTime cpTime1 = copy->RecurrenceIdL(); + + //Delete all from db + iTestLibrary->CleanDatabaseL(); + + //Access the recurrence id fields again + TCalTime exTime2 = ex->RecurrenceIdL(); + TCalTime cpTime2 = copy->RecurrenceIdL(); //Causes KERN-EXEC-3 + + CleanupStack::PopAndDestroy( copy ); + CleanupStack::PopAndDestroy(&entries); + } + +/** +@SYMTestCaseID PIM-CALENDAR-RECUR-0001 +@SYMDEF DEF078776 +@SYMTestType UT +@SYMTestPriority Critical +@SYMDEF DEF078776 +@SYMTestCaseDesc Create a parent calendar entry with a child entry. + +@SYMTestActions +1. Tests a parent entry and child entry with a standard valid recurrence ID with date and time +2. Tests a parent entry and child entry with a recurrence ID with date but no time +3. Tests a parent entry and child entry with a recurrence ID with a date and time. The time is set so it that is not within the parents occurence. +4. Tests a parent entry and child entry with a recurrence ID with a date that is not within the parent occurence. + +@SYMTestExpectedResults For the above tests: +1. No leaves or panics should occur +2. No leaves or panics should occur +3. Should leave with KErrNotFound +4. Should leave with KErrNotFound +*/ +void CTestApp::RunRecurrenceTestL() + { + // Test normal recurrenceId with date and time: + TDateTime parentStartTime(2006, EJanuary, 8, 10, 0, 0, 0); + TDateTime parentEndTime(2006, EJanuary, 14, 10, 0, 0, 0); + TDateTime childStartTime(2006, EJanuary, 9, 10, 0, 0, 0); + TDateTime childEndTime(2006, EJanuary, 11, 10, 0, 0, 0); + TDateTime recurrenceId(2006, EJanuary, 9, 10, 0, 0, 0); + RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId); + + // Test recurrenceId that has a date but no time: + recurrenceId = TDateTime(2006, EJanuary, 9, 0, 0, 0, 0); + RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId); + + // Test recurrenceId that has a date but no time but is not within the same date as the parent occurence + recurrenceId = TDateTime(2006, EJune, 9, 0, 0, 0, 0); + TRAPD(ret, RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId)); + test(ret == KErrNotFound); // ret should be KErrNotFound as the recurrenceId is not valid + + // Test recurrenceId that has a date and time which is not within the same date as the parent occurence + recurrenceId = TDateTime(2006, EJanuary, 9, 10, 30, 0, 0); + TRAP(ret, RecurrenceTestL(parentStartTime, parentEndTime, childStartTime, childEndTime, recurrenceId)); + test(ret == KErrNotFound); // ret should be KErrNotFound as the recurrenceId is not valid + } + + +void CTestApp::RecurrenceTestL(TDateTime aParentStartTime, TDateTime aParentEndTime, TDateTime aChildStartTime, TDateTime aChildEndTime, TDateTime aRecurrenceId) + { +// Create repeating parent entry + HBufC8* guid = KGUID().AllocLC(); + CCalEntry *entry = CCalEntry::NewL(CCalEntry::EReminder, guid, CCalEntry::EMethodNone, 0); + CleanupStack::Pop(guid); + CleanupStack::PushL(entry); + + + TCalTime startTime; + TCalTime endTime; + startTime.SetTimeUtcL(TTime(aParentStartTime)); + endTime.SetTimeUtcL(TTime(aParentEndTime)); + + entry->SetStartAndEndTimeL(startTime, endTime); + + TCalRRule rrule(TCalRRule::EDaily); + rrule.SetDtStart(startTime); + rrule.SetUntil(endTime); + rrule.SetInterval(1); + entry->SetRRuleL(rrule); + + RPointerArray entryarr; + CleanupClosePushL(entryarr); + + entryarr.AppendL(entry); + + TInt num = 0; + iEntryView->StoreL(entryarr, num); + test(entryarr.Count() == num); + + CleanupStack::PopAndDestroy(&entryarr); + CleanupStack::PopAndDestroy(entry); + +// Create child entry with recurrence Id + TTime ttime1(aRecurrenceId); + TCalTime recId; + recId.SetTimeUtcL(ttime1); // creating recurrence id + + HBufC8* guid1 = KGUID().AllocLC(); + CCalEntry *entry1 = CCalEntry::NewL(CCalEntry::EReminder, guid1, CCalEntry::EMethodNone, 0, recId, CalCommon::EThisOnly); + CleanupStack::Pop(guid1); + CleanupStack::PushL(entry1); + + TCalTime startTime1; + TCalTime endTime1; + startTime1.SetTimeUtcL(TTime(aChildStartTime)); + endTime1.SetTimeUtcL(TTime(aChildEndTime)); + entry1->SetStartAndEndTimeL(startTime1, endTime1); + + RPointerArray entryarr1; + CleanupClosePushL(entryarr1); + + entryarr1.AppendL(entry1); + + iEntryView->StoreL(entryarr1, num); + test(entryarr1.Count() == num); + + CleanupStack::PopAndDestroy(&entryarr1); + CleanupStack::PopAndDestroy(entry1); + } + +/** +@SYMTestCaseID PIM-TCAL-RECUR-0002 +@SYMDEF DEF080989 +@SYMTestType UT +@SYMTestPriority Critical +@SYMDEF DEF080989 +@SYMTestCaseDesc RecurrenceIdL() returns NullTTime for new CCalEntry + +@SYMTestActions +1) create a REPEATING Parent +2) create a Child Entry with a Recurrence Id which wud be an instance of the parent entry. +3) call ChildEntry->CopyFromL(Parent); +4) check for Recurrence ID using ChildEntry->RecurrenceIdL() + +@SYMTestExpectedResults For the above tests: +Recurrence ID using ChildEntry->RecurrenceIdL() should not equal null +*/ + + +void CTestApp::ChildRecurrenceIdTestL() + { + test.Next(_L("@SYMTESTCaseID:PIM-TCAL-RECUR-0002 Child Recurrance Id test")); + + HBufC8 *uid = NULL; + CCalEntry* entry = iTestLibrary->CreateCalEntryL(CCalEntry::EReminder, uid); + CleanupStack::PushL( entry ); + + TCalTime timeStart; + TCalTime timeEnd; + TCalTime entryEnd; + timeStart.SetTimeUtcL( TDateTime(2006,EJanuary,2,3,4,5,6) ); + timeEnd.SetTimeUtcL( TDateTime(2006,EJanuary,10,3,4,5,6) ); + entryEnd.SetTimeUtcL( TDateTime(2006,EJanuary,2,4,4,5,6) ); + + TCalRRule rule(TCalRRule::EDaily) ; + rule.SetDtStart(timeStart); + rule.SetUntil(timeEnd); + rule.SetInterval(1); + + entry->SetStartAndEndTimeL(timeStart,entryEnd); + entry->SetRRuleL( rule ); + + RPointerArray< CCalEntry > calEntryList; + CleanupClosePushL( calEntryList ); + + calEntryList.Append( entry ); + + TInt many = 0; + iEntryView->StoreL( calEntryList, many ); + test(calEntryList.Count() == many); + + // create repeating child entry + TTime recId(TDateTime(2006, EJanuary, 5, 3, 4, 5, 6)); + TCalTime recIdCal; + recIdCal.SetTimeLocalL(recId); + + HBufC8* guid = uid->AllocLC(); + CCalEntry* entry2 = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 1, recIdCal, CalCommon::EThisAndAll); + CleanupStack::Pop(guid); + CleanupStack::PushL(entry2); + entry2->CopyFromL(*entry); + // this should give User 84 panic without the fix. + test(entry2->RecurrenceIdL().TimeLocalL()!=Time::NullTTime()); + CleanupStack::PopAndDestroy(entry2); + + CleanupStack::PopAndDestroy(&calEntryList); + CleanupStack::PopAndDestroy(entry); + } + + +TInt CTestApp::CreateRepeatingChildL(TCalTime& aChildRptStart,TCalTime& aChildRptEnd,TCalTime& aRecurId, CalCommon::TRecurrenceRange& aRange, TCalRRule::TType& aRType) + { + test.Printf(_L("Creating Child Entry")); + _LIT(KLocation,"Child Entry"); + TTime endTime(aChildRptStart.TimeLocalL() + TTimeIntervalHours(1)); + TCalTime childend; + childend.SetTimeLocalL(endTime); + HBufC8* guid = KGUID().AllocLC(); + CCalEntry* child = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 1, aRecurId, aRange); + CleanupStack::Pop(guid); + CleanupStack::PushL(child); + child->SetLocationL(KLocation()); + child->SetStartAndEndTimeL(aChildRptStart, childend); + TCalRRule rRule(aRType); + rRule.SetDtStart(aChildRptStart); + rRule.SetUntil(aChildRptEnd); + child->SetRRuleL(rRule); + + RPointerArray childEntries; + CleanupClosePushL(childEntries); + + childEntries.AppendL(child); + + TInt success = 0; + TRAPD(errStore, iEntryView->StoreL(childEntries, success)); + //test(childEntries.Count() == success); + + CleanupStack::PopAndDestroy(&childEntries); + CleanupStack::PopAndDestroy(child); + + if(errStore != KErrNone) + { + test.Printf(_L("Failed to Create Child Entry")); + } + + return errStore; + } + +void CTestApp::CreateParentL(TCalTime& aParentRptStart,TCalTime& aParentRptEnd, TCalRRule::TType& aRType) + { + test.Printf(_L("Creating Parent Entry")); + _LIT(KLocation,"Parent Entry"); + TTime endTime(aParentRptStart.TimeLocalL() + TTimeIntervalHours(1)); + HBufC8* guid = KGUID().AllocLC(); + CCalEntry* parent = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0); + CleanupStack::Pop(guid); + CleanupStack::PushL(parent); + TCalTime endTimeCal; + endTimeCal.SetTimeLocalL(endTime); + parent->SetStartAndEndTimeL(aParentRptStart, endTimeCal); + TCalRRule rRule(aRType); + rRule.SetDtStart(aParentRptStart); + rRule.SetUntil(aParentRptEnd); + parent->SetRRuleL(rRule); + parent->SetLocationL(KLocation()); + + RPointerArray entries; + CleanupClosePushL(entries); + + entries.AppendL(parent); + + TInt success(0); + iEntryView->StoreL(entries, success); + test(entries.Count() == success); + + CleanupStack::PopAndDestroy(&entries); + CleanupStack::PopAndDestroy(parent); + } + + + +void CTestApp::TestRecurrenceRangeL() + { + test.Next(_L("Verifying recurrence ranges of child entries")); + + + //Parent Entry Data + TTime startTime(TDateTime(2006, EJanuary, 0, 14, 0, 0, 0)); + TCalTime parRptStrt; + TCalTime parRptEnd; + parRptStrt.SetTimeLocalL(TDateTime(2006, EJanuary, 0, 14, 0, 0, 0)); + parRptEnd.SetTimeLocalL(TDateTime(2006, EApril, 19, 14, 0, 0, 0)); + + TCalTime recurrenceId; + recurrenceId.SetTimeLocalL(TDateTime(2006, EMarch, 13, 14, 0, 0, 0));//RECURRENCE ID + RArray recurRanges; + CleanupClosePushL(recurRanges); + TCalRRule::TType rRType = TCalRRule::EDaily; + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType); //Creating Parent Entry + + //Checking EThisAndPrior + TTime childstart(TDateTime(2006, EMarch, 13, 16, 0, 0, 0)); + CalCommon::TRecurrenceRange rRange = CalCommon::EThisAndPrior; + TCalTime chRptStrt; + TCalTime chRptEnd; + chRptStrt.SetTimeLocalL(TDateTime(2005, EDecember, 10, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EMarch, 28, 16, 0, 0, 0)); + //Adding repeating child entry. + TInt retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + test(retVal == KErrNone); + recurRanges.AppendL(CalCommon::EThisOnly); + recurRanges.AppendL(CalCommon::EThisAndPrior); + CheckRRangeL(recurRanges); //Checking Recurrence Range + recurRanges.Reset(); + + //Checking EThisAndFuture + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType); //Creating Parent Entry + rRange = CalCommon::EThisAndFuture; + chRptStrt.SetTimeLocalL(TDateTime(2006, EFebruary, 10, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EApril, 22, 16, 0, 0, 0)); + //Adding repeating child entry. + retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + recurRanges.AppendL(CalCommon::EThisOnly); + recurRanges.AppendL(CalCommon::EThisAndFuture); + CheckRRangeL(recurRanges); //Checking Recurrence Range + test(retVal == KErrNone); + recurRanges.Reset(); + + CleanupStack::PopAndDestroy(&recurRanges); + } + +void CTestApp::ClearDatabaseL() + { + CCalIter* iter = CCalIter::NewL(iTestLibrary->GetSession()); + CleanupStack::PushL(iter); + TPtrC8 nextId(iter->FirstL()); + CDesC8ArrayFlat* idArray = new (ELeave) CDesC8ArrayFlat(8); + CleanupStack::PushL(idArray); + while (nextId != KNullDesC8()) + { + idArray->AppendL(nextId); + nextId.Set(iter->NextL()); + } + iEntryView->DeleteL(*idArray); + + CleanupStack::PopAndDestroy(idArray); + CleanupStack::PopAndDestroy(iter); + } + +void CTestApp::CheckWithFindInstanceL(TCalTime& aStartRange,TCalTime& aEndRange,CalCommon::TCalViewFilter aFilter,TInt aExpectedInstances) + { + test.Printf(_L("Checking Instances")); + + RPointerArray instances; + CleanupResetAndDestroyPushL(instances); + + CalCommon::TCalTimeRange timeRange(aStartRange, aEndRange); + iInstanceView->FindInstanceL(instances, aFilter, timeRange); + + const TInt KCount=instances.Count(); + for (TInt i = 0; i < KCount; i++) + { + TDateTime dt = instances[i]->Time().TimeLocalL().DateTime(); + RDebug::Print(_L("instance of %d at %d:%d on %d/%d/%d"), + instances[i]->Entry().LocalUidL(), dt.Hour(), dt.Minute(), dt.Day()+1, dt.Month()+1, dt.Year()); + } + + test.Printf(_L("no of instances found are %d"), KCount); + test(aExpectedInstances == KCount); + + CleanupStack::PopAndDestroy(&instances); + } + +void CTestApp::CheckRRangeL( RArray< CalCommon::TRecurrenceRange > &aRanges ) + { + test.Printf(_L("Checking Recurrence ranges")); + + CCalIter& iter = iTestLibrary->GetIterL(); + TPtrC8 uid(iter.FirstL()); + + RPointerArray entryList; + CleanupResetAndDestroyPushL(entryList); + + iEntryView->FetchL(uid, entryList); + + const TInt KEntryCount = entryList.Count(); + for(TInt count = 0; count < KEntryCount; ++count) + { + switch(entryList[count]->RecurrenceRangeL()) + { + case CalCommon::EThisAndFuture: + { + test.Printf(_L("Recurrence Range found:: EThisAndFuture ")); + } + break; + case CalCommon::EThisAndPrior: + { + test.Printf(_L("Recurrence Range found:: EThisAndPrior ")); + } + break; + case CalCommon::EThisOnly: + { + test.Printf(_L("Recurrence Range found:: EThisOnly ")); + } + break; + } + + test(aRanges[count] == entryList[count]->RecurrenceRangeL()); + } + + test.Printf(_L("\n")); + + CleanupStack::PopAndDestroy(&entryList); + } + + + +void CTestApp::MultipleChildsWithRRulesL() + { + test.Next(_L("Multiple repeating children for Parent")); + + TTime startTime(TDateTime(2006, EJanuary, 10, 16, 0, 0, 0)); + TCalTime parRptStrt; + TCalTime parRptEnd; + parRptStrt.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 16, 0, 0, 0)); + parRptEnd.SetTimeLocalL(TDateTime(2006, EMarch, 29, 16, 0, 0, 0)); + TCalRRule::TType rRType = TCalRRule::EDaily; + + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType); //Parent + TTime childstart(TDateTime(2006, EMarch, 13, 10, 0, 0, 0)); + CalCommon::TRecurrenceRange rRange = CalCommon::EThisAndPrior; + TCalTime chRptStrt; + TCalTime chRptEnd; + TCalTime recurrenceId; + recurrenceId.SetTimeLocalL(TDateTime(2006, EMarch, 13, 16, 0, 0, 0)); //Recurrence ID + chRptStrt.SetTimeLocalL(TDateTime(2005, EDecember, 10, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EMarch, 10, 16, 0, 0, 0)); + TInt retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + test(retVal == KErrNone); + //adding another repeating child entry-- should not be allowed. + TTime childtime(TDateTime(2006, EMarch, 22, 19, 0, 0, 0)); + CalCommon::TRecurrenceRange recurRange = CalCommon::EThisAndFuture; + recurrenceId.SetTimeLocalL(TDateTime(2006, EMarch, 22, 16, 0, 0, 0)); //Recurrence ID + chRptStrt.SetTimeLocalL(TDateTime(2006, EMarch, 23, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EApril, 10, 16, 0, 0, 0)); + retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,recurRange,rRType); + test(retVal == KErrNotSupported); + } + + +void CTestApp::TestRDatesForParentChildL() + { + test.Next(_L("Add Child having only RDates to a repeating Parent")); + + TTime startTime(TDateTime(2006, EJanuary, 10, 16, 0, 0, 0)); + TCalTime minRange; + TCalTime maxRange; + minRange.SetTimeLocalL(TCalTime::MinTime()); + maxRange.SetTimeLocalL(TCalTime::MaxTime()); + + TCalTime parRptStrt; + TCalTime parRptEnd; + parRptStrt.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 16, 0, 0, 0)); + parRptEnd.SetTimeLocalL(TDateTime(2006, EMarch, 29, 16, 0, 0, 0)); + TCalRRule::TType rRType = TCalRRule::EDaily; + + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType); //Parent + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,79); + _LIT(KLocation,"Child Entry"); + TCalTime childstrt; + TCalTime childend; + TCalTime recurrenceID; + recurrenceID.SetTimeLocalL(TDateTime(2006, EJanuary, 20, 16, 0, 0, 0)); + childstrt.SetTimeLocalL(TDateTime(2006, EJanuary, 20, 18, 0, 0, 0)); + childend.SetTimeLocalL(TDateTime(2006, EJanuary, 20, 19, 0, 0, 0)); + HBufC8* guid = KGUID().AllocLC(); + CCalEntry* child = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 1, recurrenceID, CalCommon::EThisAndFuture); + CleanupStack::Pop(guid); + CleanupStack::PushL(child); + child->SetLocationL(KLocation()); + child->SetStartAndEndTimeL(childstrt, childend); + TCalTime rDate; + RArray rDateArray; + CleanupClosePushL(rDateArray); + rDate.SetTimeLocalL(TDateTime(2006, EJanuary, 22, 18, 0, 0, 0)); + rDateArray.Append(rDate); + rDate.SetTimeLocalL(TDateTime(2006, EFebruary, 20, 18, 0, 0, 0)); + rDateArray.Append(rDate); + rDate.SetTimeLocalL(TDateTime(2006, EMarch, 20, 18, 0, 0, 0)); + rDateArray.Append(rDate); + child->SetRDatesL(rDateArray); + + RPointerArray childEntries; + CleanupClosePushL(childEntries); + + childEntries.AppendL(child); + test.Printf(_L("Storing Child with only RDates")); + + TInt success = 0; + TRAPD(errStore,iEntryView->StoreL(childEntries, success)); + test(errStore == KErrNone); //Rdates of child are reffered if child has no repeat rule. + //and first of them is taken as the repeat start date. + test(childEntries.Count() == success); + + CleanupStack::PopAndDestroy(&childEntries); + rDateArray.Reset(); + CleanupStack::PopAndDestroy(&rDateArray); + CleanupStack::PopAndDestroy(child); + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,14); // 10 of parent,4 of child. + + test.Next(_L("Add Repeating Child to Parent having only RDates")); + + ClearDatabaseL(); + _LIT(KParent,"Parent Entry"); + guid = KGUID().AllocLC(); + CCalEntry* parent = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0); + CleanupStack::Pop(guid); + CleanupStack::PushL(parent); + TCalTime startTimeCal; + TCalTime endTimeCal; + startTimeCal.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 15, 0, 0, 0)); + endTimeCal.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 17, 0, 0, 0)); + parent->SetStartAndEndTimeL(startTimeCal, endTimeCal); + parent->SetLocationL(KParent()); + CleanupClosePushL(rDateArray); + rDate.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 15, 0, 0, 0)); + rDateArray.Append(rDate); + rDate.SetTimeLocalL(TDateTime(2006, EJanuary, 24, 18, 0, 0, 0)); + rDateArray.Append(rDate); + rDate.SetTimeLocalL(TDateTime(2006, EFebruary, 05, 10, 0, 0, 0)); + rDateArray.Append(rDate); + rDate.SetTimeLocalL(TDateTime(2006, EFebruary, 18, 14, 0, 0, 0)); + rDateArray.Append(rDate); + rDate.SetTimeLocalL(TDateTime(2006, EMarch, 02, 10, 0, 0, 0)); + rDateArray.Append(rDate); + parent->SetRDatesL(rDateArray); + + RPointerArray entries; + CleanupClosePushL(entries); + + entries.AppendL(parent); + test.Printf(_L("Creating Parent Entry")); + success = 0; + iEntryView->StoreL(entries, success); + test(entries.Count() == success); + + CleanupStack::PopAndDestroy(&entries); + + rDateArray.Reset(); + CleanupStack::PopAndDestroy(&rDateArray); + CleanupStack::PopAndDestroy(parent); + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,5); //5 RDates + //adding repeating child entry + CalCommon::TRecurrenceRange rRange = CalCommon::EThisAndFuture; + TTime childtime(TDateTime(2006, EJanuary, 24, 20, 0, 0, 0)); + recurrenceID.SetTimeLocalL(TDateTime(2006, EFebruary, 05, 10, 0, 0,0)); //Recurrence ID + TCalTime chRptStrt; + TCalTime chRptEnd; + chRptStrt.SetTimeLocalL(TDateTime(2006, EJanuary, 24, 20, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EMarch, 10, 20, 0, 0, 0)); + TInt retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceID,rRange,rRType); + test(retVal == KErrNone); + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,48); //2 RDates + 46 child + } + + + +void CTestApp::TestSingleDayRepeatL() + { + test.Next(_L("Test Single Day Repeat")); + + test.Printf(_L("Adding repeating Child to single day repeating Parent")); //Not Allowed + TTime startTime(TDateTime(2006, EJanuary, 1, 9, 0, 0, 0)); + TCalTime parRptStrt; + TCalTime parRptEnd; + parRptStrt.SetTimeLocalL(TDateTime(2006, EJanuary, 1, 9, 0, 0, 0)); + parRptEnd.SetTimeLocalL(TDateTime(2006, EJanuary, 1, 15, 0, 0, 0)); + TCalRRule::TType rRType = TCalRRule::EDaily; + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType); //PARENT + CalCommon::TRecurrenceRange rRange = CalCommon::EThisAndPrior; + TCalTime recurrenceId; + TCalTime chRptStrt; + TCalTime chRptEnd; + recurrenceId.SetTimeLocalL(TDateTime(2006, EJanuary, 1, 9, 0, 0, 0)); //Recurrence ID + chRptStrt.SetTimeLocalL(TDateTime(2005, EDecember, 10, 9, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2005, EDecember, 30, 9, 0, 0, 0)); + TInt retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); //EThisAndPrior + test(retVal == KErrArgument); + test.Printf(_L("Adding single day repeating Child to repeating Parent")); //Allowed + ClearDatabaseL(); + TTime startParent(TDateTime(2006, EFebruary, 10, 9, 0, 0, 0)); + parRptStrt.SetTimeLocalL(TDateTime(2006, EFebruary,10,9,0,0,0)); + parRptEnd.SetTimeLocalL(TDateTime(2006, EMarch, 10,9,0,0,0)); + CreateParentL(parRptStrt,parRptEnd,rRType);//PARENT + TTime childStart(TDateTime(2006, EFebruary, 20, 1, 0, 0, 0)); + recurrenceId.SetTimeLocalL((TDateTime(2006, EFebruary, 20, 9, 0, 0, 0))); //Recurrence ID + chRptStrt.SetTimeLocalL(TDateTime(2006, EFebruary, 20, 1, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EFebruary, 20, 8, 0, 0, 0)); + retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); //EThisAndPrior + test(retVal == KErrNone); + } + + + +void CTestApp::VerifyInstancesAfterLeaveWhileAddingChildL() + { + test.Next(_L("Verifying if any new instances are added when a leave happens while adding a repeating child")); + + TCalTime minRange; + TCalTime maxRange; + minRange.SetTimeLocalL(TCalTime::MinTime()); + maxRange.SetTimeLocalL(TCalTime::MaxTime()); + //Parent Data + TTime startTime(TDateTime(2006, EJanuary, 10, 14, 0, 0, 0)); + TCalTime parRptStrt; + TCalTime parRptEnd; + parRptStrt.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 14, 0, 0, 0)); + parRptEnd.SetTimeLocalL(TDateTime(2006, EMarch, 10, 14, 0, 0, 0)); //a total of 60 instances. + TCalTime recurrenceId; + recurrenceId.SetTimeLocalL(TDateTime(2006, EMarch, 10, 14, 0, 0, 0)); //RECURRENCE ID + TCalRRule::TType rRType = TCalRRule::EDaily; + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType);//PARENT + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,60); //60 instances should be there + + //Leaving when recurrence range is EThisAndPrior + TTime childstart(TDateTime(2006, EMarch, 10, 14, 0, 0, 0)); + CalCommon::TRecurrenceRange rRange = CalCommon::EThisAndPrior; + TCalTime chRptStrt; + TCalTime chRptEnd; + recurrenceId.SetTimeLocalL(TDateTime(2006, EMarch, 10, 14, 0, 0, 0)); //RECURRENCE ID + chRptStrt.SetTimeLocalL(TDateTime(2005, EDecember, 10, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EFebruary, 19, 16, 0, 0, 0)); + TInt retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + test(retVal == KErrArgument); + //After leave, the instance should still be 60. + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,60); //60 instances should be there + + //Leaving when recurrence range is EThisAndFuture + recurrenceId.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 14, 0, 0, 0)); //RECURRENCE ID + rRange = CalCommon::EThisAndFuture; + chRptStrt.SetTimeLocalL(TDateTime(2005, EDecember, 10, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EFebruary, 19, 16, 0, 0, 0)); + retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + test(retVal == KErrArgument); + //After leave, the instance should still be 60. + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,60); //60 instances should be there + + rRange = CalCommon::EThisAndAll; + //Leaving when recurrence range is EThisAndAll + retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + test(retVal == KErrArgument); + //After leave, the instance should still be 60. + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,60);//60 instances should be there + } + + + +void CTestApp::MiscellaneousTestCasesL() + { + test.Next(_L("replace first instance with a non-repeating child and add repeating child which removes all other future instances.")); + + TCalTime minRange; + TCalTime maxRange; + minRange.SetTimeLocalL(TCalTime::MinTime()); + maxRange.SetTimeLocalL(TCalTime::MaxTime()); + TTime startTime(TDateTime(2006, EJanuary, 10, 16, 0, 0, 0)); + TCalTime parRptStrt; + TCalTime parRptEnd; + parRptStrt.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 16, 0, 0, 0)); + parRptEnd.SetTimeLocalL(TDateTime(2006, EJanuary, 12, 16, 0, 0, 0)); + TCalRRule::TType rRType = TCalRRule::EDaily; + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType); //Parent + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,3); + + _LIT(KLocation,"Child Entry"); + TCalTime childstrt; + TCalTime childend; + TCalTime recurrenceId; + recurrenceId.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 16, 0, 0, 0)); + childstrt.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 18, 0, 0, 0)); + childend.SetTimeLocalL(TDateTime(2006, EJanuary, 10, 19, 0, 0, 0)); + HBufC8* guid = KGUID().AllocLC(); + CCalEntry* child = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 1, recurrenceId, CalCommon::EThisOnly); + CleanupStack::Pop(guid); + CleanupStack::PushL(child); + child->SetLocationL(KLocation()); + child->SetStartAndEndTimeL(childstrt, childend); + + RPointerArray childEntries; + CleanupClosePushL(childEntries); + + childEntries.AppendL(child); + + TInt success = 0; + TRAPD(errStore,iEntryView->StoreL(childEntries, success)); + test(errStore == KErrNone); + test(childEntries.Count() == success); + + CleanupStack::PopAndDestroy(&childEntries); + CleanupStack::PopAndDestroy(child); + + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,3); + + TTime childstart(TDateTime(2006, EJanuary, 11, 17, 0, 0, 0)); + CalCommon::TRecurrenceRange rRange = CalCommon::EThisAndFuture; + TCalTime chRptStrt; + TCalTime chRptEnd; + recurrenceId.SetTimeLocalL(TDateTime(2006, EJanuary, 11, 16, 0, 0, 0)); //RECURRENCE ID + chRptStrt.SetTimeLocalL(TDateTime(2005, EDecember, 10, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EFebruary, 19, 16, 0, 0, 0)); + TInt retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + test(retVal == KErrNone); + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,73); //1+(21+31+20)=73 + + test.Next(_L("replace last instance with a non-repeating child and add repeating child which removes all past instances.")); + + ClearDatabaseL(); + CreateParentL(parRptStrt,parRptEnd,rRType); //Parent + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,3); + recurrenceId.SetTimeLocalL(TDateTime(2006, EJanuary, 12, 16, 0, 0, 0)); + childstrt.SetTimeLocalL(TDateTime(2006, EJanuary, 12, 18, 0, 0, 0)); + childend.SetTimeLocalL(TDateTime(2006, EJanuary, 12, 19, 0, 0, 0)); + guid = KGUID().AllocLC(); + child = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 1, recurrenceId, CalCommon::EThisOnly); + CleanupStack::Pop(guid); + CleanupStack::PushL(child); + child->SetLocationL(KLocation()); + child->SetStartAndEndTimeL(childstrt, childend); + CleanupResetAndDestroyPushL(childEntries); + success = 0; + childEntries.AppendL(child); + TRAPD(secStore,iEntryView->StoreL(childEntries, success)); + test(secStore == KErrNone); + test(childEntries.Count() == success); + CleanupStack::PopAndDestroy(&childEntries); + CleanupStack::Pop(child); + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,3); + TTime childStart(TDateTime(2006, EJanuary, 11, 18, 0, 0, 0)); + rRange = CalCommon::EThisAndPrior; + recurrenceId.SetTimeLocalL(TDateTime(2006, EJanuary, 11, 16, 0, 0, 0)); //RECURRENCE ID + chRptStrt.SetTimeLocalL(TDateTime(2005, EDecember, 10, 10, 0, 0, 0)); + chRptEnd.SetTimeLocalL(TDateTime(2006, EFebruary, 19, 16, 0, 0, 0)); + retVal = CreateRepeatingChildL(chRptStrt,chRptEnd,recurrenceId,rRange,rRType); + test(retVal == KErrNone); + CheckWithFindInstanceL(minRange,maxRange,CalCommon::EIncludeAppts,73); + } + + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * DoTestL() + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +static void DoTestL() + { + CTestApp* testManager = CTestApp::NewLC(); + + + TPerformanceTimer timer(test); + timer.Start(); + + + // Run the test suite + + //set date to constant value to achieve consistent results + TDateTime dtime(2006,EJanuary,2,3,4,5,6); + TTime newtime(dtime); + TTime oldtime; + oldtime.HomeTime(); + + User::LeaveIfError( testManager->iTzServer.SetHomeTime(newtime) ); + + testManager->RunRecurrenceTestL(); + testManager->RunTestL(); + testManager->TestRecurrenceIdPanicL(); + testManager->ChildRecurrenceIdTestL(); + testManager->TestRecurrenceRangeL(); + testManager->TestSingleDayRepeatL(); + testManager->MultipleChildsWithRRulesL(); + testManager->VerifyInstancesAfterLeaveWhileAddingChildL(); + testManager->TestRDatesForParentChildL(); + testManager->MiscellaneousTestCasesL(); + + testManager->iTestLibrary->DeleteFileL(KCalendarFile, ETrue); + User::LeaveIfError( testManager->iTzServer.SetHomeTime(oldtime) );//revert to current time + + + timer.Stop(); + test.Printf(_L("Done\n")); + // printout performance time + timer.PrintOut(); + + + CleanupStack::PopAndDestroy(testManager); + } + + +/** + +@SYMTestCaseID PIM-TCAL-RECUR-0001 + +*/ + +TInt E32Main() + { + __UHEAP_MARK; + + test.Start(_L("@SYMTESTCaseID:PIM-TCAL-RECUR-0001 Calendar Interim API Recurrence 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); + }