C++ CCalEntry::SetRRuleL方法代码示例

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) ;
}

//.........这里部分代码省略.........
	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());
//.........这里部分代码省略.........

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 */
	
//.........这里部分代码省略.........

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
	}