/*

* 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 <test/testexecutestepbase.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>

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

// 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(KController, "ctl");

_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(KLanguage, "language");

_LIT(KRegFileName, "regfilename");

_LIT(KCtlCount, "ctlcount");

_LIT(KHashCount, "hashcount");

_LIT(KIndex, "index");

_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;

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

// CSisRegistryStep

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

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!"));

	return TestStepResult();

	}

TVerdict CSisRegistrySessionStep::doTestStepPostambleL()

	{

	// Remove the installed active scheduler

	CActiveScheduler* s = CActiveScheduler::Current();

	s->Install(NULL);

	delete s;

	iSisRegistry.Close();

	__UHEAP_MARKEND;

	return TestStepResult();

	}

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

// CEmbeddingPackageStep - Checks the embedding packages for a given package

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

CEmbeddingPackageStep::CEmbeddingPackageStep()

	{

	SetTestStepName(KEmbeddingPackageStep);

	}

TVerdict CEmbeddingPackageStep::doTestStepL()

	{

	RSisRegistryEntry entry;

	RPointerArray<Swi::CSisRegistryPackage> packages;

	SetTestStepResult(EPass);

	TUid uidOpen;

	TInt embeddingPkgCount;

	if(!GetUidFromConfig(ConfigSection(), KUid, uidOpen) || !GetIntFromConfig(ConfigSection(), KPkgCount, embeddingPkgCount))

		{

		ERR_PRINTF1(_L("Missing package Uid or expected package count"));

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	if (KErrNone != entry.Open(iSisRegistry, uidOpen))

		{

		SetTestStepResult(EFail);

	    return TestStepResult();

	    }

	CleanupClosePushL(entry);

	entry.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(2, &entry);

	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;

	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();

	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);

		}

	// 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();

			// NOTE: The following block of code is temporary,

			//       so we can get the hash values first.

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

			// Name the file that will contain the expected hash value;

			// on the 2nd iteration, this would have to be substituted

			// by "c:\\system\\data\\hashForLang_txt.dat".

			//_LIT(KHashFile, "c:\\system\\data\\hashForTestsidcheck_A_exe.dat");

			// Create and open the (binary) file for writing later.

			//RFs fs_util;

			//User::LeaveIfError(fs_util.Connect());

			//CleanupClosePushL(fs_util);

			//RFile fileToWrite;

			//User::LeaveIfError(fileToWrite.Create(fs_util, KHashFile,

			//										EFileWrite | EFileStream));

			//CleanupClosePushL(fileToWrite);

			//User::LeaveIfError(fileToWrite.Write(calcHashValue));

			//CleanupStack::PopAndDestroy(&fileToWrite);

			//CleanupStack::PopAndDestroy(&fs_util);

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

		// 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_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);

	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);

	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);

	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)

			{