// Copyright (c) 1997-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:

// Test effects of changing TLocale on clock alarms

// Test alarms which are skipped over by advancing the time or revived by putting back the time.

// Test for when time is advanced or put back by changes to the locale, i.e:

// Turning daylight saving on and off and

// Increasing and decreasing GMT offset.

// The expected results for advancing or putting back the time are the same whether caused by changes

// to daylight saving or GMT offset.

// Test effects of altering workdays on workday repeated alarms

// 

//

#include "ASTstAlarmTest.h"

#include "testserver.h"

#include <tz.h>

static TRequestStatus TheStatus;

static TTime TheInitialAlarmTime;

static TTime TheExtendedAlarmTime;

static TTime TheOriginalTime;

static TTime TheCurrentTime;

static TAlarmId TheClockAlarmSlots[8] = { KNullAlarmId, KNullAlarmId, KNullAlarmId, KNullAlarmId, KNullAlarmId, KNullAlarmId, KNullAlarmId, KNullAlarmId };

// Use the Time Zone Server if available.

static RTz timezone;

// This gets us a time which isn't close to a minute boundary:

// It also sets the microseconds to 0, since alarms ignore it and comparison functions don't.

static void SafeHomeTime(TTime& aTime)

	{

	TInt sec;

	do

		{

		aTime.HomeTime();

		TDateTime dt(aTime.DateTime());

		sec = dt.Second();

		if(sec > 55 || sec < 5)

			{

			// dont loop full speed, there's no point:

			User::After(1000000);

			}

		else

			{

			dt.SetMicroSecond(0);

			aTime = dt;

			}

		}

	while(sec > 55 || sec < 5);

	}

static void CheckTimesAreEqual(const TTime& aExpectedTime, const TTime& aActualTime, TInt aLineNum)

//

// Compare times to required degree of precision

//

	{

	// determine the difference, in seconds

	TTimeIntervalSeconds	timeDiffSeconds;

	const TInt error = aExpectedTime.SecondsFrom(aActualTime, timeDiffSeconds);

	TheAlarmTest(error == KErrNone, __LINE__);

	// check the times are within 1min

	// as alarms are rounded to the minute

	const TTimeIntervalSeconds	maxDiff(60);

	const TTimeIntervalSeconds	minDiff(-60);

	if ((timeDiffSeconds > maxDiff) || (timeDiffSeconds < minDiff))

		{

		TheAlarmTest.Test().Printf(

			_L("Compared times more than 1 minute different (%u) at line %u"),

			timeDiffSeconds.Int(),

			aLineNum);

		TheAlarmTest(EFalse, __LINE__);

		}

	}

/**

Sets the system time of the device to the given local (wall-clock) time.

@param aTime The time to set.

@internalComponent

*/

static void SetHomeTime(const TTime& aTime)

    {

    TInt err = timezone.SetHomeTime(aTime);

    TheAlarmTest(err == KErrNone, __LINE__);

    }

// If aDszOn is true, set to a time in BST.

// If aDszOn is false, set to a time in GMT.

static void EnableDaylightSavingL(TBool aDszOn)

	{

	// Using TLocale to set daylight saving mode no longer works, since this is controlled by

	// the Time Zone Server. Instead the time must be set such that DST rules are in force in a

	// locale where such rules apply, e.g. 01-06-2004 12:00 BST.

	// Set the time zone to a known location.

	_LIT8(KTZName, "Europe/London");

	CTzId* zoneId = CTzId::NewL(KTZName);

	CleanupStack::PushL(zoneId);

	timezone.SetTimeZoneL(*zoneId);

	CleanupStack::PopAndDestroy(zoneId);

	// Set daylight saving time on/off. Note that when DST is set 'on' a DST change event occurs

	// almost immediately - this tests that the Alarm Queue is updated correctly for DST events.

	if (aDszOn)

		{

		// Set the system time to a time in the British Summer: 31-10-2004 01:59:58 BST = 00:59:00 UTC

		const TInt KBstOffset = 3600;

		_LIT(KTime, "20040930:005958.000000");  // Just before the DST change.

		TInt err = User::SetUTCTimeAndOffset(TTime(KTime), KBstOffset);

		TheAlarmTest(err == KErrNone, __LINE__);

		}

	else

		{

		// Set the system time to a time in the British Winter: 31-10-2004 01:00:00 GMT = 01:00:00 UTC

		const TInt KGmtOffset = 0;

		_LIT(KTime, "20040930:010000.000000"); // Just after the DST change.

		TInt err = User::SetUTCTimeAndOffset(TTime(KTime), KGmtOffset);

		TheAlarmTest(err == KErrNone, __LINE__);

		}

	}

static TTime SetClockAlarms(const TTime& aBaseTime, const TTimeIntervalMinutes& aOffset)

//

// Set Alarms.

// Extra alarm when putting clocks back to see what happen to

// weekly alarm set for 6 days & 23 1/2 hours time

//

	{

	TInt r;

	TASShdAlarm alarm;

	const TInt n = TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();

	TheAlarmTest(n == 0, __LINE__);

	//

	TTime timeForAlarms(aBaseTime);

	timeForAlarms += aOffset;

	// Once Only

	alarm.Reset();

	alarm.Message().Num(0);

	alarm.NextDueTime() = timeForAlarms;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;

	r = TheAlarmTest.Session().AlarmAdd(alarm);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheClockAlarmSlots[0] = alarm.Id();

	// Next 24 hours

	alarm.Reset();

	alarm.Message().Num(1);

	alarm.NextDueTime() = timeForAlarms;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatNext24Hours;

	r = TheAlarmTest.Session().AlarmAdd(alarm);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheClockAlarmSlots[1] = alarm.Id();

	// Clock daily

	alarm.Reset();

	alarm.Message().Num(2);

	alarm.NextDueTime() = timeForAlarms;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatDaily;

	r = TheAlarmTest.Session().AlarmAdd(alarm);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheClockAlarmSlots[2] = alarm.Id();

	// Clock weekly

	alarm.Reset();

	alarm.Message().Num(3);

	alarm.NextDueTime() = timeForAlarms;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatWeekly;

	r = TheAlarmTest.Session().AlarmAdd(alarm);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheClockAlarmSlots[3] = alarm.Id();

	if (aOffset.Int() < 0)

		{

		TheExtendedAlarmTime = timeForAlarms;

		TheExtendedAlarmTime += TTimeIntervalDays(7);

		alarm.Message().Num(4);

		alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatWeekly;

		alarm.NextDueTime() = TheExtendedAlarmTime;

		r = TheAlarmTest.Session().AlarmAdd(alarm);

		TheAlarmTest(r == KErrNone, __LINE__);

		TheClockAlarmSlots[4] = alarm.Id();

		}

	return timeForAlarms;

	}

/**

Checks that the alarms are correct.

//

//	We expect and test that:

//

//	1)	Once alarm to remain unchanged at initial alarm time

//		unless allowed time to complete.

//

//	2)	Next24 to advance to the first 'initial alarm time'

//		falling due after the original time

//

//	3a)	If before clocks go back, Weekly (set previously) to

//		advance to the 'initial alarm time' in the next week

//

//	3b)	If after clocks go back, Weekly (set previously) to

//		return to the 'initial alarm time' in the current week

//

//	4a)	If before clocks go back, Weekly (set for next week)

//		to remain at the 'extended alarm time' in the next week

//

//	4b)	If after clocks go back, Weekly (set for next week) to

//		move back to 'initial alarm time' in the current week

//

@param aInterveningOffsetChange True when a change in the UTC offset occurs

between setting the alarms and testing them.

@param aOnceCompleted True if the "Repeat Once" alarm has completed.

@internalComponent

*/

static void VerifyAlarmsAreCorrect(TBool aInterveningOffsetChange, TBool aOnceCompleted)

	{

	TInt ret;

	TTime setTime;

	TASShdAlarm alarm;

	TAlarmId alarmId;

	TTime time;

	time.HomeTime();

	// Check Once repeat if it has not completed.

	if (!aOnceCompleted)

		{

		alarmId = TheClockAlarmSlots[0];

		TheAlarmTest(alarmId != KNullAlarmId, __LINE__);

		ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

		TheAlarmTest(ret == KErrNone, __LINE__);

		CheckTimesAreEqual(TheInitialAlarmTime, alarm.NextDueTime(), __LINE__);

		}

	// Check Next 24 hours repeat

	alarmId = TheClockAlarmSlots[1];

	TheAlarmTest(alarmId != KNullAlarmId, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	TheAlarmTest(ret == KErrNone, __LINE__);

	setTime = TheInitialAlarmTime;

    // The alarm was set in the past, so add repeat interval.

	setTime += TTimeIntervalHours(+24);

	CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	// Check daily repeat

	alarmId = TheClockAlarmSlots[2];

	TheAlarmTest(alarmId != KNullAlarmId, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	TheAlarmTest(ret == KErrNone, __LINE__);

	setTime = TheInitialAlarmTime;

	if (aInterveningOffsetChange)

		{

		// The alarm was set in the past, so add repeat interval.

		setTime += TTimeIntervalHours(+24);

		}

	CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	// Check weekly repeat

	alarmId = TheClockAlarmSlots[3];

	TheAlarmTest(alarmId != KNullAlarmId, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	TheAlarmTest(ret == KErrNone, __LINE__);

	setTime = TheInitialAlarmTime;

	if (aInterveningOffsetChange)

		{

		// The alarm was set in the past, so add repeat interval.

		setTime += TTimeIntervalDays(+7);

		}

	CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	// Check weekly repeat

	alarmId = TheClockAlarmSlots[4];

	TheAlarmTest(alarmId != KNullAlarmId, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	TheAlarmTest(ret == KErrNone, __LINE__);

	if (aInterveningOffsetChange)

		{

		setTime = TheExtendedAlarmTime;

		}

	else

	    {

	    setTime = TheInitialAlarmTime;

	    }

	CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	}

static void testAlarmsOnForwardingClocks(TBool aAfterClocksGoForward, TBool aAlarmsSetInPast, TBool aAlarmsShouldAllBeQueued = ETrue)

//

//	We expect and test that:

//	1)	Once alarm to remain unchanged at 'initial alarm time'

//	2)	Next24 to remain at the 'initial alarm time'

//	3a)	If before clocks go forward, Weekly to remain at the

//		'initial alarm time'

//	3b)	If after clocks go forward, Weekly to advance to 'initial

//		alarm time' in the next week

//

	{

	TInt ret;

	TASShdAlarm alarm;

	TAlarmId alarmId;

	TTime setTime;

	//	Check Once repeat

	alarmId = TheClockAlarmSlots[0];

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	setTime = TheInitialAlarmTime;

	// Note that the time of the expected alarm should be the same as when

	// originally set. No adjustment for any UTC offset is required.

	if (aAlarmsShouldAllBeQueued)

	    {

	    TheAlarmTest(ret == KErrNone, __LINE__);

	    }

	if (ret == KErrNone && alarm.Status() == EAlarmStatusEnabled)

	    {

	    CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	    }

	//	Check Next 24 hours repeat

	alarmId = TheClockAlarmSlots[1];

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	setTime = TheInitialAlarmTime;

	if (aAlarmsShouldAllBeQueued)

	    {

	    TheAlarmTest(ret == KErrNone, __LINE__);

	    }

	if (ret == KErrNone && alarm.Status() == EAlarmStatusEnabled)

	    {

	    CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	    }

	//	Check daily repeat

	alarmId = TheClockAlarmSlots[2];

	TheAlarmTest(alarmId != KNullAlarmId, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	setTime = TheInitialAlarmTime;

	if (aAlarmsShouldAllBeQueued)

	    {

	    TheAlarmTest(ret == KErrNone, __LINE__);

	    }

	CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	//	Check weekly repeat

	alarmId = TheClockAlarmSlots[3];

	TheAlarmTest(alarmId != KNullAlarmId, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmDetails(alarmId, alarm);

	if (aAlarmsShouldAllBeQueued)

	    {

	    TheAlarmTest(ret == KErrNone, __LINE__);

	    }

	//

	setTime = TheInitialAlarmTime;

#if defined(_DEBUG)

    // In udeb the alarm goes from the state EAlarmStateQueued to the state EAlarmStateNotified

    // (skipping the state ENotifying).In EAlarmStateNotified the nextTime for the alarm is

    // recalculated and the expected value (called setTime here) needs adjustment to reflect this.

    // In urel the EAlarmStateNotified state (where the NextTime for an alarm is recalculated)

    // is never reached so the adjustement in the expected value (called setTime) is not necessary .

	if (aAfterClocksGoForward && aAlarmsSetInPast)

		{

		setTime += TTimeIntervalDays(+7);

		}

#else

	//Just to get rid of warning

	(void)aAfterClocksGoForward;

	(void)aAlarmsSetInPast;

#endif

	CheckTimesAreEqual(setTime, alarm.NextDueTime(), __LINE__);

	}

static void TestAlarmsWithDaylightSavingChange1L()

//

//	Test effects of changing daylight saving on clock alarms1

//

	{

	TheAlarmTest.Test().Next(_L("Initialise with daylight saving on"));

	EnableDaylightSavingL(ETrue);

	TheCurrentTime.HomeTime();

	//

	TheAlarmTest.Test().Next(_L("Setting alarms half an hour in the past"));

	TheInitialAlarmTime = SetClockAlarms(TheCurrentTime, TTimeIntervalMinutes(-30));

	//

	TheAlarmTest.Test().Next(_L("Testing alarms when daylight saving is on"));

    // Wait for DST to end.

    User::After(3000000);

	VerifyAlarmsAreCorrect(ETrue, EFalse);

	//

	TheAlarmTest.Test().Next(_L("Turning daylight saving off"));

	EnableDaylightSavingL(EFalse);

	//

	TheAlarmTest.Test().Next(_L("Testing alarms when daylight saving is off"));

	VerifyAlarmsAreCorrect(EFalse, ETrue);

	//

	TheAlarmTest.Test().Next(_L("Removing all alarms"));

	TheAlarmTest.TestClearStoreL();

	}

static void TestAlarmsWithDaylightSavingChange2L()

//

//	Test effects of changing daylight saving on clock alarms2

//

	{

	TheAlarmTest.Test().Next(_L("Initialise with daylight saving off"));

	EnableDaylightSavingL(EFalse);

	TheCurrentTime.HomeTime();

	//

	TheAlarmTest.Test().Next(_L("Setting alarms an hour and a half in the future"));

	// Used to set 30 minutes into future, but a defect in User::SetHomeTime() requires

	// times not to be set between 31-10-2004 1.59 (BST) and 31-10-2004 1.59 (GMT).

	TheInitialAlarmTime = SetClockAlarms(TheCurrentTime, TTimeIntervalMinutes(90));

	//

	TheAlarmTest.Test().Next(_L("Testing alarms with daylight saving off"));

	testAlarmsOnForwardingClocks(EFalse, EFalse, ETrue);

	//

	TheAlarmTest.Test().Next(_L("Turning daylight saving on"));

	EnableDaylightSavingL(ETrue);

	//

	TheAlarmTest.Test().Next(_L("Testing alarms with daylight saving on"));

	testAlarmsOnForwardingClocks(ETrue, EFalse, EFalse);

	//

	TheAlarmTest.Test().Next(_L("Removing all alarms"));

	TheAlarmTest.TestClearStoreL();

	}

//

//	Test changes in workdays

//

static void testSetWithNoWorkdays()

//

//	Test what happens when setting a workday alarm with no workdays set

//

	{

	TheAlarmTest.Test().Next(_L("Setting workday alarm with no workday set"));

	// Set no workdays

	TUint workdayMask = 0;

	TLocale locale;

	locale.SetWorkDays(workdayMask);

	locale.Set();

	// Have to wait a bit here because the kernel takes some time

	// to notify client-side environment change objects and so

	// we need to allow the alarm server to do its thing...

	User::After(100000);

	//

	TInt ret = TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();

	TheAlarmTest(ret == 0, __LINE__);

	//

	TheOriginalTime.HomeTime();

	TheInitialAlarmTime = TheOriginalTime;

	TheInitialAlarmTime += TTimeIntervalHours(1);

	//

	TASShdAlarm alarm;

	alarm.Message() = _L("Clock alarm in slot 0");

	alarm.NextDueTime() = TheInitialAlarmTime;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatWorkday;

	ret = TheAlarmTest.Session().AlarmAdd(alarm);

	TheAlarmTest(ret == KErrNone, __LINE__);

	TheAlarmTest(alarm.Id() != KNullAlarmId, __LINE__);

	TheClockAlarmSlots[0] = alarm.Id();

	// Test alarm state, should be disabled

	TASShdAlarm alarm2;

	ret = TheAlarmTest.Session().GetAlarmDetails(alarm.Id(), alarm2);

	TheAlarmTest(ret == KErrNone, __LINE__);

	TheAlarmTest(alarm2.Status() == EAlarmStatusDisabled, __LINE__);

	}

static void testDisabledAlarmWithWorkdays()

//

//  Test before-disabled alarm when workdays set is changed.

//

	{

	TheAlarmTest.Test().Next(_L("Testing disabled alarm when workdays set is changed"));

	const TAlarmId id = TheClockAlarmSlots[0];

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	//Set workdays on Monday

	TLocale locale;

	locale.SetWorkDays(0x1); //Monday

	locale.Set();

	User::After(100000);

	//Make sure the status of alarm being changed to enabled automatically