/*
* 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 "dummyintegrityservices.h"
#include <test/testexecutelog.h>
#include <s32file.h>
#include "testutilclientswi.h"


/////////////////////////////////////////////////////////////////////
// Tags used by test steps
/////////////////////////////////////////////////////////////////////

_LIT(KRemoveFile, "removefile");
_LIT(KTempFile, "temporaryfile");
_LIT(KAddFile, "addfile");
_LIT(KFailType, "failtype");
_LIT(KFailPosition, "failposition");
_LIT(KFailFileName, "failfilename");
_LIT(KPresent, "present");
_LIT(KAbsent, "absent");
_LIT(KCleanupFile, "cleanupfile");
_LIT(KCleanupDirectory, "cleanupdirectory");
_LIT(KArbitraryOpFile, "arbitraryopfile");
_LIT(KOperation, "operation");

using namespace Swi;
using namespace Swi::Test;

/////////////////////////////////////////////////////////////////////
// CIntegrityServicesStep
/////////////////////////////////////////////////////////////////////
TVerdict CIntegrityServicesStepBase::doTestStepPreambleL()
	{
	__UHEAP_MARK;

	// Install an active scheduler
	CActiveScheduler* s = new (ELeave) CActiveScheduler;
	s->Install(s);
	
	User::LeaveIfError(iIntegritySession.Connect());

	ReadFailureSettings();
	return TestStepResult();
	}

TVerdict CIntegrityServicesStepBase::doTestStepPostambleL()
	{
	// Remove the installed active scheduler
	CActiveScheduler* s = CActiveScheduler::Current();
	s->Install(NULL);
	delete s;

	iIntegritySession.Close();

	__UHEAP_MARKEND;

	return TestStepResult();
	}

void CIntegrityServicesStepBase::GetStringArrayFromConfigL(const TDesC& aSectName, const TDesC& aKeyName, RArray<TPtrC>& aArray)
	{
	_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()
	{
	TInt result = ETrue;
	RTestUtilSessionSwi testutil;
	User::LeaveIfError(testutil.Connect());
	CleanupClosePushL(testutil);
	RArray<TPtrC> fileArray;
	CleanupClosePushL(fileArray);
	
	GetStringArrayFromConfigL(ConfigSection(), KPresent, fileArray);
	for (TInt file = 0; file < fileArray.Count();file++)
		{
		if(testutil.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(testutil.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);
	
	CleanupStack::PopAndDestroy(&testutil);
	return result;
	}

void 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.SetSimulatedFailure(failType, failPosition, failFileName);
	}
	
void 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()
	{
	RArray<TPtrC> fileArray;
	CleanupClosePushL(fileArray);
	
	RTestUtilSessionSwi testutil;
	User::LeaveIfError(testutil.Connect());
	CleanupClosePushL(testutil);
	
	GetStringArrayFromConfigL(ConfigSection(), KCleanupFile, fileArray);
	for (TInt file = 0; file < fileArray.Count();file++)
		{
		TInt err = testutil.Delete(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++)
		{
		TInt err = testutil.RmDir(fileArray[file]);
		if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)
			{
			User::Leave(err);
			}
		}
	fileArray.Reset();

	CleanupStack::PopAndDestroy(&testutil);
	CleanupStack::PopAndDestroy(&fileArray);
	}

/////////////////////////////////////////////////////////////////////
// CInstallStep
/////////////////////////////////////////////////////////////////////
CInstallStep::CInstallStep()
	{
	SetTestStepName(KInstall);
	}

TVerdict CInstallStep::doTestStepL()
	{
	TRAPD(err, doInstallL());
	
	if(err == KErrNone || err == KIntegrityServicesSimulatedBatteryFailure)
		{
		if(CheckFilesL())
			{
			SetTestStepResult(EPass);
			}
		else
			{
			SetTestStepResult(EFail);
			}
		}
	else
		{
		User::Leave(err);
		}
	return TestStepResult();
	}

/////////////////////////////////////////////////////////////////////
// CRecoverStep
/////////////////////////////////////////////////////////////////////
CRecoverStep::CRecoverStep()
	{
	SetTestStepName(KRecover);
	}

TVerdict CRecoverStep::doTestStepL()
	{
	// begin recovery
	TRAPD(err, doRecoverL());
	
	if(err == KErrNone || err == KIntegrityServicesSimulatedBatteryFailure)
		{
		if(CheckFilesL())
			{
			SetTestStepResult(EPass);
			}
		else
			{
			SetTestStepResult(EFail);
			}
		}
	else
		{
		User::Leave(err);
		}

	return TestStepResult();
	}

/////////////////////////////////////////////////////////////////////
// CCleanupStep
/////////////////////////////////////////////////////////////////////
CCleanupStep::CCleanupStep()
	{
	SetTestStepName(KCleanup);
	}

TVerdict CCleanupStep::doTestStepL()
	{
	doCleanupL();
	
	SetTestStepResult(EPass);
	return TestStepResult();
	}

/////////////////////////////////////////////////////////////////////
// COOMStep
/////////////////////////////////////////////////////////////////////
COOMStep::COOMStep()
	{
	SetTestStepName(KOOM);
	}

TVerdict COOMStep::doTestStepL()
	{
	const TInt maxFailCount = 200;

	__UHEAP_MARK;

	TInt installFailCount = 0;
	TInt installResult = KErrNoMemory;

	while(installResult != KErrNone && installFailCount < maxFailCount)
		{
		INFO_PRINTF2(_L("OOM InstallFailCount: %d"), installFailCount);
				
		__UHEAP_MARK;
		
		__UHEAP_FAILNEXT(installFailCount);

		TRAP(installResult, doInstallL());
		
		__UHEAP_MARKEND;

		__UHEAP_RESET;
		
		if(installResult == KErrNone)
			{
			if(CheckFilesL())
				{
				SetTestStepResult(EPass);
				}
			else
				{
				SetTestStepResult(EFail);
				}

			doCleanupL();
			}
		else if(installResult == KErrNoMemory)
			{
			// recover any partial installation, again testing oom
			TInt recoverFailCount = 0;
			TInt recoverResult = KErrNoMemory;
			
			while(recoverResult != KErrNone && recoverFailCount < maxFailCount)
				{
				INFO_PRINTF2(_L("OOM RecoverFailCount: %d"), recoverFailCount);
		
				__UHEAP_MARK;
		
				__UHEAP_FAILNEXT(recoverFailCount);

				TRAP(recoverResult, doRecoverL());
			
				__UHEAP_MARKEND;

				__UHEAP_RESET;
		
				// Fail further into the test
				recoverFailCount++;
				}
			}
		else
			{
			User::Leave(installResult);
			}
		
		
		// Fail further into the test
		installFailCount++;
		}
	__UHEAP_MARKEND;
				
	SetTestStepResult(EPass);
	return TestStepResult();
	}
	
/////////////////////////////////////////////////////////////////////
// CRecoverStep
/////////////////////////////////////////////////////////////////////
CCheckStep::CCheckStep()
	{
	SetTestStepName(KCheck);
	}

TVerdict CCheckStep::doTestStepL()
	{
	// Just check for files
	if(CheckFilesL())
		{
		SetTestStepResult(EPass);
		}
	else
		{
		SetTestStepResult(EFail);
		}
		
	return TestStepResult();
	}