// 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__