// 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"
#include "ASSrvDefs.h"

#include <f32file.h>
#include <s32file.h>
#include <asclisoundplay.h>

#include <connect/sbeclient.h>
#include <tz.h>
// Type definitions
typedef CArrayFixFlat<TASCliSoundPlayDefinition> CPlayIntervalArray;


// Literal constants
_LIT(KAlarmServerTestBackupFile, "C:\\AlarmServer.bak");
_LIT8(KSomeAlarmData, "This is some 8-bit data");

//Temp fix for wk37, main updates for wk40
_LIT(KAlarmServerBackupFileFullPath, "C:\\private\\101F5027\\AlarmServer.ini");

static const TTimeIntervalMicroSeconds32 KTenSeconds = 10000000;

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

static RFs FsSession;
static conn::CSBEClient* BackupClient;
static TDriveList DriveList;


//
/* Try to give a fairly thorough test of the Alarm Server
 * during Startup Internalize, backup and restore
 */


//
// building block test Helper functions
//

static void Helper_StartBackupL()
	{
	// Use the Secure Backup Engine API to "start" a backup.  Ultimate effect
	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.
	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/
	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
	// These methods are implementations for MBackupRestoreNotificatioObserver
	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.
	// This P&S property is changed by calling the Secure Backup Engine API
	// below.
	BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase);
	}


static void Helper_EndBackupL()
	{
	// Use the Secure Backup Engine API to "end" a backup.  Ultimate effect
	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.
	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/
	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
	// These methods are implementations for MBackupRestoreNotificatioObserver
	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.
	// This P&S property is changed by calling the Secure Backup Engine API
	// below.
	BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);

	// allow Alarm Server observers to be notified
	User::After(1000);
	}


static void Helper_StartRestoreL()
	{
	// Use the Secure Backup Engine API to "start" a restore.  Ultimate effect
	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.
	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/
	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
	// These methods are implementations for MBackupRestoreNotificatioObserver
	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.
	// This P&S property is changed by calling the Secure Backup Engine API
	// below.
	BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase);

	// allow Alarm Server observers to be notified
	User::After(100000);
	}


static void Helper_EndRestoreL(TBool aSuccess)
	{
	// Use the Secure Backup Engine API to "end" a restore.  Ultimate effect
	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.
	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/
	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
	// These methods are implementations for MBackupRestoreNotificatioObserver
	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.
	// This P&S property is changed by calling the Secure Backup Engine API
	// below.
	if (aSuccess)
		{
		BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup);
		}
	else
		{
		// starting a backup before a restore has completed.
		BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase);
		}

	// allow Alarm Server observers to be notified
	User::After(1000000);
	}


static CDirectFileStore* Helper_StartRestoreAndOpenL()
	{
	Helper_StartRestoreL();

	TheAlarmTest.Test().Printf(_L("- Open and Lock Exclusive AlarmServer.Ini file\r\n"));
	// actually lock the file C:\System\Data\AlarmServer.ini -
	CDirectFileStore* store = NULL;
	for(TUint i=0; i < 10; i++)
		{
		TRAPD(err, store = CDirectFileStore::OpenL(FsSession,
			KAlarmServerBackupFileFullPath, EFileRead | EFileShareExclusive));
		// success?
		if (err == KErrNone)
			break;
		if (err != KErrInUse)
			User::Leave(err);
		// wait a little (10ms) & try again
		User::After(10000);
		}

	return store;
	}


static CDirectFileStore* Helper_StartBackupAndOpenL()
	{
	Helper_StartBackupL();

	TheAlarmTest.Test().Printf(_L("- Open and Lock Share Readers AlarmServer.Ini file\r\n"));
	// actually lock the file C:\System\Data\AlarmServer.ini -
	CDirectFileStore* store = NULL;
	for(TUint i=0; i < 10; i++)
		{
		TRAPD(err, store = CDirectFileStore::OpenL(FsSession,
			KAlarmServerBackupFileFullPath, EFileRead | EFileShareReadersOnly));
		// success?
		if (err == KErrNone)
			break;
		if (err != KErrInUse)
			User::Leave(err);
		// wait a little (10ms) & try again
		User::After(10000);
		}

	return store;
	}


//

//
// Backup & Restore support functions

/*
 * Makes a Backup of the Alarm Server ini file:
 * 1. Asks for Read Only lock for the AlarmServer.ini file
 * 2. Copies AlarmServer.ini to c:\AlarmServer.bak
 * 3. Hands back the file lock
 */
static void	BackupAlarmServerIniFileL()
	{
	TheAlarmTest.Test().Printf(_L("- Backup AlarmServer Ini file\r\n"));
	Helper_StartBackupL();	// make Backup

	CFileMan* fm=CFileMan::NewL(FsSession);
	FsSession.Delete(KAlarmServerTestBackupFile);		// no old file

	// keep on trying to copy AlarmServer.ini file, until it will be released by alarm server
	const TInt maxNumOfAttempts = 50;
	TInt numOfAttempts = 0;
	for (;numOfAttempts < maxNumOfAttempts; ++numOfAttempts)
		{
		if (KErrNone == fm->Copy(KAlarmServerBackupFileFullPath,KAlarmServerTestBackupFile))
			break;

		User::After(200000); //Wait for file to be released
		}
	TheAlarmTest(numOfAttempts < maxNumOfAttempts, __LINE__); //File was not locked after 50 attempts

	delete fm;
	Helper_EndBackupL();
	}


/*
 * Restores from a Backup of the Alarm Server ini file:
 * 1. Asks for full access file lock for the AlarmServer.ini file
 * 2. Copies c:\AlarmServer.bak to the AlarmServer.ini file
 * 3. Hands back the file lock
 */
static void RestoreAlarmServerIniFileL()
	{
	TheAlarmTest.Test().Printf(_L("- Restore AlarmServer Ini file\r\n"));

	// variables used to check Alarm Server notifications of Restore
	TAlarmId alarmId;
	TRequestStatus status;
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

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

	CFileMan* fm=CFileMan::NewL(FsSession);
	// didn't leave yet so:
	FsSession.Delete(KAlarmServerBackupFileFullPath);		// zap current file
	fm->Copy(KAlarmServerTestBackupFile,KAlarmServerBackupFileFullPath);
	delete fm;

	Helper_EndRestoreL(ETrue);
	}


/*
 * Pretends to start to make a Backup of the Alarm Server ini file:
 * 1. Asks for Read Only lock for the AlarmServer.ini file
 * Must delete store object and call SimulateBackupServerBackup_CompleteL()
 * after calling this!
 */
static CStreamStore* SimulateBackupServerBackup_StartL()
	{
	TheAlarmTest.Test().Printf(_L("- Claim AlarmServer Ini file for Backup\r\n"));

	// want to start a Backup and open the AlarmServer Ini file
	return Helper_StartBackupAndOpenL();
	}


/*
 * Ends pretend Backup of the Alarm Server ini file:
 * 1. Hands back the file lock
 * Must be preceded by a call to SimulateBackupServerBackup_StartL
 * and delete of the store object.
 */
static void SimulateBackupServerBackup_CompleteL()
	{
	TheAlarmTest.Test().Printf(_L("- ... Backup finished, return AlarmServer file lock\r\n"));

	Helper_EndBackupL();
	}

/*
 * Pretends to Restore the Alarm Server ini file:
 * 1. Asks for full access file lock for the AlarmServer.ini file
 * 2. Pauses briefly.
 * 3. Hands back the file lock
 * Alarm Server should re-Internalize existing alarms;
 * Session alarms should become orphaned.
 */
static void SimulateBackupServerRestorationL()
	{
	TheAlarmTest.Test().Printf(_L("- 'Restore' AlarmServer Ini file, (open and release)\r\n"));

	// want to start a Restore and open AlarmServer Ini file
	CDirectFileStore* store = Helper_StartRestoreAndOpenL();

	// take a little time for the Restore (.5s)
	User::After(500000);

	// now release file lock -
	TheAlarmTest.Test().Printf(_L("- Unlock AlarmServer.Ini file\r\n"));
	delete store;

	// restore success
	Helper_EndRestoreL(ETrue);
	}

/*
 * Pretends to start to Restore the Alarm Server ini file:
 * 1. Asks for full access file lock for the AlarmServer.ini file
 * Must be followed by a call to SimulateBackupServerRestore_Complete!
 */
static CStreamStore* SimulateBackupServerRestore_StartL()
	{
	CStreamStore* store = NULL;
	TInt err = KErrNone;

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

	// Use this Secure Backup Engine API to "start" a restore.  Ultimate effect
	// is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called.
	// This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/
	// BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods.
	// These methods are implementations for MBackupRestoreNotificatioObserver
	// which monitors changes in the P&S property conn::KUidBackupRestoreKey.
	// This P&S property is changed by calling the Secure Backup Engine API
	// below.
	BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase);

	// actually lock the file C:\System\Data\AlarmServer.ini
	const TInt maxNumOfAttempts = 50;
	TInt numOfAttempts = 0;
	for (;numOfAttempts < maxNumOfAttempts; ++numOfAttempts)
		{
		TRAP(err,store = CDirectFileStore::OpenL(FsSession, KAlarmServerBackupFileFullPath,
												 EFileRead | EFileShareExclusive));
		RDebug::Print(_L("CDirectFileStore::OpenL %S, err: %d"), &KAlarmServerBackupFileFullPath, err);
		if (err == KErrNone)
			break;

		User::After(200000); //Wait for file to be released
		}
	TheAlarmTest(numOfAttempts < maxNumOfAttempts, __LINE__); //File was not locked after 50 attempts

	return store;
	}

/*
 * Ends pretend Restore of the Alarm Server ini file:
 * 1. Hands back the file lock
 * Alarm Server should re-Initernalize existing alarms;
 * Session alarms should become orphaned.
 * Must be preceded by acall to SimulateBackupServerRestore_StartLC
 */
static void SimulateBackupServerRestore_CompleteL()
	{
	TheAlarmTest.Test().Printf(_L("- Restore finished, release AlarmServer Ini file\r\n"));

	Helper_EndRestoreL(ETrue);
	}

/*
 * Ends pretend Restore of the Alarm Server ini file:
 * 1. Hands back the file lock
 * Alarm Server should re-Initernalize existing alarms;
 * Session alarms should become orphaned.
 * Must be preceded by a call to SimulateBackupServerRestore_StartL
 * and delete of the store object.
 */
//
// Shutdown & Restart of Alarm Server only possibly in Windows Udeb builds

#if defined(_DEBUG) && defined (__WINSCW__)
static void closeServers()
	{
	TInt r=TheAlarmTest.Session().Connect();
	TheAlarmTest(r==KErrNone, __LINE__);
	TheAlarmTest.Test().Printf(_L("Server shut down\r\n"));
	TheAlarmTest.Test().Printf(_L("now closing server...\r\n"));
	TheAlarmTest.Session().__DbgShutDownServer();
	TheAlarmTest.Session().Close();
	}

static void shutDownAndStartUpServers()
	{
	closeServers();
	User::After(5000000);
	TheAlarmTest.Test().Printf(_L("now restarting server...\r\n"));
	TheAlarmTest.TestStartServers();
	}
#endif

static TAlarmId addUtcAlarm(TInt aMinutesFromNow, TAlarmRepeatDefinition aRepeatDefinition = EAlarmRepeatDefintionRepeatOnce)
	{
	TBuf<200> testTitle;
	testTitle.Format(_L("- Adding alarm set with UTC time to expire in %d minutes"), aMinutesFromNow);
	TheAlarmTest.Test().Next(testTitle);
	//
	TASShdAlarm alarm;
	alarm.Category()=KASCliCategoryClock;
	alarm.RepeatDefinition()=aRepeatDefinition;
	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__);
	// allow servers to catch up
	User::After(1000000);
	return id;
	}

static TAlarmId addAlarm(TInt aMinutesFromNow, TAlarmRepeatDefinition aRepeatDefinition = EAlarmRepeatDefintionRepeatOnce)
	{
	TBuf<200> testTitle;
	testTitle.Format(_L("- Adding alarm set with local wall-clock time to expire in %d minutes"), aMinutesFromNow);
	TheAlarmTest.Test().Next(testTitle);
	//
	TASShdAlarm alarm;
	alarm.Category() = KASCliCategoryClock;
	alarm.RepeatDefinition() = aRepeatDefinition;
	alarm.NextDueTime().HomeTime();
	alarm.NextDueTime() += TTimeIntervalMinutes(aMinutesFromNow);

	//
	TDateTime date=alarm.NextDueTime().DateTime();
	TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alarm) == KErrNone, __LINE__);
	const TAlarmId id = alarm.Id();
	TheAlarmTest(id != KNullAlarmId, __LINE__);
	TheAlarmTest.Test().Printf(_L("alarm %d due time is : hours: %d, minutes: %d, seconds: %d.\r\n"),
		     id,date.Hour(), date.Minute(), date.Second());
	// allow servers to catch up
	User::After(1000000);
	return id;
	}

//
//
//


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

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

#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));
#else
	TheAlarmTest.TestClearStoreL();

	//add alarms
	TheAlarmTest.Test().Next(_L("add 5 alarms"));
	RArray<TAlarmId> alarmIds;
	for	(TInt ii=2; ii<=6; ii++)
		{
		TAlarmId id = addAlarm(ii);
		alarmIds.Append(id);
		}

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

	//get server alarms
	RArray<TAlarmId> serverAlarmIds;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);
	alarmIds.Sort();
	serverAlarmIds.Sort();
	TInt count = alarmIds.Count();
	TheAlarmTest(count == serverAlarmIds.Count(), __LINE__);
	for	(TInt jj=0; jj<count; jj++)
		{
		TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);
		}
	serverAlarmIds.Close();
	alarmIds.Close();
#endif
	}

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

static void doTestAlarmQueueOrderBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test alarm order across Backup and Restore"));

	TheAlarmTest.TestClearStoreL();

	//add alarms
	TheAlarmTest.Test().Next(_L("add 5 alarms"));
	RArray<TAlarmId> alarmIds;
	for	(TInt ii=2; ii<=6; ii++)
		{
		TAlarmId id = addAlarm(ii);
		alarmIds.AppendL(id);
		}

	// brief pause before backup (.5s)
	User::After(500000);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	TRAPD(err, BackupAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// delete alarms
	TheAlarmTest.Test().Next(_L("delete alarms"));
	TInt jj;
	for (jj=0; jj<5; jj++)
		{
		TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmIds[jj]) == KErrNone, __LINE__);
		}

	// pause before restore (5s)
	User::After(5000000);
	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));
	TRAP(err, RestoreAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	TheAlarmTest.Test().Next(_L("check restored alarms"));
	//get server alarms
	RArray<TAlarmId> serverAlarmIds;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);
	alarmIds.Sort();
	serverAlarmIds.Sort();
	TInt count = alarmIds.Count();
	TInt serverCount = serverAlarmIds.Count();
	TheAlarmTest.Test().Printf(_L("[Added Alarms count = %i, server Count = %i]\r\n"), count, serverCount);
	TheAlarmTest(count == serverCount, __LINE__);
	for	(jj=0; jj<count; jj++)
		{
		TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);
		}
	serverAlarmIds.Close();
	alarmIds.Close();
	}

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

static void doTestAlarmQueueBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test correct alarms in queue after backup and restore"));

	TheAlarmTest.TestClearStoreL();

	// add an alarm to expire in 2 minutes
	TAlarmId id2 = addAlarm(2);
	// add an alarm to expire in 3 minutes
	TAlarmId id3 = addAlarm(3);

	// brief pause before backup (.5s)
	User::After(500000);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	TRAPD(err, BackupAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// delete alarms
	User::After(1000000);
	TheAlarmTest.Test().Next(_L("delete alarms"));
	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id2) == KErrNone, __LINE__);
	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id3) == KErrNone, __LINE__);
	User::After(1000000);

	// add alarms
	TheAlarmTest.Test().Next(_L("add alarms"));
	// add alarms to expire now
	TAlarmId id0 = addAlarm(0);
	TAlarmId id1 = addAlarm(1);
	TASShdAlarm alarm;
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNone, __LINE__);

	// first alarm (id0) should be notifying
	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);



	// pause briefly before restore (2s)
	User::After(2000000);
	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));
	TRAP(err, RestoreAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

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

	// alarms should now be gone
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNotFound, __LINE__);
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id1, alarm) == KErrNotFound, __LINE__);

	// alarms should be restored
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id2, alarm) == KErrNone, __LINE__);
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id3, alarm) == KErrNone, __LINE__);
	}

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

static void doTestAlarmSoundIntervalsBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test correct Sound Intervals after backup and restore"));

	TheAlarmTest.TestClearStoreL();

	// Fetch the Alarm Sound Intervals
	CPlayIntervalArray* originalSoundArray = new(ELeave) CPlayIntervalArray(20);
	CleanupStack::PushL(originalSoundArray);
	TheAlarmTest.Session().GetAlarmPlayIntervalsL(*originalSoundArray);

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

	// Initialise sound array with default values
	CPlayIntervalArray* newSoundArray = new(ELeave) CPlayIntervalArray(20);
	CleanupStack::PushL(newSoundArray);

	// Populate the new array to replace the default
	const TInt minuteCycle[]=KNewAlarmCycleStartOffsetMinutes;
	TInt i = 0;
	TInt offset = minuteCycle[i];
	while (offset != KErrNotFound)
		{
		const TASCliSoundPlayDefinition item(offset, KDefaultSoundPlayDurationInSeconds);
		newSoundArray->AppendL(item);
		offset = minuteCycle[++i];
		}

	// Try setting the sound details
	TheAlarmTest.Session().SetAlarmPlayIntervalsL(*newSoundArray);

	// brief pause before backup (.5s)
	User::After(500000);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	TRAPD(err, BackupAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	TheAlarmTest.Test().Next(_L("reset default sound intervals"));
	TheAlarmTest.Session().SetAlarmPlayIntervalsL(*originalSoundArray);

	// pause briefly before restore (2s)
	User::After(2000000);
	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));
	TRAP(err, RestoreAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

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

	// Fetch the details back again.
	CPlayIntervalArray* restoreSoundArray = new(ELeave) CPlayIntervalArray(20);
	CleanupStack::PushL(restoreSoundArray);
	TheAlarmTest.Session().GetAlarmPlayIntervalsL(*restoreSoundArray);

	// Test that there are the same number of entries
	TheAlarmTest(newSoundArray->Count() == restoreSoundArray->Count(), __LINE__);

	// Test entries are the same
	TInt count = newSoundArray->Count();
	for(TInt j=0; j<count; j++)
		{
		const TASCliSoundPlayDefinition& item = newSoundArray->At(j);
		const TASCliSoundPlayDefinition& item2 = restoreSoundArray->At(j);
		TheAlarmTest(item.Offset().Int() == item2.Offset().Int(), __LINE__);
		TheAlarmTest(item.Duration().Int() == item2.Duration().Int(), __LINE__);
		}

	TheAlarmTest.Test().Next(_L("reset default sound intervals"));
	TheAlarmTest.Session().SetAlarmPlayIntervalsL(*originalSoundArray);

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

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

static void doTestAlarmAddDuringBackupL()
	{
	TheAlarmTest.Test().Next(_L("* Test alarm changes during backup"));

	TheAlarmTest.TestClearStoreL();

	// Attempt to add an alarm while the backup server is backing up the alarms
	CStreamStore* store = NULL;
	TRAPD(err, store = SimulateBackupServerBackup_StartL());
	TheAlarmTest(err==KErrNone, __LINE__);

	CleanupStack::PushL(store);

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

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

	TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize"));
	// Locale change (time) x2 (INC038240 regression)
	// Exercise CASSrvAlarmStore queue an Externalize
	TTime time;
	time.UniversalTime();
	time += TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);
	time -= TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);

	// release file lock -
	CleanupStack::PopAndDestroy(store); // store
	// backup complete
	TRAP(err, SimulateBackupServerBackup_CompleteL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// wait for AlarmServer to catch-up
	User::After(1000000);

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

	// re-try alarm add after backup complete - should be successful
	TAlarmId id = addAlarm(0);
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// wait for AlarmServer to catch-up
	User::After(1000000);

	// make Alarm Server re-Internalize
	TheAlarmTest.Test().Next(_L("now simulating restore..."));
	TRAP(err, SimulateBackupServerRestorationL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// check absence of alarm
	TheAlarmTest.Test().Next(_L("check alarm has gone"));
	TASShdAlarm alarm;
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);
	}

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

static void doTestAlarmAddDuringRestoreL()
	{
	// variables used to check Alarm Server notifications of Restore
	TAlarmId alarmId;
	TRequestStatus status;

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

	TheAlarmTest.TestClearStoreL();

	// Attempt to add an alarm while the backup server is restoring up the alarms
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	CStreamStore* store = NULL;
	TRAPD(err, store = SimulateBackupServerRestore_StartL());
	CleanupStack::PushL(store);
	TheAlarmTest(err==KErrNone, __LINE__);

	// check Restore Start notification received
	TheAlarmTest.Test().Next(_L("check for Alarm Restore Start notification"));
	User::After(1000000);
	TheAlarmTest(status == EAlarmChangeEventRestoreStarted, __LINE__);
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

	TheAlarmTest(alarmId==KNullAlarmId, __LINE__);

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

	TASShdAlarm alm;
	alm.NextDueTime().HomeTime();
	TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alm) == KErrLocked, __LINE__);

	// allow servers to catch up
	User::After(1000000);

	TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize"));
	// Locale change (time) x2 (INC038240 regression)
	// Exercise CASSrvAlarmStore

	TTime time;
	time.UniversalTime();
	time += TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);
	time -= TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);

	CleanupStack::PopAndDestroy(store);

	// restore complete
	TRAP(err, SimulateBackupServerRestore_CompleteL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// check Restore Complete notification received
	TheAlarmTest.Test().Next(_L("check for Alarm Restore Complete notification"));
	TheAlarmTest.TestEventBuffer(EAlarmChangeEventRestoreCompleted, status, alarmId);
	TheAlarmTest(alarmId==KNullAlarmId, __LINE__);


	// wait for AlarmServer to catch-up
	User::After(1000000);

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

	// re-try alarm add after restore complete - should be successful
	TAlarmId id = addAlarm(0);
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// wait for Alarm Server to externalize
	User::After(3000000);
	}

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




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

static void doTestNotifyingAlarmShutdownStartupL()
	{
	TheAlarmTest.Test().Next(_L("* Test Notifying alarm across shutdown / startup"));

	TheAlarmTest.TestClearStoreL();

	TheAlarmTest.Test().Next(_L("add an alarm"));
	// add an alarm to expire in 15 minutes
	TAlarmId id = addAlarm(15);

	// get alarm expiry time
	TASShdAlarm alarm;
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);
	TTime time = alarm.NextDueTime();

#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));

	TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n"));
	// target Alternative: wait until after alarm due time
	User::SetHomeTime(time - TTimeIntervalSeconds(3));
	User::After(KTenSeconds);
#else
	// UDEB:
	// shut down the server
	closeServers();

	// re-start server after alarm expires
	User::SetHomeTime(time - TTimeIntervalSeconds(3));
	User::After(KTenSeconds);
	TheAlarmTest.Test().Next(_L("now restarting server...\r\n"));
	TheAlarmTest.TestStartServers();
	User::After(1000000);
#endif

	// Internalise on startup has a 59s window for recent alarms
	TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying"));
	//check status of alarm
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);
	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);

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

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

static void doTestNotifyingAlarmBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test Notifying alarm removed by backup / restore"));

	TheAlarmTest.TestClearStoreL();

	TheAlarmTest.Test().Next(_L("add an alarm"));
	// add an alarm to expire in 15 minutes
	TAlarmId id = addAlarm(15);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	TRAPD(err, BackupAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// get alarm expiry time
	TASShdAlarm alarm;
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);
	TTime time = alarm.NextDueTime();

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

	// wait until after alarm due time
	User::SetHomeTime(time - TTimeIntervalSeconds(3));
	User::After(KTenSeconds);

	// Internalise on startup has a 59s window for recent alarms
	TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying"));
	//check status of alarm
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

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


	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));
	TRAP(err, RestoreAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// allow Alarm server to notice file lock has been released
	User::After(1000000);

	// Internalise after Restore has a 0s window for recent alarms
	// check absence of alarm
	TheAlarmTest.Test().Next(_L("check alarm has gone\r\n"));
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);
	}

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

static void doTestSessionAlarmShutdownRestartL()
	{
	TheAlarmTest.Test().Next(_L("* Test that Session alarm is removed by shutdown"));

#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));
#else
	TheAlarmTest.TestClearStoreL();

	// Set the session alarm
	TheAlarmTest.Test().Next(_L("set session alarm in 2 minutes"));
	TASShdAlarm alarm;
	alarm.Category() = KASCliCategoryClock;
	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
	alarm.NextDueTime().HomeTime();
	alarm.NextDueTime() += TTimeIntervalMinutes(2);
	// session specific alarm (has a TRequestStatus to complete)
	alarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);
	TRequestStatus status;
	TheAlarmTest.Session().AlarmAddWithNotification(status, alarm);
	const TAlarmId id = alarm.Id();
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// status should be pending
	TheAlarmTest.Test().Next(_L("checking request is pending"));
	TheAlarmTest(status == KRequestPending, __LINE__);

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

	User::After(10000000);

	// check absence of alarm
	TheAlarmTest.Test().Next(_L("check alarm notification has been aborted"));

	TheAlarmTest(status != KRequestPending, __LINE__);

	// Get the abort
	// (Probably KErrDied though KErrServerTerminated should be okay too)
	User::WaitForRequest(status);
	TInt stat = status.Int();
	TheAlarmTest((stat == KErrDied) || (stat == KErrServerTerminated), __LINE__);

	// now restart Alarm Server
	TheAlarmTest.Test().Next(_L("restart Alarm Server"));
	TheAlarmTest.TestStartServers();

	// check presence of alarm
	TheAlarmTest.Test().Next(_L("check shutdown deleted alarm"));
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);
#endif
	}

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

static void doTestSessionAlarmBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test that Session alarm is orphaned by restore"));

	TheAlarmTest.TestClearStoreL();

	// Set the session alarm
	TheAlarmTest.Test().Next(_L("set session alarm in 20 minutes"));
	TASShdAlarm alarmWrite;
	alarmWrite.Category() = KASCliCategoryClock;
	alarmWrite.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
	alarmWrite.NextDueTime().HomeTime();
	alarmWrite.NextDueTime() += TTimeIntervalMinutes(20);
	// session specific alarm (has a TRequestStatus to complete)
	alarmWrite.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);
	TRequestStatus status;
	TheAlarmTest.Session().AlarmAddWithNotification(status, alarmWrite);
	// check that alarm was set okay
	const TAlarmId id = alarmWrite.Id();
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// status should be pending
	TheAlarmTest.Test().Next(_L("checking request is pending"));
	TheAlarmTest(status == KRequestPending, __LINE__);

	// remember the alarm time
	TTime alarmTime = alarmWrite.NextDueTime();

	// make the Alarm server re-internlize ....
	TheAlarmTest.Test().Next(_L("now simulating restore..."));
	TRAPD(err, SimulateBackupServerRestorationL());
	TheAlarmTest(err==KErrNone, __LINE__);


	// allow Alarm server to Internalize...
	User::After(1000000);	// 1s


	// check old alarm queue has been cleared
	TheAlarmTest.Test().Next(_L("check alarm notification has been aborted"));
	TheAlarmTest(status != KRequestPending, __LINE__);

	// Get the abort result
	User::WaitForRequest(status);
	TheAlarmTest(status.Int() == KErrCancel, __LINE__);

	// check presence of alarm
	TASShdAlarm alarmRead;
	TheAlarmTest.Test().Next(_L("check alarm is no longer a session alarm"));
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__);

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

	// advance clock, wait for alarm
	User::SetHomeTime(alarmWrite.NextDueTime() - TTimeIntervalSeconds(3));
	TheAlarmTest.Test().Next(_L("waiting for alarm to notify"));
	// wait until after alarm due time
	User::After(KTenSeconds);

	// alarm should be notifying
	// if Alarm Server server tries to access the TRequestStatus
	// there will be an Access Violation
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__);

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

	const TAlarmState alarmState = alarmRead.State();
	TheAlarmTest(alarmState == EAlarmStateNotifying, __LINE__);
	}


/*****************************************************************************
 * Test adapted from TAlarmData, checks alarm data across Backup & Restore.
 * (Original tested across Alarm Server shutdown & re-start.)
 */

static void doTestRestoreValidAlarmDataL()
	{
	TheAlarmTest.Test().Next(_L("Data API test"));
	TheAlarmTest.TestClearStoreL();
	TInt r;
	TAlarmId alarmId;
	TASShdAlarm alarm;
	TRequestStatus status;
	//
	alarm.Message() = _L("Alarm with data");
	alarm.NextDueTime().HomeTime();
	alarm.NextDueTime() += TTimeIntervalMinutes(2);
	//
	r = TheAlarmTest.Session().AlarmAdd(alarm);
	TheAlarmTest(r==KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	User::WaitForRequest(status);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrInUse, __LINE__);
	TheAlarmTest(status == KRequestPending, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KSomeAlarmData().Size());
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	alarm.NextDueTime().HomeTime();
	alarm.NextDueTime() += TTimeIntervalMinutes(2);
	r = TheAlarmTest.Session().AlarmAdd(alarm);
	TheAlarmTest(r==KErrNone, __LINE__);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	User::WaitForRequest(status);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	User::WaitForRequest(status);
	//
	HBufC8* buf = HBufC8::NewLC(KSomeAlarmData().Size());
	TPtr8 pBuf(buf->Des());
	r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pBuf);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(*buf == KSomeAlarmData, __LINE__);
	//
	TheAlarmTest.Test().Next(_L("Waiting for alarm to expire"));
	// advance clock to 3s before alarm due
	User::SetHomeTime(alarm.NextDueTime() - TTimeIntervalSeconds(3));
	TheAlarmTest.WaitForEvent(EAlarmChangeEventTimerExpired, status, alarmId);
	TheAlarmTest(alarmId == alarm.Id(), __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrInUse, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	//

	TheAlarmTest.Session().AlarmAddWithNotification(status, alarm, KSomeAlarmData);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	HBufC8* alarmdata = HBufC8::NewLC(KSomeAlarmData().Size());
	TPtr8 pAlarmdata(alarmdata->Des());
	r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(*alarmdata == KSomeAlarmData, __LINE__);
	TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(alarmId);
	CleanupStack::PopAndDestroy(alarmdata);
	//
	alarm.Reset();
	alarm.Message() = _L("Alarm with data");
	alarm.NextDueTime().HomeTime();
	alarm.NextDueTime() += TTimeIntervalMinutes(2);
	//
	r =	TheAlarmTest.Session().AlarmAdd(alarm, KSomeAlarmData);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	HBufC8* alarmdata1 = HBufC8::NewLC(KSomeAlarmData().Size());
	TPtr8 pAlarmdata1(alarmdata1->Des());
	r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata1);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(*alarmdata1 == KSomeAlarmData, __LINE__);
	CleanupStack::PopAndDestroy(alarmdata1);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	User::After(1000000); // 1s
	BackupAlarmServerIniFileL();
	User::After(1000000); // 1s

	TheAlarmTest.Test().Next(_L("Delete Alarm"));
	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmId) == KErrNone, __LINE__);

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

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

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

	//
	TheAlarmTest.Test().Next(_L("testing data restoration"));
	//
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrInUse, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmAdd(alarm);
	TheAlarmTest(r==KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);

	CleanupStack::PopAndDestroy(buf);
	}


//
//
//


static void doTestUtcAlarmQueueOrderShutdownStartupL()
	{
	TheAlarmTest.Test().Next(_L("* Test alarms set with UTC time order stable over server shutdown/startup"));

#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));
#else
	TheAlarmTest.TestClearStoreL();

	//add alarms
	TheAlarmTest.Test().Next(_L("add 5 alarms"));
	RArray<TAlarmId> alarmIds;
	for	(TInt ii=2; ii<=6; ii++)
		{
		TAlarmId id = addUtcAlarm(ii);
		alarmIds.Append(id);
		}

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

	//get server alarms
	RArray<TAlarmId> serverAlarmIds;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);
	alarmIds.Sort();
	serverAlarmIds.Sort();
	TInt count = alarmIds.Count();
	TheAlarmTest(count == serverAlarmIds.Count(), __LINE__);
	for	(TInt jj=0; jj<count; jj++)
		{
		TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);
		}
	serverAlarmIds.Close();
	alarmIds.Close();
#endif
	}

static void doTestUtcAlarmDSTShutdownStartupL()
	{
	TheAlarmTest.Test().Next(_L("* Test alarms set stable over server shutdown in DST off/startup in DST on"));
#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));
#else
	_LIT(KDSTON,"DST is on\r\n");
	_LIT(KDSTOFF,"DST is off\r\n");
	_LIT8(KTzEuropeLondon, "Europe/London");

	TheAlarmTest.TestClearStoreL();

	//Set time zone and system time at first
	const TInt currYear = 2007;

 	TTime oldTime;
 	oldTime.HomeTime();

 	RTz tz;
 	User::LeaveIfError(tz.Connect());
	CleanupClosePushL(tz);
	CTzId* oldTz=tz.GetTimeZoneIdL();
	CleanupStack::PushL(oldTz);
    CTzId* zoneId = CTzId::NewL(KTzEuropeLondon);
	CleanupStack::PushL(zoneId);
	tz.SetTimeZoneL(*zoneId);
	tz.SetHomeTime(TDateTime(currYear, EMarch, 24, 00, 58, 0, 0));
	tz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn);

    //add alarms
	TheAlarmTest.Test().Next(_L("add 2 alarms"));
	RArray<TAlarmId> alarmIds;
	//Create an alarm at 5.00 am
	TAlarmId id = addAlarm(242);
	alarmIds.Append(id);
	//Create an alarm at 6.00 am
	id = addAlarm(302);
	alarmIds.Append(id);

	//Get the due time of the returned back alarms
	RArray<TTime> dueTimes;
	TASShdAlarm orginalAlarm;
	TheAlarmTest.Session().GetAlarmDetails(alarmIds[0], orginalAlarm);
	dueTimes.Append(orginalAlarm.NextDueTime());
	TheAlarmTest.Session().GetAlarmDetails(alarmIds[1], orginalAlarm);
	dueTimes.Append(orginalAlarm.NextDueTime());

	TTime curTime;
	curTime.HomeTime();
	TDateTime date=curTime.DateTime();
	TBool onDST=tz.IsDaylightSavingOnL(*zoneId);

	TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second());
	if (onDST)
		{
		TheAlarmTest.Test().Printf(KDSTON);
		}
	else
		{
		TheAlarmTest.Test().Printf(KDSTOFF);
		}

	TheAlarmTest.Test().Next(_L("shutdown then restart Alarm Server"));
	closeServers();
	User::After(1000000*60*3);  //wait three minutes
	TheAlarmTest.Test().Printf(_L("now restarting server...\r\n"));
	TheAlarmTest.TestStartServers();

	curTime.HomeTime();
	date=curTime.DateTime();
	onDST=tz.IsDaylightSavingOnL(*zoneId);
	CleanupStack::PopAndDestroy(zoneId);

	TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second());
	if (onDST)
		{
		TheAlarmTest.Test().Printf(KDSTON);
		}
	else
		{
		TheAlarmTest.Test().Printf(KDSTOFF);
		}

	//get server alarms
	RArray<TAlarmId> serverAlarmIds;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);
	alarmIds.Sort();
	serverAlarmIds.Sort();
	TInt count = alarmIds.Count();
	TheAlarmTest(count == serverAlarmIds.Count(), __LINE__);
	TASShdAlarm alarm;
	for	(TInt jj=0; jj<count; jj++)
		{
		TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);
		TheAlarmTest.Session().GetAlarmDetails(alarmIds[jj], alarm);
		TheAlarmTest(alarm.NextDueTime() == dueTimes[jj], __LINE__);
		date = alarm.NextDueTime().DateTime();
		TheAlarmTest.Test().Printf(_L("alarm %d due time is : hours: %d, minutes: %d, seconds: %d.\r\n"),
		     alarmIds[jj],date.Hour(), date.Minute(), date.Second());
		}


	serverAlarmIds.Close();
	alarmIds.Close();
	dueTimes.Close();

	tz.SetTimeZoneL(*oldTz);
	CleanupStack::PopAndDestroy(oldTz);
  	tz.SetHomeTime(oldTime);
 	CleanupStack::PopAndDestroy(&tz);
#endif
	}

static void doTestFloatingAlarmDSTShutdownStartupHelsinkiL()
	{
	TheAlarmTest.Test().Next(_L("* Test alarms set stable over server shutdown in DST on/startup in DST off"));
	
#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));
#else
	_LIT8(KTzEuropeHelsinki, "Europe/Helsinki");
	_LIT(KDSTON,"DST is on\r\n");
	_LIT(KDSTOFF,"DST is off\r\n");

	TheAlarmTest.TestClearStoreL();
	
	//Set time zone and system time at first
	const TInt currYear = 2007;
 
 	TTime oldTime; 
 	oldTime.HomeTime();
 
 	RTz tz;
 	User::LeaveIfError(tz.Connect());
	CleanupClosePushL(tz);
	CTzId* oldTz=tz.GetTimeZoneIdL();
	CleanupStack::PushL(oldTz);
    CTzId* zoneId = CTzId::NewL(KTzEuropeHelsinki);
	CleanupStack::PushL(zoneId);
	tz.SetTimeZoneL(*zoneId);
	tz.SetHomeTime(TDateTime(currYear, EOctober, 27, 03, 58, 0, 0));
	tz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn);	

    //add alarms
	TheAlarmTest.Test().Next(_L("add alarms"));
	RArray<TAlarmId> alarmIds;
	//Create an alarm at 4.02 am
	TAlarmId id = addAlarm(4);
	alarmIds.Append(id);
		
	id = addAlarm(7);
	alarmIds.Append(id);
	
	id = addAlarm(10);
	alarmIds.Append(id);
	
	//Get the due time of the returned back alarms
	RArray<TTime> dueTimes;
	TASShdAlarm floatingAlarm;
	TheAlarmTest.Session().GetAlarmDetails(alarmIds[0], floatingAlarm);
	dueTimes.Append(floatingAlarm.NextDueTime());
	
	TheAlarmTest.Session().GetAlarmDetails(alarmIds[1], floatingAlarm);
	dueTimes.Append(floatingAlarm.NextDueTime());
	
	TheAlarmTest.Session().GetAlarmDetails(alarmIds[2], floatingAlarm);
	dueTimes.Append(floatingAlarm.NextDueTime());
	
	TTime curTime;
	curTime.HomeTime();
	TDateTime date=curTime.DateTime();
	TBool onDST=tz.IsDaylightSavingOnL(*zoneId);
	
	TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second());
	if (onDST)
		{
		TheAlarmTest.Test().Printf(KDSTON);
		}
	else
		{
		TheAlarmTest.Test().Printf(KDSTOFF);
		}
		
	TheAlarmTest.Test().Next(_L("shutdown then restart Alarm Server"));
	closeServers();
	User::After(1000000*60*4);  //wait for 4 mins
	
	tz.SetHomeTime(TDateTime(currYear, EOctober, 27, 04, 02, 0, 0));
	TheAlarmTest.Test().Printf(_L("now restarting server...\r\n"));
	TheAlarmTest.TestStartServers();

	curTime.HomeTime();
	date=curTime.DateTime();
	onDST=tz.IsDaylightSavingOnL(*zoneId);
	CleanupStack::PopAndDestroy(zoneId);

	TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second());
	if (onDST)
		{
		TheAlarmTest.Test().Printf(KDSTON);
		}
	else
		{
		TheAlarmTest.Test().Printf(KDSTOFF);
		}
	
	//get server alarms
	RArray<TAlarmId> serverAlarmIds;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);
	alarmIds.Sort();
	serverAlarmIds.Sort();
	TInt count = alarmIds.Count();
	if(count != serverAlarmIds.Count())
		{
		TheAlarmTest.Test().Printf(_L("No alarms found after DST change \r\n"));
		}
	else
		{
		TASShdAlarm alarm;
		for	(TInt jj=0; jj<count; jj++)
			{
			TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);
			TheAlarmTest.Session().GetAlarmDetails(alarmIds[jj], alarm);
			TheAlarmTest(alarm.NextDueTime() == dueTimes[jj], __LINE__);
			date = alarm.NextDueTime().DateTime();
			TheAlarmTest.Test().Printf(_L("alarm %d due time is : hours: %d, minutes: %d, seconds: %d.\r\n"), 
			     alarmIds[jj],date.Hour(), date.Minute(), date.Second());
			}
			
		}
	serverAlarmIds.Close();
	alarmIds.Close();
	dueTimes.Close();
	
	tz.SetTimeZoneL(*oldTz);
	CleanupStack::PopAndDestroy(oldTz);
  	tz.SetHomeTime(oldTime);
 	CleanupStack::PopAndDestroy(&tz);
#endif
	}


static void doTestUtcAlarmQueueOrderBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test alarm set with UTC time order across Backup and Restore"));

	TheAlarmTest.TestClearStoreL();

	//add alarms
	TheAlarmTest.Test().Next(_L("add 5 alarms"));
	RArray<TAlarmId> alarmIds;
	for	(TInt ii=2; ii<=6; ii++)
		{
		TAlarmId id = addUtcAlarm(ii);
		alarmIds.AppendL(id);
		}

	// brief pause before backup (1s)
	User::After(1000000);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	TRAPD(err, BackupAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// delete alarms
	TheAlarmTest.Test().Next(_L("delete alarms"));
	TInt jj;
	for (jj=0; jj<5; jj++)
		{
		TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmIds[jj]) == KErrNone, __LINE__);
		}

	// pause before restore (10s)
	User::After(10000000);
	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));
	TRAP(err, RestoreAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	TheAlarmTest.Test().Next(_L("check restored alarms"));
	//get server alarms
	RArray<TAlarmId> serverAlarmIds;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds);
	alarmIds.Sort();
	serverAlarmIds.Sort();
	TInt count = alarmIds.Count();
	TInt serverCount = serverAlarmIds.Count();
	TheAlarmTest.Test().Printf(_L("[Added Alarms count = %i, server Count = %i]\r\n"), count, serverCount);
	TheAlarmTest(count == serverCount, __LINE__);
	for	(jj=0; jj<count; jj++)
		{
		TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__);
		}
	serverAlarmIds.Close();
	alarmIds.Close();
	}


static void doTestUtcAlarmQueueBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test correct alarms set with UTC time in queue after backup and restore"));

	TheAlarmTest.TestClearStoreL();

	// add an alarm to expire in 2 minutes
	TAlarmId id2 = addUtcAlarm(2);
	// add an alarm to expire in 3 minutes
	TAlarmId id3 = addUtcAlarm(3);

	// brief pause before backup (.5s)
	User::After(500000);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	TRAPD(err, BackupAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// delete alarms
	TheAlarmTest.Test().Next(_L("delete alarms"));
	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id2) == KErrNone, __LINE__);
	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id3) == KErrNone, __LINE__);

	// add alarms
	TheAlarmTest.Test().Next(_L("add alarms"));
	// add alarms to expire now
	TAlarmId id0 = addUtcAlarm(0);
	TAlarmId id1 = addUtcAlarm(1);

	// first alarm (id0) should be notifying
	TASShdAlarm alarm;
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNone, __LINE__);
	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);


	// pause briefly before restore (2s)
	User::After(2000000);
	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));
	TRAP(err, RestoreAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

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

	// alarms should now be gone
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNotFound, __LINE__);
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id1, alarm) == KErrNotFound, __LINE__);

	// alarms should be restored
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id2, alarm) == KErrNone, __LINE__);
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id3, alarm) == KErrNone, __LINE__);
	}


static void doTestUtcAlarmAddDuringBackupL()
	{
	TheAlarmTest.Test().Next(_L("* Test alarm changes during backup"));

	TheAlarmTest.TestClearStoreL();

	// Attempt to add an alarm while the backup server is backing up the alarms
	CStreamStore* store = NULL;
	TRAPD(err, store = SimulateBackupServerBackup_StartL());
	TheAlarmTest(err==KErrNone, __LINE__);

	CleanupStack::PushL(store);

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

	TASShdAlarm alm;
	TTime time;
	time.UniversalTime();
	alm.SetUtcNextDueTime(time);
	TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alm) == KErrNone, __LINE__);

	TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize"));
	// Locale change (time) x2 (INC038240 regression)
	// Exercise CASSrvAlarmStore queue an Externalize
	time.UniversalTime();
	time += TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);
	time -= TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);

	// release file lock -
	CleanupStack::PopAndDestroy(store); // store
	// backup complete
	TRAP(err, SimulateBackupServerBackup_CompleteL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// wait for AlarmServer to catch-up
	User::After(1000000);


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

	// re-try alarm add after backup complete - should be successful
	TAlarmId id = addUtcAlarm(0);
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// make Alarm Server re-Internalize
	User::After(1000000);
	TheAlarmTest.Test().Next(_L("now simulating restore..."));
	TRAP(err, SimulateBackupServerRestorationL());
	TheAlarmTest(err==KErrNone, __LINE__);
	TASShdAlarm alarm;


	// check absence of alarm
	TheAlarmTest.Test().Next(_L("check alarm has gone"));
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);

	}


static void doTestUtcAlarmAddDuringRestoreL()
	{
	// variables used to check Alarm Server notifications of Restore
	TAlarmId alarmId;
	TRequestStatus status;

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

	TheAlarmTest.TestClearStoreL();

	// Attempt to add an alarm while the backup server is restoring up the alarms
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	CStreamStore* store = NULL;
	TRAPD(err, store = SimulateBackupServerRestore_StartL());
	CleanupStack::PushL(store);
	TheAlarmTest(err==KErrNone, __LINE__);

	// check Restore Start notification received
	TheAlarmTest.Test().Next(_L("check for Alarm Restore Start notification"));
	User::After(1000000);
	TheAlarmTest(status == EAlarmChangeEventRestoreStarted, __LINE__);
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);

	TheAlarmTest(alarmId==KNullAlarmId, __LINE__);

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

	TASShdAlarm alm;
	TTime time;
	time.UniversalTime();
	alm.SetUtcNextDueTime(time);
	TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alm) == KErrLocked, __LINE__);

	TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize"));
	// Locale change (time) x2 (INC038240 regression)
	// Exercise CASSrvAlarmStore

	time.UniversalTime();
	time += TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);
	time -= TTimeIntervalSeconds(10);
	User::SetUTCTime(time);
	User::After(1000000);

	CleanupStack::PopAndDestroy(store);
	// restore complete
	TRAP(err, SimulateBackupServerRestore_CompleteL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// check Restore Complete notification received
	TheAlarmTest.Test().Next(_L("check for Alarm Restore Complete notification"));
	TheAlarmTest.TestEventBuffer(EAlarmChangeEventRestoreCompleted, status, alarmId);
	TheAlarmTest(alarmId==KNullAlarmId, __LINE__);


	// wait for AlarmServer to catch-up
	User::After(1000000);

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

	// re-try alarm add after restore complete - should be successful
	TAlarmId id = addUtcAlarm(0);
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// wait for Alarm Server to externalize
	User::After(3000000);
	}





static void doTestNotifyingUtcAlarmShutdownStartupL()
	{
	TheAlarmTest.Test().Next(_L("* Test Notifying alarm across shutdown / startup"));

	TheAlarmTest.TestClearStoreL();

	TheAlarmTest.Test().Next(_L("add an alarm"));
	// add an alarm to expire in 15 minutes
	TAlarmId id = addUtcAlarm(15);

	// get alarm expiry time
	TASShdAlarm alarm;
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);
	TTime time = alarm.NextDueTime();

#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));

	TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n"));
#if defined(_DEBUG)
	// UREL Alternative: wait until after alarm due time
	User::SetUTCTime(time - TTimeIntervalSeconds(3));
	User::After(KTenSeconds);
#endif
#else
	// UDEB:
	// shut down the server
	closeServers();

	// re-start server after alarm expires
	User::SetUTCTime(time - TTimeIntervalSeconds(3));
	User::After(KTenSeconds);
	TheAlarmTest.Test().Next(_L("now restarting server...\r\n"));
	TheAlarmTest.TestStartServers();
	User::After(1000000);
#endif
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

#if	defined(_DEBUG)
	//check status of alarm
	// Internalise on startup has a 59s window for recent alarms
	TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying"));
	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);
#else
	// Test only possible if in _DEBUG build.
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A DEBUG TEST ONLY\r\n"));
#endif
	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id) == KErrNone, __LINE__);
	}


static void doTestNotifyingUtcAlarmBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test Notifying alarm removed by backup / restore"));

	TheAlarmTest.TestClearStoreL();

	TheAlarmTest.Test().Next(_L("add an alarm"));
	// add an alarm to expire in 15 minutes
	TAlarmId id = addUtcAlarm(15);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	TRAPD(err, BackupAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// get alarm expiry time
	TASShdAlarm alarm;
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);
	TTime time = alarm.NextDueTime();
	TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n"));
	TheAlarmTest.Test().Printf(_L("Alarm set to expire at: hours: %d, minutes: %d, seconds: %d.\r\n"), time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second());


	// wait until after alarm due time
	User::SetUTCTime(time - TTimeIntervalSeconds(3));
	TTime now;
	now.UniversalTime();
	TheAlarmTest.Test().Printf(_L("System UTC time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), now.DateTime().Hour(), now.DateTime().Minute(), now.DateTime().Second());
	TheAlarmTest.Test().Printf(_L("Wait for approximately 10 seconds for alarm to expire...\r\n"));
	User::After(KTenSeconds);
	now.UniversalTime();
	TheAlarmTest.Test().Printf(_L("System UTC time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), now.DateTime().Hour(), now.DateTime().Minute(), now.DateTime().Second());

	// Internalise on startup has a 59s window for recent alarms
	TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying"));

	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);
	TheAlarmTest.Test().Printf(_L("Alarm state: %d.\r\n"), alarm.State());
	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);

	TheAlarmTest.Test().Next(_L("restore alarmserver ini file"));
	TRAP(err, RestoreAlarmServerIniFileL());
	TheAlarmTest(err==KErrNone, __LINE__);

	// allow Alarm server to notice file lock has been released
	User::After(1000000);

	// Internalise after Restore has a 0s window for recent alarms
	// check absence of alarm
	TheAlarmTest.Test().Next(_L("check alarm has gone\r\n"));
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);
	}


static void doTestSessionUtcAlarmShutdownRestartL()
	{
	TheAlarmTest.Test().Next(_L("* Test that Session alarm is removed by shutdown"));

#if !defined(_DEBUG) || !defined(__WINSCW__)
	// Can't shutdown Alarm Server on UREL or target builds
	TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));
#else
	TheAlarmTest.TestClearStoreL();

	// Set the session alarm
	TheAlarmTest.Test().Next(_L("set session alarm in 2 minutes"));
	TASShdAlarm alarm;
	alarm.Category()=(KASCliCategoryClock);
	alarm.RepeatDefinition()=(EAlarmRepeatDefintionRepeatOnce);
	TTime time;
	time.UniversalTime();
	time += TTimeIntervalMinutes(2);
	alarm.SetUtcNextDueTime(time);
	// session specific alarm (has a TRequestStatus to complete)
	alarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);
	TRequestStatus status;
	TheAlarmTest.Session().AlarmAddWithNotification(status, alarm);
	const TAlarmId id = alarm.Id();
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// status should be pending
	TheAlarmTest.Test().Next(_L("checking request is pending"));
	TheAlarmTest(status == KRequestPending, __LINE__);

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

	User::After(10000000);

	// check absence of alarm
	TheAlarmTest.Test().Next(_L("check alarm notification has been aborted"));

	TheAlarmTest(status != KRequestPending, __LINE__);

	// Get the abort
	// (Probably KErrDied though KErrServerTerminated should be okay too)
	User::WaitForRequest(status);
	TInt stat = status.Int();
	TheAlarmTest((stat == KErrDied) || (stat == KErrServerTerminated), __LINE__);

	// now restart Alarm Server
	TheAlarmTest.Test().Next(_L("restart Alarm Server"));
	TheAlarmTest.TestStartServers();

	// check presence of alarm
	TheAlarmTest.Test().Next(_L("check shutdown deleted alarm"));
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);
#endif
	}


static void doTestSessionUtcAlarmBackupRestoreL()
	{
	TheAlarmTest.Test().Next(_L("* Test that Session alarm is orphaned by restore"));

	TheAlarmTest.TestClearStoreL();

	// Set the session alarm
	TheAlarmTest.Test().Next(_L("set session alarm in 20 minutes"));
	TASShdAlarm alarmWrite;
	alarmWrite.Category()=(KASCliCategoryClock);
	alarmWrite.RepeatDefinition()=EAlarmRepeatDefintionRepeatOnce;
	TTime time;
	time.UniversalTime();
	time += TTimeIntervalMinutes(20);
	alarmWrite.SetUtcNextDueTime(time);
	// session specific alarm (has a TRequestStatus to complete)
	alarmWrite.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);
	TRequestStatus status;
	TheAlarmTest.Session().AlarmAddWithNotification(status, alarmWrite);
	// check that alarm was set okay
	const TAlarmId id = alarmWrite.Id();
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// status should be pending
	TheAlarmTest.Test().Next(_L("checking request is pending"));
	TheAlarmTest(status == KRequestPending, __LINE__);

	// remember the alarm time
	TTime alarmTime = alarmWrite.NextDueTime();

	// make the Alarm server re-internlize ....
	TheAlarmTest.Test().Next(_L("now simulating restore..."));
	TRAPD(err, SimulateBackupServerRestorationL());
	TheAlarmTest(err==KErrNone, __LINE__);


	// allow Alarm server to Internalize...
	User::After(1000000);	// 1s


	// check old alarm queue has been cleared
	TheAlarmTest.Test().Next(_L("check alarm notification has been aborted"));
	TheAlarmTest(status != KRequestPending, __LINE__);

	// Get the abort result
	User::WaitForRequest(status);
	TheAlarmTest(status.Int() == KErrCancel, __LINE__);

	// check presence of alarm
	TASShdAlarm alarmRead;
	TheAlarmTest.Test().Next(_L("check alarm is no longer a session alarm"));
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__);

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

	// advance clock, wait for alarm
	User::SetUTCTime(alarmWrite.NextDueTime() - TTimeIntervalSeconds(3));
	TheAlarmTest.Test().Next(_L("waiting for alarm to notify"));
	// wait until after alarm due time
	User::After(KTenSeconds);

	// alarm should be notifying
	// if Alarm Server server tries to access the TRequestStatus
	// there will be an Access Violation
	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__);

	//TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);
	const TAlarmState alarmState = alarmRead.State();
	TheAlarmTest(alarmState == EAlarmStateNotifying, __LINE__);
	}


static void doTestRestoreValidUtcAlarmDataL()
	{
	TheAlarmTest.Test().Next(_L("Data API test"));
	TheAlarmTest.TestClearStoreL();
	TInt r;
	TAlarmId alarmId;
	TASShdAlarm alarm;
	TRequestStatus status;
	//
	alarm.Message()=(_L("Alarm with data"));
	TTime time;
	time.UniversalTime();
	time += TTimeIntervalMinutes(2);
	alarm.SetUtcNextDueTime(time);
	//
	r = TheAlarmTest.Session().AlarmAdd(alarm);
	TheAlarmTest(r==KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	User::WaitForRequest(status);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrInUse, __LINE__);
	TheAlarmTest(status == KRequestPending, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KSomeAlarmData().Size());
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	time.UniversalTime();
	time += TTimeIntervalMinutes(2);
	alarm.SetUtcNextDueTime(time);
	r = TheAlarmTest.Session().AlarmAdd(alarm);
	TheAlarmTest(r==KErrNone, __LINE__);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	User::WaitForRequest(status);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId);
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	User::WaitForRequest(status);
	//
	HBufC8* buf = HBufC8::NewLC(KSomeAlarmData().Size());
	TPtr8 pBuf(buf->Des());
	r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pBuf);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(*buf == KSomeAlarmData, __LINE__);
	//
	TheAlarmTest.Test().Next(_L("Waiting for alarm to expire"));
	// advance clock to 3s before alarm due
	User::SetUTCTime(alarm.NextDueTime() - TTimeIntervalSeconds(3));
	TheAlarmTest.WaitForEvent(EAlarmChangeEventTimerExpired, status, alarmId);
	TheAlarmTest(alarmId == alarm.Id(), __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrInUse, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	//

	TheAlarmTest.Session().AlarmAddWithNotification(status, alarm, KSomeAlarmData);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	HBufC8* alarmdata = HBufC8::NewLC(KSomeAlarmData().Size());
	TPtr8 pAlarmdata(alarmdata->Des());
	r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(*alarmdata == KSomeAlarmData, __LINE__);
	TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(alarmId);
	CleanupStack::PopAndDestroy(alarmdata);
	//
	alarm.Reset();
	alarm.Message()=(_L("Alarm with data"));
	time.UniversalTime();
	time += TTimeIntervalMinutes(2);
	alarm.SetUtcNextDueTime(time);
	//
	r =	TheAlarmTest.Session().AlarmAdd(alarm, KSomeAlarmData);
	TheAlarmTest(alarmId = alarm.Id(), __LINE__);
	HBufC8* alarmdata1 = HBufC8::NewLC(KSomeAlarmData().Size());
	TPtr8 pAlarmdata1(alarmdata1->Des());
	r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata1);
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest(*alarmdata1 == KSomeAlarmData, __LINE__);
	CleanupStack::PopAndDestroy(alarmdata1);

	TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file"));
	User::After(1000000); // 1s
	BackupAlarmServerIniFileL();
	User::After(1000000); // 1s

	TheAlarmTest.Test().Next(_L("Delete Alarm"));
	TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmId) == KErrNone, __LINE__);

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

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

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

	//
	TheAlarmTest.Test().Next(_L("testing data restoration"));
	//
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrInUse, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDelete(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmAdd(alarm);
	TheAlarmTest(r==KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData);
	TheAlarmTest(r == KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id());
	TheAlarmTest(r == KErrNone, __LINE__);
	//
	r = TheAlarmTest.Session().AlarmDataSize(alarm.Id());
	TheAlarmTest(r == KErrNotFound, __LINE__);

	CleanupStack::PopAndDestroy(buf);
	}


//

static void doTestsL()
	{
	// Initialise the drive list to empty and then get drive list data from
	// File Server.
	DriveList.FillZ();
	User::LeaveIfError(FsSession.DriveList(DriveList));

	BackupClient = conn::CSBEClient::NewL();
	CleanupStack::PushL(BackupClient);

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);

	TheAlarmTest.TestStartServers();
	TheAlarmTest(TheAlarmTest.Session().Connect() == KErrNone, __LINE__);
	TheAlarmTest.TestClearStoreL();

	User::After(100000);

	// delete AlarmServer.ini file
	FsSession.Delete(KAlarmServerBackupFileFullPath);
	User::After(1000000);


	// 1.
	// Baseline for Internalize behaviour
	// [add alarms, shutdown, re-start alarm server, check alarms still queued]
	doTestAlarmQueueOrderShutdownStartupL();

	// 2.
	// Backup, Restore Internalize behaviour
	// [add alarms, pretend backup/restore, check alarms queued again]
	doTestAlarmQueueOrderBackupRestoreL();


	// 3.
	// Correct Alarms are Backed up and Restored
	// [add alarms, backup, delete alarms, add different alarms, restore, check queued alarms]
	doTestAlarmQueueBackupRestoreL();

	// 4.
	// Alarm Sound Intervals are Backed up and Restored.
	doTestAlarmSoundIntervalsBackupRestoreL();

	/* 5.
	 * Should be able to add alarm or change Locale during Backup
	 */
	doTestAlarmAddDuringBackupL();

	/* 6.
	 * Testing Restore behaviour
	 *    a) Should not be able to add alarm during Restore
	 *    b) Should get Notifications at Start & End of Restore
	 *    c) Locale (time) changes during Restore should be processed,
	 *       (but Externalize happens when Restore ends).
	 */
	doTestAlarmAddDuringRestoreL();

	/* 7.
	 * Testing Failed Restore behaviour
	 *    a) Should get Notifications at Start & End of Restore
	 *    b) Alarm Queue should not change
	 *    c) Alarm Server should perform a new Externalize
	 */
	/* 8, 9.
	 * Handling of Notifying alarm across Shutdown/Startup and Backup/Restore
	 */
	doTestNotifyingAlarmShutdownStartupL();
	doTestNotifyingAlarmBackupRestoreL();

	/* 10, 11.
	 * Handling of Session alarm
	 */
	doTestSessionAlarmShutdownRestartL();
	doTestSessionAlarmBackupRestoreL();

	/* 12.
	 * Test restore of alarm with attached data
	 * [create alarm with data, backup, delete alarm, restore, check alarm & data]
	 * (Based on test case in TAlarmData.)
	 */
	doTestRestoreValidAlarmDataL();

	// UTC Tests

	// 13.
	// Baseline for Internalize behaviour
	// [add alarms, shutdown, re-start alarm server, check alarms still queued]
	doTestUtcAlarmQueueOrderShutdownStartupL();

	// 14.
	// Backup, Restore Internalize behaviour
	// [add utc alarms, pretend backup/restore, check alarms queued again]
	doTestUtcAlarmQueueOrderBackupRestoreL();


	// 15.
	// Correct UTC Alarms are Backed up and Restored
	// [add utc alarms, backup, delete alarms, add different alarms, restore, check queued alarms]
	doTestUtcAlarmQueueBackupRestoreL();

	/* 16.
	 * Should be able to add utc alarm or change Locale during Backup
	 */
	doTestUtcAlarmAddDuringBackupL();

	/* 17.
	 * Testing Restore behaviour
	 *    a) Should not be able to add utc alarm during Restore
	 *    b) Should get Notifications at Start & End of Restore
	 *    c) Locale (time) changes during Restore should be processed,
	 *       (but Externalize happens when Restore ends).
	 */
	doTestUtcAlarmAddDuringRestoreL();

	/* 18.
	 * Testing Failed Restore behaviour
	 *    a) Should get Notifications at Start & End of Restore
	 *    b) Alarm Queue should not change
	 *    c) Alarm Server should perform a new Externalize
	 */
	/* 19, 20.
	 * Handling of Notifying UTC alarm across Shutdown/Startup and Backup/Restore
	 */
	doTestNotifyingUtcAlarmShutdownStartupL();
	doTestNotifyingUtcAlarmBackupRestoreL();

	/* 21, 22.
	 * Handling of Session UTC alarm
	 */
	doTestSessionUtcAlarmShutdownRestartL();
	doTestSessionUtcAlarmBackupRestoreL();

	/* 23.
	 * Test restore of alarm with attached data
	 * [create utc alarm with data, backup, delete alarm, restore, check alarm & data]
	 * (Based on test case in TAlarmData.)
	 */
	doTestRestoreValidUtcAlarmDataL();

	/* 24.
	 * Baseline for Internalize behaviour
	 * [add alarms, shutdown, re-start alarm server, check local due time is unchanged]
	 */
	doTestUtcAlarmDSTShutdownStartupL();
	doTestFloatingAlarmDSTShutdownStartupHelsinkiL();

	// cleanup
	CleanupStack::PopAndDestroy(scheduler);
	CleanupStack::PopAndDestroy(BackupClient);
	TheAlarmTest.TestClearStoreL();
	}

//

/**

@SYMTestCaseID PIM-TBACKUPALARMS-0001

*/

GLDEF_C TInt E32Main()
    {
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if	(!cleanup)
		return KErrNoMemory;

	TheAlarmTest.Test().Title();
	TheAlarmTest.Test().Start(_L("@SYMTestCaseID:PIM-TBACKUPALARMS-0001 Backup Alarms"));
	// initialise globals
	FsSession.Connect();

	TheAlarmTest.Test().Next(_L("SECURE_DATA mode"));

	// actually do tests
	TRAPD(error, doTestsL());

	// Cleanup files
	// delete test file
	FsSession.Delete(KAlarmServerTestBackupFile);
	// delete AlarmServer.ini file
	FsSession.Delete(KAlarmServerBackupFileFullPath);
	FsSession.Close();

	// did any test Leave?
	TheAlarmTest(error == KErrNone, __LINE__);

	//
	TheAlarmTest.Test().End();
	TheAlarmTest.Test().Close();
	ASTstAlarmTest::Close();
	delete cleanup;
	__UHEAP_MARKEND;
	return KErrNone;
    }