// Copyright (c) 1999-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:

//

// System includes

#include <e32base.h>

#include <e32test.h>

#include <f32file.h>

#include <s32mem.h>

// User includes

#include <asshdalarm.h>

#include <asclisession.h>

#include <consolealarmalertservermain.h>

#include "testserver.h"

#include "ASTstAlarmTest.h"

// Type definitions

typedef void (*ThreadTestL)(void);

// Constants

const TUid KServerUid2={0x1000008D};

const TUid KServerUid3={0x101F502A};

const TUidType serverUid(KNullUid,KServerUid2,KServerUid3);

// Literal constants

_LIT(KTestTitle, "TAlarmRobustness");

_LIT(KRobustTestCreateServer, "Creating alarm server");

#ifdef _DEBUG

#ifdef __WINS__

_LIT(KRobustTestCloseServer, "Close alarm server");

#endif // #ifdef __WINS__

#endif // #ifdef _DEBUG

#ifdef _DEBUG

#ifdef __WINS__

_LIT(KTestIniFile, "c:\\private\\101f5027\\AlarmServer.ini");

_LIT(KAlarmIniFileDir, "c:\\private\\101f5027\\");

#endif // #ifdef __WINS__

#endif // #ifdef _DEBUG

// Globals

//static RTest TheAlarmTest(KTestTitle);

static RASCliSession TheAlarmServerSession;

const TInt KAlarmObjectBuffer = 512;

#ifdef _DEBUG

#ifdef __WINS__

const TInt KAlarmTestWaitForFileWrite = 2000000;

static void TestClearStoreL()

	{

	// Delete all alarms

	RArray<TAlarmCategory> categories;

	TheAlarmServerSession.GetAvailableCategoryListL(categories);

	const TInt KAlarmCategoriesCount = categories.Count();

	for(TInt i=0; i<KAlarmCategoriesCount; i++)

		{

		const TAlarmCategory category = categories[i];

		TheAlarmTest(TheAlarmServerSession.AlarmDeleteAllByCategory(category, EFalse) == KErrNone, __LINE__);

		}

	categories.Close();

	}

static void DeleteIniFileL()

	{

   	RPIMTestServer serv;

    User::LeaveIfError(serv.Connect());

    CleanupClosePushL(serv);

    serv.DeleteFileL(KTestIniFile);

	CleanupStack::PopAndDestroy(&serv);

	}

#endif // #ifdef __WINS__

#endif // #ifdef _DEBUG

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

void InitializeAlarm(TASShdAlarm& theAlarm)

	{

	theAlarm.Category() = KASCliCategoryClock;

	theAlarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatDaily;

	_LIT(KAlarmTestInit, "This is an alarm message - alarm 1");

	theAlarm.Message() = KAlarmTestInit;

	theAlarm.NextDueTime().HomeTime();

	theAlarm.NextDueTime() += TTimeIntervalMinutes(1);

	_LIT(KAlarmTestSoundName, "Arf Arf Woop");

	theAlarm.SoundName() = KAlarmTestSoundName;

	}

#ifdef _DEBUG

#ifdef __WINS__

static void CreateSingleTestAlarmL(TAlarmId& testID)

	{

	_LIT(KAlarmTestAddDisabled, "Adding disabled alarm");

	TheAlarmTest.Next(KAlarmTestAddDisabled);

	//

	TASShdAlarm alarm;

	InitializeAlarm(alarm);

	//

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm) == KErrNone, __LINE__);

	const TAlarmId id = alarm.Id();

	testID = id;

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	//

	_LIT(KAlarmTestGetDetails, "Get alarm details");

	TheAlarmTest.Next(KAlarmTestGetDetails);

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

	//

	_LIT(KAlarmTestEnableAlarm, "Enabling a disabled alarm");

	TheAlarmTest.Next(KAlarmTestEnableAlarm);

	TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(id, EAlarmStatusEnabled) == KErrNone, __LINE__);

	}

static void RunNoConfigFileTestL()

	{

	_LIT(KRobustTestNoConfig, "Run No Config File Test");

	TheAlarmTest.Next(KRobustTestNoConfig);

	// 1) Delete AlarmServer.ini file

	DeleteIniFileL();

	// 2) Connect to the alarm server.

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	// 3) Add alarm.

	TAlarmId testID = KNullAlarmId;

	CleanupClosePushL(TheAlarmServerSession);

	CreateSingleTestAlarmL(testID);

	// 4) Shutdown alarm server.

	TheAlarmTest.Next(KRobustTestCloseServer);

	TheAlarmServerSession.__DbgShutDownServer();

	CleanupStack::PopAndDestroy(&TheAlarmServerSession);

	// 5) Restart alarm server.

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	// 6) Check alarm has persisted.

	TASShdAlarm testAlarm;

	TInt error = TheAlarmServerSession.GetAlarmDetails(testID, testAlarm);

	TheAlarmTest(error == KErrNone, __LINE__);

	}

static void RunZeroLengthConfigFileTestL()

	{

	_LIT(KRobustTestZeroLengthConfigFile, "Run Zero Length Config File Test");

	TheAlarmTest.Next(KRobustTestZeroLengthConfigFile);

	// 1) Create an alarm to make sure there is a config file.

	TAlarmId testID = KNullAlarmId;

	CreateSingleTestAlarmL(testID);

	User::After(KAlarmTestWaitForFileWrite);

	// 2) Zero length the AlarmServer.ini file

   	TestClearStoreL();

	// 3) Connect to the alarm server.

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	// 4) Add alarm.

	CleanupClosePushL(TheAlarmServerSession);

	CreateSingleTestAlarmL(testID);

	// 5) Shutdown alarm server.

	TheAlarmTest.Next(KRobustTestCloseServer);

	TheAlarmServerSession.__DbgShutDownServer();

	CleanupStack::PopAndDestroy(&TheAlarmServerSession);

	// 6) Restart alarm server.

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	// 7) Check alarm has persisted.

	TASShdAlarm testAlarm;

	TInt error = TheAlarmServerSession.GetAlarmDetails(testID, testAlarm);

	TheAlarmTest(error == KErrNone, __LINE__);

	}

static void CorruptErrorConditionTestL()

	{

	_LIT(KRobustTestCorruptErrorCondition, "Corrupt Error Condition Test");

	TheAlarmTest.Next(KRobustTestCorruptErrorCondition);

	// 1) Create file session to call SetErrorCondition.

	TAlarmId testID = KNullAlarmId;

 	TInt error  = KErrCorrupt;

	RFs testFile;

	User::LeaveIfError(testFile.Connect());

	CleanupClosePushL(testFile);

	// 2) Create a few alarms to make sure we have populated config file.

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	CleanupClosePushL(TheAlarmServerSession);

	const TInt KNumberOfTestAlarms = 3;

	for( TInt i=0;i<KNumberOfTestAlarms;i++)

		{

		CreateSingleTestAlarmL(testID);

		}

	User::After(KAlarmTestWaitForFileWrite);

	// 3) Shut down server so we can re-connect and do internalization.

	TheAlarmServerSession.__DbgShutDownServer();

	CleanupStack::PopAndDestroy(&TheAlarmServerSession);

	// 4) Test loop - This will cycle through file session internalization

	//	process, checking to see that it leaves each time, instead of panicking.

	for (TInt failureCounter = 1 ; error == KErrCorrupt ; ++failureCounter)

		{

		testFile.SetErrorCondition(KErrCorrupt , failureCounter );

		error = TheAlarmServerSession.Connect();

		testFile.SetErrorCondition(KErrNone );

		}

	// 5) Close file session.

	CleanupStack::PopAndDestroy(&testFile);

	TheAlarmTest(error == KErrNone, __LINE__);

	}

static void ServerStartUpWithNoIniFileL()

	{

	_LIT(KRobustTestNoConfigDir, "Server Startup With No Config File Test");

	_LIT(KRobustTestDeleteIniFileDir, "Delete INI file and Dir");

	_LIT(KRobustTestDeleteIniFile, "Delete INI file");

	TheAlarmTest.Next(KRobustTestNoConfigDir);

	RPIMTestServer serv;

	User::LeaveIfError(serv.Connect());

	CleanupClosePushL(serv);

	// 1) Close Alarm Server

	TheAlarmTest.Start(KRobustTestCloseServer);

	TheAlarmServerSession.__DbgShutDownServer();

	// 2) Delete AlarmServer.ini file and it's dir

	TheAlarmTest.Next(KRobustTestDeleteIniFileDir);

	serv.DeleteFileL(KTestIniFile);

	serv.DeleteDirL(KAlarmIniFileDir);

	AlarmTest(serv.CheckForFile(KTestIniFile)==KErrPathNotFound);	//Check directory deleted

	// 3) Connect to the alarm server and check it created INI file directory

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	AlarmTest(serv.CheckForFile(KTestIniFile)==KErrNotFound);	//Check directory created but file still absent

	// 4) Add alarm and check INI file created

	TAlarmId testID = KNullAlarmId;

	TRequestStatus serverIniStatus;

	const TTimeIntervalMicroSeconds32 KTimeOutPeriod(1000000);

	RTimer timeoutTimer;

	CleanupClosePushL(timeoutTimer);

	TRequestStatus timerStatus;

	User::LeaveIfError(timeoutTimer.CreateLocal());

	timeoutTimer.After(timerStatus, KTimeOutPeriod);

	serv.FileServerNotifyChange(ENotifyFile, serverIniStatus, KTestIniFile);

	CreateSingleTestAlarmL(testID);

	User::WaitForRequest(timerStatus, serverIniStatus);

	if (timerStatus.Int() != KRequestPending)

		{

		// The file creation did not time out

		// so cancel the time out timer

		timeoutTimer.Cancel();

		User::WaitForRequest(timerStatus);

		}

	else

		{

		// The file creation timed out

		// so cancel the FileServerNotifyChange

		serv.FileServerNotifyChangeCancel();

		User::WaitForRequest(serverIniStatus);

		}

	AlarmTest(serv.CheckForFile(KTestIniFile)==KErrNone);	//Check file present

	// 6) Close Alarm Server Again

	TheAlarmTest.Next(KRobustTestCloseServer);

	TheAlarmServerSession.__DbgShutDownServer();

	// 7) Delete AlarmServer.ini file only

	TheAlarmTest.Next(KRobustTestDeleteIniFile);

	serv.DeleteFileL(KTestIniFile);

	AlarmTest(serv.CheckForFile(KTestIniFile)==KErrNotFound);	//Check file deleted but directory still there

	// 8) Connect to the alarm server

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	AlarmTest(serv.CheckForFile(KTestIniFile)==KErrNotFound);	//Check directory there but file still absent

	// 9) Add alarm and check INI file created

	testID = KNullAlarmId;

	serv.FileServerNotifyChange(ENotifyFile, serverIniStatus, KTestIniFile);

	timeoutTimer.After(timerStatus, KTimeOutPeriod);

	CreateSingleTestAlarmL(testID);

	User::WaitForRequest(timerStatus, serverIniStatus);

	if (timerStatus.Int() != KRequestPending)

		{

		// The file creation did not time out

		// so cancel the time out timer

		timeoutTimer.Cancel();

		User::WaitForRequest(timerStatus);

		}

	else

		{

		// The file creation timed out

		// so cancel the FileServerNotifyChange

		serv.FileServerNotifyChangeCancel();

		User::WaitForRequest(serverIniStatus);

		}

	AlarmTest(serv.CheckForFile(KTestIniFile)==KErrNone);	//Check file present

	TheAlarmTest.UpLevel();

	CleanupStack::PopAndDestroy(&timeoutTimer);

	CleanupStack::PopAndDestroy(&serv);

	serv.Close();

	}

#endif // #ifdef _DEBUG

#endif // #ifdef __WINS__

static void AlarmInternalizationTestL()

	{

	_LIT(KRobustTestAlarmInternalization, "Alarm Internalization Test");

	TheAlarmTest.Next(KRobustTestAlarmInternalization);

	// 1) Create an alarm object.

	TASShdAlarm alarm;

	TASShdAlarm alarm2;

	InitializeAlarm(alarm);

	// 2) Create a memory buffer to store alarm object created above.

	CBufFlat* buffer = CBufFlat::NewL(KAlarmObjectBuffer); // approximation

	CleanupStack::PushL(buffer);

	RBufWriteStream stream(*buffer);

	// 3) Externalize alarm object into memory buffer.

	alarm.ExternalizeL(stream);

	stream.CommitL();

	// 4) Create second memor`y buffer to manipulate the one above.

	CBufFlat* buffer2 = CBufFlat::NewL(KAlarmObjectBuffer);

	CleanupStack::PushL(buffer2);

	// 5) Test loop - Copy the contents of buffer to buffer2, starting at

	// 				the end of buffer.

	//    We just want to test that our methods leave normally under

	//    the error condition and not induce a panic. So we don't need

	//    to handle the Trap in this test loop.

	TInt err = KErrCorrupt;

	for(TInt i = buffer->Size()-1; i>-1; i--)

		{

		TPtr8 ptr=buffer->Ptr(i);

		buffer2->Reset();

		buffer2->InsertL(0, ptr);

		RBufReadStream rStream(*buffer2);

		TRAP(err, alarm2.InternalizeL(rStream))

		}

	TheAlarmTest.Test().Printf(_L("AlarmInternalizationTestL error = %d\n"), err);

	TheAlarmTest(err == KErrNone, __LINE__);

	CleanupStack::PopAndDestroy(buffer2);

	CleanupStack::PopAndDestroy(buffer);

	}

static void AlarmFormatInternalizationTestL()

	{

	_LIT(KRobustTestAlarmFormatInternalization, "Alarm Format Internalization Test");

	TheAlarmTest.Next(KRobustTestAlarmFormatInternalization);

	// 1) Create an alarm object.

	TASShdAlarm alarm;

	TASShdAlarm alarm2;

	InitializeAlarm(alarm);

	// 2) Create a memory buffer to store alarm object created above.

	CBufFlat* buffer = CBufFlat::NewL(KAlarmObjectBuffer); // approximation

	CleanupStack::PushL(buffer);

	RBufWriteStream stream(*buffer);

	// 3) Externalize alarm object into memory buffer.

	alarm.ExternalizeL(stream);

	stream.CommitL();

	// 4) Create second memory buffer to manipulate the one above.

	TPtr8 initPtr = buffer->Ptr(0); // Ptr to beginning of buffer.

	CBufFlat* buffer2 = CBufFlat::NewL(KAlarmObjectBuffer);

	CleanupStack::PushL(buffer2);

	// 5) Test loop - Write a character to every position of the

	//					alarm object.

	//    We just want to test that our methods leave normally under

	//    the error condition and not induce a panic. So we don't need

	//    to handle the Trap in this test loop.

	TInt err = KErrCorrupt;

	_LIT(KRobustTestCharactter, "a");

	const TInt KBufferSize = buffer->Size()-1;

	for(TInt i = 0; i<KBufferSize; i++)

		{

		alarm2.Reset();

		alarm2 = alarm;

		buffer2->Reset();

		buffer2->InsertL(0, initPtr);

		TPtr8 ptr = buffer2->Ptr(i);

		ptr.Copy(KRobustTestCharactter);

		RBufReadStream rStream(*buffer2);

		TRAP(err, alarm2.InternalizeL(rStream))

		}

	TheAlarmTest(err == KErrNone, __LINE__);

	CleanupStack::PopAndDestroy(buffer2);

	CleanupStack::PopAndDestroy(buffer);

	}

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

void InitializeUtcAlarm(TASShdAlarm& theAlarm)

	{

	theAlarm.Category()=KASCliCategoryClock;

	theAlarm.RepeatDefinition()=EAlarmRepeatDefintionRepeatDaily;

	_LIT(KAlarmTestInit, "This is a UTC alarm message - alarm 1");

	TBuf<KMaxAlarmMessageLength> buf(KAlarmTestInit);

	theAlarm.Message()=buf;

	TTime time;

	time.UniversalTime();

	time += TTimeIntervalMinutes(1);

	theAlarm.SetUtcNextDueTime(time);

	_LIT(KAlarmTestSoundName, "Arf Arf Woop");

	buf = KAlarmTestSoundName;

	theAlarm.SoundName()=buf;

	}

#ifdef _DEBUG

#ifdef __WINS__

static void CreateSingleTestUtcAlarmL(TAlarmId& testID)

	{

	_LIT(KAlarmTestAddDisabled, "Adding disabled UTC alarm");

	TheAlarmTest.Next(KAlarmTestAddDisabled);

	//

	TASShdAlarm alarm;

	InitializeUtcAlarm(alarm);

	//

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm) == KErrNone, __LINE__);

	const TAlarmId id = alarm.Id();

	testID = id;

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	//

	_LIT(KAlarmTestGetDetails, "Get UTC alarm details");

	TheAlarmTest.Next(KAlarmTestGetDetails);

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

	//

	_LIT(KAlarmTestEnableAlarm, "Enabling a disabled UTC alarm");

	TheAlarmTest.Next(KAlarmTestEnableAlarm);

	TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(id, EAlarmStatusEnabled) == KErrNone, __LINE__);

	}

static void RunNoConfigFileTestUtcL()

	{

	_LIT(KRobustTestNoConfig, "Run No Config File Test");

	TheAlarmTest.Next(KRobustTestNoConfig);

	// 1) Delete AlarmServer.ini file

   	DeleteIniFileL();

	// 2) Connect to the alarm server.

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	// 3) Add alarm.

	TAlarmId testID = KNullAlarmId;

	CleanupClosePushL(TheAlarmServerSession);

	CreateSingleTestUtcAlarmL(testID);

	// 4) Shutdown alarm server.

	TheAlarmTest.Next(KRobustTestCloseServer);

	TheAlarmServerSession.__DbgShutDownServer();

	CleanupStack::PopAndDestroy(&TheAlarmServerSession);

	// 5) Restart alarm server.

	TheAlarmTest.Next(KRobustTestCreateServer);

	User::LeaveIfError(TheAlarmServerSession.Connect());

	// 6) Check alarm has persisted.

	TASShdAlarm testAlarm;

	TInt error = TheAlarmServerSession.GetAlarmDetails(testID, testAlarm);