--- /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;
+    }