// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Contains tests to exercise the hash checking feature for removable drives

// 

//

#include <ecom/ecom.h>

#include "../EcomTestUtils/EcomTestUtils.h"

#include <hash.h>

#include <swi/swispubsubdefs.h>

#include "../Example/EComHashExample.h"

#include "../EcomTestUtils/TPropertyManager.h"

using namespace Swi;

LOCAL_D RTest test(_L("t_hashcheck.exe"));

LOCAL_D CTrapCleanup* 	  TheTrapCleanup 	 = NULL;

LOCAL_D CActiveScheduler* TheActiveScheduler = NULL;

LOCAL_D RFs					TheFs;

#define UNUSED_VAR(a) a = a

// Implementaion IDs used for testing

const TUid KUidTestInterface = {0x10009E34};

const TUid KUidTestImplementation = {0x10009E35};

// Plugins used in tests.

_LIT(KEComHashExampleDllOnZ, "z:\\RAMOnly\\EComHashExample.dll");

_LIT(KEComHashExampleRscOnZ, "z:\\RAMOnly\\EComHashExample.rsc");

_LIT(KEComAllRSCFilesName,					"\\Resource\\Plugins\\*.rsc");

_LIT(KEComRscDirName,						"\\Resource\\Plugins");

#if defined(__WINSCW__) // X: on emulator

_LIT(KEComHashExampleDllOnRemovableDrive, "X:\\sys\\bin\\EComHashExample.dll");

_LIT(KEComHashExampleRscOnRemovableDrive, "X:\\resource\\plugins\\EComHashExample.rsc");

#else // E: on hardware

_LIT(KEComHashExampleDllOnRemovableDrive, "E:\\sys\\bin\\EComHashExample.dll");

_LIT(KEComHashExampleRscOnRemovableDrive, "E:\\resource\\plugins\\EComHashExample.rsc");

#endif

// hash files

_LIT(KEComTempHashFileOnC, "c:\\EComTempHashFile.dll");

_LIT(KEComTempCorruptHashFileOnC, "c:\\EComTempCorruptHashFile.dll");

_LIT(KEComHashExampleHashFileOnRemovableDrive, "c:\\sys\\hash\\EComHashExample.dll");

_LIT(KEComCorruptHash, "12345678912345678900");

const TInt KHashFileReadSize = 1024*8;

void CreateTempHashFileL()

	{

	// Create valid hash file for the DLL to be used during this test.

	TInt readsize = KHashFileReadSize;

	HBufC8* block0 = HBufC8::NewLC(readsize);

	TPtr8 fileblock0(block0->Des());

	CSHA1* hasher=CSHA1::NewL();

	CleanupStack::PushL(hasher);

	RFile file;

       CleanupClosePushL(file);

	User::LeaveIfError(file.Open(TheFs, KEComHashExampleDllOnZ, EFileRead));

	TInt size;

	User::LeaveIfError(file.Size(size));

	TInt offset=0;

	do  {

		if((size - offset) < readsize)

			readsize = (size - offset);

		User::LeaveIfError(file.Read(offset, fileblock0, readsize));

		hasher->Update(fileblock0);

		offset+=readsize;

		}

	while(offset < size);

	CleanupStack::PopAndDestroy(1); // file

	TBuf8<SHA1_HASH> hash;

	hash=hasher->Final();

	CleanupStack::PopAndDestroy(2); // block0, hasher

	// write hash to file

	RFile tempHashFile;

       CleanupClosePushL(tempHashFile);

      	User::LeaveIfError(tempHashFile.Replace(TheFs, KEComTempHashFileOnC, EFileWrite));

	tempHashFile.Write(hash);

	CleanupStack::PopAndDestroy(1); // tempHashFile

    }

void DeleteTempHashFileL()

	{

	TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComTempHashFileOnC));

	test(err == KErrNone);

	}

void CreateTempCorruptHashFileL()

	{

	// write corrupt hash to file

	TBuf8<SHA1_HASH> hash;

	hash.Append(KEComCorruptHash);

	RFile tempHashFile;

       CleanupClosePushL(tempHashFile);

      	User::LeaveIfError(tempHashFile.Replace(TheFs, KEComTempCorruptHashFileOnC, EFileWrite));

	tempHashFile.Write(hash);

	CleanupStack::PopAndDestroy(1); // tempHashFile

	}

void DeleteTempCorruptHashFileL()

	{

	TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComTempCorruptHashFileOnC));

	test(err == KErrNone);

	}

void CopyHashFile()

	{

	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComTempHashFileOnC,

											KEComHashExampleHashFileOnRemovableDrive));

	test(err == KErrNone);

	}

void DeleteHashFile()

	{

	TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComHashExampleHashFileOnRemovableDrive));

	UNUSED_VAR(err);

	// If ECOM server is already running we need to allow some time for re-discovery

	// to complete.

	WAIT_FOR3s;

	}

void CopyCorruptHashFile()

	{

	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComTempCorruptHashFileOnC,

											KEComHashExampleHashFileOnRemovableDrive));

	test(err == KErrNone);

	}

void CopyPlugins()

	{

	TRAPD(err, EComTestUtils::FileManCopyFileL(KEComHashExampleDllOnZ, KEComHashExampleDllOnRemovableDrive));

	test(err == KErrNone);

	TRAP(err, EComTestUtils::FileManCopyFileL(KEComHashExampleRscOnZ, KEComHashExampleRscOnRemovableDrive));

	test(err == KErrNone);

	// If ECOM server is already running we need to allow some time for re-discovery

	// to complete.

	WAIT_FOR3s;

	}

void DeletePlugins()

	{

	TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComHashExampleDllOnRemovableDrive));

	UNUSED_VAR(err);

	TRAP(err, EComTestUtils::FileManDeleteFileL(KEComHashExampleRscOnRemovableDrive));

	UNUSED_VAR(err);

	// If ECOM server is already running we need to allow some time for re-discovery

	// to complete.

	WAIT_FOR3s;

	}

void DeleteRSCFolderOnDrive(TUint aDriveNum)

	{

	TInt err=KErrNone;

	TDriveUnit aDrive(aDriveNum);

	TBuf<256> resourceFileName;

	resourceFileName.Append(aDrive.Name());

	resourceFileName.Append(KEComAllRSCFilesName);

	TRAP(err, EComTestUtils::FileManDeleteFileL(resourceFileName));

	TBuf<256> resourceDirName;

	resourceDirName.Append(aDrive.Name());

	resourceDirName.Append(KEComRscDirName);

	TRAP(err, EComTestUtils::FileManDeleteDirL(resourceDirName));

	}

TBool IsImplementationListedL()

	{

	RImplInfoPtrArray implArray;

	REComSession::ListImplementationsL(KUidTestInterface, implArray);

	TBool found = EFalse;

	TInt count = implArray.Count();

	while(count)

		{

		count--;

		if(implArray[count]->ImplementationUid() == KUidTestImplementation)

			{

			found = ETrue;

			break;

			}

		}

	REComSession::FinalClose();

	implArray.ResetAndDestroy();

	return found;

	}

TInt IsImplementationCreatedL()

	{

	TUid dtor_ID_Key;

	TAny* ptr = NULL;

	TRAPD(err, ptr = REComSession::CreateImplementationL(KUidTestImplementation, dtor_ID_Key));

	CImplementationHashExample* implPtr = reinterpret_cast <CImplementationHashExample*> (ptr);

	if(err == KErrNone)

		{

		REComSession::DestroyedImplementation(dtor_ID_Key);

		delete implPtr;

		}

	REComSession::FinalClose();

	return err;

	}

void	DoPreInstall()

	{

	// Install in progress

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall);

	CopyHashFile();

	WAIT_FOR1s;

	// Install successful

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall);

	WAIT_FOR3s;

	// Reset

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone);

	WAIT_FOR1s;

	}

void	DoCorruptPreInstall()

	{

	// Install in progress

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall);

	CopyCorruptHashFile();

	WAIT_FOR1s;

	// Install successful

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall);

	WAIT_FOR3s;

	// Reset

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone);

	WAIT_FOR1s;

	}

void	DoPreUninstall()

	{

	// Uninstall in progress

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisUninstall);

	DeleteHashFile();

	WAIT_FOR1s;

	// Uninstall successful

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisUninstall);

	WAIT_FOR3s;

	// Reset

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone);

	WAIT_FOR1s;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1922

@SYMTestCaseDesc Test that implementation on removable drive is not available

	when no hash file has been installed.

@SYMTestPriority High

@SYMTestActions	 Copy plugins to removable drive.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is unavailable.

@SYMTestExpectedResults The test must not fail.

@SYMDEF PDEF090578

*/

LOCAL_C void TestNoHashFileInstalledL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1922 "));

	__UHEAP_MARK;

	// Test ListImplementations()

	CopyPlugins();

	TBool implListed = IsImplementationListedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be listed.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no hash so the implementation is

	// not listed.

	test(!implListed);

	// Test CreateImplementation()

	TInt implCreated = IsImplementationCreatedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be created.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no hash so the implementation is

	// not created.

	test(implCreated == KErrNotFound);

	DeletePlugins();

	__UHEAP_MARKEND;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1923

@SYMTestCaseDesc Test that implementation on removable drive is available

	when a Pre Install occurs exists.

@SYMTestPriority High

@SYMTestActions	 Copy plugins to removable drive.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is unavailable.

				 Emulate pre-install.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is available.

				 Emulate uninstall.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is unavailable.

@SYMTestExpectedResults The test must not fail.

@SYMDEF PDEF090578

*/

LOCAL_C void TestPreInstallL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1923 "));

	__UHEAP_MARK;

	// Only copy plugins - during pre-install plugins exists before the install occurs

	CopyPlugins();

	// Test ListImplementations()

	TBool implListed = IsImplementationListedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be listed.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no hash because install has not occurred

	// so the implementation is not listed.

	test(!implListed);

	// Test CreateImplementation()

	// No hash so no implementation should  be created.

	TInt implCreated = IsImplementationCreatedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be created.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no hash because install has not occurred

	// so the implementation is not created.

	test(implCreated == KErrNotFound);

	// Do install

	DoPreInstall();

	// Test ListImplementations()

	implListed = IsImplementationListedL();

	_LIT(KMessage3,"Pre-Install 3: List = %d");

	RDebug::Print(KMessage3, implListed);

	// Check implementation

#if defined(__WINSCW__)

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be listed.

	//

	test(!implListed);

#else

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is a hash so the implementation is

	// listed.

	test(implListed);

#endif

	// Test CreateImplementation()

	implCreated = IsImplementationCreatedL();

	// Check implementation was created

#if defined(__WINSCW__)

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be created.

	//

	test(implCreated == KErrNotFound);

#else

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is a hash so the implementation is

	// created.

	test(implCreated == KErrNone);

#endif

	__UHEAP_MARKEND;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1924

@SYMTestCaseDesc Test that implementation on removable drive is unavailable

	after an uninstall occurs.

@SYMTestPriority High

@SYMTestActions	 Emulate uninstall.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is unavailable.

@SYMTestExpectedResults The test must not fail.

@SYMDEF PDEF090578

*/

LOCAL_C void TestPreUninstallL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1924 "));

	__UHEAP_MARK;

	// Do uninstall

	DoPreUninstall();

	// Test ListImplementations()

	TBool implListed = IsImplementationListedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be listed.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no hash so the implementation is

	// not listed.

	test(!implListed);

	// Test CreateImplementation()

	TInt implCreated = IsImplementationCreatedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be created.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no hash so the implementation is

	// not created.

	test(implCreated == KErrNotFound);

	DeletePlugins();

	__UHEAP_MARKEND;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1925

@SYMTestCaseDesc Test that implementation on removable drive is unavailable

	if the hash is corrupted for the DLL.

@SYMTestPriority High

@SYMTestActions	 Emulate pre-install with a corrupted hash file.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is unavailable.

@SYMTestExpectedResults The test must not fail.

@SYMDEF PDEF090578

*/

LOCAL_C void TestCorruptHashL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1925 "));

	__UHEAP_MARK;

	// Only copy plugins - during pre-install plugins exists before the install occurs

	CopyPlugins();

	// Do pre install

	DoCorruptPreInstall();

	// Test ListImplementations()

	TBool implListed = IsImplementationListedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be listed.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case the hash file is corrupted so the implementation is

	// not listed.

	test(!implListed);

	// Test CreateImplementation()

	TInt implCreated = IsImplementationCreatedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be created.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case the hash file is corrupted so the implementation is

	// not created.

	test(implCreated == KErrNotFound);

	DeletePlugins();

	DeleteHashFile();

	__UHEAP_MARKEND;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1926

@SYMTestCaseDesc Test that implementation on removable drive is available

	when a full Install occurs exists.

@SYMTestPriority High

@SYMTestActions	 Copy plugins to removable drive.

				 Emulate pre-install.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is available.

@SYMTestExpectedResults The test must not fail.

@SYMDEF PDEF090578

*/

LOCAL_C void TestFullInstallL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1926 "));

	__UHEAP_MARK;

	// Only copy plugins - during pre-install plugins exists before the install occurs

	CopyPlugins();

	// Do install

	DoPreInstall();

	// Test ListImplementations()

	TBool implListed = IsImplementationListedL();

	// Test CreateImplementation()

	TInt implCreated = IsImplementationCreatedL();

#if defined(__WINSCW__)

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be listed and

	// the implementation will not be created.

	test(!implListed);

	test(implCreated == KErrNotFound);

#else

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is a valid hash so the implementation is

	// listed and created.

	test(implListed);

	test(implCreated == KErrNone);

#endif

	__UHEAP_MARKEND;

	}

/**

@SYMTestCaseID SYSLIB-ECOM-CT-1927

@SYMTestCaseDesc Test that implementation on removable drive is unavailable

	after an uninstall occurs.

@SYMTestPriority High

@SYMTestActions	 Emulate uninstall.

				 Call ListImplementations() and CreateImplementation()

				 Check implementation is unavailable.

@SYMTestExpectedResults The test must not fail.

@SYMDEF PDEF09057

*/

LOCAL_C void TestFullUninstallL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1927 "));

	__UHEAP_MARK;

	//Clean up DLL on remove drive

	DeletePlugins();

	//Clean up the hash file related the DLL

	DoPreUninstall();

	// Test ListImplementations()

	TBool implListed = IsImplementationListedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be listed.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no plugin and no hash so the implementation

	// is not listed.

	test(!implListed);

	// Test CreateImplementation()

	TInt implCreated = IsImplementationCreatedL();

	// Check implementation

	// On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's

	// on the X drive. Because of this the implementation will not be created.

	//

	// On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash

	// is available for the DLL. In this case there is no plugins and no hash file so the

	// implementation is not created.

	test(implCreated == KErrNotFound);

	__UHEAP_MARKEND;

	}

typedef void (*ClassFuncPtrL) (void);

/**

Wrapper function to call all test functions

@param		testFuncL pointer to test function

@param		aTestDesc test function name

*/

LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)

	{

	test.Next(aTestDesc);

	__UHEAP_MARK;

  	// find out the number of open handles

	TInt startProcessHandleCount;

	TInt startThreadHandleCount;

	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

	//Call the test function

	(*testFuncL)();

	// check that no handles have leaked

	TInt endProcessHandleCount;

	TInt endThreadHandleCount;

	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

	test(startThreadHandleCount  == endThreadHandleCount);

	__UHEAP_MARKEND;

	}

LOCAL_C void DoTestsL()

	{

	__UHEAP_MARK;

//If it is hardware and E: drive deosn't exist, don't run the test.

#if (!defined(__WINSCW__))

	if(!TheFs.IsValidDrive(EDriveE))

		{

		test.Printf(_L("E: drive doesn't exist, the test won't be able to run \n"));

		return;

		}

#endif

	// Basic tests

	test.Next(_L("Basic Test Suite"));

	test.Start(_L("Basic Test Suite"));

	DoBasicTestL(&TestPreInstallL, _L("TestPreInstallL"));

	DoBasicTestL(&TestPreUninstallL, _L("TestPreUninstallL"));

	DoBasicTestL(&TestFullInstallL, _L("TestFullInstallL"));

	DoBasicTestL(&TestFullUninstallL, _L("TestFullUninstallL"));

	DoBasicTestL(&TestNoHashFileInstalledL, _L("TestNoHashFileInstalledL"));

	DoBasicTestL(&TestCorruptHashL, _L("TestCorruptHashL"));

	test.End();

	__UHEAP_MARKEND;

	}

//Initialise the Active Scheduler

//

LOCAL_C void SetupL()

	{

	// Construct and install the Active Scheduler. The Active Schedular is needed

	// by components used by this test as they are ActiveObjects.

	TheActiveScheduler = new(ELeave)CActiveScheduler;

	CActiveScheduler::Install(TheActiveScheduler);

	// create hash files

	CreateTempHashFileL();

	CreateTempCorruptHashFileL();

	//Define swinstall property

	PropertyManager::DefineProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue,RProperty::EInt);

	// Initialise swinstall property

	PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone);

	}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	test.Printf(_L("\n"));

	test.Title();

	test.Start(_L("Hash Tests"));

	TheTrapCleanup = CTrapCleanup::New();

	//Delete swinstall property if it already exists

	PropertyManager::DeleteProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue);

	TInt err = TheFs.Connect();

	test(err == KErrNone);

	TRAP(err, SetupL());

	test(err == KErrNone);

	// Perform tests.

	TRAP(err,DoTestsL());

	test(err==KErrNone);

	DeleteTempHashFileL();

	DeleteTempCorruptHashFileL();

	//Delete swinstall property

	PropertyManager::DeleteProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue);

#if !defined(__WINSCW__)

	DeleteRSCFolderOnDrive(EDriveE);

#endif

	delete TheActiveScheduler;

	TheFs.Close();

	delete TheTrapCleanup;

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return (KErrNone);

	}