void CDummyCalendarApp::RepeatExceptedEntryCreateL() { test.Next(_L("Add entry, repeat twice, set excepted and delete")); iEntries.ResetAndDestroy(); // Create new calendar entry. CCalEntry* entry = NULL; HBufC8* guid = KGUIDInc081869().AllocLC(); entry = CreateCalEntryL(CCalEntry::EAppt, guid); CleanupStack::Pop(guid); iEntries.AppendL(entry); // Set start and end date. TTime start(TDateTime(2006, EMarch, 6, 10, 0, 0, 0)); TTime end(TDateTime(2006, EMarch, 6, 14, 0, 0, 0)); SetEntryStartAndEndTimeL(entry, start, end); TBuf<50> summary; RandomText(summary); entry->SetSummaryL(summary); TBuf<50> location; RandomText(location); entry->SetLocationL(location); TBuf<50> description; RandomText(description); entry->SetDescriptionL(description); // Create a daily repeating rule that occurs for 2 days. TCalRRule rpt(TCalRRule::EDaily); rpt.SetInterval(1); rpt.SetCount(2); // Make sure the repeat time is within the delete time range. TCalTime repeatStart; TCalTime repeatEnd; repeatStart.SetTimeLocalL(TDateTime(2006, EMarch, 6, 0, 0, 0, 0)); repeatEnd.SetTimeLocalL(TDateTime(2006, EMarch, 8, 0, 0, 0, 0)); rpt.SetDtStart(repeatStart); rpt.SetUntil(repeatEnd); entry->SetRRuleL(rpt); // Store the entry. Because it repeats over 2 days, there will // be 2 entries. TInt entriesStored(0); SynCGetEntryViewL().StoreL(iEntries, entriesStored); test(entriesStored == iEntries.Count()); }
// ----------------------------------------------------------------------------- // CPIMAgnEventAdapter::ConvertRepeatToAgnL // Makes conversion from framework PIM item repeat rule to native entry repeat. // ----------------------------------------------------------------------------- // void CPIMAgnEventAdapter::ConvertRepeatToAgnL( const MPIMEventItem& aEventItemData, CCalEntry& aAgnEntry) { JELOG2(EPim); const MPIMRepeatRuleData* repeatRuleData = aEventItemData.GetRepeat(); TTime eventStart = aAgnEntry.StartTimeL().TimeUtcL(); TCalRRule agnRRule = PIMRepeatRuleConverter::ConvertSupportedRepeatToAgnL( *repeatRuleData, eventStart); if ((aAgnEntry.EntryTypeL() == CCalEntry::EAnniv) && (agnRRule.Type() != TCalRRule::EYearly)) { User::Leave(KErrArgument); } if (agnRRule.Type() == TCalRRule::EWeekly) { __ASSERT_ALWAYS(agnRRule.Interval() <= 2, User::Leave(KErrArgument)); } else // other than weekly { __ASSERT_ALWAYS(agnRRule.Interval() == 1, User::Leave(KErrArgument)); } // Use local time to check the day since UTC times provide incorrect // results if the compared dates are near midnight TTime untilLocal = agnRRule.Until().TimeLocalL(); TTime startLocal = aAgnEntry.StartTimeL().TimeLocalL(); // Validate that repeat rule is correct. The end of the repeat rule // must be greater than the event start and it must not be within // the same day as the start of the event if (untilLocal != Time::NullTTime()) { __ASSERT_ALWAYS(untilLocal >= startLocal, User::Leave(KErrAbort)); TTimeIntervalDays intervalDays = untilLocal.DaysFrom(startLocal); // Interval smaller than one day. Check that the day is not the same if (intervalDays < TTimeIntervalDays(1)) { __ASSERT_ALWAYS(untilLocal.DateTime().Day() != startLocal.DateTime().Day(), User::Leave(KErrAbort)); } } // Repeat Rules OK aAgnEntry.SetRRuleL(agnRRule); CopyExceptionDatesToAgnL(*repeatRuleData, aAgnEntry); }
void CBadRRule::CreateToDoEntryL() { RPointerArray<CCalEntry> entryarr ; CleanupResetAndDestroyPushL(entryarr); TInt num ; HBufC8* guid = KGUID1().AllocLC(); // ownership of guid gets transferred CCalEntry *entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0) ; CleanupStack::Pop(guid); CleanupStack::PushL(entry) ; TCalTime startTime ; TCalTime endTime ; startTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 8, 10, 30, 0, 0))) ; endTime.SetTimeUtcL(startTime.TimeUtcL() + TTimeIntervalDays(1)) ; entry->SetStartAndEndTimeL(startTime, endTime) ; TCalTime endTime1 ; endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 23, 10, 5, 0, 0))) ; TCalRRule rrule(TCalRRule::EWeekly) ; rrule.SetDtStart(startTime); rrule.SetUntil(endTime1); rrule.SetInterval(1); RArray<TDay> days; CleanupClosePushL(days); days.AppendL(ETuesday); rrule.SetByDay(days); CleanupStack::PopAndDestroy(&days); entry->SetRRuleL(rrule) ; // both entry and rrule start time should be aligned to the first instance TCalRRule setRRule ; entry->GetRRuleL(setRRule) ; test(setRRule.DtStart().TimeUtcL() == rrule.DtStart().TimeUtcL()) ; entryarr.AppendL(entry) ; CleanupStack::Pop(entry); iCalEntryView->StoreL(entryarr, num) ; entryarr.ResetAndDestroy(); TCalTime recId; recId.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 9, 10, 30, 0, 0))); // creating recurrence id guid = KGUID1().AllocLC(); // ownership of guid gets transferred entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0, recId, CalCommon::EThisOnly); CleanupStack::Pop(guid); CleanupStack::PushL(entry) ; TCalTime startTime3 ; TCalTime endTime3 ; startTime3.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 7, 10, 2, 0, 0))) ; endTime3.SetTimeUtcL(startTime3.TimeUtcL() + TTimeIntervalHours(1)) ; entry->SetStartAndEndTimeL(startTime3, endTime3) ; entryarr.AppendL(entry) ; CleanupStack::Pop(entry) ; iCalEntryView->StoreL(entryarr, num) ; CleanupStack::PopAndDestroy(&entryarr); RArray<TTime> insTimes ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 7, 11, 2, 0, 0))) ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 16, 10, 30, 0, 0))) ; CleanupClosePushL(insTimes) ; CheckInstancesL(insTimes) ; CleanupStack::PopAndDestroy(&insTimes) ; // time portion of repeat's end eliminates the third instance }
void CBadRRule::ModifyEntriesL() { TInt num, err ; RPointerArray<CCalEntry> entryarr3 ; iCalEntryView->FetchL(KGUID(), entryarr3) ; test(entryarr3.Count() == 3) ; /* got 3 entries - EThisAndAll of second child do not have any special effect */ CleanupStack::PushL(TCleanupItem(CleanupCCalEntryArray, &entryarr3)); TCalTime startTime4 ; TCalTime endTime4 ; startTime4.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 1, 10, 1, 0, 0))) ; endTime4.SetTimeUtcL(startTime4.TimeUtcL() + TTimeIntervalHours(1)) ; entryarr3[0]->SetStartAndEndTimeL(startTime4, endTime4) ; //The repeating starting time will not be adjusted until the entry is stored test(entryarr3[0]->StartTimeL().TimeUtcL() == startTime4.TimeUtcL()) ; TCalRRule savedRRule ; entryarr3[0]->GetRRuleL(savedRRule) ; //The repeating starting time will not be adjusted until the entry is stored test(savedRRule.DtStart().TimeUtcL() == startTime4.TimeUtcL()) ; iCalEntryView->StoreL(entryarr3, num) ; // store succeeds, because children are still aligned to an instance CleanupStack::PopAndDestroy(&entryarr3) ; RArray<TTime> insTimes ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 2, 10, 1, 0, 0))) ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 7, 10, 2, 0, 0))) ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 8, 11, 2, 0, 0))) ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 23, 10, 1, 0, 0))) ; CleanupClosePushL(insTimes) ; CheckInstancesL(insTimes) ; CleanupStack::PopAndDestroy(&insTimes) ; // this is interesting - there could be 4 instance, but as the count value of the // repeat rule has been kept intact, we still get 3 instances, // but they are shifted . /* store is successful with modified time - now we shall change rrule */ RPointerArray<CCalEntry> entryarr4 ; iCalEntryView->FetchL(KGUID(), entryarr4) ; test(entryarr4.Count() == 3) ; CleanupStack::PushL(TCleanupItem(CleanupCCalEntryArray, &entryarr4)); CCalEntry *entry = entryarr4[0] ; TCalTime startTime1 ; TCalTime endTime1 ; TCalTime untilTime1 ; startTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 16, 10, 1, 0, 0))) ; endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 16, 11, 1, 0, 0))) ; untilTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 26, 10, 5, 0, 0))) ; TCalRRule rrule(TCalRRule::EWeekly) ; rrule.SetDtStart(startTime1); rrule.SetUntil(untilTime1); rrule.SetInterval(1); RArray<TDay> days; CleanupClosePushL(days); days.AppendL(ETuesday); rrule.SetByDay(days); CleanupStack::PopAndDestroy(&days); entry->SetStartAndEndTimeL(startTime1, endTime1); entry->SetRRuleL(rrule) ; TRAP(err, iCalEntryView->StoreL(entryarr4, num)) ; test(err == -1) ; // due to change in rrule store should fail test(num == 2) ; // only parent + child2 have been saved CleanupStack::PopAndDestroy(&entryarr4) ; }
void CBadRRule::CreateParentL() { RPointerArray<CCalEntry> entryarr ; CleanupResetAndDestroyPushL(entryarr); TInt num ; HBufC8* guid = KGUID().AllocLC(); // ownership of guid gets transferred CCalEntry *entry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0) ; CleanupStack::Pop(guid); CleanupStack::PushL(entry) ; TCalTime startTime ; TCalTime endTime ; startTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 7, 10, 1, 0, 0))) ; endTime.SetTimeUtcL(startTime.TimeUtcL() + TTimeIntervalHours(1)) ; entry->SetStartAndEndTimeL(startTime, endTime) ; TCalTime endTime1; endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 23, 10, 5, 0, 0))) ; TCalRRule rrule(TCalRRule::EWeekly) ; rrule.SetDtStart(startTime); rrule.SetUntil(endTime1); rrule.SetInterval(1); RArray<TDay> days; CleanupClosePushL(days); days.AppendL(ETuesday); rrule.SetByDay(days); CleanupStack::PopAndDestroy(&days); entry->SetRRuleL(rrule) ; TCalRRule setRRule ; entry->GetRRuleL(setRRule) ; test(setRRule.DtStart().TimeUtcL() == rrule.DtStart().TimeUtcL()) ; entryarr.AppendL(entry) ; CleanupStack::Pop(entry); iCalEntryView->StoreL(entryarr, num) ; entryarr.ResetAndDestroy() ; iCalEntryView->FetchL(KGUID(), entryarr); TCalRRule savedRRule ; entryarr[0]->GetRRuleL(savedRRule) ; TCalTime matchTime ; /* Jan 10, 2006 is the first Tuesday */ matchTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 9, 10, 1, 0, 0))) ; //When the entry is stored, the repeat start time is adjusted so that it fits the rule (10th January is Tuesday test(savedRRule.DtStart().TimeUtcL() == matchTime.TimeUtcL()) ; test(entryarr[0]->StartTimeL().TimeUtcL() == (matchTime.TimeUtcL())) ; CleanupStack::PopAndDestroy(&entryarr) ; RArray<TTime> insTimes ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 9, 10, 1, 0, 0))) ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 16, 10, 1, 0, 0))) ; insTimes.Append(TTime(TDateTime(2006, EJanuary, 23, 10, 1, 0, 0))) ; CleanupClosePushL(insTimes) ; CheckInstancesL(insTimes) ; CleanupStack::PopAndDestroy(&insTimes) ; }
void CDummyCalendarApp::AddEntryL(TInt aNumToAdd, TBool isParent, TBool isRepeat) { test.Next(_L("Adding entries")); TBuf<50> summary; TBuf<50> location; TBuf<50> description; iEntries.ResetAndDestroy(); for (TInt index=0; index<aNumToAdd; index++) { TBuf8<255> buf; buf.Append(_L("GuidId")); buf.AppendNum(index); HBufC8* guid = buf.AllocLC(); // need to be pushed to ... CCalEntry::TType entryType=(index%2==0)?CCalEntry::ETodo:CCalEntry::EAppt; CCalEntry* entry = NULL; if(isParent) { entry = CreateCalEntryL(entryType, guid); } else { TTime localTime(KRecurrIdLocalTime); TCalTime recurrenceId; recurrenceId.SetTimeLocalL(localTime); entry = CCalEntry::NewL(entryType, guid, CCalEntry::EMethodAdd, 1, recurrenceId, CalCommon::EThisAndFuture); } CleanupStack::Pop(guid); iEntries.AppendL(entry); TInt year = -1; TInt month = -1; TInt day = -1; if (isParent) { year = index % 5 + 2001; // Any year in the range: 2001 - 2005 month = index % 12; day = index % 28; } else { // if this is a child entry, use the recurrence local time as the entry start time // so it won't be out of range TCalTime recurrId = entry->RecurrenceIdL(); TDateTime localTime = recurrId.TimeLocalL().DateTime(); year = localTime.Year(); month = localTime.Month(); day = localTime.Day(); } TTime start(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0)); TTime end(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0)); end += TTimeIntervalDays(1); SetEntryStartAndEndTimeL(entry,start,end); RandomText(summary); entry->SetSummaryL(summary); RandomText(location); entry->SetLocationL(location); RandomText(description); entry->SetDescriptionL(description); if(isRepeat) { //create a daily repeat rule and make sure its repeat start\end date is within the deleting time range TCalRRule rpt(TCalRRule::EDaily); rpt.SetInterval(1); TCalTime repeatStart; TCalTime repeatend; if(isParent) { //make sure the repeat time is within the delete time range repeatStart.SetTimeLocalL(TDateTime(2000, EJune, 0, 0, 0, 0, 0)); repeatend.SetTimeLocalL(TDateTime(2006, EJune, 0, 0, 0, 0, 0)); } else if (index<aNumToAdd/2) { // if this is a child entry, use the entry's recurrance time as repeating rule // start time TCalTime recurrId = entry->RecurrenceIdL(); // make sure the repeat time is within the delete time range for the first half entries repeatStart.SetTimeLocalL(recurrId.TimeLocalL()); // June 1, 2003 00:00:00 repeatend.SetTimeLocalL(recurrId.TimeLocalL() + TTimeIntervalMonths(1)); // July 1, 2003 00:00:00 } else { //make sure the repeat time is out of the delete time range for the second half entries repeatStart.SetTimeLocalL(TDateTime(2003, EJune, 0, 0, 0, 0, 0)); repeatend.SetTimeLocalL(TDateTime(2007, EJune, 0, 0, 0, 0, 0)); } rpt.SetDtStart(repeatStart); rpt.SetUntil(repeatend); entry->SetRRuleL(rpt); } } TInt entriesStored(0); iLocalEntryView->StoreL(iEntries, entriesStored); //temp test(entriesStored == iEntries.Count()); }
void CTestApp::FillEntryL(CCalEntry& aEntry) { switch (aEntry.EntryTypeL()) { case CCalEntry::EAppt: { aEntry.SetSummaryL(_L("appt")); // the appt spans midnight iCalTestLib->SetEntryStartAndEndTimeL(&aEntry, TTime(TDateTime(1995,EJanuary,0,20,15,0,0)), TTime(TDateTime(1995,EJanuary,1,5,15,0,0)) ); // it repeats every 2 days and has and exception TCalRRule rRuleAppt(TCalRRule::EDaily); TCalTime dtStartAppt; dtStartAppt.SetTimeLocalL(TTime(TDateTime(1995,EJanuary,0,0,0,0,0))); TCalTime untilAppt; untilAppt.SetTimeLocalL(TTime(TDateTime(1995,EJanuary,9,0,0,0,0))); rRuleAppt.SetDtStart(dtStartAppt); rRuleAppt.SetUntil(untilAppt); rRuleAppt.SetInterval(2); aEntry.SetRRuleL(rRuleAppt); TCalTime exception; exception.SetTimeLocalL(TTime(TDateTime(1995,EJanuary,4,0,0,0,0))); RArray<TCalTime> exceptions; CleanupClosePushL(exceptions); exceptions.AppendL(exception); aEntry.SetExceptionDatesL(exceptions); CleanupStack::PopAndDestroy(&exceptions); break; } case CCalEntry::EEvent: { aEntry.SetSummaryL(_L("event")); iCalTestLib->SetEntryStartAndEndTimeL(&aEntry, TTime(TDateTime(1995,EJanuary,0,0,0,0,0)), TTime(TDateTime(1995,EJanuary,0,0,0,0,0))); break; } case CCalEntry::EAnniv: { aEntry.SetSummaryL(_L("anniv")); iCalTestLib->SetEntryStartAndEndTimeL(&aEntry, TTime(TDateTime(1995,EJanuary,0,0,0,0,0)), TTime(TDateTime(1995,EJanuary,0,0,0,0,0))); // !!! WHAT'S THIS FOR ??? TCalRRule rRuleAnniv(TCalRRule::EYearly); TCalTime dtStartAnniv; dtStartAnniv.SetTimeLocalL(TTime(TDateTime(1994,EJanuary,0,0,0,0,0))); TCalTime untilAnniv; untilAnniv.SetTimeLocalL(TCalTime::MaxTime()); rRuleAnniv.SetDtStart(dtStartAnniv); rRuleAnniv.SetUntil(untilAnniv); rRuleAnniv.SetInterval(1); aEntry.SetRRuleL(rRuleAnniv); break; } case CCalEntry::ETodo: { aEntry.SetSummaryL(_L("todo")); aEntry.SetPriorityL(1); break; } } }
void CCalAlarmAttachTest::TestUpdateEntryHavingAlarmcontentL() { test.Printf(_L("Test updating an entry having AlarmContent \n")); //Create a Calendar entry with Alarm Content RPointerArray<CCalEntry> entries; CleanupResetAndDestroyPushL(entries); HBufC8* guid = KGUID1().AllocLC(); CCalEntry* calentry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0); CleanupStack::Pop(guid); CleanupStack::PushL(calentry); TCalTime calTime1; calTime1.SetTimeUtcL(TDateTime(2007,EFebruary,15, 13, 30, 0, 0)); TCalTime calTime2; calTime2.SetTimeUtcL(TDateTime(2007,EFebruary,15, 14, 30, 0, 0)); calentry->SetStartAndEndTimeL(calTime1, calTime2); calentry->SetSummaryL(_L("Test for Alarms")); CCalAlarm* alarm = CCalAlarm::NewL(); CleanupStack::PushL(alarm); alarm->SetTimeOffset(1); CCalContent* almContent = CCalContent::NewL(); CleanupStack::PushL(almContent); // Add content and mimetype for the alarm. HBufC8* content = KContent().AllocLC(); HBufC8* mimetype = KMimeType().AllocLC(); // Takes ownership of content and mimetype. almContent->SetContentL(content, mimetype, CCalContent::EDispositionInline); alarm->SetAlarmAction(almContent); // Takes ownership of almContent. calentry->SetAlarmL(alarm); CleanupStack::Pop(mimetype); CleanupStack::Pop(content); CleanupStack::Pop(almContent); CleanupStack::PopAndDestroy(alarm); TCalRRule rptRule; rptRule.SetDtStart( calTime1 ); rptRule.SetType( TCalRRule::EYearly ); rptRule.SetCount(5); calentry->SetRRuleL(rptRule); entries.AppendL(calentry); // Store entry with Alarm content TInt entriesStored = 0; iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored); CleanupStack::Pop(calentry); CleanupStack::PopAndDestroy(&entries); //Fetch stored entry and modify alarm time. CleanupResetAndDestroyPushL(entries); iTestLib->SynCGetEntryViewL().FetchL(KGUID1(), entries); CCalEntry* entry = entries[0]; alarm = entry->AlarmL(); CleanupStack::PushL(alarm); alarm->SetTimeOffset(1); entry->SetAlarmL(alarm); CleanupStack::PopAndDestroy(alarm); //Update the entry with changes. iTestLib->SynCGetEntryViewL().UpdateL(entries, entriesStored); CleanupStack::PopAndDestroy(&entries); //Fetch updated entry and check if Alarm content is intact. CleanupResetAndDestroyPushL(entries); iTestLib->SynCGetEntryViewL().FetchL(KGUID1(), entries); TestAlarmL(entries[0], KContent(), KMimeType()); CleanupStack::PopAndDestroy(&entries); }
/** * Tests behaviour of the alarm attachments. * * Create 3 entries, a parent, and two child entries. The first child entry has * an alarm attachment and stores the entry. The second child also has an * attachment and stores the entry. The second child's alarm attachment data * should overwrite the first child's alarm data. */ void CCalAlarmAttachTest::CreateEntriesL() { //----------------------------------------------------------------------- // Create parent entry with repeat rule //----------------------------------------------------------------------- RPointerArray<CCalEntry> entries; CleanupResetAndDestroyPushL(entries); HBufC8* guid = KGUID1().AllocLC(); CCalEntry* parentEntry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0); CleanupStack::Pop(guid); CleanupStack::PushL(parentEntry); TCalTime calTime1; calTime1.SetTimeUtcL(TDateTime(2007,EFebruary,15, 13, 30, 0, 0)); TCalTime calTime2; calTime2.SetTimeUtcL(TDateTime(2007,EFebruary,15, 14, 30, 0, 0)); parentEntry->SetStartAndEndTimeL(calTime1, calTime2); parentEntry->SetSummaryL(_L("Test for Alarms")); TCalRRule rptRule; rptRule.SetDtStart( calTime1 ); rptRule.SetType( TCalRRule::EDaily ); rptRule.SetInterval( 1 ); rptRule.SetCount(5); parentEntry->SetRRuleL(rptRule); entries.AppendL(parentEntry); // Store parent entry. TInt entriesStored = 0; iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored); CleanupStack::Pop(parentEntry); CleanupStack::PopAndDestroy(&entries); //----------------------------------------------------------------------- // Create child entry with recurrence id on 17th and with alarm attachment. //----------------------------------------------------------------------- RPointerArray<CCalEntry> entriesToStore1; CleanupResetAndDestroyPushL(entriesToStore1); TCalTime recurrenceId; recurrenceId.SetTimeUtcL(TDateTime(2007,EFebruary,17, 13, 30, 0, 0)); HBufC8* parentGuid = KGUID1().AllocLC(); CCalEntry* childEntry1 = CCalEntry::NewL(CCalEntry::EEvent, parentGuid, CCalEntry::EMethodNone, 0, recurrenceId, CalCommon::EThisOnly); CleanupStack::Pop(parentGuid); CleanupStack::PushL(childEntry1); TCalTime calTime3; calTime3.SetTimeUtcL(TDateTime(2007,EFebruary,21, 13, 30, 0, 0)); TCalTime calTime4; calTime4.SetTimeUtcL(TDateTime(2007,EFebruary,21, 14, 30, 0, 0)); childEntry1->SetStartAndEndTimeL(calTime3, calTime4); // Add an attachment to the alarm. CCalAlarm* alarm = CCalAlarm::NewL(); CleanupStack::PushL(alarm); alarm->SetTimeOffset(1); CCalContent* almContent = CCalContent::NewL(); CleanupStack::PushL(almContent); // Add content and mimetype for the alarm. _LIT8(KContent, "C:\\test.jpg"); _LIT8(KMimeType, "mime type"); HBufC8* content = KContent().AllocLC(); HBufC8* mimetype = KMimeType().AllocLC(); // Takes ownership of content and mimetype. almContent->SetContentL(content, mimetype, CCalContent::EDispositionInline); alarm->SetAlarmAction(almContent); // Takes ownership of almContent. childEntry1->SetAlarmL(alarm); CleanupStack::Pop(mimetype); CleanupStack::Pop(content); CleanupStack::Pop(almContent); CleanupStack::PopAndDestroy(alarm); TInt entriesStored1 = 0; entriesToStore1.AppendL(childEntry1); iTestLib->SynCGetEntryViewL().StoreL(entriesToStore1, entriesStored1); CleanupStack::Pop(childEntry1); // Test if the alarm details retrieved are as expected. CCalEntry* entry1 = entriesToStore1[0]; TestAlarmL(entry1, KContent(), KMimeType()); // Fetch the entry and ensure the alarm details are still as expected. FetchEntryL( KContent(), KMimeType() ); CleanupStack::PopAndDestroy(&entriesToStore1); //----------------------------------------------------------------------- // Create another child entry with recurrence id and range same as above. // The entry should be updated. //----------------------------------------------------------------------- RPointerArray<CCalEntry> entriesToStore2; CleanupResetAndDestroyPushL(entriesToStore2); HBufC8* parentGuid1 = KGUID1().AllocLC(); TCalTime recurrenceId1; recurrenceId1.SetTimeUtcL(TDateTime(2007,EFebruary,17, 13, 30, 0, 0)); CCalEntry* childEntry2 = CCalEntry::NewL(CCalEntry::EEvent, parentGuid1, CCalEntry::EMethodNone, 0, recurrenceId1, CalCommon::EThisOnly); CleanupStack::Pop(parentGuid1); CleanupStack::PushL(childEntry2); TCalTime calTime5; calTime5.SetTimeUtcL(TDateTime(2007,EFebruary,22, 13, 30, 0, 0)); TCalTime calTime6; calTime6.SetTimeUtcL(TDateTime(2007,EFebruary,22, 14, 30, 0, 0)); childEntry2->SetStartAndEndTimeL(calTime5, calTime6); childEntry2->SetSummaryL(_L("Update the child entry1")); childEntry2->SetPriorityL(2); // Add attachment to the alarm. CCalAlarm* alarm1 = CCalAlarm::NewL(); CleanupStack::PushL(alarm1); alarm1->SetTimeOffset(1); CCalContent* almContent1 = CCalContent::NewL(); CleanupStack::PushL(almContent1); // Add alarm attachment to the entry. _LIT8(KContent1, "C:\\longtail.jpg"); _LIT8(KMimeType1, "mime type 2"); HBufC8* content1 = KContent1().AllocLC(); HBufC8* mimetype1 = KMimeType1().AllocLC(); almContent1->SetContentL(content1, mimetype1, CCalContent::EDispositionInline); alarm1->SetAlarmAction(almContent1); childEntry2->SetAlarmL(alarm1); CleanupStack::Pop(mimetype1); CleanupStack::Pop(content1); CleanupStack::Pop(almContent1); CleanupStack::PopAndDestroy(alarm1); entriesToStore2.AppendL(childEntry2); // Store the child entry. TInt entriesStored2 = 0; iTestLib->SynCGetEntryViewL().StoreL(entriesToStore2, entriesStored2); // Store the entry again. The stream id for the alarm action will be // re-used (in CAgnEntry). RAgendaServ::UpdateEntryL() will call // CAgnEntry::UpdateAlarmAction() instead of StoreAlarmAction(). iTestLib->SynCGetEntryViewL().StoreL(entriesToStore2, entriesStored2); CleanupStack::Pop(childEntry2); CCalEntry* entry2 = entriesToStore2[0]; // Test if the alarm details are retrieved as expected. TestAlarmL(entry2, KContent1(), KMimeType1()); // Fetch the entry and ensure the alarm details are still as expected. FetchEntryL( KContent1(), KMimeType1() ); CleanupStack::PopAndDestroy(&entriesToStore2); }
void CCalAlarmAttachTest::TestDeleteAlarmL() { CCalEntryView &view = iTestLib->SynCGetEntryViewL() ; CCalEntryView *calentryview = &view ; TInt num ; ClearAllAlarmsL() ; test.Printf(_L("Going to check deletion of non-snoozed alarms\n")) ; /* create repeating parent entry */ HBufC8* guid = KGUID3().AllocLC(); // ownership of guid gets transferred CCalEntry *entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0) ; CleanupStack::Pop(guid); CleanupStack::PushL(entry) ; TTime now1; now1.UniversalTime(); now1 += TTimeIntervalSeconds(30); TCalTime startTime ; TCalTime endTime ; startTime.SetTimeUtcL(now1) ; endTime.SetTimeUtcL(now1 + TTimeIntervalSeconds(30)) ; entry->SetStartAndEndTimeL(startTime, endTime) ; TCalRRule rrule(TCalRRule::EDaily) ; rrule.SetDtStart(startTime); TCalTime endRTime ; endRTime.SetTimeUtcL(now1 + TTimeIntervalDays(7)) ; rrule.SetUntil(endRTime); rrule.SetInterval(1); entry->SetRRuleL(rrule) ; CCalAlarm *alarm = CCalAlarm::NewL() ; CleanupStack::PushL(alarm) ; alarm->SetTimeOffset(TTimeIntervalMinutes(0)) ; entry->SetAlarmL(alarm) ; //ownership does not get transferred RPointerArray<CCalEntry> entryarr ; entryarr.AppendL(entry) ; //ownership does not got transferred calentryview->StoreL(entryarr, num) ; entryarr.Close() ; CleanupStack::PopAndDestroy(alarm) ; CleanupStack::PopAndDestroy(entry) ; /* Now let the alarm go off */ RArray< TAlarmId > alarmIdArr ; iAlarmServer.GetAlarmIdListL(alarmIdArr) ; TInt cnt = alarmIdArr.Count() ; test(cnt > 0) ; TRequestStatus status = 0; TAlarmId alarmId = alarmIdArr[0]; alarmIdArr.Close() ; test.Printf(_L("Waiting one minute for the alarm to go off...\n")) ; for(;;) { iAlarmServer.NotifyChange(status, alarmId); User::WaitForRequest(status); PrintEventDetails(status.Int()); if (status.Int() == EAlarmChangeEventTimerExpired) { break; // alarm expired } } /* delete this entry - without snoozing */ RPointerArray< CCalEntry > calEntryArray ; calentryview->FetchL(KGUID3(), calEntryArray) ; test(calEntryArray.Count() == 1) ; CCalEntry *entry1 = calEntryArray[0] ; entry1->SetCompletedL(ETrue, startTime) ; calentryview->StoreL(calEntryArray, num) ; delete entry1 ; calEntryArray.Close() ; /* now check if the alarm still exists or not */ RArray< TAlarmId > alarmIdArr1 ; iAlarmServer.GetAlarmIdListL(alarmIdArr1) ; TInt cnt1 = alarmIdArr1.Count() ; test(cnt1 < cnt) ; if (cnt1 > 0) { TAlarmId alarmId1 = alarmIdArr1[0]; test(alarmId != alarmId1) ; } alarmIdArr1.Close() ; ClearAllAlarmsL() ; test.Printf(_L("Checking of non snoozed alarms successful\n")) ; }
void CCalOOMTest::CreateEntriesL() { _LIT8(KGuid1, "Reminder-1"); _LIT8(KGuid2, "Appt-1"); _LIT(KEntryStartTime, "20121119:013000.000000"); // 20-12-2012 01.30 _LIT(KEntryEndTime, "20121119:090000.000000"); // 20-12-2012 09.00 _LIT(KTimeUntil, "20131119:013000.000000"); // 20-12-2013 01.30 _LIT(KSummary1, "THIS SUMMARY"); _LIT(KSummary2, "Appt summary"); //entry 1 HBufC8* guid8 = HBufC8::NewL(KGuid1().Length()); guid8->Des().Copy(KGuid1); CleanupStack::PushL(guid8); CCalEntry* entry = CCalEntry::NewL(CCalEntry::EReminder, guid8, CCalEntry::EMethodAdd, (TUint)0); CleanupStack::Pop(guid8); entry->SetSummaryL(KSummary1); // entry2 guid8 = HBufC8::NewL(KGuid2().Length()); guid8->Des().Copy(KGuid2); CleanupStack::PushL(guid8); CCalEntry* entry2 = CCalEntry::NewL(CCalEntry::EAppt, guid8, CCalEntry::EMethodAdd, (TUint)0); CleanupStack::Pop(guid8); entry2->SetSummaryL(KSummary2); TTime time1(KEntryStartTime()); TTime time2(KEntryEndTime()); TCalTime st; st.SetTimeUtcL(time1); TCalTime end; end.SetTimeUtcL(time2); entry->SetStartAndEndTimeL(st, end); entry2->SetStartAndEndTimeL(st, end); TCalRRule* rRule=new (ELeave) TCalRRule(TCalRRule::EDaily); TCalTime calTime = entry->StartTimeL(); rRule->SetDtStart(calTime); rRule->SetInterval(1); TTime until(KTimeUntil()); TCalTime untilTime; untilTime.SetTimeUtcL(until); rRule->SetUntil(untilTime); entry->SetRRuleL(*rRule); entry2->SetRRuleL(*rRule); TInt entriesStored(0); RPointerArray<CCalEntry> entriesToStore; CleanupResetAndDestroyPushL(entriesToStore); entriesToStore.AppendL(entry); entriesToStore.AppendL(entry2); iTestLib->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored); delete rRule; CleanupStack::PopAndDestroy(&entriesToStore); // Find _LIT(KFindSt, "20131117:013000.000000"); // The event "overlaps" with this search range, hence must be caught. The reminder must not be caught (its end time = start time). _LIT(KFindEnd, "20131119:093000.000000"); CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll; TestFindInstancesL(KFindSt, KFindEnd, filter); // calling OOM test function }