/** 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); }
/** 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 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; }
/** 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(); }
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); } }
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 }
/** 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); }
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); }
/** 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); }
/** 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::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); }
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::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(); }
/** 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); }
void CTzUserDataTest::BoundaryTestL() { test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZUSERDATA-0013 Boundary Test")); ResetTzUserDataL(); RTz tz; User::LeaveIfError(tz.Connect()); CleanupClosePushL(tz); iUserData = CTzUserData::NewL(tz); // Empty user time zone database. iUserData->GetTzIdsL(iTzIds); test (iTzIds.Count() == 0); CTzId * id = CTzId::NewL(KUserTzIdMin); CleanupStack::PushL(id); CTzRules* rulesGet = NULL; TRAPD(err, rulesGet = iUserData->ReadRulesL(*id)); test (!rulesGet); test (err==KErrNotFound); CTzUserNames* namesGet = NULL; TRAP(err, namesGet = iUserData->ReadNamesL(*id)); test (!namesGet); test (err==KErrNotFound); iUserData->DeleteL(*id); CleanupStack::PopAndDestroy(id); // Create a user time zone with all named KNullDesC. CTzRules* rules = CreateUserDefinedTzLC(0, 0); CTzUserNames* names = CTzUserNames::NewLC(KNullDesC , KNullDesC, KNullDesC, KNullDesC, KNullDesC, KNullDesC); id = iUserData->CreateL(*rules, *names); CleanupStack::PushL(id); CheckTimeZoneL(*id, *rules, *names); // Create a non-user-defined TZID object and reuse it in the following // tests. CTzId* nonUserDefinedTzId = CTzId::NewL(KUserTzIdMin - 1); CleanupStack::PushL(nonUserDefinedTzId); // Attempt to update user-defined TZ data using a TZID which is not a user- // defined TZID. TRAP(err, iUserData->UpdateL(*nonUserDefinedTzId, *rules, *names)); test(err == KErrArgument); // Attempt to read rules from user-defined TZ data using a TZID which is // not a user-defined TZID. TRAP(err, rulesGet = iUserData->ReadRulesL(*nonUserDefinedTzId)); test(err == KErrArgument); // Attempt to read names from user-defined TZ data using a TZID which is // not a user-defined TZID. TRAP(err, namesGet = iUserData->ReadNamesL(*nonUserDefinedTzId)); test(err == KErrArgument); // Attempt to delete from user-defined TZ data using a TZID which is not // a user-defined TZID. TRAP(err, iUserData->DeleteL(*nonUserDefinedTzId)); test(err == KErrArgument); CleanupStack::PopAndDestroy(4, rules); delete iUserData; CleanupStack::PopAndDestroy(&tz); ResetTzUserDataL(); }
/** 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); }
/** Soak/OOM tests for setting and getting time zones and testing of TimeZoneNameID api */ void CTestTZServer::OOMSetCurrentTimeZoneL() { _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); RTz tz; CleanupClosePushL(tz); User::LeaveIfError(tz.Connect()); TInt i = 0; for (i = 0; i < KRepeatApiNumber; i++) { TRAPD(err,tz.SetTimeZoneL(*zoneId)); TESTL(err == KErrNone); } for (i = 0; i < KRepeatApiNumber; i++) { TRAPD(err,tz.SetTimeZoneL(*zoneId1)); TESTL(err == KErrNone); } CTzId* tzId = NULL; iFailAt = 1; for ( ;; ) { StartHeapCheck(iFailAt); TRAPD(err5,tzId = tz.GetTimeZoneIdL()); if ( err5 == KErrNone ) { TESTL(tzId != NULL); __UHEAP_RESET; INFO_PRINTF1(_L("OOM testing of GetTimeZoneIdL()) Api is done")); break; } if ( ErrorProcess( err5) ) { EndHeapCheck(); } else { break; } } CleanupStack::PopAndDestroy(&tz); CleanupStack::PopAndDestroy(zoneId1); CleanupStack::PopAndDestroy(zoneId); }
void CTzUserDataTest::OOMTestL(OOMTestFunction aFunction, TOOMTest aOOMTest) { TInt tryCount = 1; RTz tz; User::LeaveIfError(tz.Connect()); CleanupClosePushL(tz); iUserData = CTzUserData::NewL(tz); TInt cellsBefore = 0; for (;;) { test.Printf(_L("Heap memory allocation set to fail at allocation #%d.\n"), tryCount); if(aOOMTest == EClientOOM) { __UHEAP_SETFAIL(RAllocator::EDeterministic, tryCount); __UHEAP_MARK; } else { TInt heapSize = 0; tz.__dbgSetHeapFailL(RAllocator::EDeterministic, tryCount); cellsBefore = tz.__dbgRequestAllocatedCellsL(heapSize); } TRAPD(err, (this->*aFunction)()); if(err == KErrNone) { test.Printf(_L("OOM test complete.\n")); break; } test(err == KErrNoMemory); if(aOOMTest == EClientOOM) { __UHEAP_MARKEND; } else { tz.__dbgResetHeapL(); TInt heapSize = 0; TInt cellsAfter = tz.__dbgRequestAllocatedCellsL(heapSize); if(cellsBefore != cellsAfter) { test.Printf(_L("ERROR: Memory leak. Heap cells: %d before, %d after.\n"), cellsBefore, cellsAfter); test(EFalse); } } tryCount++; } __UHEAP_RESET; tz.__dbgResetHeapL(); delete iUserData; iUserData = NULL; CleanupStack::PopAndDestroy(&tz); }
TVerdict CTestGetSortedCitiesStep::doTestStepL() /** * @return - TVerdict code * Override of base class virtual * The test is tesing GetCitiesL() with various input parameters, * firstly the TzId and sort key, then a default city and sort key * and finally just a sort key so all cities are found. */ { SetTestStepResult(EPass); TRAPD(errL, iLocalizer = CTzLocalizer::NewL()); __UHEAP_MARK; RTz tz; User::LeaveIfError(tz.Connect()); CleanupClosePushL(tz); CTzUserData* userdata = CTzUserData::NewL(tz); CleanupStack::PushL(userdata); //CreateAUserRuleLC should be in doTestStepPreambleL and clean the data in postamble when Shazia submits her code CreateUserRuleLC(*userdata); iLocalizer->SetDataSource(iDataSource); if (errL == KErrNone) { CTzLocalizedCityArray* cities = NULL; TInt tzId; TPtrC defaultCityFromIni; if (GetIntFromConfig(ConfigSection(),KTzIdTag,tzId)) { _LIT(KTzIdFound,"Get sorted Cities : tz id tag found"); INFO_PRINTF1(KTzIdFound); TRAPD(err1, cities = iLocalizer->GetCitiesL(tzId, iSortOrder)); if (err1 != KErrNone) { _LIT(KGetCitiesLeft,"Get sorted Cities : GetCitiesL left"); ERR_PRINTF1(KGetCitiesLeft); SetTestStepResult(EFail); } CleanupStack::PushL(cities); } else if (GetStringFromConfig(ConfigSection(),KDefaultCityTag,defaultCityFromIni)) { TBuf<40> buf; buf.Copy(defaultCityFromIni); _LIT(KDefCityFound,"Get sorted Cities : Default City Tag found = %S"); INFO_PRINTF2(KDefCityFound, &buf); CTzLocalizedCity* defaultCity = NULL; TRAPD(errdefcity, defaultCity = iLocalizer->GetDefaultCityL(KDefaultTzId)); if (errdefcity == KErrNone) { CleanupStack::PushL(defaultCity); TRAPD(err2, cities = iLocalizer->GetCitiesL(*defaultCity,iSortOrder)); if (err2 != KErrNone) { _LIT(KGetCities2Left,"Get sorted Cities : GetCitiesL(city,sort) left"); ERR_PRINTF1(KGetCities2Left); SetTestStepResult(EFail); } CleanupStack::PopAndDestroy(defaultCity); CleanupStack::PushL(cities); } else { _LIT(KGetDefCityLeft,"Get sorted Cities : GetDefaultCity left"); ERR_PRINTF1(KGetDefCityLeft); SetTestStepResult(EFail); } } else { TRAPD(err3, cities = iLocalizer->GetCitiesL(iSortOrder)); if (err3 != KErrNone) { _LIT(KGetCities3Left,"Get sorted Cities : GetCities(sort) left"); ERR_PRINTF1(KGetCities3Left); SetTestStepResult(EFail); } CleanupStack::PushL(cities); } //Loop through the cities array and match against ini file data if (cities != NULL) { TBuf<50> cityTag; for(TInt n=0; n < cities->Count(); n++) { cityTag = KCityTag; cityTag.AppendNum(n + 1); TPtrC CityNameFromIni; TPtrC temp(cities->At(n).Name() ); if ( !GetStringFromConfig(ConfigSection(), cityTag, CityNameFromIni)) //i.e. cities->At(n).Name() != CityNameFromIni) { if ( (&temp)->Length()!=0 ) { if ( (&CityNameFromIni)->Length()!=0) { _LIT(KMessage,"Got city: %S, instead of: %S"); ERR_PRINTF3(KMessage, &temp, &CityNameFromIni); } else { _LIT(KMessage,"Got city: %S, Was expecting NULL"); ERR_PRINTF2(KMessage, &temp); } } else { _LIT(KMessage,"Got NULL, Was expecting city: %S"); ERR_PRINTF2(KMessage, &CityNameFromIni); } SetTestStepResult(EFail); } else if (cities->At(n).Name()!=CityNameFromIni) { _LIT(KNoMatch,"TestGetSortedCitiesStep: City names do not match. Expected %S, got %S."); ERR_PRINTF3(KNoMatch, &CityNameFromIni, &temp); SetTestStepResult(EFail); } } } CleanupStack::PopAndDestroy(cities); } else { SetTestStepResult(EFail); _LIT(KNewLeft,"TestGetSortedCitiesStep: Problem with NewL"); ERR_PRINTF1(KNewLeft); } //the following doesn't need when Shazia submits her code CleanupStack::PopAndDestroy(2); __UHEAP_MARK; return TestStepResult(); }
/** Performs time conversions (in OOM conditions) to local/universal times either using system or specified time zone */ void CTestTZServer::OOMTimeConversionsL() { CActiveScheduler* scheduler; scheduler = new CActiveScheduler(); CleanupStack::PushL(scheduler); CActiveScheduler::Install(scheduler); _LIT8(KEuropeLondon, "Europe/London"); CTzId* zoneId = CTzId::NewL(KEuropeLondon); CleanupStack::PushL(zoneId); RTz tz; CTzConverter* timeConverter = NULL; CleanupClosePushL(tz); User::LeaveIfError(tz.Connect()); TRAPD(err, timeConverter = CTzConverter::NewL(tz)); TESTL( err == KErrNone ); CleanupStack::PushL(timeConverter); TPtrC ptrSystemTime; TESTL(GetStringFromConfig(ConfigSection(), KTime, ptrSystemTime)); TTime time(ptrSystemTime); iFailAt = 1; for ( ;; ) { StartHeapCheck(iFailAt); TInt err = timeConverter->ConvertToLocalTime(time); if ( err == KErrNone ) { __UHEAP_RESET; INFO_PRINTF1(_L("OOM testing of ConvertToLocalTime Api (using current time zone) is done")); break; } if ( ErrorProcess(err) ) { EndHeapCheck(); } else { break; } } iFailAt = 1; for ( ;; ) { StartHeapCheck(iFailAt); TInt err = timeConverter->ConvertToLocalTime(time, *zoneId); if ( err == KErrNone ) { __UHEAP_RESET; INFO_PRINTF1(_L("OOM testing of ConvertToLocalTime Api (specifiying time zone) is done")); break; } if ( ErrorProcess(err) ) { EndHeapCheck(); } else { break; } } iFailAt = 1; for ( ;; ) { StartHeapCheck(iFailAt); TInt err = timeConverter->ConvertToUniversalTime(time); if ( err == KErrNone ) { __UHEAP_RESET; INFO_PRINTF1(_L("OOM testing of ConvertToUniversalTime Api (using current time zone) is done")); break; } if ( ErrorProcess(err) ) { EndHeapCheck(); } else { break; } } iFailAt = 1; for ( ;; ) { StartHeapCheck(iFailAt); TInt err = timeConverter->ConvertToUniversalTime(time, *zoneId); if ( err == KErrNone ) { __UHEAP_RESET; INFO_PRINTF1(_L("OOM testing of ConvertToUniversalTime (specifiying time zone) Api is done")); break; } if ( ErrorProcess(err) ) { EndHeapCheck(); } else { break; } } CleanupStack::PopAndDestroy(timeConverter); CleanupStack::PopAndDestroy(&tz); CleanupStack::PopAndDestroy(zoneId); CleanupStack::PopAndDestroy(scheduler); CActiveScheduler::Install(NULL); }
/* @file @SYMTestCaseID SYSLIB-SCHSVR-CIT-0279 @SYMTestCaseDesc Persistant schedule - UTC & Hometime @SYMTestPriority High @SYMTestActions For time and condition based test schedule task and check it fires @SYMTestExpectedResults The test must not fail. @SYMPREQ PREQ234 */ TVerdict Cpersist_mixedStep::doTestStepL() /** * @return - TVerdict code * Override of base class pure virtual * Our implementation only gets called if the base class doTestStepPreambleL() did * not leave. That being the case, the current test result value will be EPass. */ { SetTestStepResult(EFail); _LIT(KTestName1, "Persistant Mixed - Hometime"); _LIT(KTaskData1, "This is some really exciting task data (number 1)"); _LIT(KTestName2, "Persistant Mixed - UTC"); _LIT(KTaskData2, "This is some really exciting task data (number 2)"); // Tests with timezone set to Europe, London RTz tz; tz.Connect(); CTzId* tzId = CTzId::NewL(2592); //set the timezone to Europe/London CleanupStack::PushL(tzId); tz.SetTimeZoneL(*tzId); // Set the time to a known value, since this makes testing much easier (and more // repeatable). SchSvrHelpers::SetUTCTimeL(TTime(TDateTime(2000, EJanuary, 1, 9, 55, 0, 0))); // 9:55 am // Prepare schedules describing when we want the tasks to run (10:00 am & 10.00) // Creates a hometime based daily persistant schedule TSchedulerItemRef ref1; // This is the time when we want the Hometime time-based schedule to fire TDateTime datetime1(2000, EJanuary, 1, 11, 0, 0, 0); TTsTime startTimeForSchedule1(datetime1, EFalse); // 11:00 am { CScheduleEntryInfoArray* entryList = new (ELeave) CScheduleEntryInfoArray(1); CleanupStack::PushL(entryList); TScheduleEntryInfo2 entry1 (startTimeForSchedule1, EDaily, 1, 30); entryList->AppendL(entry1); TInt res = TheScheduler.CreatePersistentSchedule(ref1, *entryList); TESTL(res==KErrNone); CleanupStack::PopAndDestroy(); // entryList } // Disable the schedule whilst we set it up User::LeaveIfError(TheScheduler.DisableSchedule(ref1.iHandle)); // Creates a UTC based daily persistant schedule TSchedulerItemRef ref2; // This is the time when we want the UTC time-based schedule to fire TDateTime datetime2(2000, EJanuary, 1, 10, 0, 0, 0); TTsTime startTimeForSchedule2(datetime2, ETrue); // 10:00 am { CScheduleEntryInfoArray* entryList = new (ELeave) CScheduleEntryInfoArray(1); CleanupStack::PushL(entryList); TScheduleEntryInfo2 entry1 (startTimeForSchedule2, EDaily, 1, 30); entryList->AppendL(entry1); TInt res = TheScheduler.CreatePersistentSchedule(ref2, *entryList); TESTL(res==KErrNone); CleanupStack::PopAndDestroy(); // entryList } // Disable the schedule whilst we set it up User::LeaveIfError(TheScheduler.DisableSchedule(ref2.iHandle)); // Kill the server to check if persisted schedules have been stored // Need to turn off JIT dubugging as we are panicking server and we // want test to keep running. TBool jit = User::JustInTime(); User::SetJustInTime(EFalse); TheScheduler.__FaultServer(); // Change UTC Offset whilst server is down // Set UTC offset to +1Hr by moving to Europe, Paris tzId = CTzId::NewL(2656); //set the timezone to Europe/Paris tz.SetTimeZoneL(*tzId); User::After(1000000); // Turn on JIT again. User::SetJustInTime(jit); // Connect to the server again TInt res = TheScheduler.Connect(); TESTL(res==KErrNone); // Re-register TESTL(SchSvrHelpers::RegisterClientL(TheScheduler)==KErrNone); // Associate a task with the time-based schedule TTaskInfo taskInfo1; taskInfo1.iName = KTestName1; taskInfo1.iPriority = 2; taskInfo1.iRepeat = 0; // Create some data associated with this task HBufC* taskData1 = KTaskData1().AllocLC(); User::LeaveIfError(TheScheduler.ScheduleTask(taskInfo1, *taskData1, ref1.iHandle)); CleanupStack::PopAndDestroy(); // taskData1 // Associate a task with the condition-based schedule TTaskInfo taskInfo2; taskInfo2.iName = KTestName2; taskInfo2.iPriority = 2; taskInfo2.iRepeat = 0; // Create some data associated with this task HBufC* taskData2 = KTaskData2().AllocLC(); User::LeaveIfError(TheScheduler.ScheduleTask(taskInfo2, *taskData2, ref2.iHandle)); CleanupStack::PopAndDestroy(); // taskData2 // Set the UTC time such that both schedules fire at the same time SchSvrHelpers::SetUTCTimeL(TTime(TDateTime(2000, EJanuary, 1, 9, 59, 50, 0))); // 9:59.50 am User::LeaveIfError(TheScheduler.EnableSchedule(ref1.iHandle)); User::LeaveIfError(TheScheduler.EnableSchedule(ref2.iHandle)); // Now wait for the time-based schedule to fire TESTL(STaskSemaphore::WaitL(KDefaultTimeout) == KErrNone); // Now wait for the condition-based schedule to fire TESTL(STaskSemaphore::WaitL(KDefaultTimeout) == KErrNone); TTime timeNow; timeNow.HomeTime(); TESTL(SchSvrHelpers::IsTimeTheSameNoSeconds(TTsTime(timeNow, EFalse), startTimeForSchedule1)); timeNow.UniversalTime(); TESTL(SchSvrHelpers::IsTimeTheSameNoSeconds(TTsTime(timeNow, ETrue), startTimeForSchedule2)); CleanupStack::PopAndDestroy(); // timezone ID CleanupHelpers::KillProcess(KMinimalTaskHandler); SetTestStepResult(EPass); return TestStepResult(); }