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); }