// 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