--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/commonappservices/alarmserver/Test/ssm/TWakeupAlarms.cpp Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,1572 @@
+// 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 "asclisoundplay.h"
+#include "testserver.h"
+#include <tz.h>
+#include <e32property.h>
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+#include <ssm/ssmstates.hrh>
+#endif
+#ifdef __WINS__
+#include "consoleantestclient.h"
+#endif
+
+_LIT(KTestName, "@SYMTestCaseID:PIM-TWAKEUPALARMS-0001 Wakeup Alarms");
+_LIT(KFormatDateTime, "%D%M%Y%/0%1%/1%2%/2%3%/3 %H:%T:%S.%C");
+_LIT(KAlarmServerFile, "c:\\private\\101f5027\\AlarmServer.ini");
+_LIT(KAlarmServerProcessNameMatch, "alarmserver.exe*");
+
+const TTimeIntervalMicroSeconds32 KAlarmWaitToNotifyPeriod(500000);
+
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+_LIT8(KAlarmData, "sausage");
+
+_LIT8(KTokyo, "Asia/Tokyo"); // No DST changes in Tokyo
+_LIT8(KSydney, "Australia/Sydney"); // Large positive standard offset
+#endif
+_LIT8(KLondon, "Europe/London"); // Large positive standard offset
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+_LIT8(KChicago, "America/Chicago"); // Large negative standard offset
+
+const TUid KAlarmServerUID = {0x101f5027};
+const TInt KRTCValueKey = 200;
+const TInt KSystemStateChangeKey = 301;
+const TInt KSystemStateChangeAckKey = 302;
+
+TAlarmCategory KAlarmCategory = {0x10101010};
+#endif
+
+class CAlarmTestApp : public CBase
+ {
+public:
+ static CAlarmTestApp* NewLC();
+ ~CAlarmTestApp();
+
+ void RunTestsL();
+
+private: // the test cases
+
+ void TestAlarmMissingHourRepeatOnce1L();
+ void TestAlarmMissingHourRepeatOnce2L();
+ void TestAlarmMissingHourRepeatOnce3L();
+ void TestAlarmMissingHourRepeatDailyL();
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+ void TestWakeupFlagPersistanceL();
+ void TestSetWakeupSessionAlarmL();
+ void TestDeleteWakeupAlarmL();
+ void TestDisableWakeupAlarmL();
+ void TestUnsetWakeupFlagL();
+ void TestWakeupAlarmRobustnessL();
+
+ void TestSnoozeWakeupAlarmL();
+
+ void TestFixedAlarmL();
+
+ void TestRTCSetOnDSTRolloverL();
+ void TestSetRTCOnDeviceShutdownL();
+ void TestRTCSetOnTimeZoneChangeL();
+ void TestRTCSetOnSystemTimeChangeL();
+
+ void TestHeadWakeupAlarmL();
+
+ void TestWakeupAlarmTimeL();
+ void DoTestWakeupAlarmTimeL(const TTime& aSystemLocalTime, const TTime& aAlarmTimeUTC, TTimeIntervalMinutes aNextUTCOffset, const TDesC8& aTimeZoneName);
+
+ void TestReadOnlyInShutDownL();
+ void TestAlarmFileNotWrittenOnTimeZoneChangeL();
+ void TestAlarmFileNotWrittenOnSystemTimeChangeL();
+
+ void TestWriteCommandsL(TASShdAlarm& aASShdAlarm, TInt aExpectedErrorCode);
+ void TestReadCommandsL(TASShdAlarm& aASShdAlarm);
+#endif
+
+private:
+ CAlarmTestApp();
+ void ConstructL();
+
+ // Utility methods
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+ TASShdAlarm CreateAlarm(const TTime& aAlarmTime, TBool aWakeup);
+#endif
+ void AddAlarmL(TASShdAlarm& aAlarm);
+ void DeleteAlarmL(TAlarmId aAlarmId);
+ void DeleteAllAlarmsL();
+
+ void TestAlarmNotifyL(TASShdAlarm& aAlarm, const TTime& aNotifyTime, TBool aExpectedToNotify);
+
+ void SetTimeZoneL(const TDesC8& aTimeZoneName);
+ void SetHomeTimeL(const TTime& aSystemLocalTime);
+
+ void RestartAlarmServerL();
+
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+ void TestRTCValueL(const TTime& aRTCValue);
+#endif
+ void PrintTimeL(const TTime& aTime, const TDesC& aPrefix);
+
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+ void SendSsmSystemMessageL(TSsmMainSystemStates aSsmMessage);
+#endif
+
+private:
+ RPIMTestServer iPIMTestServer;
+ RTz iTz;
+ CTzId* iSavedTzID;
+#ifdef __WINS__
+ RANTestClient iClient;
+#endif
+ };
+
+CAlarmTestApp* CAlarmTestApp::NewLC()
+ {
+ CAlarmTestApp* self = new (ELeave) CAlarmTestApp();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ //CleanupStack::Pop(self);
+ return self;
+ }
+
+CAlarmTestApp::CAlarmTestApp()
+ {
+ }
+
+void CAlarmTestApp::ConstructL()
+ {
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+ User::LeaveIfError(RProperty::Define(KAlarmServerUID, KRTCValueKey, RProperty::EByteArray, sizeof(TPckgC<TTime>) ) );
+ User::LeaveIfError(RProperty::Define(KAlarmServerUID, KSystemStateChangeKey, RProperty::EInt));
+ User::LeaveIfError(RProperty::Define(KAlarmServerUID, KSystemStateChangeAckKey, RProperty::EInt));
+#endif
+
+ // The time zone server must be running with auto dst updates enabled for this test to work
+ User::LeaveIfError(iTz.Connect());
+ iTz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn);
+
+ // save the current time zone
+ iSavedTzID = iTz.GetTimeZoneIdL();
+ User::LeaveIfError(iPIMTestServer.Connect());
+
+ TheAlarmTest.TestStartServers();
+ User::LeaveIfError(TheAlarmTest.Session().Connect());
+
+ // Make sure the test starts without any alarms set
+ DeleteAllAlarmsL();
+
+#ifdef __WINS__
+ User::LeaveIfError(iClient.Connect());
+ User::LeaveIfError(iClient.SetExtendedMode());
+#endif
+ }
+
+CAlarmTestApp::~CAlarmTestApp()
+ {
+#ifdef __WINS__
+ iClient.UnsetExtendedMode();
+ iClient.Close();
+#endif
+
+ iPIMTestServer.Close();
+
+ // restore the saved time zone
+ TRAP_IGNORE(SetTimeZoneL(iSavedTzID->TimeZoneNameID()));
+ delete iSavedTzID;
+ iTz.Close();
+ }
+
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+void CAlarmTestApp::SendSsmSystemMessageL(TSsmMainSystemStates aSsmMessage)
+ {
+ TheAlarmTest.Test().Printf(_L("Entering system state %d"), aSsmMessage);
+
+ RProperty ackProperty;
+ User::LeaveIfError(ackProperty.Attach(KAlarmServerUID, KSystemStateChangeAckKey));
+ TRequestStatus status;
+ ackProperty.Subscribe(status);
+
+ User::LeaveIfError(RProperty::Set(KAlarmServerUID, KSystemStateChangeKey, aSsmMessage));
+
+ User::WaitForRequest(status);
+ }
+#endif
+
+void CAlarmTestApp::SetHomeTimeL(const TTime& aSystemLocalTime)
+ {
+ PrintTimeL(aSystemLocalTime, _L("Set Home Time to : "));
+ User::LeaveIfError(iTz.SetHomeTime(aSystemLocalTime));
+ }
+
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+void CAlarmTestApp::TestRTCValueL(const TTime& aRTCValue)
+ {
+ TheAlarmTest.Test().Printf(_L("Test the RTC Value"));
+
+ User::After(200000);
+ TPckgBuf<TTime> rtcValuePckgBuf;
+ RProperty::Get(KAlarmServerUID, KRTCValueKey, rtcValuePckgBuf);
+
+ if (aRTCValue == Time::NullTTime())
+ {
+ TheAlarmTest.Test().Printf(_L("Check the RTC is not set"));
+ }
+ else
+ {
+ PrintTimeL(aRTCValue, _L("Check the RTC is set to : "));
+ }
+
+ if (rtcValuePckgBuf() == Time::NullTTime())
+ {
+ TheAlarmTest.Test().Printf(_L("The RTC is not set"));
+ }
+ else
+ {
+ PrintTimeL(rtcValuePckgBuf(), _L("The RTC is set to : "));
+ }
+
+ TheAlarmTest(rtcValuePckgBuf() == aRTCValue);
+ }
+
+TASShdAlarm CAlarmTestApp::CreateAlarm(const TTime& aAlarmTime, TBool aWakeup)
+ {
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ _LIT(KMessage, "An alarm");
+ alarm.Message() = KMessage;
+ alarm.SetWakeup(aWakeup);
+
+ if (aAlarmTime == Time::NullTTime())
+ {
+ alarm.NextDueTime().HomeTime();
+ alarm.NextDueTime() += TTimeIntervalDays(1);
+ }
+ else
+ {
+ alarm.NextDueTime() = aAlarmTime;
+ }
+
+ return alarm;
+ }
+#endif
+
+void CAlarmTestApp::AddAlarmL(TASShdAlarm& aAlarm)
+ {
+ TheAlarmTest.Test().Printf(_L("Adding an alarm"));
+ TRequestStatus status;
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, status, KAlarmServerFile);
+ TInt addError = TheAlarmTest.Session().AlarmAdd(aAlarm);
+
+ if (addError != KErrNone)
+ {
+ iPIMTestServer.FileServerNotifyChangeCancel();
+ }
+ else
+ {
+ TheAlarmTest.Test().Printf(_L("Added alarm %d"), aAlarm.Id());
+ }
+
+ User::WaitForRequest(status);
+ User::LeaveIfError(addError);
+ }
+
+void CAlarmTestApp::DeleteAlarmL(TAlarmId aAlarmId)
+ {
+ TheAlarmTest.Test().Printf(_L("Deleting alarm %d"), aAlarmId);
+ TRequestStatus status;
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, status, KAlarmServerFile);
+ TheAlarmTest.Session().AlarmDelete(aAlarmId);
+ RTimer timeoutTimer;
+ User::LeaveIfError(timeoutTimer.CreateLocal());
+ TRequestStatus timeoutTimerStatus;
+ timeoutTimer.After(timeoutTimerStatus, 2000000);
+ User::WaitForRequest(status, timeoutTimerStatus);
+ timeoutTimer.Cancel();
+ iPIMTestServer.FileServerNotifyChangeCancel();
+ User::WaitForRequest(status, timeoutTimerStatus);
+ }
+
+void CAlarmTestApp::SetTimeZoneL(const TDesC8& aTimeZoneName)
+ {
+ TBuf<50> timeZoneName;
+ timeZoneName.Copy(aTimeZoneName);
+ TheAlarmTest.Test().Printf(_L("Changing TimeZone to : %S"), &timeZoneName);
+
+ CTzId* tzID = CTzId::NewL(aTimeZoneName);
+ CleanupStack::PushL(tzID);
+ iTz.SetTimeZoneL(*tzID);
+ CleanupStack::PopAndDestroy(tzID);
+ }
+
+void CAlarmTestApp::PrintTimeL(const TTime& aTime, const TDesC& aPrefix)
+ {
+ TFileName dateString;
+ aTime.FormatL(dateString, KFormatDateTime);
+ TheAlarmTest.Test().Printf(_L("%S %S\n"),&aPrefix, &dateString);
+ }
+
+void CAlarmTestApp::DeleteAllAlarmsL()
+ {
+ RArray<TAlarmId> alarmIds;
+ CleanupClosePushL(alarmIds);
+ TheAlarmTest.Session().GetAlarmIdListL(alarmIds);
+
+ const TInt KAlarmCount(alarmIds.Count());
+ for (TInt i(0) ; i < KAlarmCount ; ++i )
+ {
+ TheAlarmTest.Test().Printf(_L("deleting an alarm"));
+ User::LeaveIfError(TheAlarmTest.Session().AlarmDelete(alarmIds[i]));
+ }
+
+ CleanupStack::PopAndDestroy(&alarmIds);
+ }
+
+void CAlarmTestApp::RestartAlarmServerL()
+ {
+ TheAlarmTest.Test().Printf(_L("Restarting the alarm server"));
+ TheAlarmTest.Session().Close();
+
+ iPIMTestServer.KillProcessL(KAlarmServerProcessNameMatch);
+
+ User::LeaveIfError(TheAlarmTest.Session().Connect());
+ }
+
+#ifndef __WINS__
+void CAlarmTestApp::TestAlarmNotifyL(TASShdAlarm& /*aAlarm*/, const TTime& /*aNotifyTime*/, TBool /*aExpectedToNotify*/)
+ {
+ TheAlarmTest.Test().Printf(_L("This cannot be tested on hardware"));
+#else
+void CAlarmTestApp::TestAlarmNotifyL(TASShdAlarm& aAlarm, const TTime& aNotifyTime, TBool aExpectedToNotify)
+ {
+ aExpectedToNotify?
+ TheAlarmTest.Test().Printf(_L("Test that the alarm will notify")):
+ TheAlarmTest.Test().Printf(_L("Test that the alarm will NOT notify"));
+
+ TheAlarmTest.Test().Printf(_L("Close the alarm server"));
+ TheAlarmTest.Session().Close();
+ iPIMTestServer.KillProcessL(KAlarmServerProcessNameMatch);
+
+ SetHomeTimeL(aNotifyTime);
+
+ // start observing the alarm notification
+ TRequestStatus alarmStatus;
+ iClient.NotifyOnAlarm(aAlarm, alarmStatus);
+
+ TheAlarmTest.Test().Printf(_L("Start the alarm server"));
+ User::LeaveIfError(TheAlarmTest.Session().Connect());
+
+ // Create timeout timer
+ RTimer timeoutTimer;
+ User::LeaveIfError(timeoutTimer.CreateLocal());
+ TRequestStatus timeoutTimerStatus;
+ timeoutTimer.After(timeoutTimerStatus, KAlarmWaitToNotifyPeriod);
+
+ // Wait for the alarm to expire
+ User::WaitForRequest(alarmStatus, timeoutTimerStatus);
+
+ if (alarmStatus.Int() == KErrNone)
+ {
+ TheAlarmTest.Test().Printf(_L("The alarm notified"));
+
+ iClient.AcknowledgeAlarm(aAlarm.Id());
+ timeoutTimer.Cancel();
+ User::WaitForRequest(timeoutTimerStatus);
+
+ TheAlarmTest(aExpectedToNotify);
+ }
+ else
+ {
+ TheAlarmTest.Test().Printf(_L("The alarm DID NOT notify"));
+ iClient.CancelNotifications();
+ User::WaitForRequest(alarmStatus);
+
+ TheAlarmTest(!aExpectedToNotify);
+ }
+
+ // Make sure there are no other alarms notifying
+ RArray<TAlarmId> alarmIds;
+ CleanupClosePushL(alarmIds);
+ TheAlarmTest.Session().GetAlarmIdListByStateL(EAlarmStateNotifying, alarmIds);
+ TheAlarmTest(alarmIds.Count() == 0);
+ CleanupStack::PopAndDestroy(&alarmIds);
+#endif
+ }
+
+void CAlarmTestApp::TestAlarmMissingHourRepeatDailyL()
+ {
+ TheAlarmTest.Test().Next(_L("Test a repeating alarm in the missing hour"));
+ SetTimeZoneL(KLondon);
+
+ // Set home time to (before DST threshold)
+ // Saturday, 29 March 2008, 00:12:00
+ SetHomeTimeL(TDateTime(2008, EMarch, 28, 12, 0, 0, 0));
+
+ // Set a daily repeating alarm during the missing local hour
+ // Sunday, 30 March 2008, 00:01:15
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatDaily;
+ alarm.NextDueTime() = TTime(TDateTime(2008, EMarch, 29, 1, 15, 0, 0));
+ alarm.Message().Append(_L("Missing hour alarm"));
+
+ AddAlarmL(alarm);
+
+ TestAlarmNotifyL(alarm, TTime(TDateTime(2008, EMarch, 29, 2, 14, 30, 0)), EFalse);
+ TestAlarmNotifyL(alarm, TTime(TDateTime(2008, EMarch, 29, 2, 15, 30, 0)), ETrue);
+
+#ifdef __WINS__
+ TheAlarmTest.Test().Printf(_L("make sure that the next repeat of the alarm is correct"));
+ // Monday, 31 March 2008, 00:01:15
+ TASShdAlarm fetchedAlarm;
+ TheAlarmTest.Session().GetAlarmDetails(alarm.Id(), fetchedAlarm);
+
+ TTime fetchedAlarmTime = fetchedAlarm.NextDueTime();
+ TheAlarmTest(fetchedAlarmTime == TTime(TDateTime(2008, EMarch, 30, 1, 15, 0, 0)));
+
+#endif // __WINS__
+
+ // delete the alarm
+ DeleteAlarmL(alarm.Id());
+ }
+
+/* Use case 1:
+Missing hour is from 1am (local time) to 2am (local time).
+Alarm is set for 1:15am (local time).
+No other alarm is set.
+
+The alarm will expire at 2:15 (local time) instead of 1:15 (local time).
+*/
+void CAlarmTestApp::TestAlarmMissingHourRepeatOnce1L()
+ {
+ TheAlarmTest.Test().Next(_L("Test an alarm in the missing hour"));
+ SetTimeZoneL(KLondon);
+
+ // set home time to (before DST threshold)
+ // Saturday, 29 March 2008, 00:12:00
+ SetHomeTimeL(TDateTime(2008, EMarch, 28, 12, 0, 0, 0));
+
+ // set an alarm during the missing local hour
+ // Sunday, 30 March 2008, 00:01:15
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ alarm.NextDueTime() = TTime(TDateTime(2008, EMarch, 29, 1, 15, 0, 0));
+ alarm.Message().Append(_L("Missing hour alarm"));
+
+ AddAlarmL(alarm);
+
+ TestAlarmNotifyL(alarm, TTime(TDateTime(2008, EMarch, 29, 2, 14, 30, 0)), EFalse);
+ TestAlarmNotifyL(alarm, TTime(TDateTime(2008, EMarch, 29, 2, 15, 30, 0)), ETrue);
+
+ // delete the alarm
+ DeleteAlarmL(alarm.Id());
+ }
+
+/** Use case 2:
+Missing hour is from 1am (local time) to 2am (local time).
+Alarm1 is set for 1:15am (local time)
+Alarm2 is set for 1:45am (local time)
+
+The alarms will expire at 2:15 (local time) and 2:45 (local time).
+*/
+void CAlarmTestApp::TestAlarmMissingHourRepeatOnce2L()
+ {
+ TheAlarmTest.Test().Next(_L("Test two alarms in the missing hour"));
+ SetTimeZoneL(KLondon);
+
+ // set home time to (before DST threshold)
+ // Saturday, 29 March 2008, 00:12:00
+ SetHomeTimeL(TDateTime(2008, EMarch, 28, 12, 0, 0, 0));
+
+ // set an alarm during the missing local hour
+ // Sunday, 30 March 2008, 00:01:15
+ TASShdAlarm alarm1;
+ alarm1.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ alarm1.NextDueTime() = TTime(TDateTime(2008, EMarch, 29, 1, 15, 0, 0));
+ alarm1.Message().Append(_L("Missing hour alarm"));
+
+ AddAlarmL(alarm1);
+
+ // Set an alarm during the missing local hour
+ // Sunday, 30 March 2008, 00:01:45
+ TASShdAlarm alarm2;
+ alarm2.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ alarm2.NextDueTime() = TTime(TDateTime(2008, EMarch, 29, 1, 45, 0, 0));
+ alarm2.Message().Append(_L("Missing hour alarm"));
+
+ AddAlarmL(alarm2);
+
+ TestAlarmNotifyL(alarm1, TTime(TDateTime(2008, EMarch, 29, 2, 14, 30, 0)), EFalse);
+ TestAlarmNotifyL(alarm1, TTime(TDateTime(2008, EMarch, 29, 2, 15, 30, 0)), ETrue);
+ TestAlarmNotifyL(alarm2, TTime(TDateTime(2008, EMarch, 29, 2, 44, 30, 0)), EFalse);
+ TestAlarmNotifyL(alarm2, TTime(TDateTime(2008, EMarch, 29, 2, 45, 30, 0)), ETrue);
+
+ // delete the alarm
+ DeleteAlarmL(alarm1.Id());
+ DeleteAlarmL(alarm2.Id());
+ }
+
+/** Use case 3:
+Missing hour is from 1am (local time) to 2am (local time).
+Alarm1 is set for 1:15am (local time).
+Alarm2 is set for 2:05am (local time).
+Alarm3 is set for 3:05am (local time).
+Alarm1 is the only alarm that happens during the missing hour
+but the presence of other alarms may complicate the behaviour as well.
+
+The expiry times of the alarms become:
+2:05 : Alarm2
+2:15 : Alarm1
+3:05 : Alarm3
+Notice the change in the order of the alarms. This is because we remap
+the alarms of the missing hour in the hour afterwards so between 2am and 3am
+in our example we have the alarms for 1am to 3am and so they can get reordered.
+Alarms after 3am are not impacted.
+*/
+void CAlarmTestApp::TestAlarmMissingHourRepeatOnce3L()
+ {
+ TheAlarmTest.Test().Next(_L("Test alarms changing order because of the missing hour"));
+ SetTimeZoneL(KLondon);
+
+ // set home time to (before DST threshold)
+ // Saturday, 29 March 2008, 00:12:00
+ SetHomeTimeL(TDateTime(2008, EMarch, 28, 12, 0, 0, 0));
+
+ // set an alarm during the missing local hour
+ // Sunday, 30 March 2008, 00:01:15
+ TASShdAlarm alarm1;
+ alarm1.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ alarm1.NextDueTime() = TTime(TDateTime(2008, EMarch, 29, 1, 15, 0, 0));
+ alarm1.Message().Append(_L("Missing hour alarm"));
+ AddAlarmL(alarm1);
+
+ // Set an alarm during the missing local hour
+ // Sunday, 30 March 2008, 00:02:05
+ TASShdAlarm alarm2;
+ alarm2.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ alarm2.NextDueTime() = TTime(TDateTime(2008, EMarch, 29, 2, 05, 0, 0));
+ alarm2.Message().Append(_L("Missing hour alarm"));
+ AddAlarmL(alarm2);
+
+ // Set an alarm during the missing local hour
+ // Sunday, 30 March 2008, 00:03:05
+ TASShdAlarm alarm3;
+ alarm3.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ alarm3.NextDueTime() = TTime(TDateTime(2008, EMarch, 29, 3, 05, 0, 0));
+ alarm3.Message().Append(_L("Missing hour alarm"));
+ AddAlarmL(alarm3);
+
+ TestAlarmNotifyL(alarm2, TTime(TDateTime(2008, EMarch, 29, 2, 04, 30, 0)), EFalse);
+ TestAlarmNotifyL(alarm2, TTime(TDateTime(2008, EMarch, 29, 2, 05, 30, 0)), ETrue);
+ TestAlarmNotifyL(alarm1, TTime(TDateTime(2008, EMarch, 29, 2, 14, 30, 0)), EFalse);
+ TestAlarmNotifyL(alarm1, TTime(TDateTime(2008, EMarch, 29, 2, 15, 30, 0)), ETrue);
+ TestAlarmNotifyL(alarm3, TTime(TDateTime(2008, EMarch, 29, 3, 04, 30, 0)), EFalse);
+ TestAlarmNotifyL(alarm3, TTime(TDateTime(2008, EMarch, 29, 3, 05, 30, 0)), ETrue);
+
+ // delete the alarm
+ DeleteAlarmL(alarm1.Id());
+ DeleteAlarmL(alarm2.Id());
+ DeleteAlarmL(alarm3.Id());
+ }
+
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+void CAlarmTestApp::TestWakeupAlarmRobustnessL()
+ {
+ TheAlarmTest.Test().Next(_L("Test that the RTC is not set when a wakeup alarm fails to be written to file"));
+
+ TheAlarmTest.Test().Printf(_L("Create a wakeup alarm"));
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KTestName;
+ alarm.NextDueTime().HomeTime();
+ alarm.NextDueTime() += TTimeIntervalMinutes(90);
+
+ TheAlarmTest.Test().Printf(_L("Add the wakeup alarm"));
+ User::LeaveIfError(TheAlarmTest.Session().AlarmAdd(alarm));
+
+ TheAlarmTest.Test().Printf(_L("kill the alarm server before the alarm has been written to file"));
+ RestartAlarmServerL();
+
+ TheAlarmTest.Test().Printf(_L("Test that the alarm was not written to the file"));
+
+ RArray<TAlarmId> alarmIds;
+ CleanupClosePushL(alarmIds);
+ TheAlarmTest.Session().GetAlarmIdListL(alarmIds);
+ TheAlarmTest.Test().Printf(_L("There should be zero alarms in the queue. There are %d alarms"), alarmIds.Count());
+ TheAlarmTest(alarmIds.Count() == 1 || alarmIds.Count()== 0);
+ if(alarmIds.Count()== 0)
+ {
+ TestRTCValueL(Time::NullTTime());
+ }
+ CleanupStack::PopAndDestroy(&alarmIds);
+ }
+
+void CAlarmTestApp::TestWakeupFlagPersistanceL()
+ {
+ TheAlarmTest.Test().Next(_L("TestWakeupFlagPersistanceL"));
+
+ TheAlarmTest.Test().Printf(_L("Create a wakeup alarm"));
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ _LIT(KMessage, "Wakeup alarm");
+ alarm.Message() = KMessage;
+ alarm.NextDueTime().HomeTime();
+ alarm.NextDueTime() += TTimeIntervalMinutes(90);
+
+ AddAlarmL(alarm);
+ User::After(100000);
+ RestartAlarmServerL();
+
+ TheAlarmTest.Test().Printf(_L("Fetch the wakeup alarm characteristics and make sure the flag is set"));
+ TASShdAlarm alarm2;
+ TheAlarmTest.Session().GetAlarmDetails(alarm.Id(), alarm2);
+ TheAlarmTest(alarm2.IsWakeup());
+
+ DeleteAlarmL(alarm.Id());
+
+ TestRTCValueL(Time::NullTTime());
+ }
+
+
+void CAlarmTestApp::TestSetWakeupSessionAlarmL()
+ {
+ SetTimeZoneL(KLondon);
+
+ TheAlarmTest.Test().Next(_L("TestSetWakeupFlagOnSessionAlarmL"));
+
+ TheAlarmTest.Test().Printf(_L("Create a wakeup alarm"));
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ alarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);
+ alarm.Message() = KTestName;
+ alarm.NextDueTime().HomeTime();
+ alarm.NextDueTime() += TTimeIntervalMinutes(90);
+
+ TRAPD(err, AddAlarmL(alarm));
+
+ TheAlarmTest(err == KErrArgument);
+
+ alarm.SetWakeup(EFalse);
+
+ TheAlarmTest.Test().Printf(_L("add the session alarm"));
+ AddAlarmL(alarm);
+
+ TInt setWakeupError1 = TheAlarmTest.Session().SetWakeup(alarm.Id(), ETrue);
+
+ TheAlarmTest(setWakeupError1 == KErrArgument);
+
+ TheAlarmTest.Test().Printf(_L("clear the session specific alarm flag"));
+ TAlarmCharacteristicsFlags alarmCharacteristicsFlags;
+ TheAlarmTest.Session().GetAlarmCharacteristics(alarm.Id(), alarmCharacteristicsFlags);
+ alarmCharacteristicsFlags.Clear(EAlarmCharacteristicsSessionSpecific);
+ TheAlarmTest.Session().SetAlarmCharacteristics(alarm.Id(), alarmCharacteristicsFlags);
+
+ TheAlarmTest.Test().Printf(_L("make it a wakeup alarm"));
+ TInt setWakeupError2 = TheAlarmTest.Session().SetWakeup(alarm.Id(), ETrue);
+
+ TheAlarmTest.Test().Printf(_L("set the session specific alarm flag"));
+ TheAlarmTest.Session().GetAlarmCharacteristics(alarm.Id(), alarmCharacteristicsFlags);
+ alarmCharacteristicsFlags.Set(EAlarmCharacteristicsSessionSpecific);
+ TInt setSessionSpecificError = TheAlarmTest.Session().SetAlarmCharacteristics(alarm.Id(), alarmCharacteristicsFlags);
+
+ TheAlarmTest(setSessionSpecificError == KErrArgument);
+
+ DeleteAlarmL(alarm.Id());
+ }
+
+void CAlarmTestApp::TestDeleteWakeupAlarmL()
+ {
+ TheAlarmTest.Test().Next(_L("TestDeleteWakeupAlarmL"));
+
+ TheAlarmTest.Test().Printf(_L("Create a wakeup alarm"));
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KTestName;
+ alarm.NextDueTime().HomeTime();
+ alarm.NextDueTime() += TTimeIntervalMinutes(90);
+
+ AddAlarmL(alarm);
+
+ DeleteAlarmL(alarm.Id());
+
+ // Test that the RTC is not set
+ TestRTCValueL(Time::NullTTime());
+ }
+
+void CAlarmTestApp::TestDisableWakeupAlarmL()
+ {
+ SetTimeZoneL(KLondon);
+
+ TheAlarmTest.Test().Next(_L("set a wakeup alarm"));
+ TTime systemLocalTime(TDateTime(2006, EMarch, 3, 12, 0, 0, 0)); // March the 23rd
+ TTime alarmTimeUTC(TDateTime(2006, EMarch, 6, 12, 0, 0, 0)); // March the 29th
+
+ SetHomeTimeL(systemLocalTime);
+
+ TheAlarmTest.Test().Printf(_L("Create a wakeup alarm"));
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KTestName;
+ alarm.NextDueTime() = alarmTimeUTC; // there is no utc offset in london at this time of year
+
+ AddAlarmL(alarm);
+
+ // test that the rtc is set to the uts alarm time
+ TestRTCValueL(alarmTimeUTC);
+
+ TheAlarmTest.Test().Printf(_L("Disable the alarm"));
+ TRequestStatus status;
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, status, KAlarmServerFile);
+ TheAlarmTest.Session().SetAlarmStatus(alarm.Id(), EAlarmStatusDisabled);
+ User::WaitForRequest(status);
+
+ // test that the RTC is unset now that we have disabled the alarm
+ TestRTCValueL(Time::NullTTime());
+
+ TheAlarmTest.Test().Printf(_L("Enable the alarm"));
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, status, KAlarmServerFile);
+ TheAlarmTest.Session().SetAlarmStatus(alarm.Id(), EAlarmStatusEnabled);
+ User::WaitForRequest(status);
+
+ // test that the rtc is set now that we have re-enabled the alarm
+ TestRTCValueL(alarmTimeUTC);
+
+ DeleteAlarmL(alarm.Id());
+ }
+
+void CAlarmTestApp::TestUnsetWakeupFlagL()
+ {
+ SetTimeZoneL(KLondon);
+
+ TheAlarmTest.Test().Next(_L("set a wakeup alarm"));
+ TTime systemLocalTime(TDateTime(2006, EMarch, 3, 12, 0, 0, 0)); // March the 23rd
+ TTime alarmTimeUTC(TDateTime(2006, EMarch, 4, 12, 0, 0, 0)); // March the 29th
+
+ SetHomeTimeL(systemLocalTime);
+
+ TheAlarmTest.Test().Printf(_L("Create a wakeup alarm"));
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KTestName;
+ alarm.NextDueTime() = alarmTimeUTC;
+
+ AddAlarmL(alarm);
+
+ // Test that the rtc is set to the utc alarm time
+ TestRTCValueL(alarmTimeUTC);
+
+ TheAlarmTest.Test().Printf(_L("unset the wakeup flag"));
+ TRequestStatus status;
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, status, KAlarmServerFile);
+ TheAlarmTest.Session().SetWakeup(alarm.Id(), EFalse);
+ User::WaitForRequest(status);
+
+ // Test that the rtc is not set now that the alarm is no longer a wakeup alarm
+ TestRTCValueL(Time::NullTTime());
+
+ TheAlarmTest.Test().Printf(_L("re-set the wakeup flag"));
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, status, KAlarmServerFile);
+ TheAlarmTest.Session().SetWakeup(alarm.Id(), ETrue);
+ User::WaitForRequest(status);
+
+ // Test that the rtc is set now that the alarm has been set back to a wakeup alarm
+ TestRTCValueL(alarmTimeUTC);
+
+ DeleteAlarmL(alarm.Id());
+ }
+
+void CAlarmTestApp::TestWakeupAlarmTimeL()
+ {
+ TheAlarmTest.Test().Next(_L("Test London over March DST rollover 2006"));
+ DoTestWakeupAlarmTimeL(TDateTime(2006, EMarch, 22, 12, 0, 0, 0),
+ TDateTime(2006, EMarch, 28, 12, 0, 0, 0),
+ 60,
+ KLondon);
+
+ TheAlarmTest.Test().Next(_L("Test London over October DST rollover 2006"));
+ DoTestWakeupAlarmTimeL(TDateTime(2006, EOctober, 26, 12, 0, 0, 0),
+ TDateTime(2006, EOctober, 30, 12, 0, 0, 0),
+ 0,
+ KLondon);
+
+ TheAlarmTest.Test().Next(_L("Test Chicago over April DST rollover 2006"));
+ DoTestWakeupAlarmTimeL(TDateTime(2006, EApril, 1, 12, 0, 0, 0),
+ TDateTime(2006, EApril, 5, 12, 0, 0, 0),
+ -300,
+ KChicago);
+
+ TheAlarmTest.Test().Next(_L("Test Chicago over October DST rollover 2006"));
+ DoTestWakeupAlarmTimeL(TDateTime(2006, EOctober, 27, 12, 0, 0, 0),
+ TDateTime(2006, EOctober, 29, 12, 0, 0, 0),
+ -360,
+ KChicago);
+
+ TheAlarmTest.Test().Next(_L("Test Sydney over April DST rollover 2006"));
+ DoTestWakeupAlarmTimeL(TDateTime(2006, EApril, 1, 12, 0, 0, 0),
+ TDateTime(2006, EApril, 5, 12, 0, 0, 0),
+ 600,
+ KSydney);
+
+ TheAlarmTest.Test().Next(_L("Test Sydney over October DST rollover 2006"));
+ DoTestWakeupAlarmTimeL(TDateTime(2006, EOctober, 27, 12, 0, 0, 0),
+ TDateTime(2006, EOctober, 29, 12, 0, 0, 0),
+ 660,
+ KSydney);
+
+ TheAlarmTest.Test().Next(_L("Test Tokyo (there are no DST events in Tokyo)"));
+ DoTestWakeupAlarmTimeL(TDateTime(2006, EApril, 1, 12, 0, 0, 0),
+ TDateTime(2006, ENovember, 5, 12, 0, 0, 0),
+ 540,
+ KTokyo);
+ }
+
+void CAlarmTestApp::DoTestWakeupAlarmTimeL(const TTime& aSystemLocalTime,
+ const TTime& aAlarmTimeUTC,
+ TTimeIntervalMinutes aNextUTCOffset,
+ const TDesC8& aTimeZoneName)
+ {
+ SetTimeZoneL(aTimeZoneName);
+ SetHomeTimeL(aSystemLocalTime);
+
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KTestName;
+ // Add the UTC offset from when the alarm will happen to get the local time
+ alarm.NextDueTime() = aAlarmTimeUTC + aNextUTCOffset;
+
+ AddAlarmL(alarm);
+
+ TestRTCValueL(aAlarmTimeUTC);
+
+ DeleteAlarmL(alarm.Id());
+ }
+
+void CAlarmTestApp::TestFixedAlarmL()
+ {
+ SetHomeTimeL(TDateTime(2006, EMarch, 20, 12, 0, 0, 0));
+ SetTimeZoneL(KLondon);
+
+ TheAlarmTest.Test().Printf(_L("Create fixed a wakeup alarm"));
+
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ // Set the wakeup flag for the alarm
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KTestName;
+
+ // set the time of the alarm so that it is fixed
+ alarm.SetUtcNextDueTime(TDateTime(2006, EMarch, 21, 12, 0, 0, 0));
+ AddAlarmL(alarm);
+
+ TestRTCValueL(TDateTime(2006, EMarch, 21, 12, 0, 0, 0));
+
+ DeleteAlarmL(alarm.Id());
+
+ // set the time of the alarm so that it is fixed
+ alarm.SetUtcNextDueTime(TDateTime(2006, EApril, 5, 12, 0, 0, 0));
+ AddAlarmL(alarm);
+
+ TestRTCValueL(TDateTime(2006, EApril, 5, 12, 0, 0, 0));
+
+ DeleteAlarmL(alarm.Id());
+ }
+
+void CAlarmTestApp::TestSetRTCOnDeviceShutdownL()
+ {
+ TheAlarmTest.Test().Next(_L("Test that the RTC is set on device shutdown"));
+
+ TASShdAlarm alarm = CreateAlarm(Time::NullTTime(), ETrue);
+
+ RProperty property;
+ CleanupClosePushL(property);
+ User::LeaveIfError(property.Attach(KAlarmServerUID, KRTCValueKey));
+ TRequestStatus status;
+ property.Subscribe(status);
+
+ TheAlarmTest.Test().Printf(_L("Add a wakeup alarm"));
+ User::LeaveIfError(TheAlarmTest.Session().AlarmAdd(alarm));
+
+ TheAlarmTest.Test().Printf(_L("Wait for the alarm to be set when it is added"));
+ User::WaitForRequest(status);
+
+ property.Subscribe(status);
+ SendSsmSystemMessageL(ESsmShutdown);
+
+ TheAlarmTest.Test().Printf(_L("Wait for the RTC to be set on shutdown"));
+ User::WaitForRequest(status);
+
+ TheAlarmTest.Test().Printf(_L("Return to a normal system state"));
+ SendSsmSystemMessageL(ESsmNormal);
+
+ User::LeaveIfError(TheAlarmTest.Session().AlarmDelete(alarm.Id()));
+
+ CleanupStack::PopAndDestroy(&property);
+ }
+
+void CAlarmTestApp::TestRTCSetOnDSTRolloverL()
+ {
+ TheAlarmTest.Test().Next(_L("Test that the RTC is set on DST Rollover"));
+
+ // make sure we are in london
+ SetTimeZoneL(KLondon);
+
+ // 30 secodns before DST Rollover
+ SetHomeTimeL(TDateTime(2006, EMarch, 25, 0, 59, 58, 0));
+
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ _LIT(KMessage, "An alarm");
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KMessage;
+ // 5 seconds after the DST Rollover
+ alarm.NextDueTime() = TTime(TDateTime(2006, EMarch, 25, 2, 0, 5, 0));
+
+ TheAlarmTest.Test().Printf(_L("Add a wakeup alarm"));
+ AddAlarmL(alarm);
+
+ RProperty property;
+ CleanupClosePushL(property);
+ User::LeaveIfError(property.Attach(KAlarmServerUID, KRTCValueKey));
+ TRequestStatus rtcStatus;
+ property.Subscribe(rtcStatus);
+
+ RTimer timer;
+ CleanupClosePushL(timer);
+ User::LeaveIfError(timer.CreateLocal());
+ TRequestStatus timerStatus;
+ // 2 seconds after the DST rollover
+ timer.After(timerStatus, 4000000);
+
+ TheAlarmTest.Test().Printf(_L("Wait for the RTC to be set on the DST rollover"));
+ User::WaitForRequest(rtcStatus, timerStatus);
+
+ TheAlarmTest.Test().Printf(_L("Test that the RTC was set"));
+ TheAlarmTest(rtcStatus == KErrNone);
+ TheAlarmTest.Test().Printf(_L("Test that we did not time out"));
+ TheAlarmTest(timerStatus == KRequestPending);
+
+ timer.Cancel();
+ User::WaitForRequest(timerStatus);
+ TheAlarmTest(timerStatus == KErrCancel);
+ CleanupStack::PopAndDestroy(&timer);
+
+ DeleteAlarmL(alarm.Id());
+
+ CleanupStack::PopAndDestroy(&property);
+ }
+
+void CAlarmTestApp::TestRTCSetOnTimeZoneChangeL()
+ {
+ TheAlarmTest.Test().Next(_L("Test that the RTC is set on time zone change"));
+
+ // make sure we are in london
+ SetTimeZoneL(KLondon);
+
+ // 30 secodns before DST Rollover
+ SetHomeTimeL(TDateTime(2006, EMarch, 25, 0, 59, 58, 0));
+
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ _LIT(KMessage, "An alarm");
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KMessage;
+ // 5 seconds after the DST Rollover
+ alarm.NextDueTime() = TTime(TDateTime(2006, EMarch, 25, 2, 0, 5, 0));
+
+ TheAlarmTest.Test().Printf(_L("Add a wakeup alarm"));
+ AddAlarmL(alarm);
+
+ RProperty property;
+ CleanupClosePushL(property);
+ User::LeaveIfError(property.Attach(KAlarmServerUID, KRTCValueKey));
+ TRequestStatus rtcStatus;
+ property.Subscribe(rtcStatus);
+
+ SetTimeZoneL(KChicago);
+
+ TheAlarmTest.Test().Printf(_L("Wait for the RTC to be set on the time zone change"));
+ User::WaitForRequest(rtcStatus);
+
+ TheAlarmTest.Test().Printf(_L("Test that the RTC was set"));
+ TheAlarmTest(rtcStatus == KErrNone);
+
+ DeleteAlarmL(alarm.Id());
+
+ CleanupStack::PopAndDestroy(&property);
+ }
+
+void CAlarmTestApp::TestRTCSetOnSystemTimeChangeL()
+ {
+ TheAlarmTest.Test().Next(_L("Test that the RTC is set on system time change"));
+
+ // make sure we are in london
+ SetTimeZoneL(KLondon);
+
+ // 30 secodns before DST Rollover
+ SetHomeTimeL(TDateTime(2006, EMarch, 25, 0, 59, 58, 0));
+
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ _LIT(KMessage, "An alarm");
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KMessage;
+ // 5 seconds after the DST Rollover
+ alarm.NextDueTime() = TTime(TDateTime(2006, EMarch, 25, 3, 0, 5, 0));
+
+ TheAlarmTest.Test().Printf(_L("Add a wakeup alarm"));
+ AddAlarmL(alarm);
+
+ RProperty property;
+ CleanupClosePushL(property);
+ User::LeaveIfError(property.Attach(KAlarmServerUID, KRTCValueKey));
+ TRequestStatus rtcStatus;
+ property.Subscribe(rtcStatus);
+
+ // set the system time to a timejust after the DST rollover
+ SetHomeTimeL(TDateTime(2006, EMarch, 25, 2, 0, 5, 0));
+
+ TheAlarmTest.Test().Printf(_L("Wait for the RTC to be set on the system time change"));
+ User::WaitForRequest(rtcStatus);
+
+ TheAlarmTest.Test().Printf(_L("Test that the RTC was set"));
+ TheAlarmTest(rtcStatus == KErrNone);
+
+ DeleteAlarmL(alarm.Id());
+
+ CleanupStack::PopAndDestroy(&property);
+ }
+
+#ifdef __WINS__
+void CAlarmTestApp::TestSnoozeWakeupAlarmL()
+ {
+ TheAlarmTest.Test().Next(_L("Test snoozing a wakeup alarm"));
+
+ const TTime KAlarmTime(TDateTime(2006, EMarch, 25, 12, 0, 0, 0));
+
+ SetTimeZoneL(KLondon);
+ SetHomeTimeL(KAlarmTime - TTimeIntervalSeconds(1));
+
+ // add a wakeup alarm
+ TASShdAlarm alarm;
+ alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
+ _LIT(KMessage, "An alarm");
+ alarm.SetWakeup(ETrue);
+ alarm.Message() = KMessage;
+ alarm.NextDueTime() = KAlarmTime;
+ AddAlarmL(alarm);
+
+ // wait for it to go off
+ TRequestStatus status;
+ iClient.NotifyOnAlarm(alarm, status);
+ User::WaitForRequest(status);
+
+ // subscribe to the RTC
+ RProperty property;
+ CleanupClosePushL(property);
+ User::LeaveIfError(property.Attach(KAlarmServerUID, KRTCValueKey));
+ TRequestStatus propertyStatus;
+ property.Subscribe(propertyStatus);
+
+ // snooze the alarm
+ TheAlarmTest.Test().Printf(_L("Snooze the alarm"));
+ User::LeaveIfError(iClient.SnoozeAlarm(alarm.Id(), KAlarmTime + TTimeIntervalMinutes(5)));
+
+ // wait for the RTC to change
+ User::WaitForRequest(propertyStatus);
+ CleanupStack::PopAndDestroy(&property);
+
+ // make sure the RTC is set for the snooze time
+ TestRTCValueL(KAlarmTime + TTimeIntervalMinutes(5));
+
+ // delete the alarm
+ DeleteAlarmL(alarm.Id());
+ }
+#endif
+
+void CAlarmTestApp::TestHeadWakeupAlarmL()
+ {
+ TheAlarmTest.Test().Next(_L("Test the head wakeup alarm"));
+
+ SetTimeZoneL(KLondon);
+ SetHomeTimeL(TDateTime(2006, EApril, 9, 12, 0, 0, 0));
+
+ // Add a few wakeup alarms
+ TASShdAlarm wakeupAlarm1 = CreateAlarm(TDateTime(2006, EApril, 10, 15, 0, 0, 0), ETrue);
+ AddAlarmL(wakeupAlarm1);
+ TASShdAlarm wakeupAlarm2 = CreateAlarm(TDateTime(2006, EApril, 11, 15, 0, 0, 0), ETrue);
+ AddAlarmL(wakeupAlarm2);
+ TASShdAlarm wakeupAlarm3 = CreateAlarm(TDateTime(2006, EApril, 12, 15, 0, 0, 0), ETrue);
+ AddAlarmL(wakeupAlarm3);
+ TASShdAlarm wakeupAlarm4 = CreateAlarm(TDateTime(2006, EApril, 13, 15, 0, 0, 0), ETrue);
+ AddAlarmL(wakeupAlarm4);
+
+ // Add a few non-wakeup alarms
+ TASShdAlarm normAlarm1 = CreateAlarm(TDateTime(2006, EApril, 10, 11, 0, 0, 0), EFalse);
+ AddAlarmL(normAlarm1);
+ TASShdAlarm normAlarm2 = CreateAlarm(TDateTime(2006, EApril, 11, 11, 0, 0, 0), EFalse);
+ AddAlarmL(normAlarm2);
+ TASShdAlarm normAlarm3 = CreateAlarm(TDateTime(2006, EApril, 12, 11, 0, 0, 0), EFalse);
+ AddAlarmL(normAlarm2);
+ TASShdAlarm normAlarm4 = CreateAlarm(TDateTime(2006, EApril, 13, 11, 0, 0, 0), EFalse);
+ AddAlarmL(normAlarm4);
+
+
+ RProperty property;
+ CleanupClosePushL(property);
+ User::LeaveIfError(property.Attach(KAlarmServerUID, KRTCValueKey));
+ TRequestStatus rtcStatus;
+ property.Subscribe(rtcStatus);
+
+ // Set system time to somewhere in the middle of the alarms
+ SetHomeTimeL(TDateTime(2006, EApril, 12, 9, 0, 0, 0));
+
+ // wait for the RTC to change
+ User::WaitForRequest(rtcStatus);
+ property.Subscribe(rtcStatus);
+
+ // test that the head wakeup alarm is set with the RTC and not any other times
+ TestRTCValueL(TDateTime(2006, EApril, 12, 14, 0, 0, 0));
+
+ TheAlarmTest.Session().SetAlarmStatus(wakeupAlarm3.Id(), EAlarmStatusDisabled);
+
+ User::WaitForRequest(rtcStatus);
+ property.Subscribe(rtcStatus);
+
+ // test that the second alarm is now set with the RTC
+ TestRTCValueL(TDateTime(2006, EApril, 13, 14, 0, 0, 0));
+
+ TheAlarmTest.Session().SetAlarmStatus(wakeupAlarm3.Id(), EAlarmStatusEnabled);
+
+ User::WaitForRequest(rtcStatus);
+ property.Subscribe(rtcStatus);
+
+ // test that the first alarm is set with the RTC again
+ TestRTCValueL(TDateTime(2006, EApril, 12, 14, 0, 0, 0));
+
+ TheAlarmTest.Session().SetWakeup(wakeupAlarm3.Id(), EFalse);
+ User::WaitForRequest(rtcStatus);
+ property.Subscribe(rtcStatus);
+
+ // test that the first alarm is set with the RTC again
+ TestRTCValueL(TDateTime(2006, EApril, 13, 14, 0, 0, 0));
+
+ TheAlarmTest.Session().SetWakeup(wakeupAlarm3.Id(), ETrue);
+ User::WaitForRequest(rtcStatus);
+ property.Subscribe(rtcStatus);
+
+ // test that the first alarm is set with the RTC again
+ TestRTCValueL(TDateTime(2006, EApril, 12, 14, 0, 0, 0));
+
+ DeleteAlarmL(wakeupAlarm3.Id());
+
+ User::WaitForRequest(rtcStatus);
+
+ // test that the second alarm is now set with the RTC
+ TestRTCValueL(TDateTime(2006, EApril, 13, 14, 0, 0, 0));
+
+ DeleteAllAlarmsL();
+
+ CleanupStack::PopAndDestroy(&property);
+ }
+
+void CAlarmTestApp::TestAlarmFileNotWrittenOnTimeZoneChangeL()
+ {
+ TRequestStatus alarmServerFileStatus;
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, alarmServerFileStatus, KAlarmServerFile);
+
+ SetTimeZoneL(KSydney);
+
+ RTimer timer;
+ CleanupClosePushL(timer);
+ User::LeaveIfError(timer.CreateLocal());
+ TRequestStatus timerStatus;
+ timer.After(timerStatus, 2000000);
+
+ TheAlarmTest.Test().Printf(_L("Wait for two seconds"));
+
+ User::WaitForRequest(alarmServerFileStatus, timerStatus);
+
+ TheAlarmTest.Test().Printf(_L("Test the timer completed"));
+ TheAlarmTest(timerStatus.Int() == KErrNone);
+ TheAlarmTest.Test().Printf(_L("Test the alarm server file did not change completed"));
+ TheAlarmTest(alarmServerFileStatus.Int() == KRequestPending);
+
+ iPIMTestServer.FileServerNotifyChangeCancel();
+
+ User::WaitForRequest(alarmServerFileStatus);
+
+ CleanupStack::PopAndDestroy(&timer);
+
+ SetTimeZoneL(KLondon);
+ }
+
+void CAlarmTestApp::TestAlarmFileNotWrittenOnSystemTimeChangeL()
+ {
+ TRequestStatus alarmServerFileStatus;
+ iPIMTestServer.FileServerNotifyChange(ENotifyAll, alarmServerFileStatus, KAlarmServerFile);
+
+ TTime now;
+ now.HomeTime();
+
+ SetHomeTimeL(TDateTime(2005, EMarch, 15, 12, 0, 0, 0));
+
+ RTimer timer;
+ CleanupClosePushL(timer);
+ User::LeaveIfError(timer.CreateLocal());
+ TRequestStatus timerStatus;
+ timer.After(timerStatus, 2000000);
+
+ TheAlarmTest.Test().Printf(_L("Wait for two seconds"));
+
+ User::WaitForRequest(alarmServerFileStatus, timerStatus);
+
+ TheAlarmTest.Test().Printf(_L("Test the timer completed"));
+ TheAlarmTest(timerStatus.Int() == KErrNone);
+ TheAlarmTest.Test().Printf(_L("Test the alarm server file did not change completed"));
+ TheAlarmTest(alarmServerFileStatus.Int() == KRequestPending);
+
+ iPIMTestServer.FileServerNotifyChangeCancel();
+
+ User::WaitForRequest(alarmServerFileStatus);
+
+ CleanupStack::PopAndDestroy(&timer);
+
+ SetHomeTimeL(now);
+ }
+
+void CAlarmTestApp::TestWriteCommandsL(TASShdAlarm& aASShdAlarm, TInt aExpectedError)
+ {
+ if (aExpectedError != KErrNone)
+ {
+ TASShdAlarm alarm = CreateAlarm(Time::NullTTime(), EFalse);
+ TheAlarmTest.Test().Printf(_L("AlarmAdd"));
+ TInt alarmAddError = TheAlarmTest.Session().AlarmAdd(alarm);
+ TheAlarmTest(alarmAddError == aExpectedError);
+ }
+
+ TASShdAlarm alarmAddWithNotification = CreateAlarm(Time::NullTTime(), EFalse);
+ TheAlarmTest.Test().Printf(_L("AlarmAddWithNotification"));
+ TRequestStatus status;
+ TheAlarmTest.Session().AlarmAddWithNotification(status, alarmAddWithNotification);
+
+ if (aExpectedError != KErrNone)
+ {
+ // we expected an error so wait for failure with the error code
+ User::WaitForRequest(status);
+ TheAlarmTest(status.Int() == aExpectedError);
+ }
+ else
+ {
+ // the alarm should be added sucessfully so cancel the notification and dequeue it
+ TheAlarmTest.Test().Printf(_L("AlarmNotificationCancelAndDequeue"));
+ TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(alarmAddWithNotification.Id());
+ User::WaitForRequest(status);
+ TheAlarmTest(status.Int() == KErrCancel);
+ }
+
+ TheAlarmTest.Test().Printf(_L("AlarmDataAttachL"));
+ TInt alarmDataAttachError = TheAlarmTest.Session().AlarmDataAttachL(aASShdAlarm.Id(), KAlarmData);
+ TheAlarmTest(alarmDataAttachError == aExpectedError);
+
+ TheAlarmTest.Test().Printf(_L("AlarmDataDetach"));
+ TInt alarmDataDetachError = TheAlarmTest.Session().AlarmDataDetach(aASShdAlarm.Id());
+ TheAlarmTest(alarmDataDetachError == aExpectedError);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmCharacteristics"));
+ TAlarmCharacteristicsFlags alarmCharacteristicsFlags;
+ TInt setAlarmCharacteristicsError = TheAlarmTest.Session().SetAlarmCharacteristics(aASShdAlarm.Id(), alarmCharacteristicsFlags);
+ TheAlarmTest(setAlarmCharacteristicsError == aExpectedError);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmDayOrTimed"));
+ TInt setAlarmDayOrTimedError = TheAlarmTest.Session().SetAlarmDayOrTimed(aASShdAlarm.Id(), EASShdAlarmTypeTimed);
+ TheAlarmTest(setAlarmDayOrTimedError == aExpectedError);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmPlayIntervalsL"));
+ CArrayFix<TASCliSoundPlayDefinition>* intervals = new(ELeave) CArrayFixFlat<TASCliSoundPlayDefinition>(8);
+ CleanupStack::PushL(intervals);
+ TASCliSoundPlayDefinition soundPlayDefinition1(TTimeIntervalMinutes(0), TTimeIntervalSeconds(30));
+ intervals->AppendL(soundPlayDefinition1);
+ TASCliSoundPlayDefinition soundPlayDefinition2(TTimeIntervalMinutes(5), TTimeIntervalSeconds(30));
+ intervals->AppendL(soundPlayDefinition2);
+ TRAPD(setAlarmPlayIntervalsError, TheAlarmTest.Session().SetAlarmPlayIntervalsL(*intervals));
+ TheAlarmTest(setAlarmPlayIntervalsError == aExpectedError);
+ CleanupStack::PopAndDestroy(intervals);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmStatus"));
+ TInt setAlarmStatusError = TheAlarmTest.Session().SetAlarmStatus(aASShdAlarm.Id(), EAlarmStatusEnabled);
+ TheAlarmTest(setAlarmStatusError == aExpectedError);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmStatusByCategory"));
+ TInt SetAlarmStatusByCategoryError = TheAlarmTest.Session().SetAlarmStatusByCategory(KAlarmCategory, EAlarmStatusEnabled);
+ TheAlarmTest(SetAlarmStatusByCategoryError == aExpectedError);
+
+ TheAlarmTest.Test().Printf(_L("AlarmDelete"));
+ TInt alarmDeleteError = TheAlarmTest.Session().AlarmDelete(aASShdAlarm.Id());
+ TheAlarmTest(alarmDeleteError == aExpectedError);
+
+ if (alarmDeleteError == KErrNone)
+ {
+ // We deleted the alarm so add it again
+ User::LeaveIfError(TheAlarmTest.Session().AlarmAdd(aASShdAlarm));
+ }
+
+ TheAlarmTest.Test().Printf(_L("AlarmDeleteAllByCategory"));
+ TInt alarmDeleteAllByCategoryError = TheAlarmTest.Session().AlarmDeleteAllByCategory(KAlarmCategory, EFalse);
+ TheAlarmTest(alarmDeleteAllByCategoryError == aExpectedError);
+
+ TheAlarmTest.Test().Printf(_L("AlarmDeleteByCategory"));
+ TInt alarmDeleteByCategoryError = TheAlarmTest.Session().AlarmDeleteByCategory(KAlarmCategory, 0);
+ TheAlarmTest(alarmDeleteByCategoryError == aExpectedError);
+ }
+
+void CAlarmTestApp::TestReadCommandsL(TASShdAlarm& aASShdAlarm)
+ {
+ TheAlarmTest.Test().Printf(_L("SetClientData"));
+ TInt setClientDataError = TheAlarmTest.Session().SetClientData(aASShdAlarm);
+ TheAlarmTest(setClientDataError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmSoundState"));
+ TInt setAlarmSoundStateError = TheAlarmTest.Session().SetAlarmSoundState(EAlarmGlobalSoundStateOn);
+ TheAlarmTest(setAlarmSoundStateError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmSoundsSilentFor"));
+ TInt setAlarmSoundsSilentForError = TheAlarmTest.Session().SetAlarmSoundsSilentFor(30);
+ TheAlarmTest(setAlarmSoundsSilentForError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("SetAlarmSoundsSilentUntil"));
+ TTime silentUntilTime;
+ silentUntilTime.HomeTime();
+ silentUntilTime += TTimeIntervalMinutes(5);
+ TInt setAlarmSoundsSilentUntilError = TheAlarmTest.Session().SetAlarmSoundsSilentUntil(silentUntilTime);
+ TheAlarmTest(setAlarmSoundsSilentUntilError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("CancelAlarmSilence"));
+ TInt cancelAlarmSilenceError = TheAlarmTest.Session().CancelAlarmSilence();
+ TheAlarmTest(cancelAlarmSilenceError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("AlarmCountByState"));
+ TInt alarmCountQueued = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);
+ TheAlarmTest(alarmCountQueued == 1);
+
+ TheAlarmTest.Test().Printf(_L("AlarmDataSize"));
+ TInt alarmDataSize = TheAlarmTest.Session().AlarmDataSize(aASShdAlarm.Id());
+ TheAlarmTest(alarmDataSize == KErrNotFound);
+
+ TheAlarmTest.Test().Printf(_L("AlarmSoundsTemporarilySilenced"));
+ TBool alarmSoundsTemporarilySilenced = TheAlarmTest.Session().AlarmSoundsTemporarilySilenced();
+ TheAlarmTest(alarmSoundsTemporarilySilenced == EFalse);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmCategory"));
+ TAlarmCategory alarmCategory;
+ TInt getAlarmCategoryError = TheAlarmTest.Session().GetAlarmCategory(aASShdAlarm.Id(), alarmCategory);
+ TheAlarmTest(getAlarmCategoryError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmCharacteristics"));
+ TAlarmCharacteristicsFlags TAlarmCharacteristicsFlags;
+ TInt getAlarmCharacteristicsError = TheAlarmTest.Session().GetAlarmCharacteristics(aASShdAlarm.Id(), TAlarmCharacteristicsFlags);
+ TheAlarmTest(getAlarmCharacteristicsError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmCountForCategory"));
+ TInt AlarmCountForCategory = TheAlarmTest.Session().GetAlarmCountForCategory(KAlarmCategory);
+ TheAlarmTest(AlarmCountForCategory == 0);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmData"));
+ HBufC8* sink = NULL;
+ TInt getAlarmDataError = TheAlarmTest.Session().GetAlarmData(aASShdAlarm.Id(), sink);
+ TheAlarmTest(getAlarmDataError == KErrNone || getAlarmDataError == KErrNotFound);
+ delete sink;
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmDayOrTimed"));
+ TAlarmDayOrTimed alarmDayOrTimed;
+ TInt getAlarmDayOrTimedError = TheAlarmTest.Session().GetAlarmDayOrTimed(aASShdAlarm.Id(), alarmDayOrTimed);
+ TheAlarmTest(getAlarmDayOrTimedError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmDetails"));
+ TASShdAlarm alarm;
+ TInt getAlarmDetails = TheAlarmTest.Session().GetAlarmDetails(aASShdAlarm.Id(), alarm);
+ TheAlarmTest(getAlarmDetails == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmIdListByStateL"));
+ RArray<TAlarmId> alarmIds;
+ CleanupClosePushL(alarmIds);
+ TheAlarmTest.Session().GetAlarmIdListByStateL(EAlarmStateQueued, alarmIds);
+ TheAlarmTest.Test().Printf(_L("GetAlarmIdListByStateL = %d"), alarmIds.Count());
+ TheAlarmTest(alarmIds.Count() == 1);
+ alarmIds.Reset();
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmIdListForCategoryL"));
+ TheAlarmTest.Session().GetAlarmIdListForCategoryL(KAlarmCategory, alarmIds);
+ TheAlarmTest.Test().Printf(_L("GetAlarmIdListForCategoryL = %d"), alarmIds.Count());
+ TheAlarmTest(alarmIds.Count() == 0);
+ alarmIds.Reset();
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmIdListL"));
+ TheAlarmTest.Session().GetAlarmIdListL(alarmIds);
+ TheAlarmTest.Test().Printf(_L("GetAlarmIdListL = %d"), alarmIds.Count());
+ TheAlarmTest(alarmIds.Count() == 1);
+ CleanupStack::PopAndDestroy(&alarmIds); // alarmIds.Close()
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmOwner"));
+ TFullName fullName;
+ TInt getAlarmOwnerError = TheAlarmTest.Session().GetAlarmOwner(aASShdAlarm.Id(), fullName);
+ TheAlarmTest(getAlarmOwnerError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmPlayIntervalsL"));
+ CArrayFix<TASCliSoundPlayDefinition>* intervals = new(ELeave) CArrayFixFlat<TASCliSoundPlayDefinition>(8);
+ CleanupStack::PushL(intervals);
+ TheAlarmTest.Session().GetAlarmPlayIntervalsL(*intervals);
+ CleanupStack::PopAndDestroy(intervals);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmSoundState"));
+ TAlarmGlobalSoundState alarmGlobalSoundState;
+ TInt getAlarmSoundStateError = TheAlarmTest.Session().GetAlarmSoundState(alarmGlobalSoundState);
+ TheAlarmTest(getAlarmSoundStateError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmSoundsSilentUntil"));
+ TTime silentUntil;
+ TInt getAlarmSoundsSilentUntilError = TheAlarmTest.Session().GetAlarmSoundsSilentUntil(silentUntil);
+ TheAlarmTest.Test().Printf(_L("getAlarmSoundsSilentUntilError = %d"), getAlarmSoundsSilentUntilError);
+ //TheAlarmTest(getAlarmSoundsSilentUntilError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAlarmStatus"));
+ TAlarmStatus alarmStatus;
+ TInt getAlarmStatusError = TheAlarmTest.Session().GetAlarmStatus(aASShdAlarm.Id(), alarmStatus);
+ TheAlarmTest(getAlarmStatusError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("GetAvailableCategoryListL"));
+ RArray<TAlarmCategory> categories;
+ CleanupClosePushL(categories);
+ TheAlarmTest.Session().GetAvailableCategoryListL(categories);
+ CleanupStack::PopAndDestroy(&categories);
+
+ TheAlarmTest.Test().Printf(_L("GetNextDueAlarmId"));
+ TAlarmId alarmId;
+ TInt getNextDueAlarmIdError = TheAlarmTest.Session().GetNextDueAlarmId(alarmId);
+ TheAlarmTest(getNextDueAlarmIdError == KErrNone);
+
+ TheAlarmTest.Test().Printf(_L("NumberOfAlarmsActiveInQueue"));
+ TInt numberOfAlarmsActiveInQueue = TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();
+ TheAlarmTest.Test().Printf(_L("numberOfAlarmsActiveInQueue = %d"), numberOfAlarmsActiveInQueue);
+ }
+
+void CAlarmTestApp::TestReadOnlyInShutDownL()
+ {
+ TASShdAlarm alarm = CreateAlarm(Time::NullTTime(), EFalse);
+ User::LeaveIfError(TheAlarmTest.Session().AlarmAdd(alarm));
+
+ SendSsmSystemMessageL(ESsmShutdown);
+ TheAlarmTest.Next(_L("Test that write commands leave with locked"));
+ TestWriteCommandsL(alarm, KErrLocked);
+ TheAlarmTest.Next(_L("Test alarm file not written on time zone change"));
+ TestAlarmFileNotWrittenOnTimeZoneChangeL();
+ TheAlarmTest.Next(_L("Test alarm file not written on system time change"));
+ TestAlarmFileNotWrittenOnSystemTimeChangeL();
+ TheAlarmTest.Next(_L("Test that read commands still work"));
+ TestReadCommandsL(alarm);
+
+ SendSsmSystemMessageL(ESsmNormal);
+ TheAlarmTest.Next(_L("Test that write commands work again"));
+ TestWriteCommandsL(alarm, KErrNone);
+ TheAlarmTest.Next(_L("Test that read commands still work"));
+ TestReadCommandsL(alarm);
+
+ User::LeaveIfError(TheAlarmTest.Session().AlarmDelete(alarm.Id()));
+ }
+#endif
+
+void CAlarmTestApp::RunTestsL()
+ {
+ DeleteAllAlarmsL();
+ TestAlarmMissingHourRepeatDailyL();
+ TestAlarmMissingHourRepeatOnce1L();
+ TestAlarmMissingHourRepeatOnce2L();
+ TestAlarmMissingHourRepeatOnce3L();
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+ TestWakeupFlagPersistanceL();
+ TestSetWakeupSessionAlarmL();
+ TestDeleteWakeupAlarmL();
+ TestDisableWakeupAlarmL();
+ TestUnsetWakeupFlagL();
+ TestWakeupAlarmTimeL();
+ TestWakeupAlarmRobustnessL();
+ TestFixedAlarmL();
+#ifdef __WINS__
+ TestSnoozeWakeupAlarmL();
+#endif
+ TestReadOnlyInShutDownL();
+ TestSetRTCOnDeviceShutdownL();
+ TestRTCSetOnDSTRolloverL();
+ TestRTCSetOnTimeZoneChangeL();
+ TestRTCSetOnSystemTimeChangeL();
+ TestHeadWakeupAlarmL();
+#endif
+ }
+
+void doTestL()
+ {
+ CAlarmTestApp* alarmTestApp = CAlarmTestApp::NewLC();
+ alarmTestApp->RunTestsL();
+ CleanupStack::PopAndDestroy(alarmTestApp);
+ }
+
+/**
+
+@SYMTestCaseID PIM-TWAKEUPALARMS-0001
+
+*/
+
+GLDEF_C TInt E32Main()
+ {
+ __UHEAP_MARK;
+
+ CActiveScheduler* scheduler = new CActiveScheduler;
+ CActiveScheduler::Install(scheduler);
+
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+
+ TTime now;
+ now.HomeTime();
+ TheAlarmTest.Title();
+ TheAlarmTest.Start(KTestName);
+
+ TRAPD(testError, doTestL());
+
+ // Check there are no alarm left active
+ TInt n=TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();
+ TheAlarmTest(n==0, __LINE__);
+
+ TheAlarmTest.Session().Close();
+ TheAlarmTest.EndL();
+ TheAlarmTest.Test().Close();
+ ASTstAlarmTest::Close();
+
+ delete cleanup;
+ delete scheduler;
+
+ __UHEAP_MARKEND;
+
+ return testError;
+ }