diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/Test/TClientSession.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commonappservices/alarmserver/Test/TClientSession.cpp	Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,1043 @@
+// 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__);
+	TheAlarmTest(TheAlarmTest.Session().GetAlarmStatus(id, status) == KErrNone, __LINE__);
+	TheAlarmTest(status == EAlarmStatusDisabled, __LINE__);
+
+	//delete all remaining alarms
+	TheAlarmTest.Session().AlarmDeleteAllByCategory(KASCliCategoryClock, EFalse);
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==0, __LINE__);
+	}
+
+void TestDeleteSnoozedAlarmL()
+	{
+	TheAlarmTest.Test().Next(_L("test delete snoozed agenda alarm"));
+	//******************************************************************************
+	// tests
+	//
+	// AlarmDeleteByCategory
+	//******************************************************************************
+	TheAlarmTest.TestClearStoreL();
+
+	//add 1 alarm with category KUidAgendaModelAlarmCategory
+
+	const TUid KUidAgendaModelAlarmCategory = { 0x101F4A70 };
+	TAlarmId id=AddAlarm(1, KUidAgendaModelAlarmCategory);
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==1, __LINE__);
+	User::After(1000000 * 61);
+	TTime now;
+	now.UniversalTime();
+	TTime timeToSnoozeUntil = now+ TTimeIntervalMinutes(1);
+	TheAlarmTest(TheAlarmTest.Session().__DbgSnoozeAlarm(id, timeToSnoozeUntil) == KErrNone);
+
+	TDeleteType whatToDelete=0;
+	whatToDelete=EFuture|EExpired;
+	User::LeaveIfError(TheAlarmTest.Session().AlarmDeleteByCategory(KUidAgendaModelAlarmCategory, whatToDelete));
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==1, __LINE__);
+
+	//delete all alarms
+	TheAlarmTest.Session().AlarmDeleteAllByCategory(KUidAgendaModelAlarmCategory, EFalse);
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==0, __LINE__);
+	}
+
+	
+static void TestCategorySpecificFunctionalityUtcL()
+	{
+	TheAlarmTest.Test().Next(_L("test category specific functionality for UTC alarms"));
+
+	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 = AddUtcAlarm(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)
+		{
+		AddUtcAlarm(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__);
+
+	CleanupStack::PopAndDestroy(&categoryList);    // Close array.
+	}
+
+
+void TestOverlappingUtcAlarmsL()
+	{
+	TheAlarmTest.Test().Next(_L("test overlapping alarms"));
+
+	//schedule 3 alarms for the same time
+	TTime time;
+	// TASShdAlarm::SetUtcNextDueTime(TTime aUtcTime), therefore can't use time.HomeTime()
+	time.UniversalTime();
+	time += TTimeIntervalSeconds(10);
+	for(TInt ii=0; ii<3; ii++)
+		{
+		AddUtcAlarm(time);
+		}
+
+	VerifyStates(3);
+	WaitForAlarmToExpire();
+	VerifyStates(0,1,2);
+
+	TheAlarmTest.TestClearStoreL();
+	TRequestStatus status;
+	TAlarmId alarmId;
+	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
+
+	// TASShdAlarm::SetUtcNextDueTime(TTime aUtcTime), therefore can't use time.HomeTime()
+	time.UniversalTime();
+	time += TTimeIntervalSeconds(10);
+	TAlarmId id1 = AddUtcAlarm(time);
+	time += TTimeIntervalSeconds(10);
+	TAlarmId id2 = AddUtcAlarm(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 TestUtcAlarmDetails1L()
+	{
+	TheAlarmTest.Test().Next(_L("test alarm details - 1"));
+
+	TheAlarmTest.TestClearStoreL();
+
+	TInt id = AddUtcAlarm(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 TestUtcAlarmDetails2L()
+	{
+	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 = AddUtcAlarm(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 TestUtcAlarmDetails3L()
+	{
+	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++)
+		{
+		AddUtcAlarm(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++)
+		{
+		AddUtcAlarm(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++)
+		{
+		AddUtcAlarm(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 = AddUtcAlarm(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__);
+	TheAlarmTest(TheAlarmTest.Session().GetAlarmStatus(id, status) == KErrNone, __LINE__);
+	TheAlarmTest(status == EAlarmStatusDisabled, __LINE__);
+
+	//delete all remaining alarms
+	TheAlarmTest.Session().AlarmDeleteAllByCategory(KASCliCategoryClock, EFalse);
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==0, __LINE__);
+	}
+
+
+void TestDeleteSnoozedUtcAlarmL()
+	{
+	TheAlarmTest.Test().Next(_L("test delete snoozed agenda alarm"));
+	//******************************************************************************
+	// tests
+	//
+	// AlarmDeleteByCategory
+	//******************************************************************************
+	TheAlarmTest.TestClearStoreL();
+
+	//add 1 alarm with category KUidAgendaModelAlarmCategory
+
+	const TUid KUidAgendaModelAlarmCategory = { 0x101F4A70 };
+	TAlarmId id=AddUtcAlarm(1, KUidAgendaModelAlarmCategory);
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==1, __LINE__);
+	User::After(1000000 * 61);
+	TTime now;
+	now.UniversalTime();
+	TTime timeToSnoozeUntil = now+ TTimeIntervalMinutes(1);
+	TheAlarmTest(TheAlarmTest.Session().__DbgSnoozeAlarm(id, timeToSnoozeUntil) == KErrNone);
+
+	TDeleteType whatToDelete=0;
+	whatToDelete=EFuture|EExpired;
+	User::LeaveIfError(TheAlarmTest.Session().AlarmDeleteByCategory(KUidAgendaModelAlarmCategory, whatToDelete));
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==1, __LINE__);
+
+	//delete all alarms
+	TheAlarmTest.Session().AlarmDeleteAllByCategory(KUidAgendaModelAlarmCategory, EFalse);
+	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue()==0, __LINE__);
+	}
+
+/**
+@SYMTestCaseID PIM-TCLIENTSESSION-0001
+*/
+	
+static void DoTestsL()
+	{
+	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
+	CleanupStack::PushL(scheduler);
+	CActiveScheduler::Install(scheduler);
+
+	TheAlarmTest.Test().Start(_L("@SYMTestCaseID PIM-TCLIENTSESSION-0001 Connecting to server"));
+	TInt r = TheAlarmTest.Session().Connect();
+	TheAlarmTest(r == KErrNone, __LINE__);
+
+#if defined(_DEBUG)
+// The alarm should only be allowed to display notification in WINS builds.
+#if defined(__WINSCW__)
+	TheAlarmTest.Session().__DbgPreventUserNotify(EFalse);
+#else
+	TheAlarmTest.Session().__DbgPreventUserNotify(ETrue);
+#endif
+#endif
+
+	TheAlarmTest.TestClearStoreL();
+
+	TestCategorySpecificFunctionalityL();
+	TestOverlappingAlarmsL();
+	TestAlarmDetails1L();
+	TestAlarmDetails2L();
+	TestAlarmDetails3L();
+
+#if defined(_DEBUG) && defined(__WINS__)
+	TestDeleteSnoozedAlarmL();
+#endif
+
+	TheAlarmTest.TestClearStoreL();
+
+	TestCategorySpecificFunctionalityUtcL();
+	TestOverlappingUtcAlarmsL();
+	TestUtcAlarmDetails1L();
+	TestUtcAlarmDetails2L();
+	TestUtcAlarmDetails3L();
+
+#if defined(_DEBUG) && defined(__WINS__)
+	TestDeleteSnoozedUtcAlarmL();
+#endif
+
+	TheAlarmTest.TestClearStoreL();
+
+	TheAlarmTest.Session().Close();
+
+	CleanupStack::PopAndDestroy(scheduler);
+	}
+
+GLDEF_C TInt E32Main()
+//
+// Test the alarm server.
+//
+	{
+	__UHEAP_MARK;
+	TInt ret = KErrNone;
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	if (!cleanup)
+	    {
+	    return KErrNoMemory;
+	    }
+
+	TheAlarmTest.Title();
+	TheAlarmTest.TestStartServers();
+	//
+	TRAPD(error, DoTestsL());
+	TheAlarmTest(error == KErrNone, __LINE__);
+	//
+    TRAP(ret,TheAlarmTest.EndL());
+    TheAlarmTest.Test().Close();
+	ASTstAlarmTest::Close();
+
+	delete cleanup;
+	__UHEAP_MARKEND;
+	return ret;
+	}