/*

* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

/**

 @file 

 @test

 @internalTechnology

*/

#include "tintegrityservicesstep.h"

#include <s32file.h>

#include "journal.h"

#include "journalfile.h"

/////////////////////////////////////////////////////////////////////

// CIntegrityServicesStep

/////////////////////////////////////////////////////////////////////

CIntegrityServicesStepBase::CIntegrityServicesStepBase(CStsTestServer &aStsTestServer):CStsBaseTestStep(aStsTestServer)

	{

	}

void CIntegrityServicesStepBase::ImplTestStepPreambleL()

	{

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::ImplTestStepPreambleL()"));

	__UHEAP_MARK;

	// Install an active scheduler

	CActiveScheduler* s = new (ELeave) CActiveScheduler;

	s->Install(s);

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

	ReadFailureSettingsL();	

	}

void CIntegrityServicesStepBase::ImplTestStepPostambleL()

	{

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::ImplTestStepPostambleL()"));

	// Remove the installed active scheduler

	CActiveScheduler* s = CActiveScheduler::Current();

	s->Install(NULL);

	delete s;

	iIntegritySession.Close();

__UHEAP_MARKEND;

	}

void CIntegrityServicesStepBase::GetStringArrayFromConfigL(const TDesC& aSectName, const TDesC& aKeyName, RArray<TPtrC>& aArray)

	{

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::GetStringArrayFromConfigL()"));

	_LIT(KKeyFormat, "-%02d");

	HBufC* buf = HBufC::NewLC(aKeyName.Length() + KKeyFormat().Length());

	TPtr ptr(buf->Des());

	INFO_PRINTF2(_L("Parsing attribute: %S"), &aKeyName);

	TInt i = 0;

	TBool cont = ETrue;

	do

		{

		++i;

		ptr = aKeyName;

		ptr.AppendFormat(KKeyFormat(), i);

		TPtrC val;

		cont = GetStringFromConfig(aSectName, ptr, val);

		if (cont)

			{

			User::LeaveIfError(aArray.Append(val));

			}

		} while (cont);

	INFO_PRINTF2(_L("Element count: %d"), i-1);

	CleanupStack::PopAndDestroy(buf);

	}

TBool CIntegrityServicesStepBase::CheckFilesL()

	{

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::CheckFilesL()"));

	TInt result = ETrue;

	RArray<TPtrC> fileArray;

	CleanupClosePushL(fileArray);

	GetStringArrayFromConfigL(ConfigSection(), KPresent, fileArray);

	for (TInt file = 0; file < fileArray.Count();file++)

		{

		if(FileExistsL(fileArray[file]))

			{

			INFO_PRINTF2(_L("%S was found"), &fileArray[file]);

			}

		else

			{

			ERR_PRINTF2(_L("%S was not found"), &fileArray[file]);

			result = EFalse;

			}

		}

	fileArray.Reset();

	GetStringArrayFromConfigL(ConfigSection(), KAbsent, fileArray);

	for (TInt file = 0; file < fileArray.Count();file++)

		{

		if(FileExistsL(fileArray[file]))

			{

			ERR_PRINTF2(_L("%S was found"), &fileArray[file]);

			result = EFalse;

			}

		else

			{

			INFO_PRINTF2(_L("%S was not found"), &fileArray[file]);

			}

		}

	fileArray.Reset();

	CleanupStack::PopAndDestroy(&fileArray);

	return result;

	}

void CIntegrityServicesStepBase::ReadFailureSettingsL()

	{		

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::ReadFailureSettings()"));

	TPtrC failType;

	if(!GetStringFromConfig(ConfigSection(), KFailType, failType))

		{

		failType.Set(KNullDesC);

		}

	TPtrC failPosition;

	if(!GetStringFromConfig(ConfigSection(), KFailPosition, failPosition))

		{

		failPosition.Set(KNullDesC);

		}

	TPtrC failFileName;

	if(!GetStringFromConfig(ConfigSection(), KFailFileName, failFileName))

		{

		failFileName.Set(KNullDesC);

		}

	iIntegritySession.SetSimulatedFailureL(failType, failPosition, failFileName);

	}

void CIntegrityServicesStepBase::doInstallL()

	{

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::doInstallL()"));

	RArray<TPtrC> fileArray;

	CleanupClosePushL(fileArray);

	GetStringArrayFromConfigL(ConfigSection(), KRemoveFile, fileArray);

	for (TInt file = 0; file < fileArray.Count();file++)

		{

		INFO_PRINTF2(_L("RemovingFile: %S"), &fileArray[file]);

		iIntegritySession.RemoveL(fileArray[file]);

		}

	fileArray.Reset();

	GetStringArrayFromConfigL(ConfigSection(), KAddFile, fileArray);

	for (TInt file = 0; file < fileArray.Count();file++)

		{

		INFO_PRINTF2(_L("AddingFile: %S"), &fileArray[file]);

		iIntegritySession.AddL(fileArray[file]);

		iIntegritySession.CreateNewTestFileL(fileArray[file]);

		}

	fileArray.Reset();

	GetStringArrayFromConfigL(ConfigSection(), KTempFile, fileArray);

	for (TInt file = 0; file < fileArray.Count();file++)

		{

		INFO_PRINTF2(_L("TemporaryFile: %S"), &fileArray[file]);

		iIntegritySession.TemporaryL(fileArray[file]);

		iIntegritySession.CreateTempTestFileL(fileArray[file]);

		}

	fileArray.Reset();

	RArray<TPtrC> operationArray;

	CleanupClosePushL(operationArray);

	GetStringArrayFromConfigL(ConfigSection(), KArbitraryOpFile, fileArray);

	GetStringArrayFromConfigL(ConfigSection(), KOperation, operationArray);

	TInt fileCount = fileArray.Count();

	if (fileCount != operationArray.Count())

		{

		ERR_PRINTF3(_L("Number of files (%d) does not match number of operations (%d)"), fileCount, operationArray.Count());

		SetTestStepResult(EFail);

		}

	else

		{

		for (TInt file = 0; file < fileCount;file++)

			{

			if (operationArray[file].CompareF(KAddFile) == 0)

				{

				INFO_PRINTF2(_L("AddingFile: %S"), &fileArray[file]);

				iIntegritySession.AddL(fileArray[file]);

				iIntegritySession.CreateNewTestFileL(fileArray[file]);

				}

			else if (operationArray[file].CompareF(KRemoveFile) == 0)

				{

				INFO_PRINTF2(_L("RemovingFile: %S"), &fileArray[file]);

				iIntegritySession.RemoveL(fileArray[file]);

				}

			else if (operationArray[file].CompareF(KTempFile) == 0)

				{

				INFO_PRINTF2(_L("TemporaryFile: %S"), &fileArray[file]);

				iIntegritySession.TemporaryL(fileArray[file]);

				iIntegritySession.CreateTempTestFileL(fileArray[file]);

				}

			else

				{

				ERR_PRINTF3(_L("Operation %S not understood, skipping file %S"), &operationArray[file], &fileArray[file]);

				}

			}

		}

	CleanupStack::PopAndDestroy(2, &fileArray);

	iIntegritySession.CommitL();

	}

void CIntegrityServicesStepBase::doRecoverL()

	{

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::doRecoverL()"));

	iIntegritySession.RollBackL(EFalse);

	}

void CIntegrityServicesStepBase::doCleanupL()

	{

	INFO_PRINTF1(_L("CIntegrityServicesStepBase::doCleanupL()"));

	RArray<TPtrC> fileArray;

	CleanupClosePushL(fileArray);

	GetStringArrayFromConfigL(ConfigSection(), KCleanupFile, fileArray);

	for (TInt file = 0; file < fileArray.Count();file++)

		{

		TRAPD(err, DeleteFileL(fileArray[file]));

		if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)

			{

			User::Leave(err);

			}

		}

	fileArray.Reset();

	GetStringArrayFromConfigL(ConfigSection(), KCleanupDirectory, fileArray);

	for (TInt file = 0; file < fileArray.Count();file++)

		{

		TRAPD(err, DeleteFileL(fileArray[file]));

		if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)

			{

			User::Leave(err);

			}

		}

	fileArray.Reset();

	CleanupStack::PopAndDestroy(&fileArray);

	}

/////////////////////////////////////////////////////////////////////

// CInstallStep

/////////////////////////////////////////////////////////////////////

CInstallStep::CInstallStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)

	{

	SetTestStepName(KInstall);

	}

void CInstallStep::ImplTestStepL()

	{

	INFO_PRINTF1(_L("CInstallStep::ImplTestStepL()"));

	TRAPD(err, doInstallL());

	if(err == KErrNone || err == KIntegrityServicesSimulatedBatteryFailure)

		{

		if(CheckFilesL())

			{

			SetTestStepResult(EPass);

			}

		else

			{

			SetTestStepResult(EFail);

			}

		}

	else

		{

		User::Leave(err);

		}

	}

/////////////////////////////////////////////////////////////////////

// CRecoverStep

/////////////////////////////////////////////////////////////////////

CRecoverStep::CRecoverStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)

	{

	SetTestStepName(KRecover);

	}

void CRecoverStep::ImplTestStepL()

	{

	INFO_PRINTF1(_L("CRecoverStep::ImplTestStepL()"));

	// begin recovery

	TRAPD(err, doRecoverL());

	if(err == KErrNone || err == KIntegrityServicesSimulatedBatteryFailure)

		{

		if(CheckFilesL())

			{

			SetTestStepResult(EPass);

			}

		else

			{

			SetTestStepResult(EFail);

			}

		}

	else

		{

		User::Leave(err);

		}

	}

/////////////////////////////////////////////////////////////////////

// CCleanupStep

/////////////////////////////////////////////////////////////////////

CCleanupStep::CCleanupStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)

	{

	SetTestStepName(KCleanup);

	}

void CCleanupStep::ImplTestStepL()

	{

	INFO_PRINTF1(_L("CCleanupStep::ImplTestStepL()"));

	doCleanupL();

	SetTestStepResult(EPass);

	}

/////////////////////////////////////////////////////////////////////

// CRecoverStep

/////////////////////////////////////////////////////////////////////

CCheckStep::CCheckStep(CStsTestServer &aStsTestServer):CIntegrityServicesStepBase(aStsTestServer)

	{

	SetTestStepName(KCheck);

	}

void CCheckStep::ImplTestStepL()

	{

	INFO_PRINTF1(_L("CCheckStep::ImplTestStepL()"));

	// Just check for files

	if(CheckFilesL())

		{

		SetTestStepResult(EPass);

		}

	else

		{

		SetTestStepResult(EFail);

		}

	}

//---------- new unit tests developed as part of the STS framework ----------

using namespace Usif;

//define event names for logging purposes (used in journal file unit tests and journal unit tests	

_LIT(KENone, "ENone");

_LIT(KERemovedFile,"ERemovedFile");

_LIT(KEBackupFile,"EBackupFile");

_LIT(KETempFile,"ETempFile");

_LIT(KEAddedFile,"EAddedFile");

_LIT(KECommitted,"ECommitted");

_LIT(KEBackupFilesRemoved,"EBackupFilesRemoved");

_LIT(KEAddedFilesRemoved,"EAddedFilesRemoved");

_LIT(KERemovedFilesRestored,"ERemovedFilesRestored");

_LIT(KETempFilesRemoved, "ETempFilesRemoved");

const TDesC* eventNames[] = {

				&KENone,

				&KERemovedFile,

				&KEBackupFile,

				&KETempFile,

				&KEAddedFile,

				&KECommitted,

				&KEBackupFilesRemoved,

				&KEAddedFilesRemoved,

				&KERemovedFilesRestored,

				&KETempFilesRemoved

				};

const TFileMode defaultJournalFileMode = TFileMode (TFileMode(EFileWrite) | TFileMode(EFileShareAny));

CJournalFileUnitTest::CJournalFileUnitTest(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer)

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KJournalFileUnitTest);

	}

CJournalFileUnitTest::~CJournalFileUnitTest()

	{

	delete testJournalFile;

	iFs.Close();

	iLoader.Close();

	}

void CJournalFileUnitTest::ImplTestStepPreambleL()

/**

 @return - void code

 Override of base class virtual

 */

	{

	INFO_PRINTF1(_L("JournalFileUnitTest Preamble"));

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

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

	testJournalFile = CTestFile::NewL(iFs);

	SetTestStepResult(EPass);

	}

void CJournalFileUnitTest::ImplTestStepL()

/**

 @return - void code

 Override of base class pure virtual

 */

	{

	INFO_PRINTF1(_L("JournalFileUnitTest in test step"));

	SetTestStepResult(EPass);

	TPtrC journalFilePathInIni = GetTargetFilePathFromConfigL();

	TParsePtrC journalFilePathParse(journalFilePathInIni);

	TDriveUnit journaldrive(journalFilePathParse.Drive());

	HBufC* targetFileName = HBufC::NewLC(KMaxFileName);

	HBufC* backupFileName = HBufC::NewLC(KMaxFileName);

	CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);

	//feed incorrect file to the journalfile (ie: file's on other drive)

	TPtr targetFileNameBasePtr(targetFileName->Des());

	targetFileNameBasePtr.Append(TDriveUnit(journaldrive+1).Name());

	targetFileNameBasePtr.Append(journalFilePathParse.Path());

	TPtr targetFileNamePtr(targetFileNameBasePtr);

	targetFileNamePtr.Append(_L("dummyadd.txt"));

	TPtr targetBackupFileNamePtr(backupFileName->Des());

	TInt err(0);

	TInt seekPosition(0);

	TInt seekToEndPosition(0);

	TIntValue intValue = {0};

	TIntValue extraByte = {0xFF};

	TRAP(err, journalFile->AddL(targetFileNamePtr));

	if(err!=KErrBadName)

		{

		ERR_PRINTF2(_L("<font color=red>CJournalFile::AddL() returned incorrect error code. KErrBadName is expected %d is returned!</font>"), err);

		SetTestStepResult(EFail);

		}

	targetFileNamePtr.Set(targetFileNameBasePtr);

	targetFileNamePtr.Append(_L("dummytemp.txt"));

	TRAP(err, journalFile->TemporaryL(targetFileNamePtr));

	if(err!=KErrBadName)

		{

		ERR_PRINTF2(_L("<font color=red>CJournalFile::RemoveL() returned incorrect error code. KErrBadName is expected %d is returned!</font>"), err);

		SetTestStepResult(EFail);

		}

	targetFileNamePtr.Set(targetFileNameBasePtr);

	targetFileNamePtr.Append(_L("dummyremove.txt"));

	TRAP(err, journalFile->RemoveL(targetFileNamePtr, targetBackupFileNamePtr));

	if(err!=KErrBadName)

		{

		ERR_PRINTF2(_L("<font color=red>CJournalFile::RemoveL() returned incorrect error code. KErrBadName is expected %d is returned!</font>"), err);

		SetTestStepResult(EFail);

		}

	*targetFileName = KEmptyString;

	targetFileNameBasePtr.Set(targetFileName->Des());

	targetFileNameBasePtr.Append(journalFilePathParse.DriveAndPath());

	CleanupStack::PopAndDestroy(journalFile);

	DeleteFileL(journalFilePathInIni);	

//-------------------------------------------------------------------------------------	

//Steps: 

//	1.) create a CJournalFile object

//	2.) set last event by invoking CJournalFile::EventL() (this sets the iLastEvent as well as writes the event value to the journal file on disk)

//	3.) destroy object 

//	4.) corrupt information by overwriting the event value in the file to requested invalid value

//	5.) recreate CjournalFile object -> this will trigger CJournalFile::ReadEntryL

//  note: the purpose of this testcase to excersise the main switch-case in CJournalFile::ReadEntryL		

//-------------------------------------------------------------------------------------

	TIntegrityServicesEvent eventsToSet[] = {ERemovedFile, 

											 EBackupFile, 

											 ETempFile,

											 EAddedFile,

											 ECommitted,

											 EBackupFilesRemoved,

											 EAddedFilesRemoved,

											 //ETempFilesRemoved,

											 ERemovedFilesRestored,

											 };

	TInt numOfInvalidEvents[] = {6, //number of invalid events for ERemovedFile

								 1, //number of invalid events for EBackupFile

								 6, //number of invalid events for ETempFile

								 6, //number of invalid events for EAddedFile

								 7, //number of invalid events for ECommitted

								 9, //number of invalid events for EBackupFilesRemoved

								 6, //number of invalid events for EAddedFilesRemoved

								 //ETempFilesRemoved