--- /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;
+ }