--- /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 <tz.h>
+#include <vtzrules.h>
+#include <e32math.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <tzusernames.h>
+#include <tzuserdefineddata.h>
+#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<TAlarmCategory> categories;
+ TheAlarmTest.Session().GetAvailableCategoryListL(categories);
+ TInt count = categories.Count();
+ for(TInt i=0; i<count; i++)
+ {
+ const TAlarmCategory category = categories[i];
+ User::LeaveIfError(TheAlarmTest.Session().AlarmDeleteAllByCategory(category, EFalse));
+ }
+ categories.Close();
+ }
+
+LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr)
+ {
+ RPointerArray<CTzId>* ids = static_cast<RPointerArray<CTzId>*>(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<CTzId> ids;
+ CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids));
+ userdata->GetTzIdsL(ids);
+ TInt count = ids.Count();
+ for (TInt ii=0; ii<count; ++ii)
+ {
+ userdata->DeleteL(*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;
+ }