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