--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tzservices/tzserver/test/component/tz_backup.cpp Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,1098 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <connect/sbeclient.h>
+#include <e32test.h>
+#include "tzuserdata.h"
+#include <tzlocalizer.h>
+#include "testserver.h"
+#include <tzlocalizedcityrecord.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <tzusernames.h>
+#include <tzuserdefineddata.h>
+#endif
+#include "tzidinternal.h"
+
+_LIT(KBackupTest, "Tz Backup");
+RTest test(KBackupTest);
+
+// Literal constants
+_LIT(KTzTestBackupFile, "C:\\Backup__tzuserdata.db");
+_LIT(KTzBackupFileFullPath, "C:\\private\\1020383e\\SQLite__tzuserdata.db");
+
+_LIT(KTzTestBackupLocDb, "C:\\Backup__TzLocalization.db");
+_LIT(KTzBackupLocDbFullPath, "C:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");
+
+_LIT(KTimeZoneBackupRegistrationFullPath, "Z:\\private\\1020383E\\backup_registration.xml");
+
+_LIT(KPerFile1,"c:\\private\\100012a5\\DBS_2000836D_DBS_DSC.db");
+_LIT(KPerFile2,"c:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");
+
+_LIT(KStandardName1, "UserTzName1");
+_LIT(KShortStandardName1, "UserTzSh1");
+_LIT(KDaylightSaveName1, "UserDLSaveName1");
+_LIT(KShortDaylightSaveName1, "UserShDLS1");
+_LIT(KCityNameName1, "UserCityName1");
+_LIT(KRegionName1, "UserRegionName1");
+
+_LIT(KStandardName2, "UserTzName2");
+_LIT(KShortStandardName2, "UserTzSh2");
+_LIT(KDaylightSaveName2, "UserDLSaveName2");
+_LIT(KShortDaylightSaveName2, "UserShDLS2");
+_LIT(KCityNameName2, "UserCityName2");
+_LIT(KRegionName2, "UserRegionName2");
+
+_LIT(KUserAddedCityName1, "UserAddedCity1");
+_LIT(KUserAddedCityName2, "UserAddedCity2");
+
+const TInt KLondonTzId = 2592;
+const TInt KParisTzId = 2656;
+
+static conn::CSBEClient* BackupClient;
+static TDriveList DriveList;
+
+class CTestUserDefinedBackupRestore : public CBase
+ {
+public:
+ static CTestUserDefinedBackupRestore* NewL();
+ ~CTestUserDefinedBackupRestore();
+
+enum TTest
+ {
+ EBackupTest,
+ ERestoreTest
+ };
+
+ void RunTestsL();
+ void TestBackupAndRestoreUserDbL(TTest aTest);
+ void TestFrequentlyUsedZonesUpdateAfterRestoreDeleteL();
+ void TestFrequentlyUsedZonesUpdateAfterRestoreUpdateL();
+ void TestUserCitiesUpdateAfterRestoreL();
+ void TestFrequentlyUsedCurrentZonesUpdateAfterRestoreUpdateL();
+ void TestSystemRulesUpdateAfterRestoreL();
+ void TestBackupAndRestoreLocDbL();
+private:
+ CTestUserDefinedBackupRestore();
+ TBool CheckXMLRegistrationFileL();
+ TBool SimulateTzBackup(const TDesC& aSrcfile, const TDesC& aDestfile);
+ TBool SimulateTzRestore(const TDesC& aSrcfile, const TDesC& aDestfile);
+ void ConstructL();
+ void ResetTzUserDataL();
+ TBool TestSystemRulesUpdateAfterRestoreL(TUint aExpectedTzId, TBool aRestoreEmptyFile);
+ TBool LocDbWriteFunctionL(CTzLocalizer& aTzLocalizer, TInt aExpectedErr);
+
+ TBool CompareFrequentlyUsedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare);
+ TBool CompareFrequentlyUsedZone(const CTzLocalizedTimeZone& aZone, const CTzLocalizedTimeZone& aZoneToCompare);
+ TBool CompareFrequentlyUsedCityAfterUpdate(TInt aId, const CTzLocalizedCity& aCity);
+ TBool CompareFrequentlyUsedCityRestoredAfterUpdate(TInt aId, const CTzLocalizedCity& aCity);
+ TBool CompareFrequentlyUsedZoneAfterUpdate(TInt aId, const CTzLocalizedTimeZone& aZone);
+
+//Member
+public:
+ CTzUserData* iUserData;
+ RFs iFs;
+ RPIMTestServer iServ;
+ RTz iTz;
+ };
+
+// building block test backup and restore functions
+
+static void StartBackupL()
+ {
+ /* Use the Secure Backup Engine API to "start" a backup. The backup
+ happens indirectly through CTzUserDataDb::BackupBeginningL()/
+ BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
+ These methods are implementations for MBackupRestoreNotificatioObserver
+ which monitors changes in the P&S property conn::KUidBackupRestoreKey.
+ This P&S property is changed by calling the Secure Backup Engine API
+ below.
+ */
+ test.Printf(_L("Starting Backup\n"));
+ BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase);
+ User::After(3000000);// Wait a bit to allow the server to close the database
+ }
+
+
+static void EndBackupL()
+ {
+ /* Use the Secure Backup Engine API to "end" a backup. The backup ends
+ indirectly through CTzUserDataDb::BackupBeginningL()/
+ BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
+ These methods are implementations for MBackupRestoreNotificatioObserver
+ which monitors changes in the P&S property conn::KUidBackupRestoreKey.
+ This P&S property is changed by calling the Secure Backup Engine API
+ below.
+ */
+ test.Printf(_L("Finishing Backup\n"));
+ BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);
+ User::After(3000000);// Wait a bit to allow the server to open the database
+ }
+
+
+static void StartRestoreL()
+ {
+ /* Use the Secure Backup Engine API to "start" a restore.
+ This happens indirectly through CTzUserDataDb::BackupBeginningL()/
+ BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
+ These methods are implementations for MBackupRestoreNotificatioObserver
+ which monitors changes in the P&S property conn::KUidBackupRestoreKey.
+ This P&S property is changed by calling the Secure Backup Engine API
+ below.
+ */
+ test.Printf(_L("Starting restore\n"));
+ BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase);
+ User::After(3000000);// Wait a bit to allow the server to close the database
+ }
+
+
+static void EndRestoreL()
+ {
+ /* Use the Secure Backup Engine API to "end" a restore.
+ This happens indirectly through CTzUserDataDb::BackupBeginningL()/
+ BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
+ These methods are implementations for MBackupRestoreNotificatioObserver
+ which monitors changes in the P&S property conn::KUidBackupRestoreKey.
+ This P&S property is changed by calling the Secure Backup Engine API
+ below.
+ */
+ test.Printf(_L("Finishing restore\n"));
+ BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);
+ User::After(3000000);// Wait a bit to allow the server to open and update the database
+ }
+
+LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr)
+ {
+ RPointerArray<CTzId>* ids = static_cast<RPointerArray<CTzId>*>(aPtr);
+ if (ids)
+ {
+ ids->ResetAndDestroy();
+ }
+ }
+
+LOCAL_D void CleanupCityPointerArray(TAny* aPtr)
+ {
+ RPointerArray<CTzLocalizedCityRecord>* ids = static_cast<RPointerArray<CTzLocalizedCityRecord>*>(aPtr);
+ if (ids)
+ {
+ ids->ResetAndDestroy();
+ }
+ }
+
+/** Access to user defined time zone data during backup or restore operation
+@SYMTestCaseID PIM-TTZBACKUP-TZS-BR-0001
+@SYMTestCaseDesc The purpose of this test is to verify the behaviour of the
+ client APIs that access user defined time zones during a backup or restore operation.
+@SYMTestActions
+1. Create a user defined time zone.
+2. Simulate start of backup or restore operation.
+3. Access (read, update, delete) the user defined time zone created in action 1. 1
+4. Create a user defined time zone. 2
+5. Simulate end of backup or restore operation.
+6. Access (read, update, delete) the user defined time zone created in action 1. 3
+7. Create a user defined time zone. 4
+
+@SYMTestExpectedResults In step 3 and 4, operation leaves with KErrLocked
+ In step 6 and 7, operation completes without error
+
+@SYMTestType CT
+@SYMTestPriority 1
+*/
+
+CTestUserDefinedBackupRestore::CTestUserDefinedBackupRestore()
+ {
+
+ }
+
+CTestUserDefinedBackupRestore* CTestUserDefinedBackupRestore::NewL()
+ {
+ CTestUserDefinedBackupRestore* self = new(ELeave) CTestUserDefinedBackupRestore();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CTestUserDefinedBackupRestore::ConstructL()
+ {
+ User::LeaveIfError(iFs.Connect());
+ User::LeaveIfError(iServ.Connect());
+ iServ.CloseTzSession();
+ }
+
+CTestUserDefinedBackupRestore::~CTestUserDefinedBackupRestore()
+ {
+ delete iUserData;
+ iFs.Delete(KTzTestBackupFile);
+ // delete database file
+ iFs.Delete(KTzBackupFileFullPath);
+ iFs.Close();
+ iServ.Close();
+ }
+
+void CTestUserDefinedBackupRestore::ResetTzUserDataL()
+ {
+ RPointerArray<CTzId> ids;
+ CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids));
+ iUserData->GetTzIdsL(ids);
+ TInt count = ids.Count();
+ for (TInt ii=0; ii<count; ++ii)
+ {
+ iUserData->DeleteL(*ids[ii]);
+ }
+ CleanupStack::PopAndDestroy(&ids);
+ }
+
+TBool CTestUserDefinedBackupRestore::CheckXMLRegistrationFileL()
+ {
+ TEntry entry;
+
+ TInt error = iFs.Entry(KTimeZoneBackupRegistrationFullPath, entry);
+
+ if (error == KErrNotFound)
+ {
+ return EFalse;
+ }
+
+ User::LeaveIfError(error);
+
+ if(entry.iSize == 0)
+ {
+ // file is present but is empty
+ User::Leave(KErrCorrupt);
+ }
+
+ // found the registration file
+ return ETrue;
+ }
+
+TBool CTestUserDefinedBackupRestore::SimulateTzBackup(const TDesC& aSrcfile, const TDesC& aDestfile)
+ {
+ TRAPD(error, iServ.CopyFileL(aSrcfile, aDestfile));
+
+ if (error != KErrNone)
+ {
+ test.Printf(_L("Copy failed with error %i"), error);
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CTestUserDefinedBackupRestore::SimulateTzRestore(const TDesC& aSrcfile, const TDesC& aDestfile)
+ {
+ // Backup tz user-defined database file.
+ TRAPD(error, iServ.CopyFileL(aSrcfile ,aDestfile));
+
+ if (error != KErrNone)
+ {
+ test.Printf(_L("Copy failed with error %i"), error);
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare)
+ {
+ if(aCity.TimeZoneId() != aCityToCompare.TimeZoneId())
+ {
+ return EFalse;
+ }
+ if(aCity.GroupId() != aCityToCompare.GroupId())
+ {
+ return EFalse;
+ }
+ if(aCity.Name() != aCityToCompare.Name())
+ {
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedZone(const CTzLocalizedTimeZone& aZone, const CTzLocalizedTimeZone& aZoneToCompare)
+ {
+ if(aZone.TimeZoneId() != aZoneToCompare.TimeZoneId())
+ {
+ return EFalse;
+ }
+ if(aZone.StandardName() != aZoneToCompare.StandardName())
+ {
+ return EFalse;
+ }
+ if(aZone.ShortStandardName() != aZoneToCompare.ShortStandardName())
+ {
+ return EFalse;
+ }
+ if(aZone.DaylightName() != aZoneToCompare.DaylightName())
+ {
+ return EFalse;
+ }
+ if(aZone.ShortDaylightName() != aZoneToCompare.ShortDaylightName())
+ {
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCityAfterUpdate(TInt aId, const CTzLocalizedCity& aCity)
+ {
+ if(aCity.TimeZoneId() != aId)
+ {
+ return EFalse;
+ }
+ if(aCity.GroupId() != 0)
+ {
+ return EFalse;
+ }
+ if(aCity.Name() != KCityNameName2)
+ {
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedCityRestoredAfterUpdate(TInt aId, const CTzLocalizedCity& aCity)
+ {
+ if(aCity.TimeZoneId() != aId)
+ {
+ return EFalse;
+ }
+ if(aCity.GroupId() != 0)
+ {
+ return EFalse;
+ }
+ if(aCity.Name() != KCityNameName1)
+ {
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CTestUserDefinedBackupRestore::CompareFrequentlyUsedZoneAfterUpdate(TInt aId, const CTzLocalizedTimeZone& aZone)
+ {
+ if(aZone.TimeZoneId() != aId)
+ {
+ return EFalse;
+ }
+ if(aZone.StandardName() != KStandardName1)
+ {
+ return EFalse;
+ }
+ if(aZone.ShortStandardName() != KShortStandardName1)
+ {
+ return EFalse;
+ }
+ if(aZone.DaylightName() != KDaylightSaveName1)
+ {
+ return EFalse;
+ }
+ if(aZone.ShortDaylightName() != KShortDaylightSaveName1)
+ {
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+void CTestUserDefinedBackupRestore::TestBackupAndRestoreUserDbL(TTest aTest)
+ {
+ TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust, ETzFixedDate, 0, 0, ETzWallTimeReference, 120);
+ TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);
+
+ CTzRules* rules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(rules);
+ rules->AddRuleL(rule1);
+ rules->AddRuleL(rule2);
+
+ TBuf<20> stdName;
+ stdName.Format(_L("StdName1"));
+ TBuf<20> shortStdName;
+ shortStdName.Format(_L("ShortStd1"));
+ TBuf<20> dstName;
+ dstName.Format(_L("DstName1"));
+ TBuf<20> shortDstName;
+ shortDstName.Format(_L("ShortDst1"));
+ TBuf<20> cityName;
+ cityName.Format(_L("CityName1"));
+ TBuf<20> regionName;
+ regionName.Format(_L("RegionName1"));
+
+ CTzUserNames* names = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);
+
+ CTzId* id = NULL;
+ id = iUserData->CreateL(*rules, *names);
+
+ CleanupStack::PopAndDestroy(2, rules);
+ CleanupStack::PushL(id);
+
+ TBool file = CheckXMLRegistrationFileL();
+ test(file);
+
+ if(aTest == EBackupTest)
+ {
+ TRAPD(err, StartBackupL());
+ test(err==KErrNone);
+ TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);
+ test(result);
+ }
+ else
+ {
+ TRAPD(err, StartRestoreL());
+ test(err == KErrNone);
+
+ TBool result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;
+ test(result);
+
+ CleanupStack::PopAndDestroy(id);
+ // Setting back to initial id as the database
+ // copied during restore will not have all the changes
+ // that happened afterwards
+ id = CTzId::NewL(KUserTzIdMin);
+ CleanupStack::PushL(id);
+ }
+
+ test.Printf(_L("Now try reading the names of the created zone\n"));
+
+ CTzUserNames* readNames = NULL;
+ TRAPD(err, readNames = iUserData->ReadNamesL(*id));
+ delete readNames;
+
+ test(err == KErrLocked);
+ test.Printf(_L("Could not read names as backup/restore is in progress\n"));
+
+ test.Printf(_L("Now try reading the rules of the created zone\n"));
+
+ CTzRules* readRules = NULL;
+ TRAP(err, readRules = iUserData->ReadRulesL(*id));
+ delete readRules;
+
+ test(err == KErrLocked);
+ test.Printf(_L("Could not read rules as backup/restore is in progress\n"));
+
+ test.Printf(_L(" @SYMTestCaseID PIM-TTZBACKUP-TZS-BR-0001 Now try reading the TZIDs of all user-defined time zone data\n"));
+
+ RPointerArray<CTzId> tzIds;
+ TRAP(err, iUserData->GetTzIdsL(tzIds));
+ tzIds.ResetAndDestroy();
+ tzIds.Close();
+
+ test(err == KErrLocked);
+ test.Printf(_L("Could not read TZIDs as backup/restore is in progress\n"));
+
+ TTzRule rule3(1981,1996,0,60,EMarch,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);
+ TTzRule rule4(1981,1996,60,0,EOctober,ETzDayInLastWeekOfMonth,0,ESunday,ETzUtcTimeReference,60);
+
+ CTzRules* rulesAdd = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(rulesAdd);
+ rulesAdd->AddRuleL(rule3);
+ rulesAdd->AddRuleL(rule4);
+
+ stdName.Format(_L("StdName2"));
+ shortStdName.Format(_L("ShortStd2"));
+ dstName.Format(_L("DstName2"));
+ shortDstName.Format(_L("ShortDst2"));
+ cityName.Format(_L("CityName2"));
+ regionName.Format(_L("RegionName2"));
+
+ CTzUserNames* namesAdd = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);
+ CTzId* tzId = NULL;
+ TRAP(err, tzId = iUserData->CreateL(*rulesAdd, *namesAdd));
+ delete tzId;
+ test(err == KErrLocked);
+
+ TRAP(err, iUserData->UpdateL(*id, *rulesAdd, *namesAdd));
+ test(err == KErrLocked);
+ test.Printf(_L("Could not update user-defined rules as backup/restore is in progress\n"));
+
+ TRAP(err, iUserData->DeleteL((*id)));
+ test(err == KErrLocked);
+ test.Printf(_L("Could not delete user-defined rules as backup/restore is in progress\n"));
+
+ CleanupStack::PopAndDestroy(namesAdd);
+ CleanupStack::PopAndDestroy(rulesAdd);
+
+ if(aTest == EBackupTest)
+ {
+ // backup complete
+ TRAP(err, EndBackupL());
+ test(err == KErrNone);
+ }
+ else
+ {
+ // restore complete
+ TRAP(err, EndRestoreL());
+ test(err == KErrNone);
+ }
+
+ test.Printf(_L("Check if we can perform CRUD operations on user-defined rules\n"));
+ CTzUserNames* readNamesAgain = NULL;
+
+ TRAPD(ret, readNamesAgain = iUserData->ReadNamesL(*(id)));
+ test(ret == KErrNone);
+ test.Printf(_L("Successfully read user-defined rules after backup/restore has completed\n"));
+
+ delete readNamesAgain;
+ CleanupStack::PopAndDestroy();
+
+ CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(newRules);
+ newRules->AddRuleL(rule3);
+ newRules->AddRuleL(rule4);
+
+ stdName.Format(_L("StdName3"));
+ shortStdName.Format(_L("ShortStd3"));
+ dstName.Format(_L("DstName3"));
+ shortDstName.Format(_L("ShortDst3"));
+ cityName.Format(_L("CityName3"));
+ regionName.Format(_L("RegionName3"));
+
+ CTzUserNames* newNames = CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName);
+ CTzId* newId = NULL;
+ TRAP(err, newId = iUserData->CreateL(*newRules, *newNames));
+ test(err == KErrNone);
+ test.Printf(_L("Successfully created user-defined rules after backup/restore has completed\n"));
+
+ TRAP(err, iUserData->UpdateL(*newId, *newRules, *newNames));
+ test(err == KErrNone);
+ test.Printf(_L("Successfully updated user-defined rules after backup/restore has completed\n"));
+
+ TRAP(err, iUserData->DeleteL(*newId));
+ test(err == KErrNone);
+ test.Printf(_L("Successfully deleted user-defined rules after backup/restore has completed\n"));
+
+ CleanupStack::PopAndDestroy(newNames);
+ CleanupStack::PopAndDestroy(newRules);
+ delete newId;
+ }
+
+void CTestUserDefinedBackupRestore::TestBackupAndRestoreLocDbL()
+ {
+ test.Printf(_L("Start to backup or restore localization DB which should lock the file\n"));
+ CTzLocalizer* localizer = NULL;
+ //Make sure the localization DB exists
+ localizer = CTzLocalizer::NewL();
+ delete localizer;
+ localizer = NULL;
+
+ //Verify that the client can not create an object of CTzLocalizer when backup or restroe starts
+ StartBackupL();
+ test(SimulateTzBackup(KTzBackupLocDbFullPath, KTzTestBackupLocDb));
+ TRAPD(err, localizer = CTzLocalizer::NewL());
+ test (err == KErrLocked);
+ test (!localizer);
+ EndBackupL();
+ StartRestoreL();
+ test(SimulateTzRestore(KTzTestBackupLocDb, KTzBackupLocDbFullPath) );
+ TRAP(err, localizer = CTzLocalizer::NewL());
+ test(err == KErrLocked);
+ test (!localizer);
+ EndRestoreL();
+
+ localizer = CTzLocalizer::NewL();
+ CleanupStack::PushL(localizer);
+ //Verify that functions which requires writing to the localization file are locked when backup or restore starts
+ StartBackupL();
+ test(SimulateTzBackup(KTzBackupLocDbFullPath, KTzTestBackupLocDb));
+ test(LocDbWriteFunctionL(*localizer, KErrLocked));
+ EndBackupL();
+ test(LocDbWriteFunctionL(*localizer, KErrNone));
+ StartRestoreL();
+ test(SimulateTzRestore(KTzTestBackupLocDb, KTzBackupLocDbFullPath) );
+ test(LocDbWriteFunctionL(*localizer, KErrLocked));
+ EndRestoreL();
+ test(LocDbWriteFunctionL(*localizer, KErrNone));
+ CleanupStack::PopAndDestroy(localizer);
+ }
+
+TBool CTestUserDefinedBackupRestore::LocDbWriteFunctionL(CTzLocalizer& aTzLocalizer, TInt aExpectedErr)
+ {
+ TRAPD(err, aTzLocalizer.SetFrequentlyUsedZoneL(KLondonTzId,CTzLocalizedTimeZone::EHomeZone));
+ if(aExpectedErr != err)
+ {
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+void CTestUserDefinedBackupRestore::TestFrequentlyUsedZonesUpdateAfterRestoreDeleteL()
+ {
+ // Backup the file before we added the user defined time zones
+ test.Printf(_L("Backup the file without any user-defined zones\n"));
+ _LIT8(KLondon, "Europe/London");
+ CTzId* tzid = CTzId::NewL(KLondon);
+ iTz.SetTimeZoneL(*tzid);
+ delete tzid;
+
+ TRAPD(err, StartBackupL());
+ test(err==KErrNone);
+ TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);
+ test(result);
+ TRAP(err, EndBackupL());
+ test(err == KErrNone);
+
+ // Add a user defined time zone
+ test.Printf(_L("Add a user-defined zone\n"));
+ TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust, ETzFixedDate, 0, 0, ETzWallTimeReference, 120);
+ TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);
+ CTzRules* rules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(rules);
+ rules->AddRuleL(rule1);
+ rules->AddRuleL(rule2);
+
+ CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),
+ KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());
+ CTzId* id = iUserData->CreateL(*rules, *names);
+ CleanupStack::PopAndDestroy(2, rules);
+ CleanupStack::PushL(id);
+
+ // Add this time zone in the frequently used zone table
+ CTzLocalizer* localizer = CTzLocalizer::NewL();
+ test.Printf(_L("Set the user-defined zone as the frequently used zone\n"));
+ localizer->SetFrequentlyUsedZoneL(id->TimeZoneNumericID(), CTzLocalizedTimeZone::EHomeZone);
+ CleanupStack::PopAndDestroy(id);
+
+ // Restore the file
+ test.Printf(_L("Restore the backed up file\n"));
+ TRAP(err, StartRestoreL());
+ test(err == KErrNone);
+ result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;
+ test(result);
+ TRAP(err, EndRestoreL());
+ test(err == KErrNone);
+
+ CTzLocalizedCity* cityToCompareWith = localizer->GetDefaultCityL(KLondonTzId);
+ CleanupStack::PushL(cityToCompareWith);
+
+ test.Printf(_L("Fetch the frequently used city and check if it is the expected one\n"));
+ CTzLocalizedCity* city = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EHomeZone);
+ test(CompareFrequentlyUsedCity(*city, *cityToCompareWith));
+ delete city;
+
+ CTzLocalizedTimeZone* zoneToCompareWith = localizer->GetLocalizedTimeZoneL(KLondonTzId);
+ CleanupStack::PushL(zoneToCompareWith);
+
+ CTzLocalizedTimeZone* timeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::EHomeZone);
+ test.Printf(_L("Fetch the frequently used zone and check if it is the expected one\n"));
+ test(CompareFrequentlyUsedZone(*timeZone, *zoneToCompareWith));
+ delete timeZone;
+
+ delete localizer;
+ CleanupStack::PopAndDestroy(2, cityToCompareWith);
+ }
+
+void CTestUserDefinedBackupRestore::TestFrequentlyUsedZonesUpdateAfterRestoreUpdateL()
+ {
+ // Add a user defined time zone
+ test.Printf(_L("Create a user-defined zone\n"));
+ TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust, ETzFixedDate, 0, 0, ETzWallTimeReference, 120);
+ TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);
+
+ CTzRules* rules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(rules);
+ rules->AddRuleL(rule1);
+ rules->AddRuleL(rule2);
+
+ CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),
+ KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());
+ CTzId* id = iUserData->CreateL(*rules, *names);
+ CleanupStack::PopAndDestroy(2, rules);
+
+ CleanupStack::PushL(id);
+
+ // Backup the file before we added the user defined time zones
+ test.Printf(_L("Backup the user-defined database\n"));
+ TRAPD(err, StartBackupL());
+ test(err==KErrNone);
+ TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);
+ test(result);
+ TRAP(err, EndBackupL());
+ test(err == KErrNone);
+
+ // Update the user defined time zone
+ test.Printf(_L("Update the user-defined rule\n"));
+ CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(newRules);
+ newRules->AddRuleL(rule1);
+ newRules->AddRuleL(rule2);
+
+ //Create a user defined rule names for update
+ CTzUserNames* newNames = CTzUserNames::NewLC(KStandardName2(), KShortStandardName2(),
+ KDaylightSaveName2(), KShortDaylightSaveName2(), KCityNameName2(), KRegionName2());
+ iUserData->UpdateL(*id, *newRules, *newNames);
+ CleanupStack::PopAndDestroy(2, newRules);
+
+ // Add this time zone in the frequently used zone table
+ CTzLocalizer* localizer = CTzLocalizer::NewL();
+ test.Printf(_L("Set the new zone as the frequently used zone\n"));
+ localizer->SetFrequentlyUsedZoneL(id->TimeZoneNumericID(), CTzLocalizedTimeZone::EHomeZone);
+ test.Printf(_L("Fetch the frequently used city and check if it is the expected one\n"));
+ CTzLocalizedCity* city = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EHomeZone);
+ test(CompareFrequentlyUsedCityAfterUpdate(id->TimeZoneNumericID(), *city));
+ delete city;
+
+ // Restore the file
+ test.Printf(_L("Restore the backed up file\n"));
+ TRAP(err, StartRestoreL());
+ test(err == KErrNone);
+ result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;
+ test(result);
+ TRAP(err, EndRestoreL());
+ test(err == KErrNone);
+
+ test.Printf(_L("Get the frequently used city and check if it is the expected one\n"));
+ CTzLocalizedCity* updatedCity = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EHomeZone);
+ test(CompareFrequentlyUsedCityRestoredAfterUpdate(id->TimeZoneNumericID(), *updatedCity));
+ delete updatedCity;
+ test.Printf(_L("Get the frequently used zone and check if it is the expected one\n"));
+ CTzLocalizedTimeZone* timeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::EHomeZone);
+ test(CompareFrequentlyUsedZoneAfterUpdate(id->TimeZoneNumericID(), *timeZone));
+ delete timeZone;
+
+ CleanupStack::PopAndDestroy(id);
+ delete localizer;
+ }
+
+void CTestUserDefinedBackupRestore::TestFrequentlyUsedCurrentZonesUpdateAfterRestoreUpdateL()
+ {
+ // Add a user defined time zone
+ test.Printf(_L("Create a user-defined zone\n"));
+ TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust, ETzFixedDate, 0, 0, ETzWallTimeReference, 120);
+ TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);
+
+ CTzRules* rules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(rules);
+ rules->AddRuleL(rule1);
+ rules->AddRuleL(rule2);
+
+ CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),
+ KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());
+ CTzId* id = iUserData->CreateL(*rules, *names);
+ TInt tzid = id->TimeZoneNumericID();
+ delete id;
+ CleanupStack::PopAndDestroy(2, rules);
+
+ // Backup the file before we added the user defined time zones
+ test.Printf(_L("Start the database backup\n"));
+ TRAPD(err, StartBackupL());
+ test(err==KErrNone);
+ TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);
+ test(result);
+ TRAP(err, EndBackupL());
+ test(err == KErrNone);
+
+ // Add user-defined rules
+ test.Printf(_L("Update the rule in the database\n"));
+ CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(newRules);
+ newRules->AddRuleL(rule1);
+ newRules->AddRuleL(rule2);
+
+ //Create a user defined rule names- CTzUserNames.
+ CTzUserNames* names2 = CTzUserNames::NewLC(KStandardName2(), KShortStandardName2(),
+ KDaylightSaveName2(), KShortDaylightSaveName2(), KCityNameName2(), KRegionName2());
+ CTzId* tzId = CTzId::NewL(tzid);
+ CleanupStack::PushL(tzId);
+ iUserData->UpdateL(*tzId, *rules, *names2);
+ CleanupStack::PopAndDestroy(tzId);
+ CleanupStack::PopAndDestroy(2, newRules);
+
+ // Set the time zone to Paris
+ test.Printf(_L("Set the time zone to Paris\n"));
+ CTzLocalizer* localizer = CTzLocalizer::NewL();
+ localizer->SetTimeZoneL(KParisTzId);
+
+ CTzLocalizedCity* cityToCompareWith = localizer->GetDefaultCityL(KParisTzId);
+ CleanupStack::PushL(cityToCompareWith);
+
+ // Read the frequently used city and compare with the expected one
+ test.Printf(_L("Get the frequently used city and check if it is the expected one\n"));
+ CTzLocalizedCity* city = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::ECurrentZone);
+ test(CompareFrequentlyUsedCity(*city, *cityToCompareWith));
+ delete city;
+
+ CTzLocalizedTimeZone* zoneToCompareWith = localizer->GetLocalizedTimeZoneL(KParisTzId);
+ CleanupStack::PushL(zoneToCompareWith);
+
+ test.Printf(_L("Get the frequently used zone and check if it is the expected one\n"));
+ CTzLocalizedTimeZone* timeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::ECurrentZone);
+ test(CompareFrequentlyUsedZone(*timeZone, *zoneToCompareWith));
+ delete timeZone;
+
+ // Restore the file
+ test.Printf(_L("Restore the backed up file\n"));
+ TRAP(err, StartRestoreL());
+ test(err == KErrNone);
+ result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;
+ test(result);
+ TRAP(err, EndRestoreL());
+ test(err == KErrNone);
+
+ test.Printf(_L("Again, get the frequently used city and check if it is the expected one\n"));
+ CTzLocalizedCity* updatedCity = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::ECurrentZone);
+ test(CompareFrequentlyUsedCity(*updatedCity, *cityToCompareWith));
+ delete updatedCity;
+
+ test.Printf(_L("Again, get the frequently used zone and check if it is the expected one\n"));
+ CTzLocalizedTimeZone* updatedTimeZone = localizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::ECurrentZone);
+ test(CompareFrequentlyUsedZone(*updatedTimeZone, *zoneToCompareWith));
+
+ delete updatedTimeZone;
+ delete localizer;
+ CleanupStack::PopAndDestroy(2, cityToCompareWith);
+ }
+
+void CTestUserDefinedBackupRestore::TestUserCitiesUpdateAfterRestoreL()
+ {
+ // Backup the file before we add the user defined time zones
+ test.Printf(_L("Start the backup of the user-defined database\n"));
+ TRAPD(err, StartBackupL());
+ test(err==KErrNone);
+ TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);
+ test(result);
+ TRAP(err, EndBackupL());
+ test(err == KErrNone);
+
+ // Add a user defined time zone
+ test.Printf(_L("Create a user-defined zone\n"));
+ TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust, ETzFixedDate, 0, 0, ETzWallTimeReference, 120);
+ TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);
+ CTzRules* rules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(rules);
+ rules->AddRuleL(rule1);
+ rules->AddRuleL(rule2);
+
+ CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),
+ KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());
+ CTzId* id = iUserData->CreateL(*rules, *names);
+ TInt tzid = id->TimeZoneNumericID();
+ delete id;
+ CleanupStack::PopAndDestroy(2, rules);
+
+ CTzLocalizer* localizer = CTzLocalizer::NewL();
+ // Add a city that uses this time zone
+ test.Printf(_L("Add a user-defined city to the zone\n"));
+ CTzLocalizedCity* userCity = localizer->AddCityL(tzid, KUserAddedCityName1);
+ delete userCity;
+
+ // Add a user defined time zone
+ test.Printf(_L("Add another rule to the database\n"));
+ CTzRules* newRules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(newRules);
+ newRules->AddRuleL(rule1);
+ newRules->AddRuleL(rule2);
+
+ CTzUserNames* newNames = CTzUserNames::NewLC(KStandardName2(), KShortStandardName2(), KDaylightSaveName2(),
+ KShortDaylightSaveName2(), KCityNameName2(), KRegionName2());
+ CTzId* newId = iUserData->CreateL(*newRules, *newNames);
+ tzid = newId->TimeZoneNumericID();
+ delete newId;
+ CleanupStack::PopAndDestroy(2, newRules);
+ // Add a city to the new zone
+ test.Printf(_L("Add a city to the zone\n"));
+ CTzLocalizedCity* city = localizer->AddCityL(tzid, KUserAddedCityName2);
+ delete city;
+ delete localizer;
+ // Fetch the cities and check the count
+ test.Printf(_L("Compare the cities retrieved from the table against the number expected\n"));
+ RPointerArray<CTzLocalizedCityRecord> cityRecords;
+ CleanupStack::PushL(TCleanupItem(CleanupCityPointerArray, &cityRecords));
+ iTz.LocalizationReadCitiesL(cityRecords);
+ test(cityRecords.Count() == 2);
+ CleanupStack::PopAndDestroy(&cityRecords);
+
+ // Restore the file
+ test.Printf(_L("Restore the backed up file\n"));
+ TRAP(err, StartRestoreL());
+ test(err == KErrNone);
+ result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;
+ test(result);
+ TRAP(err, EndRestoreL());
+ test(err == KErrNone);
+ // Fetch the cities from the backed up file and check the count
+ test.Printf(_L("Again, compare the cities retrieved from the table against the number expected\n"));
+ RPointerArray<CTzLocalizedCityRecord> cityRecords2;
+ CleanupStack::PushL(TCleanupItem(CleanupCityPointerArray, &cityRecords2));
+ iTz.LocalizationReadCitiesL(cityRecords2);
+ test(cityRecords2.Count() == 0);
+ CleanupStack::PopAndDestroy(&cityRecords2);
+ }
+
+/* Test the update of the cached system time zone rules in Tz server after restore the user defined tz DB
+ * There are three scenarios are to be tested:
+ * case 1. Set the Shanghai, which is in the existing database, as the current time zone
+ * The current time zone should be not be affected after restore the user defined tz DB.
+ * case 2. Set the current time zone to a user defined time zone.
+ * 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.
+ * case 3. Set the current time zone to a user defined time zone.
+ * 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.
+ */
+void CTestUserDefinedBackupRestore::TestSystemRulesUpdateAfterRestoreL()
+ {
+ CTzId* tzid = NULL;
+ TUint tzNumId = 0;
+
+ _LIT8(KTzShangHai, "Asia/Shanghai");
+ tzid = CTzId::NewL(KTzShangHai);
+ iTz.SetTimeZoneL(*tzid);
+ tzNumId = tzid->TimeZoneNumericID();
+ delete tzid;
+
+ //case 1
+ test(TestSystemRulesUpdateAfterRestoreL(tzNumId, EFalse));
+
+ test.Printf(_L("Add a user-defined zone\n"));
+ TTzRule rule1(0, KMaxTUint16, 60, 0, EAugust, ETzFixedDate, 0, 0, ETzWallTimeReference, 120);
+ TTzRule rule2(0,KMaxTUint16,0,60,EJanuary,ETzFixedDate,0,0,ETzWallTimeReference,120);
+ CTzRules* rules = CTzRules::NewL(0, KMaxTUint);
+ CleanupStack::PushL(rules);
+ rules->AddRuleL(rule1);
+ rules->AddRuleL(rule2);
+ CTzUserNames* names = CTzUserNames::NewLC(KStandardName1(), KShortStandardName1(), KDaylightSaveName1(),
+ KShortDaylightSaveName1(), KCityNameName1(), KRegionName1());
+ tzid = iUserData->CreateL(*rules, *names);
+ CleanupStack::PopAndDestroy(2, rules);
+ CleanupStack::PushL(tzid);
+ iTz.SetTimeZoneL(*tzid);
+ tzNumId = tzid->TimeZoneNumericID();
+ CleanupStack::PopAndDestroy(tzid);
+
+ //case 2
+ test(TestSystemRulesUpdateAfterRestoreL(tzNumId, EFalse));
+
+ //case 3
+ test(TestSystemRulesUpdateAfterRestoreL(KLondonTzId, ETrue));
+ }
+
+
+TBool CTestUserDefinedBackupRestore::TestSystemRulesUpdateAfterRestoreL(TUint aExpectedTzId, TBool aRestoreEmptyFile)
+ {
+ test.Next(_L("Test that the system cached rules updated correctly after a restore"));
+
+ // Backup the user defined data file
+ test.Printf(_L("Backup the user defined data file\n"));
+ TRAPD(err, StartBackupL());
+ test(err==KErrNone);
+ TBool result = SimulateTzBackup(KTzBackupFileFullPath, KTzTestBackupFile);
+ test(result);
+ TRAP(err, EndBackupL());
+ test(err == KErrNone);
+
+ // Restore the file
+ test.Printf(_L("Restore the backed up file\n"));
+ TRAP(err, StartRestoreL());
+ test(err == KErrNone);
+ if(aRestoreEmptyFile)
+ {
+ //Copy a empty user database to be restored
+ _LIT(KTzUserDataEmptyFile, "z:\\testresourcefiles\\tz_userdata_empty.db");
+ iServ.CopyFileL(KTzUserDataEmptyFile, KTzTestBackupFile);
+ }
+ result = SimulateTzRestore(KTzTestBackupFile, KTzBackupFileFullPath) ;
+ test(result);
+ TRAP(err, EndRestoreL());
+ test(err == KErrNone);
+ test.Printf(_L("Get the current time zone and check if it is the expected one\n"));
+ CTzId* tzid = iTz.GetTimeZoneIdL();
+ TUint numId = tzid->TimeZoneNumericID();
+ delete tzid;
+ return numId == aExpectedTzId;
+ }
+
+
+void CTestUserDefinedBackupRestore::RunTestsL()
+ {
+ _LIT(KTzServer,"Tzserver*");
+ TRAP_IGNORE(iServ.KillProcessL(KTzServer));
+ iServ.DeleteFileL(KTzBackupFileFullPath);
+ User::LeaveIfError(iTz.Connect());
+ iUserData = CTzUserData::NewL(iTz);
+ test.Title();
+
+ test.Start(_L("Test Access To User Defined Data During Backup"));
+ ResetTzUserDataL();
+ TestBackupAndRestoreUserDbL(EBackupTest);
+
+ test.Next(_L("Test Access To User Defined Data During Restore"));
+ TestBackupAndRestoreUserDbL(ERestoreTest);
+
+ test.Next(_L("Test Frequently Used Zones Update After Restore With Delete"));
+ TestFrequentlyUsedZonesUpdateAfterRestoreDeleteL();
+
+ test.Next(_L("Test Frequently Used Zones Update After Restore With Update"));
+ TestFrequentlyUsedZonesUpdateAfterRestoreUpdateL();
+
+ test.Next(_L("Test Frequently Used Current Zones Update After Restore With Update"));
+ TestFrequentlyUsedCurrentZonesUpdateAfterRestoreUpdateL();
+
+ test.Next(_L("Test User Cities Update After Restore"));
+ TestUserCitiesUpdateAfterRestoreL();
+
+ test.Next(_L("Test Update system Cached rules After Restore"));
+ TestSystemRulesUpdateAfterRestoreL();
+
+ test.Next(_L("Test Access To Localization DB During Backup and Restore"));
+ TestBackupAndRestoreLocDbL();
+
+ ResetTzUserDataL();
+ test.End();
+
+ iTz.Close();
+ TRAP_IGNORE(iServ.KillProcessL(KTzServer));
+ iServ.DeleteFileL(KTzBackupFileFullPath);
+ iServ.DeleteFileL(KPerFile1);
+ iServ.DeleteFileL(KPerFile2);
+ }
+
+
+static void DoTestsL()
+ {
+ BackupClient = conn::CSBEClient::NewL();
+ CleanupStack::PushL(BackupClient);
+
+ CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
+ CleanupStack::PushL(scheduler);
+ CActiveScheduler::Install(scheduler);
+
+ CTestUserDefinedBackupRestore* backupRestore = CTestUserDefinedBackupRestore::NewL();
+ CleanupStack::PushL(backupRestore);
+
+ backupRestore->RunTestsL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy(backupRestore);
+ CleanupStack::PopAndDestroy(scheduler);
+ CleanupStack::PopAndDestroy(BackupClient);
+ }
+
+
+GLDEF_C TInt E32Main()
+ {
+ __UHEAP_MARK;
+
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+ if (!cleanup)
+ {
+ return KErrNoMemory;
+ }
+
+ TRAPD(ret, DoTestsL());
+ test.Printf(_L("Trapped return value from DoTestsL(): %d\n"), ret);
+ test(ret == KErrNone);
+
+ test.Close();
+
+ delete cleanup;
+
+ __UHEAP_MARKEND;
+
+ return KErrNone;
+ }