diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/Test/tuserdefinedtzalarms.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonappservices/alarmserver/Test/tuserdefinedtzalarms.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,303 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "ASTstAlarmTest.h" +#include "ASSrvDefs.h" +#include +#include +#include +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#include +#endif + +// +class CUserDefinedFloatingAlarmTest:public CBase + { +public: + static CUserDefinedFloatingAlarmTest* NewLC(); + ~CUserDefinedFloatingAlarmTest(); + void TestFloatingAlarmWithUserDefinedRulesL(); + +private: + CUserDefinedFloatingAlarmTest(); + void DeleteAllAlarmsL(); + void TestTimesEqual(const TTime& aTime1, const TTime& aTime2); + void ResetDataL(); + CTzRules* CreateRulesL(TInt aOffset); + CTzUserNames* CreateNamesL(); + void CreateString(TDes& aString); + +private: + TInt64 iSeed; + }; + +CUserDefinedFloatingAlarmTest::CUserDefinedFloatingAlarmTest():iSeed(100) + { + } + +CUserDefinedFloatingAlarmTest::~CUserDefinedFloatingAlarmTest() + { + TRAP_IGNORE(ResetDataL()); + } + +CUserDefinedFloatingAlarmTest* CUserDefinedFloatingAlarmTest::NewLC() + { + CUserDefinedFloatingAlarmTest* self = new(ELeave) CUserDefinedFloatingAlarmTest(); + CleanupStack::PushL(self); + return self; + } + +void CUserDefinedFloatingAlarmTest::TestTimesEqual(const TTime& aTime1, const TTime& aTime2) + { + // determine the difference, in minutes + TTimeIntervalMinutes timeDiffMinutes; + const TInt error = aTime2.MinutesFrom(aTime1, timeDiffMinutes); + TheAlarmTest(error == KErrNone); + // check the times are within 1 minute + const TTimeIntervalMinutes maxDiff(1); + const TTimeIntervalMinutes minDiff(-1); + TheAlarmTest(((timeDiffMinutes <= maxDiff) && (timeDiffMinutes >= minDiff))); + } + +void CUserDefinedFloatingAlarmTest::DeleteAllAlarmsL() + { + // Delete all alarms + RArray categories; + TheAlarmTest.Session().GetAvailableCategoryListL(categories); + TInt count = categories.Count(); + for(TInt i=0; i* ids = static_cast*>(aPtr); + if (ids) + { + ids->ResetAndDestroy(); + } + } + +void CUserDefinedFloatingAlarmTest::ResetDataL() + { + RTz tz; + User::LeaveIfError(tz.Connect()); + CleanupClosePushL(tz); + CTzUserData* userdata = CTzUserData::NewL(tz); + CleanupStack::PushL(userdata); + RPointerArray ids; + CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids)); + userdata->GetTzIdsL(ids); + TInt count = ids.Count(); + for (TInt ii=0; iiDeleteL(*ids[ii]); + } + CleanupStack::PopAndDestroy(3, &tz); + } + +CTzRules* CUserDefinedFloatingAlarmTest::CreateRulesL(TInt aOffset) + { + //Create time zone rules + TTzRule rule1(2007, 2009, aOffset, 0, EOctober, ETzFixedDate, 0, 0, ETzWallTimeReference, 120); + TTzRule rule2(2007,2009,0,aOffset,EMarch,ETzFixedDate,0,0,ETzWallTimeReference,0); + + CTzRules* rules = CTzRules::NewL(0, 9999); + CleanupStack::PushL(rules); + rules->AddRuleL(rule1); + rules->AddRuleL(rule2); + + return rules; + } + +void CUserDefinedFloatingAlarmTest::CreateString(TDes& aString) + { + for (TInt i(0) ; i < 10 ; ++i) + { + // Add random upper and lower case letters + aString.Append( 'A' + (Math::Rand(iSeed) % 26) ); + } + } + +CTzUserNames* CUserDefinedFloatingAlarmTest::CreateNamesL() + { + TBuf<10> stdName; + CreateString(stdName); + TBuf<10> shortStdName; + CreateString(shortStdName); + TBuf<10> dstName; + CreateString(dstName); + TBuf<10> shortDstName; + CreateString(shortDstName); + TBuf<10> cityName; + CreateString(cityName); + TBuf<10> regionName; + CreateString(regionName); + + return CTzUserNames::NewLC(stdName, shortStdName, dstName, shortDstName, cityName, regionName); + } + +/** Floating local time alarm using user defined time zone + +@SYMTestCaseID PIM-APPSRV-ALS-TZC-0001 +@SYMTestCaseDesc The purpose of this test is to verify that + the expiry time of a floating local time + alarm is correct when the time zone rules + data for the current time zone is changed. +@SYMTestActions 1. Create a user defined time zone with a UTC + offset of 2 hours. + 2. Set the current time zone to the user defined + time zone. + 3. Create a floating local time alarm using the + Alarm Server that is due to expire 2 hours + + t minutes from the current local time. + 4. Modify the user defined time zone to have a UTC + offset of 0 hours. +@SYMTestExpectedResults The alarm expires no longer than t minutes from the + current local time. +@SYMTestType CIT +@SYMTestPriority 1 + +*/ +void CUserDefinedFloatingAlarmTest::TestFloatingAlarmWithUserDefinedRulesL() + { + //Clear the alarmserver's queue + DeleteAllAlarmsL(); + //Clear the user-defined database + ResetDataL(); + RTz tz; + CleanupClosePushL(tz); + User::LeaveIfError(tz.Connect()); + + CTzUserData* userData = CTzUserData::NewL(tz); + CleanupStack::PushL(userData); + TheAlarmTest.Test().Printf(_L("@SYMTestCaseID PIM-APPSRV-ALS-TZC-0001 Add a user-defined time zone rule to the database\n")); + + //aOffset = 60 + CTzRules* rules = CreateRulesL(60); + + CTzUserNames* names = CreateNamesL(); + + CTzId* id = NULL; + id = userData->CreateL(*rules, *names); //Create user-defined rules + + CleanupStack::PopAndDestroy(2, rules); + + //Set the current time zone to the user-defined zone + tz.SetTimeZoneL(*id); + tz.SetHomeTime(TDateTime(2008, EJuly, 11, 7, 0, 0, 0)); + + TTime now; + now.HomeTime(); + TDateTime dt = now.DateTime(); + TheAlarmTest.Test().Printf(_L("The current home time is hours: %d, minutes: %d, seconds:%d \r\n"), + dt.Hour(), dt.Minute(), dt.Second()); + + TASShdAlarm alarm; + alarm.Category() = KASCliCategoryClock; + alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce; + + TDateTime date; + //Set the time for the floating alarm + alarm.NextDueTime().HomeTime(); + alarm.NextDueTime() += TTimeIntervalMinutes(61); + //Add the floating alarm to the server's queue + TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alarm) == KErrNone, __LINE__); + const TAlarmId alarmId = alarm.Id(); + TheAlarmTest(alarmId != KNullAlarmId, __LINE__); + + date=alarm.NextDueTime().DateTime(); + TheAlarmTest.Test().Printf(_L("Floating alarm with id %d has due time hours: %d,\ + minutes: %d, seconds: %d.\r\n"), alarmId,date.Hour(), date.Minute(), date.Second()); + + CTzRules* newRule = CreateRulesL(120); + + CTzUserNames* newNames = CreateNamesL(); + + //Update the rule + userData->UpdateL(*id, *newRule, *newNames); + + now.HomeTime(); + dt = now.DateTime(); + TheAlarmTest.Test().Printf(_L("The new local time after update is hours: %d, minutes: %d, seconds:%d \r\n"), + dt.Hour(), dt.Minute(), dt.Second()); + + date = alarm.NextDueTime().DateTime(); + TheAlarmTest.Test().Printf(_L("Floating alarm has a new due time : hours: %d, minutes:\ + %d, seconds: %d.\r\n"),date.Hour(), date.Minute(), date.Second()); + + now.HomeTime(); + TestTimesEqual(alarm.NextDueTime(), now); + + CleanupStack::PopAndDestroy(2, newRule); + delete id; + CleanupStack::PopAndDestroy(userData); + CleanupStack::PopAndDestroy(&tz); + // Clear all the alarms from the queue + DeleteAllAlarmsL(); + ResetDataL(); + } + +// + +static void doTestsL() + { + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler; + CleanupStack::PushL(scheduler); + CActiveScheduler::Install(scheduler); + + TheAlarmTest.TestStartServers(); + TheAlarmTest(TheAlarmTest.Session().Connect() == KErrNone, __LINE__); + + CUserDefinedFloatingAlarmTest* testFloatingAlarm = CUserDefinedFloatingAlarmTest::NewLC(); + + testFloatingAlarm->TestFloatingAlarmWithUserDefinedRulesL(); + + // cleanup + CleanupStack::PopAndDestroy(testFloatingAlarm); + CleanupStack::PopAndDestroy(scheduler); + } + +// + + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if (!cleanup) + return KErrNoMemory; + + TheAlarmTest.Test().Title(); + TheAlarmTest.Test().Start(_L("Alarms with user-defined rules")); + + + TRAPD(error, doTestsL()); + + // did any test leave? + TheAlarmTest(error == KErrNone, __LINE__); + + TheAlarmTest.Test().End(); + TheAlarmTest.Test().Close(); + ASTstAlarmTest::Close(); + delete cleanup; + __UHEAP_MARKEND; + return KErrNone; + }