/*

* 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 "dummyintegrityservices.h"

//_LIT(KFailNone, "EFailNone");

_LIT(KFailAddingNewFile, "EFailAddingNewFile");

_LIT(KFailRemovingFile, "EFailRemovingFile");

_LIT(KFailAddingTempFile, "EFailAddingTempFile");

_LIT(KFailRestoringFile, "EFailRestoringFile");

_LIT(KFailDeletingFile, "EFailDeletingFile");

_LIT(KFailInstallComplete, "EFailInstallComplete");

_LIT(KFailNewFilesRemoved, "EFailNewFilesRemoved");

_LIT(KFailOldFilesRestored, "EFailOldFilesRestored");

_LIT(KFailTempFilesRemoved, "EFailTempFilesRemoved");

_LIT(KFailBackupFilesRemoved, "EFailBackupFilesRemoved");

_LIT(KFailBeforeJournal, "EBeforeJournal");

_LIT(KFailAfterJournal, "EAfterJournal");

_LIT(KFailBeforeAction, "EBeforeAction");

_LIT(KFailAfterAction, "EAfterAction");

using namespace Swi;

using namespace Swi::Test;

CDummyIntegrityServices* CDummyIntegrityServices::NewL(TInt64 aTransactionID, const TDesC& aPath)

	{

	CDummyIntegrityServices* self = CDummyIntegrityServices::NewLC(aTransactionID, aPath);

	CleanupStack::Pop(self);

	return self;

	}

CDummyIntegrityServices* CDummyIntegrityServices::NewLC(TInt64 aTransactionID, const TDesC& aPath)

	{

	CDummyIntegrityServices* self = new(ELeave) CDummyIntegrityServices(aTransactionID);

	CleanupStack::PushL(self);

	self->ConstructL(aPath);

	return self;

	}

CDummyIntegrityServices::CDummyIntegrityServices(TInt64 aTransactionID) : CIntegrityServices(aTransactionID)

	{

	}

void CDummyIntegrityServices::ConstructL(const TDesC& aPath)

	{

	CIntegrityServices::ConstructL(aPath);

	}

void CDummyIntegrityServices::SetSimulatedFailure(TPtrC16 aFailType, TPtrC16 aFailPosition, TPtrC16 aFailFileName)

	{

	if(aFailType.CompareF(KFailAddingNewFile) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailAddingNewFile;

		}

	else if(aFailType.CompareF(KFailRemovingFile) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailRemovingFile;

		}

	else if(aFailType.CompareF(KFailAddingTempFile) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailAddingTempFile;

		}

	else if(aFailType.CompareF(KFailRestoringFile) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailRestoringFile;

		}

	else if(aFailType.CompareF(KFailDeletingFile) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailDeletingFile;

		}

	else if(aFailType.CompareF(KFailInstallComplete) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailInstallComplete;

		}

	else if(aFailType.CompareF(KFailNewFilesRemoved) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailNewFilesRemoved;

		}

	else if(aFailType.CompareF(KFailOldFilesRestored) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailOldFilesRestored;

		}

	else if(aFailType.CompareF(KFailTempFilesRemoved) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailTempFilesRemoved;

		}

	else if(aFailType.CompareF(KFailBackupFilesRemoved) == 0)

		{

		iFailType = CDummyIntegrityServices::EFailBackupFilesRemoved;

		}

	else

		{

		// default to EFailNone

		iFailType = CDummyIntegrityServices::EFailNone;

		}

	if(aFailPosition.CompareF(KFailBeforeJournal) == 0)

		{

		iFailPosition = CDummyIntegrityServices::EBeforeJournal;

		}

	else if(aFailPosition.CompareF(KFailAfterJournal) == 0)

		{

		iFailPosition = CDummyIntegrityServices::EAfterJournal;

		}

	else if(aFailPosition.CompareF(KFailBeforeAction) == 0)

		{

		iFailPosition = CDummyIntegrityServices::EBeforeAction;

		}

	else if(aFailPosition.CompareF(KFailAfterAction) == 0)

		{

		iFailPosition = CDummyIntegrityServices::EAfterAction;

		}

	else

		{

		if(iFailType != CDummyIntegrityServices::EFailNone)

			{

			// scripting error, FailType specified without FailPosition

			User::Leave(KErrCorrupt);

			}

		}

	iFailFileName = aFailFileName;

	}

void CDummyIntegrityServices::SimulatePowerFailureL(TFailType aFailType, TFailPosition aFailPosition, const TDesC& aFailFileName)

	{

	if(iFailType == aFailType && iFailPosition == aFailPosition && iFailFileName == aFailFileName)

		{

		User::Leave(KIntegrityServicesSimulatedBatteryFailure);

		}

	}

void CDummyIntegrityServices::CreateNewTestFileL(TDesC& aFileName)

	{

	if (aFileName.Length() > 0 && aFileName[aFileName.Length() - 1] == KPathDelimiter)

		{  // A new test directory is created

		User::LeaveIfError(iFs.MkDir(aFileName));

		}

	else

		{  // A new test file is created

		RFile newFile;

		CleanupClosePushL(newFile);

		SimulatePowerFailureL(EFailAddingNewFile, EBeforeAction, aFileName);

		User::LeaveIfError(newFile.Create(iFs, aFileName, EFileWrite));

		SimulatePowerFailureL(EFailAddingNewFile, EAfterAction, aFileName);

		CleanupStack::PopAndDestroy(&newFile);		

		}

	}

void CDummyIntegrityServices::CreateTempTestFileL(TDesC& aFileName)

	{

	RFile tempFile;

	CleanupClosePushL(tempFile);

	SimulatePowerFailureL(EFailAddingTempFile, EBeforeAction, aFileName);

	User::LeaveIfError(tempFile.Create(iFs, aFileName, EFileWrite));

	SimulatePowerFailureL(EFailAddingTempFile, EAfterAction, aFileName);

	CleanupStack::PopAndDestroy(&tempFile);

	}