--- /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 <e32std.h>
+#include <e32test.h>
+#include <asclisession.h>
+#include <asshdalarm.h>
+#include <tz.h>
+#include <calalarm.h>
+#include <calentry.h>
+#include <calentryview.h>
+#include <calprogresscallback.h>
+#include <calsession.h>
+#include <calrrule.h>
+#include <calinstance.h>
+#include <calinstanceview.h>
+#include <caliterator.h>
+
+
+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<CalCommon::TRecurrenceRange> &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<TAlarmCategory> categories;
+ iAlarmServer.GetAvailableCategoryListL(categories);
+ TInt count = categories.Count();
+ for(TInt i=0; i<count; i++)
+ {
+ const TAlarmCategory category = categories[i];
+ test(iAlarmServer.AlarmDeleteAllByCategory(category, EFalse) == KErrNone);
+ }
+ categories.Close();
+
+ // Restore alarm sound
+ iAlarmServer.SetAlarmSoundState(EAlarmGlobalSoundStateOn);
+ }
+
+
+CTestApp* CTestApp::NewLC()
+ {
+ CTestApp* self = new (ELeave) CTestApp();
+
+ CleanupStack::PushL(self);
+ self->ConstructL();
+
+ 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<CCalEntry> 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<CCalEntry> 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<CCalInstance> 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<CCalEntry> 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<CCalEntry> 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<CCalEntry> 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<CCalEntry> 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<CCalEntry> 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<CalCommon::TRecurrenceRange> 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<CCalInstance> 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<CCalEntry> 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<TCalTime> 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<CCalEntry> 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<CCalEntry> 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<CCalEntry> 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);
+ }