diff -r 000000000000 -r 32704c33136d installationservices/swi/test/tsisregistrytest/sessionstep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swi/test/tsisregistrytest/sessionstep.cpp	Tue Jan 26 12:06:03 2010 +0200
@@ -0,0 +1,2721 @@
+/*
+* 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 <test/testexecutelog.h>
+#include <hash.h>
+
+#include "sessionstep.h"
+#include "sisregistrysession.h"
+#include "sisregistryentry.h"
+#include "sisregistrypackage.h"
+#include "installtypes.h"
+#include "cleanuputils.h"
+#include "hashcontainer.h"
+#include "testutilclientswi.h"
+#include "arrayutils.h"
+#include "sisregistrytoken.h"
+#include "sisregistrylog.h"
+#include "s32file.h"
+#include "sishelperclient.h"
+#include "sisregistrywritableentry.h"
+#include "sisregistryfiledescription.h"
+#include "sisregistrydependency.h"
+#include "sisregistryobject.h"
+#include "controllerinfo.h"
+#include "hashcontainer.h"
+#include "sisregistryproperty.h"
+
+const TInt KDefaultBufferSize		= 2048;
+/////////////////////////////////////////////////////////////////////
+// defs, Constants used by test steps
+/////////////////////////////////////////////////////////////////////
+
+_LIT(KNoUid, "nouid");
+_LIT(KUid, "uid");
+_LIT(KDrivebitmapcount, "drivebitmapcout");
+_LIT(KSid, "sid");
+_LIT(KPackage, "package");
+_LIT(KVendor, "vendor");
+_LIT(KSisFile, "sis");
+_LIT(KKeyFormat, "-%02d");
+_LIT(KSidFileNameSec, "file");
+_LIT(KModFileName, "file");
+_LIT(KModTag, "modtag");
+_LIT(KHashFileName, "file");
+_LIT(KHashFileValue, "hashvalue");
+_LIT(KRootCertTag, "rootcert");
+_LIT(KResultTag, "expectedresult");
+_LIT(KDateTime, "datetime"); //YYYYMMDD:HHMMSS.MMMMMM
+_LIT(KPkgCount, "embeddingpkgcount");
+_LIT(KCertChainCount, "certChainCount");
+_LIT(KLanguage, "language");
+
+_LIT(KSisRegistryPath, "\\sys\\install\\sisregistry\\");
+_LIT(KCacheBackupFile, "\\sys\\install\\sisregistry\\backup.lst");
+_LIT(KCorruptCacheBackupFile, "z:\\tswi\\tsisregistrytest\\data\\hashforlang_txt.dat");
+_LIT(KSysBackupFileBackup, "\\sys\\install\\sisregistry\\backup.bak");
+
+/////////////////////////////////////////////////////////////////////
+// Tags used by test steps
+/////////////////////////////////////////////////////////////////////
+using namespace Swi;
+
+/////////////////////////////////////////////////////////////////////
+// CSisRegistrySessionStep
+/////////////////////////////////////////////////////////////////////
+TVerdict CSisRegistrySessionStep::doTestStepPreambleL()
+	{
+	__UHEAP_MARK;
+
+	// Install an active scheduler
+	CActiveScheduler* s = new (ELeave) CActiveScheduler;
+	s->Install(s);
+	
+	INFO_PRINTF1(_L("Connecting to SisRegistry.."));
+	User::LeaveIfError(iSisRegistry.Connect());
+	INFO_PRINTF1(_L("Connected!"));
+	
+	StartTimer();
+	return TestStepResult();
+	}
+
+TVerdict CSisRegistrySessionStep::doTestStepPostambleL()
+	{
+	StopTimerAndPrintResultL();
+	// Remove the installed active scheduler
+	CActiveScheduler* s = CActiveScheduler::Current();
+	s->Install(NULL);
+	delete s;
+	INFO_PRINTF1(_L("Disconnecting from SisRegistry.."));
+	iSisRegistry.Close();
+	
+	__UHEAP_MARKEND;
+	
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CRegistryEntryStep
+/////////////////////////////////////////////////////////////////////
+TVerdict CRegistryEntryStep::doTestStepPreambleL()
+	{
+	CSisRegistrySessionStep::doTestStepPreambleL();
+	TUid pckgUid;
+	if(!GetUidFromConfig(ConfigSection(), KUid, pckgUid))
+		{
+		ERR_PRINTF1(_L("Package UID is missing in the configuration file!"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+			
+	TInt err = iRegistryEntry.Open(iSisRegistry, pckgUid);
+	if (KErrNone != err)
+		{
+		ERR_PRINTF2(_L("Registry entry couldn't be opened (Error code=%d)!"), err);
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+	StartTimer(); // Start timer again to ignore the time taken to open the registry entry
+	return TestStepResult();
+	}
+
+TVerdict CRegistryEntryStep::doTestStepPostambleL()
+	{
+	iRegistryEntry.Close();
+	CSisRegistrySessionStep::doTestStepPostambleL();
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CEmbeddingPackageStep - Checks the embedding packages for a given package
+/////////////////////////////////////////////////////////////////////
+CEmbeddingPackageStep::CEmbeddingPackageStep()
+	{
+	SetTestStepName(KEmbeddingPackageStep);
+	}
+
+TVerdict CEmbeddingPackageStep::doTestStepL()
+	{
+	SetTestStepResult(EPass);
+	
+	TInt embeddingPkgCount;
+	if(!GetIntFromConfig(ConfigSection(), KPkgCount, embeddingPkgCount))
+		{
+		ERR_PRINTF1(_L("Missing expected package count"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+	
+	RPointerArray<Swi::CSisRegistryPackage> packages;
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	iRegistryEntry.EmbeddingPackagesL(packages);
+	CleanupResetAndDestroyPushL(packages);
+	
+	if(packages.Count() != embeddingPkgCount)
+		{
+		ERR_PRINTF3(_L("The actual number of embedding packages does not meet expected. Expected: %d Actual: %d"), embeddingPkgCount, packages.Count());
+		SetTestStepResult(EFail);
+		}
+	CleanupStack::PopAndDestroy(&packages);
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CSidFileStep - Checks the filename to sid mapping
+/////////////////////////////////////////////////////////////////////
+CSidFileStep::CSidFileStep()
+	{
+	SetTestStepName(KSidFileName);
+	}
+
+TVerdict CSidFileStep::doTestStepL()
+	{
+	RArray<TUid> theSids;
+	CleanupClosePushL(theSids);
+	GetUidArrayFromConfigL(ConfigSection(), KSid, theSids);
+	
+	//RArray<TUid> thePackageUids;
+	//CleanupClosePushL(thePackageUids);
+	//GetUidArrayFromConfigL(ConfigSection(), KUid, thePackageUids);
+	
+	RArray<TPtrC> expectedSidNames;
+	CleanupClosePushL(expectedSidNames);
+	GetStringArrayFromConfigL(ConfigSection(), KSidFileNameSec, expectedSidNames);
+	
+	SetTestStepResult(EPass);
+	
+	if (theSids.Count() != expectedSidNames.Count())
+		{
+		User::LeaveIfError(KErrCorrupt);
+		}
+	
+	TBuf<KMaxFileName> fileName;
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	for (TInt sidCount(0); sidCount<theSids.Count(); sidCount++)
+		{
+		iSisRegistry.SidToFileNameL(theSids[sidCount],fileName);
+		if (expectedSidNames[sidCount].Compare(fileName) != 0)
+			{
+			SetTestStepResult(EFail);
+			break;
+			}
+		}
+		
+	CleanupStack::PopAndDestroy(&expectedSidNames);
+	//CleanupStack::PopAndDestroy(&thePackageUids);
+	CleanupStack::PopAndDestroy(&theSids);
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////
+// CModifiableFileStep - Checks whether the file is tagged as modifiable
+////////////////////////////////////////////////////////////////////////
+CModifiableFileStep::CModifiableFileStep()
+	{
+	SetTestStepName(KModifiableFile);
+	}
+
+TVerdict CModifiableFileStep::doTestStepL()
+	{
+	RArray<TPtrC> theFileNames;
+	CleanupClosePushL(theFileNames);
+	GetStringArrayFromConfigL(ConfigSection(), KModFileName, theFileNames);
+		
+	RArray<TInt> expectedModifiableTags;
+	CleanupClosePushL(expectedModifiableTags);
+	GetIntArrayFromConfigL(ConfigSection(), KModTag, expectedModifiableTags);
+	
+	SetTestStepResult(EPass);
+	
+	if (theFileNames.Count() != expectedModifiableTags.Count())
+		{
+		User::LeaveIfError(KErrCorrupt);
+		}
+	
+	TInt numModFiles = theFileNames.Count();
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	
+	for (TInt i=0; i<numModFiles; i++)
+		{
+		TBool isFileModifiable = iSisRegistry.ModifiableL(theFileNames[i]);
+		
+		INFO_PRINTF2(_L("File '%d':"), i);
+		INFO_PRINTF2(_L(" expected modifiable tag   = %d"), expectedModifiableTags[i]);
+		INFO_PRINTF2(_L(" calculated modifiable tag = %d"), isFileModifiable);
+
+		if (expectedModifiableTags[i] != isFileModifiable)
+			{
+			SetTestStepResult(EFail);
+			break;
+			}
+		}
+	
+	// Items popped and cleaned up from the stack (in this order):
+	// &expectedModifiableTags and &theFileNames.
+	CleanupStack::PopAndDestroy(2, &theFileNames);
+	
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////
+// CFileHashStep - Checks the hash of a file
+////////////////////////////////////////////////////////////////////////
+CFileHashStep::CFileHashStep()
+	{
+	SetTestStepName(KFileHash);
+	}
+
+TVerdict CFileHashStep::doTestStepL()
+	{
+	// Get the filenames (for which the hash will be calculated)
+	// from the test section.
+	RArray<TPtrC> theFileNames;
+	CleanupClosePushL(theFileNames);
+	GetStringArrayFromConfigL(ConfigSection(), KHashFileName, theFileNames);
+
+	// Get the filenames that contain the expected hash values,
+	// from the test section.
+	RArray<TPtrC> expectedHashFiles;
+	CleanupClosePushL(expectedHashFiles);
+	GetStringArrayFromConfigL(ConfigSection(), KHashFileValue, expectedHashFiles);
+	
+	// Initialise the test step result to pass.
+	SetTestStepResult(EPass);
+	
+	// Ensure that there are as many filenames whose hash will be calculated,
+	// as there are files with expected hash values.
+	TInt numModFiles = theFileNames.Count();
+	if (numModFiles != expectedHashFiles.Count())
+		{
+		User::LeaveIfError(KErrCorrupt);
+		}
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	
+	// For each file in config section KHashFileName, calculate its hash
+	// value and compare it with the corresponding expected hash value.
+	// Fail the test case if they don't match.
+	for (TInt i=0; i<numModFiles; i++)
+		{
+		INFO_PRINTF2(_L("Using SisRegistry to calculate hash for: %S"), &theFileNames[i]);
+		// Use SisRegistry to calculate the hash value for this file.
+		CHashContainer* hashContainer = iSisRegistry.HashL(theFileNames[i]);
+		CleanupStack::PushL(hashContainer);
+		
+		const TDesC8& calcHashValue = hashContainer->Data();
+		INFO_PRINTF2(_L("Received hash with length %d"), calcHashValue.Length());
+		
+		// Open for reading the file that has the expected hash value.
+		INFO_PRINTF2(_L("Reading Expected hash value from: %S"), &expectedHashFiles[i]);
+		RFs fs;
+		User::LeaveIfError(fs.Connect());
+		CleanupClosePushL(fs);
+		
+		RFile fileToRead;
+		User::LeaveIfError(fileToRead.Open(fs, expectedHashFiles[i],
+										   EFileRead | EFileShareReadersOnly | EFileStream));
+		CleanupClosePushL(fileToRead);
+
+		// Create a block of memory to store the expected hash value.
+		TInt fileSize = 0;
+		User::LeaveIfError(fileToRead.Size(fileSize));
+		HBufC8* memForExpectedHashValue = HBufC8::NewLC(fileSize);
+	
+		// Read the expected hash value into the previously created memory block.
+		TPtr8 expectedHashValue(memForExpectedHashValue->Des());
+		User::LeaveIfError(fileToRead.Read(0, expectedHashValue, fileSize));
+
+		INFO_PRINTF2(_L("Expecting hash with length %d"), expectedHashValue.Length());
+
+		INFO_PRINTF1(_L("Comparing hash values"));
+		
+		// Compare the calculated has value against its expected value.	
+		if (calcHashValue.Compare(expectedHashValue) != KErrNone)
+			{
+			SetTestStepResult(EFail);
+			
+			// Items popped and cleaned up from the stack (in this order):
+			// memForExpectedHashValue, &fileToRead, &fs and hashContainer.
+			CleanupStack::PopAndDestroy(4, hashContainer);
+		
+			break;
+			}
+
+		// Items popped and cleaned up from the stack (in this order):
+		// memForExpectedHashValue, &fileToRead, &fs and hashContainer.
+		CleanupStack::PopAndDestroy(4, hashContainer);
+		}
+
+	// Items popped and cleaned up from the stack (in this order):
+	// &expectedHashFiles and &theFileNames.
+	CleanupStack::PopAndDestroy(2, &theFileNames);
+	
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CInstalledUidsStep - checks installed packages Uids list
+/////////////////////////////////////////////////////////////////////
+CInstalledUidsStep::CInstalledUidsStep()
+	{
+	SetTestStepName(KInstalledUids);
+	}
+
+TVerdict CInstalledUidsStep::doTestStepL()
+	{
+	RArray<TUid> expectedUids;
+	CleanupClosePushL(expectedUids);
+	GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+		
+	RArray<TUid> actualUids;
+	CleanupClosePushL(actualUids);
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	iSisRegistry.InstalledUidsL(actualUids);
+	
+	SetTestStepResult(EPass);
+	
+	for (TInt index=0; index < expectedUids.Count(); index++)
+		{
+		if(actualUids.Find(expectedUids[index]) != KErrNotFound)
+			{
+			INFO_PRINTF2(_L("Uid: 0x%08x was found!"), expectedUids[index]);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF2(_L("Uid: 0x%08x not found!"), expectedUids[index]);
+			}
+		}
+		
+	CleanupStack::PopAndDestroy(2, &expectedUids); //actualUids
+	
+	return TestStepResult();
+	}
+	
+/////////////////////////////////////////////////////////////////////
+// CInstalledPackagesStep - checks installed packages names and vendor list
+/////////////////////////////////////////////////////////////////////
+CInstalledPackagesStep::CInstalledPackagesStep()
+	{
+	SetTestStepName(KInstalledPackages);
+	}
+
+TVerdict CInstalledPackagesStep::doTestStepL()
+	{
+	RArray<TUid> expectedUids;
+	CleanupClosePushL(expectedUids);
+	GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+	
+	RArray<TPtrC> expectedPackageNames;
+	CleanupClosePushL(expectedPackageNames);
+	GetStringArrayFromConfigL(ConfigSection(), KPackage, expectedPackageNames);
+	
+	RArray<TPtrC> expectedVendorNames;
+	CleanupClosePushL(expectedVendorNames);
+	GetStringArrayFromConfigL(ConfigSection(), KVendor, expectedVendorNames);
+	
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+		
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	iSisRegistry.InstalledPackagesL(packages);
+	
+	SetTestStepResult(EPass);
+	
+	for (TInt expected = 0; expected < expectedPackageNames.Count(); expected++)
+		{
+		TBool result = EFalse;
+		for (TInt actual = 0; actual < packages.Count(); ++actual)
+			{
+			if (packages[actual]->Uid() == expectedUids[expected] &&
+				!packages[actual]->Name().CompareF(expectedPackageNames[expected]) &&
+				!packages[actual]->Vendor().CompareF(expectedVendorNames[expected]))
+				{
+				result = ETrue;
+				break;
+				}
+			}
+			
+		if(result)
+			{
+			INFO_PRINTF3(_L("Package %S by Vendor %S was found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF3(_L("Package %S by Vendor %S was not found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+			}
+		}
+	
+	CleanupStack::PopAndDestroy(4, &expectedUids); //packages, expectedVendorNames, expectedPackageNames
+	
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CRemovablePackagesStep - checks removable packages names and vendor list
+/////////////////////////////////////////////////////////////////////
+CRemovablePackagesStep::CRemovablePackagesStep()
+	{
+	SetTestStepName(KRemovablePackages);
+	}
+
+TVerdict CRemovablePackagesStep::doTestStepL()
+	{
+	RArray<TUid> expectedNoUids;
+	CleanupClosePushL(expectedNoUids);
+	GetUidArrayFromConfigL(ConfigSection(), KNoUid, expectedNoUids);
+	
+	RArray<TUid> expectedUids;
+	CleanupClosePushL(expectedUids);
+	GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+	
+	RArray<TPtrC> expectedPackageNames;
+	CleanupClosePushL(expectedPackageNames);
+	GetStringArrayFromConfigL(ConfigSection(), KPackage, expectedPackageNames);
+	
+	RArray<TPtrC> expectedVendorNames;
+	CleanupClosePushL(expectedVendorNames);
+	GetStringArrayFromConfigL(ConfigSection(), KVendor, expectedVendorNames);
+	
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	
+	iSisRegistry.RemovablePackagesL(packages);
+	
+	TInt expected = 0;
+	for (expected = 0; expected < expectedPackageNames.Count(); expected++)
+		{
+		TBool result = EFalse;
+		for (TInt actual = 0; actual < packages.Count(); ++actual)
+			{
+			if (packages[actual]->Uid() == expectedUids[expected] &&
+				!packages[actual]->Name().CompareF(expectedPackageNames[expected]) &&
+				!packages[actual]->Vendor().CompareF(expectedVendorNames[expected]))
+				{
+				result = ETrue;
+				break;
+				}
+			}
+
+		if(result)
+			{
+			INFO_PRINTF3(_L("Package %S by Vendor %S was found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF3(_L("Package %S by Vendor %S was not found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+			}
+		}
+		
+	for (expected = 0; expected < expectedNoUids.Count(); expected++)
+		{
+		TBool result = ETrue;
+		for (TInt actual = 0; actual < packages.Count(); ++actual)
+			{
+			if (packages[actual]->Uid() == expectedNoUids[expected])
+				{
+				result = EFalse;
+				break;
+				}
+			}
+
+		if(result)
+			{
+			INFO_PRINTF2(_L("Non-Removable Package %d was not found!"), &expectedNoUids[expected]);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF2(_L("Non-Removable Package %d was found!"), &expectedNoUids[expected]);
+			}
+		}
+	
+	CleanupStack::PopAndDestroy(5, &expectedNoUids); //packages, expectedVendorNames, expectedPackageNames
+	
+	return TestStepResult();
+	}
+	
+/////////////////////////////////////////////////////////////////////
+// CNonRemovablePackagesStep - checks Non-removable packages in rom
+/////////////////////////////////////////////////////////////////////
+CInRomNonRemovablePackage::CInRomNonRemovablePackage()
+ 	{
+ 	SetTestStepName(KInRomNonRemovablePackages);
+ 	}
+ 
+TVerdict CInRomNonRemovablePackage::doTestStepL()
+ 	{
+  	RPointerArray<CSisRegistryPackage> packages;
+ 	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+ 	
+ 	iSisRegistry.RemovablePackagesL(packages);
+ 	
+ 	RSisRegistryEntry entry;
+	TBool inrom = EFalse;
+	for (TInt i = 0; i < packages.Count(); ++i)
+		{
+		User::LeaveIfError(entry.OpenL(iSisRegistry, *packages[i]));
+		inrom = entry.IsInRomL();
+ 	  	
+ 	  	if(inrom)
+	  		{
+	  		SetTestStepResult(EFail);
+	 		}
+		}
+	INFO_PRINTF1(_L("Packages which are removable are not in ROM"));	
+ 	CleanupStack::PopAndDestroy(&packages); 
+ 	
+ 	return TestStepResult();
+ 	}
+ 
+//////////////////////////////////////////////////////////////////////////////
+// CInstalledDrives - check all the drives where files are installed from SIS
+//////////////////////////////////////////////////////////////////////////////
+CInstalledDrives::CInstalledDrives()
+ 	{
+ 	SetTestStepName(KInstalledDrives);
+ 	}
+ 	
+TVerdict CInstalledDrives::doTestStepL()
+ 	{
+ 	TInt drivebitmapcount=0;
+	TUid expectedUid;
+	GetUidFromConfig(ConfigSection(), KUid, expectedUid);
+	GetIntFromConfig(ConfigSection(), KDrivebitmapcount, drivebitmapcount);
+	
+ 	RSisRegistryEntry entry;
+	CleanupClosePushL(entry);
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	User::LeaveIfError(entry.Open(iSisRegistry, expectedUid));
+ 	
+	TUint drives = entry.InstalledDrivesL();
+	if (drives != drivebitmapcount)
+		{
+		SetTestStepResult(EFail);
+		INFO_PRINTF3(_L("Drive bitmask count is not correct, expected %d but received %d"), drivebitmapcount, drives);
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Drive bitmask count is OK...")); 	
+		}  
+		
+	CleanupStack::PopAndDestroy(&entry);
+
+ 	return TestStepResult();
+ 	}
+
+
+/////////////////////////////////////////////////////////////////////
+// CIsUidInstalledStep - checks whether an Uid is registered
+/////////////////////////////////////////////////////////////////////
+CIsUidInstalledStep::CIsUidInstalledStep()
+	{
+	SetTestStepName(KIsUidInstalled);
+	}
+
+TVerdict CIsUidInstalledStep::doTestStepL()
+	{
+	RArray<TUid> expectedUids;
+	CleanupClosePushL(expectedUids);
+	GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+	
+	SetTestStepResult(EPass);
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	for (TInt index = 0; index < expectedUids.Count(); index++)
+		{
+		if(iSisRegistry.IsInstalledL(expectedUids[index]))
+			{
+			INFO_PRINTF2(_L("Uid: 0x%08x was found!"), expectedUids[index]);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF2(_L("Uid: 0x%08x not found!"), expectedUids[index]);
+			}
+		}
+	CleanupStack::PopAndDestroy(&expectedUids);
+	
+	return TestStepResult();
+	}
+	
+/////////////////////////////////////////////////////////////////////
+// CIsPackageInstalledStep - checks if packages are registered
+/////////////////////////////////////////////////////////////////////
+
+CIsPackageInstalledStep::CIsPackageInstalledStep()
+	{
+	SetTestStepName(KIsPackageInstalled);
+	}
+
+TVerdict CIsPackageInstalledStep::doTestStepL()
+	{
+	RArray<TUid> expectedUids;
+	CleanupClosePushL(expectedUids);
+	GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+	
+	RArray<TPtrC> expectedPackageNames;
+	CleanupClosePushL(expectedPackageNames);
+	GetStringArrayFromConfigL(ConfigSection(), KPackage, expectedPackageNames);
+	
+	RArray<TPtrC> expectedVendorNames;
+	CleanupClosePushL(expectedVendorNames);
+	GetStringArrayFromConfigL(ConfigSection(), KVendor, expectedVendorNames);
+	
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+	
+	SetTestStepResult(EPass);
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	for (TInt i = 0; i < expectedUids.Count(); ++i)
+		{
+		CSisRegistryPackage* package = CSisRegistryPackage::NewLC(expectedUids[i],
+			expectedPackageNames[i], expectedVendorNames[i]);
+		package->SetIndex(0);
+		
+		RSisRegistryEntry entry;
+		CleanupClosePushL(entry);
+
+		TInt err = entry.Open(iSisRegistry, package->Name(), package->Vendor());
+		if (err != KErrNone)
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF2(_L("Uid: 0x%08x not found!"), expectedUids[i]);
+			}
+		
+		CleanupStack::PopAndDestroy(2, package); //entry
+		}
+	
+	CleanupStack::PopAndDestroy(4, &expectedUids); // expectedVendorNames, expectedPackageNames
+	
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CIsControllerInstalledStep - checks whether a Controller is present
+/////////////////////////////////////////////////////////////////////
+CIsControllerInstalledStep::CIsControllerInstalledStep()
+	{
+	SetTestStepName(KIsControllerInstalled);
+	}
+
+TVerdict CIsControllerInstalledStep::doTestStepL()
+	{
+	RArray<TPtrC> expectedControllersSisFiles;
+	CleanupClosePushL(expectedControllersSisFiles);
+	GetStringArrayFromConfigL(ConfigSection(), KSisFile, expectedControllersSisFiles);
+	
+	SetTestStepResult(EPass);
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	for (TInt index = 0; index < expectedControllersSisFiles.Count(); index++)
+		{
+		HBufC8* controllerData = GetControllerFromSisLC(expectedControllersSisFiles[index]);
+		const TInt controllerOffset = 4;
+		// The registry does not store the first 4 bytes of the controller - see CInstallationProcessor
+		TPtrC8 controllerDataPtr = controllerData->Mid(controllerOffset);
+
+		if(iSisRegistry.IsInstalledL(controllerDataPtr))
+			{
+			INFO_PRINTF2(_L("%S matching controller was found!"), &expectedControllersSisFiles[index]);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			INFO_PRINTF2(_L("%S controller did not match expected!"), &expectedControllersSisFiles[index]);
+			}
+		CleanupStack::PopAndDestroy(controllerData); 
+		}
+	CleanupStack::PopAndDestroy(2, &expectedControllersSisFiles); //fs.,
+	
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CGetControllersStep - checks whether one can get the binary version 
+// of entry controllers present
+/////////////////////////////////////////////////////////////////////
+CGetControllersStep::CGetControllersStep()
+	{
+	SetTestStepName(KGetControllers);	
+	}
+
+TVerdict CGetControllersStep::doTestStepL()
+	{
+	SetTestStepResult(EPass);
+	RArray<TUid> expectedUids;
+	CleanupClosePushL(expectedUids);
+	GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+	RFs fs;
+	CleanupClosePushL(fs);
+	User::LeaveIfError(fs.Connect());
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	for (TInt index = 0; index < expectedUids.Count(); index++)
+		{
+		TInt res;		
+		RSisRegistryEntry entry;
+		CleanupClosePushL(entry);
+		INFO_PRINTF3(_L("Open: %08x %d entry!"), expectedUids[index],index);
+		res = entry.Open(iSisRegistry, expectedUids[index]);
+		if (res != KErrNone)
+			{
+			SetTestStepResult(EFail);
+			INFO_PRINTF2(_L("Failed Open Uid: %08x entry!"), expectedUids[index]);
+			User::Leave(res);
+			}
+
+		RPointerArray<HBufC8> actualControllers;
+		CleanupResetAndDestroy<RPointerArray<HBufC8> >::PushL(actualControllers);
+		TRAP(res, entry.ControllersL(actualControllers));
+		if (res != KErrNone)
+			{
+			INFO_PRINTF3(_L("Accessing controllers for uid: %08x left with %d!"), expectedUids[index], res);
+			SetTestStepResult(EFail);
+			User::Leave(res);
+			}
+		
+		// In the test, we exctract the controllers from the SIS files in order to compare them with the ones stored in the registry
+		HBufC* keyName = HBufC::NewLC(KUid().Length() + KKeyFormat().Length()
+						+ KSisFile().Length() + KKeyFormat().Length());
+		TPtr ptr(keyName->Des());
+		ptr = KUid();
+		ptr.AppendFormat(KKeyFormat(), index + 1);
+		ptr.Append(KSisFile);
+		
+		RArray<TPtrC> sisFilenames;
+		CleanupClosePushL(sisFilenames);
+		GetStringArrayFromConfigL(ConfigSection(), ptr, sisFilenames);
+		
+		if (sisFilenames.Count() != actualControllers.Count())
+			{
+			ERR_PRINTF3(_L("Actual Controllers = %d, Expected Controllers = %d"), actualControllers.Count(), sisFilenames.Count());
+			SetTestStepResult(EFail);
+			}
+		
+		for (TInt filenameIndex = 0; filenameIndex < sisFilenames.Count(); filenameIndex++)
+			{
+			HBufC8* controllerData = GetControllerFromSisLC(sisFilenames[filenameIndex]);
+			const TInt controllerOffset = 4;
+			// The registry does not store the first 4 bytes of the controller - see CInstallationProcessor
+			TPtrC8 controllerDataPtr = controllerData->Mid(controllerOffset);
+			TBool found = EFalse;
+			for (TInt controller = 0; controller < actualControllers.Count(); controller++)
+				{
+				if(*actualControllers[controller] == controllerDataPtr)
+					{
+					found = ETrue;
+					break;
+					}
+				}
+	
+			if(found)
+				{
+				INFO_PRINTF3(_L("Matching controller #%d found for Uid: %08x!"), filenameIndex, expectedUids[index]);
+				}
+			else
+				{			
+				SetTestStepResult(EFail);
+				ERR_PRINTF3(_L("Matching controller #%d not found for Uid: %08x!"), filenameIndex, expectedUids[index]);
+				}
+				
+			CleanupStack::PopAndDestroy(controllerData);
+			}
+		    
+		CleanupStack::PopAndDestroy(4, &entry); // actualControllers,  sisFilenames, keyNames
+		}
+		
+	CleanupStack::PopAndDestroy(2, &expectedUids); // fs
+	
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CEntryUidOpenCloseStep
+/////////////////////////////////////////////////////////////////////
+CEntryUidOpenCloseStep::CEntryUidOpenCloseStep()
+	{
+	SetTestStepName(KEntryUidOpenClose);
+	}
+
+TVerdict CEntryUidOpenCloseStep::doTestStepL()
+	{
+	RArray<TUid> uids;
+	CleanupClosePushL(uids);
+	TBool isUidGiven(EFalse);
+	(void)GetBoolFromConfig(ConfigSection(), _L("UidGiven"), isUidGiven); // if not specified, the UidGiven is false.
+
+	if(!isUidGiven)
+		iSisRegistry.InstalledUidsL(uids);
+	else
+		GetUidArrayFromConfigL(ConfigSection(), KUid, uids);
+	
+    SetTestStepResult(EPass);
+    
+    //StartTimer again to ignore time taken to read from config file
+    StartTimer();    
+    
+    for(TInt index = 0; index < uids.Count(); index++)
+    	{
+    	Swi::RSisRegistryEntry entry;
+    	CleanupClosePushL(entry);
+    	TInt result = entry.Open(iSisRegistry, uids[index]);
+    	if (result == KErrNone)
+    		{
+			INFO_PRINTF2(_L("Uid: 0x%08x was opened successfully!"), uids[index]);
+			entry.Close();
+			INFO_PRINTF2(_L("Uid: 0x%08x was closed successfully!"), uids[index]);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF3(_L("Uid: 0x%08x not opened, error %d!"), uids[index], result);
+			}
+		CleanupStack::PopAndDestroy(&entry);
+    	}
+    
+    CleanupStack::PopAndDestroy(&uids);
+    
+	return TestStepResult();
+	}
+	
+/////////////////////////////////////////////////////////////////////
+// CEntryPackageOpenCloseStep
+/////////////////////////////////////////////////////////////////////
+CEntryPackageOpenCloseStep::CEntryPackageOpenCloseStep()
+	{
+	SetTestStepName(KEntryPackageOpenClose);
+	}
+
+TVerdict CEntryPackageOpenCloseStep::doTestStepL()
+	{
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+	
+	iSisRegistry.InstalledPackagesL(packages);
+	
+	SetTestStepResult(EPass);
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	
+    for(TInt index = 0; index < packages.Count(); index++)
+    	{
+    	TPtrC package = packages[index]->Name();
+    	TPtrC vendor = packages[index]->Vendor();
+    	
+    	Swi::RSisRegistryEntry entry;
+    	
+    	TInt result = entry.OpenL(iSisRegistry, *packages[index]);
+    	if (result == KErrNone)
+    		{
+    		CleanupClosePushL(entry);
+			INFO_PRINTF3(_L("Package %S by Vendor %S was opened successfully!"), &package, &vendor);
+			CleanupStack::PopAndDestroy(&entry);
+			INFO_PRINTF3(_L("Package %S by Vendor %S was closed successfully!"), &package, &vendor);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF4(_L("Package %S by Vendor %S not opened, error %d!"), &package, &vendor, result);
+			}
+    	}
+    
+    CleanupStack::PopAndDestroy(&packages);
+    
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CEntryNameOpenCloseStep
+/////////////////////////////////////////////////////////////////////
+CEntryNameOpenCloseStep::CEntryNameOpenCloseStep()
+	{
+	SetTestStepName(KEntryNameOpenClose);
+	}
+
+TVerdict CEntryNameOpenCloseStep::doTestStepL()
+	{
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+	
+	iSisRegistry.InstalledPackagesL(packages);
+	
+	SetTestStepResult(EPass);
+    for(TInt index = 0; index < packages.Count(); index++)
+    	{
+    	TPtrC package = packages[index]->Name();
+    	TPtrC vendor = packages[index]->Vendor();
+    	
+    	Swi::RSisRegistryEntry entry;
+    	
+    	TInt result = entry.Open(iSisRegistry, package, vendor);
+    	if (result == KErrNone)
+    		{
+    		CleanupClosePushL(entry);
+			INFO_PRINTF3(_L("Package %S by Vendor %S was opened successfully!"), &package, &vendor);
+			CleanupStack::PopAndDestroy(&entry);
+			INFO_PRINTF3(_L("Package %S by Vendor %S was closed successfully!"), &package, &vendor);
+			}
+		else
+			{
+			SetTestStepResult(EFail);
+			ERR_PRINTF4(_L("Package %S by Vendor %S not opened, error %d!"), &package, &vendor, result);
+			}
+    	}
+    
+    CleanupStack::PopAndDestroy(&packages);
+    
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CEntryMethodsTestStep - tests specific to entry methods
+/////////////////////////////////////////////////////////////////////
+CEntryMethodsStep::CEntryMethodsStep()
+	{
+	SetTestStepName(KEntryMethods);
+	}
+
+TVerdict CEntryMethodsStep::doTestStepL()
+	{
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+	
+	iSisRegistry.InstalledPackagesL(packages);
+		
+	SetTestStepResult(EPass);
+    for(TInt index = 0; index < packages.Count(); index++)
+    	{
+    	TPtrC package = packages[index]->Name();
+    	TPtrC vendor = packages[index]->Vendor();
+    	
+    	Swi::RSisRegistryEntry entry;
+    	
+    	INFO_PRINTF3(_L("Opening Package %S by Vendor %S..."), &package, &vendor);
+    	User::LeaveIfError(entry.OpenL(iSisRegistry, *packages[index]));
+    	CleanupClosePushL(entry);
+		// get the version
+		TVersion packageVersion = entry.VersionL(); 
+		INFO_PRINTF4(_L("Version  %d %d %d"), packageVersion.iMajor, packageVersion.iMinor, packageVersion.iBuild );
+	
+		// get sids	
+		RArray<TUid> sids;
+		CleanupClosePushL(sids);
+		entry.SidsL(sids);
+		if (sids.Count() <= 0)
+			{
+			INFO_PRINTF1(_L("No sids installed!"));
+			}
+		else 
+			{
+			for (TInt sid = 0; sid < sids.Count(); sid++)
+				{
+				INFO_PRINTF2(_L("Sid: 0x%08x was found!"), sids[sid]);
+				}
+			}
+		
+		CleanupStack::PopAndDestroy(&sids);
+
+		// get the vendor; package name 
+		HBufC* reportedVendor = entry.UniqueVendorNameL();
+		CleanupStack::PushL(reportedVendor);
+		HBufC* reportedPackage = entry.PackageNameL();
+		CleanupStack::PushL(reportedPackage);
+		
+		INFO_PRINTF3(_L("Package: %S from Vendor: %S"), reportedPackage, reportedVendor); 
+	
+		CleanupStack::PopAndDestroy(reportedPackage);
+		CleanupStack::PopAndDestroy(reportedVendor);
+
+		// get the localised vendor name 
+		HBufC* vendorLocal = entry.LocalizedVendorNameL();
+		CleanupStack::PushL(vendorLocal);
+		INFO_PRINTF2(_L("Localised Vendor Name: %S"), vendorLocal); 
+	
+		CleanupStack::PopAndDestroy(vendorLocal);
+
+		// get uid
+		TUid uid = entry.UidL();
+		INFO_PRINTF3(_L("Package Uid: %d 0x%08x"), uid.iUid, uid.iUid);
+	
+		// get language
+		TLanguage language = entry.LanguageL();
+		INFO_PRINTF3(_L("Package Language: %d 0x%08x"), language, language);
+
+		// get property
+		TInt32 propertyKey = 10;
+		TInt32 propertyValue = entry.PropertyL(propertyKey);
+		INFO_PRINTF3(_L("Package property: key %d  value %d"), propertyKey, propertyValue);
+
+		// is present - currenty relies on default value
+		TBool isPresent = entry.IsPresentL();
+		INFO_PRINTF2(_L("Package present is  %d"), isPresent);
+  	
+  		// is signed
+		TBool isSigned = entry.IsSignedL();
+		INFO_PRINTF2(_L("Package signed is  %d"), isSigned);
+  
+
+		// check Trust
+		switch(entry.TrustL())
+			{
+			case ESisPackageUnsignedOrSelfSigned:
+				INFO_PRINTF1(_L("Packaged Trust: Unsigned or self signed"));
+				break;
+			case ESisPackageCertificateChainNoTrustAnchor:
+				INFO_PRINTF1(_L("Packaged Trust: Certificate Chain has no trust anchor in Cert store"));
+				break;
+			case ESisPackageCertificateChainValidatedToTrustAnchor:
+				INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated to Trust Anchor in Cert store"));
+				break;
+			case ESisPackageChainValidatedToTrustAnchorOCSPTransientError:
+				INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated and OCSP Transient Error"));
+				break;
+			case ESisPackageChainValidatedToTrustAnchorAndOCSPValid:
+				INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated and OCSP Valid"));
+				break;
+			case ESisPackageBuiltIntoRom:
+				INFO_PRINTF1(_L("Packaged Trust: Built into ROM"));
+				break;
+			case ESisPackageValidationFailed:
+				INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validation Failed"));
+				break;
+			default:
+				INFO_PRINTF1(_L("Packaged Trust: Unknown"));
+				break;
+			};
+
+		// Time at which the trust was established
+	  	TTime timeStamp = entry.TrustTimeStampL();
+  		TBuf <32> dateTimeText;
+		TRAP_IGNORE(timeStamp.FormatL(dateTimeText, _L("%H%:1%T%:2%S on %1%/1%2%/2%3")));
+		INFO_PRINTF2(_L("Package Trust Established: %S"), &dateTimeText);
+
+    	// is in rom
+		TBool inRom = entry.IsInRomL();
+		INFO_PRINTF2(_L("Package inRom is  %d"), inRom);
+
+    	// is an augmentation
+		TBool isAug = entry.IsAugmentationL();
+		INFO_PRINTF2(_L("Package isAug is  %d"), isAug);
+  	
+  		// installation size
+		TInt64 size = entry.SizeL();
+		INFO_PRINTF3(_L("Package size is %d %d"), I64HIGH(size), I64LOW(size));
+  	
+  		// get list of files
+  		RPointerArray<HBufC> files;
+  		CleanupResetAndDestroy<RPointerArray<HBufC> >::PushL(files);
+  		entry.FilesL(files);
+ 		INFO_PRINTF2(_L("Package has %d files"), files.Count());
+ 		for (TInt file = 0; file < files.Count(); file++)
+ 			{
+		//	INFO_PRINTF3(_L("File %d  file path %S"),file + 1, files[file]);	  	
+ 			}
+  		CleanupStack::PopAndDestroy(&files);
+  
+		CleanupStack::PopAndDestroy(&entry);
+    	}
+    
+    CleanupStack::PopAndDestroy(&packages);
+	
+	return TestStepResult();
+	}	
+	
+				
+/////////////////////////////////////////////////////////////////////
+// CEntrySidsStep - obtain a list of Sids from an entry
+/////////////////////////////////////////////////////////////////////
+CEntrySidsStep::CEntrySidsStep()
+	{
+	SetTestStepName(KEntrySids);
+	}
+
+TVerdict CEntrySidsStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	RArray<TUid> expectedSids;
+	GetUidArrayFromConfigL(ConfigSection(), KSid, expectedSids);
+	CleanupClosePushL(expectedSids);
+	
+	Swi::RSisRegistryEntry entry;
+	
+	TPtrC package;
+	TPtrC vendor;
+	if(GetStringFromConfig(ConfigSection(), KPackage, package)
+	&& GetStringFromConfig(ConfigSection(), KVendor, vendor))
+		{
+		//StartTimer again to ignore time taken to read from config file
+		StartTimer();
+		User::LeaveIfError(entry.Open(iSisRegistry, package, vendor));
+		}
+	else
+		{
+		TUid packageUid;
+		if(!GetUidFromConfig(ConfigSection(), KUid, packageUid))
+			{
+			ERR_PRINTF1(_L("Neither package-vendor name nor UID found!"));
+			User::Leave(KErrNotFound);
+			}
+		//StartTimer again to ignore time taken to read from config file
+		StartTimer();
+		User::LeaveIfError(entry.Open(iSisRegistry, packageUid));
+		}
+	CleanupClosePushL(entry);
+	
+	RArray<TUid> sids;
+	entry.SidsL(sids);
+	CleanupClosePushL(sids);
+	
+	if (sids.Count() != expectedSids.Count())
+		{
+		ERR_PRINTF3(_L("Actual Sids = %d, Expected Sids = %d"), sids.Count(), expectedSids.Count());
+		}
+	else 
+		{
+		SetTestStepResult(EPass);
+		for (TInt index=0; index < expectedSids.Count(); index++)
+			{
+			if(sids.Find(expectedSids[index]) != KErrNotFound)
+				{
+				INFO_PRINTF2(_L("Sid: 0x%08x was found!"), expectedSids[index]);
+				}
+			else
+				{
+				SetTestStepResult(EFail);
+				ERR_PRINTF2(_L("Sid: 0x%08x not found!"), expectedSids[index]);
+				}
+			}
+		}
+	
+	CleanupStack::PopAndDestroy(3, &expectedSids); // expectedSids, entry, sids
+	return TestStepResult();
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CIsSidPresentStep - test package SIDs are reported as present.
+/////////////////////////////////////////////////////////////////////
+
+CIsSidPresentStep::CIsSidPresentStep()
+	{
+	SetTestStepName(KIsSidPresentStep);
+	}
+
+TVerdict CIsSidPresentStep::doTestStepL()
+	{
+	// iterate through every sid which is installed in a package
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+	
+	iSisRegistry.InstalledPackagesL(packages);
+
+	TInt32 minSid = KMaxTInt32;
+	TInt32 maxSid = KMinTInt32;
+
+	for (TInt i = packages.Count() - 1; i >= 0; --i)
+		{
+		const CSisRegistryPackage& pkg = *packages[i];
+
+		Swi::RSisRegistryEntry e;
+		TInt r = e.Open(iSisRegistry, pkg.Uid());
+		User::LeaveIfError(r);
+		CleanupClosePushL(e);
+
+		RArray<TUid> sids;
+		e.SidsL(sids);
+		CleanupClosePushL(sids);
+
+		for (TInt j = sids.Count() - 1; j >= 0; --j)
+			{
+			TUid sid = sids[j];
+			minSid = Min(minSid, sid.iUid);
+			maxSid = Max(maxSid, sid.iUid);
+			
+			TBool sidPresent = iSisRegistry.IsSidPresentL(sid);
+			TESTL(sidPresent);
+			}
+
+		CleanupStack::PopAndDestroy(2, &e);
+		}
+
+	TUid minSidM1(TUid::Uid(minSid - 1));
+	TESTL(! iSisRegistry.IsSidPresentL(minSidM1));
+	TUid maxSidP1(TUid::Uid(minSid + 1));
+	TESTL(! iSisRegistry.IsSidPresentL(maxSidP1));	
+	
+	CleanupStack::PopAndDestroy(&packages);
+	
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+	
+/////////////////////////////////////////////////////////////////////
+// CIsPackagePresentStep - Test the IsPresent method
+/////////////////////////////////////////////////////////////////////
+
+CIsPackagePresentStep::CIsPackagePresentStep()
+	{
+	SetTestStepName(KIsPackagePresentStep);
+	}
+	
+TVerdict CIsPackagePresentStep::doTestStepL()
+	{
+	SetTestStepResult(EPass);
+	
+	RArray<TUid> pUids;
+	CleanupClosePushL(pUids);
+	GetUidArrayFromConfigL(ConfigSection(), KUid, pUids);
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	// Create a session with the SCR
+	Usif::RSoftwareComponentRegistry scrSession;			
+	User::LeaveIfError(scrSession.Connect());
+	CleanupClosePushL(scrSession);
+	
+	TInt count(pUids.Count());
+	for (TInt i = 0; i < count; ++i)
+		{	
+		// query the registry to see if this entry is present
+		RSisRegistryEntry entry;
+ 		//Since the SisRegistry is inconsistent from hardware and emulator, we won't check
+ 		//whether a package is presented on device if it's not installed at all thus no registry entry (e.g. MIDP)
+ 		#ifdef __WINS__
+ 			User::LeaveIfError(entry.Open(iSisRegistry, pUids[i]));
+ 		#else
+ 			TInt err = entry.Open(iSisRegistry, pUids[i]);
+ 			if(KErrNotFound == err)
+ 				{
+ 				INFO_PRINTF2(_L("Package with UID 0x%08x is not installed on HW. IsPresent test skipped"),
+ 						pUids[i]);
+ 					continue;
+ 				}
+ 			User::LeaveIfError(err);
+ 		#endif
+		CleanupClosePushL(entry);
+		
+		if (!entry.IsPresentL())
+			{
+			INFO_PRINTF2(_L("Package with UID 0x%08x is marked as not present!"),
+				pUids[i]);
+			SetTestStepResult(EFail);
+			CleanupStack::PopAndDestroy(&entry);
+			// Since package is not present in SWI Registry, we are not checking again in SCR
+			continue; 
+			}
+		
+		// Convert the Uid to ComponentId
+		Usif::TComponentId componentId = iSisRegistry.GetComponentIdForUidL(pUids[i]);
+				
+		// Check if the component is present in SCR
+		if (!scrSession.IsComponentPresentL(componentId))
+			{
+			INFO_PRINTF2(_L("Package with UID 0x%08x is present in SWI Registry, but not in SCR"), pUids[i]);
+			SetTestStepResult(EFail);
+			}
+			
+		CleanupStack::PopAndDestroy(&entry);
+		}
+	CleanupStack::PopAndDestroy(2, &pUids); // scrSession, pUids
+	return TestStepResult();
+	}
+CIntegrityCheckStep::CIntegrityCheckStep()
+	{
+	SetTestStepName(KIntegrityCheckStep);
+	}
+CIntegrityCheckStep::~CIntegrityCheckStep()
+	{
+	}
+
+TVerdict CIntegrityCheckStep::doTestStepL()
+	{
+	TInt result=0;
+
+	CleanupResetAndDestroy<RPointerArray<CX509Certificate> >::PushL(iCertArray);
+	
+	InitializeL();
+	TUid pUid;
+	GetUidFromConfig(ConfigSection(), KUid, pUid);
+	GetIntFromConfig(ConfigSection(),KResultTag,result);
+
+	RSisRegistryEntry entry;
+	
+	SetTestStepResult(EFail);
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	// query the registry to see if this entry is present	
+	User::LeaveIfError (entry.Open(iSisRegistry, pUid));
+	
+	//Call the controller
+	TBool check = entry.VerifyControllerSignatureL(iCertArray);
+			
+	if(check!=result)
+		{
+		ERR_PRINTF3(_L("ERROR: Received result: %d.  Expected Result: %d"), check, result);
+		SetTestStepResult(EFail);
+		}
+	else
+		{
+		SetTestStepResult(EPass);
+		}
+	entry.Close();
+	CleanupStack::PopAndDestroy(&iCertArray);
+	return TestStepResult();
+	}
+	
+void CIntegrityCheckStep::InitializeL()
+	{
+	CX509Certificate* cert = NULL;
+	RArray<TPtrC> rootCertificates;
+	CleanupClosePushL(rootCertificates);
+	GetStringArrayFromConfigL(ConfigSection(), KRootCertTag, rootCertificates);
+	
+	User::LeaveIfError (fs.Connect());
+	//opens the data file
+	CleanupClosePushL(fs);
+
+	//Loop through all the X509 root certificates and load them
+	for (TInt i=0; i<rootCertificates.Count(); i++)
+		{
+		HBufC8* rawData = ReadFileLC(rootCertificates[i]);
+		cert = CX509Certificate::NewL(*rawData);
+		CleanupStack::PopAndDestroy(rawData);
+		CleanupStack::PushL(cert);
+		iCertArray.AppendL(cert);
+		CleanupStack::Pop();
+		}
+	
+	//closes the file session
+	CleanupStack::PopAndDestroy(&fs);
+	CleanupStack::PopAndDestroy(&rootCertificates);
+	}
+
+HBufC8* CIntegrityCheckStep::ReadFileLC(const TDesC& aDatapath)
+	{ 	
+	RFile file;
+	User::LeaveIfError(file.Open(fs, aDatapath, EFileRead)) ; 
+	
+	TInt fileSize = 0;
+	User::LeaveIfError(file.Size(fileSize));	
+	
+	HBufC8* rawData = HBufC8::NewLC(fileSize);
+	TPtr8 rawDataPtr(rawData->Des());
+	rawDataPtr.SetLength(fileSize);	
+	file.Read (rawDataPtr);
+	
+	file.Close();
+	
+	return rawData;
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CIntegrityDateAndTimeCheckStep - 
+/////////////////////////////////////////////////////////////////////	
+
+
+CIntegrityDateAndTimeCheckStep::CIntegrityDateAndTimeCheckStep()
+	{
+	SetTestStepName(KDateAndTimeIntegrityCheckStep);
+	}
+
+
+TVerdict CIntegrityDateAndTimeCheckStep::doTestStepPreambleL()
+	{
+	CIntegrityCheckStep::doTestStepPreambleL();
+	
+	GetUidFromConfig(ConfigSection(), KUid, iPackageUid);
+	GetIntFromConfig(ConfigSection(),KResultTag,iExpectedResult);
+	
+	TPtrC dateAndTime;
+	GetStringFromConfig(ConfigSection(), KDateTime, dateAndTime);
+	iTime = TTime(dateAndTime);
+	
+	iOriginalTime.UniversalTime();
+	User::SetUTCTime(iTime);
+	
+	return EPass;
+	}
+
+TVerdict CIntegrityDateAndTimeCheckStep::doTestStepPostambleL()
+	{
+	TTime timeNow;
+	timeNow.UniversalTime();
+	
+	TTimeIntervalMicroSeconds timeInterval = timeNow.MicroSecondsFrom(iTime);
+	timeNow = iOriginalTime + timeInterval;
+	
+	User::SetUTCTime(timeNow);
+	
+	return TestStepResult();
+	}
+
+TVerdict CIntegrityDateAndTimeCheckStep::doTestStepL()
+	{
+	CleanupResetAndDestroy<RPointerArray<CX509Certificate> >::PushL(iCertArray);
+	
+	InitializeL();
+
+	RSisRegistryEntry entry;
+	
+	SetTestStepResult(EPass);
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	// query the registry to see if this entry is present	
+	User::LeaveIfError(entry.Open(iSisRegistry, iPackageUid));
+	CleanupClosePushL(entry);
+	
+	//Call the controller
+	TBool check = EFalse;
+	
+	check = entry.VerifyControllerSignatureL(iCertArray, ETrue);
+	if(check!=iExpectedResult)
+		{
+		ERR_PRINTF3(_L("ERROR: First call to verify failed.  Result: %d.  Expected Result: %d"), check, iExpectedResult);
+		SetTestStepResult(EFail);
+		}
+
+	check = entry.VerifyControllerSignatureL(iCertArray, EFalse);
+	if(check==EFalse)
+		{
+		ERR_PRINTF2(_L("ERROR: Second call to verify failed.  Result: %d.  Expected Result: ETrue"), check);
+		SetTestStepResult(EFail);
+		}
+		
+	check = entry.VerifyControllerSignatureL(iCertArray, ETrue);
+	if(check!=iExpectedResult)
+		{
+		ERR_PRINTF3(_L("ERROR: Third call to verify failed.  Result: %d.  Expected Result: %d"), check, iExpectedResult);
+		SetTestStepResult(EFail);
+		}		
+			
+	CleanupStack::PopAndDestroy(2, &iCertArray);
+	
+	return TestStepResult();
+	}
+
+
+/////////////////////////////////////////////////////////////////////
+// CLoggingFileInfoStep - 
+/////////////////////////////////////////////////////////////////////
+
+CLoggingFileInfoStep::CLoggingFileInfoStep()
+ 	{
+ 	SetTestStepName(KLoggingFileInfo);
+ 	}
+ 
+TVerdict CLoggingFileInfoStep::doTestStepL()
+ 	{
+ 	SetTestStepResult(EPass);
+    __UHEAP_MARK;
+ 	RPointerArray<CLogEntry> fileInfo;
+ 	CleanupResetAndDestroy<RPointerArray<CLogEntry> >::PushL(fileInfo);
+ 	iSisRegistry.RetrieveLogFileL(fileInfo);
+ 
+ 	if	(fileInfo.Count()>0)
+	 	{
+	  	for (TInt i = 0; i < 5; i++)
+	 		{ 
+	 		TInt var = 1;
+	 		TBuf<16> entry;
+	 		entry.Format(_L("LOGENTRY%d.%d"),i,var);	 		
+		  	TPtrC text0;	
+			GetStringFromConfig(ConfigSection(), entry, text0);
+			entry.Format(_L("LOGENTRY%d.%d"),i,++var);
+		 TPtrC text1;	
+		 	GetStringFromConfig(ConfigSection(), entry, text1);
+		 	entry.Format(_L("LOGENTRY%d.%d"),i,++var);
+		 TPtrC text2;	
+		 	GetStringFromConfig(ConfigSection(), entry, text2);
+		 	entry.Format(_L("LOGENTRY%d.%d"),i,++var);
+		 TPtrC text3;	
+		 	GetStringFromConfig(ConfigSection(), entry, text3);
+		 	
+		 	TBuf<16> pkgName = fileInfo[0]->GetPkgName();
+		 	TBuf<20> versiontext;
+			versiontext.Format(_L("%d.%d.%d"),fileInfo[i]->GetMajorVersion(),fileInfo[i]->GetMinorVersion(),fileInfo[i]->GetBuildVersion());
+			
+			enum Swi::TSwiLogTypes s = fileInfo[i]->GetInstallType();
+			TBuf<16> installType ;
+			switch (s)
+					{
+					case 0: // Swi::TSwiLogTypes::ESwiLogInstall :
+						installType.Format(_L("Install"));
+						break;
+					case 1: 
+						installType.Format(_L("UnInstall"));
+						
+						break;
+					case 2: // Swi::TSwiLogTypes::ESwiLogUpgrade :
+					installType.Format(_L("Upgrade"));
+					
+						break;
+					default:
+					installType.Format(_L("Error unknown value"));
+					
+						break;
+					}
+				
+			TBuf<16> uidOfPkg;
+			uidOfPkg.Format(_L("%x"),fileInfo[i]->GetUid());
+			
+			if(pkgName == text0 && versiontext == text1
+			&& installType ==text2 && uidOfPkg ==text3)
+					{
+					SetTestStepResult(EPass);
+					}
+				else
+					{
+					SetTestStepResult(EFail);
+					}
+		  	}
+	 	}
+ 	else
+ 		{
+ 		SetTestStepResult(EPass);
+ 		}
+	CleanupStack::PopAndDestroy(&fileInfo);
+ 	__UHEAP_MARKEND;
+	return TestStepResult();
+ 	}
+
+CRomStubPerformanceStep::CRomStubPerformanceStep()
+	{
+	SetTestStepName(KRomStubPerformanceStep);
+	}
+
+TVerdict CRomStubPerformanceStep::doTestStepL()
+	{
+	// Simple test step to determine how long it takes to
+	// regenerate the cache.
+	
+	// Make sure the sisregistry is deleted before regenerating the cache. This
+	// will ensure that the registry entries are created from the ROM stub, instead
+	// of being read from the harddisk
+	RTestUtilSessionSwi util;
+	User::LeaveIfError(util.Connect());
+	CleanupClosePushL(util);
+	
+	TDriveUnit sysDrive (RFs::GetSystemDrive());
+	TBuf<128> sisRegistryPath (sysDrive.Name());
+	sisRegistryPath.Append(KSisRegistryPath);
+
+	TInt err = util.RmDir(sisRegistryPath);
+	if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)
+		{
+		User::Leave(err);
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Sis Registry Deleted!"));
+		}
+	
+	INFO_PRINTF1(_L("Regenerate the cache. Starting the timer..."));
+	TTime startTime;
+	startTime.UniversalTime();
+
+	// Stop the timer
+	TTime endTime;
+	endTime.UniversalTime();
+	INFO_PRINTF1(_L("Cache regenerated. Timer stopped."));
+
+	TInt64 durationMicro=endTime.MicroSecondsFrom(startTime).Int64();
+	TInt durationMilli=durationMicro/1000;
+	
+	INFO_PRINTF2(_L("Duration (milliseconds): %d"),durationMilli);
+	CleanupStack::PopAndDestroy(&util);
+	
+	SetTestStepResult(EPass);
+
+	return TestStepResult();
+	}
+
+//////////////////////////////////////////////////////////////
+// CCorruptCacheStep - The Sis Registry will leave backup.bak 
+// around when it encounters a corrupt cache file
+//////////////////////////////////////////////////////////////
+
+CCorruptCacheStep::CCorruptCacheStep()
+	{
+	SetTestStepName(KCorruptCacheStep);
+	}
+
+TVerdict CCorruptCacheStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	__UHEAP_MARK;
+	
+	RTestUtilSessionSwi util;
+	User::LeaveIfError(util.Connect());
+	CleanupClosePushL(util);
+	TDriveUnit sysDrive (RFs::GetSystemDrive());
+	TDriveName sysDriveName (sysDrive.Name());
+
+	// Close the Sis Registry and wait for 3 secs for
+	// server to shut down
+	iSisRegistry.Close();
+	
+	INFO_PRINTF1(_L("Sis Registry shut down"));
+	User::After(3000000);
+	
+	// Delete the "good" backup.lst (if present)
+	TInt err = util.Delete(KCacheBackupFile);
+
+	if (err == KErrNone)
+		{
+		INFO_PRINTF2(_L("Deleted '%S'"), &KCacheBackupFile);	
+		}
+	
+	// Use hashforlang_txt.dat as a corrupt backup.lst and connect to the 
+	// Sis Registry.
+	util.Copy(KCorruptCacheBackupFile, KCacheBackupFile);
+	
+	INFO_PRINTF3(_L("Copied '%S' to '%S'"), &KCorruptCacheBackupFile, &KCacheBackupFile);
+	
+	INFO_PRINTF1(_L("Connecting to SisRegistry..."));
+	
+	RProcess sisRegistryServer;
+	TInt retVal = sisRegistryServer.Create(_L("SisRegistryServer"),KNullDesC);
+	
+	if (retVal == KErrNone)
+		{
+		TRequestStatus status;
+		sisRegistryServer.Logon(status);
+		sisRegistryServer.Resume();
+		User::WaitForRequest(status);
+
+		TExitCategoryName panicName = sisRegistryServer.ExitCategory();
+		TPtrC name(panicName);
+		TInt reasonNumber = sisRegistryServer.ExitReason();
+		
+		if (reasonNumber == 0 && name.Compare(_L("Kill")) == KErrNone)
+			{
+			if (util.FileExistsL(KSysBackupFileBackup))
+				{
+				if (util.FileExistsL(KCacheBackupFile))
+					{
+					INFO_PRINTF4(_L("'%S' and '%S' exist in System Drive: %S\\"),
+							&KSysBackupFileBackup, &KCacheBackupFile, &sysDriveName);
+					SetTestStepResult(EPass);
+					}
+				else
+					{
+					INFO_PRINTF3(_L("Expecting '%S' exist in System Drive: %S\\ but not found"),
+								&KCacheBackupFile, &sysDriveName);
+					}
+				}
+			else
+				{
+				INFO_PRINTF3(_L("Expecting '%S' exist in System Drive: %S\\ but not found"),
+							&KSysBackupFileBackup, &sysDriveName);
+				}
+			}
+
+		INFO_PRINTF3(_L("CCorruptCacheStep - Exit Reason Number: %d Exit Reason Code: %S"),
+						reasonNumber, &name);
+		}
+		
+	sisRegistryServer.Terminate(0);
+	sisRegistryServer.Close();
+		
+	CleanupStack::PopAndDestroy(&util);
+
+	__UHEAP_MARKEND;
+	
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////
+// CCorruptCacheRecoverStep - Checks to see if the Sis Registry 
+// recovers from a corrupt token cache file
+////////////////////////////////////////////////////////////////
+
+CCorruptCacheRecoverStep::CCorruptCacheRecoverStep()
+	{
+	SetTestStepName(KCorruptCacheRecoverStep);
+	}
+
+TVerdict CCorruptCacheRecoverStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);	
+	
+	RTestUtilSessionSwi util;
+	User::LeaveIfError(util.Connect());
+	CleanupClosePushL(util);
+	TDriveUnit sysDrive (RFs::GetSystemDrive());
+	TDriveName sysDriveName (sysDrive.Name());
+	
+	// Close the Sis Registry and wait for 3 secs for
+	// the server to shut down
+	iSisRegistry.Close();
+	INFO_PRINTF1(_L("Sis Registry shut down"));
+	User::After(3000000);
+	
+	// Attempt to read from the token cache file
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	
+	RFileReadStream stream;
+	User::LeaveIfError(stream.Open(fs, KCacheBackupFile, EFileRead | EFileShareReadersOnly));
+	CleanupClosePushL(stream);
+	
+	INFO_PRINTF2(_L("'%S' regenerated successfully. Check by reading and internalizing..."), &KCacheBackupFile); 
+	
+	RPointerArray<CSisRegistryToken> tokens;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryToken> >::PushL(tokens);
+	
+	// Will not catch a panic, but still a worthwhile check to make
+	TRAPD(err, stream.ReadUint32L());
+	TRAP(err, InternalizePointerArrayL(tokens, stream));
+	
+	if (err == KErrNone)
+		{
+		INFO_PRINTF2(_L("'%S' successfully read!"), &KCacheBackupFile);
+		
+		if (!util.FileExistsL(KSysBackupFileBackup))
+			{
+			if (util.FileExistsL(KCacheBackupFile))
+				{
+				INFO_PRINTF3(_L("'%S' exist in System Drive: %S\\"),
+							&KCacheBackupFile, &sysDriveName);
+							
+				SetTestStepResult(EPass);
+				}
+			else
+				{
+				INFO_PRINTF3(_L("Expecting '%S' exist in System Drive: %S\\ but not found"),
+							&KCacheBackupFile, &sysDriveName);
+				}
+			}
+		else
+			{
+			INFO_PRINTF3(_L("'%S' exist in System Drive: %S\\ but shouldn't"),
+						&KSysBackupFileBackup, &sysDriveName);
+			}
+		}
+		
+	CleanupStack::PopAndDestroy(4, &util);
+	
+	return TestStepResult();		
+	}
+
+/////////////////////////////////////////////////////////////////////
+// CChangeLocaleStep - Changes the locale
+/////////////////////////////////////////////////////////////////////
+
+CChangeLocaleStep::CChangeLocaleStep()
+	{
+	SetTestStepName(KChangeLocale);
+	}
+
+TVerdict CChangeLocaleStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+
+	TInt language=0;
+    if (!GetIntFromConfig(ConfigSection(), KLanguage, language))
+        {
+        INFO_PRINTF1(_L("Missing language in config section"));
+        return EFail;
+        }
+
+    #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL 
+	_LIT(KLitLanguageLocaleDllNameBase, "elocl_lan");
+	//Region and collation code values are hard coded, as the check, after changing the locale is made for the language only.
+	_LIT(KLitRegionLocaleDllNameBase, "elocl_reg.826");        
+	_LIT(KLitCollationLocaleDllNameBase, "elocl_col.001");
+	_LIT(ThreeDigExt,".%03d");
+	        
+	TExtendedLocale localeDll;    
+	const TUidType uidType(TUid::Uid(0x10000079),TUid::Uid(0x100039e6));
+	TBuf<16> languageLocaleDllName(KLitLanguageLocaleDllNameBase);  
+	languageLocaleDllName.AppendFormat(ThreeDigExt, language);
+	TBuf<16> regionLocaleDllName(KLitRegionLocaleDllNameBase);  
+	TBuf<16> collationLocaleDllName(KLitCollationLocaleDllNameBase);  
+	// Try to load the locale dll
+	TInt error=localeDll.LoadLocale(languageLocaleDllName, regionLocaleDllName, collationLocaleDllName);
+	    
+	if (error==KErrNotFound)
+	    {
+	    // Locale dll is not found for the asked language. 
+	    ERR_PRINTF2(_L("Failed to find the locale dll for %d"), language);
+	    }
+	       
+	User::LeaveIfError(error);
+	localeDll.SaveSystemSettings();
+	
+	#else
+	_LIT(KLitLocaleDllNameBase, "ELOCL");
+	_LIT(TwoDigExt,".%02d");
+	
+	RLibrary localeDll;	
+	CleanupClosePushL(localeDll);
+	
+	const TUidType uidType(TUid::Uid(0x10000079),TUid::Uid(0x100039e6));
+	TBuf<16> localeDllName(KLitLocaleDllNameBase);	
+	localeDllName.AppendFormat(TwoDigExt, language);
+	
+	// Try to load the locale dll
+	TInt error=localeDll.Load(localeDllName, uidType);
+	if (error==KErrNotFound)
+		{
+	    // Locale dll is not found for the asked language. 
+		ERR_PRINTF2(_L("Failed to find the locale dll for %d"), language);
+		}
+	
+	User::LeaveIfError(error);
+	User::LeaveIfError(UserSvr::ChangeLocale(localeDllName));
+	CleanupStack::PopAndDestroy(); // localeDll
+    #endif
+	
+	// Check if the device locale has changed
+	if (language == User::Language())
+		{
+		SetTestStepResult(EPass);
+		}
+	else
+		{
+		ERR_PRINTF3(_L("Failed to change the locale to %d whereas the current locale is"), language, User::Language());
+		}
+
+	return TestStepResult();
+	}
+
+// Creates an dummy token object used in further steps.
+void CreateTokenObjectL(RBufWriteStream& aWriteStream)
+	{
+	// Package details
+	aWriteStream.WriteInt32L(732875480); //Uid
+	aWriteStream << _L("DummyPkg"); // Name
+	aWriteStream << _L("Vendor"); // Vendor 
+	aWriteStream.WriteInt32L(0); // Index
+	
+	aWriteStream.WriteUint32L(0); // Drives
+	
+	aWriteStream.WriteInt32L(0); // SID array count
+	aWriteStream.WriteInt32L(0); // Controller array count
+	
+	// Version
+	aWriteStream.WriteInt32L(1); // Major
+	aWriteStream.WriteInt32L(1); // Minor 
+	aWriteStream.WriteInt32L(1); // Build
+	
+	// user selected options	
+	aWriteStream.WriteInt32L(static_cast<TInt32>(1)); // Selected Language
+	aWriteStream.WriteUint32L(static_cast<TUint32>(25)); // Selected Drive
+	}
+
+
+// These tests are added to improve the coverage.
+CCreateTokenByCopy::CCreateTokenByCopy()
+	{
+	SetTestStepName(KCreateTokenByCopy);
+	}
+
+TVerdict CCreateTokenByCopy::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	CSisRegistryToken* registryToken = CSisRegistryToken::NewL();
+	CleanupStack::PushL(registryToken);
+	
+	// Create a buffer
+	CBufFlat* tokenBuf = CBufFlat::NewL(KDefaultBufferSize);
+	CleanupStack::PushL(tokenBuf);
+	
+	// create write stream
+	RBufWriteStream writeStream(*tokenBuf);
+	CleanupClosePushL(writeStream);
+
+	// Create the dummy token object
+	CreateTokenObjectL(writeStream);
+	
+	// create read stream
+	RBufReadStream readStream(*tokenBuf);
+	CleanupClosePushL(readStream);
+	
+	registryToken->InternalizeL(readStream);
+		
+	CSisRegistryToken* copyRegistryToken = CSisRegistryToken::NewL(*registryToken);
+	CleanupStack::PushL(copyRegistryToken);
+	
+	CleanupStack::PopAndDestroy(5, registryToken); //registryToken, tokenBuf, writeStream, readStream, copyRegistryToken
+	
+	SetTestStepResult(EPass);
+	
+	return TestStepResult();
+	}
+
+CCreateTokenFromStream::CCreateTokenFromStream()
+	{
+	SetTestStepName(KCreateTokenFromStream);
+	}
+
+TVerdict CCreateTokenFromStream::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	// Create a buffer
+	CBufFlat* tokenBuf = CBufFlat::NewL(KDefaultBufferSize);
+	CleanupStack::PushL(tokenBuf);
+	
+	// create write stream
+	RBufWriteStream writeStream(*tokenBuf);
+	CleanupClosePushL(writeStream);
+	
+	// create read stream
+	RBufReadStream readStream(*tokenBuf);
+	CleanupClosePushL(readStream);
+	
+	// Create the dummy token object
+	CreateTokenObjectL(writeStream);	
+	
+	//Ignore the error as we try to read the object an empty stream.
+	CSisRegistryToken* tokenFromStream = CSisRegistryToken::NewL(readStream);
+	CleanupStack::PushL(tokenFromStream);	
+	
+	CleanupStack::PopAndDestroy(4, tokenBuf); // tokenBuf, writeStream, readStream, tokenFromStream
+	
+	SetTestStepResult(EPass);
+	
+	return TestStepResult();
+	}
+
+
+	
+/////////////////////////////////////////////////////////////////////
+// CCertificateChainListStep - Checks the certificate chain count for a given package.
+/////////////////////////////////////////////////////////////////////
+CCertificateChainListStep::CCertificateChainListStep()
+	{
+	SetTestStepName(KCertificateChainListStep);
+	}
+
+TVerdict CCertificateChainListStep::doTestStepL()
+	{
+	SetTestStepResult(EPass);
+	
+	TUid uidOpen;
+	TInt certChainCount;
+	RSisRegistryEntry entry;
+
+	if(!GetUidFromConfig(ConfigSection(), KUid, uidOpen) || !GetIntFromConfig(ConfigSection(), KCertChainCount, certChainCount))
+		{
+		ERR_PRINTF1(_L("Missing package Uid or expected certificate chain count"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	if (KErrNone != entry.Open(iSisRegistry, uidOpen))
+		{
+		SetTestStepResult(EFail);
+	    return TestStepResult();
+	    }
+	CleanupClosePushL(entry);
+	
+	RPointerArray<HBufC8> chains;
+	CleanupResetAndDestroyPushL(chains);
+	TRAP_IGNORE(entry.CertificateChainsL(chains));
+
+	if(chains.Count() != certChainCount)
+		{
+		ERR_PRINTF3(_L("The actual certificate chain count does not meet expected. Expected: %d Actual: %d"), certChainCount, chains.Count());
+		SetTestStepResult(EFail);
+		}
+		
+	CleanupStack::PopAndDestroy(2, &entry);	//chains and entry.
+	return TestStepResult();
+	}
+
+
+////////////////////////////////////////////////////////////////////////////
+// CSidToPackageStep - Returns a pointer to package containing the Sid given
+////////////////////////////////////////////////////////////////////////////
+CSidToPackageStep::CSidToPackageStep()
+	{
+	SetTestStepName(KSidToPackage);
+	}
+
+TVerdict CSidToPackageStep::doTestStepL()
+	{
+	TUid sid;
+	if(!GetUidFromConfig(ConfigSection(), KSid, sid))
+		{
+		ERR_PRINTF1(_L("Sid is missing in the configuration file!"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	
+	CSisRegistryPackage *pckg = iSisRegistry.SidToPackageL(sid);
+	if(!pckg)
+		{
+		ERR_PRINTF1(_L("NULL package returned!"));
+		SetTestStepResult(EFail);
+		}
+	else
+		{
+		delete pckg;
+		}
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CIsSidPresentSingleStep - test package SIDs are reported as present.
+////////////////////////////////////////////////////////////////////////////
+CIsSidPresentSingleStep::CIsSidPresentSingleStep()
+	{
+	SetTestStepName(KIsSidPresentSingleStep);
+	}
+
+TVerdict CIsSidPresentSingleStep::doTestStepL()
+	{
+	TUid sid;
+	if(!GetUidFromConfig(ConfigSection(), KSid, sid))
+		{
+		ERR_PRINTF1(_L("Sid is missing in the configuration file!"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+	
+	TBool expectedresult(EFalse);
+	(void)GetBoolFromConfig(ConfigSection(), KResultTag, expectedresult); // if not specified, expected result is false.
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	TBool result = iSisRegistry.IsSidPresentL(sid);
+	if(result != expectedresult)
+		{
+		ERR_PRINTF2(_L("The result is different from the expected one!"), sid);
+		SetTestStepResult(EFail);
+		}
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CFileDescriptionsStep - Return the file descriptions associated with the given package
+////////////////////////////////////////////////////////////////////////////
+CFileDescriptionsStep::CFileDescriptionsStep()
+	{
+	SetTestStepName(KFileDescriptionsStep);
+	}
+
+TVerdict CFileDescriptionsStep::doTestStepL()
+	{
+	TUid pckgUid;
+	if(!GetUidFromConfig(ConfigSection(), KUid, pckgUid))
+		{
+		ERR_PRINTF1(_L("Package UID is missing in the configuration file!"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+		
+	RSisRegistryWritableEntry writableEntry;
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	TInt err = writableEntry.Open(iSisRegistry, pckgUid);
+	if (KErrNone != err)
+		{
+		ERR_PRINTF2(_L("Writable entry couldn't be opened (Error code=%d)!"), err);
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+	CleanupClosePushL(writableEntry);
+	
+	RPointerArray<CSisRegistryFileDescription> fileDescriptions;
+	CleanupResetAndDestroyPushL(fileDescriptions);
+	writableEntry.FileDescriptionsL(fileDescriptions);
+	TInt fileCount = fileDescriptions.Count();
+	CleanupStack::PopAndDestroy(2, &writableEntry); // writableEntry, fileDescriptions
+	if(!fileCount)
+		return PrintErrorAndReturnFailL(_L("No file returned!"));
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CIsAugmentationStep - whether or not the given package augments another package
+////////////////////////////////////////////////////////////////////////////
+CIsAugmentationStep::CIsAugmentationStep()
+	{
+	SetTestStepName(KIsAugmentationStep);
+	}
+
+TVerdict CIsAugmentationStep::doTestStepL()
+	{
+	TBool expectedresult(EFalse);
+	(void)GetBoolFromConfig(ConfigSection(), KResultTag, expectedresult); // if not specified, expected result is false.
+	
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();
+	
+	TBool result = iRegistryEntry.IsAugmentationL();
+	if(result != expectedresult)
+		{
+		ERR_PRINTF1(_L("The result is different from the expected one!"));
+		SetTestStepResult(EFail);
+		}
+	
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CFilesStep - Provides a list of files installed by the given package
+////////////////////////////////////////////////////////////////////////////
+CFilesStep::CFilesStep()
+	{
+	SetTestStepName(KFilesStep);
+	}
+
+TVerdict CFilesStep::doTestStepL()
+	{	
+	RPointerArray<HBufC> files;
+	CleanupResetAndDestroyPushL(files);
+	iRegistryEntry.FilesL(files);
+	if(!files.Count())
+		{
+		ERR_PRINTF1(_L("The package files couldn't be retrieved!"));
+		SetTestStepResult(EFail);
+		}
+	CleanupStack::PopAndDestroy(&files);
+	
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CAugmentationsStep - Returns all augmentations to the given package.
+////////////////////////////////////////////////////////////////////////////
+CAugmentationsStep::CAugmentationsStep()
+	{
+	SetTestStepName(KAugmentationsStep);
+	}
+
+TVerdict CAugmentationsStep::doTestStepL()
+	{	
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroyPushL(packages);
+	iRegistryEntry.AugmentationsL(packages);
+	if(!packages.Count())
+		{
+		ERR_PRINTF1(_L("The augmentation package couldn't be retrieved!"));
+		SetTestStepResult(EFail);
+		}
+	CleanupStack::PopAndDestroy(&packages);
+	
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CPackageStep - Returns the package of a current entry
+////////////////////////////////////////////////////////////////////////////
+CPackageStep::CPackageStep()
+	{
+	SetTestStepName(KPackageStep);
+	}
+
+TVerdict CPackageStep::doTestStepL()
+	{	
+	CSisRegistryPackage* package=iRegistryEntry.PackageL();
+	if(!package)
+		{
+		ERR_PRINTF1(_L("The package couldn't be retrieved!"));
+		SetTestStepResult(EFail);
+		}
+	delete package;
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CDependentPackagesStep - Returns the array of packages dependent on the given package.
+////////////////////////////////////////////////////////////////////////////
+CDependentPackagesStep::CDependentPackagesStep()
+	{
+	SetTestStepName(KDependentPackagesStep);
+	}
+
+TVerdict CDependentPackagesStep::doTestStepL()
+	{
+	RPointerArray<CSisRegistryPackage> dependents;
+	CleanupResetAndDestroyPushL(dependents);
+	iRegistryEntry.DependentPackagesL(dependents);
+	if(!dependents.Count())
+		{
+		ERR_PRINTF1(_L("The dependant package couldn't be retrieved!"));
+		SetTestStepResult(EFail);
+		}
+	CleanupStack::PopAndDestroy(&dependents);;
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CDependenciesStep - Returns the dependency array for the given package
+////////////////////////////////////////////////////////////////////////////
+CDependenciesStep::CDependenciesStep()
+	{
+	SetTestStepName(KDependenciesStep);
+	}
+
+TVerdict CDependenciesStep::doTestStepL()
+	{
+	RPointerArray<CSisRegistryDependency> dependencies;
+	CleanupResetAndDestroyPushL(dependencies);
+	iRegistryEntry.DependenciesL(dependencies);
+	if(!dependencies.Count())
+		{
+		ERR_PRINTF1(_L("The dependency package couldn't be retrieved!"));
+		SetTestStepResult(EFail);
+		}
+	CleanupStack::PopAndDestroy(&dependencies);;
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CEmbeddedPackagesStep - return a array of packages that were embedded within the given package.
+////////////////////////////////////////////////////////////////////////////
+CEmbeddedPackagesStep::CEmbeddedPackagesStep()
+	{
+	SetTestStepName(KEmbeddedPackagesStep);
+	}
+
+TVerdict CEmbeddedPackagesStep::doTestStepL()
+	{
+	RPointerArray<CSisRegistryPackage> embedded;
+	CleanupResetAndDestroyPushL(embedded);
+	iRegistryEntry.EmbeddedPackagesL(embedded);
+	if(!embedded.Count())
+		{
+		ERR_PRINTF1(_L("The embedded package couldn't be retrieved!"));
+		SetTestStepResult(EFail);
+		}
+	CleanupStack::PopAndDestroy(&embedded);;
+	return TestStepResult();
+	}
+	
+
+// Test creation of SisRegistryObject.
+
+CCreateSisRegistryObject::CCreateSisRegistryObject()
+	{
+	SetTestStepName(KCreateSisRegistryObject);
+	}
+
+TVerdict CCreateSisRegistryObject::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	CSisRegistryObject* registryObject = CSisRegistryObject::NewL();
+	delete registryObject;
+	
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+
+////////////////////////////////////////////////////////////////////////////
+// CIsFileRegisteredStep - Tests IsFileRegisteredL API in SWI Registry
+////////////////////////////////////////////////////////////////////////////
+CIsFileRegisteredStep::CIsFileRegisteredStep()
+	{
+	SetTestStepName(KIsFileRegisteredStep);
+	}
+
+TVerdict CIsFileRegisteredStep::doTestStepL()
+	{
+	TBool expectedResult(EFalse);
+	GetBoolFromConfig(ConfigSection(), _L("expectedResult"), expectedResult);
+	TPtrC testedFilename;
+	if (!GetStringFromConfig(ConfigSection(), _L("testedFilename"), testedFilename))
+		{
+		ERR_PRINTF1(_L("testedFilename property was not found in IsFileRegistered test step!"));
+		SetTestStepResult(EFail);		
+		return TestStepResult();
+		}
+	INFO_PRINTF2(_L("Testing presence of file %S in the registry"), &testedFilename);
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	TBool foundResult = iSisRegistry.IsFileRegisteredL(testedFilename);	
+	if (foundResult != expectedResult)
+		{
+		ERR_PRINTF3(_L("File presence test failed! Expected %d, but received %d"), expectedResult, foundResult);
+		SetTestStepResult(EFail);				
+		}
+	return TestStepResult();
+	}
+
+CGetComponentIdForUidStep::CGetComponentIdForUidStep()
+	{
+	}
+	
+TVerdict CGetComponentIdForUidStep::doTestStepL()
+	{
+	TUid uid;
+	if (!GetUidFromConfig(ConfigSection(), _L("uid"), uid))
+		{
+		ERR_PRINTF1(_L("uid property was not found in GetComponentIdForUid test step!"));
+		SetTestStepResult(EFail);		
+		return TestStepResult();
+		}	
+	INFO_PRINTF2(_L("Retrieving component id for UID %d"), uid.iUid);
+
+	//StartTimer again to ignore time taken to read from config file
+	StartTimer();	
+	
+	Usif::TComponentId componentId = iSisRegistry.GetComponentIdForUidL(uid);
+	INFO_PRINTF3(_L("Retrieved component id %d for UID %d"), componentId, uid.iUid);
+	return TestStepResult();
+	}
+	
+// Test creation of CSisRegistryDependency objects.
+
+// Creates a dummy CSisRegistryDependency object.
+void CreateSisRegDependencyObjectL(RBufWriteStream& aWriteStream)
+	{
+	// Package Uid
+	aWriteStream.WriteInt32L(732875480); //Uid
+	
+	// From Version
+	aWriteStream.WriteInt32L(1); // Major
+	aWriteStream.WriteInt32L(0); // Minor 
+	aWriteStream.WriteInt32L(0); // Build
+	
+	// To Version
+	aWriteStream.WriteInt32L(2); // Major
+	aWriteStream.WriteInt32L(0); // Minor 
+	aWriteStream.WriteInt32L(0); // Build
+	}
+	
+CSisRegistryDependencyStep::CSisRegistryDependencyStep()
+	{
+	SetTestStepName(KSisRegistryDependencyStep);
+	}
+	
+TVerdict CSisRegistryDependencyStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	// Create a buffer
+	CBufFlat* buffer = CBufFlat::NewL(KDefaultBufferSize);
+	CleanupStack::PushL(buffer);
+	
+	// create write stream
+	RBufWriteStream writeStream(*buffer);
+	CleanupClosePushL(writeStream);
+	
+	// create read stream
+	RBufReadStream readStream(*buffer);
+	CleanupClosePushL(readStream);
+	
+	CreateSisRegDependencyObjectL(writeStream);	
+	
+	CSisRegistryDependency* objFromStream = CSisRegistryDependency::NewL(readStream);
+	CleanupStack::PushL(objFromStream);	
+	
+	CSisRegistryDependency* objectByCopy = CSisRegistryDependency::NewL(*objFromStream);
+	CleanupStack::PushL(objectByCopy);
+	
+	_LIT(KPkgMajor, "pkgMajor");
+	TInt pkgMajor = 0;
+	if(!GetIntFromConfig(ConfigSection(), KPkgMajor, pkgMajor))
+		{
+		ERR_PRINTF1(_L("Missing major version!"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+	
+	_LIT(KPkgMinor, "pkgMinor");
+	TInt pkgMinor = 0;
+	if(!GetIntFromConfig(ConfigSection(), KPkgMinor, pkgMinor))
+		{
+		ERR_PRINTF1(_L("Missing minor version!"));
+		SetTestStepResult(EFail);
+		return TestStepResult();	
+		}
+	
+	_LIT(KPkgBuild, "pkgBuild");
+	TInt pkgBuild = 0;
+	if(!GetIntFromConfig(ConfigSection(), KPkgBuild, pkgBuild))
+		{
+		ERR_PRINTF1(_L("Missing build!"));
+		SetTestStepResult(EFail);
+		return TestStepResult();
+		}
+	
+	TVersion version(pkgMajor, pkgMinor, pkgBuild);
+	
+	if(!(objectByCopy->IsCompatible(version)))
+		{
+		SetTestStepResult(EFail);
+		}
+	
+	CleanupStack::PopAndDestroy(5, buffer); // buffer, writeStream, readStream, objFromStream and objByCopy.
+	SetTestStepResult(EPass);
+	
+	return TestStepResult();
+	}
+	
+// Test creation of CSisRegistryFileDescription object.
+
+CSisRegistryFileDescStep::CSisRegistryFileDescStep()
+	{
+	SetTestStepName(KSisRegistryFileDescStep);
+	}
+	
+void CSisRegistryFileDescStep::CreateSisRegFileDescObjectL(RBufWriteStream& aWriteStream, TDesC8& aHashData, TDesC& aTarget, TDesC& aMimeType)
+	{
+	aWriteStream << aTarget;			//file name
+	aWriteStream << aMimeType;			// file mime type
+	aWriteStream.WriteInt32L(1);		//operation
+	aWriteStream.WriteInt32L(1);		//operation options
+	aWriteStream.WriteInt32L(2);		//hash algorithm
+	aWriteStream << aHashData;			//hash data
+	aWriteStream.WriteInt32L(1200);		//uncompressed length
+	aWriteStream.WriteInt32L(1400);		//uncompressed length
+	aWriteStream.WriteInt32L(0);		//index
+	aWriteStream.WriteInt32L(12341212);	//SID.	
+	}
+	
+TVerdict CSisRegistryFileDescStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	CSisRegistryFileDescription* object = CSisRegistryFileDescription::NewL();
+	delete object;
+	
+	// Create a buffer
+	CBufFlat* buffer = CBufFlat::NewL(KDefaultBufferSize);
+	CleanupStack::PushL(buffer);
+	
+	// create write stream
+	RBufWriteStream writeStream(*buffer);
+	CleanupClosePushL(writeStream);
+	
+	// create read stream
+	RBufReadStream readStream(*buffer);
+	CleanupClosePushL(readStream);
+	
+	_LIT8(KHashData, "kshfashgkghsrewiturtugit");
+	TInt dataLen = 24;
+	HBufC8* hashData = HBufC8::NewLC(dataLen);
+	*hashData = KHashData;
+	
+	_LIT(KTargetName, "c:\\sys\\bin\\test.exe");
+	HBufC* target = HBufC::NewLC(dataLen);
+	*target = KTargetName;
+	
+	HBufC* mimeType = HBufC::NewLC(dataLen);
+	
+	CreateSisRegFileDescObjectL(writeStream, *hashData, *target, *mimeType);
+
+	CSisRegistryFileDescription* obj = CSisRegistryFileDescription::NewL(readStream);
+	delete obj;
+	
+	CleanupStack::PopAndDestroy(6, buffer);	//mime type, target, hashData, readStream, writeStream and buffer.
+		
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+	
+// Test creation of CControllerInfo object.
+
+CControllerInfoStep::CControllerInfoStep()
+	{
+	SetTestStepName(KControllerInfoStep);
+	}
+
+
+// Creates an dummy CControllerInfo object.
+void CControllerInfoStep::CreateCControllerInfoObjectL(RBufWriteStream& aWriteStream, TDesC8& aHashData)
+	{
+	aWriteStream.WriteInt32L(1);		//major version
+	aWriteStream.WriteInt32L(0);		//minor version
+	aWriteStream.WriteInt32L(1);		//build version
+ 	aWriteStream.WriteInt32L(0);		//offset	
+ 	aWriteStream.WriteInt32L(2);		//hash algorithm
+  	aWriteStream << aHashData;			//hashdata
+ 	}
+
+TVerdict CControllerInfoStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	// Create a buffer
+	CBufFlat* buffer = CBufFlat::NewL(KDefaultBufferSize);
+	CleanupStack::PushL(buffer);
+	
+	// create write stream
+	RBufWriteStream writeStream(*buffer);
+	CleanupClosePushL(writeStream);
+	
+	// create read stream
+	RBufReadStream readStream(*buffer);
+	CleanupClosePushL(readStream);
+	
+	_LIT8(KHashData, "kshfashgkghs");
+	TInt dataLen = 12;
+	HBufC8* hashData = HBufC8::NewLC(dataLen);
+	*hashData = KHashData;
+	
+	CreateCControllerInfoObjectL(writeStream, *hashData);
+	
+	CControllerInfo* objFromStream = CControllerInfo::NewL(readStream);
+	CleanupStack::PushL(objFromStream);	
+	
+	CControllerInfo* object = CControllerInfo::NewL(*objFromStream);
+	delete object;
+	
+	TVersion version(1, 5, 9);
+	CHashContainer* hashContainer = CHashContainer::NewLC(CMessageDigest::ESHA1, *hashData);
+
+	CControllerInfo* controllerObj = CControllerInfo::NewL(version, *hashContainer);
+	CleanupStack::PushL(controllerObj);
+	
+	TVersion controllerVersion = controllerObj->Version();
+	if((controllerVersion.iMajor!= version.iMajor) || (controllerVersion.iMinor!= version.iMinor) || (controllerVersion.iBuild!= version.iBuild))
+		{
+		SetTestStepResult(EFail);
+		}
+	
+	CleanupStack::PopAndDestroy(7, buffer);	//controllerObj, hashContainer, objFromStream, hashData, readStream, writeStream and buffer.
+		
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+
+// Test creation of CSisRegistryProperty object.
+
+CSisRegistryPropertyStep::CSisRegistryPropertyStep()
+	{
+	SetTestStepName(KSisRegistryPropertyStep);
+	}
+
+
+// Creates an dummy CSisRegistryProperty object.
+void CSisRegistryPropertyStep::CreateCSisRegPropertyObjectL(RBufWriteStream& aWriteStream)
+	{
+	aWriteStream.WriteInt32L(1);		//key
+	aWriteStream.WriteInt32L(-1);		//value
+ 	}
+
+TVerdict CSisRegistryPropertyStep::doTestStepL()
+	{
+	SetTestStepResult(EFail);
+	
+	// Create a buffer
+	CBufFlat* buffer = CBufFlat::NewL(KDefaultBufferSize);
+	CleanupStack::PushL(buffer);
+	
+	// create write stream
+	RBufWriteStream writeStream(*buffer);
+	CleanupClosePushL(writeStream);
+	
+	// create read stream
+	RBufReadStream readStream(*buffer);
+	CleanupClosePushL(readStream);
+	
+	CreateCSisRegPropertyObjectL(writeStream);
+	
+	CSisRegistryProperty* object = CSisRegistryProperty::NewL(readStream);
+	delete object;	
+	
+	CleanupStack::PopAndDestroy(3, buffer);	//readStream, writeStream and buffer.
+		
+	SetTestStepResult(EPass);
+	return TestStepResult();
+	}
+
+//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+// This test case is used only for performance measurement to check that a typical UI app. manager performs well with the SWI Registry
+CSisApplicationManagerStep::CSisApplicationManagerStep()
+	{
+	SetTestStepName(KApplicationManagerStep);
+	}
+	
+TVerdict CSisApplicationManagerStep::doTestStepL()
+	{
+	RPointerArray<CSisRegistryPackage> packages;
+	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+	// First get the list of removable packages
+	iSisRegistry.RemovablePackagesL(packages);	
+	for (TInt i = 0; i < packages.Count(); ++i)
+		{
+	    Swi::RSisRegistryEntry entry;
+    	User::LeaveIfError(entry.OpenL(iSisRegistry, *packages[i]));
+    	CleanupClosePushL(entry);
+		TBool isPresent = entry.IsPresentL();
+		TSisPackageTrust trust = entry.TrustL();
+		TInt64 size = entry.SizeL();
+		TVersion version = entry.VersionL();
+		// Disable compiler warnings
+		while (isPresent && trust && size && version.iMajor)
+			break;
+		CleanupStack::PopAndDestroy(&entry);		
+		}	
+	CleanupStack::PopAndDestroy(&packages);
+	SetTestStepResult(EPass);
+	return TestStepResult();	
+	}