1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "caltestlib.h"

    17 #include <calentry.h>

    18 #include <calentryview.h>

    19 #include <calalarm.h>

    20 #include <calcategory.h>

    21 #include <calinstance.h>

    22 #include <calinstanceview.h>

    23 #include <calrrule.h>

    24 #include <caliterator.h>

    25 #include <tz.h>

    26 #include <vtzrules.h>

    27 #include <e32test.h>

    28 #include <s32file.h>

    29 

    30 static RTest test(_L("tcal_entryattributes"));

    31 

    32 _LIT8(KGUID1, "A_Global_UID1");

    33 _LIT8(KGUID2, "A_Global_UID2");

    34 _LIT8(KGUID3, "A_Global_UID3");

    35 _LIT8(KGUID4, "A_Global_UID4");

    36 _LIT8(KGUID5, "A_Global_UID5");

    37 _LIT(KCalName, "TestCalendar");

    38 

    39 _LIT(KSummary1, "dummy summary text");

    40 _LIT(KDescription1, "dummy description text");

    41 

    42 class CEntryAttributesTestManager : public CBase

    43 	{

    44 public:

    45 	static CEntryAttributesTestManager* NewLC();

    46 	~CEntryAttributesTestManager();

    47 

    48 	void CreateEntriesL(TBool aFloating = EFalse);

    49 	void TestFetchAndDeleteNonExistentEntryL();

    50 	void TestLiteEntriesL();

    51 	void TestLastChangedDateL();

    52 	void TestLastChangedDateWithStoreL();

    53 	void StoreLastChangedDatesL();

    54 	void CheckForValuesL(TBool aFlip);

    55 	void UpdateEntriesL();

    56 	void TestCopySummaryAndDescriptionL();

    57 	void TestAlarmedCompletedTodoL();

    58 	void FindSummaryL();

    59 	void TestEndTimeBeforeStartTimeL();

    60 	void TestEndTimeNullL();

    61 	void TestEndTimeForeverL();

    62 	void TestAlarmedTodoWithoutDueDateL();

    63 	void TestGEOAttributesL();

    64 	void TestGEOValueSetAndGetL();

    65 	void TestGEOEntrySetAndGetL();

    66 	void TestGEOVerifySetAndGetL(const TReal& aSetLat, const TReal& aSetLong, const TReal& aExpLat, const TReal& aExpLong, CCalGeoValue& aCalGeoValue) const;

    67 	void TestGEOInternalizeAndExternalizeL();

    68 	void TestGEOCompareAndCopyFromL();

    69 	void UpdateEntryHaveRdateOnlyL();

    70 	void TestStartDateTestL();

    71 	void TestStoreEntryWithTzL();

    72 	void TestRdateL();

    73 	void TestDeleteInstancesL(TInt aLoop=0);

    74 	void GetInstanceCrossDstL();

    75 	void FindInstancesL(TInt aExpectedNumInstances);

    76 	// from former tcal_CopyEntryImpl

    77 	

    78 	void CreateEntriesForCopyL();

    79 	void CreateEventForCopyPasteL();

    80 	

    81 	// for DEF080249: Addition of additional child entry with repeat rule should fail

    82 	void AddTwoRepeatingChildL();

    83 	

    84 	void StoreAndExportL();

    85 

    86 private:

    87 

    88 	CEntryAttributesTestManager();

    89 	void TestEndTimeNullL(CCalEntry::TType aType);

    90 

    91 	// no copy constructor and assignment operator

    92 	CEntryAttributesTestManager(CEntryAttributesTestManager& );

    93 	CEntryAttributesTestManager& operator = (const CEntryAttributesTestManager& );

    94 

    95 	void ConstructL();

    96 	void TestCalEntryL(CCalEntry* aEntry, TBool aFloating = EFalse);

    97 	void TestThisLiteEntryL(CCalEntry* aEntry);

    98 	

    99 	// from former tcal_CopyEntryImpl

   100 	

   101 	void CopyEventForCopyPasteL(const CCalEntry& aEntry);

   102 	void CopyEntryL(const CCalEntry& aEntry);

   103 

   104 

   105 private:

   106 	CCalTestLibrary* iTestLib;

   107 	CArrayFix<TTime>* iDateArray;

   108 	};

   109 

   110 

   111 // Constructor/Destructor

   112 

   113 CEntryAttributesTestManager* CEntryAttributesTestManager::NewLC()

   114 	{

   115 	CEntryAttributesTestManager* self = new (ELeave) CEntryAttributesTestManager();

   116 	

   117 	CleanupStack::PushL(self);

   118 	self->ConstructL();

   119 	

   120 	return (self);

   121 	}

   122 

   123 CEntryAttributesTestManager::CEntryAttributesTestManager()

   124 	{

   125 	}

   126 

   127 void CEntryAttributesTestManager::ConstructL()

   128 	{

   129 	iDateArray = new(ELeave) CArrayFixFlat<TTime>(5);

   130 	

   131 	iTestLib = CCalTestLibrary::NewL(EFalse);

   132 	

   133 	iTestLib->ReplaceFileL(KCalName());

   134 	iTestLib->OpenFileL(KCalName());

   135 	}

   136 

   137 	

   138 CEntryAttributesTestManager::~CEntryAttributesTestManager()

   139 	{

   140 	TRAP_IGNORE(iTestLib->DeleteFileL(KCalName));

   141 	delete iDateArray;

   142 	delete iTestLib;

   143 	}

   144 

   145 

   146 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

   147  * Test cases forming the Entry Attributes test suite

   148  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

   149 void CEntryAttributesTestManager::TestDeleteInstancesL(TInt aLoop)

   150 	{

   151 	test.Printf(_L("Test TestDeleteInstancesL started\n"));

   152 

   153 	

   154 	_LIT8(KRnzLine1, "BEGIN:VCALENDAR\r\n"

   155 					 "VERSION:1.0\r\n"

   156 					 "TZ:+00\r\n"

   157 					 "DAYLIGHT:TRUE;+01;20010325T010000Z;20011028T010000Z;;\r\n"

   158 					 "DAYLIGHT:TRUE;+01;20070325T010000Z;20071028T010000Z;;\r\n"

   159 					 "DAYLIGHT:TRUE;+01;20080330T010000Z;20081026T010000Z;;\r\n"

   160 					 "DAYLIGHT:TRUE;+01;20090329T010000Z;20091025T010000Z;;\r\n"

   161 					 "DAYLIGHT:TRUE;+01;20100328T010000Z;20101031T010000Z;;\r\n"

   162 					 "DAYLIGHT:TRUE;+01;20110327T010000Z;20111030T010000Z;;\r\n"

   163 					 "BEGIN:VEVENT\r\n"

   164 					 "UID:5\r\n"

   165 					 "DUE:19990416T230000Z\r\n"

   166 					 "DTSTART:20010925T170000Z\r\n"

   167 					 "DTEND:20010925T170000Z\r\n"

   168 					 "X-EPOCAGENDAENTRYTYPE:ANNIVERSARY\r\n"

   169 					 "CLASS:PUBLIC\r\n"

   170 					 "SEQUENCE:0\r\n"

   171 					 "X-METHOD:ADD\r\n"

   172 					 "RRULE:YM1 9 #2\r\n"

   173 					 "END:VEVENT\r\n"

   174 					 "END:VCALENDAR\r\n");	

   175 	

   176 	RPointerArray<CCalEntry> importedEntryArr;

   177 	CleanupResetAndDestroyPushL(importedEntryArr);

   178 

   179 	iTestLib->ImportL(KRnzLine1, importedEntryArr);

   180 	test.Printf(_L("File imported\n"));

   181 	

   182 	// store in the cal file

   183 	TInt success = 0;

   184 	iTestLib->SynCGetEntryViewL().StoreL(importedEntryArr, success);

   185 	test(success == 1);

   186 	

   187 	CleanupStack::PopAndDestroy(&importedEntryArr);

   188 	

   189 	

   190 	// fetch instances

   191 	TTime		startDate(TDateTime(2000, EJanuary, 0, 12, 0, 0, 0));

   192 	TCalTime	start;

   193 	start.SetTimeUtcL(startDate);

   194 		

   195 	TTime		endDate(TDateTime(2098, EJanuary, 0, 12, 0, 0, 0));

   196 	TCalTime	end;

   197 	end.SetTimeUtcL(endDate);

   198 

   199 	CalCommon::TCalTimeRange	timeRange(start, end);

   200 	CalCommon::TCalViewFilter	filter=CalCommon::EIncludeAll;

   201 	RPointerArray<CCalInstance> fetchedInstanceArr;

   202 	CleanupClosePushL(fetchedInstanceArr);	

   203 	iTestLib->SynCGetInstanceViewL().FindInstanceL(fetchedInstanceArr, filter, timeRange);

   204 	TInt countInstances=fetchedInstanceArr.Count();

   205 	

   206 	// try to delete one-by-one

   207 

   208 	if( aLoop==0 )

   209 		{

   210 		// one way to do it

   211 		for(TInt i=countInstances-1;i>=0;i--)

   212 			{

   213 			iTestLib->SynCGetInstanceViewL().DeleteL(fetchedInstanceArr[i], CalCommon::EThisAndFuture); 

   214 			}

   215 		test.Printf(_L("TestDeleteInstances1 Finished\n"));

   216 		}

   217 	else

   218 		{

   219 		// another way to delete instaces

   220 		for(TInt i=0;i<countInstances; i++)

   221 			{

   222 			iTestLib->SynCGetInstanceViewL().DeleteL(fetchedInstanceArr[i], CalCommon::EThisAndPrior); 

   223 			}

   224 		// cleanup

   225 		test.Printf(_L("TestDeleteInstances2 Finished\n"));

   226 		}

   227 	CleanupStack::PopAndDestroy(&fetchedInstanceArr);

   228 }

   229 	

   230 /* Set and get each property on a CCalEntry and check the two match. */ 	

   231 

   232 

   233 void CEntryAttributesTestManager::TestCalEntryL(CCalEntry* aEntry, TBool aFloating)

   234 	{

   235 	TTime time1;

   236 	time1.HomeTime();

   237 	TTime time2(time1);

   238 	time2 += TTimeIntervalHours(2);

   239 	time2 += TTimeIntervalYears(1);

   240 	

   241 	TCalTime calTime1;

   242 	TCalTime calTime2;

   243 

   244 	if (aFloating)

   245 		{

   246 		calTime1.SetTimeLocalFloatingL(time1);

   247 		calTime2.SetTimeLocalFloatingL(time2);

   248 		}

   249 	else

   250 		{

   251 		calTime1.SetTimeUtcL(time1);

   252 		calTime2.SetTimeUtcL(time2);		

   253 		}

   254 	

   255 	aEntry->SetStartAndEndTimeL(calTime1, calTime2);

   256 

   257 	test.Next(_L("Start date"));

   258 

   259 	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

   260 		{

   261 		if (aFloating)

   262 			{

   263 			test(aEntry->StartTimeL().TimeLocalL().DaysFrom(time1).Int() == 0);

   264 			}

   265 		else

   266 			{

   267 			test(aEntry->StartTimeL().TimeUtcL().DaysFrom(time1).Int() == 0);

   268 			}

   269 		}

   270 	else

   271 		{

   272 		if (aFloating)

   273 			{

   274 			test(aEntry->StartTimeL().TimeLocalL() == time1);

   275 			}

   276 		else

   277 			{

   278 			test(aEntry->StartTimeL().TimeUtcL() == time1);

   279 			}

   280 		}

   281 

   282 	if (aEntry->EntryTypeL() == CCalEntry::EReminder)

   283 		{

   284 	

   285 		test.Next(_L("End date"));

   286 

   287 		if (aFloating)

   288 			{

   289 			test(aEntry->EndTimeL().TimeLocalL() == Time::NullTTime());	

   290 			}

   291 		else

   292 			{

   293 			test(aEntry->EndTimeL().TimeUtcL() == Time::NullTTime());

   294 			}

   295 		}

   296 	else 

   297 		{

   298 

   299 		test.Next(_L("End date"));

   300 

   301 		if (aFloating)

   302 			{

   303 			test(aEntry->EndTimeL().TimeLocalL() == time2);

   304 			}

   305 		else

   306 			{

   307 			test(aEntry->EndTimeL().TimeUtcL() == time2);

   308 			}

   309 		}

   310 

   311 	if (aFloating)

   312 		{

   313 

   314 		test.Next(_L("time mode"));

   315 

   316 		test(aEntry->StartTimeL().TimeMode() == TCalTime::EFloating);

   317 

   318 		if (aEntry->EntryTypeL() != CCalEntry::EReminder)

   319 			{

   320 			test(aEntry->EndTimeL().TimeMode() == TCalTime::EFloating);

   321 			}

   322 		}

   323 

   324 

   325 	test.Next(_L("alarm setting"));

   326 

   327 	CCalAlarm* alarm = aEntry->AlarmL();

   328 	test(alarm == NULL);

   329 	TTime time4(time1);

   330 	time4 += TTimeIntervalHours(5);

   331 	

   332 	alarm = CCalAlarm::NewL();

   333 	

   334 	const TInt KAlarmOffset(600);

   335 	alarm->SetTimeOffset(KAlarmOffset);

   336 	alarm->SetAlarmSoundNameL(KNullDesC());

   337 	aEntry->SetAlarmL(alarm);

   338 	delete alarm;

   339 	alarm = NULL;

   340 	TTimeIntervalHours hours2(0);

   341 	alarm = aEntry->AlarmL();

   342 	test(alarm->TimeOffset().Int() == KAlarmOffset);

   343 	test(alarm->AlarmSoundNameL().Length() == 0);

   344 	alarm->SetAlarmSoundNameL(_L("dummy"));

   345 	test(alarm->AlarmSoundNameL().Compare(_L("dummy")) == 0);

   346 	delete alarm;

   347 	alarm = NULL;

   348 	aEntry->SetAlarmL(NULL);

   349 	test(aEntry->AlarmL() == NULL);

   350 	

   351 	const TInt KHugeAlarmOffset(600000);

   352 	alarm = CCalAlarm::NewL();

   353 	alarm->SetTimeOffset(KHugeAlarmOffset);

   354 	aEntry->SetAlarmL(alarm);

   355 	delete alarm;

   356 	alarm = NULL;

   357 	alarm = aEntry->AlarmL();

   358 	test(alarm->TimeOffset().Int() == KHugeAlarmOffset);

   359 	delete alarm;

   360 	

   361 	TTime time5(time1);

   362 	time5 += TTimeIntervalHours(2);

   363 	time5 += TTimeIntervalDays(5);

   364 

   365 	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

   366 		{

   367 

   368 		test.Next(_L("status"));

   369 

   370 		aEntry->SetStatusL(CCalEntry::ETodoNeedsAction);

   371 		test(aEntry->StatusL() == CCalEntry::ETodoNeedsAction);

   372 		aEntry->SetStatusL(CCalEntry::ETodoInProcess);

   373 		test(aEntry->StatusL() == CCalEntry::ETodoInProcess);

   374 

   375 		test.Next(_L("complete date"));

   376 

   377 		TCalTime completedCalTime;

   378 		completedCalTime.SetTimeUtcL(time5);

   379 		aEntry->SetCompletedL(ETrue, completedCalTime);

   380 		test(aEntry->StatusL() == CCalEntry::ETodoCompleted);

   381 		test(aEntry->CompletedTimeL().TimeUtcL() == time5);

   382 		aEntry->SetCompletedL(EFalse, completedCalTime);

   383 		test(aEntry->StatusL() != CCalEntry::ETodoCompleted);

   384 		}

   385 	else 

   386 		{

   387 

   388 		test.Next(_L("status"));

   389 

   390 		aEntry->SetStatusL(CCalEntry::EConfirmed);

   391 		test(aEntry->StatusL() == CCalEntry::EConfirmed);

   392 		aEntry->SetStatusL(CCalEntry::ETentative);

   393 		test(aEntry->StatusL() == CCalEntry::ETentative);

   394 		}

   395 		

   396 	test.Next(_L("priority"));

   397 

   398 	aEntry->SetPriorityL(5);

   399 	test(aEntry->PriorityL() == 5);

   400 	aEntry->SetPriorityL(9);

   401 	test(aEntry->PriorityL() == 9);

   402 	

   403 	test.Next(_L("summary"));

   404 

   405 	TBuf<32> buf1;

   406 	buf1.Copy(KSummary1);

   407 	aEntry->SetSummaryL(buf1);

   408 	test(aEntry->SummaryL().Compare(buf1) == 0);

   409 	

   410 	test.Next(_L("Description"));

   411 

   412 	TBuf<32> buf2;

   413 	buf2.Copy(KDescription1);

   414 	aEntry->SetDescriptionL(buf2);

   415 	test(aEntry->DescriptionL().Compare(buf2) == 0);

   416 

   417 	test.Next(_L("Location"));

   418 

   419 	TBuf<32> buf3;

   420 	buf3.Copy(_L("dummy Location text"));

   421 	aEntry->SetLocationL(buf3);

   422 	test(aEntry->LocationL().Compare(buf3) == 0);

   423 

   424 	test.Next(_L("Category"));

   425 

   426 	const RPointerArray<CCalCategory> categoryList = aEntry->CategoryListL();

   427 	test(categoryList.Count() == 0);

   428 	TBuf<32> buf4;

   429 	buf4.Copy(_L("dummy Category text"));

   430 	

   431 	CCalCategory* category = CCalCategory::NewL(buf4);

   432 	CleanupStack::PushL(category);

   433 	aEntry->AddCategoryL(category);

   434 	CleanupStack::Pop(category);

   435 	const RPointerArray<CCalCategory> categoryList1 = aEntry->CategoryListL();

   436 	test(categoryList1.Count() == 1);

   437 	test(categoryList1[0]->ExtendedCategoryName().Compare(buf4) == 0);

   438 		

   439 	test.Next(_L("DTSTAMP"));

   440 

   441 	TTime now;

   442 	now.UniversalTime();

   443 	TCalTime dTStampTime;

   444 	dTStampTime.SetTimeUtcL(now);

   445 	aEntry->SetDTStampL(dTStampTime);

   446 	test(dTStampTime.TimeUtcL() == aEntry->DTStampL().TimeUtcL());

   447 	

   448 	// copy this entry

   449 

   450 	test.Next(_L("entry copying"));

   451 

   452 	HBufC8* uid = aEntry->UidL().AllocLC();

   453 	CCalEntry* entryCopy = CCalEntry::NewL(aEntry->EntryTypeL(), uid, aEntry->MethodL(), 

   454 		aEntry->SequenceNumberL(), aEntry->RecurrenceIdL(), aEntry->RecurrenceRangeL());

   455 	CleanupStack::Pop(uid);

   456 	CleanupStack::PushL(entryCopy);

   457 	entryCopy->CopyFromL(*aEntry);

   458 	test(entryCopy->CompareL(*aEntry));

   459 

   460 	CleanupStack::PopAndDestroy(entryCopy);

   461 

   462 	test.Next(_L("last modified date"));

   463 

   464 	now.UniversalTime();

   465 	aEntry->SetLastModifiedDateL();

   466 	TTimeIntervalSeconds secs;

   467 	aEntry->LastModifiedDateL().TimeUtcL().SecondsFrom(now, secs);

   468 	test(secs.Int() < 2);

   469 	

   470 	test.Next(_L("method"));

   471 

   472 		{

   473 		// positive testing	

   474 		

   475 		aEntry->SetMethodL(CCalEntry::EMethodAdd);

   476 		test(aEntry->MethodL() == CCalEntry::EMethodAdd);

   477 		aEntry->SetMethodL(CCalEntry::EMethodCancel);

   478 		test(aEntry->MethodL() == CCalEntry::EMethodCancel);

   479 		aEntry->SetMethodL(CCalEntry::EMethodNone);

   480 		test(aEntry->MethodL() == CCalEntry::EMethodNone);	

   481 		aEntry->SetMethodL(CCalEntry::EMethodPublish);

   482 		test(aEntry->MethodL() == CCalEntry::EMethodPublish);

   483 		aEntry->SetMethodL(CCalEntry::EMethodRequest);

   484 		test(aEntry->MethodL() == CCalEntry::EMethodRequest);

   485 		aEntry->SetMethodL(CCalEntry::EMethodReply);

   486 		test(aEntry->MethodL() == CCalEntry::EMethodReply);

   487 		aEntry->SetMethodL(CCalEntry::EMethodRefresh);

   488 		test(aEntry->MethodL() == CCalEntry::EMethodRefresh);

   489 		aEntry->SetMethodL(CCalEntry::EMethodCounter);

   490 		test(aEntry->MethodL() == CCalEntry::EMethodCounter);

   491 		aEntry->SetMethodL(CCalEntry::EMethodDeclineCounter);

   492 		test(aEntry->MethodL() == CCalEntry::EMethodDeclineCounter);

   493 		

   494 		// negative testing	

   495 		

   496 		TRAPD(err1, aEntry->SetMethodL(CCalEntry::TMethod(CCalEntry::EMethodNone-1)) );

   497 		test(err1 == KErrArgument);

   498 

   499 		TRAPD(err2, aEntry->SetMethodL(CCalEntry::TMethod(CCalEntry::EMethodDeclineCounter+1)) );

   500 		test(err2 == KErrArgument);

   501 		}	

   502 

   503 		test.Next(_L("sequence number"));

   504 

   505 		{

   506 		aEntry->SetSequenceNumberL(1);

   507 		test(aEntry->SequenceNumberL() == 1);

   508 		}	

   509 	

   510 	test.Next(_L("replication status"));

   511 

   512 		{

   513 		// positive testing

   514 		

   515 		aEntry->SetReplicationStatusL(CCalEntry::EOpen);

   516 		test(aEntry->ReplicationStatusL() == CCalEntry::EOpen);

   517 		aEntry->SetReplicationStatusL(CCalEntry::EPrivate);

   518 		test(aEntry->ReplicationStatusL() == CCalEntry::EPrivate);

   519 		aEntry->SetReplicationStatusL(CCalEntry::ERestricted);

   520 		test(aEntry->ReplicationStatusL() == CCalEntry::ERestricted);

   521 		

   522 		// negative testing	

   523 		

   524 		TRAPD(err1, aEntry->SetReplicationStatusL(CCalEntry::TReplicationStatus(CCalEntry::EOpen-1)) );

   525 		test(err1 == KErrArgument);

   526 		TRAPD(err2, aEntry->SetReplicationStatusL(CCalEntry::TReplicationStatus(CCalEntry::ERestricted+1)) );

   527 		test(err2 == KErrArgument);

   528 		}

   529 

   530 		test.Next(_L("transparency"));

   531 

   532 		{

   533 		// positive testing	

   534 		

   535 		aEntry->SetTimeTransparencyL(CCalEntry::ETranspTentative);

   536 		test(aEntry->TimeTransparencyL() == CCalEntry::ETranspTentative);

   537 		aEntry->SetTimeTransparencyL(CCalEntry::ETranspBusy);

   538 		test(aEntry->TimeTransparencyL() == CCalEntry::ETranspBusy);

   539 		aEntry->SetTimeTransparencyL(CCalEntry::ETranspFree);

   540 		test(aEntry->TimeTransparencyL() == CCalEntry::ETranspFree);

   541 		aEntry->SetTimeTransparencyL(CCalEntry::ETranspOutOfOffice);

   542 		test(aEntry->TimeTransparencyL() == CCalEntry::ETranspOutOfOffice);	

   543 

   544 		// negative testing	

   545 

   546 		TRAPD(err1, aEntry->SetTimeTransparencyL(CCalEntry::TTransp(-1)) );

   547 		test(err1 == KErrArgument);	

   548 		}	

   549 		

   550 	// .. other properties?

   551 	}

   552 	

   553 	

   554 

   555 

   556 void CEntryAttributesTestManager::TestThisLiteEntryL(CCalEntry* aEntry)

   557 	{

   558 /* Get properties on a CCalEntry (set as a lite entry) then compare with getting properties from the full entry. */

   559 

   560 	test.Next(_L("Testing lite entry"));

   561 	

   562 	test.Next(_L("Start date"));

   563 

   564 	TTime time1	= aEntry->StartTimeL().TimeUtcL();

   565 	

   566 	test.Next(_L("End date"));

   567 

   568 	TTime time2 = aEntry->EndTimeL().TimeUtcL();

   569 		

   570 	test.Next(_L("priority"));

   571 

   572 	TInt priority = aEntry->PriorityL();

   573 

   574 	TTime time3;

   575 

   576 	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

   577 		{

   578 

   579 		test.Next(_L("complete date"));

   580 

   581 		time3 = aEntry->CompletedTimeL().TimeUtcL();

   582 		}

   583 	

   584 	// now use full aEntry and compare results

   585 	aEntry->SetStatusL(aEntry->StatusL());

   586 	

   587 	test.Next(_L("Testing full aEntry"));

   588 	

   589 	test.Next(_L("Start date"));

   590 

   591 	test(time1 == aEntry->StartTimeL().TimeUtcL());

   592 	

   593 	test.Next(_L("End date"));

   594 

   595 	TDateTime dt1 = time2.DateTime();

   596 	TDateTime dt2 = aEntry->EndTimeL().TimeUtcL().DateTime();

   597 	CCalEntry::TType type = aEntry->EntryTypeL();

   598 	test(time2 == aEntry->EndTimeL().TimeUtcL());

   599 

   600 	test.Next(_L("priority"));

   601 

   602 	test(priority == aEntry->PriorityL());

   603 

   604 	if (aEntry->EntryTypeL() == CCalEntry::ETodo)

   605 		{

   606 

   607 		test.Next(_L("complete date"));

   608 

   609 		test(time3 == aEntry->CompletedTimeL().TimeUtcL());

   610 		}

   611 	

   612 	test(aEntry->TimeTransparencyL() == CCalEntry::ETranspOutOfOffice);

   613 	}

   614 

   615 void CEntryAttributesTestManager::CreateEntriesL(TBool aFloating)

   616 	{

   617 	TTime time1;

   618 	time1.HomeTime();

   619 	TTime time2(time1);

   620 	time2 += TTimeIntervalHours(2);

   621 	time2 += TTimeIntervalMonths(30);

   622 	RPointerArray<CCalEntry> array;

   623 	CleanupResetAndDestroyPushL(array);

   624 	HBufC8* guid = KGUID1().AllocLC();

   625 	CCalEntry* entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0);

   626 	CleanupStack::Pop(guid);

   627 	CleanupStack::PushL(entry);

   628 	TCalTime calTime1;

   629 	TCalTime calTime2;

   630 

   631 	if (aFloating)

   632 		{

   633 		calTime1.SetTimeLocalFloatingL(time1);

   634 		calTime2.SetTimeLocalFloatingL(time2);

   635 		}

   636 	else

   637 		{

   638 		calTime1.SetTimeUtcL(time1);

   639 		calTime2.SetTimeUtcL(time2);

   640 		}

   641 

   642 	entry->SetStartAndEndTimeL(calTime1, calTime2);

   643 	TestCalEntryL(entry, aFloating);

   644 	array.AppendL(entry);

   645 	CleanupStack::Pop(entry);

   646 	

   647 	TInt success(0);

   648 	

   649 	iTestLib->SynCGetEntryViewL().StoreL(array, success);

   650 	//Test storing an entry array twice and make sure it doesn't leave

   651 	test.Next(_L("Storing an entry array twice"));

   652 

   653 	iTestLib->SynCGetEntryViewL().StoreL(array, success);

   654 	delete entry;

   655 	entry = NULL;

   656 

   657 	array.Reset();

   658 	guid = KGUID2().AllocLC();

   659 	entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);

   660 	CleanupStack::Pop(guid);

   661 	CleanupStack::PushL(entry);

   662 	entry->SetStartAndEndTimeL(calTime1, calTime2);

   663 	TestCalEntryL(entry, aFloating);

   664 	

   665 	array.AppendL(entry);

   666 	CleanupStack::Pop(entry);

   667 	iTestLib->SynCGetEntryViewL().StoreL(array, success);

   668 	delete entry;

   669 	entry = NULL;

   670 	array.Reset();

   671 	

   672 	guid = KGUID3().AllocLC();

   673 	entry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0);

   674 	CleanupStack::Pop(guid);

   675 	CleanupStack::PushL(entry);

   676 	entry->SetStartAndEndTimeL(calTime1, calTime2);

   677 	TestCalEntryL(entry, aFloating);

   678 	

   679 	array.AppendL(entry);

   680 	CleanupStack::Pop(entry);

   681 	iTestLib->SynCGetEntryViewL().StoreL(array, success);

   682 	delete entry;

   683 	entry = NULL;

   684 	array.Reset();

   685 	

   686 	guid = KGUID4().AllocLC();

   687 	entry = CCalEntry::NewL(CCalEntry::EAnniv, guid, CCalEntry::EMethodNone, 0);

   688 	CleanupStack::Pop(guid);

   689 	CleanupStack::PushL(entry);

   690 	entry->SetStartAndEndTimeL(calTime1, calTime2);

   691 	TestCalEntryL(entry, aFloating);

   692 	

   693 	array.AppendL(entry);

   694 	CleanupStack::Pop(entry);

   695 	iTestLib->SynCGetEntryViewL().StoreL(array, success);

   696 	delete entry;

   697 	entry = NULL;

   698 	array.Reset();

   699 	

   700 	guid = KGUID5().AllocLC();

   701 	entry = CCalEntry::NewL(CCalEntry::EReminder, guid, CCalEntry::EMethodNone, 0);

   702 	CleanupStack::Pop(guid);

   703 	CleanupStack::PushL(entry);

   704 	entry->SetStartAndEndTimeL(calTime1, calTime2);

   705 	TestCalEntryL(entry, aFloating);

   706 	

   707 	array.AppendL(entry);

   708 	CleanupStack::Pop(entry);

   709 	iTestLib->SynCGetEntryViewL().StoreL(array, success);

   710 	delete entry;

   711 	entry = NULL;

   712 	array.Reset();

   713 	CleanupStack::Pop(&array);

   714 	}

   715 

   716 	

   717 void CEntryAttributesTestManager::TestLiteEntriesL()

   718 	{

   719 // retrieve lite entries from database and test them, including checking that full entries can be retrieved

   720 	RPointerArray<CCalInstance> array;

   721 	CleanupResetAndDestroyPushL(array);

   722 	

   723 	CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll;

   724 	TCalTime startDate;

   725 	startDate.SetTimeLocalL(TDateTime(2000, EJanuary, 0, 0, 0, 0, 0));

   726 	TCalTime endDate;

   727 	endDate.SetTimeLocalL(TDateTime(2010, EJanuary, 0, 0, 0, 0, 0));

   728 	

   729 	CalCommon::TCalTimeRange timeRange(startDate, endDate);

   730 	iTestLib->SynCGetInstanceViewL().FindInstanceL(array, filter, timeRange);

   731 	TInt i = 0;

   732 	while (i < array.Count())

   733 		{

   734 		TestThisLiteEntryL(&array[i]->Entry());

   735 		i++;

   736 		}

   737 		

   738 	CleanupStack::PopAndDestroy(&array);

   739 	}

   740 	

   741 

   742 void CEntryAttributesTestManager::StoreLastChangedDatesL()

   743 	{

   744 	test.Next(_L("Storing LastChangedDate before Modifying entries"));

   745 

   746 	

   747 	CCalIter& iter = iTestLib->GetIterL();

   748 	

   749 	for( TPtrC8 Uid(iter.FirstL()); Uid != KNullDesC8(); Uid.Set(iter.NextL()) )

   750 		{

   751 		RPointerArray<CCalEntry> entryList;

   752 		CleanupResetAndDestroyPushL(entryList);

   753 		

   754 		iTestLib->SynCGetEntryViewL().FetchL(Uid, entryList);

   755 		iDateArray->AppendL(entryList[0]->LastModifiedDateL().TimeUtcL());

   756 		

   757 		CleanupStack::PopAndDestroy(&entryList); 

   758 		}

   759 	}

   760 

   761 

   762 void CEntryAttributesTestManager::CheckForValuesL(TBool aFlip)

   763 	{

   764 	test.Next(_L("Checking entries"));

   765 

   766 	

   767 	CCalIter& iter = iTestLib->GetIterL();

   768 	

   769 	TInt i = 0;

   770 	for( TPtrC8 Uid(iter.FirstL()); Uid != KNullDesC8(); Uid.Set(iter.NextL()), ++i )

   771 		{

   772 		RPointerArray<CCalEntry> entryList;

   773 		CleanupResetAndDestroyPushL(entryList);

   774 		

   775 		iTestLib->SynCGetEntryViewL().FetchL(Uid, entryList);

   776 

   777 		TDateTime dt= iDateArray->At(i).DateTime();

   778 		test.Printf(_L("Initial Lastmodified date is  %d/%d/%d, %d:%d:%d\n"),dt.Day()+1, dt.Month()+1, dt.Year(), dt.Hour(), dt.Minute(), dt.Second());

   779 		dt= entryList[0]->LastModifiedDateL().TimeUtcL().DateTime();

   780 

   781 		if(aFlip) //while fetching last changed time should not be altered.

   782 		{

   783 			test(iDateArray->At(i) == entryList[0]->LastModifiedDateL().TimeUtcL());

   784 			test.Printf(_L("Fetching after 1 seconds   %d/%d/%d, %d:%d:%d\n\n"),dt.Day()+1, dt.Month()+1, dt.Year(), dt.Hour(), dt.Minute(), dt.Second());

   785 		}	

   786 		else	 //while Updating last changed time should be set to current time.

   787 		{

   788 			test(!(iDateArray->At(i) == entryList[0]->LastModifiedDateL().TimeUtcL()));	

   789 			test.Printf(_L("After Updating   %d/%d/%d, %d:%d:%d\n\n"),dt.Day()+1, dt.Month()+1, dt.Year(), dt.Hour(), dt.Minute(), dt.Second());

   790 		}

   791 		

   792 		CleanupStack::PopAndDestroy(&entryList);	

   793 		}

   794 	}

   795 

   796 

   797 void CEntryAttributesTestManager::UpdateEntriesL()

   798 	{

   799 	test.Next(_L("Updating entries so the LastChangedDate shud change"));

   800 

   801 	

   802 	CCalIter& iter = iTestLib->GetIterL();

   803 	

   804 	for( TPtrC8 Uid(iter.FirstL()); Uid != KNullDesC8(); Uid.Set(iter.NextL()) )

   805 		{

   806 		RPointerArray<CCalEntry> entryList;

   807 		CleanupResetAndDestroyPushL(entryList);

   808 		iTestLib->SynCGetEntryViewL().FetchL(Uid, entryList);

   809 

   810 		TBuf<32> bufSummary;

   811 		bufSummary.Copy(_L("dummy summary text"));

   812 		entryList[0]->SetSummaryL(bufSummary);

   813 		TBuf<32> bufDescription;

   814 		bufDescription.Copy(_L("dummy description text"));

   815 		entryList[0]->SetDescriptionL(bufDescription);

   816 		TInt success=0;

   817 		iTestLib->SynCGetEntryViewL().UpdateL(entryList, success);

   818 		test(success==entryList.Count());

   819 		entryList.ResetAndDestroy();

   820 		iTestLib->SynCGetEntryViewL().FetchL(Uid, entryList);

   821 		test(entryList[0]->SummaryL()==bufSummary);

   822 		test(entryList[0]->DescriptionL()==bufDescription);

   823 		entryList[0]->SetSummaryL(KNullDesC);

   824 		entryList[0]->SetDescriptionL(KNullDesC);

   825 		iTestLib->SynCGetEntryViewL().UpdateL(entryList, success);

   826 		entryList.ResetAndDestroy();

   827 		iTestLib->SynCGetEntryViewL().FetchL(Uid, entryList);

   828 		test(entryList[0]->SummaryL()==KNullDesC);

   829 		test(entryList[0]->DescriptionL()==KNullDesC);

   830 		CleanupStack::PopAndDestroy(&entryList);	

   831 		}

   832 	}	

   833 	

   834 void CEntryAttributesTestManager::TestLastChangedDateL()

   835 	{

   836 	// check last modified date changes during an update:

   837 	StoreLastChangedDatesL();

   838 	CheckForValuesL(ETrue);

   839 

   840 	UpdateEntriesL();

   841 	CheckForValuesL(EFalse);	

   842 

   843 	// check last modified date changes during a StoreL on a parent (not allowed on a child)

   844 	TestLastChangedDateWithStoreL();

   845 	}

   846 

   847 void CEntryAttributesTestManager::TestLastChangedDateWithStoreL()

   848 	{

   849 	_LIT8(KGuid, "test StoreL with LastModifiedDateL");

   850 	HBufC8* guid = KGuid().AllocLC();

   851 	CCalEntry* parent = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);

   852 	CleanupStack::Pop(guid);

   853 	CleanupStack::PushL(parent);

   854 	

   855 	TTime time = TDateTime(2006, EJanuary, 0, 9, 0, 0, 0);

   856 	TCalTime dummyTime;

   857 	dummyTime.SetTimeLocalL(time); // 0900 on 1 Jan 06

   858 	parent->SetStartAndEndTimeL(dummyTime, dummyTime);

   859 	

   860 	const TTime KOriginalLastModTime = parent->LastModifiedDateL().TimeLocalL();

   861 	

   862 	iTestLib->StoreEntryL(*parent);	

   863 	CleanupStack::PopAndDestroy(parent);

   864 	

   865 	RPointerArray<CCalEntry> entries;

   866 	CleanupResetAndDestroyPushL(entries);

   867 	iTestLib->SynCGetEntryViewL().FetchL(KGuid, entries);

   868 	test(entries.Count() == 1);

   869 	parent = entries[0];

   870 	test(KOriginalLastModTime == parent->LastModifiedDateL().TimeLocalL());

   871 	

   872 	// wait a second so the last modified date will be different

   873 	User::After(1000000);

   874 	// update the parent

   875 	_LIT(KSummary, "zxcvbnm");

   876 	parent->SetSummaryL(KSummary);

   877 	iTestLib->StoreEntryL(*parent);

   878 	

   879 	entries.ResetAndDestroy();

   880 	

   881 	// get updated parent

   882 	iTestLib->SynCGetEntryViewL().FetchL(KGuid, entries);

   883 	test(entries.Count() == 1);

   884 	parent = entries[0];

   885 	test(KOriginalLastModTime < parent->LastModifiedDateL().TimeLocalL());

   886 	test(parent->LastModifiedDateL().TimeLocalL() < KOriginalLastModTime + TTimeIntervalSeconds(3));

   887 	

   888 	CleanupStack::PopAndDestroy(&entries);

   889 	}

   890 	

   891 void CEntryAttributesTestManager::TestCopySummaryAndDescriptionL()

   892 	{

   893 	CreateEntriesL(EFalse);

   894 	

   895 	RPointerArray<CCalEntry> entryList;

   896 	CleanupResetAndDestroyPushL(entryList);

   897 	RPointerArray<CCalEntry> entriesToStore;

   898 	CleanupResetAndDestroyPushL(entriesToStore);

   899 	

   900 	iTestLib->SynCGetEntryViewL().FetchL(KGUID1(), entryList);

   901 	_LIT8(KNewGuid, "zxcvbnm");

   902 	HBufC8* uid = KNewGuid().AllocLC();

   903 	CCalEntry* newEntry = CCalEntry::NewL(CCalEntry::ETodo, uid, CCalEntry::EMethodNone, 0);

   904 	CleanupStack::Pop(uid);

   905 	CleanupStack::PushL(newEntry);

   906 	newEntry->CopyFromL(*entryList[0], CCalEntry::EDontCopyId);

   907 	

   908 	entriesToStore.AppendL(newEntry);

   909 	CleanupStack::Pop(newEntry);

   910 

   911 	TInt success(0);

   912 	iTestLib->SynCGetEntryViewL().StoreL(entriesToStore, success);

   913 	test(success == 1);

   914 	

   915 	CDesC8Array* uidArray = new (ELeave) CDesC8ArrayFlat(1);

   916 	CleanupStack::PushL(uidArray);

   917 	uidArray->AppendL(KGUID1());

   918 	iTestLib->SynCGetEntryViewL().DeleteL(*uidArray);

   919 	CleanupStack::PopAndDestroy(uidArray);

   920 	

   921 	entryList.ResetAndDestroy();

   922 	iTestLib->SynCGetEntryViewL().FetchL(KNewGuid(), entryList);

   923 	test(entryList.Count() == 1);

   924 	

   925 	test(entryList[0]->SummaryL() == KSummary1());

   926 	test(entryList[0]->DescriptionL() == KDescription1());

   927 	CleanupStack::PopAndDestroy(); // entriesToStore

   928 	CleanupStack::PopAndDestroy(); // entryList

   929 	}

   930 

   931 void CEntryAttributesTestManager::TestAlarmedCompletedTodoL()

   932 	{

   933 	_LIT8(KGuid1, "guid-1");

   934 	

   935 	_LIT(KTime1, "20030127:020000.000000");

   936 	_LIT(KTime2, "20040127:020000.000000");

   937 		

   938 	HBufC8* guid = KGuid1().AllocLC();

   939 	CCalEntry* entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodAdd, (TUint)0);	

   940 	CleanupStack::Pop(guid);

   941 	CleanupStack::PushL(entry);

   942 	

   943 	TTime time1(KTime1());

   944 	TCalTime st;

   945 	st.SetTimeUtcL(time1);

   946 	entry->SetStartAndEndTimeL(st, st);

   947 	

   948 	TTime time2(KTime2());

   949 	TCalTime comp;

   950 	comp.SetTimeUtcL(time2);

   951 	entry->SetCompletedL(ETrue, comp);

   952 	

   953 	TTime compTime = entry->CompletedTimeL().TimeUtcL();

   954 	test(compTime == time2);

   955 	

   956 	CCalAlarm* alarm=CCalAlarm::NewL();

   957 	CleanupStack::PushL(alarm);

   958 	alarm->SetTimeOffset(20);

   959 	alarm->SetAlarmSoundNameL(_L("SHHH"));

   960 	entry->SetAlarmL(alarm);

   961 	CleanupStack::PopAndDestroy(alarm);

   962 	

   963 	CCalAlarm* alarm1 = entry->AlarmL();

   964 	test(alarm1 == NULL);

   965 			

   966 	iTestLib->StoreEntryL(*entry);

   967 	CleanupStack::PopAndDestroy(entry);

   968 	

   969 	// fetch the entry

   970 	RPointerArray<CCalEntry> entries;

   971 	CleanupResetAndDestroyPushL(entries);

   972 	iTestLib->SynCGetEntryViewL().FetchL(KGuid1, entries);

   973 	

   974 	entry = entries[0];

   975 	

   976 	TTime compTime2 = entry->CompletedTimeL().TimeUtcL();

   977 	test(compTime2 == time2);

   978 	

   979 	CCalAlarm* alarm2 = entry->AlarmL();

   980 	test(alarm2 == NULL);

   981 	CleanupStack::PopAndDestroy(&entries);

   982 	}

   983 

   984 // from former tcal_CopyEntryImpl

   985 

   986 void CEntryAttributesTestManager::CopyEntryL(const CCalEntry& aEntry)

   987 	{

   988 	HBufC8* guid = aEntry.UidL().AllocLC();

   989 	CCalEntry::TType type = aEntry.EntryTypeL();

   990     CCalEntry::TMethod method = aEntry.MethodL();

   991     TInt seqNumber = aEntry.SequenceNumberL();

   992     

   993     CCalEntry* entry = CCalEntry::NewL(type,guid,method,seqNumber);

   994     CleanupStack::Pop(guid);

   995     CleanupStack::PushL(entry);

   996     

   997 	const TDesC8& original_uid = aEntry.UidL();

   998 	const TDesC8& uid_before_copy = entry->UidL();

   999 	

  1000 	__ASSERT_ALWAYS(original_uid == uid_before_copy, User::Invariant());

  1001 	

  1002 	entry->CopyFromL(aEntry);

  1003 	

  1004 	const TDesC8& uid_after_copy = entry->UidL();

  1005 	

  1006 	__ASSERT_ALWAYS(original_uid == uid_after_copy, User::Invariant());

  1007    

  1008     CleanupStack::PopAndDestroy(entry);

  1009    	}

  1010    	

  1011 

  1012 void CEntryAttributesTestManager::CopyEventForCopyPasteL(const CCalEntry& aEntry)

  1013 	{

  1014     CCalEntry::TType type = aEntry.EntryTypeL();

  1015     CCalEntry::TMethod method = aEntry.MethodL();

  1016     TInt seqNumber = aEntry.SequenceNumberL();

  1017 	_LIT8(KGuid, "ABCDEFGHIJ");

  1018 	HBufC8* newUid = KGuid().AllocLC();

  1019     CCalEntry* entry = CCalEntry::NewL(type,newUid,method,seqNumber);

  1020     CleanupStack::Pop(newUid);

  1021     CleanupStack::PushL(entry);

  1022     TCalLocalUid newLocalUid(4);

  1023 	entry->SetLocalUidL(newLocalUid);

  1024 	entry->CopyFromL(aEntry ,CCalEntry::EDontCopyId);

  1025 	

  1026 	HBufC8* copyUid = entry->UidL().AllocLC();

  1027 

  1028 	const TDesC8& original_uid = aEntry.UidL();

  1029 	const TDesC8& uid_after_copy = entry->UidL();

  1030 	TCalLocalUid originalUniqueId = aEntry.LocalUidL();

  1031 	TCalLocalUid copiedUniqueId = entry->LocalUidL();

  1032 	

  1033 	__ASSERT_ALWAYS(originalUniqueId != copiedUniqueId, User::Invariant());

  1034 	__ASSERT_ALWAYS(original_uid != uid_after_copy, User::Invariant());

  1035    

  1036    	entry->CopyFromL(aEntry, CCalEntry::ECopyAll);

  1037 	

  1038 	const TDesC8& original_entry_uid = aEntry.UidL();

  1039 	const TDesC8& after_copy_uid = entry->UidL();

  1040 	copiedUniqueId = entry->LocalUidL();

  1041 	

  1042 	__ASSERT_ALWAYS(originalUniqueId == copiedUniqueId, User::Invariant());

  1043 	__ASSERT_ALWAYS(original_entry_uid == after_copy_uid, User::Invariant());

  1044    

  1045    	CleanupStack::PopAndDestroy(copyUid);

  1046    	CleanupStack::PopAndDestroy(entry);

  1047     }

  1048     

  1049 	

  1050 void CEntryAttributesTestManager::CreateEntriesForCopyL()

  1051 	{

  1052 	TTime time1;

  1053 	time1.HomeTime();

  1054 	TTime time2(time1);

  1055 	time2 += TTimeIntervalHours(2);

  1056 	time2 += TTimeIntervalMonths(30);

  1057 	

  1058 	HBufC8* guid = KGUID1().AllocLC();

  1059 	CCalEntry* entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0);

  1060 	CleanupStack::Pop(guid);

  1061 	CleanupStack::PushL(entry);

  1062 	

  1063 	TCalTime calTime1;

  1064 	calTime1.SetTimeUtcL(time1);

  1065 	TCalTime calTime2;

  1066 	calTime2.SetTimeUtcL(time2);

  1067 	entry->SetStartAndEndTimeL(calTime1, calTime2);

  1068 	

  1069 	CopyEntryL(*entry);

  1070 

  1071 	CleanupStack::PopAndDestroy(entry);

  1072 	}

  1073 	

  1074 

  1075 void CEntryAttributesTestManager::CreateEventForCopyPasteL()

  1076 	{

  1077 	TTime time1;

  1078 	time1.HomeTime();

  1079 	TTime time2(time1);

  1080 	time2 += TTimeIntervalHours(2);

  1081 	time2 += TTimeIntervalMonths(30);

  1082 	

  1083 	HBufC8* guid = KGUID1().AllocLC();

  1084 	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0);

  1085 	CleanupStack::Pop(guid);

  1086 	CleanupStack::PushL(entry);

  1087 	

  1088 	TCalTime calTime1;

  1089 	calTime1.SetTimeUtcL(time1);

  1090 	TCalTime calTime2;

  1091 	calTime2.SetTimeUtcL(time2);

  1092 	entry->SetStartAndEndTimeL(calTime1, calTime2);

  1093 	

  1094 	CopyEventForCopyPasteL(*entry);

  1095 	

  1096 	CleanupStack::PopAndDestroy(entry);

  1097 	}

  1098 

  1099 

  1100 void CEntryAttributesTestManager::FindSummaryL()

  1101 	{

  1102 	_LIT8(KGuid1, "guid-1");

  1103 	_LIT(KSummary1, "SAMPLE SUMMARY");

  1104 	_LIT(KTime1, "20020815:230000.000000");

  1105 	

  1106 	_LIT(KTimeFindSt, "20020715:230000.000000");

  1107 	_LIT(KTimeFindEnd, "20020915:230000.000000");

  1108 	

  1109 	HBufC8* guid8 = KGuid1().AllocLC();

  1110 	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EReminder, guid8, CCalEntry::EMethodAdd, (TUint)0);	

  1111 	CleanupStack::Pop(guid8);

  1112 	CleanupStack::PushL(entry);

  1113 	TTime time(KTime1());

  1114 	TCalTime st;

  1115 	st.SetTimeUtcL(time);

  1116 	

  1117 	entry->SetStartAndEndTimeL(st, st);

  1118 	entry->SetSummaryL(KSummary1);

  1119 	

  1120 	TInt						entriesStored(0);

  1121 	RPointerArray<CCalEntry>	entriesToStore;

  1122 	entriesToStore.AppendL(entry);

  1123 	TRAPD(err, iTestLib->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored));

  1124 	test(err == KErrNone);

  1125 	CleanupStack::PopAndDestroy(entry);

  1126 	entriesToStore.Reset();

  1127 	

  1128 	// added to test with a new session //

  1129 	delete iTestLib;

  1130 	iTestLib = NULL;

  1131 	iTestLib = CCalTestLibrary::NewL(EFalse);

  1132 	iTestLib->OpenFileL(KCalName());

  1133 	

  1134 	// testing if entry exists with new session //

  1135 	RPointerArray<CCalEntry>	entries;