diff -r 000000000000 -r f979ecb2b13e pimappservices/calendar/tsrc/tCal_UndatedToDo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimappservices/calendar/tsrc/tCal_UndatedToDo.cpp Tue Feb 02 10:12:19 2010 +0200 @@ -0,0 +1,1040 @@ +// 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 + +RTest test(_L("tcal_undatedtodo")); + +_LIT(KCalendarFile, "tcal_undatedtodo"); +_LIT(KDateFormat, "%02d:%02d %02d/%02d/%04d\0"); + +class CTestApp : public CBase + { +public: + static CTestApp* NewL(); + ~CTestApp(); + + void DoTestsL(); + +private: + void ConstructL(); + + void TestTodoSortOrderL(const CalCommon::TCalTimeRange& aSearchRange); + void TestFindInstanceNonRepeatingTodoL(); + void TestFindInstanceRepeatingTodoL(); + void TestNextInstanceL(); + + void CreateAndTestNonRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, const CalCommon::TCalTimeRange& aTimeRange, TBool aExpected); + CCalEntry* CreateTodoLC(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime); + + void CreateAndTestRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount, const CalCommon::TCalTimeRange& aTimeRange, RArray aExpectedLocalInstanceTimes); + CCalEntry* CreateRepeatingTodoLC(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount); + + void PrintDetailsInstancesL(const RPointerArray& aInstanceList); + HBufC* TimeBufLC(const TTime& aLocalTime); + +private: // member data + CCalTestLibrary* iTestLib; + + CCalEntryView* iEntryView; // not owned + CCalInstanceView* iInstanceView;// not owned + + TTime iToday; + }; + +CTestApp* CTestApp::NewL() + { + CTestApp* app = new (ELeave) CTestApp(); + CleanupStack::PushL(app); + app->ConstructL(); + CleanupStack::Pop(app); + return app; + } + +CTestApp::~CTestApp() + { + delete iTestLib; + } + +void CTestApp::ConstructL() + { + iTestLib = CCalTestLibrary::NewL(); + + iTestLib->ReplaceFileL(KCalendarFile()); + iTestLib->OpenFileL(KCalendarFile()); + + iInstanceView = &iTestLib->SynCGetInstanceViewL(); + iEntryView = &iTestLib->SynCGetEntryViewL(); + + iToday.HomeTime(); + } + +HBufC* CTestApp::TimeBufLC(const TTime& aLocalTime) + { + TBuf<17> timeBuf; + TDateTime localDateTime = aLocalTime.DateTime(); + timeBuf.AppendFormat(KDateFormat, + localDateTime.Hour(), + localDateTime.Minute(), + localDateTime.Day() + 1, + static_cast(localDateTime.Month()) + 1, + localDateTime.Year()); + + return timeBuf.AllocLC(); + } + +void CTestApp::PrintDetailsInstancesL(const RPointerArray& aInstanceList) + { + const TInt KInstanceCount(aInstanceList.Count()); + + if (KInstanceCount == 0) + { + test.Printf(_L("No instances found!")); + } + else + { + test.Printf(_L("%d instances found"), KInstanceCount); + + // print the entry details + if (aInstanceList[0]->Entry().EndTimeL().TimeLocalL() != Time::NullTTime()) + { + // get the instance and entry due dates as strings + HBufC* entryEndTimeBuf = TimeBufLC(aInstanceList[0]->Entry().EndTimeL().TimeLocalL()); + + // does entry have start time? + TCalTime entryStartTime = aInstanceList[0]->Entry().StartTimeL(); + if (entryStartTime.TimeLocalL() == Time::NullTTime()) + { + test.Printf(_L("Entry due date := %s"), entryEndTimeBuf->Ptr()); + } + else + { + // get the instance and entry start times as strings + HBufC* entryStartTimeBuf = TimeBufLC(aInstanceList[0]->Entry().StartTimeL().TimeLocalL()); + + test.Printf(_L("Entry start and due date := %s - %s"), entryStartTimeBuf->Ptr(), entryEndTimeBuf->Ptr()); + CleanupStack::PopAndDestroy(entryStartTimeBuf); + } + + CleanupStack::PopAndDestroy(entryEndTimeBuf); + } + else + { + test.Printf(_L("undated entry")); + } + } + + for (TInt i(0) ; i < KInstanceCount ; ++i) + { + if (aInstanceList[i]->Entry().EndTimeL().TimeLocalL() != Time::NullTTime()) + { + // get the instance and entry due dates as strings + HBufC* instanceEndTimeBuf = TimeBufLC(aInstanceList[i]->EndTimeL().TimeLocalL()); + + // does entry have start time? + TCalTime entryStartTime = aInstanceList[i]->Entry().StartTimeL(); + if (entryStartTime.TimeLocalL() == Time::NullTTime()) + { + test.Printf(_L("Instance %d due date := %s"), i + 1, instanceEndTimeBuf->Ptr()); + } + else + { + // get the instance and entry start times as strings + HBufC* instanceStartTimeBuf = TimeBufLC(aInstanceList[i]->StartTimeL().TimeLocalL()); + + test.Printf(_L("Instance %d start and due date := %s - %s"), i + 1, instanceStartTimeBuf->Ptr(), instanceEndTimeBuf->Ptr()); + CleanupStack::PopAndDestroy(instanceStartTimeBuf); + } + + CleanupStack::PopAndDestroy(instanceEndTimeBuf); + } + else + { + test.Printf(_L("undated")); + } + + // display the completed time if the is one + TTime completedTimeLocal = aInstanceList[i]->Entry().CompletedTimeL().TimeLocalL(); + if (completedTimeLocal != Time::NullTTime()) + { + HBufC* completedTimeBuf = TimeBufLC(completedTimeLocal); + test.Printf(_L("Completed time = %s"), completedTimeBuf->Ptr()); + CleanupStack::PopAndDestroy(completedTimeBuf); + } + else + { + test.Printf(_L("incomplete")); + } + } + } + +CCalEntry* CTestApp::CreateTodoLC(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime) + { + HBufC8* guid = NULL; + CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::ETodo, guid); + CleanupStack::PushL(entry); + TCalTime calStartTime; + calStartTime.SetTimeLocalL(aStartTime); + TCalTime calEndTime; + calEndTime.SetTimeLocalL(aEndTime); + entry->SetStartAndEndTimeL(calStartTime, calEndTime); + + if (aCompletedTime != Time::NullTTime()) + { + TCalTime calTime; + calTime.SetTimeLocalL(aCompletedTime); + entry->SetCompletedL(ETrue, calTime); + } + + return entry; + } + +CCalEntry* CTestApp::CreateRepeatingTodoLC(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount) + { + HBufC8* guid = NULL; + CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::ETodo, guid); + CleanupStack::PushL(entry); + TCalTime calStartTime; + calStartTime.SetTimeLocalL(aStartTime); + TCalTime calEndTime; + calEndTime.SetTimeLocalL(aEndTime); + entry->SetStartAndEndTimeL(calStartTime, calEndTime); + + TCalRRule rRule(aRepeatType); + rRule.SetDtStart(calEndTime); + rRule.SetInterval(aInterval); + rRule.SetCount(aCount); + + switch (aRepeatType) + { + case TCalRRule::EWeekly: + { + RArray days; + CleanupClosePushL(days); + days.AppendL(aEndTime.DayNoInWeek()); + rRule.SetByDay(days); + CleanupStack::PopAndDestroy(&days); + } + break; + case TCalRRule::EMonthly: + { + RArray monthDays; + CleanupClosePushL(monthDays); + monthDays.AppendL(aEndTime.DayNoInMonth()); + rRule.SetByMonthDay(monthDays); + CleanupStack::PopAndDestroy(&monthDays); + } + break; + case TCalRRule::EYearly: + { + RArray months; + CleanupClosePushL(months); + months.AppendL(aEndTime.DateTime().Month()); + rRule.SetByMonth(months); + CleanupStack::PopAndDestroy(&months); + } + break; + } + + entry->SetRRuleL(rRule); + + if (aCompletedTime != Time::NullTTime()) + { + TCalTime calTime; + calTime.SetTimeLocalL(aCompletedTime); + entry->SetCompletedL(ETrue, calTime); + } + + return entry; + } + +void CTestApp::TestTodoSortOrderL(const CalCommon::TCalTimeRange& aSearchRange) + { + RPointerArray entryArray; + CleanupClosePushL(entryArray); + + // Create 3 TODOs 2 days in the past + // with different priorities + entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(2), iToday - TTimeIntervalDays(2), Time::NullTTime())); + entryArray[entryArray.Count() - 1]->SetPriorityL(4); + entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(2), iToday - TTimeIntervalDays(2), Time::NullTTime())); + entryArray[entryArray.Count() - 1]->SetPriorityL(2); + entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(2), iToday - TTimeIntervalDays(2), Time::NullTTime())); + entryArray[entryArray.Count() - 1]->SetPriorityL(3); + + // Create 3 TODOs 1 day in the past + // with different completed times + entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(4))); + entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(2))); + entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(7))); + + // Create 2 undated TODOs + entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), Time::NullTTime())); + entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), Time::NullTTime())); + // Create 2 undated TODOs + // with completed times + entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), iToday - TTimeIntervalMinutes(4))); + entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), iToday - TTimeIntervalMinutes(7))); + + // Create a TODO in the future + entryArray.AppendL(CreateTodoLC(iToday + TTimeIntervalDays(2), iToday + TTimeIntervalDays(2), Time::NullTTime())); + + TInt success(0); + iEntryView->StoreL(entryArray, success); + test(success == entryArray.Count()); + + CleanupStack::PopAndDestroy(entryArray.Count()); + CleanupStack::PopAndDestroy(&entryArray); + RPointerArray instanceArray; + CleanupResetAndDestroyPushL(instanceArray); + + iInstanceView->FindInstanceL(instanceArray, CalCommon::EIncludeAll, aSearchRange); + + test.Printf(_L("Test we found the expected number of instances!")); + //test(instanceArray.Count() == 11); + + const TInt KInstanceCount(instanceArray.Count()); + for (TInt i(0) ; i < KInstanceCount ; ++i) + { + TDateTime dt = instanceArray[i]->Time().TimeLocalL().DateTime(); + test.Printf(_L("the time of instance [%d] = %d:%d %d/%d/%d: \n"), i, dt.Hour(), dt.Minute(),dt.Day() + 1, dt.Month() + 1, dt.Year()); + } + + test.Printf(_L("Test the times of the todos")); + test(instanceArray[0]->Time().TimeLocalL() == iToday - TTimeIntervalDays(2)); + test(instanceArray[1]->Time().TimeLocalL() == iToday - TTimeIntervalDays(2)); + test(instanceArray[2]->Time().TimeLocalL() == iToday - TTimeIntervalDays(2)); + + // completed todos are sorted by completed time + test(instanceArray[3]->Time().TimeLocalL() == iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(7)); + test(instanceArray[4]->Time().TimeLocalL() == iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(4)); + test(instanceArray[5]->Time().TimeLocalL() == iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(2)); + + // due date should be Time::NullTTime but instance time should be set to completed time + test(instanceArray[6]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime()); + test(instanceArray[7]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime()); + test(instanceArray[6]->Time().TimeLocalL() == iToday - TTimeIntervalMinutes(7)); + test(instanceArray[7]->Time().TimeLocalL() == iToday - TTimeIntervalMinutes(4)); + + test(instanceArray[8]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime()); + test(instanceArray[9]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime()); + + test(instanceArray[10]->Time().TimeLocalL() == iToday + TTimeIntervalDays(2)); + + test.Printf(_L("Test the priority of the todos")); + test(instanceArray[0]->Entry().PriorityL() == 2); + test(instanceArray[1]->Entry().PriorityL() == 3); + test(instanceArray[2]->Entry().PriorityL() == 4); + + CleanupStack::PopAndDestroy(&instanceArray); + } + + +void CTestApp::CreateAndTestNonRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, const CalCommon::TCalTimeRange& aTimeRange, TBool aExpected) + { + iTestLib->CleanDatabaseL(); + + // Create and store entry + RPointerArray entryArray; + CleanupResetAndDestroyPushL(entryArray); + CCalEntry* todo = CreateTodoLC(aStartTime, aEndTime, aCompletedTime); + entryArray.AppendL(todo); + CleanupStack::Pop(todo); + TInt numSuc; + iTestLib->SynCGetEntryViewL().StoreL(entryArray, numSuc); + CleanupStack::PopAndDestroy(&entryArray); + + // find the todo + RPointerArray instanceList; + CleanupResetAndDestroyPushL(instanceList); + iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceList, CalCommon::EIncludeAll, aTimeRange); + PrintDetailsInstancesL(instanceList); + + if (aExpected) + { + // We are expecting an instance so test it + test(instanceList.Count() == 1); + + // test the entry times + if (aEndTime != Time::NullTTime()) + { + // dated + test(instanceList[0]->Entry().EndTimeL().TimeLocalL() == aEndTime); + } + else + { + // undated + test(instanceList[0]->Entry().StartTimeL().TimeLocalL() == Time::NullTTime()); + test(instanceList[0]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime()); + } + + // test the instance times + if (instanceList[0]->Entry().CompletedTimeL().TimeLocalL() == Time::NullTTime()) + { + // incomplete + if (aEndTime != Time::NullTTime()) + { + // the todo is dated + + // the instance due date should always be the same as the entry due date + test(instanceList[0]->EndTimeL().TimeLocalL() == aEndTime); + + if (aStartTime != Time::NullTTime()) + { + // The entry has a start time so the instance should have the same start time + test(instanceList[0]->StartTimeL().TimeLocalL() == aStartTime); + } + else + { + // The entry was not stored with a start time + // so the instance start time should be the same as the due date + test(instanceList[0]->StartTimeL().TimeLocalL() == instanceList[0]->EndTimeL().TimeLocalL()); + } + } + else + { + // The todo is undated + // so test that the start and end times are the same and that they are set as some time today + test(instanceList[0]->StartTimeL().TimeLocalL() == instanceList[0]->EndTimeL().TimeLocalL()); + test(instanceList[0]->StartTimeL().TimeLocalL() != Time::NullTTime()); + test(instanceList[0]->StartTimeL().TimeLocalL().DaysFrom(iToday).Int() == 0); + } + } + else + { + // complete + test(instanceList[0]->StartTimeL().TimeLocalL() == instanceList[0]->Entry().CompletedTimeL().TimeLocalL()); + test(instanceList[0]->EndTimeL().TimeLocalL() == instanceList[0]->Entry().CompletedTimeL().TimeLocalL()); + } + } + else + { + test(instanceList.Count() == 0); + } + CleanupStack::PopAndDestroy(&instanceList); + } + +void CTestApp::CreateAndTestRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount, const CalCommon::TCalTimeRange& aTimeRange, RArray aExpectedLocalInstanceTimes) + { + iTestLib->CleanDatabaseL(); + + // Create and store repeating todo entry + RPointerArray entryArray; + CleanupResetAndDestroyPushL(entryArray); + CCalEntry* rptTodo = CreateRepeatingTodoLC(aStartTime, aEndTime, aCompletedTime, aRepeatType, aInterval, aCount); + entryArray.AppendL(rptTodo); + CleanupStack::Pop(rptTodo); + TInt numSuc; + iTestLib->SynCGetEntryViewL().StoreL(entryArray, numSuc); + CleanupStack::PopAndDestroy(&entryArray); + + // find the todo + RPointerArray instanceList; + CleanupResetAndDestroyPushL(instanceList); + iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceList, CalCommon::EIncludeAll, aTimeRange); + PrintDetailsInstancesL(instanceList); + + test(instanceList.Count() == aExpectedLocalInstanceTimes.Count()); + + for (TInt i(0) ; i < instanceList.Count() ; ++i) + { + test(instanceList[i]->EndTimeL().TimeLocalL() == aExpectedLocalInstanceTimes[i]); + } + + CleanupStack::PopAndDestroy(&instanceList); + } + +void CTestApp::TestFindInstanceNonRepeatingTodoL() + { + // set up a search range +- 10 days from now + TCalTime startDateTime1; + startDateTime1.SetTimeLocalL(iToday - TTimeIntervalDays(10)); + TCalTime endDateTime1; + endDateTime1.SetTimeLocalL(iToday + TTimeIntervalDays(10)); + CalCommon::TCalTimeRange timeRangeWithToday(startDateTime1, endDateTime1); + + TCalTime startDateTime2; + startDateTime2.SetTimeLocalL(iToday + TTimeIntervalDays(1)); + TCalTime endDateTime2; + endDateTime2.SetTimeLocalL(iToday + TTimeIntervalDays(20)); + CalCommon::TCalTimeRange timeRangeAfterToday(startDateTime2, endDateTime2); + + TCalTime startDateTime3; + startDateTime3.SetTimeLocalL(iToday - TTimeIntervalDays(20)); + TCalTime endDateTime3; + endDateTime3.SetTimeLocalL(iToday - TTimeIntervalDays(1)); + CalCommon::TCalTimeRange timeRangeBeforeToday(startDateTime3, endDateTime3); + + // completed todos + test.Printf(_L("\n--Completed todo with completion date before the time range (due before)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), // due before + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--Completed todo with completion date before the time range (due inside)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.StartTime().TimeLocalL() + TTimeIntervalDays(2), // due inside + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--Completed todo with completion date before the time range (due after)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // due after + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--Completed todo with completion date after the time range (due after)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // due after + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--Completed todo with completion date after the time range (due inside)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), // due inside + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--Completed todo with completion date after the time range (due inside)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), // due before + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--Completed todo with completion date inside the time range (due before)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), // due before + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n--Completed todo with completion date inside the time range (due after)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // due after + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n--Completed todo with completion date inside the time range (due inside)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), // due inside + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), + timeRangeWithToday, + ETrue); + + // incomplete todos + test.Printf(_L("\n--incomplete dated todo with start and due date before time range--")); + CreateAndTestNonRptTodoL(timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), // before + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), + Time::NullTTime(), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--incomplete dated todo with only due date before time range--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), // no start date + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), // only due date before + Time::NullTTime(), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--incomplete dated todo crossing the start time of the search range--")); + CreateAndTestNonRptTodoL(timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(1), + timeRangeWithToday.StartTime().TimeLocalL() + TTimeIntervalDays(1), // crossing the start time + Time::NullTTime(), + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n--incomplete dated todo with start and due date inside the search range--")); + CreateAndTestNonRptTodoL(timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), // totally inside + Time::NullTTime(), + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n--incomplete dated todo with only due date inside the search range--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), // no start date + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), // only due date inside + Time::NullTTime(), + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n--incomplete dated todo crossing the end of the search range--")); + CreateAndTestNonRptTodoL(timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(1), + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(1), // crossing the end of the range + Time::NullTTime(), + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n--incomplete dated todo with start and due date after the search range--")); + CreateAndTestNonRptTodoL(timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // totally after range + Time::NullTTime(), + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--incomplete dated todo with only due date after the search range--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), // no start date + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // only due after + Time::NullTTime(), + timeRangeWithToday, + EFalse); + + // undated todos + test.Printf(_L("\n--undated todo (completed before search range)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + Time::NullTTime(), + timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2),// before + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--undated todo (completed inside search range)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + Time::NullTTime(), + timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), // during + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n--undated todo (completed after search range)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + Time::NullTTime(), + timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // after + timeRangeWithToday, + EFalse); + + test.Printf(_L("\n--undated todo (incomplete)--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + Time::NullTTime(), + Time::NullTTime(), // incomplete + timeRangeWithToday, + ETrue); + + test.Printf(_L("\n----Test undated todos are not found when search range does not include today--")); + test.Printf(_L("\n--Search for undated todos after today--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + Time::NullTTime(), + Time::NullTTime(), // incomplete + timeRangeAfterToday, + EFalse); + + test.Printf(_L("\n--Search for undated todos before today--")); + CreateAndTestNonRptTodoL(Time::NullTTime(), + Time::NullTTime(), + Time::NullTTime(), // incomplete + timeRangeBeforeToday, + EFalse); + + } + +void CTestApp::TestFindInstanceRepeatingTodoL() + { + RArray expectedLocalInstanceTimes; + CleanupClosePushL(expectedLocalInstanceTimes); + + const TTime KArbitraryTime(TDateTime(2006, ENovember, 22, 11, 30, 0, 0)); + +// set up a search range +- 10 days from (11:30 23 November 2006) + TCalTime startDateTime; + startDateTime.SetTimeLocalL(KArbitraryTime - TTimeIntervalDays(10)); + TCalTime endDateTime; + endDateTime.SetTimeLocalL(KArbitraryTime + TTimeIntervalDays(10)); + CalCommon::TCalTimeRange timeRange(startDateTime, endDateTime); + +// Create repeating todos of all different repeat types + // Make sure instances of all repeat types have instances before, after, in and on the time range + // 1. With and without a completed date set + // 2. With and without a start date + test.Printf(_L("\n--Testing Daily Repeats--")); + test.Printf(_L("\n--incomplete with start date and due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(1)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(6)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(11)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(16)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(21)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(6), // The middle of the first instance is 5 days before + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + Time::NullTTime(), // incomplete + TCalRRule::EDaily, + 5, // interval + 8, // count + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--incomplete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(1)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(6)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(11)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(16)); + CreateAndTestRptTodoL(Time::NullTTime(), // without start date + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + Time::NullTTime(), // incomplete + TCalRRule::EDaily, + 5, + 7, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(1)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(6)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(11)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(16)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(21)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(6), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2), // complete inside + TCalRRule::EDaily, + 5, + 7, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(1)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(6)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(11)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(16)); + CreateAndTestRptTodoL(Time::NullTTime(), // without start date + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2), // complete outside + TCalRRule::EDaily, + 5, + 7, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Testing weekly Repeats--")); + test.Printf(_L("\n--Complete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(3)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(10)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(17)); + CreateAndTestRptTodoL(Time::NullTTime(), // without start date + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(2), // complete outside + TCalRRule::EWeekly, + 1, + 7, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with start and due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(3)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(10)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(17)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(24)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(9), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(2), // complete outside + TCalRRule::EWeekly, + 1, + 7, + timeRange, + expectedLocalInstanceTimes); + test.Printf(_L("\n--Incomplete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(3)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(10)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(17)); + CreateAndTestRptTodoL(Time::NullTTime(), // without start date + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + Time::NullTTime(), // incomplete + TCalRRule::EWeekly, + 1, + 7, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Incomplete with start and due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(3)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(10)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(17)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(24)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(9), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), + Time::NullTTime(), // incomplete + TCalRRule::EWeekly, + 1, + 7, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Testing monthly Repeats--")); + test.Printf(_L("\n--Complete with start and due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2) + TTimeIntervalMonths(1)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalMonths(1) - TTimeIntervalDays(20), + timeRange.StartTime().TimeLocalL() - TTimeIntervalMonths(1) + TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), // complete before + TCalRRule::EMonthly, + 1, + 4, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2)); + CreateAndTestRptTodoL(Time::NullTTime(), + timeRange.StartTime().TimeLocalL() - TTimeIntervalMonths(1) + TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(4), // complete before + TCalRRule::EMonthly, + 1, + 4, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Incomplete with start and due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2)); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2) + TTimeIntervalMonths(1)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalMonths(1) - TTimeIntervalDays(20), + timeRange.StartTime().TimeLocalL() - TTimeIntervalMonths(1) + TTimeIntervalDays(2), + Time::NullTTime(), // incomplete + TCalRRule::EMonthly, + 1, + 4, + timeRange, + expectedLocalInstanceTimes); + test.Printf(_L("\n--Incomplete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2)); + CreateAndTestRptTodoL(Time::NullTTime(), + timeRange.StartTime().TimeLocalL() - TTimeIntervalMonths(1) + TTimeIntervalDays(2), + Time::NullTTime(), // incomplete + TCalRRule::EMonthly, + 1, + 4, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Testing yearly Repeats--")); + test.Printf(_L("\n--Complete with only due date set--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2)); + CreateAndTestRptTodoL(Time::NullTTime(), + timeRange.StartTime().TimeLocalL() - TTimeIntervalYears(1) + TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(2), // complete before + TCalRRule::EYearly, + 1, + 3, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with start and due date set (across start of range)--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(2)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalYears(1) - TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalYears(1) + TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(2), // complete before + TCalRRule::EYearly, + 1, + 3, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with start and due date set (inside range)--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.StartTime().TimeLocalL() + TTimeIntervalDays(4)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalYears(1) + TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalYears(1) + TTimeIntervalDays(4), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(2), // complete before + TCalRRule::EYearly, + 1, + 3, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with start and due date set (across end of range)--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.EndTime().TimeLocalL() + TTimeIntervalDays(2)); + CreateAndTestRptTodoL(timeRange.EndTime().TimeLocalL() - TTimeIntervalYears(1) - TTimeIntervalDays(2), + timeRange.EndTime().TimeLocalL() - TTimeIntervalYears(1) + TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(2), // complete before + TCalRRule::EYearly, + 1, + 3, + timeRange, + expectedLocalInstanceTimes); + + test.Printf(_L("\n--Complete with start and due date set (across whole range)--")); + expectedLocalInstanceTimes.Reset(); + expectedLocalInstanceTimes.AppendL(timeRange.EndTime().TimeLocalL() + TTimeIntervalDays(2)); + CreateAndTestRptTodoL(timeRange.StartTime().TimeLocalL() - TTimeIntervalYears(1) - TTimeIntervalDays(2), + timeRange.EndTime().TimeLocalL() - TTimeIntervalYears(1) + TTimeIntervalDays(2), + timeRange.StartTime().TimeLocalL() - TTimeIntervalDays(2), // complete before + TCalRRule::EYearly, + 1, + 3, + timeRange, + expectedLocalInstanceTimes); + + + CleanupStack::PopAndDestroy(&expectedLocalInstanceTimes); + } + +void CTestApp::TestNextInstanceL() + { + // create TCalTime for a day after today + TCalTime today; + today.SetTimeLocalL(iToday + TTimeIntervalDays(1)); + + RPointerArray entryArray; + CleanupResetAndDestroyPushL(entryArray); + + // create a todo that is 20 days in the future + CCalEntry* entry = CreateTodoLC(iToday + TTimeIntervalDays(20), + iToday + TTimeIntervalDays(20), + Time::NullTTime()); + + HBufC* entryDueTimeBuf = TimeBufLC(entry->EndTimeL().TimeLocalL()); + test.Printf(_L("Adding an entry with due time := %s"), entryDueTimeBuf->Ptr()); + CleanupStack::PopAndDestroy(entryDueTimeBuf); + + entryArray.AppendL(entry); + CleanupStack::Pop(entry); + TInt numSuc; + iTestLib->SynCGetEntryViewL().StoreL(entryArray, numSuc); + entryArray.ResetAndDestroy(); + + TCalTime nextTime = iTestLib->SynCGetInstanceViewL().NextInstanceL(CalCommon::EIncludeAll, today); + + HBufC* nextTimeBuf = TimeBufLC(nextTime.TimeLocalL()); + test.Printf(_L("Original NextInstanceL(), from tomorrow := %s"), nextTimeBuf->Ptr()); + CleanupStack::PopAndDestroy(nextTimeBuf); + + CCalEntry* todo = CreateTodoLC(Time::NullTTime(), + Time::NullTTime(), + Time::NullTTime()); + + entryArray.AppendL(todo); + CleanupStack::Pop(todo); + iTestLib->SynCGetEntryViewL().StoreL(entryArray, numSuc); + CleanupStack::PopAndDestroy(&entryArray); + + TCalTime nextTime2 = iTestLib->SynCGetInstanceViewL().NextInstanceL(CalCommon::EIncludeAll, today); + + HBufC* nextTime2Buf = TimeBufLC(nextTime.TimeLocalL()); + test.Printf(_L("NextInstanceL() with undated todo added, from tomorrow := %s"), nextTime2Buf->Ptr()); + CleanupStack::PopAndDestroy(nextTime2Buf); + + test(nextTime.TimeLocalL() == nextTime2.TimeLocalL()); + } + + + +void CTestApp::DoTestsL() + { + // Set up time range for +- 10 days + TCalTime startDateTime; + startDateTime.SetTimeLocalL(iToday - TTimeIntervalDays(10)); + TCalTime endDateTime; + endDateTime.SetTimeLocalL(iToday + TTimeIntervalDays(10)); + CalCommon::TCalTimeRange timeRange(startDateTime, endDateTime); + + // Set up time range for min max time + TCalTime minCalTime; + minCalTime.SetTimeUtcL(TCalTime::MinTime()); + TCalTime maxCalTime; + maxCalTime.SetTimeUtcL(TCalTime::MaxTime()); + CalCommon::TCalTimeRange timeRangeMinToMax(minCalTime, maxCalTime); + + + test.Next(_L("Test that todos are sorted in the correct order (with time range +- 10 days)")); + + iTestLib->CleanDatabaseL(); + TestTodoSortOrderL(timeRange); + + test.Next(_L("Test that todos are sorted in the correct order (with time range min at max time)")); + + iTestLib->CleanDatabaseL(); + TestTodoSortOrderL(timeRangeMinToMax); + + + test.Next(_L("Test all types of non-repeating todos are returned correctly")); + + iTestLib->CleanDatabaseL(); + TestFindInstanceNonRepeatingTodoL(); + + test.Next(_L("Test all types of repeating todos are returned correctly")); + + iTestLib->CleanDatabaseL(); + TestFindInstanceRepeatingTodoL(); + + test.Next(_L("Test NextInstanceL with and without an undated todo")); + + iTestLib->CleanDatabaseL(); + TestNextInstanceL(); + } + +static void doMainL() + { + CTestApp* app = CTestApp::NewL(); + CleanupStack::PushL(app); + + app->DoTestsL(); + + CleanupStack::PopAndDestroy(app); + } + +/** + +@SYMTestCaseID PIM-TCAL-UNDATEDTODO-0001 + +*/ + +TInt E32Main() + { + __UHEAP_MARK; + test.Start(_L("@SYMTESTCaseID:PIM-TCAL-UNDATEDTODO-0001 tCal_Instance")); + + test.Title(); + CTrapCleanup* theCleanup = CTrapCleanup::New(); + CActiveScheduler* scheduler = new(ELeave)CActiveScheduler; + CActiveScheduler::Install(scheduler); + TRAPD(ret,doMainL()); + delete scheduler; + test(ret == KErrNone); + delete theCleanup; + test.End(); + test.Close(); + __UHEAP_MARKEND; + return(KErrNone); + } +