diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/Test/ssm/TWakeupAlarms.cpp --- /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 +#include +#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT +#include +#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) ) ); + 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 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 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 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 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* intervals = new(ELeave) CArrayFixFlat(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 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* intervals = new(ELeave) CArrayFixFlat(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 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; + }