/** 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();
}
