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

//

#include "ASTstAlarmTest.h"

// Globals

static TRequestStatus TheStatus;

// Constants

const TAlarmCategory KASCliCategoryTest		= { 0x101F5031 };

TAlarmId AddAlarm(TInt aMinutesFromNow, TAlarmCategory aAlarmCategory = KASCliCategoryClock)

	{

	TBuf<200> testTitle;

	testTitle.Format(_L("\nAdding alarm to expire in %d minutes\n"), aMinutesFromNow);

	TheAlarmTest.Test().Printf(testTitle);

	//

	TASShdAlarm alarm;

	alarm.Category() = aAlarmCategory;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalMinutes(aMinutesFromNow);

	//

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

	const TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	TAlarmCategory category;

	TheAlarmTest.Session().GetAlarmCategory(id, category);

	TheAlarmTest(category == aAlarmCategory, __LINE__);

	return id;

	}

TAlarmId AddAlarm(const TTime& aTime, TAlarmCategory aAlarmCategory = KASCliCategoryClock)

	{

	TheAlarmTest.Test().Printf(_L("\nAdding alarm\n"));

	//

	TASShdAlarm alarm;

	alarm.Category() = aAlarmCategory;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;

	alarm.NextDueTime()=aTime;

	//

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

	const TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	return id;

	}

TAlarmId AddUtcAlarm(TInt aMinutesFromNow, TAlarmCategory aAlarmCategory = KASCliCategoryClock)

	{

	TBuf<200> testTitle;

	testTitle.Format(_L("\nAdding UTC alarm to expire in %d minutes\n"), aMinutesFromNow);

	TheAlarmTest.Test().Printf(testTitle);

	//

	TASShdAlarm alarm;

	alarm.Category()=aAlarmCategory;

	alarm.RepeatDefinition()=(EAlarmRepeatDefintionRepeatOnce);

	TTime time;

	time.UniversalTime();

	time += TTimeIntervalMinutes(aMinutesFromNow);

	alarm.SetUtcNextDueTime(time);

	//

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

	const TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	TAlarmCategory category;

	TheAlarmTest.Session().GetAlarmCategory(id, category);

	TheAlarmTest(category == aAlarmCategory, __LINE__);

	return id;

	}

TAlarmId AddUtcAlarm(const TTime& aTime, TAlarmCategory aAlarmCategory = KASCliCategoryClock)

	{

	TheAlarmTest.Test().Printf(_L("\nAdding UTC alarm\n"));

	//

	TASShdAlarm alarm;

	alarm.Category()=aAlarmCategory;

	alarm.RepeatDefinition()=EAlarmRepeatDefintionRepeatOnce;

	alarm.SetUtcNextDueTime(aTime);

	//

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

	const TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	return id;

	}

void WaitForAlarmToExpire()

	{

#if defined(_DEBUG) || defined(__WINSCW__)

	TheAlarmTest.Test().Printf(_L("\nWaiting for alarm to expire...\n"));

	TAlarmId alarmId;

	TRequestStatus status;

	FOREVER

		{

		TheAlarmTest.Session().NotifyChange(status, alarmId);

		User::WaitForRequest(status);

		if	(status.Int() == EAlarmChangeEventTimerExpired)

			break;

		}

#endif

	}

void VerifyStates(TInt aQueued, TInt aNotifying=0, TInt aWaitingToNotify=0, TInt aNotified=0, TInt aSnoozed=0)

	{

#if defined(_DEBUG) || defined(__WINSCW__)

	TInt queued = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);

	TInt notifying = TheAlarmTest.Session().AlarmCountByState(EAlarmStateNotifying);

	TInt waitingToNotify = TheAlarmTest.Session().AlarmCountByState(EAlarmStateWaitingToNotify);

	TInt notified = TheAlarmTest.Session().AlarmCountByState(EAlarmStateNotified);

	TInt snoozed = TheAlarmTest.Session().AlarmCountByState(EAlarmStateSnoozed);

	//

	TheAlarmTest(queued == aQueued, __LINE__);

	// When TheAlarmTest.Session().__DbgPreventUserNotify() is set with ETrue (i.e. when

	// on target platform), all notifying alarms immediately become notified.

#if defined(__WINSCW__)

	TheAlarmTest(notifying == aNotifying, __LINE__);

	TheAlarmTest(waitingToNotify == aWaitingToNotify, __LINE__);

	TheAlarmTest(notified == aNotified, __LINE__);

#else   // __WINSCW__

	TheAlarmTest(notifying == 0, __LINE__);

	TheAlarmTest(waitingToNotify == 0, __LINE__);

	TheAlarmTest(notified == aNotified + aWaitingToNotify + aNotifying, __LINE__);

#endif  // __WINSCW__

	TheAlarmTest(snoozed == aSnoozed, __LINE__);

#endif

	}

void AlarmDeleteAllByCategoryIndirectlyL(TAlarmCategory aCategory)

	{

	if (TheAlarmTest.Session().GetAlarmCountForCategory(aCategory) == 0)

		return;

	//get ids of alarms with this category

	RArray<TAlarmId> alarmIds;

	CleanupClosePushL(alarmIds);

	TheAlarmTest.Session().GetAlarmIdListForCategoryL(aCategory, alarmIds);

	//delete alarms

	for (TInt ii = alarmIds.Count() - 1; ii >= 0; ii--)

		{

		TheAlarmTest.Session().AlarmDelete(alarmIds[ii]);

		TheAlarmTest(TheAlarmTest.Session().GetAlarmCountForCategory(aCategory) == ii, __LINE__);

		}

	CleanupStack::PopAndDestroy(&alarmIds); // Close array.

	}

//

//

//

//

//

static void TestCategorySpecificFunctionalityL()

	{

	TheAlarmTest.Test().Next(_L("test category specific functionality"));

	RArray<TAlarmCategory> categoryList;

	CleanupClosePushL(categoryList);

	TheAlarmTest.Session().GetAvailableCategoryListL(categoryList);

	TheAlarmTest(categoryList.Count() == 0, __LINE__);

	categoryList.Reset();

	//add 5 alarms with category KASCliCategoryClock 1,3,5,7,9 minutes from now

	TAlarmId id = KNullAlarmId;

	for (TInt ii=1; ii<=5; ++ii)

		{

		const TAlarmId allocatedId = AddAlarm(2*ii - 1);

		if (id == KNullAlarmId)

			{

			id = allocatedId;

			}

		TheAlarmTest(TheAlarmTest.Session().GetAlarmCountForCategory(KASCliCategoryClock) == ii, __LINE__);

		}

	TheAlarmTest.Session().GetAvailableCategoryListL(categoryList);

	TheAlarmTest(categoryList.Count() == 1 && categoryList[0] == KASCliCategoryClock, __LINE__);

	categoryList.Reset();

	//add 5 alarms with category KASCliCategoryTest 2,4,6,8,10 minutes from now

	for (TInt jj=1; jj<=5; ++jj)

		{

		AddAlarm(2*jj, KASCliCategoryTest);

		TheAlarmTest(TheAlarmTest.Session().GetAlarmCountForCategory(KASCliCategoryTest) == jj, __LINE__);

		}

	TheAlarmTest.Session().GetAvailableCategoryListL(categoryList);

	TheAlarmTest(categoryList.Count() == 2, __LINE__);

	categoryList.Reset();

	VerifyStates(10);

	WaitForAlarmToExpire();

	VerifyStates(9,1);

	WaitForAlarmToExpire();

	VerifyStates(8,1,1);

	//delete all KASCliCategoryTest alarms

	AlarmDeleteAllByCategoryIndirectlyL(KASCliCategoryTest);

	TheAlarmTest.Session().GetAvailableCategoryListL(categoryList);

	TheAlarmTest(categoryList.Count() == 1 && categoryList[0] == KASCliCategoryClock, __LINE__);

	categoryList.Reset();

	//delete all KASCliCategoryClock alarms

	TheAlarmTest.Session().AlarmDeleteAllByCategory(KASCliCategoryClock, EFalse);

	TheAlarmTest.Session().GetAvailableCategoryListL(categoryList);

	TheAlarmTest(categoryList.Count() == 0, __LINE__);

    TheAlarmTest.TestClearStoreL();

	CleanupStack::PopAndDestroy(&categoryList); // Close array.

	}

void TestOverlappingAlarmsL()

	{

	TheAlarmTest.Test().Next(_L("test overlapping alarms"));

	//schedule 3 alarms for the same time

	TTime time;

	time.HomeTime();

	time += TTimeIntervalSeconds(10);

	for(TInt ii=0; ii<3; ii++)

		{

		AddAlarm(time);

		}

	VerifyStates(3);

	WaitForAlarmToExpire();

	User::After(1000000);

	VerifyStates(0,1,2);

	TheAlarmTest.TestClearStoreL();

    TRequestStatus status;

    TAlarmId alarmId;

    TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

	time.HomeTime();

	time += TTimeIntervalSeconds(10);

	TAlarmId id1 = AddAlarm(time);

	time += TTimeIntervalSeconds(10);

	TAlarmId id2 = AddAlarm(time);

	TASShdAlarm alarm1;

	TASShdAlarm alarm2;

#if defined(_DEBUG)

	WaitForAlarmToExpire();

	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id1, alarm1) == KErrNone, __LINE__);

	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id2, alarm2) == KErrNone, __LINE__);

#if defined(__WINSCW__)

	TheAlarmTest(alarm1.State() == EAlarmStateNotifying, __LINE__);

	TheAlarmTest(alarm2.State() == EAlarmStateQueued, __LINE__);

#else

	TheAlarmTest(alarm1.State() == EAlarmStateNotified, __LINE__);

	TheAlarmTest(alarm2.State() == EAlarmStateQueued, __LINE__);

#endif

	WaitForAlarmToExpire();

	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id1, alarm1) == KErrNone, __LINE__);

	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id2, alarm2) == KErrNone, __LINE__);

#if defined(__WINSCW__)

	TheAlarmTest(alarm1.State() == EAlarmStateNotifying, __LINE__);

	TheAlarmTest(alarm2.State() == EAlarmStateWaitingToNotify, __LINE__);

#else

	TheAlarmTest(alarm1.State() == EAlarmStateNotified, __LINE__);

	TheAlarmTest(alarm2.State() == EAlarmStateNotified, __LINE__);

#endif

#endif

	TheAlarmTest.TestClearStoreL();

	}

void  TestAlarmDetails1L()

	{

	TheAlarmTest.Test().Next(_L("test alarm details - 1"));

	TheAlarmTest.TestClearStoreL();

	TInt id = AddAlarm(1);

	TAlarmStatus status;

	TheAlarmTest(TheAlarmTest.Session().GetAlarmStatus(id, status) == KErrNone, __LINE__);

	TheAlarmTest(status == EAlarmStatusEnabled, __LINE__);

	TheAlarmTest(TheAlarmTest.Session().SetAlarmStatus(id, EAlarmStatusDisabled) == KErrNone, __LINE__);

	TheAlarmTest(TheAlarmTest.Session().GetAlarmStatus(id, status) == KErrNone, __LINE__);

	TheAlarmTest(status == EAlarmStatusDisabled, __LINE__);

	TheAlarmTest(TheAlarmTest.Session().SetAlarmStatusByCategory(KASCliCategoryClock, EAlarmStatusEnabled) == KErrNone, __LINE__);

	TheAlarmTest(TheAlarmTest.Session().GetAlarmStatus(id, status) == KErrNone, __LINE__);

	TheAlarmTest(status == EAlarmStatusEnabled, __LINE__);

	WaitForAlarmToExpire();

	TheAlarmTest.Session().AlarmDelete(id);

	}

void TestAlarmDetails2L()

	{

	TheAlarmTest.Test().Next(_L("test alarm details - 2"));

	//******************************************************************************

	// tests

	//

	// AlarmAddL

	// AlarmDeleteL

	// AlarmCountByCategory

	// AlarmCountByState

	// AlarmIdListByStateLC

	//******************************************************************************

	TheAlarmTest.TestClearStoreL();

	RArray<TAlarmId> alarmIds;

	CleanupClosePushL(alarmIds);

	//add 10 alarms (category KASCliCategoryClock)

	for(TInt ii=1; ii<=10; ii++)

		{

		TInt minutesFromNow = (ii);

		TAlarmId id = AddAlarm(minutesFromNow);

		alarmIds.AppendL(id);

		TInt numberOfAlarms = TheAlarmTest.Session().GetAlarmCountForCategory(KASCliCategoryClock);

		TheAlarmTest(numberOfAlarms == ii, __LINE__);

		}

	//check states of alarms

	TInt alarmCount=0;

	//states should be:

	// 10 x EAlarmStateQueued

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);

	TheAlarmTest(alarmCount == 10, __LINE__);

#if defined(_DEBUG)

#if defined(__WINSCW__)

	//wait for alarm to expire

	WaitForAlarmToExpire();

	//states should be:

	// 1 x EAlarmStateNotifying

	// 9 x EAlarmStateQueued

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateNotifying);

	TheAlarmTest(alarmCount == 1, __LINE__);

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);

	TheAlarmTest(alarmCount == 9, __LINE__);

	//wait for another alarm to expire

	WaitForAlarmToExpire();

	//states should be:

	// 1 x EAlarmStateNotifying

	// 1 x EAlarmStateWaitingToNotify

	// 8 x EAlarmStateQueued

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateNotifying);

	TheAlarmTest(alarmCount == 1, __LINE__);

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateWaitingToNotify);

	TheAlarmTest(alarmCount == 1, __LINE__);

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);

	TheAlarmTest(alarmCount == 8, __LINE__);

	//last 8 alarms in our array should correspond to array of alarms with state queued

	RArray<TAlarmId> alarmsWithStateQueued;

	CleanupClosePushL(alarmsWithStateQueued);

	TheAlarmTest.Session().GetAlarmIdListByStateL(EAlarmStateQueued, alarmsWithStateQueued);

		for(TInt jj=0; jj<8; jj++)

		{

		TheAlarmTest(alarmIds[jj+2] == alarmsWithStateQueued[jj], __LINE__);

		}

	CleanupStack::PopAndDestroy(&alarmsWithStateQueued);    // Close array.

#else

	//wait for alarm to expire

	WaitForAlarmToExpire();

	//states should be:

	// 1 x EAlarmStateNotified

	// 9 x EAlarmStateQueued

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateNotified);

	TheAlarmTest(alarmCount == 1, __LINE__);

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);

	TheAlarmTest(alarmCount == 9, __LINE__);

	//wait for another alarm to expire

	WaitForAlarmToExpire();

	//states should be:

	// 2 x EAlarmStateNotified

	// 8 x EAlarmStateQueued

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateNotified);

	TheAlarmTest(alarmCount == 2, __LINE__);

	alarmCount = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);

	TheAlarmTest(alarmCount == 8, __LINE__);

	//last 8 alarms in our array should correspond to array of alarms with state queued

	RArray<TAlarmId> alarmsWithStateQueued;

	CleanupClosePushL(alarmsWithStateQueued);

	TheAlarmTest.Session().GetAlarmIdListByStateL(EAlarmStateQueued, alarmsWithStateQueued);

		for(TInt jj=0; jj<8; jj++)

		{

		TheAlarmTest(alarmIds[jj+2] == alarmsWithStateQueued[jj], __LINE__);

		}

	CleanupStack::PopAndDestroy(&alarmsWithStateQueued);    // Close array.

#endif

#endif

	//delete all alarms individually

	for (TInt count = alarmIds.Count() - 1; count >= 0; count--)

		{

		TheAlarmTest.Session().AlarmDelete(alarmIds[count]);

		}

	CleanupStack::PopAndDestroy(&alarmIds);    // Close array.

	}

void TestAlarmDetails3L()

	{

	TheAlarmTest.Test().Next(_L("test alarm details - 3"));

	//******************************************************************************

	// tests

	//

	// AlarmDetailsL

	// AlarmCategoryL

	// SetAlarmStatusByCategoryL

	// AlarmCountByCategory

	// DeleteAllAlarmsByCategoryL

	// AlarmCategoryListLC

	// AlarmIdListByCategoryLC

	// SetAlarmStatusL

	// AlarmStatus

	//******************************************************************************

	TheAlarmTest.TestClearStoreL();

	//add 5 alarms with category KASCliCategoryClock

	for(TInt ii=1; ii<=5; ii++)

		{

		AddAlarm(ii, KASCliCategoryClock);

		}

	//get list of categories - should contain only KASCliCategoryClock

	RArray<TAlarmCategory> alarmCategories;

	CleanupClosePushL(alarmCategories);

	TheAlarmTest.Session().GetAvailableCategoryListL(alarmCategories);

	TheAlarmTest(alarmCategories.Count() == 1 && alarmCategories[0] == KASCliCategoryClock, __LINE__);

	//add 5 alarms with category KASCliCategoryTest

	for(TInt jj=1; jj<=5; jj++)

		{

		AddAlarm(jj, KASCliCategoryTest);

		}

	alarmCategories.Reset();

	TheAlarmTest.Session().GetAvailableCategoryListL(alarmCategories);

	TheAlarmTest(alarmCategories.Count() == 2, __LINE__);

	CleanupStack::PopAndDestroy(&alarmCategories);    // Close array.

	//add another 10 alarms with category KASCliCategoryClock

	for(TInt kk=1; kk<=10; kk++)

		{

		AddAlarm(kk, KASCliCategoryClock);

		}

	//get alarms with category KASCliCategoryClock

	RArray<TAlarmId> alarms;

	CleanupClosePushL(alarms);

	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, alarms);

	TInt count = alarms.Count();

	TheAlarmTest(count == 15, __LINE__);

	//check each alarm has category KASCliCategoryClock

	for(TInt mm=0; mm<15; mm++)

		{

		//directly

		TAlarmCategory category;

		TheAlarmTest(TheAlarmTest.Session().GetAlarmCategory(alarms[mm], category) == KErrNone, __LINE__);

		TheAlarmTest(category == KASCliCategoryClock, __LINE__);

		//indirectly

		TASShdAlarm alarm;

		TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(alarms[mm], alarm) == KErrNone, __LINE__);

		TheAlarmTest(alarm.Category() == KASCliCategoryClock, __LINE__);

		}

	CleanupStack::PopAndDestroy(&alarms);    // Close array.

	//should now have 15 alarms with category KASCliCategoryClock and 5 with category KASCliCategoryTest

	TheAlarmTest(TheAlarmTest.Session().GetAlarmCountForCategory(KASCliCategoryClock)==15 &&

		TheAlarmTest.Session().GetAlarmCountForCategory(KASCliCategoryTest)==5, __LINE__);

	//disable all KASCliCategoryClock alarms

	TheAlarmTest.Session().SetAlarmStatusByCategory(KASCliCategoryClock, EAlarmStatusDisabled);

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==5, __LINE__);

	//try to delete all KASCliCategoryTest orphaned alarms (should be none)

	TheAlarmTest.Session().AlarmDeleteAllByCategory(KASCliCategoryTest, ETrue);

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==5, __LINE__);

	//delete all KASCliCategoryTest alarms

	TheAlarmTest.Session().AlarmDeleteAllByCategory(KASCliCategoryTest, EFalse);

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==0, __LINE__);

	//re-enable the KASCliCategoryClock alarms

	TheAlarmTest.Session().SetAlarmStatusByCategory(KASCliCategoryClock, EAlarmStatusEnabled);

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==15, __LINE__);

	//create a new enabled alarm

	TAlarmId id = AddAlarm(1, KASCliCategoryClock);

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==16, __LINE__);

	//check status

	TAlarmStatus status;

	TheAlarmTest(TheAlarmTest.Session().GetAlarmStatus(id, status) == KErrNone, __LINE__);

	TheAlarmTest(status == EAlarmStatusEnabled, __LINE__);

	//disable it

	TheAlarmTest.Session().SetAlarmStatus(id, EAlarmStatusDisabled);

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==15, __LINE__);