diff -r 000000000000 -r 2e3d3ce01487 tzservices/tzloc/test/rtest/t_localizationuserdata.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tzservices/tzloc/test/rtest/t_localizationuserdata.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,1135 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include "testserver.h" +#include +#include +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#include +#endif + + +class CTzLocalizationUserDataSuite : public CBase + { +public: + static CTzLocalizationUserDataSuite* NewLC(); + ~CTzLocalizationUserDataSuite(); + void TestLocalizedTimeZoneL(); + void TestLocalizedTimeZoneWithLocalizeIDL(); + void TestLocalizedCityL(); + void TestDefaultCityL(); + void TestCityGroupL(); + void TestCityArrayL(); + void TestCurrentTimeZoneL(); + void TestFindTimeZoneL(); + void TestUserDataModificationL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aTimeZone); + void TestUserDataDeletionL(); + void TestUserDataDeletionCityImpactL(); + void TestUserDefinedTimeZoneL(); + +private: + CTzLocalizationUserDataSuite(); + void ConstructL(); + void ResetTzUserDataL(); + + CTzId* CreateTimeZoneL(); + CTzUserNames* CreateUserRuleAndGetNamesLC(TInt& aTimeZoneId); + void TestFindTimeZoneByNameL(TInt aTimeZoneId, const CTzUserNames& aNames,const TDesC& aNameToFind); + + CTzRules* CreateRulesLC(); + CTzUserNames* CreateNamesLC(); + + TBool CompareLocalizedCity(TInt aTimeZoneId, const CTzUserNames& aNames, const CTzLocalizedCity& aCity); + TBool CompareTimeZoneNames(TInt aTimezoneId, const CTzUserNames& aNames, const CTzLocalizedTimeZone& aLocalizedTimeZone); + TBool CompareLocalizedCityGroup(const CTzUserNames& aNames, const CTzLocalizedCityGroup& aCityGroup); + TBool FindCityInArrayL(const CTzLocalizedCityArray& aCityArray, TInt aTimeZoneId, const CTzUserNames& aNames); + TBool CompareLocalizedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare); + TBool CompareTimeZoneName(const CTzLocalizedTimeZone& aTimeZone, const CTzLocalizedTimeZone& aTimeZoneToCompare); + + void CreateString(TDes& aString); + TBool TestTimeZoneShortStandardNameL(CTzLocalizer& aTzLocalizer, const TDesC& aShortStandardName); + +private: + CTzLocalizer* iLocalizer; + RTz iTzSession; + CTzUserData* iUserData; + TInt64 iSeed; + }; + + +_LIT(KTestName,"t_localizationuserdata"); +_LIT(KPerFile1,"c:\\private\\100012a5\\DBS_2000836D_DBS_DSC.db"); +_LIT(KPerFile2,"c:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db"); + +_LIT(KUserAddedCity1Name, "UserAddedCity1"); +_LIT(KUserAddedCity2Name, "UserAddedCity2"); +_LIT(KUserAddedCity3Name, "UserAddedCity3"); + + +const TInt KLondonTzId = 2592; +const TInt KParisTzId = 2656; + + +RTest test(KTestName); + + +LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr) + { + RPointerArray* ids = static_cast*>(aPtr); + if (ids) + { + ids->ResetAndDestroy(); + } + } + + +CTzLocalizationUserDataSuite* CTzLocalizationUserDataSuite::NewLC() + { + CTzLocalizationUserDataSuite* self = new (ELeave) CTzLocalizationUserDataSuite(); + CleanupStack::PushL(self); + self->ConstructL(); + return (self); + } + + +CTzLocalizationUserDataSuite::CTzLocalizationUserDataSuite():iSeed(100) + { + } + + +void CTzLocalizationUserDataSuite::ConstructL() + { + iLocalizer = CTzLocalizer::NewL(); + iLocalizer->SetDataSource(CTzLocalizer::ETzDataSourceSystem|CTzLocalizer::ETzDataSourceUser); + iLocalizer->SetTimeZoneL(KLondonTzId); + + User::LeaveIfError(iTzSession.Connect()); + iUserData = CTzUserData::NewL(iTzSession); + } + + +CTzLocalizationUserDataSuite::~CTzLocalizationUserDataSuite() + { + TRAP_IGNORE(iLocalizer->SetTimeZoneL(KLondonTzId)); + delete iLocalizer; + delete iUserData; + iTzSession.Close(); + } + + +CTzUserNames* CTzLocalizationUserDataSuite::CreateUserRuleAndGetNamesLC(TInt& aTimeZoneId) + { + CTzId* tzid = CreateTimeZoneL(); + CleanupStack::PushL(tzid); + CTzUserNames* names = iUserData->ReadNamesL(*tzid); + aTimeZoneId = tzid->TimeZoneNumericID(); + CleanupStack::PopAndDestroy(tzid); + CleanupStack::PushL(names); + return names; + } + + +TBool CTzLocalizationUserDataSuite::CompareTimeZoneNames(TInt aTimeZoneId, const CTzUserNames& aNames, const CTzLocalizedTimeZone& aLocalizedTimeZone) + { + if (aTimeZoneId != aLocalizedTimeZone.TimeZoneId()) + { + return EFalse; + } + if (aNames.StandardName() != aLocalizedTimeZone.StandardName()) + { + return EFalse; + } + if (aNames.ShortStandardName() != aLocalizedTimeZone.ShortStandardName()) + { + return EFalse; + } + if (aNames.DaylightSaveName() != aLocalizedTimeZone.DaylightName()) + { + return EFalse; + } + if (aNames.ShortDaylightSaveName() != aLocalizedTimeZone.ShortDaylightName()) + { + return EFalse; + } + + return ETrue; + } + + +TBool CTzLocalizationUserDataSuite::CompareLocalizedCity(TInt aTimeZoneId, const CTzUserNames& aNames, const CTzLocalizedCity& aCity) + { + if (aNames.CityName() != aCity.Name()) + { + return EFalse; + } + if (aTimeZoneId != aCity.TimeZoneId()) + { + return EFalse; + } + if (aCity.GroupId()!=0) + { + return EFalse; + } + + return ETrue; + } + + +TBool CTzLocalizationUserDataSuite::CompareLocalizedCityGroup(const CTzUserNames& aNames, const CTzLocalizedCityGroup& aCityGroup) + { + if (aNames.RegionName() != aCityGroup.Name()) + { + return EFalse; + } + if (aCityGroup.Id()!=0) + { + return EFalse; + } + + return ETrue; + } + + +TBool CTzLocalizationUserDataSuite::CompareLocalizedCity(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 CTzLocalizationUserDataSuite::CompareTimeZoneName(const CTzLocalizedTimeZone& aTimeZone, const CTzLocalizedTimeZone& aTimeZoneToCompare) + { + if(aTimeZone.StandardName() != aTimeZoneToCompare.StandardName()) + { + return EFalse; + } + if(aTimeZone.ShortStandardName() != aTimeZoneToCompare.ShortStandardName()) + { + return EFalse; + } + if(aTimeZone.DaylightName() != aTimeZoneToCompare.DaylightName()) + { + return EFalse; + } + if(aTimeZone.ShortDaylightName() != aTimeZoneToCompare.ShortDaylightName()) + { + return EFalse; + } + return ETrue; + } + + +CTzId* CTzLocalizationUserDataSuite::CreateTimeZoneL() + { + //Create a user defined rule - CTzRules. + TTime dston (TDateTime(2005, EMarch, 0, 0, 0, 0, 0)); + TTime dstoff (TDateTime(2005, ESeptember, 0, 0, 0, 0, 0)); + TMonth monthOn = dston.DateTime().Month(); + TInt dayOn = dston.DateTime().Day(); + TMonth monthOff = dstoff.DateTime().Month(); + TInt dayOff = dstoff.DateTime().Day(); + + TTzRule dstOff(0, 9999, 0, 0, monthOn, ETzFixedDate, dayOn, 0, ETzWallTimeReference, 0); + TTzRule dstOn (0, 9999, 0, 0, monthOff, ETzFixedDate, dayOff, 0, ETzWallTimeReference, 0); + + CTzRules* rules = CTzRules::NewL(0, KMaxTUint); + CleanupStack::PushL(rules); + rules->AddRuleL(dstOff); + rules->AddRuleL(dstOn); + + //Create a user defined rule names- CTzUserNames. + _LIT(KStandardName, "UserTzName"); + _LIT(KShortName, "UserTzSh"); + _LIT(KDaylightSaveName, "UserDLSaveName"); + _LIT(KShortDaylightSaveName, "UserShDLS"); + _LIT(KCityNameName, "UserCityName"); + _LIT(KRegionName, "UserRegionName"); + + CTzUserNames* names = CTzUserNames::NewLC(KStandardName(), KShortName(), KDaylightSaveName(), KShortDaylightSaveName(), KCityNameName(), KRegionName()); + //Add the rule to the database + CTzId* tzid = iUserData->CreateL(*rules, *names); + CleanupStack::PopAndDestroy(2, rules); + return tzid; + } + + +void CTzLocalizationUserDataSuite::ResetTzUserDataL() + { + RPointerArray ids; + CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids)); + iUserData->GetTzIdsL(ids); + TInt count = ids.Count(); + for (TInt ii=0; iiDeleteL(*ids[ii]); + } + CleanupStack::PopAndDestroy(&ids); + } + + +TBool CTzLocalizationUserDataSuite::FindCityInArrayL(const CTzLocalizedCityArray& aCityArray, TInt aTimeZoneId, const CTzUserNames& aNames) + { + TBool found = EFalse; + const TInt count = aCityArray.Count(); + for(TInt ii=0; iiFindTimeZoneByNameL(aNameToFind); + CleanupStack::PushL(timeZone); + test(CompareTimeZoneNames(aTimeZoneId, aNames, *timeZone)); + CleanupStack::PopAndDestroy(timeZone); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TZL-TZN-0001 + +@SYMTestCaseDesc + The purpose of this test is to verify that the localized time zone names for + a user defined time zone is correct. + +@SYMTestActions + 1. Create a user defined zone and store the returned time zone identifier. + 2. Get the localized time zone information for the user defined time zone + identifier obtained in action 1. + +@SYMTestExpectedResults + The following information is the same as that used to create the user + defined time zone in action 1: + + - Standard time zone name + - Short standard time zone name + - Standard daylight saving time name + - Short daylight saving time name + +@SYMTestType: CT + +@SYMTestPriority: 1 +*/ + + + +void CTzLocalizationUserDataSuite::TestLocalizedTimeZoneL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0001 Test Localized Time Zone")); + TInt tzid = 0; + CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid); + CTzLocalizedTimeZone* locTimezone = iLocalizer->GetLocalizedTimeZoneL(tzid); + CleanupStack::PushL(locTimezone); + test(CompareTimeZoneNames(tzid, *names, *locTimezone)); + CleanupStack::PopAndDestroy(2, names); + ResetTzUserDataL(); + } + + + +void CTzLocalizationUserDataSuite::TestLocalizedTimeZoneWithLocalizeIDL() + { + test.Next(_L("Test Localized Time Zone")); + TInt tzid = 0; + CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid); + CTzLocalizedCity* city = iLocalizer->GetDefaultCityL(tzid); + CleanupStack::PushL(city); + CTzLocalizedTimeZone* locTimezone = iLocalizer->GetLocalizedTimeZoneL(*city); + CleanupStack::PopAndDestroy(city); + CleanupStack::PushL(locTimezone); + test(CompareTimeZoneNames(tzid, *names, *locTimezone)); + CleanupStack::PopAndDestroy(2, names); + ResetTzUserDataL(); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TZL-TZN-0002 + +@SYMTestCaseDesc + The purpose of this test is to verify that the localized city information + for a user defined time zone is correct. + +@SYMTestActions + 1. Create a user defined zone and store the returned time zone identifier. + 2. Get the localized city information for the user defined zone identifier + obtained in action 1. + +@SYMTestExpectedResults + The following information is the same as that used to create the user + defined time zone in action 1: + + - City name + - Time zone identifier + - Group identifier (0 for all user defined time zones) + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestLocalizedCityL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0002 Test Localized City")); + TInt tzid = 0; + CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid); + CTzLocalizedCityArray* locCityArray = iLocalizer->GetCitiesL(tzid); + CleanupStack::PushL(locCityArray); + test(CompareLocalizedCity(tzid, *names, locCityArray->At(0))); + CleanupStack::PopAndDestroy(2, names); + ResetTzUserDataL(); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TZL-TZN-0003 + +@SYMTestCaseDesc + The purpose of this test is to verify that the default localized city + information for a user defined time zone is correct. + +@SYMTestActions + 1. Create a user defined zone and store the returned time zone identifier. + 2. Get the default localized city information for the user defined zone + identifier obtained in action 1. + +@SYMTestExpectedResults + The following information is the same as that used to create the user + defined time zone in action 1: + + - City name + - Time zone identifier + - Group identifier (0 for all user defined time zones) + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestDefaultCityL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0003 Test Default City")); + TInt tzid = 0; + CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid); + CTzLocalizedCity* defaultCity = iLocalizer->GetDefaultCityL(tzid); + CleanupStack::PushL(defaultCity); + test(CompareLocalizedCity(tzid, *names, *defaultCity)); + CleanupStack::PopAndDestroy(2, names); + ResetTzUserDataL(); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TZL-TZN-0004 + +@SYMTestCaseDesc + The purpose of this test is to verify that the localized city group + information for a user defined time zone fails as expected. + +@SYMTestActions + 1. Create a user defined zone and store the returned time zone identifier. + 2. Verify that the localized city group information for a user defined time + zone fails as expected. + +@SYMTestExpectedResults + The localized city group information cannot be obtained (the call leaves + with KErrArgument). + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestCityGroupL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0004 Test City Group")); + TInt tzid = 0; + CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid); + CTzLocalizedCityArray* locCityArray = iLocalizer->GetCitiesL(tzid); + CleanupStack::PushL(locCityArray); + TRAPD(err, iLocalizer->GetCityGroupL(locCityArray->At(0).GroupId())); + test(err == KErrArgument); + CleanupStack::PopAndDestroy(2, names); + ResetTzUserDataL(); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TZL-TZN-0005 + +@SYMTestCaseDesc + The purpose of this test is to verify that the localized city array + information for user defined time zones is correct. + +@SYMTestActions + 1. Create two user defined time zones. + 2. Get the localized city array information for the user defined time zone + group identifier (always 0). + +@SYMTestExpectedResults + The localized city array contains the two city names used to create the user + defined time zones in action 1. + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestCityArrayL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0005 Test City Array")); + + TInt grouplessId = 0; + CTzLocalizedCityArray* cities = iLocalizer->GetCitiesInGroupL(grouplessId); + const TInt originalCount = cities->Count(); + delete cities; + + TInt tzid1 = 0; + CTzUserNames* names1 = CreateUserRuleAndGetNamesLC(tzid1); + + TInt tzid2 = 0; + CTzUserNames* names2 = CreateUserRuleAndGetNamesLC(tzid2); + + cities = iLocalizer->GetCitiesInGroupL(grouplessId); + CleanupStack::PushL(cities); + + test(cities->Count() == (2 + originalCount)); + test(FindCityInArrayL(*cities, tzid1, *names1)); + test(FindCityInArrayL(*cities, tzid1, *names2)); + + CleanupStack::PopAndDestroy(3); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TZL-TZN-0006 + +@SYMTestCaseDesc + Verify that the current time zone can be set to a user defined time zone. + +@SYMTestActions + 1. Create a user defined time zone and store the returned time zone + identifier. + 2. Set the current time using the user defined time zone identifier stored + in action 1. + 3. Get the time zone identifier for the current time zone from the TZ + Server. + +@SYMTestExpectedResults + The time zone identifier obtained in action 1 is the same as the time zone + identifier obtained in action 3. + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestCurrentTimeZoneL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0006 Test Current Time Zone")); + TInt tzid = 0; + CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid); + iLocalizer->SetTimeZoneL(tzid); + CTzLocalizedTimeZone* currentTz = iLocalizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::ECurrentZone); + CleanupStack::PushL(currentTz); + test(CompareTimeZoneNames(tzid, *names, *currentTz)); + CleanupStack::PopAndDestroy(2, names); + ResetTzUserDataL(); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TZL-TZN-0010 + +@SYMTestCaseDesc + The purpose of this test is to verify that time zone name, city name and + city group name for a user defined time zone can be found. + +@SYMTestActions + 1. Create a user defined time zone and store the returned time zone + identifier. + 2. Find the user defined time zone by long/short standard time name and + long short daylight saving time names. [1] + 3. Find the user defined time zone by city name, searching both in all time + zones and the specific time zone identified by the time zone identifier + obtained in action 1. [2] + 4. Find the user defined time zone by city group name. [3] + +@SYMTestExpectedResults + [1], [2], [3] User defined time zone is found + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestFindTimeZoneL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0010 Test Find Time Zone")); + TInt tzid = 0; + CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid); + TestFindTimeZoneByNameL(tzid,*names,names->StandardName()); + TestFindTimeZoneByNameL(tzid,*names,names->ShortStandardName()); + TestFindTimeZoneByNameL(tzid,*names,names->DaylightSaveName()); + TestFindTimeZoneByNameL(tzid,*names,names->ShortDaylightSaveName()); + CTzLocalizedCity* city = iLocalizer->FindCityByNameL(names->CityName()); + CleanupStack::PushL(city); + test(CompareLocalizedCity(tzid, *names, *city)); + CleanupStack::PopAndDestroy(city); + + city = iLocalizer->FindCityByNameL(names->CityName(), tzid); + CleanupStack::PushL(city); + test(CompareLocalizedCity(tzid, *names, *city)); + CleanupStack::PopAndDestroy(city); + + CTzLocalizedCityGroup* group = iLocalizer->FindCityGroupByNameL(names->RegionName()); + CleanupStack::PushL(group); + test(CompareLocalizedCityGroup(*names, *group)); + CleanupStack::PopAndDestroy(group); + + CleanupStack::PopAndDestroy(names); + } + + +CTzRules* CTzLocalizationUserDataSuite::CreateRulesLC() + { + TTime dston (TDateTime(2005, EMarch, 0, 0, 0, 0, 0)); + TTime dstoff (TDateTime(2005, ESeptember, 0, 0, 0, 0, 0)); + TMonth monthOn = dston.DateTime().Month(); + TInt dayOn = dston.DateTime().Day(); + TMonth monthOff = dstoff.DateTime().Month(); + TInt dayOff = dstoff.DateTime().Day(); + + TTzRule dstOff(0, 9999, 0, 0, monthOn, ETzFixedDate, dayOn, 0, ETzWallTimeReference, 0); + TTzRule dstOn (0, 9999, 0, 0, monthOff, ETzFixedDate, dayOff, 0, ETzWallTimeReference, 0); + + CTzRules* rules = CTzRules::NewL(0, KMaxTUint); + CleanupStack::PushL(rules); + rules->AddRuleL(dstOff); + rules->AddRuleL(dstOn); + + return rules; + } + + +void CTzLocalizationUserDataSuite::CreateString(TDes& aString) + { + for (TInt i(0) ; i < 10 ; ++i) + { + // Add random upper and lower case letters + aString.Append( 'A' + (Math::Rand(iSeed) % 26) ); + } + } + + +CTzUserNames* CTzLocalizationUserDataSuite::CreateNamesLC() + { + TBuf<10> stdName; + CreateString(stdName); + TBuf<10> shortStdName; + CreateString(shortStdName); + TBuf<10> dstName; + CreateString(dstName); + TBuf<10> shortDstName; + CreateString(shortDstName); + TBuf<10> cityName; + CreateString(cityName); + TBuf<10> regionName; + CreateString(regionName); + + return CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0002 + +@SYMTestCaseDesc + The purpose of this test is to verify that an update to user-defined rules + is reflected in the frequently used zone database. + +@SYMTestActions + 1. Create a user-defined time zone and set it as the frequently used zone. + 2. Update the time zone rule. + 3. Read the frequently used city and zone and test against the ones + expected. + +@SYMTestExpectedResults + The frequently used zone read from the database should be the one expected. + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestUserDataModificationL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone) + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0002 Test frequently used zone database after user data modification")); + + //Create user-defined time zone + CTzRules* rules = CreateRulesLC(); + CTzUserNames* names = CreateNamesLC(); + CTzId* tzId = iUserData->CreateL(*rules, *names); + TInt tzid = tzId->TimeZoneNumericID(); + delete tzId; + CleanupStack::PopAndDestroy(names); + + // Associate the user-defined zone with the given frequently used zone. + iLocalizer->SetFrequentlyUsedZoneL(tzid, aFrequentlyUsedZone); + + //Create a new user-defined name + CTzUserNames* names2 = CreateNamesLC(); + + //Update the time zone + CTzId* id = CTzId::NewL(tzid); + CleanupStack::PushL(id); + iUserData->UpdateL(*id, *rules, *names2); + + switch(aFrequentlyUsedZone) + { + case CTzLocalizedTimeZone::EHomeZone: + case CTzLocalizedTimeZone::EInterestZone: + { + CTzLocalizedCity* city = iLocalizer->GetFrequentlyUsedZoneCityL(aFrequentlyUsedZone); + test(CompareLocalizedCity(tzid, *names2, *city)); + delete city; + + CTzLocalizedTimeZone* timeZone = iLocalizer->GetFrequentlyUsedZoneL(aFrequentlyUsedZone); + test(CompareTimeZoneNames(tzid, *names2, *timeZone)); + delete timeZone; + break; + } + + case CTzLocalizedTimeZone::ECurrentZone: + { + //Extract zone information, same zone should be returned by GetFrequentlyUsedZoneL below. + CTzLocalizedTimeZone* zoneToCompareWith = iLocalizer->GetLocalizedTimeZoneL(KParisTzId); + CleanupStack::PushL(zoneToCompareWith); + //Extract zone information, same city should be returned by GetFrequentlyUsedZoneCityL below. + CTzLocalizedCity* cityToCompareWith = iLocalizer->GetDefaultCityL(KParisTzId); + CleanupStack::PushL(cityToCompareWith); + + iLocalizer->SetTimeZoneL(KParisTzId); + CTzLocalizedCity* freqUsedCity = iLocalizer->GetFrequentlyUsedZoneCityL(aFrequentlyUsedZone); + test(CompareLocalizedCity(*freqUsedCity, *cityToCompareWith)); + delete freqUsedCity; + + CTzLocalizedTimeZone* freqUsedZone = iLocalizer->GetFrequentlyUsedZoneL(aFrequentlyUsedZone); + test(CompareTimeZoneName(*freqUsedZone, *zoneToCompareWith)); + delete freqUsedZone; + CleanupStack::PopAndDestroy(2,zoneToCompareWith); + break; + } + default: + { + User::Invariant(); + break; + } + + } + + CleanupStack::PopAndDestroy(3, rules); + ResetTzUserDataL(); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0003 + +@SYMTestCaseDesc + The purpose of this test is to verify that a deletion to the user-defined + rules is reflected in the frequently used zone database. + +@SYMTestActions + 1. Create a user-defined time zone and set it as the frequently used zone of + interest. + 2. Create another user-defined time zone and set it as the frequently used + home zone. + 3. Delete the time zone created in Step 2. + 4. Read the frequently used city and zone and test whether against the ones + expected. + +@SYMTestExpectedResults + The frequently used city and zone read from the database should be the ones + expected. + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestUserDataDeletionL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0003 Test frequently used zone database after user data deletion")); + // Add a user-defined time zone as a frequently used zone of interest + CTzRules* rulesInterest = CreateRulesLC(); + CTzUserNames* namesInterest = CreateNamesLC(); + CTzId* tzIdInterest = iUserData->CreateL(*rulesInterest, *namesInterest); + TInt tzidInterest = tzIdInterest->TimeZoneNumericID(); + delete tzIdInterest; + + //Extract zone information, same city should be returned by GetFrequentlyUsedZoneCityL below. + CTzLocalizedCity* cityToCompareWith = iLocalizer->GetDefaultCityL(KLondonTzId); + CleanupStack::PushL(cityToCompareWith); + + //Extract zone information, same zone should be returned by GetFrequentlyUsedZoneL below. + CTzLocalizedTimeZone* zoneToCompareWith = iLocalizer->GetLocalizedTimeZoneL(KLondonTzId); + CleanupStack::PushL(zoneToCompareWith); + + iLocalizer->SetFrequentlyUsedZoneL(tzidInterest, CTzLocalizedTimeZone::EInterestZone); + + CTzRules* rulesHome = CreateRulesLC(); + CTzUserNames* namesHome = CreateNamesLC(); + CTzId* tzId = iUserData->CreateL(*rulesHome, *namesHome); + TInt tzidHome = tzId->TimeZoneNumericID(); + delete tzId; + + // Add rule to frequently used zones + iLocalizer->SetFrequentlyUsedZoneL(tzidHome, CTzLocalizedTimeZone::EHomeZone); + + CTzId* id = CTzId::NewL(tzidHome); + CleanupStack::PushL(id); + iUserData->DeleteL(*id); + CleanupStack::PopAndDestroy(id); + + CTzLocalizedCity* city = iLocalizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EHomeZone); + //Check if the frequently used city read from the database is same as the one expected + test(CompareLocalizedCity(*city, *cityToCompareWith)); + delete city; + + CTzLocalizedCity* cityInterest = iLocalizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::EInterestZone); + //Check if the frequently used city of interest read from the database is same as the one expected + test(CompareLocalizedCity(tzidInterest, *namesInterest, *cityInterest)); + delete cityInterest; + + CTzLocalizedTimeZone* timeZone = iLocalizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::EHomeZone); + //Check if the frequently used zone read from the database is same as the one expected + test(CompareTimeZoneName(*timeZone, *zoneToCompareWith)); + delete timeZone; + + CTzLocalizedTimeZone* timeZoneInterest = iLocalizer->GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::EInterestZone); + //Check if the frequently used zone of interest read from the database is same as the one expected + test(CompareTimeZoneNames(tzidInterest, *namesInterest, *timeZoneInterest)); + + delete timeZoneInterest; + ResetTzUserDataL(); + CleanupStack::PopAndDestroy(6, rulesInterest); + } + + +/** +@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0004 + +@SYMTestCaseDesc + The purpose of this test is to verify that a deletion to the user-defined + rules is reflected in the city database + +@SYMTestActions + 1. Create a user-defined time zone. + 2. Add three cities to the time zone. + 3. Read the number of cities. + 4. Delete one of the cities. + 5. Read the number of cities after deletion. + +@SYMTestExpectedResults + The number of cities in Step 3 should be 3 and in Step 5 should be 2. + +@SYMTestType + CT + +@SYMTestPriority + 1 +*/ + + +void CTzLocalizationUserDataSuite::TestUserDataDeletionCityImpactL() + { + test.Next(_L("@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0004 Test city database after user data deletion\n")); + CTzRules* rules = CreateRulesLC(); + CTzUserNames* names = CreateNamesLC(); + CTzId* tzId = iUserData->CreateL(*rules, *names); + CleanupStack::PopAndDestroy(names); + CleanupStack::PopAndDestroy(rules); + TInt tzid = tzId->TimeZoneNumericID(); + delete tzId; + //Add 3 user-defined cities to the city database + test.Printf(_L("Add 3 cities to the city database\n")); + CTzLocalizedCity* userCity = iLocalizer->AddCityL(tzid, KUserAddedCity1Name); + delete userCity; + CTzRules* rules2 = CreateRulesLC(); + CTzUserNames* names2 = CreateNamesLC(); + CTzId* tzId1 = iUserData->CreateL(*rules2, *names2); + CleanupStack::PopAndDestroy(2,rules2); + tzid = tzId1->TimeZoneNumericID(); + delete tzId1; + CTzLocalizedCity* userCity1 = iLocalizer->AddCityL(tzid, KUserAddedCity2Name); + delete userCity1; + + CTzRules* rules3 = CreateRulesLC(); + CTzUserNames* names3 = CreateNamesLC(); + CTzId* tzId2 = iUserData->CreateL(*rules3, *names3); + CleanupStack::PopAndDestroy(2,rules3); + tzid = tzId2->TimeZoneNumericID(); + delete tzId2; + + CTzLocalizedCity* userCity2 = iLocalizer->AddCityL(tzid, KUserAddedCity3Name); + delete userCity2; + //Read the number of cities + RPointerArray cityRecords; + iTzSession.LocalizationReadCitiesL(cityRecords); + test.Printf(_L("Check if the number of cities read is correct\n")); + test(cityRecords.Count() == 3); + cityRecords.ResetAndDestroy(); + cityRecords.Close(); + //Delete a city from the city database + CTzId* id = CTzId::NewL(tzid); + CleanupStack::PushL(id); + test.Printf(_L("Delete a city from the database\n")); + iUserData->DeleteL(*id); + CleanupStack::PopAndDestroy(id); + //Read the number of cities again + RPointerArray cityRecords2; + iTzSession.LocalizationReadCitiesL(cityRecords2); + test.Printf(_L("Again, check if the number of cities read is correct\n")); + test(cityRecords2.Count() == 2); + cityRecords2.ResetAndDestroy(); + cityRecords2.Close(); + + ResetTzUserDataL(); + } + + +TBool CTzLocalizationUserDataSuite::TestTimeZoneShortStandardNameL(CTzLocalizer& aTzLocalizer, const TDesC& aShortStandardName) + { + CTzLocalizedTimeZone* localizedTimeZone = aTzLocalizer.GetFrequentlyUsedZoneL(CTzLocalizedTimeZone::ECurrentZone); + CleanupStack::PushL(localizedTimeZone); + HBufC* shortStandardName(localizedTimeZone->ShortStandardName().AllocLC()); + test.Printf(_L("The short standard name is %S\n"), shortStandardName); + TBool compare = (shortStandardName->Des() == aShortStandardName); + CleanupStack::PopAndDestroy(shortStandardName); + CleanupStack::PopAndDestroy(localizedTimeZone); + return compare; + } + + + +void CTzLocalizationUserDataSuite::TestUserDefinedTimeZoneL() + { + test.Next(_L("Test user defined zone\n")); + _LIT(KUserStandardName, "Southark Standard Time"); + _LIT(KUserShortStandardName, "SST"); + _LIT(KUserDaylightName, "WorkingDay"); + _LIT(KUserShortDaylightName, "WD"); + _LIT(KRegionName, "Sarf"); + _LIT(KCityName, "MobiCity"); + _LIT(KCity2Name, "East end"); + CTzRules* rules = CreateRulesLC(); + CTzUserNames* names = CTzUserNames::NewLC(KUserStandardName(), KUserShortStandardName(), KUserDaylightName(), KUserShortDaylightName(), KCityName(), KRegionName() ); + CTzId* tzId = iUserData->CreateL(*rules, *names); + CleanupStack::PopAndDestroy(names); + CleanupStack::PopAndDestroy(rules); + TInt tzid = tzId->TimeZoneNumericID(); + + RTz tz; + CleanupClosePushL(tz); + User::LeaveIfError(tz.Connect()); + //Create a localizer and get frequently used zone + CTzLocalizer* localizer = CTzLocalizer::NewLC(); + localizer->SetTimeZoneL(tzid); + + //use the utility test function here for the short standard name + test (TestTimeZoneShortStandardNameL(*localizer, KUserShortStandardName())); + + CTzLocalizedCity* localizedCity = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::ECurrentZone); + CleanupStack::PushL(localizedCity); + test(localizedCity->Name() == KCityName()); + test(localizedCity->TimeZoneId() == (TUint16) tzid); + CleanupStack::PopAndDestroy(localizedCity); + + // + // Test the AddCityL() and RemoveCityL() APIs. + // + + // Try adding the same city. + TRAPD(errSame, localizer->AddCityL(tzid, KCityName, 0)); + test(errSame == KErrAlreadyExists); + + // Try adding and removing a different city. + CTzLocalizedCity* differentCity = NULL; + TRAPD(errDifferent, differentCity = localizer->AddCityL(tzid, KCity2Name, 0)); + test(errDifferent == KErrNone); + TRAPD(errDelete, localizer->RemoveCityL(differentCity)); + test(errDelete == KErrNone); + + //Get the CTzLocalizedCity and keep it to use it later on. + CTzLocalizedCity* localizedGetCity = localizer->GetFrequentlyUsedZoneCityL(CTzLocalizedTimeZone::ECurrentZone); + CleanupStack::PushL(localizedGetCity); + test(localizedGetCity->Name() == KCityName()); + + //Set the time zone to London using a tzId. + localizer->SetFrequentlyUsedZoneL(KLondonTzId, CTzLocalizedTimeZone::ECurrentZone); + //Test the short standard name for compliance + test (TestTimeZoneShortStandardNameL(*localizer, _L("GMT"))); + + // Set the frequently used zone using the previously retrieved CTzLocalizedCity of Southwark. + localizer->SetFrequentlyUsedZoneL(*localizedGetCity, CTzLocalizedTimeZone::ECurrentZone); + CleanupStack::PopAndDestroy(localizedGetCity); + + //Get the frequently used zone and check that short standard name is as expected. + test (TestTimeZoneShortStandardNameL(*localizer, KUserShortStandardName())); + + //Set the frequently used time zone back to london, this time using the CTzLocalizedTimeZone API + CTzLocalizedTimeZone* londonLocalizedTimeZone = localizer->GetLocalizedTimeZoneL(KLondonTzId); + CleanupStack::PushL(londonLocalizedTimeZone); + localizer->SetFrequentlyUsedZoneL(*londonLocalizedTimeZone, CTzLocalizedTimeZone::ECurrentZone); + //Test that the short standard name is again GMT + test (TestTimeZoneShortStandardNameL(*localizer, _L("GMT"))); + CleanupStack::PopAndDestroy(londonLocalizedTimeZone); + + CleanupStack::PopAndDestroy(localizer); + CleanupStack::PopAndDestroy(&tz); + delete tzId; + } + +/** +@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0001 +*/ +static void DoTestsL() + { + test.Title(); + + test.Start(_L("@SYMTestCaseID PIM-APPSERV-TLOCALIZATIONUSERDATA-0001 User defined time zone test suite")); + + RPIMTestServer serv; + CleanupClosePushL(serv); + User::LeaveIfError(serv.Connect()); + serv.CloseTzSession(); + _LIT(KAgendaServer,"agsvexe*"); + TRAP_IGNORE(serv.KillProcessL(KAgendaServer)); + _LIT(KTzServer,"Tzserver*"); + TRAP_IGNORE(serv.KillProcessL(KTzServer)); + serv.DeleteFileL(KPerFile1); + serv.DeleteFileL(KPerFile2); + + CTzLocalizationUserDataSuite* loctest = CTzLocalizationUserDataSuite::NewLC(); + loctest->TestUserDefinedTimeZoneL(); + loctest->TestLocalizedTimeZoneL(); + loctest->TestLocalizedTimeZoneWithLocalizeIDL(); + loctest->TestLocalizedCityL(); + loctest->TestDefaultCityL(); + loctest->TestCityGroupL(); + loctest->TestCityArrayL(); + loctest->TestCurrentTimeZoneL(); + loctest->TestFindTimeZoneL(); + loctest->TestUserDataModificationL(CTzLocalizedTimeZone::EHomeZone); + loctest->TestUserDataModificationL(CTzLocalizedTimeZone::ECurrentZone); + loctest->TestUserDataModificationL(CTzLocalizedTimeZone::EInterestZone); + loctest->TestUserDataDeletionL(); + loctest->TestUserDataDeletionCityImpactL(); + CleanupStack::PopAndDestroy(loctest); + + TRAP_IGNORE(serv.KillProcessL(KTzServer)); + + //delete persistent file + serv.DeleteFileL(KPerFile1); + serv.DeleteFileL(KPerFile2); + + CleanupStack::PopAndDestroy(&serv); + + test.End(); + } + + +TInt E32Main() + { + __UHEAP_MARK; + + CTrapCleanup* trapCleanup = CTrapCleanup::New(); + if(!trapCleanup) + { + return KErrNoMemory; + } + + CActiveScheduler* scheduler = new CActiveScheduler; + if(!scheduler) + { + return KErrNoMemory; + } + CActiveScheduler::Install(scheduler); + + TRAPD(ret, DoTestsL()); + test.Printf(_L("Trapped return value from DoTestsL(): %d\n"), ret); + test(ret == KErrNone); + + test.Close(); + + delete scheduler; + delete trapCleanup; + + __UHEAP_MARKEND; + + return (KErrNone); + }