void CTzBootPerformanceTest::TestBootupPerformanceL()
{
TTime startTime;
TTime endTime;
startTime.UniversalTime();
RTz tz;
User::LeaveIfError(tz.Connect());
endTime.UniversalTime();
tz.Close();
TTimeIntervalMicroSeconds micros = endTime.MicroSecondsFrom(startTime);
_LIT(KBootTime, "Time to connect time zone server = %d (ms) \n");
test.Printf(KBootTime,micros);
#ifndef __WINS__
#ifdef GetPerformanceBaseline
bootTimeBaseLine = micros.Int64();
_LIT(KBootTimeBaseLine, "The baseline of boot-up time = %d (ms) \n");
test.Printf(KBootTimeBaseLine,bootTimeBaseLine);
#else
test((micros.Int64()-bootTimeBaseLine)/bootTimeBaseLine<0.1);
#endif
#endif
}
/**
Out of memory behaviour.
@SYMTestCaseID PIM-APPSERV-TZS-CO-0006
@SYMTestCaseDesc
The purpose of this test is to verify that user-defined time zone operations
are robust and result in no memory leaks under OOM conditions.
@SYMTestActions
Create, Read, Update and Delete a user-defined time zone rule under OOM
conditions.
@SYMTestExpectedResults
Each operation leaves with KErrNoMemory until eventually the operation
completes successfully. Once the operation completes successfully the
client process (for client-side OOM testing) or TZ Server process (for
server-side OOM testing) is terminated and does not report a memory leak.
@SYMTestType
CT
@SYMTestPriority
1
*/
void CTzUserDataTest::TestOutOfMemoryBehaviourL(TOOMTest aOOMTest)
{
ResetTzUserDataL();
test.Start(_L("@SYMTestCaseID PIM-APPSERV-TZS-CO-0006 Test Create User-Defined Time Zone OOM"));
OOMTestL(&CreateOOML,aOOMTest);
// Ensure that a tz ID is saved in iTzIds which is used to fetch a time zone
// in ReadOOML().
RTz tz;
User::LeaveIfError(tz.Connect());
CleanupClosePushL(tz);
iUserData = CTzUserData::NewL(tz);
iUserData->GetTzIdsL(iTzIds);
delete iUserData;
iUserData = NULL;
CleanupStack::PopAndDestroy(&tz);
test.Next(_L("Test Read User-Defined Time Zone OOM"));
OOMTestL(&ReadOOML,aOOMTest);
test.Next(_L("Test Get User-Defined Time Zone IDs OOM"));
OOMTestL(&GetIdsOOML,aOOMTest);
test.Next(_L("Test Update User-Defined Time Zone OOM"));
OOMTestL(&UpdateOOML,aOOMTest);
test.Next(_L("Test Delete User-Defined Time Zone OOM"));
OOMTestL(&DeleteOOML,aOOMTest);
test.End();
ResetTzUserDataL();
}
/** Gets the current system time zone in OOM conditions
*/
void CTestTZServer::OOMGetCurrentTimeZoneL()
{
RTz tz;
CleanupClosePushL(tz);
User::LeaveIfError(tz.Connect());
CTzId* tzId = NULL;
iFailAt = 1;
for ( ;; )
{
StartHeapCheck(iFailAt);
TRAPD(err,tzId = tz.GetTimeZoneIdL());
if ( err == KErrNone )
{
TESTL(tzId != NULL);
__UHEAP_RESET;
INFO_PRINTF1(_L("OOM testing of GetTimeZoneIdL()) Api is done"));
break;
}
if ( ErrorProcess(err) )
{
EndHeapCheck();
}
else
{
break;
}
}
CleanupStack::PopAndDestroy(&tz);
}
void NotifyProvider::LogEventL(const CLogEvent &event)
{
// store new call
QString number=QString::fromRawData(reinterpret_cast<const QChar*>(event.Number().Ptr()),event.Number().Length());
QString direction=QString::fromRawData(reinterpret_cast<const QChar*>(event.Direction().Ptr()),event.Direction().Length());
QString description=QString::fromRawData(reinterpret_cast<const QChar*>(event.Description().Ptr()),event.Description().Length());
if (description.contains("Voice call")&&direction.contains("Missed call"))
{
TTime times=event.Time();
RTz tzsession;
tzsession.Connect();
tzsession.ConvertToLocalTime(times);
tzsession.Close();
TDateTime dts=times.DateTime();
QDate d; QTime t;
d.setYMD(dts.Year(),dts.Month()+1,dts.Day()+1);
t.setHMS(dts.Hour(),dts.Minute(),dts.Second());
QDateTime dt; dt.setDate(d); dt.setTime(t);
dt=dt.toLocalTime();
QString time=dt.toString("d.M.yy hh:mm");
TNotifyInfo info;
info.time=time;
info.timeStamp=dt;
info.sender=number;
info.text=findContact(number);
info.id=-1;
info.type=EMissedCall;
iNotifiers.insert(0,info);
qDebug()<<"store call from"<<info.sender;
prepareNotifier(EMissedCall);
}
}
/** Retrieves numeric id for various time zones
*/
void CTestTZServer::TimeZoneNumericIdL()
{
iField.Zero();
iField.Append(KNumericIds);
GetIntFromConfig(ConfigSection(),iField,iIntNumericId); //gets expected numeric id
RTz tz;
CleanupClosePushL(tz);
User::LeaveIfError(tz.Connect());
CTzId* tzId = NULL;
TRAPD(err,tzId = tz.GetTimeZoneIdL());
TESTL(err == KErrNone);
CleanupStack::PushL(tzId);
TUint tzNumericId = tzId->TimeZoneNumericID();
INFO_PRINTF2(_L("actual : %d"),tzNumericId);
TESTL(tzNumericId == iIntNumericId);
CleanupStack::PopAndDestroy(tzId);
CleanupStack::PopAndDestroy(&tz);
}
void CTzUserDataTest::TestServerResponseToChangesL()
{
ResetTzUserDataL();
test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZS-RC-0003-TO-0006 Server Response To Changes"));
RTz tz;
User::LeaveIfError(tz.Connect());
CleanupClosePushL(tz);
iUserData = CTzUserData::NewL(tz);
const TInt KStandardOffset = 60;
const TInt KDSTOffset = 60;
CreateUserTzAndSetCurrentTimeToL(tz,KStandardOffset,KDSTOffset);
UpdateCurrentUserTzL(tz);
TestUpdateCachedUserTimeZoneL(tz);
TestDeletedCachedUserTimeZoneL(tz);
TestDeleteCurrentTimeZoneL(tz);
TestCurrentTimeZonePersistenceL(tz);
delete iUserData;
iUserData= NULL;
CleanupStack::PopAndDestroy(&tz);
}
void CTzUserDataTest::DeleteCurrentUserTzL(RTz& aTz, TTest aWhatToTest)
{
test.Next(_L("Delete Current TZ rules - Server Response to Changes"));
// Set system to default time zone
ResetTimeZoneToLondonL();
CTzId* defaulteTzid = aTz.GetTimeZoneIdL();
test(KTzLondon()==defaulteTzid->TimeZoneNameID());
delete defaulteTzid;
// Set system to a newly created user time zone
const TInt KStandardOffset = 60;
const TInt KDSTOffset = 120;
CreateUserTzAndSetCurrentTimeToL(aTz,KStandardOffset,KDSTOffset);
//Delete the user time zone
DeleteCurrentTzL(aTz);
if(aWhatToTest == EPersistence)
{
aTz.Close();
User::After(1000000);
User::LeaveIfError(aTz.Connect());
}
CTzId* tzGot = aTz.GetTimeZoneIdL();
test(KTzLondon()==tzGot->TimeZoneNameID());
delete tzGot;
}
void CTzUserDataTest::TestDaylightSavingStateL(CTzId& aTzId, const RArray<TTime>& times, TBool aIsOn, RTz& aRTz)
{
aRTz.SetTimeZoneL(aTzId);
TInt count = times.Count();
for(TInt ii=0; ii<count; ++ii)
{
test (aIsOn == aRTz.IsDaylightSavingOnL(aTzId, times[ii]));
}
}
// Close and delete the DB and create a new one in the latest format
void CTzLocalizationDbAccessor::RecreateDbL(RTz& aTzSession)
{
CloseDb();
aTzSession.LocalizationCloseDbL();
const TUid KTzLocalizationDbSecurityPolicyUid = {0x10206A8B};
User::LeaveIfError(iDbsSession.DeleteDatabase(KTzLocalizationDbName(),KTzLocalizationDbSecurityPolicyUid));
aTzSession.LocalizationOpenDbL();
OpenDbL();
}
/** Setting of Time Zone using different Time Zone Servers
*/
void CTestTZServer::MulitpleTZServerL()
{
_LIT8(KEuropeLondon, "Europe/London");
CTzId* zoneId = CTzId::NewL(KEuropeLondon);
CleanupStack::PushL(zoneId);
_LIT8(KPacificPortMoresby, "Pacific/Port_Moresby");
CTzId* zoneId1 = CTzId::NewL(KPacificPortMoresby);
CleanupStack::PushL(zoneId1);
_LIT8(KAfricaDar, "Africa/Dar_es_Salaam");
CTzId* zoneId2 = CTzId::NewL(KAfricaDar);
CleanupStack::PushL(zoneId2);
RTz tz;
CleanupClosePushL(tz);
User::LeaveIfError(tz.Connect());
RTz tz1;
CleanupClosePushL(tz1);
User::LeaveIfError(tz1.Connect());
RTz tz2;
CleanupClosePushL(tz2);
User::LeaveIfError(tz2.Connect());
CTzId* tzId = NULL;
TRAPD(err,tz.SetTimeZoneL(*zoneId));
TESTL(err == KErrNone);
TRAP(err,tz1.SetTimeZoneL(*zoneId1));
TESTL(err == KErrNone);
TRAP(err,tz2.SetTimeZoneL(*zoneId2));
TESTL(err == KErrNone);
TRAP(err,tzId = tz.GetTimeZoneIdL());
TESTL(err == KErrNone);
TESTL(tzId != NULL);
TRAP(err,tzId = tz1.GetTimeZoneIdL());
TESTL(err == KErrNone);
TESTL(tzId != NULL);
TRAP(err,tzId = tz2.GetTimeZoneIdL());
TESTL(err == KErrNone);
TESTL(tzId != NULL);
CleanupStack::PopAndDestroy(&tz2);
CleanupStack::PopAndDestroy(&tz1);
CleanupStack::PopAndDestroy(&tz);
CleanupStack::PopAndDestroy(zoneId2);
CleanupStack::PopAndDestroy(zoneId1);
CleanupStack::PopAndDestroy(zoneId);
}
void CTzUserDataTest::DeleteCurrentTzL(RTz& aTz)
{
CTzId* currentTzid = aTz.GetTimeZoneIdL();
CleanupStack::PushL(currentTzid);
iUserData->DeleteL(*currentTzid);
CleanupStack::PopAndDestroy(currentTzid);
CTzId* tzGot = aTz.GetTimeZoneIdL();
test(KTzLondon()==tzGot->TimeZoneNameID());
delete tzGot;
}
LOCAL_D void ResetTimeZoneToLondonL()
{
RTz tz;
User::LeaveIfError(tz.Connect());
CleanupClosePushL(tz);
CTzId* id = CTzId::NewL(KTzLondon);
CleanupStack::PushL(id);
tz.SetTimeZoneL(*id);
CleanupStack::PopAndDestroy(2, &tz);
}
void CTzUserDataTest::CreateUserTzAndSetCurrentTimeToL(RTz& aTz, TInt aStandardOffSet, TInt aDSTOffset)
{
test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZS-RC-0001 Test user-defined time zone is current time zone"));
CTzId* usertzid = CreateUserDefinedTzL(aStandardOffSet, aDSTOffset, ETrue);
CleanupStack::PushL(usertzid);
aTz.SetTimeZoneL(*usertzid);
CTzId* tzGot = aTz.GetTimeZoneIdL();
test (*tzGot == *usertzid);
delete tzGot;
CleanupStack::PopAndDestroy(usertzid);
}
/**
The purpose of the follwing test case is to verify the behaviour of
reuse of Tz Ids in case all the 4095 ids have been used.
*/
void CTzUserDataTest::TestTzIdReusabilityL()
{
ResetTzUserDataL();
RTz tz;
CleanupClosePushL(tz);
User::LeaveIfError(tz.Connect());
iUserData = CTzUserData::NewL(tz);
const TInt maxTzIds = 4095;
for(TInt i=0; i<= maxTzIds; i++)
{
CTzId* tzid = NULL;
TRAPD(err, tzid = CreateUserDefinedTzL(0,0, EFalse));
if(i%KPrintFreq == 0 || i == maxTzIds)
{
test.Printf(_L("Added %d rules to the database\n"), i);
}
if(err != KErrNone)
{
test.Printf(_L("Error while creating rules. Error is %d\n"), err);
}
delete tzid;
}
const TUint KFirstReusedTzId = 16400;
CTzId* tzId = CTzId::NewL(KFirstReusedTzId);
CleanupStack::PushL(tzId);
iUserData->DeleteL(*tzId);
CleanupStack::PopAndDestroy(tzId);
const TUint KSecondReusedTzId = 16500;
CTzId* tzId1 = CTzId::NewL(KSecondReusedTzId);
CleanupStack::PushL(tzId1);
iUserData->DeleteL(*tzId1);
CleanupStack::PopAndDestroy(tzId1);
CTzId* reusedId = CreateUserDefinedTzL(0, 0, EFalse);
test(reusedId->TimeZoneNumericID() == KFirstReusedTzId);
test.Printf(_L("The first re-used id is %d\n"), reusedId->TimeZoneNumericID());
delete reusedId;
CTzId* secondReusedId = CreateUserDefinedTzL(0, 0, EFalse);
test(secondReusedId->TimeZoneNumericID() == KSecondReusedTzId);
test.Printf(_L("The second re-used id is %d\n"), secondReusedId->TimeZoneNumericID());
delete secondReusedId;
TRAPD(err, CreateUserDefinedTzL(0, 0, EFalse));
test(err == KErrOverflow);
delete iUserData;
iUserData = NULL;
CleanupStack::PopAndDestroy(&tz);
}
void CTzUserDataTest::UpdateCurrentTzL(RTz& aTz,TInt aOldOffSet, TInt aNewOffSet )
{
CTzRules* newrules = CreateUserDefinedTzLC(aOldOffSet, aNewOffSet);
CTzUserNames* newnames = CreateUserDefinedTzNamesLC();
CTzId* currentTzid = aTz.GetTimeZoneIdL();
CleanupStack::PushL(currentTzid);
iUserData->UpdateL(*currentTzid,*newrules, *newnames);
CleanupStack::PopAndDestroy(currentTzid);
CTzRules* currentRules = aTz.GetTimeZoneRulesL(0, 9999,ETzUtcTimeReference );
CleanupStack::PushL(currentRules);
test(newrules->IsEqualTo(*currentRules));
CleanupStack::PopAndDestroy(3, newrules);
}
/** Retrieves daylight property for various time zones in OOM conditions
*/
void CTestTZServer::OOMDaylightSavingL()
{
RTz tz;
CleanupClosePushL(tz);
User::LeaveIfError(tz.Connect());
tz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn);
CTzId* tzId = NULL;
TRAPD(err1,tzId = tz.GetTimeZoneIdL()); //the current system time zone
TESTL ( err1 == KErrNone );
CleanupStack::PushL(tzId);
TBool isDaylightOn = EFalse;
iFailAt = 0;
for ( ;; )
{
StartHeapCheck(iFailAt);
TRAPD(err, isDaylightOn = tz.IsDaylightSavingOnL(*tzId)); //daylight property for current system time zone
if ( err == KErrNone )
{
__UHEAP_RESET;
INFO_PRINTF1(_L("OOM testing of IsDaylightSavingOnL()) Api is done"));
break;
}
if ( ErrorProcess(err) )
{
EndHeapCheck();
}
else
{
break;
}
}
iField.Zero();
iField.Append(KDaylightSaving);
GetBoolFromConfig(ConfigSection(),iField,iDaylightSaving); //gets expected daylight property
//compares expected daylight property with actual daylight property
TESTL(iDaylightSaving == isDaylightOn);
CleanupStack::PopAndDestroy(tzId);
CleanupStack::PopAndDestroy(&tz);
}
void CTzUserDataTest::TestUtcOffsetL(CTzId& aTzId, const CTzRules& rules, const RArray<TTime>& times, TInt aOffset, RTz& aRTz )
{
aRTz.SetTimeZoneL(aTzId);
TInt count = times.Count();
for(TInt ii=0; ii<count; ++ii)
{
test (aOffset == rules.GetOffsetL(times[ii], ETzUtcTimeReference));
TTime utc = times[ii];
aRTz.ConvertToUniversalTime(utc);
TTimeIntervalMinutes minutes;
times[ii].MinutesFrom(utc, minutes);
test (minutes == TTimeIntervalMinutes(aOffset));
}
}
void CTzUserDataTest::TestBasicUserDataL()
{
ResetTzUserDataL();
RTz tz;
User::LeaveIfError(tz.Connect());
CleanupClosePushL(tz);
iUserData = CTzUserData::NewL(tz);
TestCreateUserDefinedTzL();
TestReadIdsL(tz);
TestIdsL(tz);
TestUpdateUserDefinedTzL();
TestDeleteUserDefinedTzL();
TestShortTzId(tz);
delete iUserData;
iUserData = NULL;
CleanupStack::PopAndDestroy(&tz);
}
TInt CDstIntUtils::SetHomeTimeZoneL(const TDesC8& aLocation, const RTz &aServer)
{
CTzId *timezoneid = CTzId::NewL(aLocation);
CleanupStack::PushL(timezoneid);
TInt err;
TRAP(err, aServer.SetTimeZoneL(*timezoneid));
CleanupStack::PopAndDestroy(timezoneid);
return err;
}
TInt CDstIntUtils::CheckHomeTimeZoneL(const RTz &aServer, const TDesC8& aLocation)
{
TInt err = KErrBadName;
CTzId *timezoneid = aServer.GetTimeZoneIdL();
if(timezoneid->TimeZoneNameID() == aLocation)
{
err = KErrNone;
}
delete timezoneid;
return err;
}
bool_t GetIsDst(datetime_t UNUSED_PARAM(t))
{
#ifndef SYMBIAN90
TLocale locale;
return locale.QueryHomeHasDaylightSavingOn();
#else
TBool IsDst=EFalse;
RTz TzServer;
if (TzServer.Connect()==KErrNone)
{
CTzConverter* Converter = CTzConverter::NewL(TzServer);
CTzId* TzId = CTzId::NewL(Converter->CurrentTzId());
IsDst = TzServer.IsDaylightSavingOnL(*TzId);
delete TzId;
delete Converter;
TzServer.Close();
}
return IsDst;
#endif
}
void CTzUserDataTest::TestShortTzId(RTz& aRTz)
{
test.Next(_L("test short TzId behaviour"));
TInt KGreaterThanExpectedVal = 65536; //a value greater than 0xffff i.e. 16 bits
TUint8 groupId = 8; //make up some random value
TUint resourceId = 123; //make up some random value
TRAPD(err, aRTz.LocalizationWriteCityL(_L("myCity"), KGreaterThanExpectedVal, groupId, resourceId));
test(err == KErrArgument);
TRAPD(err1, aRTz.LocalizationDeleteCityL(_L("myCity"), KGreaterThanExpectedVal));
test(err1 == KErrArgument);
TRAPD(err2, aRTz.LocalizationDeleteCityL(_L("myCity"), KGreaterThanExpectedVal - 1));
test(err2 == KErrNotFound);
TRAPD(err3, CTzLocalizedTimeZoneRecord::NewLC(KGreaterThanExpectedVal, _L("standardName"), _L("daylightName"), _L("shortStandardName"), _L("shortDaylighName"), 0));
test(err3 == KErrArgument);
TRAPD(err4, CTzLocalizedCityRecord::NewLC(_L("aCity"), 0, 0, KGreaterThanExpectedVal, 0));
test(err4 == KErrArgument);
}
void CTzUserDataTest::TestTimeZoneRulesL(TTest aWhatToTest)
{
ResetTzUserDataL();
test.Next(_L("Time Zone Rules"));
RTz tz;
User::LeaveIfError(tz.Connect());
CleanupClosePushL(tz);
tz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn);
iUserData = CTzUserData::NewL(tz);
test.Next(_L("Create user-defined Time Zone"));
// Offset 60 There is no DST
test.Printf(_L("Offset 60 There is no DST\n"));
CreateTzAndCheckL(60, 60, tz, aWhatToTest);
// Offset - 60 There is no DST
test.Printf(_L("Offset -60 There is no DST\n"));
CreateTzAndCheckL(-60, -60, tz, aWhatToTest);
// Offset 60 There is DST of 60
CreateTzAndCheckL(60, 120, tz, aWhatToTest);
// Offset - 60 There is DST of 60
test.Printf(_L("Offset - 60 There is DST of 60\n"));
CreateTzAndCheckL(-60, 0, tz, aWhatToTest);
// Create user time zone based on London TZ rules
test.Printf(_L("Create User Tz Based On London Rule\n"));
CreateUserTzBasedOnLondonRuleL(tz, aWhatToTest);
// Create user time zone based on Shanghai TZ rules
test.Printf(_L("Create User Tz Based On Shanghai Rule\n"));
CreateUserTzBasedOnShanghaiRuleL(tz, aWhatToTest);
delete iUserData;
iUserData= NULL;
CleanupStack::PopAndDestroy(&tz);
ResetTzUserDataL();
}
bool_t GetDatePacked(datetime_t t, datepack_t *tp, bool_t Local)
{
TDateTime Date;
TTime ot;
if (!tp || t == INVALID_DATETIME_T) return 0;
ot = DateTimeToSymbian(t);
if (Local)
{
#ifndef SYMBIAN90
TLocale locale;
TTimeIntervalSeconds universalTimeOffset(locale.UniversalTimeOffset());
ot += universalTimeOffset;
if (locale.QueryHomeHasDaylightSavingOn())
{
TTimeIntervalHours daylightSaving(1);
ot += daylightSaving;
}
#else
RTz TzServer;
if (TzServer.Connect()==KErrNone)
{
CTzConverter* Converter = CTzConverter::NewL(TzServer);
Converter->ConvertToLocalTime(ot);
delete Converter;
TzServer.Close();
}
#endif
}
Date = ot.DateTime();
tp->Year = Date.Year();
tp->Month = (int)Date.Month() + 1;
tp->Day = Date.Day()+1;
tp->Hour = Date.Hour();
tp->Minute = Date.Minute();
tp->Second = Date.Second();
return 1;
}
datetime_t TimePackToRel(const datepack_t *tp, bool_t Local)
{
TDateTime Date;
TTime ot;
if (!tp) return INVALID_DATETIME_T;
Date.SetYear(tp->Year);
Date.SetMonth((TMonth)(tp->Month-1));
Date.SetDay(tp->Day-1);
Date.SetHour(tp->Hour);
Date.SetMinute(tp->Minute);
Date.SetSecond(tp->Second);
ot = TTime(Date);
if (Local)
{
#ifndef SYMBIAN90
TLocale locale;
TTimeIntervalSeconds universalTimeOffset(locale.UniversalTimeOffset());
ot -= universalTimeOffset;
if (locale.QueryHomeHasDaylightSavingOn())
{
TTimeIntervalHours daylightSaving(1);
ot -= daylightSaving;
}
#else
RTz TzServer;
if (TzServer.Connect()==KErrNone)
{
CTzConverter* Converter = CTzConverter::NewL(TzServer);
Converter->ConvertToUniversalTime(ot);
delete Converter;
TzServer.Close();
}
#endif
}
return SymbianToDateTime(ot);
}
void CTzUserDataTest::ResetTzUserDataL()
{
RTz tz;
User::LeaveIfError(tz.Connect());
CleanupClosePushL(tz);
CTzUserData* userdata = CTzUserData::NewL(tz);
CleanupStack::PushL(userdata);
userdata->GetTzIdsL(iTzIds);
TInt count = iTzIds.Count();
for (TInt ii=0; ii<count; ++ii)
{
if(ii%KPrintFreq == 0)
{
test.Printf(_L("Deleted %d time zones in the database\n"), ii);
}
userdata->DeleteL(*iTzIds[ii]);
}
CleanupStack::PopAndDestroy(2, &tz);
iTzIds.ResetAndDestroy();
}
void CTzUserDataTest::CachedUserTimeZoneL(RTz& aRTz, TTest aWhatToTest)
{
test.Next(_L("Conver times - Server Response to Changes"));
TInt offset = 60;
TTime utctime (TDateTime(2000, EMay, 0, 0, 0, 0, 0));
//Convert a given time from UTC to local time using the user-defined time zone
TTime localtime = utctime ;
CreateUserTzAndSetCurrentTimeToL(aRTz, offset, offset);
aRTz.ConvertToLocalTime(localtime);
TTimeIntervalMinutes minutes;
localtime.MinutesFrom(utctime, minutes);
test (minutes == TTimeIntervalMinutes(offset));
localtime = utctime;
//Convert a given time from UTC to local time when the corrent tz rule is updated
if(aWhatToTest==EUpdateCachedTz)
{
offset = 120;
UpdateCurrentTzL(aRTz, offset, offset);
}
else if(aWhatToTest==EDeleteCachedTz)
{
//Delete the current tz rule which result in system time reverting to the default time zone.
DeleteCurrentTzL(aRTz);
//Convert a given time from UTC to local time using an existing time zone which is the defaut time zone.
CTzRules* currentRules = aRTz.GetTimeZoneRulesL(0, 9999,ETzUtcTimeReference );
CleanupStack::PushL(currentRules);
offset = currentRules->GetOffsetL(utctime, ETzUtcTimeReference);
CleanupStack::PopAndDestroy(currentRules);
}
aRTz.ConvertToLocalTime(localtime);
localtime.MinutesFrom(utctime, minutes);
test (minutes == TTimeIntervalMinutes(offset));
}
void CTzUserDataTest::ReadIdsAndTestL(RTz& aRTz, TBool aCheckId)
{
test.Next(_L("Read time zone IDs"));
RPointerArray<CTzId> ids;
CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids));
iUserData->GetTzIdsL(ids);
test(iTzIds.Count() == ids.Count());
if(aCheckId)
{
TInt count = ids.Count();
for(TInt ii = 0; ii<count; ++ii)
{
test(ids[ii]->IsUserTzId());
}
//Current time zone is default time zone Europe/London which is not the user-defined time zone.
CTzId* currentId = aRTz.GetTimeZoneIdL();
test (!currentId->IsUserTzId());
delete currentId;
}
CleanupStack::PopAndDestroy(&ids);
}
/** Retrives offsets for various numeric ids in OOM conditions
*/
void CTestTZServer::OOMGetOffsetTZIdsL()
{
RArray<TPtrC> numericIdsList;
CleanupClosePushL(numericIdsList);
TPtrC numericids;
GetStringFromConfig(ConfigSection(), KNumericIds, numericids);
TokenizeStringL(numericids, numericIdsList); //retrieve numeric ids to obtain their offsets
RArray<TInt> tzIds;
CleanupClosePushL(tzIds);
for (TInt i = 0; i < numericIdsList.Count(); i++)
{
TLex lex(numericIdsList[i]);
TInt numericId;
User::LeaveIfError(lex.Val(numericId));
tzIds.Append(numericId);
}
RTz tz;
CleanupClosePushL(tz);
User::LeaveIfError(tz.Connect());
tz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn);
RArray<TInt> offsets;
CleanupClosePushL(offsets);
iFailAt = 1;
for ( ;; )
{
StartHeapCheck(iFailAt);
offsets.Reset();
TRAPD(err,tz.GetOffsetsForTimeZoneIdsL(tzIds,offsets));
if ( err == KErrNone )
{
__UHEAP_RESET;
INFO_PRINTF1(_L("OOM testing of GetOffsetsForTimeZoneIdsL Api is done"));
break;
}
if ( ErrorProcess(err) )
{
EndHeapCheck();
}
else
{
break;
}
}
RArray<TPtrC> expectedOffsetList;
CleanupClosePushL(expectedOffsetList);
TPtrC expectedOffsets;
GetStringFromConfig(ConfigSection(), KOffset, expectedOffsets);
TokenizeStringL(expectedOffsets, expectedOffsetList); //gets the expected offsets for the specified numeric ids
RArray<TInt> expectedOffsetsList;
CleanupClosePushL(expectedOffsetsList);
for (TInt i = 0; i < expectedOffsetList.Count(); i++)
{
TLex lex(expectedOffsetList[i]);
TInt offset;
User::LeaveIfError(lex.Val(offset));
expectedOffsetsList.Append(offset);
}
//compares the expected offsets for the numeric ids with the actual retrieved offsets
TESTL(expectedOffsetsList.Count() == offsets.Count());
for (TInt x = 0; x < expectedOffsetsList.Count(); x++)
{
INFO_PRINTF2(_L("tzid : %d"),tzIds[x]);
}
for (TInt x = 0; x < expectedOffsetsList.Count(); x++)
{
INFO_PRINTF2(_L("actual : %d"),offsets[x]);
}
for (TInt x = 0; x < expectedOffsetsList.Count(); x++)
{
TESTL(expectedOffsetsList[x] == offsets[x]);
}
CleanupStack::PopAndDestroy(&expectedOffsetsList);
CleanupStack::PopAndDestroy(&expectedOffsetList);
CleanupStack::PopAndDestroy(&offsets);
CleanupStack::PopAndDestroy(&tz);
CleanupStack::PopAndDestroy(&tzIds);
CleanupStack::PopAndDestroy(&numericIdsList);
}
/** Convert times using multiple TZ converter objects
*/
void CTestTZServer::MulitpleTZConverterL()
{
CActiveScheduler* scheduler;
scheduler = new CActiveScheduler();
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
TPtrC ptrSystemTime;
TESTL(GetStringFromConfig(ConfigSection(), KTime, ptrSystemTime));
TTime time(ptrSystemTime);
_LIT8(KEuropeLondon, "Europe/London");
CTzId* zoneId = CTzId::NewL(KEuropeLondon);
CleanupStack::PushL(zoneId);
RTz tz;
CTzConverter* timeConverter = NULL;
CTzConverter* timeConverter1 = NULL;
CTzConverter* timeConverter2 = NULL;
CTzConverter* timeConverter3 = NULL;
CTzConverter* timeConverter4 = NULL;
CTzConverter* timeConverter5 = NULL;
CTzConverter* timeConverter6 = NULL;
CTzConverter* timeConverter7 = NULL;
CleanupClosePushL(tz);
User::LeaveIfError(tz.Connect());
TRAPD(err,timeConverter = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter);
TRAP(err,timeConverter1 = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter1);
TRAP(err,timeConverter2 = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter2);
TRAP(err,timeConverter3 = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter3);
TRAP(err,timeConverter4 = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter4);
TRAP(err,timeConverter5 = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter5);
TRAP(err,timeConverter6 = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter6);
TRAP(err,timeConverter7 = CTzConverter::NewL(tz));
TESTL(err == KErrNone);
CleanupStack::PushL(timeConverter7);
TRAP(err, timeConverter->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter1->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter2->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter3->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter4->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter5->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter6->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter7->ConvertToLocalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter1->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter2->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter3->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter4->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter5->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter6->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter7->ConvertToLocalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter1->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter2->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter3->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter4->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter5->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter6->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter7->ConvertToUniversalTime(time));
TESTL(err == KErrNone);
TRAP(err, timeConverter->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter1->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter2->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter3->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter4->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter5->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter6->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
TRAP(err, timeConverter7->ConvertToUniversalTime(time, *zoneId));
TESTL(err == KErrNone);
CleanupStack::PopAndDestroy(timeConverter7);
CleanupStack::PopAndDestroy(timeConverter6);
CleanupStack::PopAndDestroy(timeConverter5);
CleanupStack::PopAndDestroy(timeConverter4);
CleanupStack::PopAndDestroy(timeConverter3);
CleanupStack::PopAndDestroy(timeConverter2);
CleanupStack::PopAndDestroy(timeConverter1);
CleanupStack::PopAndDestroy(timeConverter);
CleanupStack::PopAndDestroy(&tz);
CleanupStack::PopAndDestroy(zoneId);
CleanupStack::PopAndDestroy(scheduler);
CActiveScheduler::Install(NULL);
}
