--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swtransactionservices/test/tintegrityservices/source/tintegrityservicesstep.cpp	Fri Mar 19 09:33:35 2010 +0200
@@ -0,0 +1,1487 @@
+/*
+* 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
+								 9 //number of invalid events for ERemovedFilesRestored
+	                             };
+	TIntegrityServicesEvent invalidEvents[][10] = {{EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for ERemovedFile
+			                                        {EBackupFile}, //invalid events for EBackupFile, this is not really invalid value for EBackupFile, actually EBackupFile itself is invalid on its own in the file
+													{EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for ETempFile
+													{EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for EAddedFile
+													{ENone, EBackupFile, ECommitted, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for ECommitted
+													{ENone, ERemovedFile, EBackupFile, ETempFile, EAddedFile, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for EBackupFilesRemoved
+													{ENone, EBackupFile, EBackupFilesRemoved, EAddedFilesRemoved, ERemovedFilesRestored, ETempFilesRemoved}, //invalid events for EAddedFilesRemoved
+													//{}, //invalid events for ETempFilesRemoved
+													{ENone, ERemovedFile, EBackupFile, ETempFile, EAddedFile, ECommitted, EBackupFilesRemoved, ETempFilesRemoved, ERemovedFilesRestored} //invalid events for ERemovedFilesRestored
+	                                               };
+	
+	ASSERT(sizeof(eventsToSet)/sizeof(TIntegrityServicesEvent) == sizeof(numOfInvalidEvents)/sizeof(TInt) == sizeof(invalidEvents)/(sizeof(TIntegrityServicesEvent)*10));
+	for (TInt i=0; i<sizeof(eventsToSet)/sizeof(TIntegrityServicesEvent); ++i)
+	{
+	for(TInt j=0; j<numOfInvalidEvents[i]; ++j)
+		{
+		journalFile=0;
+		journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+		journalFile->EventL(invalidEvents[i][j]); //set last event to any of the requested invalid events (also writes it to jounral file)
+		CleanupStack::PopAndDestroy(journalFile);
+		intValue.int32 = static_cast<TInt32>(eventsToSet[i]);
+		seekPosition=0;
+		OpenJournalFileL(journalFilePathInIni, defaultJournalFileMode);
+		SeekInJournalFileL(ESeekStart, seekPosition);
+		WriteIntToJournalFileL(intValue, Mode32Bit); //write the requested event to journal file (overwrites last event set by EventL())
+		seekToEndPosition=0;
+		SeekInJournalFileL(ESeekEnd, seekToEndPosition);
+		WriteIntToJournalFileL(extraByte, Mode8Bit);
+		CloseJournalFile();
+		//force a Sync and catch the error that should be KErrCorrupt
+		journalFile=0;
+		TRAPD(err, 
+				journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+				CleanupStack::PopAndDestroy(journalFile);
+				);
+		if(err!=KErrCorrupt)
+			{
+			ERR_PRINTF4(_L("<font color=red>CJournalFile::SynchL() returned incorrect error code. KErrCorrupt is expected and %d is returned! Conditions: last event set via EventL(): %S  Event written into journal file: %S</font>"), err, eventNames[invalidEvents[i][j]], eventNames[eventsToSet[i]]);
+			SetTestStepResult(EFail);
+			}
+		DeleteFileL(journalFilePathInIni);
+		}
+	}	
+//-------------------------------------------------------------------------------------	
+//Steps: 
+//	1.) create a journal file using CJournalFile::NewLC
+//  2.) add an item via AddL() or TemporaryL()	
+//	2.) corrupt disk information in the filename written into the file
+//	3.) try to recreate journal object using CJournalFile::NewLC
+//	4.) expect KErrCorrupt
+//-------------------------------------------------------------------------------------
+
+	targetFileNamePtr.Set(targetFileNameBasePtr);
+	targetFileNamePtr.Append(_L("dummyadd_or_temp.txt"));
+	for(TInt i=0; i<2; i++)
+		{
+		//create a journal file and add an item via AddL() or TemporaryL()
+		journalFile=0;
+		journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+		if(i==0)
+			{
+			journalFile->AddL(targetFileNamePtr);
+			}
+		else if(i==1)
+			{
+			journalFile->TemporaryL(targetFileNamePtr);
+			}
+		CleanupStack::PopAndDestroy(journalFile);
+		//open journal file and corrupt it by overwriting the drive letter in the file's path
+		seekPosition=sizeof(TInt32)+1;
+		OpenJournalFileL(journalFilePathInIni, defaultJournalFileMode);
+		SeekInJournalFileL(ESeekStart, seekPosition);
+		intValue = ReadIntFromJournalFileL(Mode8Bit);
+		intValue.int8++; //corrupt drive letter (ie: 'c' ==> 'd')
+		SeekInJournalFileL(ESeekStart, seekPosition);
+		WriteIntToJournalFileL(intValue, Mode8Bit);
+		CloseJournalFile();
+		//check that CJournalFile recognizes corruption
+		journalFile=0;
+		TRAP(err, 
+				  journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+		          CleanupStack::PopAndDestroy(journalFile);
+			 );
+		if(err!=KErrCorrupt)
+			{
+			ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
+			SetTestStepResult(EFail);
+			}
+		DeleteFileL(journalFilePathInIni);
+		}
+//-------------------------------------------------------------------------------------	
+//Steps: 
+//	1.) create a journal file using CJournalFile::NewLC
+//  2.) add an item via RemoveyL()	
+//	2.) corrupt disk information in various ways in the file
+//	3.) try to recreate journal object using CJournalFile::NewL
+//	4.) expect KErrCorrupt
+//-------------------------------------------------------------------------------------
+
+	journalFile=0;
+	journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+	targetFileNamePtr.Set(targetFileNameBasePtr);
+	targetFileNamePtr.Append(_L("dummyremove.txt"));
+	journalFile->RemoveL(targetFileNamePtr, targetBackupFileNamePtr);
+	CleanupStack::PopAndDestroy(journalFile);
+
+	OpenJournalFileL(journalFilePathInIni, defaultJournalFileMode);
+	seekPosition=sizeof(TInt32)+1+targetFileNamePtr.Length();
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	intValue.int32 = static_cast<TInt32>(EAddedFile); //corrupt operation: originally EBackupFile is recorded here
+	WriteIntToJournalFileL(intValue, Mode32Bit);
+	
+	//check that CJournalFile recognizes corruption
+	journalFile=0;
+	TRAP(err, 
+			journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+    		CleanupStack::PopAndDestroy(journalFile);
+		);
+	if(err!=KErrCorrupt)
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	intValue.int32 = static_cast<TInt32>(EBackupFile); //restore original record
+	WriteIntToJournalFileL(intValue, Mode32Bit);
+
+	//check that journal file is not corrupted
+	journalFile=0;
+	TRAP(err, 
+			journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+    		CleanupStack::PopAndDestroy(journalFile);
+		);
+	if(err!=KErrNone)
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrNone is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+
+	seekPosition=sizeof(TInt32)+1;
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	intValue = ReadIntFromJournalFileL(Mode8Bit); //read first file's drive letter
+	intValue.int8++; //corrupt drive letter (ie: 'c' ==> 'd')
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	WriteIntToJournalFileL(intValue, Mode8Bit); //write corrupt drive letter to file
+
+	//check that CJournalFile recognizes corruption
+	journalFile=0;
+	TRAP(err, 
+			journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+    		CleanupStack::PopAndDestroy(journalFile);
+		);
+	if(err!=KErrCorrupt)
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+
+	intValue.int8--; //restore original drive letter
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	WriteIntToJournalFileL(intValue, Mode8Bit); //write original drive letter to file
+
+		
+	//check that journal file is not corrupted
+	journalFile=0;
+	TRAP(err, 
+			journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+    		CleanupStack::PopAndDestroy(journalFile);
+		);
+	if(err!=KErrNone)
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrNone is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+
+	seekPosition=sizeof(TInt32)+1+targetFileNamePtr.Length()+sizeof(TInt32)+1;
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	intValue = ReadIntFromJournalFileL(Mode8Bit); //read second file's drive letter (backup file name)
+	intValue.int8++; //corrupt drive letter (ie: 'c' ==> 'd')
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	WriteIntToJournalFileL(intValue, Mode8Bit); //write corrupt drive letter to file
+
+	
+	//check that CJournalFile recognizes corruption
+	journalFile=0;
+	TRAP(err, 
+			journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+    		CleanupStack::PopAndDestroy(journalFile);
+		);
+	if(err!=KErrCorrupt)
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+	
+	intValue.int8--; //restore original drive letter
+	SeekInJournalFileL(ESeekStart, seekPosition);
+	WriteIntToJournalFileL(intValue, Mode8Bit); //write original drive letter to file
+
+	//check that journal file is not corrupted
+	journalFile=0;
+	TRAP(err, 
+			journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+    		CleanupStack::PopAndDestroy(journalFile);
+		);
+	if(err!=KErrNone)
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrNone is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+	CloseJournalFile();
+	INFO_PRINTF1(_L("Deleting journal file - Line 769"));
+	DeleteFileL(journalFilePathInIni);
+
+	
+	CreateJournalFileL(journalFilePathInIni, TFileMode(TFileMode(EFileWrite) | TFileMode(EFileShareExclusive)));
+	journalFile=0;
+	TRAP(err, 
+			journalFile = CJournalFile::NewLC(iFs, iLoader, journalFilePathInIni, journaldrive);
+    		CleanupStack::PopAndDestroy(journalFile);
+		);
+	if(err!=KErrInUse )
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournalFile::NewL() returned incorrect error code. KErrInUse is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+	CloseJournalFile();
+	INFO_PRINTF1(_L("Deleting journal file - Line 783"));
+	DeleteFileL(journalFilePathInIni);
+
+	CleanupStack::PopAndDestroy(2, targetFileName);
+	}
+
+void CJournalFileUnitTest::ImplTestStepPostambleL()
+/**
+ @return - void code
+ Override of base class virtual
+ */
+	{
+	INFO_PRINTF1(_L("JournalFileUnitTest Postamble"));
+	delete testJournalFile;
+	testJournalFile=0;
+	iFs.Close();
+	iLoader.Close();
+	}
+
+void CJournalFileUnitTest::OpenJournalFileL(const TDesC& aFileName, TFileMode aMode)
+	{
+	testJournalFile->OpenJournalFileL(aFileName, aMode);
+	}
+
+void CJournalFileUnitTest::CreateJournalFileL(const TDesC& aFileName, TFileMode aMode)
+	{
+	testJournalFile->CreateJournalFileL(aFileName, aMode);
+	}
+
+void CJournalFileUnitTest::SeekInJournalFileL(TSeek aSeekMode, TInt &aPos)
+	{
+	testJournalFile->SeekInJournalFileL(aSeekMode, aPos);
+	}
+
+TIntValue CJournalFileUnitTest::ReadIntFromJournalFileL(TIntMode mode)
+	{
+	return testJournalFile->ReadIntFromJournalFileL(mode);
+	}
+
+void CJournalFileUnitTest::CloseJournalFile()
+	{
+	testJournalFile->CloseJournalFile();
+	}
+
+void CJournalFileUnitTest::WriteIntToJournalFileL(TIntValue value, TIntMode mode)
+	{
+	testJournalFile->WriteIntToJournalFileL(value, mode);
+	}
+
+
+
+/*static*/ CTestFile* CTestFile::NewL(RFs& aFs)
+	{
+	CTestFile* self = new(ELeave) CTestFile(aFs);
+	return self;
+	}
+
+CTestFile::CTestFile(RFs& aFs): iFs(aFs)
+	{
+	
+	}
+
+CTestFile::~CTestFile()
+	{
+	CloseJournalFile();
+	}
+
+void CTestFile::OpenJournalFileL(const TDesC& aFileName, TFileMode aMode)
+	{
+	TInt err = journalFile.Open(iFs, aFileName, aMode);
+	User::LeaveIfError(err);
+	}
+
+void CTestFile::CreateJournalFileL(const TDesC& aFileName, TFileMode aMode)
+	{
+	TInt err = iFs.MkDirAll(aFileName);
+	if(err != KErrNone && err != KErrAlreadyExists)
+		{
+		User::Leave(err);
+		}
+	err = journalFile.Create(iFs, aFileName, aMode);
+	User::LeaveIfError(err);
+	}
+
+void CTestFile::CloseJournalFile()
+	{
+	journalFile.Close();
+	}
+
+void CTestFile::WriteIntToJournalFileL(TIntValue value, TIntMode mode)
+	{
+	HBufC8* fileIOBuffer = HBufC8::NewLC(10);
+	TPtr8  fileIOBufferPtr(fileIOBuffer->Des());
+	TPckgC<TInt32> pckg(value.int32);
+	
+	switch(mode)
+		{
+		case Mode8Bit:
+		case Mode16Bit:
+		case Mode32Bit:
+			fileIOBufferPtr.Append(pckg);
+			User::LeaveIfError(journalFile.Write(fileIOBufferPtr, static_cast<TInt>(mode)));
+			break;
+		default:
+			User::Leave(KErrArgument);
+			break;
+		}
+	
+	CleanupStack::PopAndDestroy(fileIOBuffer);
+	}
+
+TIntValue CTestFile::ReadIntFromJournalFileL(TIntMode mode)
+	{
+	HBufC8* fileIOBuffer = HBufC8::NewLC(10);
+	TPtr8  fileIOBufferPtr(fileIOBuffer->Des());
+	User::LeaveIfError(journalFile.Read(fileIOBufferPtr, static_cast<TInt>(mode)));
+	TIntValue ret = {0};
+	
+	switch(mode)
+		{
+		case Mode8Bit: 
+		case Mode16Bit:
+		case Mode32Bit:
+			{
+			for(TInt i=0; i<static_cast<TInt>(mode); ++i)
+				{
+				ret.int32 |=  TInt32((*fileIOBuffer)[i]) << (8*i);
+				}
+			break;
+			}
+		default:
+			User::Leave(KErrArgument);
+			break;
+		}
+	CleanupStack::PopAndDestroy(fileIOBuffer);
+	return ret;
+	}
+	
+void CTestFile::SeekInJournalFileL(TSeek aSeekMode, TInt &aPos)
+	{
+	User::LeaveIfError(journalFile.Seek(aSeekMode, aPos));
+	}
+
+
+
+//------------------------------------------------------------------------------------------------------------
+
+CJournalFileUnitTestScenarioBase::CJournalFileUnitTestScenarioBase(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer), iCleanupNeeded(ETrue)
+	{
+	}
+
+CJournalFileUnitTestScenarioBase::~CJournalFileUnitTestScenarioBase()
+	{
+	iFs.Close();
+	iLoader.Close();
+	delete iTargetFileName;
+	delete iBackupFileName;
+	}
+
+
+void CJournalFileUnitTestScenarioBase::ImplTestStepPreambleL()
+	{
+	INFO_PRINTF1(_L("CJournalFileUnitTestScenarioBase Preamble"));
+	iJournalFileName.Set(GetTargetFilePathFromConfigL());
+	User::LeaveIfError(iFs.Connect());
+	User::LeaveIfError(iLoader.Connect());
+	iTargetFileName = HBufC::NewL(KMaxFileName);
+	iBackupFileName = HBufC::NewL(KMaxFileName);
+	TParsePtrC journalFilePathParse(iJournalFileName);
+	TPtr ptr(iTargetFileName->Des());
+	ptr.Append(journalFilePathParse.DriveAndPath());
+	ptr.Append(_L("journalfile_oom_test_dummyfile.txt"));
+	iJournaldrive = journalFilePathParse.Drive();
+	SetTestStepResult(EPass);
+	
+	}
+
+void CJournalFileUnitTestScenarioBase::ImplTestStepL()
+	{
+	CleanupStack::PushL(TCleanupItem(&CJournalFileUnitTestScenarioBase::InTestCleanup, this));
+	ImplTestCaseScenarioL();
+	CleanupStack::PopAndDestroy(this);
+	}
+
+void CJournalFileUnitTestScenarioBase::ImplTestStepPostambleL()
+	{
+	INFO_PRINTF1(_L("CJournalFileUnitTestScenarioBase Postamble"));
+	
+	delete iTargetFileName; 
+	iTargetFileName=0;
+	delete iBackupFileName; 
+	iBackupFileName=0;
+	iFs.Close();
+	iLoader.Close();
+	TRAP_IGNORE(DeleteFileL(iJournalFileName));
+	}
+
+/*static*/void CJournalFileUnitTestScenarioBase::InTestCleanup(TAny* aObject)
+	{
+	CJournalFileUnitTestScenarioBase* object=static_cast<CJournalFileUnitTestScenarioBase*>(aObject);
+	object->INFO_PRINTF1(_L("CJournalFileUnitTestScenarioBase::InTestCleanup()"));
+	if(object->iCleanupNeeded)
+		{
+		TRAP_IGNORE(object->DeleteFileL(object->iJournalFileName));
+		}
+	}
+
+//------------------------------------------------------------------------------------------------------------
+CJournalFileUnitTestAdd::CJournalFileUnitTestAdd(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
+	{
+	SetTestStepName(KJournalFileUnitTestAdd);
+	}
+void CJournalFileUnitTestAdd::ImplTestCaseScenarioL()
+	{
+	INFO_PRINTF1(_L("CJournalFileUnitTestAdd in test step"));
+	CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
+	journalFile->AddL(*iTargetFileName);
+	CleanupStack::PopAndDestroy(journalFile);
+	}
+//------------------------------------------------------------------------------------------------------------
+CJournalFileUnitTestTemp::CJournalFileUnitTestTemp(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
+	{
+	SetTestStepName(KJournalFileUnitTestTemp);
+	}
+
+void CJournalFileUnitTestTemp::ImplTestCaseScenarioL()
+	{
+	INFO_PRINTF1(_L("CJournalFileUnitTestTemp in test step"));
+	CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
+	journalFile->TemporaryL(*iTargetFileName);
+	CleanupStack::PopAndDestroy(journalFile);
+	}
+
+//------------------------------------------------------------------------------------------------------------
+CJournalFileUnitTestRemove::CJournalFileUnitTestRemove(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
+	{
+	SetTestStepName(KJournalFileUnitTestRemove);
+	}
+
+void CJournalFileUnitTestRemove::ImplTestCaseScenarioL()
+	{
+	INFO_PRINTF1(_L("CJournalFileUnitTestRemove in test step"));
+	TPtr backupFileNamePtr(iBackupFileName->Des());
+	CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
+	journalFile->RemoveL(*iTargetFileName, backupFileNamePtr);
+	CleanupStack::PopAndDestroy(journalFile);
+	}
+//------------------------------------------------------------------------------------------------------------
+CJournalFileUnitTestRead::CJournalFileUnitTestRead(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
+	{
+	iCleanupNeeded=EFalse;
+	SetTestStepName(KJournalFileUnitTestRead);
+	}
+
+void CJournalFileUnitTestRead::ImplTestCaseScenarioL()
+	{
+	INFO_PRINTF1(_L("CJournalFileUnitTestRead in test step"));
+	CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
+	CleanupStack::PopAndDestroy(journalFile);
+	}
+//------------------------------------------------------------------------------------------------------------
+CJournalFileUnitTestEvent::CJournalFileUnitTestEvent(CStsTestServer &aStsTestServer): CJournalFileUnitTestScenarioBase(aStsTestServer)
+	{
+	}
+
+void CJournalFileUnitTestEvent::ImplTestCaseScenarioL()
+	{
+	INFO_PRINTF1(_L("CJournalFileUnitTestEvent in test step"));
+	CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, iJournalFileName, iJournaldrive);
+	journalFile->EventL(ECommitted);
+	CleanupStack::PopAndDestroy(journalFile);
+	}
+//------------------------------------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------------------------------------
+CJournalUnitTest::CJournalUnitTest(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer)
+	{
+	// Call base class method to set up the human readable name for logging
+	SetTestStepName(KJournalUnitTest);
+	}
+
+CJournalUnitTest::~CJournalUnitTest()
+	{
+	delete iTestFileInterface;
+	iFs.Close();
+	iLoader.Close();
+	}
+
+void CJournalUnitTest::ImplTestStepPreambleL()
+	{
+	INFO_PRINTF1(_L("JournalFileUnitTest Preamble"));
+	iJournalPathInIni.Set(GetTargetFilePathFromConfigL());
+	iTrID = GetTransactionIdFromConfigL();
+	User::LeaveIfError(iFs.Connect());
+	User::LeaveIfError(iLoader.Connect());
+	iTestFileInterface = CTestFile::NewL(iFs);
+	SetTestStepResult(EPass);
+	
+	}
+
+void CJournalUnitTest::ImplTestStepL()
+	{
+	INFO_PRINTF1(_L("JournalUnitTest in test step"));
+	SetTestStepResult(EPass);
+	TestCase1L();
+	}
+
+void CJournalUnitTest::ImplTestStepPostambleL()
+	{
+	INFO_PRINTF1(_L("JournalFileUnitTest Postamble"));
+	delete iTestFileInterface;
+	iTestFileInterface=0;
+	iFs.Close();
+	iLoader.Close();
+	}
+
+void CJournalUnitTest::TestCase1L()
+	{
+	INFO_PRINTF1(_L("JournalFileUnitTest Test Case1"));
+
+//-------------------------------------------------------------------------------------	
+//Steps: 
+//	1.) create a corrupt journal file on C drive (by writing invalid event into the file /eg: with a value of EAddedFile+1000/) 
+//	2.) Create a journal
+//	3.) Add a file to the journal on C drive by invoking CJounral::AddL() 
+//	4.) this will create a new journal file object representing journal activity on drive C, however due to the corrupt file being already on the C drive CJournalFile::NewLC will throw KErrCorrupt
+//  5.) expect KErrCorrupt	
+//  note: the purpose of this testcase to excersise the conditional branches in CJournal::PrepareToWriteL		
+//-------------------------------------------------------------------------------------
+	
+	TInt err=0;
+	TDriveUnit driveUnitC(KDriveLetterC);
+	TDriveUnit driveUnitE(KDriveLetterE);
+	
+	
+	HBufC* journalFileName = HBufC::NewLC(KMaxFileName);
+	HBufC* targetFileName = HBufC::NewLC(KMaxFileName);
+	
+	TPtr journalFileNamePtr(journalFileName->Des());
+	journalFileNamePtr.Append(driveUnitC.Name());
+	CJournal::CreateJournalFileNameL(iTrID, iJournalPathInIni, journalFileNamePtr); 
+	
+	//create file path base (eg: drive:\path\)
+	TPtr targetFileNameBasePtr(targetFileName->Des());
+	targetFileNameBasePtr.Append(driveUnitC.Name());
+	targetFileNameBasePtr.Append(iJournalPathInIni);
+	
+	//open up the file via the test file interface (for writing corrupt data)
+	iTestFileInterface->CreateJournalFileL(journalFileNamePtr, defaultJournalFileMode);
+	TInt seekPosition=0;
+	TIntValue intValue = {0};
+	intValue.int32=static_cast<TInt32>(EAddedFile)+1000; //corrupt data in file (eg: write operation value to an invalid value)
+	//corrupt data in journal file
+	iTestFileInterface->SeekInJournalFileL(ESeekStart, seekPosition);
+	iTestFileInterface->WriteIntToJournalFileL(intValue, Mode32Bit);
+	iTestFileInterface->CloseJournalFile();
+
+	TPtr targetFileNamePtr(targetFileNameBasePtr);
+	targetFileNamePtr.Append(_L("dummyadd.txt"));
+	
+	//create a journal and add a file on C drive: that will force CJournalFile to read in and process the  
+	//previously created corrupt file. As the file contains corrupt information CJournalFile construction is expected to fail with KErrCorrupt 
+	CJournal* journal = CJournal::NewLC(iFs, iLoader, iTrID, iJournalPathInIni);
+	TRAP(err, journal->AddL(targetFileNamePtr));
+	if(err!=KErrCorrupt)
+		{
+		ERR_PRINTF2(_L("<font color=red>CJournal::AddL() returned incorrect error code. KErrCorrupt is expected and %d is returned!</font>"), err);
+		SetTestStepResult(EFail);
+		}
+	CleanupStack::PopAndDestroy(journal); journal=0;
+
+	//clean up: delete created journal file and drive file (.drv)
+	DeleteFileL(*journalFileName);
+	//reuse targetFileName buffer to create .drv filename to delete that file
+	*targetFileName=KEmptyString;
+	targetFileNamePtr.Set(targetFileName->Des());
+	CJournal::CreateDrvFileNameL(iTrID, iJournalPathInIni, targetFileNamePtr);
+	TRAP_IGNORE(DeleteFileL(targetFileNamePtr)); //clean up .drv file in case it's been created but avoid causing leave in case it hasn't 
+	
+	CleanupStack::PopAndDestroy(targetFileName);
+	CleanupStack::PopAndDestroy(journalFileName);
+	}
+
+//------------------------------------------------------------------------------------------------------------
+
+
+CJournalUnitTestScenarioBase::CJournalUnitTestScenarioBase(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer) 
+	{
+	iDriveUnitC = _L("c"); 
+	iDriveUnitE = _L("e");
+	}
+
+CJournalUnitTestScenarioBase::~CJournalUnitTestScenarioBase()
+	{
+	iFs.Close();
+	iLoader.Close();
+	delete iTargetFileName;
+	delete iJournalFileName;
+	delete iDrvFileName;
+	delete iBackupFileName;
+	}
+
+void CJournalUnitTestScenarioBase::ImplTestStepPreambleL()
+	{
+	INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::ImplTestStepPreambleL()"));
+	iJournalPathInIni.Set(GetTargetFilePathFromConfigL());
+	iTrID = GetTransactionIdFromConfigL();
+	User::LeaveIfError(iFs.Connect());
+	User::LeaveIfError(iLoader.Connect());
+	iTargetFileName = HBufC::NewL(KMaxFileName);
+	iJournalFileName = HBufC::NewL(KMaxFileName);
+	iDrvFileName = HBufC::NewL(KMaxFileName);
+	iBackupFileName = HBufC::NewL(KMaxFileName);
+
+	TPtr ptr(iJournalFileName->Des());
+	ptr.Append(iDriveUnitC.Name());
+	ptr.Append(iJournalPathInIni);
+	ptr.AppendNumUC(iTrID, EHex);
+	ptr.Append(KKournalFileExt);
+	
+	ptr.Set(iTargetFileName->Des());
+	ptr.Append(iDriveUnitC.Name());
+	ptr.Append(iJournalPathInIni);
+
+	ptr.Set(iDrvFileName->Des());
+	CJournal::CreateDrvFileNameL(iTrID, iJournalPathInIni, ptr);
+
+	SetTestStepResult(EPass);
+	}
+
+void CJournalUnitTestScenarioBase::ImplTestStepL()
+	{
+	INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::ImplTestStepL()"));
+
+	TPtr basePathPtr(iTargetFileName->Des());
+	TPtr fileNamePtr(basePathPtr);
+	TCleanupItem inTestCleanupItem(&CJournalUnitTestScenarioBase::InTestCleanUp, this);
+	CleanupStack::PushL(inTestCleanupItem);
+
+	CJournal* journal = CJournal::NewLC(iFs, iLoader, iTrID, iJournalPathInIni);
+	
+	*iBackupFileName=KEmptyString;
+	TPtr backupFileNamePtr(iBackupFileName->Des());
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("journal_oom_test_dummyremovefile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	journal->RemoveL(fileNamePtr, backupFileNamePtr);
+	*iBackupFileName=KEmptyString;
+	backupFileNamePtr.Set(iBackupFileName->Des());
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	journal->RemoveL(fileNamePtr, backupFileNamePtr);
+	
+	  
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("journal_oom_test_dummytempfile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	journal->TemporaryL(fileNamePtr);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	journal->TemporaryL(fileNamePtr);
+	
+	
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("journal_oom_test_dummyaddfile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	journal->AddL(fileNamePtr);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	journal->AddL(fileNamePtr);
+	  
+	ScenarioEndL(journal);
+	CleanupStack::PopAndDestroy(journal);
+	CleanupStack::PopAndDestroy(this);
+	}
+
+void CJournalUnitTestScenarioBase::ImplTestStepPostambleL()
+	{
+	INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::ImplTestStepPostambleL()"));
+	delete iTargetFileName;
+	iTargetFileName=0;
+	delete iJournalFileName;
+	iJournalFileName=0;
+	delete iDrvFileName;
+	iDrvFileName=0;
+	delete iBackupFileName;
+	iBackupFileName=0;
+	iFs.Close();
+	iLoader.Close();
+	}
+
+/*static*/ void CJournalUnitTestScenarioBase::InTestCleanUp(TAny* aObject)
+	{
+	CJournalUnitTestScenarioBase* object=static_cast<CJournalUnitTestScenarioBase*>(aObject);
+	object->INFO_PRINTF1(_L("CJournalUnitTestScenarioBase::InTestCleanUp()"));
+
+	TPtr ptr(object->iJournalFileName->Des());
+	ptr.Replace(0, 2, object->iDriveUnitC.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on C drive
+	ptr.Replace(0, 2, object->iDriveUnitE.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on E drive
+	TRAP_IGNORE(object->DeleteFileL(*(object->iDrvFileName))); //delete drv file on system drive
+	}
+
+//------------------------------------------------------------------------------------------------------------
+
+CJournalUnitTestInstall::CJournalUnitTestInstall(CStsTestServer &aStsTestServer): CJournalUnitTestScenarioBase(aStsTestServer)
+	{
+	// Call base class method to set up the human readable name for logging
+	SetTestStepName(KJournalUnitTestInstall);
+	}
+
+void CJournalUnitTestInstall::ScenarioEndL(CJournal* aJournal)
+	{
+	aJournal->CommitL();
+	}
+
+//------------------------------------------------------------------------------------------------------------
+
+CJournalUnitTestRollback::CJournalUnitTestRollback(CStsTestServer &aStsTestServer): CJournalUnitTestScenarioBase(aStsTestServer)
+	{
+	// Call base class method to set up the human readable name for logging
+	SetTestStepName(KJournalUnitTestRollback);
+	}
+
+void CJournalUnitTestRollback::ScenarioEndL(CJournal* aJournal)
+	{
+	aJournal->RollBackL();
+	}
+
+//------------------------------------------------------------------------------------------------------------
+
+
+CIntegrityServicesTestScenarioBase::CIntegrityServicesTestScenarioBase(CStsTestServer &aStsTestServer): CStsBaseTestStep(aStsTestServer) 
+	{
+	iDriveUnitC = _L("c"); 
+	iDriveUnitE = _L("e");
+	}
+
+CIntegrityServicesTestScenarioBase::~CIntegrityServicesTestScenarioBase()
+	{
+	iFs.Close();
+	iLoader.Close();
+	delete iTargetFileName;
+	delete iJournalFileName;
+	delete iDrvFileName;
+	delete iBackupFileName;
+	delete iTransactionBackupDirectoryPath;
+	}
+
+void CIntegrityServicesTestScenarioBase::ImplTestStepPreambleL()
+	{
+	INFO_PRINTF1(_L("IntegrityServicesTestOOM Preamble"));
+	iTargetPathInIni.Set(GetTargetFilePathFromConfigL());
+	iTrID = GetTransactionIdFromConfigL();
+	User::LeaveIfError(iFs.Connect());
+	User::LeaveIfError(iLoader.Connect());
+	iTargetFileName = HBufC::NewL(KMaxFileName);
+	iJournalFileName = HBufC::NewL(KMaxFileName);
+	iDrvFileName = HBufC::NewL(KMaxFileName);
+	iBackupFileName = HBufC::NewL(KMaxFileName);
+	iTransactionBackupDirectoryPath = HBufC::NewL(KMaxFileName);
+
+	TPtr ptr(iJournalFileName->Des());
+	ptr.Append(iDriveUnitC.Name());
+	CJournal::CreateJournalFileNameL(iTrID, KTransactionPath, ptr);
+
+	ptr.Set(iDrvFileName->Des());
+	CJournal::CreateDrvFileNameL(iTrID, KTransactionPath, ptr);
+	
+	TParsePtrC parse(*iDrvFileName);
+	ptr.Set(iTransactionBackupDirectoryPath->Des()); //this is the directory that holds the backup files for the transaction
+	ptr.Append(parse.DriveAndPath());
+	ptr.Append(parse.Name());
+	
+	ptr.Set(iTargetFileName->Des());
+	ptr.Append(iDriveUnitC.Name());
+	ptr.Append(iTargetPathInIni);
+	NormalizeDirectoryName(ptr); //removes trailing slash
+
+	SetTestStepResult(EPass);
+	}
+
+void CIntegrityServicesTestScenarioBase::ImplTestStepL()
+	{
+	TPtr basePathPtr(iTargetFileName->Des());
+	TPtr fileNamePtr(basePathPtr);
+	RFile newFile;
+	TUint fileMode(EFileShareExclusive | EFileWrite);
+	
+	TCleanupItem inTestCleanupItem(&CIntegrityServicesTestScenarioBase::InTestCleanUp, this);
+	CleanupStack::PushL(inTestCleanupItem);
+
+	CIntegrityServices* integrityServices = CIntegrityServices::NewLC(iTrID);
+	
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyremovefile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	integrityServices->RemoveL(fileNamePtr);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	integrityServices->RemoveL(fileNamePtr);
+	  
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyregistertempfile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	integrityServices->RegisterTemporaryL(fileNamePtr);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	integrityServices->RegisterTemporaryL(fileNamePtr);
+	
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("\\integrityservices_oom_test_dummycreatetempfile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	CleanupClosePushL(newFile);
+	integrityServices->CreateTemporaryL(fileNamePtr, newFile, fileMode);
+	CleanupStack::PopAndDestroy(&newFile);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	CleanupClosePushL(newFile);
+	integrityServices->CreateTemporaryL(fileNamePtr, newFile, fileMode);
+	CleanupStack::PopAndDestroy(&newFile);
+	
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyaddfile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	integrityServices->RegisterNewL(fileNamePtr);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	integrityServices->RegisterNewL(fileNamePtr);
+	 
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("\\integrityservices_oom_test_dummycreatenewfile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	CleanupClosePushL(newFile);
+	integrityServices->CreateNewL(fileNamePtr, newFile, fileMode);
+	CleanupStack::PopAndDestroy(&newFile);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	CleanupClosePushL(newFile);
+	integrityServices->CreateNewL(fileNamePtr, newFile, fileMode);
+	CleanupStack::PopAndDestroy(&newFile);
+	
+	fileNamePtr.Set(basePathPtr);
+	fileNamePtr.Append(_L("\\integrityservices_oom_test_dummyoverwritefile.txt"));
+	basePathPtr.Replace(0, 2, iDriveUnitC.Name());
+	CleanupClosePushL(newFile);
+	integrityServices->OverwriteL(fileNamePtr, newFile, fileMode);
+	CleanupStack::PopAndDestroy(&newFile);
+	basePathPtr.Replace(0, 2, iDriveUnitE.Name());
+	CleanupClosePushL(newFile);
+	integrityServices->OverwriteL(fileNamePtr, newFile, fileMode);
+	CleanupStack::PopAndDestroy(&newFile);
+	  
+	ScenarioEndL(integrityServices);
+	CleanupStack::PopAndDestroy(integrityServices);
+	CleanupStack::PopAndDestroy(this);
+	}
+
+void CIntegrityServicesTestScenarioBase::ImplTestStepPostambleL()
+	{
+	INFO_PRINTF1(_L("IntegrityServicesTestOOM Postamble"));
+	delete iTargetFileName;
+	iTargetFileName=0;
+	delete iJournalFileName;
+	iJournalFileName=0;
+	delete iDrvFileName;
+	iDrvFileName=0;
+	delete iBackupFileName;
+	iBackupFileName=0;
+	delete iTransactionBackupDirectoryPath;
+	iTransactionBackupDirectoryPath=0;
+	iFs.Close();
+	iLoader.Close();
+	}
+
+/*static*/void CIntegrityServicesTestScenarioBase::InTestCleanUp(TAny* aObject)
+	{
+	CIntegrityServicesTestScenarioBase* object=static_cast<CIntegrityServicesTestScenarioBase*>(aObject);
+	//first clean up transaction related files
+	TPtr ptr(object->iJournalFileName->Des());
+	ptr.Replace(0, 2, object->iDriveUnitC.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on C drive
+	ptr.Replace(0, 2, object->iDriveUnitE.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete journal file on E drive
+	TRAP_IGNORE(object->DeleteFileL(*(object->iDrvFileName))); //delete drv file on system drive
+	ptr.Set(object->iTransactionBackupDirectoryPath->Des());
+	ptr.Replace(0, 2, object->iDriveUnitC.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete backup directory on C drive
+	ptr.Replace(0, 2, object->iDriveUnitE.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete backup directory on E drive
+	
+	//then clean up all the added/created/etc... files
+	ptr.Set(object->iTargetFileName->Des());
+	ptr.Replace(0, 2, object->iDriveUnitC.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete target dir on C drive
+	ptr.Replace(0, 2, object->iDriveUnitE.Name());
+	TRAP_IGNORE(object->DeleteFileL(ptr)); //delete target dir on E drive
+	
+	}
+
+void CIntegrityServicesTestScenarioBase::NormalizeDirectoryName(TDes& aFileName)
+{
+	TInt lastCharPos = aFileName.Length() - 1;
+	if ( lastCharPos >= 0 && aFileName[lastCharPos] == KPathDelimiter &&
+		 aFileName.Locate(KPathDelimiter) != lastCharPos) // Take care not to remove slash from "c:\" and the like
+		{
+		aFileName.Delete(lastCharPos, 1);
+		}			
+}
+
+//------------------------------------------------------------------------------------------------------------
+
+CIntegrityServicesTestInstall::CIntegrityServicesTestInstall(CStsTestServer &aStsTestServer): CIntegrityServicesTestScenarioBase(aStsTestServer)
+	{
+	// Call base class method to set up the human readable name for logging
+	SetTestStepName(KIntegrityservicesUnitTestInstall);
+	}
+
+void CIntegrityServicesTestInstall::ScenarioEndL(Usif::CIntegrityServices* aIntegrServ)
+	{
+	aIntegrServ->CommitL();
+	}
+
+//------------------------------------------------------------------------------------------------------------
+
+CIntegrityServicesTestRollback::CIntegrityServicesTestRollback(CStsTestServer &aStsTestServer): CIntegrityServicesTestScenarioBase(aStsTestServer)
+	{
+	// Call base class method to set up the human readable name for logging
+	SetTestStepName(KIntegrityservicesUnitTestRollback);
+	}
+
+void CIntegrityServicesTestRollback::ScenarioEndL(Usif::CIntegrityServices* aIntegrServ)
+	{
+	aIntegrServ->RollBackL();
+	}