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

// 

//

#include "ASTstAlarmTest.h"

// Type definitions

#define UNUSED_VAR(a) a = a

// Constants

const TUint KHeapMinSize=0x01000;

const TUint KHeapMaxSize=0x10000;

// Global data

static TAlarmId TheAlarmId;

static TBool TheNotifyFlag=EFalse;

static TBool TheNotifyThread=ETrue;

static TRequestStatus TheSsnStatus;

static TRequestStatus ThisRequest=KErrNone;

static TRequestStatus CurrentRequest=KErrNone;

// Prototypes

static void testOtherNotify(TBool aExpected);

static TInt ntfThreadMain(TAny* /*aPtr*/)

//

//	Main thread of notification thread

//

	{

	RASCliSession almSvr;

	const TInt r=almSvr.Connect();

	TheAlarmTest(r==KErrNone, __LINE__);

	//

	TAlarmId alarmId;

	TRequestStatus stat;

	FOREVER

		{

		FOREVER

			{

			almSvr.NotifyChange(stat, alarmId);

			User::After(KTimeToWait);

			if	(stat == KRequestPending)

				break;

			User::WaitForRequest(stat);

			}

		User::WaitForRequest(stat);

		//

		if (!TheNotifyThread)

			break;

		//

		TheAlarmTest(stat >= EAlarmChangeEventState && stat <= EAlarmChangeEventLast, __LINE__);

		TheNotifyFlag = ETrue;

		}

	//

	TheNotifyFlag=ETrue;

	return(KErrNone);

	}

static void startNotifyThread(TPtrC16 aThreadName)

//

//	Start the thread that determines NotifyOnChange

//

	{

	TheAlarmTest.Test().Next(_L("Starting the notification test thread"));

	RThread t;

	TInt r=t.Create(aThreadName,ntfThreadMain,KDefaultStackSize,KHeapMinSize,KHeapMaxSize,NULL);

	TheAlarmTest(r==KErrNone, __LINE__);

	TRequestStatus tStat;

	t.Logon(tStat);

	t.SetPriority(EPriorityMore);

	TheAlarmTest(tStat==KRequestPending, __LINE__);

	t.Resume();

	TheAlarmTest(tStat==KRequestPending, __LINE__);

	User::After(KTimeToWait);

	}

static void testSetupNotify(TPtrC16 aThreadName)

//

//	Set up the notify requests

//

	{

	TheNotifyFlag=EFalse;

	startNotifyThread(aThreadName);

	//

	TheAlarmTest.Test().Next(_L("Set up notification requests"));

	//

	TheAlarmTest.Session().NotifyChange(CurrentRequest, TheAlarmId);

	User::WaitForRequest(CurrentRequest);

	//

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(CurrentRequest, TheAlarmId);

	TheAlarmTest.Session().NotifyChangeCancel();

	//

	TheAlarmTest(CurrentRequest == KErrCancel, __LINE__);

	TheAlarmTest(TheNotifyFlag == EFalse, __LINE__);

	//

#if defined(_DEBUG)

	TheAlarmTest.Session().__DbgPreventUserNotify(ETrue);

#endif

	}

static void testOtherNotify(TBool aExpected)

//

//	Check there was a notification to the notify thread

//

	{

	User::After(KTimeToWait);

	TheAlarmTest(TheNotifyFlag==aExpected, __LINE__);

	TheNotifyFlag=EFalse;

	}

static TAlarmId SetSessionAlarm(TASShdAlarm& aAlarm, const TTime& aTime, TRequestStatus& aStatus)

//

//	Set the session alarm

//

	{

	TheAlarmTest(TheNotifyFlag == EFalse, __LINE__);

	//

	aAlarm.Reset();

	aAlarm.Message() = _L("The session alarm");

	aAlarm.NextDueTime() = aTime;

	aAlarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);

	//

	TheAlarmTest.Session().AlarmAddWithNotification(aStatus, aAlarm);

	TheAlarmTest(aStatus == KRequestPending, __LINE__);

	//

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

	return aAlarm.Id();

	}

static void testSetSessionAlarm(const TDesC& aDes, const TTime& aDueTime)

//

//	Test setting a session alarm

//

	{

	TheAlarmTest.Test().Next(aDes);

	// Check there's nothing ready

	testOtherNotify(EFalse);

	// Get all events from the event buffer

	TAlarmId alarmId;

	TRequestStatus notificationStatus;

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(notificationStatus == KRequestPending, __LINE__);

	// Queue session alarm

	TRequestStatus sessionAlarmStatus;

	TASShdAlarm alarm;

	TAlarmId sessionAlarmId = SetSessionAlarm(alarm, aDueTime, sessionAlarmStatus);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Get details

	TASShdAlarm alarm2;

	TInt r = TheAlarmTest.Session().GetAlarmDetails(sessionAlarmId, alarm2);

	TheAlarmTest(r == KErrNone, __LINE__);

	TDateTime dateTime = aDueTime.DateTime();

	TDateTime alarmTime = alarm2.NextDueTime().DateTime();

	// Check details

	TheAlarmTest(alarmTime.Day()==dateTime.Day(), __LINE__);

	TheAlarmTest(alarmTime.Hour()==dateTime.Hour(), __LINE__);

	TheAlarmTest(alarmTime.Minute()==dateTime.Minute(), __LINE__);

	alarmTime = alarm2.NextDueTime().DateTime();

	dateTime = aDueTime.DateTime();

	TheAlarmTest(alarmTime.Day()==dateTime.Day(), __LINE__);

	TheAlarmTest(alarmTime.Hour()==dateTime.Hour(), __LINE__);

	TheAlarmTest(alarmTime.Minute()==dateTime.Minute(), __LINE__);

	// Cancel alarm

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(notificationStatus == KRequestPending, __LINE__);

	TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(sessionAlarmId);

	User::WaitForRequest(sessionAlarmStatus);

	TheAlarmTest(sessionAlarmStatus == KErrCancel, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus == EAlarmChangeEventAlarmDeletion, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Add another alarm

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	sessionAlarmId = SetSessionAlarm(alarm, aDueTime, sessionAlarmStatus);

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	// Orphan alarm

	r = TheAlarmTest.Session().SetAlarmCharacteristics(sessionAlarmId, EAlarmCharacteristicsSessionSpecific);

	User::WaitForRequest(sessionAlarmStatus);

	TheAlarmTest(sessionAlarmStatus == KErrCancel, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Get details

	r = TheAlarmTest.Session().GetAlarmDetails(sessionAlarmId, alarm);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheAlarmTest(alarm.HasBecomeOrphaned(), __LINE__);

	testOtherNotify(ETrue);

	}

static void testImmediateClose()

//

//	Test closing a session after the alarm goes off

//	The session alarm must be on the notification queue but not first

//	So that its session paramter is not cleared when its owner's name needs

//	to be found.

//

	{

	TTime time;

	time.HomeTime();

	TheAlarmTest(TheNotifyFlag == EFalse, __LINE__);

	TASShdAlarm alarm;

	alarm.SoundName() = _L("Signal");

	alarm.NextDueTime() = time - TTimeIntervalSeconds(75);

	alarm.Message() = _L("Session alarm");

	//

	RASCliSession almSvr;

	TheAlarmTest(almSvr.Connect() == KErrNone, __LINE__);

	almSvr.AlarmAddWithNotification(TheSsnStatus, alarm);

	//

	User::After(1000000);

	const TAlarmId sessionAlarmId = alarm.Id();

	TheAlarmTest(sessionAlarmId != KNullAlarmId, __LINE__);

	//

	alarm.Reset();

	alarm.SoundName() = _L("Signal");

	alarm.NextDueTime() = time - TTimeIntervalSeconds(65);

	alarm.Message() = _L("Clock alarm");

	//

	TheAlarmTest(almSvr.AlarmAdd(alarm) == KErrNone, __LINE__);

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

	//

	almSvr.Close();

	//

	}

static void testSetAlarms()

//

//	Test setting a day alarm

//

	{

	TTime inAFewMinutes;

	inAFewMinutes.HomeTime();

	inAFewMinutes += TTimeIntervalMinutes(2);

	TTime inThreeDays;

	inThreeDays.HomeTime();

	inThreeDays += TTimeIntervalDays(3);

	//

	testSetSessionAlarm(_L("Session alarm, in a few minutes"), inAFewMinutes);

	testSetSessionAlarm(_L("Session alarm, in a few days"), inThreeDays);

	}

static void testTakeOverOrphanL()

//

//	Test whether a session alarm takes over an orphaned alarm

//

	{

	TheAlarmTest.Test().Next(_L("Take over orphaned"));

	TheAlarmTest.TestClearStoreL();

	testOtherNotify(ETrue);

	// Get all events from the event buffer

	TAlarmId alarmId;

	TRequestStatus notificationStatus;

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(notificationStatus == KRequestPending, __LINE__);

	// Add session alarm

	TASShdAlarm alarm;

	TTime time;

	time.HomeTime();

	time += TTimeIntervalDays(3);

	// Create session alarm

	TAlarmId sessionAlarmId = SetSessionAlarm(alarm, time, TheSsnStatus);

	TheAlarmTest(TheSsnStatus == KRequestPending, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Check the number of orphaned alarms is 0

	TInt n = TheAlarmTest.CountOrphanedAlarmsL();

	TheAlarmTest(n == 0, __LINE__);

	// Orphan the alarm

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(TheAlarmTest.Session().SetAlarmCharacteristics(sessionAlarmId, 0) == KErrNone, __LINE__);

	TheAlarmTest(TheSsnStatus == KErrCancel, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Check the number of orphaned alarms is 1

	n = TheAlarmTest.CountOrphanedAlarmsL();

	TheAlarmTest(n == 1, __LINE__);

	// Create another session alarm

	time.HomeTime();

	time += TTimeIntervalDays(4);

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	sessionAlarmId = SetSessionAlarm(alarm, time, TheSsnStatus);

	TheAlarmTest(TheSsnStatus == KRequestPending, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Check the number of orphaned alarms is 1

	n = TheAlarmTest.CountOrphanedAlarmsL();

	TheAlarmTest(n == 1, __LINE__);

	// Orphan the alarm

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(TheAlarmTest.Session().SetAlarmCharacteristics(sessionAlarmId, 0) == KErrNone, __LINE__);

	TheAlarmTest(TheSsnStatus == KErrCancel, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Check the number of orphaned alarms is 2

	n = TheAlarmTest.CountOrphanedAlarmsL();

	TheAlarmTest(n == 2, __LINE__);

	// Create another session alarm

	time.HomeTime();

	time += TTimeIntervalDays(5);

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	sessionAlarmId = SetSessionAlarm(alarm, time, TheSsnStatus);

	TheAlarmTest(TheSsnStatus == KRequestPending, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Check the number of orphaned alarms is 2

	n = TheAlarmTest.CountOrphanedAlarmsL();

	TheAlarmTest(n == 2, __LINE__);

	// Cancel session alarm

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(notificationStatus == KRequestPending, __LINE__);

	TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(sessionAlarmId);

	User::WaitForRequest(TheSsnStatus);

	TheAlarmTest(TheSsnStatus == KErrCancel, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Check the number of orphaned alarms is 2

	n = TheAlarmTest.CountOrphanedAlarmsL();

	TheAlarmTest(n == 2, __LINE__);

	}

static TAlarmId SetSessionUtcAlarm(TASShdAlarm& aAlarm, const TTime& aTime, TRequestStatus& aStatus)

//

//	Set the session UTC alarm

//

	{

	TheAlarmTest(TheNotifyFlag == EFalse, __LINE__);

	//

	aAlarm.Reset();

	aAlarm.Message()=(_L("The session UTC alarm"));

	aAlarm.SetUtcNextDueTime(aTime);

	aAlarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);

	//

	TheAlarmTest.Session().AlarmAddWithNotification(aStatus, aAlarm);

	TheAlarmTest(aStatus == KRequestPending, __LINE__);

	//

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

	return aAlarm.Id();

	}

static void testSetSessionUtcAlarm(const TDesC& aDes, const TTime& aDueTime)

//

//	Test setting a session UTC alarm

//

	{

	TheAlarmTest.Test().Next(aDes);

	// Check there's nothing ready

	testOtherNotify(EFalse);

	// Get all events from the event buffer

	TAlarmId alarmId;

	TRequestStatus notificationStatus;

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(notificationStatus == KRequestPending, __LINE__);

	// Queue session alarm

	TRequestStatus sessionAlarmStatus;

	TASShdAlarm alarm;

	TAlarmId sessionAlarmId = SetSessionUtcAlarm(alarm, aDueTime, sessionAlarmStatus);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Get details

	TASShdAlarm alarm2;

	TInt r = TheAlarmTest.Session().GetAlarmDetails(sessionAlarmId, alarm2);

	TheAlarmTest(r == KErrNone, __LINE__);

	TDateTime dateTime = aDueTime.DateTime();

	TDateTime alarmTime = alarm2.NextDueTime().DateTime();

	// Check details

	TheAlarmTest(alarmTime.Day()==dateTime.Day(), __LINE__);

	TheAlarmTest(alarmTime.Hour()==dateTime.Hour(), __LINE__);

	TheAlarmTest(alarmTime.Minute()==dateTime.Minute(), __LINE__);

	alarmTime = alarm2.NextDueTime().DateTime();

	dateTime = aDueTime.DateTime();

	TheAlarmTest(alarmTime.Day()==dateTime.Day(), __LINE__);

	TheAlarmTest(alarmTime.Hour()==dateTime.Hour(), __LINE__);

	TheAlarmTest(alarmTime.Minute()==dateTime.Minute(), __LINE__);

	// Cancel alarm

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	TheAlarmTest(notificationStatus == KRequestPending, __LINE__);

	TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(sessionAlarmId);

	User::WaitForRequest(sessionAlarmStatus);

	TheAlarmTest(sessionAlarmStatus == KErrCancel, __LINE__);

	// Check that the notification thread was updated

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus == EAlarmChangeEventAlarmDeletion, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Add another alarm

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	sessionAlarmId = SetSessionUtcAlarm(alarm, aDueTime, sessionAlarmStatus);

	testOtherNotify(ETrue);

	// Check that the notification request was correctly updated

	User::WaitForRequest(notificationStatus);

	TheAlarmTest(notificationStatus > 0, __LINE__);

	TheAlarmTest.WaitForNotificationBufferToBeEmptied(notificationStatus, alarmId);

	// Orphan alarm

	r = TheAlarmTest.Session().SetAlarmCharacteristics(sessionAlarmId, EAlarmCharacteristicsSessionSpecific);

	User::WaitForRequest(sessionAlarmStatus);

	TheAlarmTest(sessionAlarmStatus == KErrCancel, __LINE__);

	TheAlarmTest(alarmId == sessionAlarmId, __LINE__);

	// Get details

	r = TheAlarmTest.Session().GetAlarmDetails(sessionAlarmId, alarm);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheAlarmTest(alarm.HasBecomeOrphaned(), __LINE__);

	testOtherNotify(ETrue);

	}

static void testImmediateCloseUtc()

//

//	Test closing a session after the alarm goes off

//	The session alarm must be on the notification queue but not first

//	So that its session paramter is not cleared when its owner's name needs

//	to be found.

//

	{

	TTime time;