1 // Copyright (c) 2008-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 <connect/sbeclient.h>

    17 #include <e32test.h>

    18 #include "tzuserdata.h"

    19 #include <tzlocalizer.h>

    20 #include "testserver.h"

    21 #include <tzlocalizedcityrecord.h>

    22 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    23 #include <tzusernames.h>

    24 #include <tzuserdefineddata.h>

    25 #endif

    26 #include "tzidinternal.h"

    27 

    28 _LIT(KBackupTest, "Tz Backup");

    29 RTest test(KBackupTest);

    30 

    31 // Literal constants

    32 _LIT(KTzTestBackupFile, "C:\\Backup__tzuserdata.db");

    33 _LIT(KTzBackupFileFullPath, "C:\\private\\1020383e\\SQLite__tzuserdata.db");

    34 

    35 _LIT(KTzTestBackupLocDb, "C:\\Backup__TzLocalization.db");

    36 _LIT(KTzBackupLocDbFullPath, "C:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");

    37 

    38 _LIT(KTimeZoneBackupRegistrationFullPath, "Z:\\private\\1020383E\\backup_registration.xml");

    39 

    40 _LIT(KPerFile1,"c:\\private\\100012a5\\DBS_2000836D_DBS_DSC.db");

    41 _LIT(KPerFile2,"c:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");

    42 

    43 _LIT(KStandardName1, "UserTzName1");

    44 _LIT(KShortStandardName1, "UserTzSh1");

    45 _LIT(KDaylightSaveName1, "UserDLSaveName1");

    46 _LIT(KShortDaylightSaveName1, "UserShDLS1");

    47 _LIT(KCityNameName1, "UserCityName1");

    48 _LIT(KRegionName1, "UserRegionName1");

    49 

    50 _LIT(KStandardName2, "UserTzName2");

    51 _LIT(KShortStandardName2, "UserTzSh2");

    52 _LIT(KDaylightSaveName2, "UserDLSaveName2");

    53 _LIT(KShortDaylightSaveName2, "UserShDLS2");

    54 _LIT(KCityNameName2, "UserCityName2");

    55 _LIT(KRegionName2, "UserRegionName2");

    56 

    57 _LIT(KUserAddedCityName1, "UserAddedCity1");

    58 _LIT(KUserAddedCityName2, "UserAddedCity2");

    59 

    60 const TInt KLondonTzId = 2592;

    61 const TInt KParisTzId = 2656;

    62 

    63 static conn::CSBEClient* BackupClient;

    64 static TDriveList DriveList;

    65 

    66 class CTestUserDefinedBackupRestore : public CBase

    67 	{

    68 public:

    69 	static CTestUserDefinedBackupRestore* NewL();

    70 	~CTestUserDefinedBackupRestore();

    71 

    72 enum TTest

    73 	{

    74 	EBackupTest,

    75 	ERestoreTest

    76 	};

    77 

    78 	void RunTestsL();

    79 	void TestBackupAndRestoreUserDbL(TTest aTest);

    80 	void TestFrequentlyUsedZonesUpdateAfterRestoreDeleteL();

    81 	void TestFrequentlyUsedZonesUpdateAfterRestoreUpdateL();

    82 	void TestUserCitiesUpdateAfterRestoreL();

    83 	void TestFrequentlyUsedCurrentZonesUpdateAfterRestoreUpdateL();

    84 	void TestSystemRulesUpdateAfterRestoreL();

    85 	void TestBackupAndRestoreLocDbL();

    86 private:

    87 	CTestUserDefinedBackupRestore();

    88 	TBool CheckXMLRegistrationFileL();

    89 	TBool SimulateTzBackup(const TDesC& aSrcfile, const TDesC& aDestfile);

    90 	TBool SimulateTzRestore(const TDesC& aSrcfile, const TDesC& aDestfile);

    91 	void ConstructL();

    92 	void ResetTzUserDataL();

    93 	TBool TestSystemRulesUpdateAfterRestoreL(TUint aExpectedTzId, TBool aRestoreEmptyFile);

    94 	TBool LocDbWriteFunctionL(CTzLocalizer& aTzLocalizer, TInt aExpectedErr);

    95 

    96 	TBool CompareFrequentlyUsedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare);

    97 	TBool CompareFrequentlyUsedZone(const CTzLocalizedTimeZone& aZone, const CTzLocalizedTimeZone& aZoneToCompare);

    98 	TBool CompareFrequentlyUsedCityAfterUpdate(TInt aId, const CTzLocalizedCity& aCity);

    99 	TBool CompareFrequentlyUsedCityRestoredAfterUpdate(TInt aId, const CTzLocalizedCity& aCity);

   100 	TBool CompareFrequentlyUsedZoneAfterUpdate(TInt aId, const CTzLocalizedTimeZone& aZone);

   101 		

   102 //Member

   103 public:

   104 	CTzUserData* iUserData;

   105 	RFs iFs;

   106 	RPIMTestServer iServ;

   107 	RTz iTz;

   108 	};

   109 

   110 // building block test backup and restore functions

   111 

   112 static void StartBackupL()

   113 	{

   114 	/* Use the Secure Backup Engine API to "start" a backup.  The backup

   115 	 happens indirectly through CTzUserDataDb::BackupBeginningL()/

   116 	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

   117 	 These methods are implementations for MBackupRestoreNotificatioObserver

   118 	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

   119 	 This P&S property is changed by calling the Secure Backup Engine API

   120 	 below.

   121 	 */	

   122 	test.Printf(_L("Starting Backup\n"));

   123 	BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase);

   124 	User::After(3000000);// Wait a bit to allow the server to close the database

   125 	}

   126 

   127 

   128 static void EndBackupL()

   129 	{

   130 	/* Use the Secure Backup Engine API to "end" a backup. The backup ends

   131 	 indirectly through CTzUserDataDb::BackupBeginningL()/

   132 	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

   133 	 These methods are implementations for MBackupRestoreNotificatioObserver

   134 	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

   135 	 This P&S property is changed by calling the Secure Backup Engine API

   136 	 below.

   137 	 */

   138 	test.Printf(_L("Finishing Backup\n"));

   139 	BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);

   140 	User::After(3000000);// Wait a bit to allow the server to open the database

   141 	}

   142 

   143 

   144 static void StartRestoreL()

   145 	{

   146 	/* Use the Secure Backup Engine API to "start" a restore.  

   147 	 This happens indirectly through CTzUserDataDb::BackupBeginningL()/

   148 	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

   149 	 These methods are implementations for MBackupRestoreNotificatioObserver

   150 	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

   151 	 This P&S property is changed by calling the Secure Backup Engine API

   152 	 below.

   153 	 */

   154 	test.Printf(_L("Starting restore\n"));

   155 	BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase);

   156 	User::After(3000000);// Wait a bit to allow the server to close the database

   157 	}

   158 

   159 

   160 static void EndRestoreL()

   161 	{

   162 	/* Use the Secure Backup Engine API to "end" a restore.

   163 	 This happens indirectly through CTzUserDataDb::BackupBeginningL()/

   164 	 BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

   165 	 These methods are implementations for MBackupRestoreNotificatioObserver

   166 	 which monitors changes in the P&S property conn::KUidBackupRestoreKey.

   167 	 This P&S property is changed by calling the Secure Backup Engine API

   168 	 below.

   169 	 */

   170 	test.Printf(_L("Finishing restore\n"));

   171 	BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);

   172 	User::After(3000000);// Wait a bit to allow the server to open and update the database

   173 	}

   174 

   175 LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr)

   176 	{

   177 	RPointerArray<CTzId>* ids = static_cast<RPointerArray<CTzId>*>(aPtr);

   178 	if (ids)

   179 		{

   180 		ids->ResetAndDestroy();

   181 		}

   182 	}

   183 

   184 LOCAL_D void CleanupCityPointerArray(TAny* aPtr)

   185 	{

   186 	RPointerArray<CTzLocalizedCityRecord>* ids = static_cast<RPointerArray<CTzLocalizedCityRecord>*>(aPtr);

   187 	if (ids)

   188 		{

   189 		ids->ResetAndDestroy();

   190 		}

   191 	}

   192 	

   193 /** Access to user defined time zone data during backup or restore operation 

   194 @SYMTestCaseID      PIM-TTZBACKUP-TZS-BR-0001

   195 @SYMTestCaseDesc    The purpose of this test is to verify the behaviour of the 

   196 					client APIs that access user defined time zones during a backup or restore operation.

   197 @SYMTestActions    

   198 1.	Create a user defined time zone.

   199 2.	Simulate start of backup or restore operation.

   200 3.	Access (read, update, delete) the user defined time zone created in action 1. 1

   201 4.	Create a user defined time zone. 2

   202 5.	Simulate end of backup or restore operation.

   203 6.	Access (read, update, delete) the user defined time zone created in action 1. 3

   204 7.	Create a user defined time zone. 4

   205 

   206 @SYMTestExpectedResults In step 3 and 4, operation leaves with KErrLocked

   207 						In step 6 and 7, operation completes without error	

   208 

   209 @SYMTestType                CT

   210 @SYMTestPriority            1

   211 */

   212 

   213 CTestUserDefinedBackupRestore::CTestUserDefinedBackupRestore()

   214 	{

   215 	

   216 	}

   217 	

   218 CTestUserDefinedBackupRestore* CTestUserDefinedBackupRestore::NewL()

   219 	{

   220 	CTestUserDefinedBackupRestore* self = new(ELeave) CTestUserDefinedBackupRestore();

   221 	CleanupStack::PushL(self);

   222 	self->ConstructL();

   223 	CleanupStack::Pop(self);

   224 	return self;

   225 	}

   226 

   227 void CTestUserDefinedBackupRestore::ConstructL()

   228 	{

   229 	User::LeaveIfError(iFs.Connect());

   230 	User::LeaveIfError(iServ.Connect());

   231 	iServ.CloseTzSession();

   232 	}

   233 

   234 CTestUserDefinedBackupRestore::~CTestUserDefinedBackupRestore()

   235 	{

   236 	delete iUserData;

   237 	iFs.Delete(KTzTestBackupFile);

   238 	// delete database file

   239 	iFs.Delete(KTzBackupFileFullPath);

   240 	iFs.Close();

   241 	iServ.Close();

   242 	}

   243 

   244 void CTestUserDefinedBackupRestore::ResetTzUserDataL()

   245 	{

   246 	RPointerArray<CTzId> ids;

   247 	CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids));

   248 	iUserData->GetTzIdsL(ids);

   249 	TInt count = ids.Count();

   250 	for (TInt ii=0; ii<count; ++ii)

   251 		{

   252 		iUserData->DeleteL(*ids[ii]);	

   253 		}

   254 	CleanupStack::PopAndDestroy(&ids);	

   255 	}

   256 

   257 TBool CTestUserDefinedBackupRestore::CheckXMLRegistrationFileL()

   258 	{

   259 	TEntry entry;

   260 

   261 	TInt error = iFs.Entry(KTimeZoneBackupRegistrationFullPath, entry);

   262 

   263 	if (error == KErrNotFound)

   264 		{

   265 		return EFalse;

   266 		}

   267 

   268 	User::LeaveIfError(error);

   269 

   270 	if(entry.iSize == 0)

   271 		{

   272 		// file is present but is empty

   273 		User::Leave(KErrCorrupt);

   274 		}

   275 

   276 	// found the registration file

   277 	return ETrue;

   278 	}

   279 

   280 TBool CTestUserDefinedBackupRestore::SimulateTzBackup(const TDesC& aSrcfile, const TDesC& aDestfile)

   281 	{

   282     TRAPD(error, iServ.CopyFileL(aSrcfile, aDestfile));

   283  

   284 	if (error != KErrNone)

   285 		{

   286 		test.Printf(_L("Copy failed with error %i"), error);

   287 		return EFalse;

   288 		}

   289 	return ETrue;

   290 	}

   291 	

   292 TBool CTestUserDefinedBackupRestore::SimulateTzRestore(const TDesC& aSrcfile, const TDesC& aDestfile)

   293 	{

   294     // Backup tz user-defined database file.

   295     TRAPD(error, iServ.CopyFileL(aSrcfile ,aDestfile));

   296 	

   297 	if (error != KErrNone)

   298 		{

   299 		test.Printf(_L("Copy failed with error %i"), error);

   300 		return EFalse;

   301 		}

   302 	return ETrue;

   303 	}

   304 

   305 TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare)

   306 	{

   307 	if(aCity.TimeZoneId() != aCityToCompare.TimeZoneId())

   308 		{

   309 		return EFalse;

   310 		}

   311 	if(aCity.GroupId() != aCityToCompare.GroupId())

   312 		{

   313 		return EFalse;

   314 		}

   315 	if(aCity.Name() != aCityToCompare.Name())

   316 		{

   317 		return EFalse;

   318 		}

   319 	return ETrue;

   320 	}

   321 	

   322 TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedZone(const CTzLocalizedTimeZone& aZone, const CTzLocalizedTimeZone& aZoneToCompare)

   323 	{

   324 	if(aZone.TimeZoneId() != aZoneToCompare.TimeZoneId())

   325 		{

   326 		return EFalse;

   327 		}

   328 	if(aZone.StandardName() != aZoneToCompare.StandardName())

   329 		{

   330 		return EFalse;

   331 		}

   332 	if(aZone.ShortStandardName() != aZoneToCompare.ShortStandardName())

   333 		{

   334 		return EFalse;

   335 		}

   336 	if(aZone.DaylightName() != aZoneToCompare.DaylightName())

   337 		{

   338 		return EFalse;

   339 		}

   340 	if(aZone.ShortDaylightName() != aZoneToCompare.ShortDaylightName())

   341 		{

   342 		return EFalse;

   343 		}

   344 	return ETrue;

   345 	}

   346 

   347 TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCityAfterUpdate(TInt aId, const CTzLocalizedCity& aCity)

   348 	{

   349 	if(aCity.TimeZoneId() != aId)

   350 		{

   351 		return EFalse;

   352 		}

   353 	if(aCity.GroupId() != 0)

   354 		{

   355 		return EFalse;

   356 		}

   357 	if(aCity.Name() != KCityNameName2)

   358 		{

   359 		return EFalse;

   360 		}

   361 	return ETrue;

   362 	}

   363 	

   364 TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCityRestoredAfterUpdate(TInt aId, const CTzLocalizedCity& aCity)

   365 	{

   366 	if(aCity.TimeZoneId() != aId)

   367 		{

   368 		return EFalse;

   369 		}

   370 	if(aCity.GroupId() != 0)

   371 		{

   372 		return EFalse;

   373 		}

   374 	if(aCity.Name() != KCityNameName1)

   375 		{

   376 		return EFalse;

   377 		}

   378 	return ETrue;

   379 	}

   380 	

   381 TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedZoneAfterUpdate(TInt aId, const CTzLocalizedTimeZone& aZone)

   382 	{

   383 	if(aZone.TimeZoneId() != aId)

   384 		{

   385 		return EFalse;

   386 		}

   387 	if(aZone.StandardName() != KStandardName1)

   388 		{

   389 		return EFalse;

   390 		}

   391 	if(aZone.ShortStandardName() != KShortStandardName1)

   392 		{

   393 		return EFalse;

   394 		}

   395 	if(aZone.DaylightName() != KDaylightSaveName1)

   396 		{

   397 		return EFalse;

   398 		}

   399 	if(aZone.ShortDaylightName() != KShortDaylightSaveName1)

   400 		{

   401 		return EFalse;

   402 		}

   403 	return ETrue;

   404 	}

   405 	

   406 void CTestUserDefinedBackupRestore::TestBackupAndRestoreUserDbL(TTest aTest)

   407 	{

   408 	TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust,  ETzFixedDate, 0,  0, ETzWallTimeReference, 120);

   409 	TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);

   410 

   411 	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

   412 	CleanupStack::PushL(rules);

   413 	rules->AddRuleL(rule1);

   414 	rules->AddRuleL(rule2);

   415 	

   416 	TBuf<20> stdName;

   417 	stdName.Format(_L("StdName1"));	

   418 	TBuf<20> shortStdName;

   419 	shortStdName.Format(_L("ShortStd1"));	

   420 	TBuf<20> dstName;

   421 	dstName.Format(_L("DstName1"));	

   422 	TBuf<20> shortDstName;

   423 	shortDstName.Format(_L("ShortDst1"));	

   424 	TBuf<20> cityName;

   425 	cityName.Format(_L("CityName1"));	

   426 	TBuf<20> regionName;

   427 	regionName.Format(_L("RegionName1"));

   428 	

   429 	CTzUserNames* names = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);

   430 	

   431 	CTzId* id = NULL;

   432 	id = iUserData->CreateL(*rules, *names);

   433 	

   434 	CleanupStack::PopAndDestroy(2, rules);

   435 	CleanupStack::PushL(id);

   436 	

   437 	TBool file = CheckXMLRegistrationFileL();

   438 	test(file);

   439 	

   440 	if(aTest == EBackupTest)

   441 		{

   442 		TRAPD(err, StartBackupL());

   443 		test(err==KErrNone);

   444 		TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);

   445 		test(result);

   446 		}

   447 	else

   448 		{

   449 		TRAPD(err, StartRestoreL());

   450 		test(err == KErrNone);

   451 		

   452 		TBool result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;

   453 		test(result);

   454 		

   455 		CleanupStack::PopAndDestroy(id);

   456 		// Setting back to initial id as the database

   457 		// copied during restore will not have all the changes

   458 		// that happened afterwards

   459 		id = CTzId::NewL(KUserTzIdMin);

   460 		CleanupStack::PushL(id);

   461 		}

   462 	

   463 	test.Printf(_L("Now try reading the names of the created zone\n"));

   464 

   465 	CTzUserNames* readNames = NULL;

   466 	TRAPD(err, readNames = iUserData->ReadNamesL(*id));

   467 	delete readNames;

   468 	

   469 	test(err == KErrLocked);

   470 	test.Printf(_L("Could not read names as backup/restore is in progress\n"));

   471 			

   472 	test.Printf(_L("Now try reading the rules of the created zone\n"));

   473 

   474 	CTzRules* readRules = NULL;

   475 	TRAP(err, readRules = iUserData->ReadRulesL(*id));

   476 	delete readRules;

   477 	

   478 	test(err == KErrLocked);

   479 	test.Printf(_L("Could not read rules as backup/restore is in progress\n"));

   480 		

   481 	test.Printf(_L(" @SYMTestCaseID PIM-TTZBACKUP-TZS-BR-0001  Now try reading the TZIDs of all user-defined time zone data\n"));

   482 	

   483 	RPointerArray<CTzId> tzIds;

   484 	TRAP(err, iUserData->GetTzIdsL(tzIds));

   485 	tzIds.ResetAndDestroy();

   486 	tzIds.Close();

   487 

   488 	test(err == KErrLocked);

   489 	test.Printf(_L("Could not read TZIDs as backup/restore is in progress\n"));

   490 

   491 	TTzRule rule3(1981,1996,0,60,EMarch,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

   492 	TTzRule rule4(1981,1996,60,0,EOctober,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);

   493 	

   494 	CTzRules* rulesAdd = CTzRules::NewL(0, KMaxTUint);

   495 	CleanupStack::PushL(rulesAdd);

   496 	rulesAdd->AddRuleL(rule3);

   497 	rulesAdd->AddRuleL(rule4);

   498 

   499 	stdName.Format(_L("StdName2"));	

   500 	shortStdName.Format(_L("ShortStd2"));	

   501 	dstName.Format(_L("DstName2"));	

   502 	shortDstName.Format(_L("ShortDst2"));	

   503 	cityName.Format(_L("CityName2"));	

   504 	regionName.Format(_L("RegionName2"));

   505 	

   506 	CTzUserNames* namesAdd = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);

   507 	CTzId* tzId = NULL;

   508 	TRAP(err, tzId  = iUserData->CreateL(*rulesAdd, *namesAdd));

   509 	delete tzId;

   510 	test(err == KErrLocked);

   511 	

   512 	TRAP(err, iUserData->UpdateL(*id, *rulesAdd, *namesAdd));

   513 	test(err == KErrLocked);

   514 	test.Printf(_L("Could not update user-defined rules as backup/restore is in progress\n"));

   515 

   516 	TRAP(err, iUserData->DeleteL((*id)));

   517 	test(err == KErrLocked);

   518 	test.Printf(_L("Could not delete user-defined rules as backup/restore is in progress\n"));

   519 	

   520 	CleanupStack::PopAndDestroy(namesAdd);

   521 	CleanupStack::PopAndDestroy(rulesAdd);

   522 	

   523 	if(aTest == EBackupTest)

   524 		{

   525 		// backup complete

   526 		TRAP(err, EndBackupL());

   527 		test(err == KErrNone);

   528 		}

   529 	else

   530 		{

   531 		// restore complete

   532 		TRAP(err, EndRestoreL());

   533 		test(err == KErrNone);

   534 		}

   535 	

   536 	test.Printf(_L("Check if we can perform CRUD operations on user-defined rules\n"));

   537 	CTzUserNames* readNamesAgain = NULL;

   538 

   539 	TRAPD(ret, readNamesAgain = iUserData->ReadNamesL(*(id)));

   540 	test(ret == KErrNone);

   541 	test.Printf(_L("Successfully read user-defined rules after backup/restore has completed\n"));

   542 				

   543 	delete readNamesAgain;

   544 	CleanupStack::PopAndDestroy();

   545 	

   546 	CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);

   547 	CleanupStack::PushL(newRules);

   548 	newRules->AddRuleL(rule3);

   549 	newRules->AddRuleL(rule4);

   550 

   551 	stdName.Format(_L("StdName3"));	

   552 	shortStdName.Format(_L("ShortStd3"));	

   553 	dstName.Format(_L("DstName3"));	

   554 	shortDstName.Format(_L("ShortDst3"));	

   555 	cityName.Format(_L("CityName3"));	

   556 	regionName.Format(_L("RegionName3"));

   557 	

   558 	CTzUserNames* newNames = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);

   559 	CTzId* newId = NULL;

   560 	TRAP(err, newId  = iUserData->CreateL(*newRules, *newNames));

   561 	test(err == KErrNone);

   562 	test.Printf(_L("Successfully created user-defined rules after backup/restore has completed\n"));

   563 	

   564 	TRAP(err, iUserData->UpdateL(*newId, *newRules, *newNames));

   565 	test(err == KErrNone);

   566 	test.Printf(_L("Successfully updated user-defined rules after backup/restore has completed\n"));

   567 		

   568 	TRAP(err, iUserData->DeleteL(*newId));

   569 	test(err == KErrNone);

   570 	test.Printf(_L("Successfully deleted user-defined rules after backup/restore has completed\n"));

   571 	

   572 	CleanupStack::PopAndDestroy(newNames);

   573 	CleanupStack::PopAndDestroy(newRules);	

   574 	delete newId;

   575 	}

   576 

   577 void CTestUserDefinedBackupRestore::TestBackupAndRestoreLocDbL()

   578 	{

   579 	test.Printf(_L("Start to backup or restore localization DB which should lock the file\n"));

   580 	CTzLocalizer* localizer = NULL;

   581 	//Make sure the localization DB exists

   582 	localizer = CTzLocalizer::NewL();

   583 	delete localizer;

   584 	localizer = NULL;

   585 	

   586 	//Verify that the client can not create an object of CTzLocalizer when backup or restroe starts

   587 	StartBackupL();

   588 	test(SimulateTzBackup(KTzBackupLocDbFullPath, KTzTestBackupLocDb));

   589 	TRAPD(err, localizer = CTzLocalizer::NewL());

   590 	test (err == KErrLocked);

   591 	test (!localizer);

   592 	EndBackupL();

   593 	StartRestoreL();

   594 	test(SimulateTzRestore(KTzTestBackupLocDb, KTzBackupLocDbFullPath) );

   595 	TRAP(err, localizer = CTzLocalizer::NewL());

   596 	test(err == KErrLocked);

   597 	test (!localizer);

   598 	EndRestoreL();

   599 	

   600 	localizer = CTzLocalizer::NewL();

   601 	CleanupStack::PushL(localizer);

   602 	//Verify that functions which requires writing to the localization file are locked when backup or restore starts

   603 	StartBackupL();

   604 	test(SimulateTzBackup(KTzBackupLocDbFullPath, KTzTestBackupLocDb));

   605 	test(LocDbWriteFunctionL(*localizer, KErrLocked));

   606 	EndBackupL();

   607 	test(LocDbWriteFunctionL(*localizer, KErrNone));

   608 	StartRestoreL();

   609 	test(SimulateTzRestore(KTzTestBackupLocDb, KTzBackupLocDbFullPath) );

   610 	test(LocDbWriteFunctionL(*localizer, KErrLocked));

   611 	EndRestoreL();

   612 	test(LocDbWriteFunctionL(*localizer, KErrNone));

   613 	CleanupStack::PopAndDestroy(localizer);

   614 	}

   615 

   616 TBool CTestUserDefinedBackupRestore::LocDbWriteFunctionL(CTzLocalizer& aTzLocalizer, TInt aExpectedErr)

   617 	{

   618 	TRAPD(err, aTzLocalizer.SetFrequentlyUsedZoneL(KLondonTzId,CTzLocalizedTimeZone::EHomeZone));

   619 	if(aExpectedErr != err)

   620 		{

   621 		return EFalse;

   622 		}

   623 	return ETrue;

   624 	}

   625 

   626 void CTestUserDefinedBackupRestore::TestFrequentlyUsedZonesUpdateAfterRestoreDeleteL()

   627 	{

   628 	// Backup the file before we added the user defined time zones

   629 	test.Printf(_L("Backup the file without any user-defined zones\n"));

   630 	_LIT8(KLondon, "Europe/London");

   631 	CTzId* tzid  = CTzId::NewL(KLondon);

   632 	iTz.SetTimeZoneL(*tzid);

   633 	delete tzid;

   634 	

   635 	TRAPD(err, StartBackupL());

   636 	test(err==KErrNone);

   637 	TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);

   638 	test(result);

   639 	TRAP(err, EndBackupL());

   640 	test(err == KErrNone);

   641 	

   642 	// Add a user defined time zone

   643 	test.Printf(_L("Add a user-defined zone\n"));

   644 	TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust,  ETzFixedDate, 0,  0, ETzWallTimeReference, 120);

   645 	TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);

   646 	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

   647 	CleanupStack::PushL(rules);

   648 	rules->AddRuleL(rule1);

   649 	rules->AddRuleL(rule2);

   650 	

   651 	CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),

   652 	KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());

   653 	CTzId* id = iUserData->CreateL(*rules, *names);

   654 	CleanupStack::PopAndDestroy(2, rules);

   655 	CleanupStack::PushL(id);

   656 	

   657 	// Add this time zone in the frequently used zone table

   658 	CTzLocalizer* localizer = CTzLocalizer::NewL();

   659 	test.Printf(_L("Set the user-defined zone as the frequently used zone\n"));

   660 	localizer->SetFrequentlyUsedZoneL(id->TimeZoneNumericID(), CTzLocalizedTimeZone::EHomeZone);

   661 	CleanupStack::PopAndDestroy(id);

   662 	

   663 	// Restore the file

   664 	test.Printf(_L("Restore the backed up file\n"));

   665 	TRAP(err, StartRestoreL());

   666 	test(err == KErrNone);

   667 	result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;

   668 	test(result);

   669 	TRAP(err, EndRestoreL());

   670 	test(err == KErrNone);

   671 	

   672 	CTzLocalizedCity* cityToCompareWith = localizer->GetDefaultCityL(KLondonTzId);

   673 	CleanupStack::PushL(cityToCompareWith);

   674 	

   675 	test.Printf(_L("Fetch the frequently used city and check if it is the expected one\n"));

   676 	CTzLocalizedCity* city = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EHomeZone);

   677 	test(CompareFrequentlyUsedCity(*city, *cityToCompareWith));

   678 	delete city;

   679 	

   680 	CTzLocalizedTimeZone* zoneToCompareWith = localizer->GetLocalizedTimeZoneL(KLondonTzId);

   681 	CleanupStack::PushL(zoneToCompareWith);

   682 	

   683 	CTzLocalizedTimeZone* timeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::EHomeZone);

   684 	test.Printf(_L("Fetch the frequently used zone and check if it is the expected one\n"));

   685 	test(CompareFrequentlyUsedZone(*timeZone, *zoneToCompareWith));

   686 	delete timeZone;

   687 	

   688 	delete localizer;

   689 	CleanupStack::PopAndDestroy(2, cityToCompareWith);

   690 	}

   691 

   692 void CTestUserDefinedBackupRestore::TestFrequentlyUsedZonesUpdateAfterRestoreUpdateL()

   693 	{

   694 	// Add a user defined time zone

   695 	test.Printf(_L("Create a user-defined zone\n"));

   696 	TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust,  ETzFixedDate, 0,  0, ETzWallTimeReference, 120);

   697 	TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);

   698 	

   699 	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

   700 	CleanupStack::PushL(rules);

   701 	rules->AddRuleL(rule1);

   702 	rules->AddRuleL(rule2);

   703 	

   704 	CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),

   705 	KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());

   706 	CTzId* id = iUserData->CreateL(*rules, *names);

   707 	CleanupStack::PopAndDestroy(2, rules);

   708 	

   709 	CleanupStack::PushL(id);

   710 	

   711 	// Backup the file before we added the user defined time zones

   712 	test.Printf(_L("Backup the user-defined database\n"));

   713 	TRAPD(err, StartBackupL());

   714 	test(err==KErrNone);

   715 	TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);

   716 	test(result);

   717 	TRAP(err, EndBackupL());

   718 	test(err == KErrNone);

   719 	

   720 	// Update the user defined time zone

   721 	test.Printf(_L("Update the user-defined rule\n"));

   722 	CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);

   723 	CleanupStack::PushL(newRules);

   724 	newRules->AddRuleL(rule1);

   725 	newRules->AddRuleL(rule2);

   726 	

   727 	//Create a user defined rule names for update

   728 	CTzUserNames* newNames = CTzUserNames::NewLC(KStandardName2(), KShortStandardName2(),

   729 	KDaylightSaveName2(), KShortDaylightSaveName2(), KCityNameName2(), KRegionName2());

   730 	iUserData->UpdateL(*id, *newRules, *newNames);

   731 	CleanupStack::PopAndDestroy(2, newRules);

   732 	

   733 	// Add this time zone in the frequently used zone table

   734 	CTzLocalizer* localizer = CTzLocalizer::NewL();

   735 	test.Printf(_L("Set the new zone as the frequently used zone\n"));

   736 	localizer->SetFrequentlyUsedZoneL(id->TimeZoneNumericID(), CTzLocalizedTimeZone::EHomeZone);

   737 	test.Printf(_L("Fetch the frequently used city and check if it is the expected one\n"));

   738 	CTzLocalizedCity* city = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EHomeZone);

   739 	test(CompareFrequentlyUsedCityAfterUpdate(id->TimeZoneNumericID(), *city));

   740 	delete city;

   741 	

   742 	// Restore the file

   743 	test.Printf(_L("Restore the backed up file\n"));

   744 	TRAP(err, StartRestoreL());

   745 	test(err == KErrNone);

   746 	result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;

   747 	test(result);

   748 	TRAP(err, EndRestoreL());

   749 	test(err == KErrNone);

   750 			

   751 	test.Printf(_L("Get the frequently used city and check if it is the expected one\n"));

   752 	CTzLocalizedCity* updatedCity = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EHomeZone);

   753 	test(CompareFrequentlyUsedCityRestoredAfterUpdate(id->TimeZoneNumericID(), *updatedCity));

   754 	delete updatedCity;

   755 	test.Printf(_L("Get the frequently used zone and check if it is the expected one\n"));

   756 	CTzLocalizedTimeZone* timeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::EHomeZone);

   757 	test(CompareFrequentlyUsedZoneAfterUpdate(id->TimeZoneNumericID(), *timeZone));

   758 	delete timeZone;

   759 	

   760 	CleanupStack::PopAndDestroy(id);

   761 	delete localizer;

   762 	}

   763 

   764 void CTestUserDefinedBackupRestore::TestFrequentlyUsedCurrentZonesUpdateAfterRestoreUpdateL()

   765 	{

   766 	// Add a user defined time zone

   767 	test.Printf(_L("Create a user-defined zone\n"));

   768 	TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust,  ETzFixedDate, 0,  0, ETzWallTimeReference, 120);

   769 	TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);

   770 	

   771 	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

   772 	CleanupStack::PushL(rules);

   773 	rules->AddRuleL(rule1);

   774 	rules->AddRuleL(rule2);

   775 

   776 	CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),

   777 	KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());

   778 	CTzId* id = iUserData->CreateL(*rules, *names);

   779 	TInt tzid = id->TimeZoneNumericID();

   780 	delete id;

   781 	CleanupStack::PopAndDestroy(2, rules);

   782 		

   783 	// Backup the file before we added the user defined time zones

   784 	test.Printf(_L("Start the database backup\n"));

   785 	TRAPD(err, StartBackupL());

   786 	test(err==KErrNone);

   787 	TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);

   788 	test(result);

   789 	TRAP(err, EndBackupL());

   790 	test(err == KErrNone);

   791 	

   792 	// Add user-defined rules

   793 	test.Printf(_L("Update the rule in the database\n"));

   794 	CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);

   795 	CleanupStack::PushL(newRules);

   796 	newRules->AddRuleL(rule1);

   797 	newRules->AddRuleL(rule2);

   798 	

   799 	//Create a user defined rule names- CTzUserNames.

   800 	CTzUserNames* names2 = CTzUserNames::NewLC(KStandardName2(), KShortStandardName2(),

   801 	KDaylightSaveName2(), KShortDaylightSaveName2(), KCityNameName2(), KRegionName2());

   802 	CTzId* tzId = CTzId::NewL(tzid);

   803 	CleanupStack::PushL(tzId);

   804 	iUserData->UpdateL(*tzId, *rules, *names2);

   805 	CleanupStack::PopAndDestroy(tzId);

   806 	CleanupStack::PopAndDestroy(2, newRules);

   807 	

   808 	// Set the time zone to Paris

   809 	test.Printf(_L("Set the time zone to Paris\n"));

   810 	CTzLocalizer* localizer = CTzLocalizer::NewL();

   811 	localizer->SetTimeZoneL(KParisTzId);

   812 	

   813 	CTzLocalizedCity* cityToCompareWith = localizer->GetDefaultCityL(KParisTzId);

   814 	CleanupStack::PushL(cityToCompareWith);

   815 	

   816 	// Read the frequently used city and compare with the expected one

   817 	test.Printf(_L("Get the frequently used city and check if it is the expected one\n"));

   818 	CTzLocalizedCity* city = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::ECurrentZone);

   819 	test(CompareFrequentlyUsedCity(*city, *cityToCompareWith));

   820 	delete city;

   821 	

   822 	CTzLocalizedTimeZone* zoneToCompareWith = localizer->GetLocalizedTimeZoneL(KParisTzId);

   823 	CleanupStack::PushL(zoneToCompareWith);

   824 	

   825 	test.Printf(_L("Get the frequently used zone and check if it is the expected one\n"));

   826 	CTzLocalizedTimeZone* timeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::ECurrentZone);

   827 	test(CompareFrequentlyUsedZone(*timeZone, *zoneToCompareWith));

   828 	delete timeZone;

   829 	

   830 	// Restore the file

   831 	test.Printf(_L("Restore the backed up file\n"));

   832 	TRAP(err, StartRestoreL());

   833 	test(err == KErrNone);

   834 	result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;

   835 	test(result);

   836 	TRAP(err, EndRestoreL());

   837 	test(err == KErrNone);

   838 	

   839 	test.Printf(_L("Again, get the frequently used city and check if it is the expected one\n"));

   840 	CTzLocalizedCity* updatedCity = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::ECurrentZone);

   841 	test(CompareFrequentlyUsedCity(*updatedCity, *cityToCompareWith));

   842 	delete updatedCity;

   843 	

   844 	test.Printf(_L("Again, get the frequently used zone and check if it is the expected one\n"));

   845 	CTzLocalizedTimeZone* updatedTimeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::ECurrentZone);

   846 	test(CompareFrequentlyUsedZone(*updatedTimeZone, *zoneToCompareWith));

   847 	

   848 	delete updatedTimeZone;

   849 	delete localizer;

   850 	CleanupStack::PopAndDestroy(2, cityToCompareWith);

   851 	}

   852 

   853 void CTestUserDefinedBackupRestore::TestUserCitiesUpdateAfterRestoreL()

   854 	{

   855 	// Backup the file before we add the user defined time zones

   856 	test.Printf(_L("Start the backup of the user-defined database\n"));

   857 	TRAPD(err, StartBackupL());

   858 	test(err==KErrNone);

   859 	TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);

   860 	test(result);

   861 	TRAP(err, EndBackupL());

   862 	test(err == KErrNone);

   863 	

   864 	// Add a user defined time zone

   865 	test.Printf(_L("Create a user-defined zone\n"));

   866 	TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust,  ETzFixedDate, 0,  0, ETzWallTimeReference, 120);

   867 	TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);

   868 	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

   869 	CleanupStack::PushL(rules);

   870 	rules->AddRuleL(rule1);

   871 	rules->AddRuleL(rule2);

   872 

   873 	CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(), 

   874 	KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());

   875 	CTzId* id = iUserData->CreateL(*rules, *names);

   876 	TInt tzid = id->TimeZoneNumericID();

   877 	delete id;

   878 	CleanupStack::PopAndDestroy(2, rules);

   879 		

   880 	CTzLocalizer* localizer = CTzLocalizer::NewL();

   881 	// Add a city that uses this time zone

   882 	test.Printf(_L("Add a user-defined city to the zone\n"));

   883 	CTzLocalizedCity* userCity = localizer->AddCityL(tzid, KUserAddedCityName1);

   884 	delete userCity;

   885 	

   886 	// Add a user defined time zone

   887 	test.Printf(_L("Add another rule to the database\n"));

   888 	CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);

   889 	CleanupStack::PushL(newRules);

   890 	newRules->AddRuleL(rule1);

   891 	newRules->AddRuleL(rule2);

   892 	

   893 	CTzUserNames* newNames = CTzUserNames::NewLC(KStandardName2(), KShortStandardName2(), KDaylightSaveName2(), 

   894 	KShortDaylightSaveName2(), KCityNameName2(), KRegionName2());

   895 	CTzId* newId = iUserData->CreateL(*newRules, *newNames);

   896 	tzid = newId->TimeZoneNumericID();

   897 	delete newId;

   898 	CleanupStack::PopAndDestroy(2, newRules);

   899 	// Add a city to the new zone

   900 	test.Printf(_L("Add a city to the zone\n"));

   901 	CTzLocalizedCity*	city = localizer->AddCityL(tzid, KUserAddedCityName2);

   902 	delete city;

   903 	delete localizer;

   904 	// Fetch the cities and check the count

   905 	test.Printf(_L("Compare the cities retrieved from the table against the number expected\n"));

   906 	RPointerArray<CTzLocalizedCityRecord> cityRecords;

   907 	CleanupStack::PushL(TCleanupItem(CleanupCityPointerArray, &cityRecords));

   908 	iTz.LocalizationReadCitiesL(cityRecords);

   909 	test(cityRecords.Count() == 2);

   910 	CleanupStack::PopAndDestroy(&cityRecords);

   911 	

   912 	// Restore the file

   913 	test.Printf(_L("Restore the backed up file\n"));

   914 	TRAP(err, StartRestoreL());

   915 	test(err == KErrNone);

   916 	result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;

   917 	test(result);

   918 	TRAP(err, EndRestoreL());

   919 	test(err == KErrNone);

   920 	// Fetch the cities from the backed up file and check the count

   921 	test.Printf(_L("Again, compare the cities retrieved from the table against the number expected\n"));

   922 	RPointerArray<CTzLocalizedCityRecord> cityRecords2;

   923 	CleanupStack::PushL(TCleanupItem(CleanupCityPointerArray, &cityRecords2));

   924 	iTz.LocalizationReadCitiesL(cityRecords2);

   925 	test(cityRecords2.Count() == 0);

   926 	CleanupStack::PopAndDestroy(&cityRecords2);

   927 	}

   928 

   929 /* Test the update of the cached system time zone rules in Tz server after restore the user defined tz DB 

   930  * There are three scenarios are to be tested:

   931  * case 1. Set the Shanghai, which is in the existing database, as the current time zone  

   932  *    The current time zone should be not be affected after restore the user defined tz DB.

   933  * case 2. Set the current time zone to a user defined time zone.

   934  * 	  The current time zone should be reset to the same time zone after restore the user defined tz DB which have the current time zone rules. 

   935  * case 3. Set the current time zone to a user defined time zone.

   936  * 	  The current time zone should be reset to the default time zone London after restore the user defined tz DB which doesn't have the current time zone rules. 	

   937  */

   938 void CTestUserDefinedBackupRestore::TestSystemRulesUpdateAfterRestoreL()

   939 	{

   940 	CTzId* tzid = NULL;

   941 	TUint tzNumId = 0;

   942 	

   943 	_LIT8(KTzShangHai, "Asia/Shanghai");

   944 	tzid = CTzId::NewL(KTzShangHai);

   945 	iTz.SetTimeZoneL(*tzid);

   946 	tzNumId = tzid->TimeZoneNumericID();

   947 	delete tzid;

   948 	

   949 	//case 1

   950 	test(TestSystemRulesUpdateAfterRestoreL(tzNumId, EFalse));

   951 	

   952 	test.Printf(_L("Add a user-defined zone\n"));

   953 	TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust,  ETzFixedDate, 0,  0, ETzWallTimeReference, 120);

   954 	TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);

   955 	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

   956 	CleanupStack::PushL(rules);

   957 	rules->AddRuleL(rule1);

   958 	rules->AddRuleL(rule2);

   959 	CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),

   960 	KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());

   961 	tzid = iUserData->CreateL(*rules, *names);

   962 	CleanupStack::PopAndDestroy(2, rules);

   963 	CleanupStack::PushL(tzid);

   964 	iTz.SetTimeZoneL(*tzid);

   965 	tzNumId = tzid->TimeZoneNumericID();

   966 	CleanupStack::PopAndDestroy(tzid);

   967 	

   968 	//case 2

   969 	test(TestSystemRulesUpdateAfterRestoreL(tzNumId, EFalse));

   970 	

   971 	//case 3

   972 	test(TestSystemRulesUpdateAfterRestoreL(KLondonTzId, ETrue));

   973 	}

   974 

   975 

   976 TBool CTestUserDefinedBackupRestore::TestSystemRulesUpdateAfterRestoreL(TUint aExpectedTzId, TBool aRestoreEmptyFile)

   977 	{

   978 	test.Next(_L("Test that the system cached rules updated correctly after a restore"));

   979 	

   980 	// Backup the user defined data file

   981 	test.Printf(_L("Backup the user defined data file\n"));

   982 	TRAPD(err, StartBackupL());

   983 	test(err==KErrNone);

   984 	TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);

   985 	test(result);

   986 	TRAP(err, EndBackupL());

   987 	test(err == KErrNone);

   988 	

   989 	// Restore the file

   990 	test.Printf(_L("Restore the backed up file\n"));

   991 	TRAP(err, StartRestoreL());

   992 	test(err == KErrNone);

   993 	if(aRestoreEmptyFile)

   994 		{

   995 		//Copy a empty user database to be restored

   996 		_LIT(KTzUserDataEmptyFile, "z:\\testresourcefiles\\tz_userdata_empty.db");

   997 		iServ.CopyFileL(KTzUserDataEmptyFile, KTzTestBackupFile);

   998 		}

   999 	result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;

  1000 	test(result);

  1001 	TRAP(err, EndRestoreL());

  1002 	test(err == KErrNone);

  1003 	test.Printf(_L("Get the current time zone and check if it is the expected one\n"));

  1004 	CTzId* tzid = iTz.GetTimeZoneIdL();

  1005 	TUint numId = tzid->TimeZoneNumericID();

  1006 	delete tzid;

  1007 	return numId == aExpectedTzId;

  1008 	}

  1009 

  1010 

  1011 void CTestUserDefinedBackupRestore::RunTestsL()

  1012 	{

  1013 	_LIT(KTzServer,"Tzserver*");

  1014 	TRAP_IGNORE(iServ.KillProcessL(KTzServer));

  1015 	iServ.DeleteFileL(KTzBackupFileFullPath);

  1016 	User::LeaveIfError(iTz.Connect());

  1017 	iUserData = CTzUserData::NewL(iTz);

  1018 	test.Title();

  1019 	

  1020 	test.Start(_L("Test Access To User Defined Data During Backup"));

  1021 	ResetTzUserDataL();

  1022 	TestBackupAndRestoreUserDbL(EBackupTest);

  1023 

  1024 	test.Next(_L("Test Access To User Defined Data During Restore"));

  1025 	TestBackupAndRestoreUserDbL(ERestoreTest);	

  1026 

  1027 	test.Next(_L("Test Frequently Used Zones Update After Restore With Delete"));

  1028 	TestFrequentlyUsedZonesUpdateAfterRestoreDeleteL();

  1029 	

  1030 	test.Next(_L("Test Frequently Used Zones Update After Restore With Update"));

  1031 	TestFrequentlyUsedZonesUpdateAfterRestoreUpdateL();

  1032 

  1033 	test.Next(_L("Test Frequently Used Current Zones Update After Restore With Update"));

  1034 	TestFrequentlyUsedCurrentZonesUpdateAfterRestoreUpdateL();

  1035 

  1036 	test.Next(_L("Test User Cities Update After Restore"));

  1037 	TestUserCitiesUpdateAfterRestoreL();

  1038 	

  1039 	test.Next(_L("Test Update system Cached rules After Restore"));

  1040 	TestSystemRulesUpdateAfterRestoreL();

  1041 	

  1042 	test.Next(_L("Test Access To Localization  DB During Backup and Restore"));

  1043 	TestBackupAndRestoreLocDbL();	

  1044 

  1045 	ResetTzUserDataL();	

  1046 	test.End();

  1047 

  1048 	iTz.Close();	

  1049 	TRAP_IGNORE(iServ.KillProcessL(KTzServer));

  1050 	iServ.DeleteFileL(KTzBackupFileFullPath);

  1051 	iServ.DeleteFileL(KPerFile1);

  1052 	iServ.DeleteFileL(KPerFile2);

  1053 	}

  1054 

  1055 	

  1056 static void DoTestsL()

  1057 	{

  1058 	BackupClient = conn::CSBEClient::NewL();

  1059 	CleanupStack::PushL(BackupClient);

  1060 

  1061 	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

  1062 	CleanupStack::PushL(scheduler);

  1063 	CActiveScheduler::Install(scheduler);

  1064 	

  1065 	CTestUserDefinedBackupRestore* backupRestore = CTestUserDefinedBackupRestore::NewL();

  1066 	CleanupStack::PushL(backupRestore);

  1067 

  1068 	backupRestore->RunTestsL();

  1069 

  1070 	// cleanup

  1071 	CleanupStack::PopAndDestroy(backupRestore);

  1072 	CleanupStack::PopAndDestroy(scheduler);

  1073 	CleanupStack::PopAndDestroy(BackupClient);

  1074 	}

  1075 

  1076 

  1077 GLDEF_C TInt E32Main()

  1078     {

  1079 	__UHEAP_MARK;

  1080 

  1081 	CTrapCleanup* cleanup = CTrapCleanup::New();

  1082 	if	(!cleanup)

  1083 		{

  1084 		return KErrNoMemory;

  1085 		}

  1086 

  1087 	TRAPD(ret, DoTestsL());

  1088 	test.Printf(_L("Trapped return value from DoTestsL(): %d\n"), ret);		

  1089 	test(ret == KErrNone);

  1090 	

  1091 	test.Close();

  1092 	

  1093 	delete cleanup;

  1094 

  1095 	__UHEAP_MARKEND;

  1096 

  1097 	return KErrNone;

  1098     }