// 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();

	}

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