// Copyright (c) 1999-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:

 // f32test\loader\t_ldrtst.cpp

 // 

 //

 #define __E32TEST_EXTENSION__

 #include "t_hash.h"

 #include "t_ldrtst.h"

 #include "../../../e32test/mmu/d_memorytest.h"

 #if defined(__WINS__)

 	#include <e32wins.h>

 	#include <emulator.h>

 #elif defined(__EPOC32__)

 	#include <f32image.h>

 #endif

 const TInt KNumberOfCorruptFiles = 2;

 RTest test(_L("T_LDRTST"));

 LoaderTest* TheLoaderTest;

 RFs Fs;

 #if defined (__X86__) || defined(__WINS__)

 TBool NoRemovable=ETrue;

 #else

 TBool NoRemovable=EFalse;

 #endif

 /** Error code of simulated RFs error */

 const TInt KRFsError = -99;

 /**

 	Number of drives which are identified by a numeric value,

 	which means, e.g., run from an internal pageable drive.

  */

 const TInt KSpecialDriveCount = 2;

 /** The real drive letters corresponding to each special drive. */

 static TFixedArray<TText, KSpecialDriveCount> SpecialDrives;

 /** Bitmask of paged and unpaged module flags. */

 const TUint32 KModulePagedCodeFlags = (KModuleFlagPagedCode | KModuleFlagUnpagedCode);

 _LIT(KSysHash,"?:\\Sys\\Hash\\");

 TInt GetModuleFlags(TInt aModule)

 	{

 	TInt f = ModuleFlags[aModule];

 #ifdef __WINS__

 	// paged and unpaged flags are not supported on the emulator

 	f &= ~KModulePagedCodeFlags;

 	// On emulator, treat all modules as XIP, all EXEs as fixed

 	f |= KModuleFlagXIP;

 	if (f & KModuleFlagExe)

 		f|=KModuleFlagFixed;

 #endif	// #ifdef __EPOC32__

 	return f;

 	}

 TModuleSet::TModuleSet()

 	{

 	Mem::FillZ(this,sizeof(TModuleSet));

 	}

 void TModuleSet::Add(TInt aModule)

 	{

 	TUint8 m=(TUint8)(1<<(aModule&7));

 	TInt i=aModule>>3;

 	if (!(iBitMap[i]&m))

 		{

 		iBitMap[i]|=m;

 		++iCount;

 		}

 	}

 void TModuleSet::Remove(TInt aModule)

 	{

 	TUint8 m=(TUint8)(1<<(aModule&7));

 	TInt i=aModule>>3;

 	if (iBitMap[i]&m)

 		{

 		iBitMap[i]&=~m;

 		--iCount;

 		}

 	}

 TModuleSet::TModuleSet(const TModuleList& aList, TInt aMask, TInt aVal)

 	{

 	Mem::FillZ(this,sizeof(TModuleSet));

 	TInt i;

 	for (i=0; i<aList.iCount; ++i)

 		{

 		TInt m=aList.iInfo[i].iDllNum;

 		if (((GetModuleFlags(m)&aMask)^aVal)==0)

 			Add(aList.iInfo[i].iDllNum);

 		}

 	}

 void TModuleSet::Remove(const TModuleList& aList)

 	{

 	TInt i;

 	for (i=0; i<aList.iCount; ++i)

 		Remove(aList.iInfo[i].iDllNum);

 	}

 void TModuleSet::Display(const TDesC& aTitle) const

 	{

 	TBuf<256> s=aTitle;

 	TInt i;

 	for (i=0; i<iCount; ++i)

 		{

 		if (Present(i))

 			s.AppendFormat(_L("%3d "),i);

 		}

 	test.Printf(_L("%S\n"),&s);

 	}

 TModuleList::TModuleList()

 	{

 	iCount=0;

 	Mem::Fill(iInfo, KNumModules*sizeof(SDllInfo), 0xff);

 	}

 void TModuleList::SetCount()

 	{

 	TInt i;

 	for (i=0; i<KNumModules && iInfo[i].iDllNum>=0; ++i) {}

 	iCount=i;

 	}

 void TModuleList::Display(const TDesC& aTitle) const

 	{

 	TBuf<256> s=aTitle;

 	TInt i;

 	for (i=0; i<iCount; ++i)

 		{

 		TInt modnum=iInfo[i].iDllNum;

 		s.AppendFormat(_L("%3d "),modnum);

 		}

 	test.Printf(_L("%S\n"),&s);

 	}

 TBool TModuleList::IsPresent(TInt aModNum) const

 	{

 	return Find(aModNum)>=0;

 	}

 TInt TModuleList::Find(TInt aModNum) const

 	{

 	TInt i;

 	for (i=iCount-1; i>=0 && iInfo[i].iDllNum!=aModNum; --i) {}

 	return i;

 	}

 void TModuleList::Add(const SDllInfo& a)

 	{

 	iInfo[iCount++]=a;

 	}

 RMemoryTestLdd TestLdd;

 TBool AddressReadable(TLinAddr a)

 	{

 	TUint32 value;

 	return TestLdd.ReadMemory((TAny*)a,value)==KErrNone;

 	}

 TInt LoaderTest::DetermineDllLoadResult(TInt aDllNum, TInt aExeNum)

 	{

 	TBool proc_sym=(iMemModelAtt & (EMemModelAttrSameVA|EMemModelAttrSupportFixed))==EMemModelAttrSameVA;

 	const TInt* exeinfo=ModuleExeInfo[aDllNum];

 	TInt attp=exeinfo[0];

 	TInt linkexe=exeinfo[1];

 	TInt dllflags=GetModuleFlags(aDllNum);

 	TInt exeflags=GetModuleFlags(aExeNum);

 #ifdef __EPOC32__

 	// if NP and DEFAULTPAGED or DEFAULTUNPAGED (not NOPAGING or ALWAYSPAGE) then

 	// executable identified as corrupt, unless previous conditions in S3.1.3.2 cause

 	// it to be paged or unpaged without examining the flags.

 	TUint32 policy = E32Loader::PagingPolicy();

 	test.Printf(_L("DetermineDllLoadResult,dll=%d,exe=%d,dllflags=0x%x,policy=0x%x\n"), aDllNum, aExeNum, dllflags, policy);

 	TBool flagsChecked =

 			policy != EKernelConfigCodePagingPolicyNoPaging					// 3.1.3.2.1, policy != no paging

 		&&	(dllflags & KModuleFlagIDrive) != 0							// 3.1.3.2.2-3, pageable drive

 		&&	(dllflags & (KModuleFlagUncompressed | KModuleFlagBytePair)) != 0	// 3.1.3.2.4 pageable format

 		&&	policy != EKernelConfigCodePagingPolicyAlwaysPage;				// 3.1.3.2.5, policy != ALWAYS

 	if (flagsChecked && (dllflags & KModulePagedCodeFlags) == KModulePagedCodeFlags)

 		{

 		TBool codePolDefUnpaged = (policy == EKernelConfigCodePagingPolicyDefaultUnpaged);

 		TBool codePolDefPaged = (policy == EKernelConfigCodePagingPolicyDefaultPaged);

 		if (codePolDefPaged || codePolDefUnpaged)

 			return KErrCorrupt;

 		}

 #endif

 	if (linkexe>=0 && linkexe!=aExeNum)

 		return KErrNotSupported;	// if DLL links to a different EXE, no good

 	if (!(dllflags&KModuleFlagDataInTree))

 		return KErrNone;			// if no data in DLL tree, OK

 	if (proc_sym)

 		return KErrNone;			// if all user processes equivalent, OK

 	if (!(dllflags&KModuleFlagXIPDataInTree))

 		return KErrNone;			// if no XIP modules with data in DLL tree, OK

 #ifdef __EPOC32__

 	if (attp<0 || !(GetModuleFlags(attp)&KModuleFlagFixed))

 		{

 		// moving processes only

 		if (!(exeflags&KModuleFlagFixed))

 			return KErrNone;

 		return KErrNotSupported;

 		}

 	// fixed attach process only

 	if (aExeNum!=attp)

 		return KErrNotSupported;

 #else

 	(void)attp;

 	(void)exeflags;

 #endif

 	return KErrNone;

 	}

 TInt LoaderTest::DetermineDllLoadResult(TInt aDllNum, TInt aExeNum1, TInt aExeNum2)

 	{

 	// Determine result of loading aDllNum into aExeNum2 given that it's already loaded into aExeNum1

 	// return KErrNone if code segment can be shared, 1 if it must be duplicated

 	TBool proc_sym=(iMemModelAtt & (EMemModelAttrSameVA|EMemModelAttrSupportFixed))==EMemModelAttrSameVA;

 	const TInt* exeinfo=ModuleExeInfo[aDllNum];

 //	TInt attp=exeinfo[0];

 	TInt linkexe=exeinfo[1];

 	TInt dllflags=GetModuleFlags(aDllNum);

 	TInt exe1flags=GetModuleFlags(aExeNum1);

 	TInt exe2flags=GetModuleFlags(aExeNum2);

 	if (linkexe>=0 && linkexe!=aExeNum2)

 		return KErrNotSupported;	// if DLL links to a different EXE, no good

 	if (!(dllflags&KModuleFlagDataInTree))

 		return KErrNone;			// if no data in DLL tree, OK

 	if (proc_sym)

 		return KErrNone;			// if all user processes equivalent, OK

 	if (!((exe1flags|exe2flags)&KModuleFlagFixed))

 		return KErrNone;			// if neither process fixed, OK

 	if (!(dllflags&KModuleFlagXIPDataInTree))

 		return 1;					// if no XIP modules with data in DLL tree, OK but can't share

 #ifdef __WINS__

 	return KErrNone;

 #else

 	return KErrNotSupported;

 #endif

 	}

 TBool LoaderTest::IsRomAddress(TLinAddr a)

 	{

 	const TRomHeader& rh=*(const TRomHeader*)UserSvr::RomHeaderAddress();

 	return (a>=rh.iRomBase && (a-rh.iRomBase)<rh.iRomSize);

 	}

 TBool LoaderTest::IsRamCodeAddress(TLinAddr a)

 	{

 	switch (iMemModelAtt & EMemModelTypeMask)

 		{

 		case EMemModelTypeDirect:

 			return ETrue;

 		case EMemModelTypeMoving:

 			return (a>=0xc0000000u);

 		case EMemModelTypeMultiple:

 			return (a<0x80000000u);

 		case EMemModelTypeFlexible:

 			return (a<0x80000000u);

 		case EMemModelTypeEmul:

 			return (a<0x80000000u);

 		default:

 			return EFalse;

 		}

 	}

 TBool LoaderTest::CheckDataAddress(TLinAddr a, TInt aDllNum, TInt aExeNum)

 	{

 	TInt xf=GetModuleFlags(aExeNum);

 	TInt df=GetModuleFlags(aDllNum);

 	switch (iMemModelAtt & EMemModelTypeMask)

 		{

 		case EMemModelTypeDirect:

 			return ETrue;

 		case EMemModelTypeMoving:

 			{

 			const TRomHeader& rh=*(const TRomHeader*)UserSvr::RomHeaderAddress();

 			if (!(xf&KModuleFlagFixed))

 				return (a<0x40000000u);

 			if ((xf&KModuleFlagXIP) && (df&KModuleFlagXIP))

 				return (a>=rh.iKernDataAddress && a<rh.iKernelLimit);

 			return (a>=rh.iKernelLimit && a<0xc0000000u);

 			}

 		case EMemModelTypeMultiple:

 			return (a<0x80000000u);

 		case EMemModelTypeFlexible:

 			return (a<0x80000000u);

 		case EMemModelTypeEmul:

 			return (a<0x80000000u);

 		default:

 			return EFalse;

 		}

 	}

 void LoaderTest::DumpModuleInfo(const SDllInfo& aInfo, TInt aExeNum)

 	{

 	TInt flags=GetModuleFlags(aInfo.iDllNum);

 	TUint32 mmtype=iMemModelAtt & EMemModelTypeMask;

 	TAny* h=iDev.ModuleCodeSeg(aInfo.iModuleHandle);

 	if (!h)

 		{

 #ifdef __EPOC32__

 		test(flags & KModuleFlagXIP);

 		test(IsRomAddress(aInfo.iEntryPointAddress));

 		test.Printf(_L("Module handle %08x ROM XIP\n"),aInfo.iModuleHandle);

 #endif

 		test(!(flags & KModuleFlagData));

 		return;

 		}

 	TCodeSegCreateInfo info;

 	TInt r=iDev.GetCodeSegInfo(h, info);

 	test(r==KErrNone);

 	TFileName fn;

 	fn.Copy(info.iFileName);

 	test.Printf(_L("DCodeSeg@%08x Data=%08x+%x,%x File %S,attr=0x%x\n"),h,info.iDataRunAddress,info.iDataSize,info.iBssSize,&fn,info.iAttr);

 	TInt total_data_size=info.iDataSize+info.iBssSize;

 #ifndef __WINS__

 	// Don't do check below for WINS because:

 	// a. It doesn't work on code warrior since it puts constants into .data

 	// b. On MSCV with c++ exceptions enabled we also get data

 	if (flags & KModuleFlagData)

 		test(total_data_size!=0);

 	else

 		test(total_data_size==0);

 	// ensure code paged iff expected.  This implements the logic from

 	// PREQ1110 Design Sketch SGL.TS0022.008 v1.0 S3.1.3.2

 	TUint policy = E32Loader::PagingPolicy();

 	TBool expected;

 	TBool isCodePaged = (info.iAttr & ECodeSegAttCodePaged)!=0;

 	// 1. If paging policy is NOPAGING then executable is Unpaged.

 	TUint32 memModelAttributes=UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);

 	if (policy == EKernelConfigCodePagingPolicyNoPaging || !(memModelAttributes&EMemModelAttrCodePaging))

 		{

 		test.Printf(_L("sbcpexp,1\n"));

 		expected = false;

 		}

 	// 2. If ... media ... doesn't have Pageable Media Attribute then it is Unpaged.

 	// (this has been superseded by BlockMap check on filesystem / media.  During these

 	// tests, only the internal media supports paging.)

 	else if ((flags & KModuleFlagIDrive) == 0)

 		{

 		test.Printf(_L("sbcpexp,2\n"));

 		expected = false;

 		}

 	// 3. If ... removable media then it is Unpaged.

 	// Not tested here because removable media (drive 1) covered by above case.

 //	else if (MODULE_FILENAME(aInfo.iDllNum)[0] == '1')

 //		{

 //		test.Printf(_L("sbcpexp,2\n"));

 //		expected = false;

 //		}

 	// 4. [If not bytepair [or uncompressed]] then Unpaged

 	else if ((flags & (KModuleFlagBytePair | KModuleFlagUncompressed)) == 0)

 		{

 		test.Printf(_L("sbcpexp,3\n"));

 		expected = false;

 		}

 	// 5. If the Paging Policy is ALWAYSPAGE then the executable is Paged.

 	else if (policy == EKernelConfigCodePagingPolicyAlwaysPage)

 		{

 		test.Printf(_L("sbcpexp,4\n"));

 		expected = true;

 		}

 	// 6. if KImageCodePaged and KImageCodePaged both set, should not reach here

 	//	because load will have failed with KErrCorrupt.  If Paged on its own

 	//	then paged; if unpaged on its own then unpaged

 	else if ((flags & KModuleFlagPagedCode) != 0)

 		{

 		test.Printf(_L("sbcpexp,5\n"));

 		expected = true;

 		}

 	else if ((flags & KModuleFlagUnpagedCode) != 0)

 		{

 		test.Printf(_L("sbcpexp,6\n"));

 		expected = false;

 		}

 	// 7. Otherwise the PagingPolicy (DEFAULTPAGED or DEFAULTUNPAGED) determines

 	//	how the executable is treated

 	else

 		{

 		test.Printf(_L("sbcpexp,7\n"));

 		expected = (policy == EKernelConfigCodePagingPolicyDefaultPaged);

 		}

 	test(expected == isCodePaged);

 #endif

 	if ((flags & KModuleFlagXIP) && mmtype!=EMemModelTypeEmul)

 		test(IsRomAddress(aInfo.iEntryPointAddress));

 	else

 		{

 		test(IsRamCodeAddress(aInfo.iEntryPointAddress));

 		if(mmtype==EMemModelTypeFlexible)

 			{

 			// can't make assumtions about current processes address space

 			}

 		else if (mmtype==EMemModelTypeMultiple)

 			{

 			test(!AddressReadable(aInfo.iEntryPointAddress));

 			}

 		else

 			{

 			test(AddressReadable(aInfo.iEntryPointAddress));

 			}

 		}

 	if (total_data_size!=0)

 		test(CheckDataAddress(info.iDataRunAddress, aInfo.iDllNum, aExeNum));

 	}

 void LoaderTest::DumpModuleList(const TModuleList& aList, TInt aExeNum)

 	{

 	TInt i;

 	for (i=0; i<aList.iCount; ++i)

 		{

 		TInt modnum=aList.iInfo[i].iDllNum;

 		TInt entry=aList.iInfo[i].iEntryPointAddress;

 		test.Printf(_L("MODULE %3d: ENTRY %08x "),modnum,entry);

 		DumpModuleInfo(aList.iInfo[i],aExeNum);

 		}

 	}

 void LoaderTest::CheckModuleList(TInt aRoot, const TModuleList& aList)

 	{

 	const TInt* deps=ModuleDependencies[aRoot];

 	TInt ndeps=*deps++;

 	TInt f=0;

 	TInt i;

 	for (i=0; i<ndeps; ++i)

 		{

 		TInt m=deps[i];

 		f|=GetModuleFlags(m);

 		}

 	if (!(f&KModuleFlagDllInCycle))

 		{

 		i=0;		// indexes aList

 		TInt j=0;	// indexes deps

 		while(i<KNumModules)

 			{

 			if (j<ndeps)

 				{

 				if (!(GetModuleFlags(deps[j])&KModuleFlagExe))

 					{

 					test(aList.iInfo[i].iDllNum==deps[j]);

 					++i;

 					}

 				++j;

 				}

 			else if (j==ndeps)

 				{

 				test(aList.iInfo[i].iDllNum==aRoot);

 				++i;

 				++j;

 				}

 			else

 				{

 				test(aList.iInfo[i].iDllNum<0);

 				++i;

 				}

 			}

 		}

 	TModuleSet ml;

 	TInt nd=ndeps;

 	TBool root_included=EFalse;

 	for (i=0; i<ndeps; ++i)

 		{

 		if (deps[i]==aRoot)

 			root_included=ETrue;

 		if (!(GetModuleFlags(deps[i])&KModuleFlagExe))

 			ml.Add(deps[i]);

 		else

 			--nd;

 		}

 	test(ml.iCount==nd);

 	for (i=0; i<KNumModules; ++i)

 		{

 		if (i<nd)

 			{

 			test(aList.iInfo[i].iDllNum>=0);

 			ml.Remove(aList.iInfo[i].iDllNum);

 			}

 		else if (i==nd && !root_included)

 			test(aList.iInfo[i].iDllNum==aRoot);

 		else

 			test(aList.iInfo[i].iDllNum<0);

 		}

 	test(ml.iCount==0);

 	}

 LoaderTest::LoaderTest()

 	{

 	Mem::Fill(iCmdLine, sizeof(iCmdLine), 0xff);

 	iMemModelAtt=(TUint32)UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);

 	test.Printf(_L("MemModelAttributes=%08x\n"),iMemModelAtt);

 	}

 LoaderTest::~LoaderTest()

 	{

 	iFs.Close();

 	iDev.Close();

 	}

 void LoaderTest::Init()

 	{

 	test.Next(_L("Load device driver"));

 	TInt r=User::LoadLogicalDevice(_L("D_LDRTST"));

 	test(r==KErrNone || r==KErrAlreadyExists);

 	r=iDev.Open();

 	test(r==KErrNone);

 	r=iFs.Connect();

 	test(r==KErrNone);

 	TBuf<256> cmdline;

 	User::CommandLine(cmdline);

 	TLex lex(cmdline);

 	TInt i;

 	for (i=0; i<8; ++i)

 		{

 		lex.SkipSpace();

 		if (lex.Eos())

 			break;

 		lex.Val(iCmdLine[i]);

 		}

 	}

 LoaderTest* LoaderTest::New()

 	{

 	LoaderTest* p=new LoaderTest;

 	test(p!=NULL);

 	p->Init();

 	return p;

 	}

 void LoaderTest::Close()

 	{

 	delete this;

 	}

 void LoaderTest::TraceOn()

 	{

 	iFs.SetDebugRegister(KFLDR);

 	User::SetDebugMask(0xefdfffff);

 	}

 void LoaderTest::TraceOff()

 	{

 	iFs.SetDebugRegister(0);

 	User::SetDebugMask(0x80000000);

 	}

 void LoaderTest::TestOneByOne()

 	{

 	test.Next(_L("Test all single EXE/DLL combinations"));

 	TInt i=0;

 	TInt r=0;

 	TInt x=0;

 	for (x=0; x<KNumModules; ++x)

 		{

 		if (!(GetModuleFlags(x)&KModuleFlagExe))

 			continue;

 #ifdef __WINS__

 		if (GetModuleFlags(x)&KModuleFlagTargetOnly)

 			continue;

 #endif

 		RProcess p;

 		TUint32 tt;

 		r=LoadExe(x, 0, p, tt);

 		test.Printf(_L("LoadExe(%d)->%d\n"),x,r);

 		test.Printf(_L("BENCHMARK: LoadExe(%d)->%dms\n"),x,tt);

 		test(r==KErrNone);

 		RLoaderTest lt;

 		r=lt.Connect(x);

 		test.Printf(_L("Connect(%d)->%d\n"),x,r);

 		test(r==KErrNone);

 		TModuleList exe_info;

 		r=lt.GetExeDepList(exe_info.iInfo);

 		test(r==KErrNone);

 		exe_info.SetCount();

 		DumpModuleList(exe_info, x);

 		CheckModuleList(x, exe_info);

 		TInt m;

 		for (m=0; m<KNumModules; ++m)

 			{

 			if (GetModuleFlags(m)&KModuleFlagExe)

 				continue;

 #ifdef __WINS__

 			if (GetModuleFlags(m)&KModuleFlagTargetOnly)

 				continue;

 #endif

 			if ((GetModuleFlags(m) & KModuleFlagVDrive) && NoRemovable)

 				{

 				test.Printf(_L("LoadDll: Not testing dll %d from removable media\n"),m);

 				continue;

 				}

 			TInt predicted=DetermineDllLoadResult(m,x);

 			if (x==iCmdLine[1] && m==iCmdLine[2])

 				TraceOn();

 			TModuleList dll_init_info;

 			TModuleList dll_c_info;

 			TModuleList dll_d_info;

 			TInt h=lt.LoadDll(m, dll_init_info.iInfo);

 			dll_init_info.SetCount();

 			test.Printf(_L("LoadDll(%d)->%d (%d)\n"),m,h,predicted);

 			test(Min(h,0)==predicted);

 			if (h>=0)

 				{

 				DumpModuleList(dll_init_info, x);

 				CheckModuleList(m, dll_init_info);

 				test(lt.GetCDList(dll_c_info.iInfo)==KErrNone);

 				dll_c_info.SetCount();

 				dll_c_info.Display(_L("Construct: "));

 				if (!(GetModuleFlags(m)&KModuleFlagDllInCycle))

 					{

 					TInt j=0;

 					for (i=0; i<dll_init_info.iCount; ++i)

 						{

 						TInt modnum=dll_init_info.iInfo[i].iDllNum;

 						if ((GetModuleFlags(modnum)&KModuleFlagData) && !exe_info.IsPresent(modnum))

 							{

 							test(modnum==dll_c_info.iInfo[j].iDllNum);

 							++j;

 							}

 						}

 					test(j==dll_c_info.iCount);

 					}

 				else

 					{

 					TModuleSet ms(dll_init_info, KModuleFlagData, KModuleFlagData);

 					ms.Remove(exe_info);

 					test(ms.iCount==dll_c_info.iCount);

 					ms.Remove(dll_c_info);

 					test(ms.iCount==0);

 					}

 				TInt y=(7*m+59);

 				r=lt.CallRBlkI(h,y);

 				r-=y;

 				r/=INC_BLOCK_SZ;

 				test.Printf(_L("DLL %d RBlkI->%d\n"),m,r);

 				y=ModuleRBlkIParams[m][1]+ModuleRBlkIParams[m][0]*DLLNUMOFFSET;

 				test(r==y);

 				r=lt.CloseDll(h);

 				test.Printf(_L("CloseDll(%d)->%d\n"),h,r);

 				test(r==KErrNone);

 				test(lt.GetCDList(dll_d_info.iInfo)==KErrNone);

 				dll_d_info.SetCount();

 				dll_d_info.Display(_L("Destruct:  "));

 				test(dll_d_info.iCount==dll_c_info.iCount);

 				for (i=0; i<dll_d_info.iCount; ++i)

 					test(dll_d_info.iInfo[i].iDllNum==dll_c_info.iInfo[dll_c_info.iCount-i-1].iDllNum);

 				}

 			if (x==iCmdLine[1] && m==iCmdLine[2])

 				TraceOff();

 			}

 		lt.Exit();

 		p.Close();

 		}

 	}

 // return KErrNone if shared code, 1 if not shared

 TInt LoaderTest::DetermineLoadExe2Result(TInt aExeNum)

 	{

 	if ( (iMemModelAtt&(EMemModelAttrSameVA|EMemModelAttrSupportFixed))==EMemModelAttrSameVA )

 		return KErrNone;	// multiple memory model always supports multiple instances

 	TUint32 f=GetModuleFlags(aExeNum);

 	if (!(f&KModuleFlagFixed))

 		return KErrNone;	// not fixed, so share code segment

 	if (!(f&KModuleFlagDataInTree))

 		{

 #ifdef __EPOC32__

 		return KErrNone;	// fixed but no data, so share code segment

 #else

 		return 1;			// on emulator, never share EXE code segments

 #endif

 		}

 #ifdef __EPOC32__

 	if (!(f&KModuleFlagXIP))

 		return 1;			// fixed but not XIP, data in tree - create second code segment

 	// fixed, XIP, data in tree

 	return KErrAlreadyExists;

 #else

 	if (f & KModuleFlagExports)

 		return KErrAlreadyExists;

 	if (!(f & KModuleFlagData))

 		return KErrNone;

 	return 1;

 #endif

 	}

 void LoaderTest::TestMultipleExeInstances()

 	{

 	test.Next(_L("Test multiple instantiation of EXEs"));

 	TInt i=0;

 	TInt r=0;

 	TInt x=0;

 	for (x=0; x<KNumModules; ++x)

 		{

 		TUint32 f=GetModuleFlags(x);

 		if (!(f&KModuleFlagExe))

 			continue;

 #ifdef __WINS__

 		if (f&KModuleFlagTargetOnly)

 			continue;

 #endif

 		RProcess p1, p2;

 		RLoaderTest lt1, lt2;

 		TModuleList exe_info1;

 		TModuleList exe_info2;

 		TUint32 tt;

 		r=LoadExe(x, 0, p1, tt);

 		test.Printf(_L("LoadExe1(%d)->%d\n"),x,r);

 		test.Printf(_L("BENCHMARK: LoadExe1(%d)->%dms\n"),x,tt);

 		test(r==KErrNone);

 		r=lt1.Connect(x, 0);

 		test.Printf(_L("Connect1(%d)->%d\n"),x,r);

 		test(r==KErrNone);

 		TInt s=DetermineLoadExe2Result(x);

 		r=LoadExe(x, 1, p2, tt);

 		test.Printf(_L("LoadExe2(%d)->%d (%d)\n"),x,r,s);

 		if (s==KErrNone)

 			test.Printf(_L("BENCHMARK: LoadExe2(%d)->%dms\n"),x,tt);

 		test(r==Min(s,0));

 		if (r==KErrNone)

 			{

 			r=lt2.Connect(x, 1);

 			test.Printf(_L("Connect2(%d)->%d\n"),x,r);

 			test(r==KErrNone);

 			r=lt1.GetExeDepList(exe_info1.iInfo);

 			test(r==KErrNone);

 			exe_info1.SetCount();

 			DumpModuleList(exe_info1, x);

 			r=lt2.GetExeDepList(exe_info2.iInfo);

 			test(r==KErrNone);

 			exe_info2.SetCount();

 			DumpModuleList(exe_info2, x);

 			test(exe_info1.iCount==exe_info2.iCount);

 			if (s==1)

 				{

 				TInt nm=exe_info1.iCount;

 				test(exe_info1.iInfo[nm-1].iModuleHandle!=exe_info2.iInfo[nm-1].iModuleHandle);

 				}

 #ifdef __WINS__

 			else if((GetModuleFlags(x) & KModuleFlagData))

 #else

 			else

 #endif

 				{

 				for (i=0; i<exe_info1.iCount; ++i)

 					test(exe_info1.iInfo[i].iModuleHandle==exe_info2.iInfo[i].iModuleHandle);

 				}

 			const TInt* tests=TC_ExeLoad;

 			TInt ntests=*tests++;

 			while(ntests--)

 				{

 				TInt m=*tests++;

 				TModuleList dll_init_info1;

 				TModuleList dll_c_info1;

 				TModuleList dll_d_info1;

 				TModuleList dll_init_info2;

 				TModuleList dll_c_info2;

 				TModuleList dll_d_info2;

 				TInt h1=lt1.LoadDll(m, dll_init_info1.iInfo);

 				dll_init_info1.SetCount();

 				test.Printf(_L("LoadDll1(%d)->%d\n"),m,h1);

 				if (h1>=0)

 					{

 					DumpModuleList(dll_init_info1, x);

 					CheckModuleList(m, dll_init_info1);

 					test(lt1.GetCDList(dll_c_info1.iInfo)==KErrNone);

 					dll_c_info1.SetCount();

 					dll_c_info1.Display(_L("Construct1: "));

 					TInt y=(41*m+487);

 					r=lt1.CallRBlkI(h1,y);

 					r-=y;

 					r/=INC_BLOCK_SZ;

 					test.Printf(_L("DLL1 %d RBlkI->%d\n"),m,r);

 					y=ModuleRBlkIParams[m][1]+ModuleRBlkIParams[m][0]*DLLNUMOFFSET;

 					test(r==y);

 					TInt s=DetermineDllLoadResult(m, x, x);

 					TInt h2=lt2.LoadDll(m, dll_init_info2.iInfo);

 					dll_init_info2.SetCount();

 					test.Printf(_L("LoadDll2(%d)->%d (%d)\n"),m,h2,s);

 					test(h2==Min(s,0));

 					if (h2>=0)

 						{

 						DumpModuleList(dll_init_info2, x);

 						CheckModuleList(m, dll_init_info2);

 						test(lt2.GetCDList(dll_c_info2.iInfo)==KErrNone);

 						dll_c_info2.SetCount();

 						dll_c_info2.Display(_L("Construct2: "));

 						y=(79*m+257);

 						r=lt2.CallRBlkI(h2,y);

 						r-=y;

 						r/=INC_BLOCK_SZ;

 						test.Printf(_L("DLL2 %d RBlkI->%d\n"),m,r);

 						y=ModuleRBlkIParams[m][1]+ModuleRBlkIParams[m][0]*DLLNUMOFFSET;

 						test(r==y);

 						test(dll_init_info1.iCount==dll_init_info2.iCount);

 #ifdef __WINS__

 						if (s==1 && !(ModuleFlags[m]&KModuleFlagDataInTree))

 #else

 						if (s==1)

 #endif

 							{

 							TInt nm=dll_init_info1.iCount;

 							test(dll_init_info1.iInfo[nm-1].iModuleHandle!=dll_init_info2.iInfo[nm-1].iModuleHandle);

 							}

 						else

 							{

 							for (i=0; i<dll_init_info1.iCount; ++i)

 								test(dll_init_info1.iInfo[i].iModuleHandle==dll_init_info2.iInfo[i].iModuleHandle);

 							}

 						r=lt2.CloseDll(h2);

 						test.Printf(_L("CloseDll2(%d)->%d\n"),h2,r);

 						test(r==KErrNone);

 						test(lt2.GetCDList(dll_d_info2.iInfo)==KErrNone);

 						dll_d_info2.SetCount();

 						dll_d_info2.Display(_L("Destruct2:  "));

 						test(dll_d_info2.iCount==dll_c_info2.iCount);

 						for (i=0; i<dll_d_info2.iCount; ++i)

 							test(dll_d_info2.iInfo[i].iDllNum==dll_c_info2.iInfo[dll_c_info2.iCount-i-1].iDllNum);

 						}

 					r=lt1.CloseDll(h1);

 					test.Printf(_L("CloseDll1(%d)->%d\n"),h1,r);

 					test(r==KErrNone);

 					test(lt1.GetCDList(dll_d_info1.iInfo)==KErrNone);

 					dll_d_info1.SetCount();

 					dll_d_info1.Display(_L("Destruct1:  "));

 					test(dll_d_info1.iCount==dll_c_info1.iCount);

 					for (i=0; i<dll_d_info1.iCount; ++i)

 						test(dll_d_info1.iInfo[i].iDllNum==dll_c_info1.iInfo[dll_c_info1.iCount-i-1].iDllNum);

 					}

 				}

 			lt2.Exit();

 			p2.Close();

 			}

 		lt1.Exit();

 		p1.Close();

 		}

 	}

 void SetLoaderFail(TInt aLdr, TInt aKern)

 	{

 	test.Printf(_L("ldr=%d, kern=%d\n"),aLdr,aKern);

 	RLoader l;

 	test(l.Connect()==KErrNone);

 	test(l.DebugFunction(ELoaderDebug_SetHeapFail, aLdr, aKern, 0)==KErrNone);

 	l.Close();

 	}

 void SetLoaderFailRFs(TInt aError, TInt aCount)

 	{

 	test.Printf(_L("SetLoaderFailRFs: error=%d, count=%d\n"),aError,aCount);

 	RLoader l;

 	test(l.Connect()==KErrNone);

 	test(l.DebugFunction(ELoaderDebug_SetRFsFail, aError, aCount, 0)==KErrNone);

 	l.Close();

 	}

 class TLoopOOM

 	{

 public:

 	enum OomState{EInit, EKernelHeap, EUserHeap, ERFsError};

 	TLoopOOM();

 	void Reset();

 	TBool Iterate(TInt aResult);

 public:

 	TInt iLdr;

 	TInt iKern;

 	TInt iRFsCount;

 	OomState iState;

 	};

 TLoopOOM::TLoopOOM()

 	{

 	Reset();

 	}

 void TLoopOOM::Reset()

 	{

 	iLdr = 0;

 	iKern = 0;

 	iRFsCount = 0;

 	iState = EInit;

 	}

 TBool TLoopOOM::Iterate(TInt aResult)

 	{

 	TBool noErrors = (aResult==KErrNone||aResult==KErrNotSupported);

 	test.Printf(_L("%d %d %d %d\n"), iKern,iLdr,iRFsCount,aResult);

 	switch(iState)

 		{

 	case EInit:

 		iState = EKernelHeap;

 		SetLoaderFail(iLdr,++iKern);

 		return ETrue;

 	case EKernelHeap:

 		if (noErrors)

 			{

 			iKern = 0;

 			iLdr = 1;

 			iState = EUserHeap;

 			}

 		else

 			++iKern;

 		SetLoaderFail(iLdr,iKern);

 		return ETrue;

 	case EUserHeap:

 		if (noErrors)

 			{

 			iLdr = 0;

 			iState = ERFsError;

 			SetLoaderFail(0,0);

 			SetLoaderFailRFs(KRFsError, ++iRFsCount);

 			}

 		else

 			SetLoaderFail(++iLdr,iKern);

 		return ETrue;

 	case ERFsError:

 		if (noErrors)

 			break;

 		else

 			{

 			SetLoaderFailRFs(KRFsError, ++iRFsCount);

 			return ETrue;

 			}

 		}

 	SetLoaderFailRFs(KErrNone, 0);

 	return EFalse;

 	}

 void LoaderTest::TestOOM()

 	{

 	test.Next(_L("Test OOM Handling"));

 #ifdef _DEBUG

 	TInt r=0;

 	TInt x=0;

 	TUint32 tt;

 	for (x=0; x<KNumModules; ++x)

 		{

 		if (!(GetModuleFlags(x)&KModuleFlagExe))

 			continue;

 #ifdef __WINS__

 		if (GetModuleFlags(x)&KModuleFlagTargetOnly)

 			continue;

 #endif

 		if ((GetModuleFlags(x) & KModuleFlagVDrive) && NoRemovable)

 			{

 			test.Printf(_L("LoaderTest::TestOOM Not testing dll %d from removable media\n"),x);

 			continue;

 			}

 		if (x==iCmdLine[1])

 			TraceOn();

 		TLoopOOM loom;

 		RProcess p;

 		RLoaderTest lt;

 		while(loom.Iterate(r))

 			{

 			r=LoadExe(x, 0, p, tt);

 			test.Printf(_L("LoadExe(%d)->%d\n"),x,r);

 			test(r==KErrNone || (loom.iState!=TLoopOOM::ERFsError && r==KErrNoMemory) || 

 				(loom.iState==TLoopOOM::ERFsError && r==KRFsError));

 			if (r==KErrNone)

 				{

 				TInt s=lt.Connect(x);

 				test.Printf(_L("Connect(%d)->%d\n"),x,s);

 				test(s==KErrNone);

 				lt.Exit();

 				p.Close();

 				}

 			}

 		SetLoaderFail(0,0);

 		r=LoadExe(x, 0, p, tt);

 		test(r==KErrNone);

 		r=lt.Connect(x);

 		test(r==KErrNone);

 		const TInt* tests=TC_DllOOM;

 		TInt ntests=*tests++;

 		TModuleList list;

 		while(ntests--)

 			{

 			TInt m=*tests++;

 			if ((GetModuleFlags(m) & KModuleFlagVDrive) && NoRemovable)

 				{

 				test.Printf(_L("LoaderTest::TestOOM Not testing dll %d from removable media\n"),m);

 				continue;

 				}

 			loom.Reset();

 			r=KErrNone;

 			while(loom.Iterate(r))

 				{

 				TInt h=lt.LoadDll(m, list.iInfo);

 				r=Min(h,0);

 				test.Printf(_L("%d:LoadDll(%d)->%d\n"),x,m,h);

 				test(r==KErrNone || r==KErrNotSupported || KErrNoMemory || 

 					(loom.iState==TLoopOOM::ERFsError && r==KRFsError) );

 				if (r==KErrNone)

 					{

 					TInt s=lt.CloseDll(h);

 					test(s==KErrNone);

 					}

 				}

 			}

 		lt.Exit();

 		p.Close();

 		if (x==iCmdLine[1])

 			TraceOff();

 		}

 #else

 	test.Printf(_L("Only on DEBUG builds\n"));

 #endif

 	}

 class RLoaderTestHandle : public RSessionBase

 	{

 public:

 	TInt Connect();

 	void TryToGetPaniced();

 	};

 TInt RLoaderTestHandle::Connect()

 	{

 	return CreateSession(_L("!Loader"),TVersion(KLoaderMajorVersionNumber,KLoaderMinorVersionNumber,KE32BuildVersionNumber));

 	}

 void RLoaderTestHandle::TryToGetPaniced()

 	{

 	_LIT(KFoo,"foo");

 	TLdrInfo info;

 	TPckg<TLdrInfo> infoBuf(info);

 	TIpcArgs args;

 	args.Set(0,(TDes8*)&infoBuf);

 	args.Set(1,&KFoo);

 	args.Set(2,&KFoo);

 	SendReceive(ELoadLibrary, args);

 	}

 TInt PanicTestThread(TAny*)

 	{

 	RLoaderTestHandle t;

 	TInt r = t.Connect();

 	if (r==KErrNone) t.TryToGetPaniced();

 	return r;

 	}

 void TestCorruptedFiles()

 	{

 	test.Next(_L("Test corrupted files"));

 	TInt numCorruptFiles=0;

 	TInt r=0;

 	for (TInt x=0; x<KNumModules; ++x)

 		{

 		if (!(GetModuleFlags(x)&KModuleFlagExe))

 			continue;

 		const TPtrC fn = MODULE_FILENAME(x);

 		if (fn[1] != ':')

 			continue;

 		if (++numCorruptFiles > KNumberOfCorruptFiles)

 			break;

 		RProcess p;

 		TUint32 tt;

 		r=LoadExe(x, 0, p, tt);

 		test.Printf(_L("LoadCorruptExe(%d)->%d\n"),x,r);

 		test(r==KErrCorrupt);

 		}

 	}

 // -------- copying files to non-ROM media --------

 static void GetSpecialDrives()

 /**

 	Work out which physical drive corresponds to each

 	numeric drive in the list of filenames.  This populates

 	SpecialDrives.

 	@see SpecialDrives

  */

 	{

 	test.Printf(_L("NoRemovable=%d\n"),NoRemovable);

 	// mark each special drive as not present

 	for (TInt i = 0; i < KSpecialDriveCount; ++i)

 		{

 		SpecialDrives[i] = '!';

 		}

 	// cannot load binaries from emulated removable drives

 #if defined (__WINS__)

 	SpecialDrives[1] = 'c';			// "removable"

 #endif

 	TBuf<12> hashDir;

 	hashDir = KSysHash;

 	hashDir[0] = (TUint8) RFs::GetSystemDriveChar();

 	TInt r = Fs.MkDirAll(hashDir);

 	test(r == KErrNone || r == KErrAlreadyExists);

 	for (TInt d = 0; d <= (TInt)sizeof(SpecialDriveList); ++d)

 		{

 		TInt dr = SpecialDriveList[d];

 		TDriveInfo di;

 		test.Printf(_L("Drive %d\n"), dr);

 		test(Fs.Drive(di, dr) == KErrNone);

 		if (di.iType == EMediaNotPresent)

 			continue;

 		TChar ch0;

 		test(RFs::DriveToChar(dr, ch0) == KErrNone);

 		TText ch = static_cast<TText>(TUint(ch0));

 		// drive 0 == internal

 		if ((di.iDriveAtt & KDriveAttInternal) && SpecialDrives[0] == '!')

 			{

 			SpecialDrives[0] = ch;

 			if (NoRemovable)

 				SpecialDrives[1] = ch;

 			}

 		// drive 1 == removable

 		else if ((di.iDriveAtt & KDriveAttRemovable) && SpecialDrives[1] == '!' && !NoRemovable)

 			SpecialDrives[1] = ch;

 		else

 			{

 			// drive not useful so continue and don't create \sys\bin

 			continue;

 			}

 		TFileName fn;

 		fn.Append(ch);

 		fn.Append(_L(":\\sys\\bin\\"));

 		r = Fs.MkDirAll(fn);

 		test.Printf(_L("MkDirAll %S returns %d\n"), &fn, r);

 		test(r == KErrNone || r == KErrAlreadyExists);

 		}

 	}

 void GetNonZFileName(const TDesC& aOrigName, TDes& aNonZName)

 /**

 	Resolve a special drive to the target drive using the mappings in

 	SpecialDrives.  This is used to load non-XIP binaries from pageable media.

 	@param	aOrigName		Fully-qualified filename with special drive number.

 							E.g., "3:\\sys\\bin\\dllt45.dll".

 	@param	aNonZName		Descriptor to populate with aOrigName and the transformed

 							drive, e.g. "c:\\sys\\bin\\dllt45.dll".

  */

 	{

 	test.Printf(_L(">GetNonZFileName,\"%S\"\n"), &aOrigName);

 	test(aOrigName[1] == ':');

 	aNonZName.Copy(aOrigName);

 	TText replaceChar = SpecialDrives[aOrigName[0] - '0'];

 	test(TChar(replaceChar).IsAlpha());

 	aNonZName[0] = replaceChar;

 	test.Printf(_L("<GetNonZFileName,\"%S\"\n"), &aNonZName);

 	}

 static void GetHashFileName(const TDesC& aOrigName, TDes& aHashName)

 /**

 	Get name of the hash file used for an EXE or DLL which has been

 	copied to writable media.

 	@param	aOrigName		Name of EXE or DLL which has been copied to

 							writable media.  This does not have to be

 							qualified because only the name and extension

 							are used.

 	@param	aHashName		On return this is set to the absolute filename

 							which should contain the file's hash.  This

 							function does not create the file, or its containing

 							directory.

  */

 	{

 	aHashName.Copy(KSysHash);

 	aHashName[0] = (TUint8) RFs::GetSystemDriveChar();

 	const TParsePtrC ppc(aOrigName);

 	aHashName.Append(ppc.NameAndExt());

 	}

 static void CopyExecutablesL(TBool aCorruptMode=EFalse)

 /**

 	Make a copy of each executable that should be copied

 	to a writable drive.

 	If aCorruptMode make KNumberOfCorruptFiles corrupted copies: truncated file and a file with corrupted header 

  */

 	{

 	TInt r;

 	TInt numCorruptFiles = 0;

 	GetSpecialDrives();

 	CFileMan* fm = CFileMan::NewL(Fs);

 	for (TInt i = 0; i < KNumModules; ++i)

 		{

 		if (aCorruptMode && numCorruptFiles==KNumberOfCorruptFiles)

 			break;

 		if (aCorruptMode && !(GetModuleFlags(i)&KModuleFlagExe))

 			continue;

 		const TPtrC fn = MODULE_FILENAME(i);

 		// if this is an absolute filename then copy it to

 		// the appropriate drive.

 		if (fn[1] != ':')

 			continue;

 		TFileName fnDest;

 		GetNonZFileName(fn, fnDest);

 		TFileName fnSrc(fn);

 		fnSrc[0] = 'z';

 		test.Printf(_L("CopyExecutables;%S,%S\n"), &fnSrc, &fnDest);

 #ifdef __WINS__

 		const TParsePtrC sppc(fnSrc);

 		TBuf<MAX_PATH> sName;

 		r = MapEmulatedFileName(sName, sppc.NameAndExt());

 		test(r == KErrNone);

 		TBuf<MAX_PATH> dName;

 		r = MapEmulatedFileName(dName, fnDest);

 		test(r == KErrNone);

 		BOOL b = Emulator::CopyFile((LPCTSTR)sName.PtrZ(),(LPCTSTR)dName.PtrZ(),FALSE);

 		test(b);

 #else

 		r = fm->Copy(fnSrc, fnDest);

 		test(r == KErrNone);

 #endif

 		r = Fs.SetAtt(fnDest, 0, KEntryAttReadOnly);

 		test.Printf(_L("CopyExecutables:setatt=%d\n"), r);

 		User::LeaveIfError(r);

 #ifdef __EPOC32__

 		TInt moduleFlags = GetModuleFlags(i);

 		// modify the new destination file by applying the required paging flags

 		RFile fNp;

 		r = fNp.Open(Fs, fnDest, EFileWrite | EFileStream);

 		User::LeaveIfError(r);

 		CleanupClosePushL(fNp);

 		// read the header and get the total number of bytes to checksum.

 		// (This may be greater than sizeof(E32ImageHeader).

 		TPckgBuf<E32ImageHeader> hdrBuf;

 		r = fNp.Read(0, hdrBuf);

 		User::LeaveIfError(r);

 		TInt totalSize = hdrBuf().TotalSize();

 		test.Printf(_L("np flags=0x%x,totalSize=%d\n"), hdrBuf().iFlags, totalSize);

 		// read in the actual bytes to checksum

 		TUint8* startBytes0 = (TUint8*) User::AllocLC(totalSize);

 		TPtr8 startBytes(startBytes0, 0, totalSize);

 		r = fNp.Read(0, startBytes);

 		User::LeaveIfError(r);

 		test(startBytes.Length() == totalSize);

 		// apply the required paging flags to the header

 		E32ImageHeader* hdr2 = reinterpret_cast<E32ImageHeader*>(startBytes0);

 		TUint& flags = hdr2->iFlags;

 		flags &= ~(KImageCodePaged | KImageCodeUnpaged);

 		if (moduleFlags & KModuleFlagPagedCode)

 			flags |= KImageCodePaged;

 		if (moduleFlags & KModuleFlagUnpagedCode)

 			flags |= KImageCodeUnpaged;

 		test.Printf(_L("setting new image flags 0x%x\n"), flags);

 		// corrupt header of the 2nd file

 		if (aCorruptMode && numCorruptFiles==1 && (moduleFlags&KModuleFlagExe))

 			{

 			hdr2->iCodeBase += 3;

 			hdr2->iDataBase += 1;

 			hdr2->iImportOffset += 1;

 			hdr2->iCodeRelocOffset += 3;

 			hdr2->iDataRelocOffset += 3;

 			++numCorruptFiles;

 			}

 		// recalculate the checksum

 		hdr2->iHeaderCrc = KImageCrcInitialiser;

 		TUint32 crc = 0;

 		Mem::Crc32(crc, startBytes.Ptr(), totalSize);

 		hdr2->iHeaderCrc = crc;

 		r = fNp.Write(0, startBytes);

 		User::LeaveIfError(r);

 		// truncate 1st corrupted file

 		if (aCorruptMode && numCorruptFiles==0 && (moduleFlags&KModuleFlagExe))

 			{

 			TInt size;

 			r = fNp.Size(size);

 			User::LeaveIfError(r);

 			// if trncate by 1 it managed to load. if trancate by 3 it failed to load with KErrCorrupt as expected

 			r = fNp.SetSize(size-3); 

 			User::LeaveIfError(r);

 			++numCorruptFiles;

 			}

 		CleanupStack::PopAndDestroy(2, &fNp);		// startBytes0, fNp

 #endif

 		// if copied to removable media, then generate hash

 		if (fn[0] == '0')

 			continue;

 		CSHA1* sha1 = CSHA1::NewL();

 		CleanupStack::PushL(sha1);

 		RFile fDest;

 		r = fDest.Open(Fs, fnDest, EFileRead | EFileStream);

 		User::LeaveIfError(r);

 		CleanupClosePushL(fDest);

 		TBool done;

 		TBuf8<512> content;

 		do

 			{

 			r = fDest.Read(content);

 			User::LeaveIfError(r);

 			done = (content.Length() == 0);

 			if (! done)

 				sha1->Update(content);

 			} while (! done);

 		CleanupStack::PopAndDestroy(&fDest);

 		// write hash to \sys\hash

 		TBuf8<SHA1_HASH> hashVal = sha1->Final();

 		// reuse fnSrc to save stack space

 		GetHashFileName(fnDest, fnSrc);

 		RFile fHash;

 		r = fHash.Replace(Fs, fnSrc, EFileWrite | EFileStream);

 		test.Printf(_L("hash file,%S,r=%d\n"), &fnSrc, r);

 		User::LeaveIfError(r);

 		CleanupClosePushL(fHash);

 		r = fHash.Write(hashVal);

 		User::LeaveIfError(r);

 		CleanupStack::PopAndDestroy(2, sha1);

 		}

 	delete fm;

 	}

 static void DeleteExecutables(TBool aCorruptMode=EFalse)

 /**

 	Delete any executables which were created by CopyExecutables.

 	This function is defined so the test cleans up when it has finished.

  */

 	{

 	TInt numCorruptFiles = 0;

 	for (TInt i = 0; i < KNumModules; ++i)

 		{

 		if (aCorruptMode && numCorruptFiles==KNumberOfCorruptFiles)

 			break;

 		if (aCorruptMode && !(GetModuleFlags(i)&KModuleFlagExe))

 			continue;

 		const TPtrC fn = MODULE_FILENAME(i);

 		// if this is an absolute filename then copy it to

 		// the appropriate drive.

 		if (fn[1] != ':')

 			continue;

 		test.Printf(_L("DeleteExecutables:fn=%S\n"), &fn);

 		TFileName fnDest;

 		GetNonZFileName(fn, fnDest);

 		TInt r;

 		r = Fs.Delete(fnDest);

 		test.Printf(_L("DeleteExecutables:fnDest=%S,del=%d\n"), &fnDest, r);

 		test(r == KErrNone);

 		// only need to delete hash files for binaries copied to removable media,

 		// but simpler to delete and test for KErrNotFound

 		TFileName fnHash;

 		GetHashFileName(fnDest, fnHash);

 		r = Fs.Delete(fnHash);

 		test.Printf(_L("DeleteExecutables,h=%S,hdel=%d\n"), &fnHash, r);

 		test(r == KErrPathNotFound || r == KErrNotFound || r == KErrNone);

 		if (aCorruptMode)

 			++numCorruptFiles;

 		}

 	}

 GLDEF_C TInt E32Main()

 	{

 	RThread().SetPriority(EPriorityLess);

 	test.Title();

 	test.Start(_L("Setup"));

 	RLoader l;

 	test(l.Connect()==KErrNone);

 	test(l.CancelLazyDllUnload()==KErrNone);

 	l.Close();

 	test(TestLdd.Open()==KErrNone);

 	LoaderTest* pL=LoaderTest::New();

 	TheLoaderTest=pL;

 	TInt tm=pL->iCmdLine[0];

 	TInt nr = (tm>>4)&3;

 	if (nr==1)

 		NoRemovable = ETrue;

 	else if (nr==2)

 		NoRemovable = EFalse;

 	test(Fs.Connect() == KErrNone);

 	// allocate a cleanup stack so can call CFileMan::NewL in CopyExecutables

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

 	CTrapCleanup* cleanup=CTrapCleanup::New();

 	TRAPD(r, CopyExecutablesL());

 	test(r == KErrNone);

 	delete cleanup;

 	if (tm&1)

 		pL->TestOneByOne();

 	if (tm&2)

 		pL->TestMultipleExeInstances();

 	if (tm&4)

 		pL->TestOOM();

 	if (tm&8)

 		pL->TestMultipleLoads();

 	pL->Close();

 	// Test loader error handling - will panic the client thread

 	test.Next(_L("Test loader error handling - will panic the client thread"));

 	RThread t;

 	t.Create(_L("Loader panic test"),PanicTestThread,KDefaultStackSize,0x1000,0x1000,NULL);

 	TRequestStatus s;

 	t.Logon(s);

 	TBool justInTime=User::JustInTime(); 

 	User::SetJustInTime(EFalse); 

 	t.Resume();

 	User::WaitForRequest(s);

 	test(t.ExitType()==EExitPanic);

 	test(t.ExitCategory().Compare(_L("LOADER"))==0);

 	test(t.ExitReason()==0);

 	t.Close();

 	User::SetJustInTime(justInTime);

 	DeleteExecutables();

 #ifdef __EPOC32__

 	// test corrupted files

 	cleanup=CTrapCleanup::New();

 	test.Next(_L("CopyExecutablesL(ETrue)"));

 	TRAPD(rr, CopyExecutablesL(ETrue));

 	test(rr == KErrNone);

 	delete cleanup;

 	test.Next(_L("TestCorruptedFiles()"));

 	TestCorruptedFiles();

 	test.Next(_L("DeleteExecutables()"));

 	DeleteExecutables(ETrue);

 #endif

 	Fs.Close();

 	test.End();

 	return KErrNone;

 	}