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 

    18 #include <calentry.h>

    19 #include <calentryview.h>

    20 #include <calinstance.h>

    21 #include <calinstanceview.h>

    22 #include <calrrule.h>

    23 #include <calsession.h>

    24 #include <e32test.h>

    25 #include <vtzrules.h>

    26 #include <calalarm.h>

    27 #include <s32file.h>

    28 #include <caliterator.h>

    29 #include <caldataexchange.h>

    30 #include <caldataformat.h>

    31 

    32 RTest test(_L("tcal_tz"));

    33 

    34 _LIT(KCalendarFile, "tcal_tz");

    35 

    36 // Timezone constants

    37 

    38 _LIT8(KEuropeLondon, "Europe/London");

    39 _LIT8(KAsiaTokyo, "Asia/Tokyo");

    40 _LIT8(KAsiaTaiwan, "Asia/Taiwan");

    41 _LIT8(KAsiaBangkok, "Asia/Bangkok");

    42 _LIT8(KEuropeStockholm, "Europe/Stockholm");

    43 _LIT8(KEuropeHelsinki, "Europe/Helsinki");

    44 _LIT8(KUsNewYork, "America/New_York");

    45 _LIT8(KUsCentral, "US/Central");

    46 _LIT8(KUsLosAngeles, "US/LosAngeles");

    47 _LIT8(KEuropeTirane, "Europe/Tirane");

    48 _LIT8(KPacificHonolulu, "Pacific/Honolulu");

    49 

    50 // Watch out for confusion between this and

    51 // the custom rule we create that matches this zone.

    52 _LIT8(KPacificAuckland, "Pacific/Auckland");

    53 

    54 // Time constants

    55 

    56 const TDateTime KTokyoEntryTime(2005,EMarch,6,2,45,15,0);

    57 const TDateTime KExpectedTokyoEntryTime(2005,EMarch,7,2,45,15,0);

    58 

    59 

    60 class CTzTestManager : public CActive

    61 	{

    62 public:

    63 	static CTzTestManager* NewLC();

    64 	~CTzTestManager();

    65 

    66 	void Start();

    67 

    68 private:

    69 	CTzTestManager();

    70 	void ConstructL();

    71 	

    72 	void TestSetTimeZoneL(const TDesC8& aTimeZoneName);

    73 	void TestSetAndGetTzRulesL();

    74 	void TestRemoteRepeatL();

    75 	void TestRepeatRuleTzSetupL(TBool aFloating, TBool aException = EFalse, TBool aRDate = EFalse);

    76 	void TestRepeatRuleLocalTimeL();

    77 	void TestRepeatRuleTzStartEndTimeL();

    78 	void TestRepeatRuleTzStartEndTzRulesL();

    79 	void TestRepeatRuleTzRulesL();

    80 	void DefectTestL();

    81 	void TestRDatesTzSetupL();

    82 	void TestFloatingEntrySetupL(); // Create a floating entry in calendar

    83 	void TestFloatingEntryCheckL(const TTime& aExpectedTime); // Check the previously stored floating entry

    84 	void TestFloatingRepeatCheckL(); // Check the previously stored floating repeating entry

    85 	void TestFloatingExceptionCheckL(); // Check the previously stored floating repeating entry with exception date

    86 	void TestFloatingRDateCheckL(); // Check the previously stored floating repeating entry with RDate

    87 

    88 	void TestForeignZoneRepeatRule1L();

    89 	void TestForeignZoneRepeatRule2L();

    90 	void TestLocalRepeatRuleL();

    91 	void TestLocalRepeatRule2L();

    92 	void TestLocalTimeZoneL();

    93 	

    94 	void TestAlarmTzUpdateSetupL();

    95 	void TestAlarmTzUpdateCheckL();

    96 	void SetupEventCrossingMidnightL();

    97 	void CheckEventCrossingMidnightL();

    98 	void CheckDSTThresholdL();

    99 	

   100 	void TestCopyRepeatRulesL();

   101 	void TestExportTzRulesInHemisphereL(TBool aSouthernHemisphere);

   102 	void ImportFloatingEntryL();

   103 	void TestTimeModeL();

   104 	void TestAlarmOffsetL();

   105 	void CheckVcalImportFromS40L();

   106 	void CheckUtcOffsetL(TCalTime& aTestLocalTime, TInt aExpectedOffset);

   107 

   108 	void CheckEntryInTimeZoneL(const TTime& aExpectedTime);

   109 	

   110 	void TestCreateEntryWithMidnightInHomeTimeL(TBool aFloating = EFalse);

   111 	void TestCreateEntryWithDstChangeL(TBool aFloating = EFalse);	

   112 	

   113 	// no copy constructor and assignment operator

   114 	CTzTestManager(CTzTestManager& );

   115 	CTzTestManager& operator = (const CTzTestManager& );

   116 

   117 	void CheckIsAnInstanceInTimeModeL(const TTime& aLocalTime, TBool aFound = ETrue, TCalTime::TTimeMode aTimeMode = TCalTime::EFixedTimeZone);

   118 	void CheckIsAnInstanceInSpecifiedZoneL(const TTime& aTime);

   119 	void VerifyRulesL(const CTzRules& aRules,const TCalTime& aStartRange, const TCalTime& aEndRange);

   120 

   121 	// from CActive

   122 	void RunL();

   123 	void DoCancel();

   124 

   125 private:

   126 	CCalTestLibrary*	iTestLibrary; // need a connection to a session to create a CCalEntry

   127 	CCalEntry*			iCalEntry;

   128 	TBuf8<256>			iCurrentTimeZone;

   129 	TInt 				iTestStep;

   130 	};

   131 

   132 

   133 // Constructor/Destructor

   134 CTzTestManager::CTzTestManager() : CActive(EPriorityLow)

   135 	{

   136 	CActiveScheduler::Add(this);

   137 	}

   138 

   139 CTzTestManager* CTzTestManager::NewLC()

   140 	{

   141 	CTzTestManager* self = new (ELeave) CTzTestManager;

   142 	

   143 	CleanupStack::PushL(self);

   144 	self->ConstructL();

   145 	

   146 	return (self);

   147 	}

   148 

   149 

   150 void CTzTestManager::ConstructL()

   151 	{

   152 	iTestLibrary = CCalTestLibrary::NewL();

   153 	

   154 	iTestLibrary->ReplaceFileL(KCalendarFile());

   155 	iTestLibrary->OpenFileL(KCalendarFile());

   156 

   157 	iTestLibrary->PIMTestServer().GetTimeZoneL(iCurrentTimeZone);

   158 	}

   159 	

   160 

   161 CTzTestManager::~CTzTestManager()

   162 	{

   163 	if (iTestLibrary && iCurrentTimeZone.Length())

   164 		{

   165 		TRAP_IGNORE(TestSetTimeZoneL(iCurrentTimeZone));

   166 		}

   167 		

   168 	delete iCalEntry;

   169 	delete iTestLibrary;

   170 	}

   171 

   172 void CTzTestManager::Start()

   173 	{

   174 	TRequestStatus* status = &iStatus;

   175 	User::RequestComplete(status, KErrNone);

   176 	if ( ! IsActive())

   177 		{

   178 		SetActive();

   179 		}

   180 	}

   181 

   182 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

   183  * Test cases forming the Time Zone test suite

   184  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

   185 

   186 

   187 void CTzTestManager::TestSetTimeZoneL(const TDesC8& aTimeZoneName)

   188 	{

   189 	iTestLibrary->SetTimeZoneL(aTimeZoneName);

   190 	}

   191 

   192 

   193 // TestRulesProvided: Creates a collection of TTzRule's and with it a CAgnTzZone. 

   194 // Then it tests the time conversion methods in CAgnTzZone.

   195 /** @SYMTestCaseID     PIM-TCAL-TZ-0002 */

   196 void CTzTestManager::TestSetAndGetTzRulesL()

   197 	{

   198 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0002 Running tcal_tz - TestSetAndGetTzRulesL")); 

   199 	HBufC8* dummy = NULL;

   200 	

   201 	delete iCalEntry;

   202 	iCalEntry = NULL;

   203 	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

   204 	

   205 	// Create arbitrary tz rule - add one hour between March 81 and October 96

   206 	TTzRule tRule1(1981,1996,0,60,EMarch,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

   207 	TTzRule tRule2(1981,1996,60,0,EOctober,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

   208 	TTzRule tRule3(0,KMaxTUint16,0,0,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,0);	

   209 	CTzRules* tzRules = CTzRules::NewL(2003,2007);

   210 	CleanupStack::PushL(tzRules); // PUSH

   211 	tzRules->AddRuleL(tRule1);

   212 	tzRules->AddRuleL(tRule2);

   213 	tzRules->AddRuleL(tRule3);	

   214 

   215 	// create weekly repeat rule every Tuesday from 1 May 05 to 1 Dec 05

   216 	TDateTime dtStart(2005,EMay,0,10,0,0,0);

   217 	TDateTime dtEnd(2005,EDecember,0,10,0,0,0);

   218 	TTime dtStart1(dtStart);

   219 	TTime dtEnd1(dtEnd);

   220 	TCalTime startCalTime;

   221 	TCalTime endCalTime;

   222 	tzRules->ConvertToUtcL(dtStart1);

   223 	startCalTime.SetTimeUtcL(dtStart1);

   224 	tzRules->ConvertToUtcL(dtEnd1);

   225 	startCalTime.SetTimeUtcL(dtEnd1);

   226 

   227 	iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

   228 	

   229 	TCalRRule calRule(TCalRRule::EWeekly);

   230 	calRule.SetDtStart(startCalTime);

   231 	calRule.SetUntil(endCalTime);

   232 	calRule.SetInterval(1);

   233 	RArray<TDay> days;

   234 	days.AppendL(ETuesday);

   235 	calRule.SetByDay(days);

   236 	iCalEntry->SetRRuleL(calRule);

   237 	days.Reset();

   238 

   239 	

   240 	iCalEntry->SetTzRulesL(*tzRules);

   241 	

   242 	CTzRules* tzRules2 = iCalEntry->TzRulesL();

   243 	CleanupStack::PushL(tzRules2);

   244 	

   245 	test(tzRules->Count() == tzRules2->Count());

   246 	

   247 	// Compare rules stored (tzRules) with rules retrieved (tzRules2)

   248 	TInt count = tzRules->Count();

   249 	TTzRule oneRule;

   250 	TTzRule anotherRule;

   251 	for (TInt i = 0; i < count; i++)

   252 		{

   253 		oneRule = (*tzRules)[i];

   254 		anotherRule = (*tzRules2)[i];

   255 		

   256 		test(oneRule.iFrom == anotherRule.iFrom);

   257 		test(oneRule.iTo == anotherRule.iTo);

   258 		test(oneRule.iOldLocalTimeOffset == anotherRule.iOldLocalTimeOffset);

   259 		test(oneRule.iNewLocalTimeOffset == anotherRule.iNewLocalTimeOffset);

   260 		test(oneRule.iMonth == anotherRule.iMonth);

   261 		test(oneRule.iDayRule == anotherRule.iDayRule);

   262 		test(oneRule.iDayOfMonth == anotherRule.iDayOfMonth);

   263 		test(oneRule.iDayOfWeek == anotherRule.iDayOfWeek);

   264 		test(oneRule.iTimeReference == anotherRule.iTimeReference);

   265 		test(oneRule.iTimeOfChange == anotherRule.iTimeOfChange);

   266 		}

   267 

   268 	CleanupStack::PopAndDestroy(tzRules2);

   269 	CleanupStack::PopAndDestroy(tzRules);

   270 	delete iCalEntry;

   271 	iCalEntry = NULL;

   272 	}

   273 

   274 	

   275 void CTzTestManager::CheckEntryInTimeZoneL(const TTime& aExpectedTime)

   276 	{

   277 	// Check that instance dates and times are properly converted to local times

   278 	TTime newTime = iCalEntry->StartTimeL().TimeLocalL();

   279 	test(newTime == aExpectedTime);

   280 	}

   281 

   282 

   283 // Tests that the start time of an entry changes correctly in different time zones

   284 // (using zone extracted from TZ server)

   285 /** @SYMTestCaseID     PIM-TCAL-TZ-0003 */

   286 void CTzTestManager::TestRemoteRepeatL()

   287 	{

   288 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0003 Running tcal_tz - TestRemoteRepeatL")); 	

   289 	HBufC8* dummy = NULL;

   290 	

   291 	delete iCalEntry;

   292 	iCalEntry = NULL;

   293 	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

   294 	

   295 	// create rule repeating every Monday from 7 Mar 05 to 7 Dec 05

   296 	TDateTime dtEnd(2005,EDecember,6,10,0,0,0);

   297 	TCalTime startCalTime;

   298 	TCalTime endCalTime;

   299 	// OK to use SetTimeLocal, since we are using SetTzRulesL();

   300 	startCalTime.SetTimeLocalL(KTokyoEntryTime);

   301 	endCalTime.SetTimeLocalL(dtEnd);

   302 

   303 	iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

   304 

   305 	TCalRRule calRule(TCalRRule::EWeekly);

   306 	calRule.SetDtStart(startCalTime);

   307 	calRule.SetUntil(endCalTime);

   308 	calRule.SetInterval(1);

   309 	RArray<TDay> days;

   310 	days.AppendL(EMonday);

   311 	calRule.SetByDay(days);

   312 	days.Reset();

   313 	

   314 	iCalEntry->SetRRuleL(calRule);	

   315 	iCalEntry->SetTzRulesL();

   316 	}

   317 

   318 

   319 /** @SYMTestCaseID     PIM-TCAL-TZ-0004 */

   320 void CTzTestManager::TestFloatingEntrySetupL()

   321 	{

   322 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0004 Running tcal_tz - TestFloatingEntrySetupL")); 

   323 	iTestLibrary->CleanDatabaseL();

   324 

   325 	delete iCalEntry;

   326 	iCalEntry = NULL;

   327 	

   328 	HBufC8* dummy = NULL;

   329 	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

   330 	

   331 	// create rule repeating every Tuesday from 7 Mar 05 to 7 Dec 05

   332 	TDateTime dtEnd(2005,EDecember,6,10,0,0,0);

   333 	TCalTime startCalTime;

   334 	TCalTime endCalTime;

   335 	startCalTime.SetTimeLocalFloatingL(KTokyoEntryTime);

   336 	endCalTime.SetTimeLocalFloatingL(dtEnd);

   337 	

   338 	iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

   339 	

   340 	RPointerArray<CCalEntry> entryArray;

   341 	CleanupClosePushL(entryArray);

   342 	

   343 	

   344 	entryArray.AppendL(iCalEntry);

   345 	TInt entriesAdded = 0;

   346 	iTestLibrary->SynCGetEntryViewL().StoreL(entryArray, entriesAdded);

   347 

   348 

   349 	CleanupStack::PopAndDestroy(&entryArray);	

   350 	}

   351 

   352 

   353 void CTzTestManager::TestFloatingEntryCheckL(const TTime& aExpectedTime)

   354 	{

   355 	RPointerArray<CCalEntry> entryArray;

   356 	CleanupResetAndDestroyPushL(entryArray);

   357 		

   358 

   359 	iTestLibrary->SynCGetEntryViewL().FetchL(iCalEntry->UidL(), entryArray);

   360 

   361 	// Check that entry dates and times are properly converted to local times

   362 	test(entryArray.Count() == 1);

   363 	TTime newTime = entryArray[0]->StartTimeL().TimeLocalL();

   364 	test(newTime == aExpectedTime);

   365 	

   366 	

   367 	CleanupStack::PopAndDestroy(&entryArray);

   368 	}

   369 

   370 

   371 /** @SYMTestCaseID     PIM-TCAL-TZ-0005 */

   372 void CTzTestManager::TestRepeatRuleTzSetupL(TBool aFloating, TBool aException, TBool aRDate)

   373 	{

   374 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0005 Running tcal_tz - TestRepeatRuleTzL")); 	

   375 	CCalEntryView& entryView = iTestLibrary->SynCGetEntryViewL();

   376 	if (aFloating)

   377 		{

   378 		entryView.DeleteL(*iCalEntry);

   379 		}

   380 		

   381 	delete iCalEntry;

   382 	iCalEntry = NULL;

   383 	HBufC8* dummy = NULL;

   384 	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

   385 	

   386 	TTime dtStart(TDateTime(2005, EJanuary, 0, 9, 0, 0, 0));

   387 	TTime dtEnd(TDateTime(2005, EDecember, 30, 9, 0, 0, 0));

   388 	TCalTime startCalTime;

   389 	TCalTime endCalTime;

   390 	

   391 	if (aFloating)

   392 		{

   393 		// Create a floating repeat entry in Auckland timezone

   394 		// create rule repeating every 2 days from 9am (local time)

   395 		startCalTime.SetTimeLocalFloatingL(dtStart);

   396 		endCalTime.SetTimeLocalFloatingL(dtEnd);

   397 		

   398 		TCalRRule rpt(TCalRRule::EDaily);

   399 		rpt.SetDtStart(startCalTime);

   400 		rpt.SetUntil(endCalTime);

   401 		rpt.SetInterval(2);

   402 

   403 		iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

   404 

   405 		// add the repeat rule and the timezone rules to the entry

   406 		iCalEntry->SetRRuleL(rpt);

   407 	

   408 		TRAPD(err, iCalEntry->SetTzRulesL());

   409 		test(err == KErrArgument);

   410 		}

   411 	else

   412 		{

   413 		// set time zone to Auckland, NZ

   414 		// DST ends on Sunday, 20 March 2005, 03:00 local daylight time 

   415 		// DST starts on Sunday, 2 October 2005, 02:00 local standard time

   416 		// create rule repeating every 2 days from 9am (NZ time)

   417 		

   418 		// fetch foreign rules from TZ server for Auckland

   419 		RTz tz;

   420 		User::LeaveIfError(tz.Connect());

   421 		CTzId* id = CTzId::NewL(KPacificAuckland);

   422 		CleanupStack::PushL(id);

   423 	

   424 		CTzRules* rules = tz.GetTimeZoneRulesL(*id, TDateTime(2000, EJanuary, 0, 0, 0, 0, 0), TDateTime(2010, EJanuary, 0, 0, 0, 0, 0), ETzUtcTimeReference);

   425 		CleanupStack::PopAndDestroy(id);

   426 		CleanupStack::PushL(rules);

   427 		

   428 		tz.Close();

   429 		

   430 		// convert to UTC for setting the calendar entry, because this is a foreign rule

   431 		rules->ConvertToUtcL(dtStart);

   432 		rules->ConvertToUtcL(dtEnd);

   433 		startCalTime.SetTimeUtcL(dtStart);

   434 		endCalTime.SetTimeUtcL(dtEnd);

   435 		

   436 		iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

   437 

   438 		// create repeat rule

   439 		TCalRRule rpt(TCalRRule::EDaily);

   440 		rpt.SetDtStart(startCalTime);

   441 		rpt.SetUntil(endCalTime);

   442 		rpt.SetInterval(2);

   443 

   444 		iCalEntry->SetRRuleL(rpt);

   445 			

   446 		iCalEntry->SetTzRulesL(*rules); // set tz rules to be local

   447 		

   448 		CleanupStack::PopAndDestroy(rules);

   449 		}

   450 

   451 	if (aException)

   452 		{

   453 		// Set 2 exceptions on the parent

   454 		

   455 		RArray<TCalTime> exArray;

   456 		CleanupClosePushL(exArray);		

   457 		

   458 		TCalTime exTime1;

   459 		exTime1.SetTimeLocalFloatingL(TDateTime(2005, EMarch, 23, 9, 0, 0, 0));	// March 24rd 9am

   460 		exArray.Append(exTime1);

   461 

   462 		TCalTime exTime2;

   463 		exTime2.SetTimeLocalFloatingL(TDateTime(2005, ESeptember, 29, 9, 0, 0, 0));	// September 30th 9am

   464 		exArray.Append(exTime2);

   465 

   466 		iCalEntry->SetExceptionDatesL(exArray);

   467 		

   468 		RArray<TCalTime> exArray2;

   469 		CleanupClosePushL(exArray2);

   470 		

   471 		iCalEntry->GetExceptionDatesL(exArray2);

   472 		test(exArray.Count() == exArray2.Count());

   473 		for (TInt i = 0; i < exArray.Count(); i++)

   474 			{

   475 			test(exArray[i].TimeMode() == exArray2[i].TimeMode());

   476 			test(exArray[i].TimeLocalL() == exArray2[i].TimeLocalL());

   477 			}

   478 			

   479 		CleanupStack::PopAndDestroy(); // reset exArray2

   480 		

   481 		CleanupStack::PopAndDestroy(); // reset exArray

   482 		}

   483 

   484 	if (aRDate)

   485 		{

   486 		// Set 2 sporadic dates on the parent

   487 

   488 		RArray<TCalTime> rDateArray;

   489 		CleanupClosePushL(rDateArray);

   490 

   491 		TCalTime rDate1;

   492 		rDate1.SetTimeLocalFloatingL(TDateTime(2004, EDecember, 2, 9, 0, 0, 0));

   493 		rDateArray.Append(rDate1);

   494 

   495 		TCalTime rDate2;

   496 		rDate2.SetTimeLocalFloatingL(TDateTime(2006, EMarch, 23, 9, 0, 0, 0));

   497 		rDateArray.Append(rDate2);

   498 		

   499 		iCalEntry->SetRDatesL(rDateArray);			

   500 		CleanupStack::PopAndDestroy(); // reset rDateArray

   501 		}

   502 	

   503 	RPointerArray<CCalEntry> entryArray;

   504 	CleanupClosePushL(entryArray);

   505 	

   506 	entryArray.AppendL(iCalEntry);

   507 	TInt entriesAdded = 0;

   508 	entryView.StoreL(entryArray, entriesAdded);

   509 	

   510 	CleanupStack::PopAndDestroy(&entryArray);

   511 	}

   512 

   513 

   514 /** @SYMTestCaseID     PIM-TCAL-TZ-0006 */

   515 void CTzTestManager::TestRepeatRuleLocalTimeL()

   516 	{

   517 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0006 Running tcal_tz - TestRepeatRuleLocalTimeL")); 

   518 	//

   519 	// Check instances are correct in local London time

   520 	//

   521 	

   522 	// Local time zone is London, Repeat Rule has TzRules

   523 	// similar to Pacific/Auckland.

   524 	// London DST starts on 

   525 	//  Sunday, 27 March 2005, 01:00 local daylight time 

   526 	// London DST ends on 

   527 	//  Sunday, 30 October 2005, 02:00 local standard time

   528 	

   529 	// Jan 1th 9am NZ time = Dec 31 8pm UK time

   530 	// NZ = UK+13 (NZ DST on, UK DST off)

   531 

   532 	TDateTime time1(2005, EMarch, 16, 20, 0, 0, 0);	// March 18th 9am NZ time = March 17th 8pm UK time

   533 													// NZ = UK+13 (NZ DST on, UK DST off)

   534 													

   535 	TDateTime time2(2005, EMarch, 22, 21, 0, 0, 0);	// March 24rd 9am NZ time = March 23nd 9pm UK time

   536 													// NZ = UK+12 (NZ DST off, UK DST off)

   537 													

   538 	TDateTime time3(2005, EMarch, 28, 22, 0, 0, 0);	// March 30th 9am NZ time = March 29th 10pm UK time

   539 													// NZ = UK+11 (NZ DST off, UK DST on)

   540 	

   541 	TDateTime time4(2005, ESeptember, 28, 22, 0, 0, 0);	// September 30th 9am NZ time = September 29th 10pm UK time

   542 														// NZ = UK+11 (NZ DST off, UK DST on)

   543 														

   544 	TDateTime time5(2005, EOctober, 12, 21, 0, 0, 0);	// October 14th 9am NZ time = October 13th 9pm UK time

   545 														// NZ = UK+12 (NZ DST on, UK DST on)

   546 														

   547 	TDateTime time6(2005, ENovember, 1, 20, 0, 0, 0);	// November 3rd 9am NZ time = November 2nd 8pm UK time

   548 														// NZ = UK+13 (NZ DST on, UK DST off)

   549 	

   550 	

   551 	CheckIsAnInstanceInTimeModeL(time1);

   552 	CheckIsAnInstanceInTimeModeL(time2);

   553 	CheckIsAnInstanceInTimeModeL(time3);

   554 	CheckIsAnInstanceInTimeModeL(time4);

   555 	CheckIsAnInstanceInTimeModeL(time5);

   556 	CheckIsAnInstanceInTimeModeL(time6);

   557 	}

   558 

   559 

   560 /** @SYMTestCaseID     PIM-TCAL-TZ-0007 */

   561 void CTzTestManager::TestRepeatRuleTzRulesL()

   562 	{

   563 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0007 Running tcal_tz - TestRepeatRuleTzRulesL")); 	

   564 	//

   565 	// Check instances are correct in entry's timezone

   566 	//

   567 	

   568 	// Local time zone is Europe/London, Repeat Rule has TzRules

   569 	// similar to Pacific/Auckland.

   570 	

   571 	TDateTime time1(2005, EMarch, 17, 9, 0, 0, 0);	// March 18th 9am NZ time = March 17th 8pm UK time

   572 													// NZ = UK+13 (NZ DST on, UK DST off)

   573 													

   574 	TDateTime time2(2005, EMarch, 23, 9, 0, 0, 0);	// March 24rd 9am NZ time = March 23nd 9pm UK time

   575 													// NZ = UK+12 (NZ DST off, UK DST off)

   576 													

   577 	TDateTime time3(2005, EMarch, 29, 9, 0, 0, 0);	// March 30th 9am NZ time = March 29th 10pm UK time

   578 													// NZ = UK+11 (NZ DST off, UK DST on)

   579 	

   580 	TDateTime time4(2005, ESeptember, 29, 9, 0, 0, 0);	// September 30th 9am NZ time = September 29th 10pm UK time

   581 														// NZ = UK+11 (NZ DST off, UK DST on)

   582 														

   583 	TDateTime time5(2005, EOctober, 13, 9, 0, 0, 0);	// October 14th 9am NZ time = October 13th 9pm UK time

   584 														// NZ = UK+12 (NZ DST on, UK DST on)

   585 														

   586 	TDateTime time6(2005, ENovember, 2, 9, 0, 0, 0);	// November 3rd 9am NZ time = November 2nd 8pm UK time

   587 														// NZ = UK+13 (NZ DST on, UK DST off)

   588 

   589 	CheckIsAnInstanceInSpecifiedZoneL(time1);

   590 	CheckIsAnInstanceInSpecifiedZoneL(time2);

   591 	CheckIsAnInstanceInSpecifiedZoneL(time3);

   592 	CheckIsAnInstanceInSpecifiedZoneL(time4);

   593 	CheckIsAnInstanceInSpecifiedZoneL(time5);

   594 	CheckIsAnInstanceInSpecifiedZoneL(time6);

   595 	}

   596 

   597 

   598 /** @SYMTestCaseID     PIM-TCAL-TZ-0008 */

   599 void CTzTestManager::TestRepeatRuleTzStartEndTimeL()

   600 	{

   601 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0008 Running tcal_tz - TestRepeatRuleTzStartEndTimeL")); 	

   602 	//

   603 	// Check start and end time 

   604 	// converted to local time (Asia/Tokyo).

   605 

   606 	// The start and end times were set to this 

   607 	// in Pacific/Auckland summer time:

   608 	TTime time(TDateTime(2005, EJanuary, 0, 9, 0, 0, 0));

   609 	

   610 	// Local time is now Asia/Tokyo (no DST rule)

   611 	time -= TTimeIntervalHours(13-9);

   612 

   613 	TDateTime dbgStartTime = iCalEntry->StartTimeL().TimeUtcL().DateTime();

   614 

   615 	TTime start = iCalEntry->StartTimeL().TimeLocalL();

   616 	test(time == start);

   617 

   618 	TTime end = iCalEntry->EndTimeL().TimeLocalL();

   619 	test(time == end);

   620 	}

   621 

   622 

   623 /** @SYMTestCaseID     PIM-TCAL-TZ-0009 */

   624 void CTzTestManager::TestRepeatRuleTzStartEndTzRulesL()

   625 	{

   626 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0009 Running tcal_tz - TestRepeatRuleTzStartEndTzRulesL")); 	

   627 	//

   628 	// Check start and end time 

   629 	// converted with entry's TzRules.

   630 

   631 	// The start and end times were set to this 

   632 	TTime time(TDateTime(2005, EJanuary, 0, 9, 0, 0, 0));

   633 	

   634 	CTzRules* rules = iCalEntry->TzRulesL();

   635 	CleanupStack::PushL(rules);

   636 

   637 	TTime start = iCalEntry->StartTimeL().TimeUtcL();

   638 	rules->ConvertToLocalL(start);

   639 	test(time == start);

   640 

   641 	TTime end = iCalEntry->EndTimeL().TimeUtcL();

   642 	rules->ConvertToLocalL(end);

   643 	test(time == end);

   644 	

   645 	CleanupStack::PopAndDestroy(rules);

   646 	}

   647 

   648 

   649 /** @SYMTestCaseID     PIM-TCAL-TZ-0010 */

   650 void CTzTestManager::TestFloatingRepeatCheckL()

   651 	{

   652 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0010 Running tcal_tz - TestFloatingRepeatCheckL")); 	

   653 	// changed time zone to London

   654 	// check instance are correct in local UK time, should be the same as Auckland time because entry time is floating

   655 	TDateTime time1(2005, EMarch, 17, 9, 0, 0, 0);	// March 18th 9am floating time 

   656 													

   657 	TDateTime time2(2005, EMarch, 23, 9, 0, 0, 0);	// March 24rd 9am floating time 

   658 													

   659 	TDateTime time3(2005, EMarch, 29, 9, 0, 0, 0);	// March 30th 9am floating time 

   660 	

   661 	TDateTime time4(2005, ESeptember, 29, 9, 0, 0, 0);	// September 30th 9am floating time 

   662 														

   663 	TDateTime time5(2005, EOctober, 13, 9, 0, 0, 0);	// October 14th 9am floating time 

   664 														

   665 	TDateTime time6(2005, ENovember, 2, 9, 0, 0, 0);	// November 3rd 9am floating time 

   666 	

   667 	CheckIsAnInstanceInTimeModeL(time1, ETrue, TCalTime::EFloating);

   668 	CheckIsAnInstanceInTimeModeL(time2, ETrue, TCalTime::EFloating);

   669 	CheckIsAnInstanceInTimeModeL(time3, ETrue, TCalTime::EFloating);

   670 	CheckIsAnInstanceInTimeModeL(time4, ETrue, TCalTime::EFloating);

   671 	CheckIsAnInstanceInTimeModeL(time5, ETrue, TCalTime::EFloating);

   672 	CheckIsAnInstanceInTimeModeL(time6, ETrue, TCalTime::EFloating);

   673 	}

   674 

   675 

   676 /** @SYMTestCaseID     PIM-TCAL-TZ-0011 */

   677 void CTzTestManager::TestFloatingExceptionCheckL()

   678 	{

   679 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0011 Running tcal_tz - TestFloatingExceptionCheckL")); 	

   680 	// changed time zone to London

   681 	// check instance are correct in local UK time, should be the same as Auckland time because entry time is floating

   682 	TDateTime time1(2005, EMarch, 17, 9, 0, 0, 0);	// March 18th 9am floating time 

   683 													

   684 	TDateTime time2(2005, EMarch, 23, 9, 0, 0, 0);	// March 24rd 9am floating time 

   685 													

   686 	TDateTime time3(2005, EMarch, 29, 9, 0, 0, 0);	// March 30th 9am floating time 

   687 	

   688 	TDateTime time4(2005, ESeptember, 29, 9, 0, 0, 0);	// September 30th 9am floating time 

   689 														

   690 	TDateTime time5(2005, EOctober, 13, 9, 0, 0, 0);	// October 14th 9am floating time 

   691 														

   692 	TDateTime time6(2005, ENovember, 2, 9, 0, 0, 0);	// November 3rd 9am floating time 

   693 

   694 	

   695 	CheckIsAnInstanceInTimeModeL(time1, ETrue, TCalTime::EFloating);

   696 	CheckIsAnInstanceInTimeModeL(time3, ETrue, TCalTime::EFloating);

   697 	CheckIsAnInstanceInTimeModeL(time5, ETrue, TCalTime::EFloating);

   698 	CheckIsAnInstanceInTimeModeL(time6, ETrue, TCalTime::EFloating);

   699 

   700 	CheckIsAnInstanceInTimeModeL(time2, EFalse, TCalTime::EFloating);

   701 	CheckIsAnInstanceInTimeModeL(time4, EFalse, TCalTime::EFloating);

   702 	}

   703 

   704 

   705 /** @SYMTestCaseID     PIM-TCAL-TZ-0012 */

   706 void CTzTestManager::TestFloatingRDateCheckL()

   707 	{

   708 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0012 Running tcal_tz - TestFloatingRDateCheckL")); 	

   709 	// changed time zone to London

   710 	// check instance are correct in local UK time, should be the same as Auckland time because entry time is floating

   711 	TDateTime time1(2005, EMarch, 17, 9, 0, 0, 0);	// March 18th 9am floating time 

   712 													

   713 	TDateTime time2(2005, EMarch, 23, 9, 0, 0, 0);	// March 24rd 9am floating time 

   714 													

   715 	TDateTime time3(2005, EMarch, 29, 9, 0, 0, 0);	// March 30th 9am floating time 

   716 	

   717 	TDateTime time4(2005, ESeptember, 29, 9, 0, 0, 0);	// September 30th 9am floating time 

   718 														

   719 	TDateTime time5(2005, EOctober, 13, 9, 0, 0, 0);	// October 14th 9am floating time 

   720 														

   721 	TDateTime time6(2005, ENovember, 2, 9, 0, 0, 0);	// November 3rd 9am floating time 

   722 

   723 	TDateTime time7(2004, EDecember, 2, 9, 0, 0, 0);  // rDate1

   724 

   725 	TDateTime time8(2006, EMarch, 23, 9, 0, 0, 0); // rDate2

   726 	

   727 	CheckIsAnInstanceInTimeModeL(time1, ETrue, TCalTime::EFloating);

   728 	CheckIsAnInstanceInTimeModeL(time2, ETrue, TCalTime::EFloating);

   729 	CheckIsAnInstanceInTimeModeL(time3, ETrue, TCalTime::EFloating);

   730 	CheckIsAnInstanceInTimeModeL(time4, ETrue, TCalTime::EFloating);

   731 	CheckIsAnInstanceInTimeModeL(time5, ETrue, TCalTime::EFloating);

   732 	CheckIsAnInstanceInTimeModeL(time6, ETrue, TCalTime::EFloating);

   733 	CheckIsAnInstanceInTimeModeL(time7, ETrue, TCalTime::EFloating);

   734 	CheckIsAnInstanceInTimeModeL(time8, ETrue, TCalTime::EFloating);

   735 	}

   736 

   737 

   738 /*

   739 This test is a variation of a repeat rule test. 

   740 It was adapted from an unofficial version

   741 of tcal_tz.cpp written for reproducing a defect.

   742 */

   743 /** @SYMTestCaseID     PIM-TCAL-TZ-0013 */

   744 void CTzTestManager::DefectTestL()

   745 	{

   746 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0013 Running tcal_tz - DefectTestL")); 	

   747 	HBufC8* uid = _L8("DUMMY_UID").AllocLC();

   748 	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, uid, CCalEntry::EMethodNone, 0);

   749 	

   750 	CleanupStack::Pop(uid);

   751 	CleanupStack::PushL(entry);

   752 

   753 	delete iCalEntry;		

   754 	iCalEntry = entry;

   755 	

   756 	CTzRules* tzRules = CTzRules::NewL(2000, 2010);

   757 	CleanupStack::PushL(tzRules);

   758 

   759 	// Specify start/end time

   760 	TDateTime dtStart(2001,EJuly,5,20,30,0,0); //9:30pm in London 06 of July (Wednesday) 10:30 in Stockholm 07 of July (Thursday)

   761 	TDateTime dtEnd(2001,EJuly,5,21,30,0,0);

   762 	TCalTime startCalTime;

   763 	TCalTime endCalTime;

   764 	startCalTime.SetTimeUtcL(dtStart);

   765 	endCalTime.SetTimeUtcL(dtEnd);

   766 	entry->SetStartAndEndTimeL(startCalTime,endCalTime);

   767 	entry->SetSummaryL(_L("QGsUtilsTest:: TestTzL"));

   768 	entry->SetDescriptionL(_L("TZ test. "));

   769 	

   770 	TCalRRule rule;

   771 	TCalTime ruleStart;

   772 	ruleStart.SetTimeUtcL(dtStart);

   773 	// Create weekly repeat rule on Thursday and Saturday in Sweden

   774 	rule.SetType(TCalRRule::EWeekly);

   775 	rule.SetInterval(1);

   776 	rule.SetCount(2);

   777 	rule.SetDtStart(ruleStart);

   778 	RArray<TDay> days;

   779 	CleanupClosePushL(days);

   780 	days.Append(EThursday); // 7th in Sweden is a Thursday

   781 	days.Append(ESaturday);

   782 	rule.SetByDay(days);

   783 	days.Reset();

   784 	days.Close();

   785 	entry->SetRRuleL(rule);

   786 	CleanupStack::PopAndDestroy(&days);

   787 	

   788 	tzRules->SetInitialStdTimeOffset(60); // Swedish rules

   789 	TTzRule rule1(2000, 2010, 60, 120, EMarch, ETzDayInLastWeekOfMonth, 0, ESunday, ETzUtcTimeReference, 120);

   790 	TTzRule rule2(2000, 2010, 120, 60, EOctober, ETzDayInLastWeekOfMonth, 0, ESunday, ETzUtcTimeReference, 180);

   791 	tzRules->AddRuleL(rule1);

   792 	tzRules->AddRuleL(rule2);

   793 	entry->SetTzRulesL(*tzRules); // set tz rules to be Swedish

   794 

   795 

   796 	// store entry

   797 

   798 	CCalEntryView& entryView = iTestLibrary->SynCGetEntryViewL();

   799 

   800 	RPointerArray<CCalEntry> entryArray;

   801 	CleanupClosePushL(entryArray);

   802 	

   803 	entryArray.AppendL(entry);

   804 	TInt entriesAdded = 0;

   805 	entryView.StoreL(entryArray, entriesAdded);

   806 	

   807 	CleanupStack::PopAndDestroy(&entryArray);

   808 	CleanupStack::PopAndDestroy(tzRules);

   809 

   810 

   811 	// fetch instances

   812 

   813 	CCalInstanceView* instanceView = &iTestLibrary->SynCGetInstanceViewL();

   814 	

   815 	RPointerArray<CCalInstance> instances;

   816 	CleanupResetAndDestroyPushL(instances);

   817 	

   818 	TCalTime calTimeStart;

   819 	calTimeStart.SetTimeUtcL(TDateTime(2001, EJuly, 0, 0, 0, 0, 0)); // 00:00 on 1 July 2005

   820 	TCalTime calTimeEnd;

   821 	calTimeEnd.SetTimeUtcL(TDateTime(2001, EAugust, 0, 0, 0, 0, 0)); // 00:00 on 1 August 2005

   822 			

   823 	CalCommon::TCalViewFilter filter(CalCommon::EIncludeAll);

   824 	CalCommon::TCalTimeRange timeRange(calTimeStart, calTimeEnd);

   825 	

   826 	instanceView->FindInstanceL(instances, filter, timeRange);

   827 	test(instances.Count() == 2);

   828 	for (TInt i = 0; i < instances.Count(); i++)

   829 		{

   830 		TDateTime dt = instances[i]->Time().TimeUtcL().DateTime();

   831 		test.Printf(_L("found instance #%d: %d/%d/%d, %d:%d:%d UTC\n"), i, 

   832 			dt.Day()+1, dt.Month()+1, dt.Year(), dt.Hour(), dt.Minute(), dt.Second());

   833 		}

   834 		

   835 	CleanupStack::PopAndDestroy(&instances); // instances.ResetAndDestroy();

   836 	

   837 	

   838 	// needed by CheckIsAnInstanceInSpecifiedZoneL

   839 	iCalEntry = entry;

   840 	// 7/7/2001, 21:30 London, 22:30 Stockholm

   841 	TDateTime time1a(2001, EJuly, 6, 21, 30, 0, 0);

   842 	TDateTime time1b(2001, EJuly, 6, 22, 30, 0, 0);

   843 	CheckIsAnInstanceInTimeModeL(time1a, ETrue, TCalTime::EFloating);

   844 	CheckIsAnInstanceInSpecifiedZoneL(time1b);

   845 

   846 	// 7/12/2001, 21:30 London, 22:30 Stockholm

   847 	TDateTime time2a(2001, EJuly, 11, 21, 30, 0, 0);

   848 	TDateTime time2b(2001, EJuly, 11, 22, 30, 0, 0);

   849 	CheckIsAnInstanceInTimeModeL(time2a, ETrue, TCalTime::EFloating);

   850 	CheckIsAnInstanceInSpecifiedZoneL(time2b);

   851 

   852 	iCalEntry = NULL;

   853 	

   854 	CleanupStack::PopAndDestroy(entry);

   855 	}

   856 

   857 

   858 /** @SYMTestCaseID     PIM-TCAL-TZ-0014 */

   859 void CTzTestManager::TestRDatesTzSetupL()

   860 	{

   861 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0014 Running tcal_tz - TestRDatesTzSetupL")); 	

   862 	HBufC8* dummy = NULL;

   863 	delete iCalEntry;

   864 	iCalEntry = NULL;

   865 	iCalEntry = iTestLibrary->CreateCalEntryL(CCalEntry::EEvent, dummy);

   866 	

   867 	TTime dtStart(TDateTime(2005, EJanuary, 0, 9, 0, 0, 0));

   868 	TTime dtEnd(TDateTime(2005, EJanuary, 0, 10, 0, 0, 0));

   869 	TCalTime startCalTime;

   870 	TCalTime endCalTime;

   871 	startCalTime.SetTimeLocalL(dtStart);

   872 	endCalTime.SetTimeLocalL(dtEnd);

   873 	iCalEntry->SetStartAndEndTimeL(startCalTime, startCalTime);

   874 

   875 	RArray<TCalTime> dates;

   876 	CleanupClosePushL(dates);

   877 	TCalTime rdate;

   878 	TDateTime date1(2005, EJanuary, 10, 9, 0, 0, 0);

   879 	rdate.SetTimeLocalL(date1);

   880 	dates.AppendL(rdate);

   881 	TDateTime date2(2005, EJanuary, 20, 9, 0, 0, 0);

   882 	rdate.SetTimeLocalL(date2);

   883 	dates.AppendL(rdate);

   884 	iCalEntry->SetRDatesL(dates);

   885 	CleanupStack::PopAndDestroy(&dates);

   886 

   887 	RTz tz;

   888 	User::LeaveIfError(tz.Connect());

   889 	CTzId* id = CTzId::NewL(KPacificAuckland);

   890 	CleanupStack::PushL(id);

   891 	CTzRules* rules = tz.GetTimeZoneRulesL(*id, TDateTime(2000, EJanuary, 0, 0, 0, 0, 0), TDateTime(2010, EJanuary, 0, 0, 0, 0, 0), ETzUtcTimeReference);

   892 	CleanupStack::PopAndDestroy(id);

   893 	tz.Close();

   894 	

   895 	CleanupStack::PushL(rules);

   896 	

   897 	iCalEntry->SetTzRulesL(*rules); // set tz rules to be local

   898 	CleanupStack::PopAndDestroy(rules);

   899 	

   900 	CCalEntryView& entryView = iTestLibrary->SynCGetEntryViewL();

   901 	RPointerArray<CCalEntry> entryArray;

   902 	CleanupClosePushL(entryArray);

   903 	

   904 	entryArray.AppendL(iCalEntry);

   905 	TInt entriesAdded = 0;

   906 	entryView.StoreL(entryArray, entriesAdded);

   907 	

   908 	CleanupStack::PopAndDestroy(&entryArray);

   909 

   910 	// Now retrieve and test results

   911 

   912 	CheckIsAnInstanceInSpecifiedZoneL(date1);

   913 	CheckIsAnInstanceInSpecifiedZoneL(date2);

   914 	}

   915 

   916 

   917 void CTzTestManager::CheckIsAnInstanceInTimeModeL(const TTime& aLocalTime, TBool aFound, TCalTime::TTimeMode aTimeMode)

   918 	{

   919 	CCalInstanceView& instanceView = iTestLibrary->SynCGetInstanceViewL();

   920 	

   921 	RPointerArray<CCalInstance> instances;

   922 	CleanupResetAndDestroyPushL(instances);	

   923 

   924 	// Set up filter to find instance at aTime:

   925 	CalCommon::TCalViewFilter filter(CalCommon::EIncludeAll);

   926 	TCalTime calTime;

   927 	if(aTimeMode == TCalTime::EFloating)

   928 		{

   929 		calTime.SetTimeLocalFloatingL(aLocalTime);

   930 		}

   931 	else if(aTimeMode == TCalTime::EFixedTimeZone)

   932 		{

   933 		calTime.SetTimeLocalL(aLocalTime);

   934 		}

   935 	

   936 	CalCommon::TCalTimeRange timeRange(calTime, calTime);

   937 

   938 	instanceView.FindInstanceL(instances, filter, timeRange);

   939 	

   940 	TDateTime dt = aLocalTime.DateTime();

   941 	test.Printf(_L("expecting an instance at %d:%d:%d on %d/%d/%d"), 

   942 		dt.Hour(), dt.Minute(), dt.Second(), dt.Day()+1, dt.Month()+1, dt.Year());

   943 		

   944 	for (TInt i = 0; i < instances.Count(); i++)

   945 		{

   946 		dt = instances[i]->Time().TimeLocalL().DateTime();

   947 	test.Printf(_L("found instance %d at %d:%d:%d on %d/%d/%d"), i,

   948 		dt.Hour(), dt.Minute(), dt.Second(), dt.Day()+1, dt.Month()+1, dt.Year());

   949 		}

   950 		

   951 	if (aFound)

   952 		{

   953 		test(instances.Count() == 1);

   954 		test(instances[0]->Time().TimeLocalL() == aLocalTime);

   955 		}

   956 	else

   957 		{

   958 		test(instances.Count() == 0);

   959 		}

   960 

   961 	CleanupStack::PopAndDestroy(&instances); // instances.ResetAndDestroy();

   962 	}

   963 

   964 

   965 // aTime should be relative to iCalEntry's own CTzRules.

   966 void CTzTestManager::CheckIsAnInstanceInSpecifiedZoneL(const TTime& aTime)

   967 	{

   968 	CCalInstanceView& instanceView = iTestLibrary->SynCGetInstanceViewL();

   969 	

   970 	RPointerArray<CCalInstance> instances;

   971 	CleanupResetAndDestroyPushL(instances);	

   972 

   973 	// Set up filter to find instance at aTime:

   974 	CalCommon::TCalViewFilter filter(CalCommon::EIncludeAll);

   975 	TCalTime calTime;

   976 	CTzRules* rules = iCalEntry->TzRulesL();

   977 	CleanupStack::PushL(rules);

   978 	TTime queryTime = aTime;

   979 	rules->ConvertToUtcL(queryTime);

   980 	calTime.SetTimeUtcL(queryTime);

   981 	CalCommon::TCalTimeRange timeRange(calTime, calTime);

   982 	

   983 	instanceView.FindInstanceL(instances, filter, timeRange);

   984 	test(instances.Count() == 1);

   985 

   986 	TTime instanceTime = instances[0]->Time().TimeUtcL();

   987 	TDateTime dbgTime2 = instanceTime.DateTime();

   988 	rules->ConvertToLocalL(instanceTime);

   989 	test(instanceTime == aTime);

   990 

   991 	CleanupStack::PopAndDestroy(rules);

   992 	CleanupStack::PopAndDestroy(&instances); // instances.ResetAndDestroy();

   993 	}

   994 

   995 

   996 void CTzTestManager::VerifyRulesL(const CTzRules& aRules,const TCalTime& aStartRange,const TCalTime& aEndRange)

   997 	{

   998 	CCalInstanceView* instanceView = &iTestLibrary->SynCGetInstanceViewL();

   999 

  1000 	RPointerArray<CCalInstance> instances;

  1001 	CleanupResetAndDestroyPushL(instances);		

  1002 		

  1003 	CalCommon::TCalViewFilter filter(CalCommon::EIncludeAll);

  1004 	CalCommon::TCalTimeRange timeRange(aStartRange,aEndRange);

  1005 	instanceView->FindInstanceL(instances, filter, timeRange);

  1006 	for (TInt i = 0; i < instances.Count(); i++)

  1007 		{

  1008 		CCalEntry& entry = instances[i]->Entry();

  1009 		CTzRules* rules = entry.TzRulesL();

  1010 		CleanupStack::PushL(rules);

  1011 		test(rules->IsEqualTo(aRules));

  1012 		CleanupStack::PopAndDestroy(rules);

  1013 		}

  1014 		

  1015 	CleanupStack::PopAndDestroy(&instances);

  1016 	}

  1017 	

  1018 	

  1019 // DEF074085

  1020 // SetRRulesL() did not preserve the timezone rules of the CAgnEntry repeat def

  1021 // Any subsequent UpdateL would see a null timezone and reset to the local one

  1022 // Fix to SetRRulesL() preserves the CAgnRptDef tz rules

  1023 // This test case:

  1024 // Sets a repeat rule with SetRRulesL()

  1025 // Sets an arbitrary repeat timezone rule 

  1026 // StoreL() to the database

  1027 // Verifies the retrieved tz rules are the original ones saved

  1028 // FetchL() the saved entry

  1029 // Modifies the summary with SetSummaryL()

  1030 // Calls SetRRulesL() again (Defect was here)

  1031 // Calls UpdateL()

  1032 // Verifies the retrieved tz rules are the original ones saved

  1033 void CTzTestManager::TestCopyRepeatRulesL()

  1034 	{

  1035 	iTestLibrary->CleanDatabaseL();

  1036 	

  1037 	delete iCalEntry;

  1038 	iCalEntry = NULL;

  1039 

  1040 	_LIT8(KEntryUid,"DEF074805");

  1041 	HBufC8* uid = KEntryUid().AllocLC();

  1042 

  1043 	iCalEntry=CCalEntry::NewL(CCalEntry::EEvent,uid, CCalEntry::EMethodAdd, 0);

  1044 

  1045 	CleanupStack::Pop();

  1046 	iCalEntry->SetSummaryL(_L("Original"));

  1047 	TDateTime dtStart(2005,EMarch,0,8,0,0,0);

  1048 	TCalTime startCalTime;

  1049 	startCalTime.SetTimeLocalL(dtStart);

  1050 	iCalEntry->SetStartAndEndTimeL(startCalTime,startCalTime);

  1051 	TCalRRule calRule(TCalRRule::EWeekly);

  1052 	calRule.SetDtStart(startCalTime);

  1053 	calRule.SetCount(8);

  1054 	calRule.SetInterval(1);

  1055 	RArray<TDay> days;

  1056 	days.AppendL(ESunday);

  1057 	calRule.SetByDay(days);

  1058 	// This call to SetRRuleL() has a null timezone

  1059 	iCalEntry->SetRRuleL(calRule);

  1060 	days.Reset();

  1061 

  1062 	// Arbitrary timezone (Not the same as local)

  1063 	TTzRule tRule1(1981,1996,0,60,EMarch,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

  1064 	TTzRule tRule2(1981,1996,60,0,EOctober,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

  1065 	TTzRule tRule3(0,KMaxTUint16,0,0,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,0);	

  1066 	CTzRules* origRules = CTzRules::NewL(2003,2007);

  1067 	CleanupStack::PushL(origRules);

  1068 	origRules->AddRuleL(tRule1);

  1069 	origRules->AddRuleL(tRule2);

  1070 	origRules->AddRuleL(tRule3);

  1071 	// Sets the timezone in the repeat def

  1072 	iCalEntry->SetTzRulesL(*origRules);

  1073 		{

  1074 		CCalEntryView& entryView = iTestLibrary->SynCGetEntryViewL();

  1075 		RPointerArray<CCalEntry> entryArray;

  1076 		CleanupClosePushL(entryArray);

  1077 		

  1078 		entryArray.AppendL(iCalEntry);

  1079 		TInt entriesAdded = 0;

  1080 		// Save to database

  1081 		entryView.StoreL(entryArray, entriesAdded);

  1082 		

  1083 		CleanupStack::PopAndDestroy(&entryArray);

  1084 		}

  1085 	// Set up the range for entries to read

  1086 	TCalTime startRange;

  1087 	startRange.SetTimeLocalL(TDateTime(2005,EMarch,0,8,0,0,0));

  1088 	TCalTime endRange;

  1089 	endRange.SetTimeLocalL(TDateTime(2005,EApril,15, 8, 0, 0, 0));

  1090 	// Verify the StoreL() preserved the original rules

  1091 	VerifyRulesL(*origRules,startRange,endRange);

  1092 		{

  1093 		// Fetch the entry ready for update

  1094 		CCalEntryView& entryView = iTestLibrary->SynCGetEntryViewL();

  1095 		RPointerArray<CCalEntry> entryArray;

  1096 		CleanupResetAndDestroyPushL(entryArray);

  1097 				

  1098 		entryView.FetchL(KEntryUid, entryArray);	

  1099 		

  1100 		// Update the rule (DEFECT was here)

  1101 		entryArray[0]->SetRRuleL(calRule);

  1102 		entryArray[0]->SetSummaryL(_L("Modified"));

  1103 		TInt entriesAdded = 0;

  1104 		// Updates the database

  1105 		entryView.UpdateL(entryArray, entriesAdded);

  1106 		

  1107 		CleanupStack::PopAndDestroy(&entryArray);

  1108 		}

  1109 	// Verifies defect fix

  1110 	VerifyRulesL(*origRules,startRange,endRange);

  1111 	

  1112 	CleanupStack::PopAndDestroy(origRules);

  1113 	}

  1114 

  1115 

  1116 /** @SYMTestCaseID     PIM-TCAL-TZ-0015 */

  1117 void CTzTestManager::TestForeignZoneRepeatRule1L()

  1118 	{

  1119 	iTestLibrary->CleanDatabaseL();

  1120 	

  1121 	HBufC8* uid = _L8("DUMMY_UID").AllocLC();

  1122 	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, uid, CCalEntry::EMethodNone, 0);

  1123 	CleanupStack::Pop(uid);

  1124 	CleanupStack::PushL(entry);

  1125 		

  1126 	CTzRules* tzRules = CTzRules::NewL(2000, 2010);

  1127 	CleanupStack::PushL(tzRules);

  1128 	

  1129 	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-0015 Creating repeating entry every Thursday and Saturday from 7 July at 00:30 Stockholm time (6 July 22:30 UTC)")); 	

  1130 	TDateTime dtStart(2005,EJuly,5,22,30,0,0); //11:30pm in London 06 of Juli (Wednessday) 00:30 in Stockholm 07 of Juli (Thursday)

  1131 	TDateTime dtEnd(2005,EJuly,5,23,20,0,0);

  1132 	TCalTime startCalTime;

  1133 	TCalTime endCalTime;

  1134 	startCalTime.SetTimeUtcL(dtStart);

  1135 	endCalTime.SetTimeUtcL(dtEnd);