1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "ASTstAlarmTest.h"

    17 #include "ASSrvDefs.h"

    18 

    19 #include <f32file.h>

    20 #include <s32file.h>

    21 #include <asclisoundplay.h>

    22 

    23 #include <connect/sbeclient.h>

    24 #include <tz.h>

    25 // Type definitions

    26 typedef CArrayFixFlat<TASCliSoundPlayDefinition> CPlayIntervalArray;

    27 

    28 

    29 // Literal constants

    30 _LIT(KAlarmServerTestBackupFile, "C:\\AlarmServer.bak");

    31 _LIT8(KSomeAlarmData, "This is some 8-bit data");

    32 

    33 //Temp fix for wk37, main updates for wk40

    34 _LIT(KAlarmServerBackupFileFullPath, "C:\\private\\101F5027\\AlarmServer.ini");

    35 

    36 static const TTimeIntervalMicroSeconds32 KTenSeconds = 10000000;

    37 

    38 #define KNewAlarmCycleStartOffsetMinutes		{0,10,20,30,50,100,200,300,450,600,900,1200,1800,2400, 3000, 4000, 5000, 10000,KErrNotFound};

    39 

    40 static RFs FsSession;

    41 static conn::CSBEClient* BackupClient;

    42 static TDriveList DriveList;

    43 

    44 

    45 //

    46 /* Try to give a fairly thorough test of the Alarm Server

    47  * during Startup Internalize, backup and restore

    48  */

    49 

    50 

    51 //

    52 // building block test Helper functions

    53 //

    54 

    55 static void Helper_StartBackupL()

    56 	{

    57 	// Use the Secure Backup Engine API to "start" a backup.  Ultimate effect

    58 	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.

    59 	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/

    60 	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

    61 	// These methods are implementations for MBackupRestoreNotificatioObserver

    62 	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.

    63 	// This P&S property is changed by calling the Secure Backup Engine API

    64 	// below.

    65 	BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase);

    66 	}

    67 

    68 

    69 static void Helper_EndBackupL()

    70 	{

    71 	// Use the Secure Backup Engine API to "end" a backup.  Ultimate effect

    72 	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.

    73 	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/

    74 	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

    75 	// These methods are implementations for MBackupRestoreNotificatioObserver

    76 	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.

    77 	// This P&S property is changed by calling the Secure Backup Engine API

    78 	// below.

    79 	BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);

    80 

    81 	// allow Alarm Server observers to be notified

    82 	User::After(1000);

    83 	}

    84 

    85 

    86 static void Helper_StartRestoreL()

    87 	{

    88 	// Use the Secure Backup Engine API to "start" a restore.  Ultimate effect

    89 	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.

    90 	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/

    91 	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

    92 	// These methods are implementations for MBackupRestoreNotificatioObserver

    93 	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.

    94 	// This P&S property is changed by calling the Secure Backup Engine API

    95 	// below.

    96 	BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase);

    97 

    98 	// allow Alarm Server observers to be notified

    99 	User::After(100000);

   100 	}

   101 

   102 

   103 static void Helper_EndRestoreL(TBool aSuccess)

   104 	{

   105 	// Use the Secure Backup Engine API to "end" a restore.  Ultimate effect

   106 	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.

   107 	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/

   108 	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

   109 	// These methods are implementations for MBackupRestoreNotificatioObserver

   110 	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.

   111 	// This P&S property is changed by calling the Secure Backup Engine API

   112 	// below.

   113 	if (aSuccess)

   114 		{

   115 		BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);

   116 		}

   117 	else

   118 		{

   119 		// starting a backup before a restore has completed.

   120 		BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase);

   121 		}

   122 

   123 	// allow Alarm Server observers to be notified

   124 	User::After(1000000);

   125 	}

   126 

   127 

   128 static CDirectFileStore* Helper_StartRestoreAndOpenL()

   129 	{

   130 	Helper_StartRestoreL();

   131 

   132 	TheAlarmTest.Test().Printf(_L("- Open and Lock Exclusive AlarmServer.Ini file\r\n"));

   133 	// actually lock the file C:\System\Data\AlarmServer.ini -

   134 	CDirectFileStore* store = NULL;

   135 	for(TUint i=0; i < 10; i++)

   136 		{

   137 		TRAPD(err, store = CDirectFileStore::OpenL(FsSession,

   138 			KAlarmServerBackupFileFullPath, EFileRead | EFileShareExclusive));

   139 		// success?

   140 		if (err == KErrNone)

   141 			break;

   142 		if (err != KErrInUse)

   143 			User::Leave(err);

   144 		// wait a little (10ms) & try again

   145 		User::After(10000);

   146 		}

   147 

   148 	return store;

   149 	}

   150 

   151 

   152 static CDirectFileStore* Helper_StartBackupAndOpenL()

   153 	{

   154 	Helper_StartBackupL();

   155 

   156 	TheAlarmTest.Test().Printf(_L("- Open and Lock Share Readers AlarmServer.Ini file\r\n"));

   157 	// actually lock the file C:\System\Data\AlarmServer.ini -

   158 	CDirectFileStore* store = NULL;

   159 	for(TUint i=0; i < 10; i++)

   160 		{

   161 		TRAPD(err, store = CDirectFileStore::OpenL(FsSession,

   162 			KAlarmServerBackupFileFullPath, EFileRead | EFileShareReadersOnly));

   163 		// success?

   164 		if (err == KErrNone)

   165 			break;

   166 		if (err != KErrInUse)

   167 			User::Leave(err);

   168 		// wait a little (10ms) & try again

   169 		User::After(10000);

   170 		}

   171 

   172 	return store;

   173 	}

   174 

   175 

   176 //

   177 

   178 //

   179 // Backup & Restore support functions

   180 

   181 /*

   182  * Makes a Backup of the Alarm Server ini file:

   183  * 1. Asks for Read Only lock for the AlarmServer.ini file

   184  * 2. Copies AlarmServer.ini to c:\AlarmServer.bak

   185  * 3. Hands back the file lock

   186  */

   187 static void	BackupAlarmServerIniFileL()

   188 	{

   189 	TheAlarmTest.Test().Printf(_L("- Backup AlarmServer Ini file\r\n"));

   190 	Helper_StartBackupL();	// make Backup

   191 

   192 	CFileMan* fm=CFileMan::NewL(FsSession);

   193 	FsSession.Delete(KAlarmServerTestBackupFile);		// no old file

   194 

   195 	// keep on trying to copy AlarmServer.ini file, until it will be released by alarm server

   196 	const TInt maxNumOfAttempts = 50;

   197 	TInt numOfAttempts = 0;

   198 	for (;numOfAttempts < maxNumOfAttempts; ++numOfAttempts)

   199 		{

   200 		if (KErrNone == fm->Copy(KAlarmServerBackupFileFullPath,KAlarmServerTestBackupFile))

   201 			break;

   202 

   203 		User::After(200000); //Wait for file to be released

   204 		}

   205 	TheAlarmTest(numOfAttempts < maxNumOfAttempts, __LINE__); //File was not locked after 50 attempts

   206 

   207 	delete fm;

   208 	Helper_EndBackupL();

   209 	}

   210 

   211 

   212 /*

   213  * Restores from a Backup of the Alarm Server ini file:

   214  * 1. Asks for full access file lock for the AlarmServer.ini file

   215  * 2. Copies c:\AlarmServer.bak to the AlarmServer.ini file

   216  * 3. Hands back the file lock

   217  */

   218 static void RestoreAlarmServerIniFileL()

   219 	{

   220 	TheAlarmTest.Test().Printf(_L("- Restore AlarmServer Ini file\r\n"));

   221 

   222 	// variables used to check Alarm Server notifications of Restore

   223 	TAlarmId alarmId;

   224 	TRequestStatus status;

   225 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

   226 

   227 	Helper_StartRestoreL();

   228 	TheAlarmTest.TestEventBuffer(EAlarmChangeEventRestoreStarted, status, alarmId);

   229 

   230 	CFileMan* fm=CFileMan::NewL(FsSession);

   231 	// didn't leave yet so:

   232 	FsSession.Delete(KAlarmServerBackupFileFullPath);		// zap current file

   233 	fm->Copy(KAlarmServerTestBackupFile,KAlarmServerBackupFileFullPath);

   234 	delete fm;

   235 

   236 	Helper_EndRestoreL(ETrue);

   237 	}

   238 

   239 

   240 /*

   241  * Pretends to start to make a Backup of the Alarm Server ini file:

   242  * 1. Asks for Read Only lock for the AlarmServer.ini file

   243  * Must delete store object and call SimulateBackupServerBackup_CompleteL()

   244  * after calling this!

   245  */

   246 static CStreamStore* SimulateBackupServerBackup_StartL()

   247 	{

   248 	TheAlarmTest.Test().Printf(_L("- Claim AlarmServer Ini file for Backup\r\n"));

   249 

   250 	// want to start a Backup and open the AlarmServer Ini file

   251 	return Helper_StartBackupAndOpenL();

   252 	}

   253 

   254 

   255 /*

   256  * Ends pretend Backup of the Alarm Server ini file:

   257  * 1. Hands back the file lock

   258  * Must be preceded by a call to SimulateBackupServerBackup_StartL

   259  * and delete of the store object.

   260  */

   261 static void SimulateBackupServerBackup_CompleteL()

   262 	{

   263 	TheAlarmTest.Test().Printf(_L("- ... Backup finished, return AlarmServer file lock\r\n"));

   264 

   265 	Helper_EndBackupL();

   266 	}

   267 

   268 /*

   269  * Pretends to Restore the Alarm Server ini file:

   270  * 1. Asks for full access file lock for the AlarmServer.ini file

   271  * 2. Pauses briefly.

   272  * 3. Hands back the file lock

   273  * Alarm Server should re-Internalize existing alarms;

   274  * Session alarms should become orphaned.

   275  */

   276 static void SimulateBackupServerRestorationL()

   277 	{

   278 	TheAlarmTest.Test().Printf(_L("- 'Restore' AlarmServer Ini file, (open and release)\r\n"));

   279 

   280 	// want to start a Restore and open AlarmServer Ini file

   281 	CDirectFileStore* store = Helper_StartRestoreAndOpenL();

   282 

   283 	// take a little time for the Restore (.5s)

   284 	User::After(500000);

   285 

   286 	// now release file lock -

   287 	TheAlarmTest.Test().Printf(_L("- Unlock AlarmServer.Ini file\r\n"));

   288 	delete store;

   289 

   290 	// restore success

   291 	Helper_EndRestoreL(ETrue);

   292 	}

   293 

   294 /*

   295  * Pretends to start to Restore the Alarm Server ini file:

   296  * 1. Asks for full access file lock for the AlarmServer.ini file

   297  * Must be followed by a call to SimulateBackupServerRestore_Complete!

   298  */

   299 static CStreamStore* SimulateBackupServerRestore_StartL()

   300 	{

   301 	CStreamStore* store = NULL;

   302 	TInt err = KErrNone;

   303 

   304 	TheAlarmTest.Test().Printf(_L("- Access AlarmServer Ini file, as if  Restoring\r\n"));

   305 

   306 	// Use this Secure Backup Engine API to "start" a restore.  Ultimate effect

   307 	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.

   308 	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/

   309 	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.

   310 	// These methods are implementations for MBackupRestoreNotificatioObserver

   311 	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.

   312 	// This P&S property is changed by calling the Secure Backup Engine API

   313 	// below.

   314 	BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase);

   315 

   316 	// actually lock the file C:\System\Data\AlarmServer.ini

   317 	const TInt maxNumOfAttempts = 50;

   318 	TInt numOfAttempts = 0;

   319 	for (;numOfAttempts < maxNumOfAttempts; ++numOfAttempts)

   320 		{

   321 		TRAP(err,store = CDirectFileStore::OpenL(FsSession, KAlarmServerBackupFileFullPath,

   322 												 EFileRead | EFileShareExclusive));

   323 		RDebug::Print(_L("CDirectFileStore::OpenL %S, err: %d"), &KAlarmServerBackupFileFullPath, err);

   324 		if (err == KErrNone)

   325 			break;

   326 

   327 		User::After(200000); //Wait for file to be released

   328 		}

   329 	TheAlarmTest(numOfAttempts < maxNumOfAttempts, __LINE__); //File was not locked after 50 attempts

   330 

   331 	return store;

   332 	}

   333 

   334 /*

   335  * Ends pretend Restore of the Alarm Server ini file:

   336  * 1. Hands back the file lock

   337  * Alarm Server should re-Initernalize existing alarms;

   338  * Session alarms should become orphaned.

   339  * Must be preceded by acall to SimulateBackupServerRestore_StartLC

   340  */

   341 static void SimulateBackupServerRestore_CompleteL()

   342 	{

   343 	TheAlarmTest.Test().Printf(_L("- Restore finished, release AlarmServer Ini file\r\n"));

   344 

   345 	Helper_EndRestoreL(ETrue);

   346 	}

   347 

   348 /*

   349  * Ends pretend Restore of the Alarm Server ini file:

   350  * 1. Hands back the file lock

   351  * Alarm Server should re-Initernalize existing alarms;

   352  * Session alarms should become orphaned.

   353  * Must be preceded by a call to SimulateBackupServerRestore_StartL

   354  * and delete of the store object.

   355  */

   356 //

   357 // Shutdown & Restart of Alarm Server only possibly in Windows Udeb builds

   358 

   359 #if defined(_DEBUG) && defined (__WINSCW__)

   360 static void closeServers()

   361 	{

   362 	TInt r=TheAlarmTest.Session().Connect();

   363 	TheAlarmTest(r==KErrNone, __LINE__);

   364 	TheAlarmTest.Test().Printf(_L("Server shut down\r\n"));

   365 	TheAlarmTest.Test().Printf(_L("now closing server...\r\n"));

   366 	TheAlarmTest.Session().__DbgShutDownServer();

   367 	TheAlarmTest.Session().Close();

   368 	}

   369 

   370 static void shutDownAndStartUpServers()

   371 	{

   372 	closeServers();

   373 	User::After(5000000);

   374 	TheAlarmTest.Test().Printf(_L("now restarting server...\r\n"));

   375 	TheAlarmTest.TestStartServers();

   376 	}

   377 #endif

   378 

   379 static TAlarmId addUtcAlarm(TInt aMinutesFromNow, TAlarmRepeatDefinition aRepeatDefinition = EAlarmRepeatDefintionRepeatOnce)

   380 	{

   381 	TBuf<200> testTitle;

   382 	testTitle.Format(_L("- Adding alarm set with UTC time to expire in %d minutes"), aMinutesFromNow);

   383 	TheAlarmTest.Test().Next(testTitle);

   384 	//

   385 	TASShdAlarm alarm;

   386 	alarm.Category()=KASCliCategoryClock;

   387 	alarm.RepeatDefinition()=aRepeatDefinition;

   388 	TTime time;

   389 	time.UniversalTime();

   390 	time += TTimeIntervalMinutes(aMinutesFromNow);

   391 	alarm.SetUtcNextDueTime(time);

   392 	//

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

   394 	const TAlarmId id = alarm.Id();

   395 	TheAlarmTest(id != KNullAlarmId, __LINE__);

   396 	// allow servers to catch up

   397 	User::After(1000000);

   398 	return id;

   399 	}

   400 

   401 static TAlarmId addAlarm(TInt aMinutesFromNow, TAlarmRepeatDefinition aRepeatDefinition = EAlarmRepeatDefintionRepeatOnce)

   402 	{

   403 	TBuf<200> testTitle;

   404 	testTitle.Format(_L("- Adding alarm set with local wall-clock time to expire in %d minutes"), aMinutesFromNow);

   405 	TheAlarmTest.Test().Next(testTitle);

   406 	//

   407 	TASShdAlarm alarm;

   408 	alarm.Category() = KASCliCategoryClock;

   409 	alarm.RepeatDefinition() = aRepeatDefinition;

   410 	alarm.NextDueTime().HomeTime();

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

   412 

   413 	//

   414 	TDateTime date=alarm.NextDueTime().DateTime();

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

   416 	const TAlarmId id = alarm.Id();

   417 	TheAlarmTest(id != KNullAlarmId, __LINE__);

   418 	TheAlarmTest.Test().Printf(_L("alarm %d due time is : hours: %d, minutes: %d, seconds: %d.\r\n"),

   419 		     id,date.Hour(), date.Minute(), date.Second());

   420 	// allow servers to catch up

   421 	User::After(1000000);

   422 	return id;

   423 	}

   424 

   425 //

   426 //

   427 //

   428 

   429 

   430 /*****************************************************************************

   431  */

   432 

   433 static void doTestAlarmQueueOrderShutdownStartupL()

   434 	{

   435 	TheAlarmTest.Test().Next(_L("* Test alarms set using local wall-clock time order stable over server shutdown/startup"));

   436 

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

   438 	// Can't shutdown Alarm Server on UREL or target builds

   439 	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));

   440 #else

   441 	TheAlarmTest.TestClearStoreL();

   442 

   443 	//add alarms

   444 	TheAlarmTest.Test().Next(_L("add 5 alarms"));

   445 	RArray<TAlarmId> alarmIds;

   446 	for	(TInt ii=2; ii<=6; ii++)

   447 		{

   448 		TAlarmId id = addAlarm(ii);

   449 		alarmIds.Append(id);

   450 		}

   451 

   452 	TheAlarmTest.Test().Next(_L("shutdown then restart Alarm Server"));

   453 	shutDownAndStartUpServers();

   454 

   455 	//get server alarms

   456 	RArray<TAlarmId> serverAlarmIds;

   457 	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);

   458 	alarmIds.Sort();

   459 	serverAlarmIds.Sort();

   460 	TInt count = alarmIds.Count();

   461 	TheAlarmTest(count == serverAlarmIds.Count(), __LINE__);

   462 	for	(TInt jj=0; jj<count; jj++)

   463 		{

   464 		TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);

   465 		}

   466 	serverAlarmIds.Close();

   467 	alarmIds.Close();

   468 #endif

   469 	}

   470 

   471 /*****************************************************************************

   472  */

   473 

   474 static void doTestAlarmQueueOrderBackupRestoreL()

   475 	{

   476 	TheAlarmTest.Test().Next(_L("* Test alarm order across Backup and Restore"));

   477 

   478 	TheAlarmTest.TestClearStoreL();

   479 

   480 	//add alarms

   481 	TheAlarmTest.Test().Next(_L("add 5 alarms"));

   482 	RArray<TAlarmId> alarmIds;

   483 	for	(TInt ii=2; ii<=6; ii++)

   484 		{

   485 		TAlarmId id = addAlarm(ii);

   486 		alarmIds.AppendL(id);

   487 		}

   488 

   489 	// brief pause before backup (.5s)

   490 	User::After(500000);

   491 

   492 	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));

   493 	TRAPD(err, BackupAlarmServerIniFileL());

   494 	TheAlarmTest(err==KErrNone, __LINE__);

   495 

   496 	// delete alarms

   497 	TheAlarmTest.Test().Next(_L("delete alarms"));

   498 	TInt jj;

   499 	for (jj=0; jj<5; jj++)

   500 		{

   501 		TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmIds[jj]) == KErrNone, __LINE__);

   502 		}

   503 

   504 	// pause before restore (5s)

   505 	User::After(5000000);

   506 	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));

   507 	TRAP(err, RestoreAlarmServerIniFileL());

   508 	TheAlarmTest(err==KErrNone, __LINE__);

   509 

   510 	TheAlarmTest.Test().Next(_L("check restored alarms"));

   511 	//get server alarms

   512 	RArray<TAlarmId> serverAlarmIds;

   513 	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);

   514 	alarmIds.Sort();

   515 	serverAlarmIds.Sort();

   516 	TInt count = alarmIds.Count();

   517 	TInt serverCount = serverAlarmIds.Count();

   518 	TheAlarmTest.Test().Printf(_L("[Added Alarms count = %i, server Count = %i]\r\n"), count, serverCount);

   519 	TheAlarmTest(count == serverCount, __LINE__);

   520 	for	(jj=0; jj<count; jj++)

   521 		{

   522 		TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);

   523 		}

   524 	serverAlarmIds.Close();

   525 	alarmIds.Close();

   526 	}

   527 

   528 /*****************************************************************************

   529  */

   530 

   531 static void doTestAlarmQueueBackupRestoreL()

   532 	{

   533 	TheAlarmTest.Test().Next(_L("* Test correct alarms in queue after backup and restore"));

   534 

   535 	TheAlarmTest.TestClearStoreL();

   536 

   537 	// add an alarm to expire in 2 minutes

   538 	TAlarmId id2 = addAlarm(2);

   539 	// add an alarm to expire in 3 minutes

   540 	TAlarmId id3 = addAlarm(3);

   541 

   542 	// brief pause before backup (.5s)

   543 	User::After(500000);

   544 

   545 	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));

   546 	TRAPD(err, BackupAlarmServerIniFileL());

   547 	TheAlarmTest(err==KErrNone, __LINE__);

   548 

   549 	// delete alarms

   550 	User::After(1000000);

   551 	TheAlarmTest.Test().Next(_L("delete alarms"));

   552 	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id2) == KErrNone, __LINE__);

   553 	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id3) == KErrNone, __LINE__);

   554 	User::After(1000000);

   555 

   556 	// add alarms

   557 	TheAlarmTest.Test().Next(_L("add alarms"));

   558 	// add alarms to expire now

   559 	TAlarmId id0 = addAlarm(0);

   560 	TAlarmId id1 = addAlarm(1);

   561 	TASShdAlarm alarm;

   562 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNone, __LINE__);

   563 

   564 	// first alarm (id0) should be notifying

   565 	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);

   566 

   567 

   568 

   569 	// pause briefly before restore (2s)

   570 	User::After(2000000);

   571 	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));

   572 	TRAP(err, RestoreAlarmServerIniFileL());

   573 	TheAlarmTest(err==KErrNone, __LINE__);

   574 

   575 	TheAlarmTest.Test().Next(_L("check correct alarms after restore"));

   576 

   577 	// alarms should now be gone

   578 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNotFound, __LINE__);

   579 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id1, alarm) == KErrNotFound, __LINE__);

   580 

   581 	// alarms should be restored

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

   583 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id3, alarm) == KErrNone, __LINE__);

   584 	}

   585 

   586 /*****************************************************************************

   587  */

   588 

   589 static void doTestAlarmSoundIntervalsBackupRestoreL()

   590 	{

   591 	TheAlarmTest.Test().Next(_L("* Test correct Sound Intervals after backup and restore"));

   592 

   593 	TheAlarmTest.TestClearStoreL();

   594 

   595 	// Fetch the Alarm Sound Intervals

   596 	CPlayIntervalArray* originalSoundArray = new(ELeave) CPlayIntervalArray(20);

   597 	CleanupStack::PushL(originalSoundArray);

   598 	TheAlarmTest.Session().GetAlarmPlayIntervalsL(*originalSoundArray);

   599 

   600 	TheAlarmTest.Test().Next(_L("set non-default sound intervals"));

   601 

   602 	// Initialise sound array with default values

   603 	CPlayIntervalArray* newSoundArray = new(ELeave) CPlayIntervalArray(20);

   604 	CleanupStack::PushL(newSoundArray);

   605 

   606 	// Populate the new array to replace the default

   607 	const TInt minuteCycle[]=KNewAlarmCycleStartOffsetMinutes;

   608 	TInt i = 0;

   609 	TInt offset = minuteCycle[i];

   610 	while (offset != KErrNotFound)

   611 		{

   612 		const TASCliSoundPlayDefinition item(offset, KDefaultSoundPlayDurationInSeconds);

   613 		newSoundArray->AppendL(item);

   614 		offset = minuteCycle[++i];

   615 		}

   616 

   617 	// Try setting the sound details

   618 	TheAlarmTest.Session().SetAlarmPlayIntervalsL(*newSoundArray);

   619 

   620 	// brief pause before backup (.5s)

   621 	User::After(500000);

   622 

   623 	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));

   624 	TRAPD(err, BackupAlarmServerIniFileL());

   625 	TheAlarmTest(err==KErrNone, __LINE__);

   626 

   627 	TheAlarmTest.Test().Next(_L("reset default sound intervals"));

   628 	TheAlarmTest.Session().SetAlarmPlayIntervalsL(*originalSoundArray);

   629 

   630 	// pause briefly before restore (2s)

   631 	User::After(2000000);

   632 	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));

   633 	TRAP(err, RestoreAlarmServerIniFileL());

   634 	TheAlarmTest(err==KErrNone, __LINE__);

   635 

   636 	TheAlarmTest.Test().Next(_L("check correct sound intervals after restore"));

   637 

   638 	// Fetch the details back again.

   639 	CPlayIntervalArray* restoreSoundArray = new(ELeave) CPlayIntervalArray(20);

   640 	CleanupStack::PushL(restoreSoundArray);

   641 	TheAlarmTest.Session().GetAlarmPlayIntervalsL(*restoreSoundArray);

   642 

   643 	// Test that there are the same number of entries

   644 	TheAlarmTest(newSoundArray->Count() == restoreSoundArray->Count(), __LINE__);

   645 

   646 	// Test entries are the same

   647 	TInt count = newSoundArray->Count();

   648 	for(TInt j=0; j<count; j++)

   649 		{

   650 		const TASCliSoundPlayDefinition& item = newSoundArray->At(j);

   651 		const TASCliSoundPlayDefinition& item2 = restoreSoundArray->At(j);

   652 		TheAlarmTest(item.Offset().Int() == item2.Offset().Int(), __LINE__);

   653 		TheAlarmTest(item.Duration().Int() == item2.Duration().Int(), __LINE__);

   654 		}

   655 

   656 	TheAlarmTest.Test().Next(_L("reset default sound intervals"));

   657 	TheAlarmTest.Session().SetAlarmPlayIntervalsL(*originalSoundArray);

   658 

   659 	CleanupStack::PopAndDestroy(3);// originalSoundArray, newSoundArray, restoreSoundArray

   660 	}

   661 

   662 /*****************************************************************************

   663  */

   664 

   665 static void doTestAlarmAddDuringBackupL()

   666 	{

   667 	TheAlarmTest.Test().Next(_L("* Test alarm changes during backup"));

   668 

   669 	TheAlarmTest.TestClearStoreL();

   670 

   671 	// Attempt to add an alarm while the backup server is backing up the alarms

   672 	CStreamStore* store = NULL;

   673 	TRAPD(err, store = SimulateBackupServerBackup_StartL());

   674 	TheAlarmTest(err==KErrNone, __LINE__);

   675 

   676 	CleanupStack::PushL(store);

   677 

   678 	TheAlarmTest.Test().Next(_L("adding alarm should work"));

   679 

   680 	TASShdAlarm alm;

   681 	TheAlarmTest(addAlarm(0, alm.RepeatDefinition()) != KNullAlarmId, __LINE__);

   682 

   683 	TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize"));

   684 	// Locale change (time) x2 (INC038240 regression)

   685 	// Exercise CASSrvAlarmStore queue an Externalize

   686 	TTime time;

   687 	time.UniversalTime();

   688 	time += TTimeIntervalSeconds(10);

   689 	User::SetUTCTime(time);

   690 	User::After(1000000);

   691 	time -= TTimeIntervalSeconds(10);

   692 	User::SetUTCTime(time);

   693 	User::After(1000000);

   694 

   695 	// release file lock -

   696 	CleanupStack::PopAndDestroy(store); // store

   697 	// backup complete

   698 	TRAP(err, SimulateBackupServerBackup_CompleteL());

   699 	TheAlarmTest(err==KErrNone, __LINE__);

   700 

   701 	// wait for AlarmServer to catch-up

   702 	User::After(1000000);

   703 

   704 	TheAlarmTest.Test().Next(_L("check we can now add alarm"));

   705 

   706 	// re-try alarm add after backup complete - should be successful

   707 	TAlarmId id = addAlarm(0);

   708 	TheAlarmTest(id != KNullAlarmId, __LINE__);

   709 

   710 	// wait for AlarmServer to catch-up

   711 	User::After(1000000);

   712 

   713 	// make Alarm Server re-Internalize

   714 	TheAlarmTest.Test().Next(_L("now simulating restore..."));

   715 	TRAP(err, SimulateBackupServerRestorationL());

   716 	TheAlarmTest(err==KErrNone, __LINE__);

   717 

   718 	// check absence of alarm

   719 	TheAlarmTest.Test().Next(_L("check alarm has gone"));

   720 	TASShdAlarm alarm;

   721 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);

   722 	}

   723 

   724 /*****************************************************************************

   725  */

   726 

   727 static void doTestAlarmAddDuringRestoreL()

   728 	{

   729 	// variables used to check Alarm Server notifications of Restore

   730 	TAlarmId alarmId;

   731 	TRequestStatus status;

   732 

   733 	TheAlarmTest.Test().Next(_L("* Test alarm changes during restore"));

   734 

   735 	TheAlarmTest.TestClearStoreL();

   736 

   737 	// Attempt to add an alarm while the backup server is restoring up the alarms

   738 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

   739 	CStreamStore* store = NULL;

   740 	TRAPD(err, store = SimulateBackupServerRestore_StartL());

   741 	CleanupStack::PushL(store);

   742 	TheAlarmTest(err==KErrNone, __LINE__);

   743 

   744 	// check Restore Start notification received

   745 	TheAlarmTest.Test().Next(_L("check for Alarm Restore Start notification"));

   746 	User::After(1000000);

   747 	TheAlarmTest(status == EAlarmChangeEventRestoreStarted, __LINE__);

   748 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

   749 

   750 	TheAlarmTest(alarmId==KNullAlarmId, __LINE__);

   751 

   752 	TheAlarmTest.Test().Next(_L("adding alarm should fail"));

   753 

   754 	TASShdAlarm alm;

   755 	alm.NextDueTime().HomeTime();

   756 	TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alm) == KErrLocked, __LINE__);

   757 

   758 	// allow servers to catch up

   759 	User::After(1000000);

   760 

   761 	TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize"));

   762 	// Locale change (time) x2 (INC038240 regression)

   763 	// Exercise CASSrvAlarmStore

   764 

   765 	TTime time;

   766 	time.UniversalTime();

   767 	time += TTimeIntervalSeconds(10);

   768 	User::SetUTCTime(time);

   769 	User::After(1000000);

   770 	time -= TTimeIntervalSeconds(10);

   771 	User::SetUTCTime(time);

   772 	User::After(1000000);

   773 

   774 	CleanupStack::PopAndDestroy(store);

   775 

   776 	// restore complete

   777 	TRAP(err, SimulateBackupServerRestore_CompleteL());

   778 	TheAlarmTest(err==KErrNone, __LINE__);

   779 

   780 	// check Restore Complete notification received

   781 	TheAlarmTest.Test().Next(_L("check for Alarm Restore Complete notification"));

   782 	TheAlarmTest.TestEventBuffer(EAlarmChangeEventRestoreCompleted, status, alarmId);

   783 	TheAlarmTest(alarmId==KNullAlarmId, __LINE__);

   784 

   785 

   786 	// wait for AlarmServer to catch-up

   787 	User::After(1000000);

   788 

   789 	TheAlarmTest.Test().Next(_L("check we can now add alarm"));

   790 

   791 	// re-try alarm add after restore complete - should be successful

   792 	TAlarmId id = addAlarm(0);

   793 	TheAlarmTest(id != KNullAlarmId, __LINE__);

   794 

   795 	// wait for Alarm Server to externalize

   796 	User::After(3000000);

   797 	}

   798 

   799 /*****************************************************************************

   800  */

   801 

   802 

   803 

   804 

   805 /*****************************************************************************

   806  */

   807 

   808 static void doTestNotifyingAlarmShutdownStartupL()

   809 	{

   810 	TheAlarmTest.Test().Next(_L("* Test Notifying alarm across shutdown / startup"));

   811 

   812 	TheAlarmTest.TestClearStoreL();

   813 

   814 	TheAlarmTest.Test().Next(_L("add an alarm"));

   815 	// add an alarm to expire in 15 minutes

   816 	TAlarmId id = addAlarm(15);

   817 

   818 	// get alarm expiry time

   819 	TASShdAlarm alarm;

   820 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

   821 	TTime time = alarm.NextDueTime();

   822 

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

   824 	// Can't shutdown Alarm Server on UREL or target builds

   825 	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));

   826 

   827 	TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n"));

   828 	// target Alternative: wait until after alarm due time

   829 	User::SetHomeTime(time - TTimeIntervalSeconds(3));

   830 	User::After(KTenSeconds);

   831 #else

   832 	// UDEB:

   833 	// shut down the server

   834 	closeServers();

   835 

   836 	// re-start server after alarm expires

   837 	User::SetHomeTime(time - TTimeIntervalSeconds(3));

   838 	User::After(KTenSeconds);

   839 	TheAlarmTest.Test().Next(_L("now restarting server...\r\n"));

   840 	TheAlarmTest.TestStartServers();

   841 	User::After(1000000);

   842 #endif

   843 

   844 	// Internalise on startup has a 59s window for recent alarms

   845 	TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying"));

   846 	//check status of alarm

   847 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

   848 	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);

   849 

   850 	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id) == KErrNone, __LINE__);

   851 	}

   852 

   853 /*****************************************************************************

   854  */

   855 

   856 static void doTestNotifyingAlarmBackupRestoreL()

   857 	{

   858 	TheAlarmTest.Test().Next(_L("* Test Notifying alarm removed by backup / restore"));

   859 

   860 	TheAlarmTest.TestClearStoreL();

   861 

   862 	TheAlarmTest.Test().Next(_L("add an alarm"));

   863 	// add an alarm to expire in 15 minutes

   864 	TAlarmId id = addAlarm(15);

   865 

   866 	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));

   867 	TRAPD(err, BackupAlarmServerIniFileL());

   868 	TheAlarmTest(err==KErrNone, __LINE__);

   869 

   870 	// get alarm expiry time

   871 	TASShdAlarm alarm;

   872 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

   873 	TTime time = alarm.NextDueTime();

   874 

   875 	TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n"));

   876 

   877 	// wait until after alarm due time

   878 	User::SetHomeTime(time - TTimeIntervalSeconds(3));

   879 	User::After(KTenSeconds);

   880 

   881 	// Internalise on startup has a 59s window for recent alarms

   882 	TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying"));

   883 	//check status of alarm

   884 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

   885 

   886 	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);

   887 

   888 

   889 	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));

   890 	TRAP(err, RestoreAlarmServerIniFileL());

   891 	TheAlarmTest(err==KErrNone, __LINE__);

   892 

   893 	// allow Alarm server to notice file lock has been released

   894 	User::After(1000000);

   895 

   896 	// Internalise after Restore has a 0s window for recent alarms

   897 	// check absence of alarm

   898 	TheAlarmTest.Test().Next(_L("check alarm has gone\r\n"));

   899 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);

   900 	}

   901 

   902 /*****************************************************************************

   903  */

   904 

   905 static void doTestSessionAlarmShutdownRestartL()

   906 	{

   907 	TheAlarmTest.Test().Next(_L("* Test that Session alarm is removed by shutdown"));

   908 

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

   910 	// Can't shutdown Alarm Server on UREL or target builds

   911 	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));

   912 #else

   913 	TheAlarmTest.TestClearStoreL();

   914 

   915 	// Set the session alarm

   916 	TheAlarmTest.Test().Next(_L("set session alarm in 2 minutes"));

   917 	TASShdAlarm alarm;

   918 	alarm.Category() = KASCliCategoryClock;

   919 	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;

   920 	alarm.NextDueTime().HomeTime();

   921 	alarm.NextDueTime() += TTimeIntervalMinutes(2);

   922 	// session specific alarm (has a TRequestStatus to complete)

   923 	alarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);

   924 	TRequestStatus status;

   925 	TheAlarmTest.Session().AlarmAddWithNotification(status, alarm);

   926 	const TAlarmId id = alarm.Id();

   927 	TheAlarmTest(id != KNullAlarmId, __LINE__);

   928 

   929 	// status should be pending

   930 	TheAlarmTest.Test().Next(_L("checking request is pending"));

   931 	TheAlarmTest(status == KRequestPending, __LINE__);

   932 

   933 	TheAlarmTest.Test().Next(_L("Shutdown Alarm Server"));

   934 	closeServers();

   935 

   936 	User::After(10000000);

   937 

   938 	// check absence of alarm

   939 	TheAlarmTest.Test().Next(_L("check alarm notification has been aborted"));

   940 

   941 	TheAlarmTest(status != KRequestPending, __LINE__);

   942 

   943 	// Get the abort

   944 	// (Probably KErrDied though KErrServerTerminated should be okay too)

   945 	User::WaitForRequest(status);

   946 	TInt stat = status.Int();

   947 	TheAlarmTest((stat == KErrDied) || (stat == KErrServerTerminated), __LINE__);

   948 

   949 	// now restart Alarm Server

   950 	TheAlarmTest.Test().Next(_L("restart Alarm Server"));

   951 	TheAlarmTest.TestStartServers();

   952 

   953 	// check presence of alarm

   954 	TheAlarmTest.Test().Next(_L("check shutdown deleted alarm"));

   955 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);

   956 #endif

   957 	}

   958 

   959 /*****************************************************************************

   960  */

   961 

   962 static void doTestSessionAlarmBackupRestoreL()

   963 	{

   964 	TheAlarmTest.Test().Next(_L("* Test that Session alarm is orphaned by restore"));

   965 

   966 	TheAlarmTest.TestClearStoreL();

   967 

   968 	// Set the session alarm

   969 	TheAlarmTest.Test().Next(_L("set session alarm in 20 minutes"));

   970 	TASShdAlarm alarmWrite;

   971 	alarmWrite.Category() = KASCliCategoryClock;

   972 	alarmWrite.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;

   973 	alarmWrite.NextDueTime().HomeTime();

   974 	alarmWrite.NextDueTime() += TTimeIntervalMinutes(20);

   975 	// session specific alarm (has a TRequestStatus to complete)

   976 	alarmWrite.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);

   977 	TRequestStatus status;

   978 	TheAlarmTest.Session().AlarmAddWithNotification(status, alarmWrite);

   979 	// check that alarm was set okay

   980 	const TAlarmId id = alarmWrite.Id();

   981 	TheAlarmTest(id != KNullAlarmId, __LINE__);

   982 

   983 	// status should be pending

   984 	TheAlarmTest.Test().Next(_L("checking request is pending"));

   985 	TheAlarmTest(status == KRequestPending, __LINE__);

   986 

   987 	// remember the alarm time

   988 	TTime alarmTime = alarmWrite.NextDueTime();

   989 

   990 	// make the Alarm server re-internlize ....

   991 	TheAlarmTest.Test().Next(_L("now simulating restore..."));

   992 	TRAPD(err, SimulateBackupServerRestorationL());

   993 	TheAlarmTest(err==KErrNone, __LINE__);

   994 

   995 

   996 	// allow Alarm server to Internalize...

   997 	User::After(1000000);	// 1s

   998 

   999 

  1000 	// check old alarm queue has been cleared

  1001 	TheAlarmTest.Test().Next(_L("check alarm notification has been aborted"));

  1002 	TheAlarmTest(status != KRequestPending, __LINE__);

  1003 

  1004 	// Get the abort result

  1005 	User::WaitForRequest(status);

  1006 	TheAlarmTest(status.Int() == KErrCancel, __LINE__);

  1007 

  1008 	// check presence of alarm

  1009 	TASShdAlarm alarmRead;

  1010 	TheAlarmTest.Test().Next(_L("check alarm is no longer a session alarm"));

  1011 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__);

  1012 

  1013 	TheAlarmTest(!alarmRead.HasOwningSession(), __LINE__);

  1014 	TheAlarmTest(alarmRead.HasBecomeOrphaned(), __LINE__);

  1015 

  1016 	// advance clock, wait for alarm

  1017 	User::SetHomeTime(alarmWrite.NextDueTime() - TTimeIntervalSeconds(3));

  1018 	TheAlarmTest.Test().Next(_L("waiting for alarm to notify"));

  1019 	// wait until after alarm due time

  1020 	User::After(KTenSeconds);

  1021 

  1022 	// alarm should be notifying

  1023 	// if Alarm Server server tries to access the TRequestStatus

  1024 	// there will be an Access Violation

  1025 	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__);

  1026 

  1027 	//TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);

  1028 

  1029 	const TAlarmState alarmState = alarmRead.State();

  1030 	TheAlarmTest(alarmState == EAlarmStateNotifying, __LINE__);

  1031 	}

  1032 

  1033 

  1034 /*****************************************************************************

  1035  * Test adapted from TAlarmData, checks alarm data across Backup & Restore.

  1036  * (Original tested across Alarm Server shutdown & re-start.)

  1037  */

  1038 

  1039 static void doTestRestoreValidAlarmDataL()

  1040 	{

  1041 	TheAlarmTest.Test().Next(_L("Data API test"));

  1042 	TheAlarmTest.TestClearStoreL();

  1043 	TInt r;

  1044 	TAlarmId alarmId;

  1045 	TASShdAlarm alarm;

  1046 	TRequestStatus status;

  1047 	//

  1048 	alarm.Message() = _L("Alarm with data");

  1049 	alarm.NextDueTime().HomeTime();

  1050 	alarm.NextDueTime() += TTimeIntervalMinutes(2);

  1051 	//

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

  1053 	TheAlarmTest(r==KErrNone, __LINE__);

  1054 	//

  1055 	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());

  1056 	TheAlarmTest(r == KErrNotFound, __LINE__);

  1057 	//

  1058 	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());

  1059 	TheAlarmTest(r == KErrNotFound, __LINE__);

  1060 	//

  1061 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

  1062 	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);

  1063 	TheAlarmTest(r == KErrNone, __LINE__);

  1064 	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);

  1065 	TheAlarmTest(alarmId = alarm.Id(), __LINE__);

  1066 	User::WaitForRequest(status);

  1067 	//

  1068 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

  1069 	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);

  1070 	TheAlarmTest(r == KErrInUse, __LINE__);

  1071 	TheAlarmTest(status == KRequestPending, __LINE__);

  1072 	//

  1073 	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());

  1074 	TheAlarmTest(r == KSomeAlarmData().Size());

  1075 	//

  1076 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

  1077 	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());

  1078 	TheAlarmTest(r == KErrNone, __LINE__);

  1079 	TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId);

  1080 	//

  1081 	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());

  1082 	TheAlarmTest(r == KErrNotFound, __LINE__);

  1083 	//

  1084 	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());

  1085 	TheAlarmTest(r == KErrNotFound, __LINE__);

  1086 	//

  1087 	alarm.NextDueTime().HomeTime();

  1088 	alarm.NextDueTime() += TTimeIntervalMinutes(2);

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

  1090 	TheAlarmTest(r==KErrNone, __LINE__);

  1091 	//

  1092 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

  1093 	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);

  1094 	TheAlarmTest(r == KErrNone, __LINE__);

  1095 	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);

  1096 	TheAlarmTest(alarmId = alarm.Id(), __LINE__);

  1097 	User::WaitForRequest(status);

  1098 	//

  1099 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

  1100 	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());

  1101 	TheAlarmTest(r == KErrNone, __LINE__);

  1102 	TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId);

  1103 	//

  1104 	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());

  1105 	TheAlarmTest(r == KErrNotFound, __LINE__);

  1106 	//

  1107 	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());

  1108 	TheAlarmTest(r == KErrNotFound, __LINE__);

  1109 	//

  1110 	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

  1111 	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);

  1112 	TheAlarmTest(r == KErrNone, __LINE__);

  1113 	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);

  1114 	TheAlarmTest(alarmId = alarm.Id(), __LINE__);

  1115 	User::WaitForRequest(status);

  1116 	//

  1117 	HBufC8* buf = HBufC8::NewLC(KSomeAlarmData().Size());

  1118 	TPtr8 pBuf(buf->Des());

  1119 	r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pBuf);

  1120 	TheAlarmTest(r == KErrNone, __LINE__);

  1121 	TheAlarmTest(*buf == KSomeAlarmData, __LINE__);

  1122 	//

  1123 	TheAlarmTest.Test().Next(_L("Waiting for alarm to expire"));

  1124 	// advance clock to 3s before alarm due

  1125 	User::SetHomeTime(alarm.NextDueTime() - TTimeIntervalSeconds(3));

  1126 	TheAlarmTest.WaitForEvent(EAlarmChangeEventTimerExpired, status, alarmId);

  1127 	TheAlarmTest(alarmId == alarm.Id(), __LINE__);

  1128 	//

  1129 	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);

  1130 	TheAlarmTest(r == KErrInUse, __LINE__);

  1131 	//

  1132 	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());

  1133 	TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__);

  1134 	//

  1135 	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());