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

// e32test\dll\t_xxver2.cpp

// Overview:

// Test matching algorithm for DLL versions. Test aspects of DLL and EXE files.

// API Information:

// RLibrary

// Details:

// - This test makes use of 4 versions of a single DLL, and 15 EXEs which link

// against it.  The EXEs all have different reqirements on which DLL versions

// are acceptable

// - Test that the correct version of linked libraries are used (Run for each

// EXE and for the 16 combinations in which the 4 versions of the DLL can be

// available.  The test is performed with each EXE run in sequence, and again

// with all of them run at the same time)

// - Test that the correct version of dynamically loaded libraries are used and

// the libary exports are as expected.  (Run for each DLL version and for the

// 16 combinations of DLL availability)

// - Test that RLibrary::GetInfo and RLibrary::GetInfoFromHeader return the

// expected data for all DLLs and EXEs

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32uid.h>

#include <e32test.h>

#include <f32file.h>

#include <d_ldrtst.h>

#include <f32image.h>

RTest test(_L("T_XXVER2"));

RFs	gFs;

CFileMan* gFileMan;

RLdrTest LdrTest;

TBuf<8> SourcePath = _S16("Z:\\img\\");

TFileName KDestPath()

	{

	_LIT(KDestPath, "C:\\system\\bin\\ver");

	_LIT(KDestPathSysBin, "C:\\sys\\bin\\ver");

	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))

		return KDestPathSysBin();

	else

		return KDestPath();

	}

_LIT(KDllName0, "t_ver2{00010000}.dll");

_LIT(KDllName1, "t_ver2{00010001}.dll");

_LIT(KDllName2, "t_ver2{00020000}.dll");

_LIT(KDllName3, "t_ver2.dll");

const TDesC* const DllArray[] =

	{

	&KDllName0(),

	&KDllName1(),

	&KDllName2(),

	&KDllName3()

	};

const TInt KNumDlls = sizeof(DllArray)/sizeof(const TDesC* const);

const TInt DllVersion[KNumDlls] =

	{

	0x00010000,

	0x00010001,

	0x00020000,

	0x00030000

	};

const TInt KNumTestVersions = 7;

const TInt TestDllVersion[KNumTestVersions] =

	{

	0x00000000,

	0x00010000,

	0x00010001,

	0x00010002,

	0x00020000,

	0x00030000,

	0x00040000

	};

_LIT(KExeName0, "t_xver2a.exe");	// request 1.0 work with any

_LIT(KExeName1, "t_xver2b.exe");	// request 1.0 work with 2.0 but not 3.0

_LIT(KExeName2, "t_xver2c.exe");	// request 1.0 don't work with 2.0

_LIT(KExeName3, "t_xver2d.exe");	// request 1.1 work with 1.0 but not 2.0

_LIT(KExeName4, "t_xver2e.exe");	// request 1.1 work with any

_LIT(KExeName5, "t_xver2f.exe");	// request 1.1 work with 2.0, 3.0 but not with 1.0

_LIT(KExeName6, "t_xver2g.exe");	// request 1.1 don't work with 2.0, 3.0 or 1.0

_LIT(KExeName7, "t_xver2h.exe");	// request 1.1 work with 1.0 and 2.0 but not 3.0

_LIT(KExeName8, "t_xver2i.exe");	// request 1.1 work with 2.0 but not 3.0 or 1.0

_LIT(KExeName9, "t_xver2j.exe");	// request 2.0 only use 1.0 exports

_LIT(KExeName10, "t_xver2k.exe");	// request 2.0 only use 1.0, 1.1 exports

_LIT(KExeName11, "t_xver2l.exe");	// request 2.0 use 2.0 exports work on 3.0

_LIT(KExeName12, "t_xver2m.exe");	// request 2.0 use 2.0 exports, don't work on 3.0

_LIT(KExeName13, "t_xver2n.exe");	// request 3.0 use 1.0 exports only

_LIT(KExeName14, "t_xver2o.exe");	// request 3.0 use all

const TDesC* const ExeArray[] =

	{

	&KExeName0(),

	&KExeName1(),

	&KExeName2(),

	&KExeName3(),

	&KExeName4(),

	&KExeName5(),

	&KExeName6(),

	&KExeName7(),

	&KExeName8(),

	&KExeName9(),

	&KExeName10(),

	&KExeName11(),

	&KExeName12(),

	&KExeName13(),

	&KExeName14()

	};

const TInt KNumExes = sizeof(ExeArray)/sizeof(const TDesC* const);

const TInt ResultArray[KNumExes<<KNumDlls] =

	{

//	DLLs Present			A	B	C	D	E	F	G	H	I	J	K	L	M	N	O

// None

							-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,

// 1.0

							0,	0,	0,	0,	0,	-1,	-1,	0,	-1,	-1,	-1,	-1,	-1,	-1,	-1,

// 1.1

							1,	1,	1,	1,	1,	1,	1,	1,	1,	-1,	-1,	-1,	-1,	-1,	-1,

// 1.0, 1.1

							1,	1,	1,	1,	1,	1,	1,	1,	1,	-1,	-1,	-1,	-1,	-1,	-1,

// 2.0

							2,	2,	-1,	-1,	2,	2,	-1,	2,	2,	2,	2,	2,	2,	-1,	-1,

// 2.0, 1.0

							0,	0,	0,	0,	2,	2,	-1,	2,	2,	2,	2,	2,	2,	-1,	-1,

// 2.0, 1.1

							1,	1,	1,	1,	1,	1,	1,	1,	1,	2,	2,	2,	2,	-1,	-1,

// 2.0, 1.1, 1.0

							1,	1,	1,	1,	1,	1,	1,	1,	1,	2,	2,	2,	2,	-1,	-1,

// 3.0

							3,	-1,	-1,	-1,	3,	3,	-1,	-1,	-1,	3,	3,	3,	-1,	3,	3,

// 3.0, 1.0

							0,	0,	0,	0,	3,	3,	-1,	0,	-1,	3,	3,	3,	-1,	3,	3,

// 3.0, 1.1

							1,	1,	1,	1,	1,	1,	1,	1,	1,	3,	3,	3,	-1,	3,	3,

// 3.0, 1.1, 1.0

							1,	1,	1,	1,	1,	1,	1,	1,	1,	3,	3,	3,	-1,	3,	3,

// 3.0, 2.0

							2,	2,	-1,	-1,	2,	2,	-1,	2,	2,	2,	2,	2,	2,	3,	3,

// 3.0, 2.0, 1.0

							0,	0,	0,	0,	2,	2,	-1,	2,	2,	2,	2,	2,	2,	3,	3,

// 3.0, 2.0, 1.1

							1,	1,	1,	1,	1,	1,	1,	1,	1,	2,	2,	2,	2,	3,	3,

// 3.0, 2.0, 1.1, 1.0

							1,	1,	1,	1,	1,	1,	1,	1,	1,	2,	2,	2,	2,	3,	3

//

	};

const TInt ResultArray2[KNumTestVersions<<KNumDlls] =

	{

//	DLLs Present			0.0	1.0	1.1	1.2	2.0	3.0	4.0

// None

							-1,	-1,	-1,	-1,	-1,	-1,	-1,

// 1.0

							-1,	0,	-1,	-1,	-1,	-1,	-1,

// 1.1

							-1,	1,	1,	-1,	-1,	-1,	-1,

// 1.0, 1.1

							-1,	1,	1,	-1,	-1,	-1,	-1,

// 2.0

							-1,	-1,	-1,	-1,	2,	-1,	-1,

// 2.0, 1.0

							-1,	0,	-1,	-1,	2,	-1,	-1,

// 2.0, 1.1

							-1,	1,	1,	-1,	2,	-1,	-1,

// 2.0, 1.1, 1.0

							-1,	1,	1,	-1,	2,	-1,	-1,

// 3.0

							-1,	-1,	-1,	-1,	-1,	3,	-1,

// 3.0, 1.0

							-1,	0,	-1,	-1,	-1,	3,	-1,

// 3.0, 1.1

							-1,	1,	1,	-1,	-1,	3,	-1,

// 3.0, 1.1, 1.0

							-1,	1,	1,	-1,	-1,	3,	-1,

// 3.0, 2.0

							-1,	-1,	-1,	-1,	2,	3,	-1,

// 3.0, 2.0, 1.0

							-1,	0,	-1,	-1,	2,	3,	-1,

// 3.0, 2.0, 1.1

							-1,	1,	1,	-1,	2,	3,	-1,

// 3.0, 2.0, 1.1, 1.0

							-1,	1,	1,	-1,	2,	3,	-1

//

	};

struct SExportInfo

	{

	TInt	iTotal;

	TInt	iHoles;

	TInt	iHole[1];

	};

const TInt Dll0ExportInfo[] = {19,0};

const TInt Dll1ExportInfo[] = {29,0};

const TInt Dll2ExportInfo[] = {39,4,2,3,23,24};

const TInt Dll3ExportInfo[] = {59,6,2,3,4,23,24,39};

const SExportInfo* const DllExportInfo[KNumDlls] =

	{

	(const SExportInfo*)Dll0ExportInfo,

	(const SExportInfo*)Dll1ExportInfo,

	(const SExportInfo*)Dll2ExportInfo,

	(const SExportInfo*)Dll3ExportInfo

	};

void CheckExports(TInt aDllNum, RLibrary aLib)

	{

	test.Printf(_L("Testing exports for DLL %d\n"), aDllNum);

	const TFileName& fn = aLib.FileName();

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

	const SExportInfo* e = DllExportInfo[aDllNum];

	TAny* libcs = LdrTest.LibraryCodeSeg(aLib.Handle());

	test.Printf(_L("Code seg @%08x\n"), libcs);

	test(libcs != NULL);

	TInt n = e->iTotal;

	TInt nh = e->iHoles;

	TInt ord;

	for (ord=1; ord<=n+1; ++ord)

		{

		TLibraryFunction f = aLib.Lookup(ord);

		test.Printf(_L("Ord %3d->%08x\n"), ord, f);

		if (ord>n)

			{

			test(!f);

			continue;

			}

		TInt i;

		for (i=0; i<nh && e->iHole[i]!=ord; ++i) {}

		if (i<nh)

			test(!f);	// hole

		else

			test(f!=NULL);

		TAny* cs = LdrTest.CodeSegFromAddr((TLinAddr)f);

		test(f ? (cs==libcs) : !cs);

		}

	}

void CreateAndPopulateDir(TUint aMask)

	{

	test.Printf(_L("CreateAndPopulateDir %d\n"), aMask);

	TFileName fn = KDestPath();

	fn.AppendNumFixedWidth(aMask, EDecimal, 2);

	fn.Append('\\');

	TInt r = gFs.MkDirAll(fn);

	test.Printf(_L("MkDir %S->%d\n"), &fn, r);

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

	TFileName fn2 = fn;

	fn2.Append(_L("*.*"));

	TTime now;

	now.HomeTime();

	r = gFileMan->Attribs(fn2, 0, KEntryAttReadOnly|KEntryAttHidden|KEntryAttSystem|KEntryAttArchive, now);

	test.Printf(_L("Attribs %S->%d\n"), &fn2, r);

	r = gFileMan->Delete(fn2);

	test.Printf(_L("Delete %S->%d\n"), &fn2, r);

	TInt n = 0;

	for (; aMask; aMask>>=1, ++n)

		{

		if (!(aMask & 1))

			continue;

		fn2 = fn;

		fn2.Append(*DllArray[n]);

		TFileName src = SourcePath;

		src.Append(*DllArray[n]);

		r = gFileMan->Copy(src, fn2);

		test.Printf(_L("%S->%S (%d)\n"), &src, &fn2, r);

		test(r == KErrNone);

		}

	for (n=0; n<KNumExes; ++n)

		{

		fn2 = fn;

		fn2.Append(*ExeArray[n]);

		TFileName src = SourcePath;

		src.Append(*ExeArray[n]);

		r = gFileMan->Copy(src, fn2);

		test.Printf(_L("%S->%S (%d)\n"), &src, &fn2, r);

		test(r == KErrNone);

		}

	}

void RunExe(TUint aMask, TInt aExeNum)

	{

	test.Printf(_L("RunExe mask %d exenum %d\n"), aMask, aExeNum);

	RProcess p;

	TRequestStatus s;

	TFileName fn = KDestPath();

	fn.AppendNumFixedWidth(aMask, EDecimal, 2);

	fn.Append('\\');

	fn.Append(*ExeArray[aExeNum]);

	TInt r = p.Create(fn, KNullDesC);

	test.Printf(_L("Create %S->%d\n"), &fn, r);

	TInt rix = aExeNum + KNumExes*TInt(aMask);

	TInt expected = ResultArray[rix];

	test.Printf(_L("RunExe expected %d\n"), expected);

	if (expected<0)

		{

		test(r<0);

		return;

		}

	p.Logon(s);

	p.Resume();

	User::WaitForRequest(s);

	if (p.ExitType()!=EExitKill)

		{

		TInt et = p.ExitType();

		TInt er = p.ExitReason();

		const TDesC& ec = p.ExitCategory();

		test.Printf(_L("Exit %d,%d,%S\n"), et, er, &ec);

		test(0);

		}

	CLOSE_AND_WAIT(p);

	test.Printf(_L("Return code %08x\n"), s.Int());

	test(s.Int() == DllVersion[expected]);

	}

void RunExes(TUint aMask)

	{

	test.Printf(_L("RunExes mask %d\n"), aMask);

	RProcess p[KNumExes];

	TRequestStatus s[KNumExes];

	TInt xn;

	for (xn=0; xn<KNumExes; ++xn)

		{

		TFileName fn = KDestPath();

		fn.AppendNumFixedWidth(aMask, EDecimal, 2);

		fn.Append('\\');

		fn.Append(*ExeArray[xn]);

		TInt r = p[xn].Create(fn, KNullDesC);

		test.Printf(_L("Create %S->%d\n"), &fn, r);

		TInt rix = xn + KNumExes*TInt(aMask);

		TInt expected = ResultArray[rix];

		test.Printf(_L("RunExe expected %d\n"), expected);

		if (expected<0)

			{

			test(r<0);

			continue;

			}

		p[xn].Logon(s[xn]);

		}

	for (xn=0; xn<KNumExes; ++xn)

		{

		TInt rix = xn + KNumExes*TInt(aMask);

		TInt expected = ResultArray[rix];

		if (expected<0)

			continue;

		p[xn].Resume();

		}

	for (xn=0; xn<KNumExes; ++xn)

		{

		TInt rix = xn + KNumExes*TInt(aMask);

		TInt expected = ResultArray[rix];

		if (expected<0)

			continue;

		User::WaitForRequest(s[xn]);

		if (p[xn].ExitType()!=EExitKill)

			{

			TInt et = p[xn].ExitType();

			TInt er = p[xn].ExitReason();

			const TDesC& ec = p[xn].ExitCategory();

			test.Printf(_L("Exit %d,%d,%S\n"), et, er, &ec);

			test(0);

			}

		CLOSE_AND_WAIT(p[xn]);

		test.Printf(_L("Return code %08x\n"), s[xn].Int());

		test(s[xn].Int() == DllVersion[expected]);

		}

	}

void TestDynamic(TUint aMask, TInt aTN)

	{

	TUint32 ver = TestDllVersion[aTN];

	TInt rix = aTN + KNumTestVersions*TInt(aMask);

	TInt expected = ResultArray2[rix];

	test.Printf(_L("ReqVer %08x Expected %d\n"), ver, expected);

	TFileName path = KDestPath();

	path.AppendNumFixedWidth(aMask, EDecimal, 2);

	TFileName fn = path;

	fn.Append(_L("\\T_VER2.DLL"));

	RLibrary l;

	TInt r = l.Load(fn, KNullDesC, TUidType(), ver);

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

	if (expected<0)

		{

		test(r<0);

		return;

		}

	TLibraryFunction f = l.Lookup(1);

	test(f != 0);

	TInt result = (*f)();

	test.Printf(_L("Ord 1 returns %08x\n"), result);

	test(result == DllVersion[expected]);

	l.Close();

	r = l.Load(_L("T_VER2.DLL"), path, TUidType(), ver);

	test.Printf(_L("Load T_VER2.DLL path %S returns %d\n"), &path, r);

	if (expected<0)

		{

		test(r<0);

		return;

		}

	f = l.Lookup(1);

	test(f != 0);

	result = (*f)();

	test.Printf(_L("Ord 1 returns %08x\n"), result);

	test(result == DllVersion[expected]);

	CheckExports(expected, l);

	l.Close();

	}

void TestLibraryInfo(TInt aN)

	{

	TFileName fn;

	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))

		fn = _S16("C:\\sys\\bin\\ver15\\");

	else

		fn = _S16("C:\\system\\bin\\ver15\\");

	fn += *DllArray[aN];

	test.Printf(_L("Getting info for %S\n"), &fn);

	TBool formHeader=EFalse;

	for(;;)

		{

		RLibrary::TInfoV2 info;

		TPckg<RLibrary::TInfoV2> infoBuf(info);

		TInt r;

		if(formHeader)

			{

			TUint8* buf;

			RFs fs;

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

			RFile file;

			test((r=file.Open(fs,fn,0))==KErrNone);

			TInt size;

			test((r=file.Size(size))==KErrNone);

			if(size>RLibrary::KRequiredImageHeaderSize)

				size=RLibrary::KRequiredImageHeaderSize;

			buf=new TUint8[size];

			test(buf!=0);

			TPtr8 header(buf,size);

			test((r=file.Read(header))==KErrNone);

			file.Close();

			fs.Close();

			r = RLibrary::GetInfoFromHeader(header, infoBuf);

			test.Printf(_L("GetInfoFromHeader returns %d\n"), r);

			delete buf;

			}

		else

			{

			r = RLibrary::GetInfo(fn, infoBuf);

			test.Printf(_L("GetInfo returns %d\n"), r);

			}

		test(r==KErrNone);

		const TUint32* uid = (const TUint32*)&info.iUids;

		test.Printf(_L("VER  %08x\n"), info.iModuleVersion);

		test.Printf(_L("UID1 %08x\n"), uid[0]);

		test.Printf(_L("UID2 %08x\n"), uid[1]);

		test.Printf(_L("UID3 %08x\n"), uid[2]);

		test.Printf(_L("SID  %08x\n"), (TUint32)info.iSecurityInfo.iSecureId);

		test.Printf(_L("VID  %08x\n"), (TUint32)info.iSecurityInfo.iVendorId);

		test.Printf(_L("CAP0 %08x\n"), ((SSecurityInfo&)info.iSecurityInfo).iCaps[0]);

		test.Printf(_L("CAP1 %08x\n"), ((SSecurityInfo&)info.iSecurityInfo).iCaps[1]);

		TUint32 v = (TUint32)DllVersion[aN];

		test(info.iModuleVersion == v);

		test(uid[0] == (TUint32)KDynamicLibraryUidValue);

		test(uid[2] == (TUint32)0x40abcdef);

		TUint32 xsid = ((v>>16)<<4)|(v&0x0f)|0x89abcd00u;

		test(info.iSecurityInfo.iSecureId == xsid);

		TUint32 xvid = 0x01234500+(xsid&0xff);

		test(info.iSecurityInfo.iVendorId == xvid);

		test(((SSecurityInfo&)info.iSecurityInfo).iCaps[0]==0x0002aaab);

		test(((SSecurityInfo&)info.iSecurityInfo).iCaps[1]==0);

		if(formHeader)

#if defined(__ARMCC__)

			test(info.iHardwareFloatingPoint == EFpTypeVFPv2);

#else

			test(info.iHardwareFloatingPoint == EFpTypeNone);

#endif

		if(formHeader)

			break;

		formHeader = ETrue;

		}

	}

void TestExeInfo(TInt aN)

	{

	TFileName fn;

	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))

		fn = _S16("C:\\sys\\bin\\ver15\\");

	else

		fn = _S16("C:\\system\\bin\\ver15\\");

	fn += *ExeArray[aN];

	test.Printf(_L("Getting info for %S\n"), &fn);

	TBool formHeader=EFalse;

	for(;;)

		{

		RLibrary::TInfoV2 info;

		TPckg<RLibrary::TInfoV2> infoBuf(info);

		TInt r;

		if(formHeader)

			{

			TUint8* buf;

			RFs fs;

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

			RFile file;

			test((r=file.Open(fs,fn,0))==KErrNone);

			TInt size;

			test((r=file.Size(size))==KErrNone);

			if(size>RLibrary::KRequiredImageHeaderSize)

				size=RLibrary::KRequiredImageHeaderSize;

			buf=new TUint8[size];

			test(buf!=0);

			TPtr8 header(buf,size);

			test((r=file.Read(header))==KErrNone);

			file.Close();

			fs.Close();

			r = RLibrary::GetInfoFromHeader(header, infoBuf);

			test.Printf(_L("GetInfoFromHeader returns %d\n"), r);

			delete buf;

			}

		else

			{

			r = RLibrary::GetInfo(fn, infoBuf);

			test.Printf(_L("GetInfo returns %d\n"), r);

			}

		test(r==KErrNone);

		const TUint32* uid = (const TUint32*)&info.iUids;

		test.Printf(_L("VER  %08x\n"), info.iModuleVersion);

		test.Printf(_L("UID1 %08x\n"), uid[0]);

		test.Printf(_L("UID2 %08x\n"), uid[1]);

		test.Printf(_L("UID3 %08x\n"), uid[2]);

		test.Printf(_L("SID  %08x\n"), (TUint32)info.iSecurityInfo.iSecureId);

		test.Printf(_L("VID  %08x\n"), (TUint32)info.iSecurityInfo.iVendorId);

		test.Printf(_L("CAP0 %08x\n"), ((SSecurityInfo&)info.iSecurityInfo).iCaps[0]);

		test.Printf(_L("CAP1 %08x\n"), ((SSecurityInfo&)info.iSecurityInfo).iCaps[1]);

	#if defined(__EABI__) && !defined(__X86__)

		test(info.iModuleVersion == 0x000a0000);

	#else

		test(info.iModuleVersion == 0x00010000);

	#endif

		test(uid[0] == (TUint32)KExecutableImageUidValue);

		TUint32 xuid3 = 0x40abcd61u + aN;

		test(uid[2] == xuid3);

		test(info.iSecurityInfo.iSecureId == xuid3);

		TUint32 xvid = 0x01234500+(xuid3&0xff);

		test(info.iSecurityInfo.iVendorId == xvid);

		test(((SSecurityInfo&)info.iSecurityInfo).iCaps[0]==0x0002aaab);

		test(((SSecurityInfo&)info.iSecurityInfo).iCaps[1]==0);

		if(formHeader)

			test(info.iHardwareFloatingPoint == EFpTypeNone);

		if(formHeader)

			break;

		formHeader = ETrue;

		}

	}

void TestCompression(void)

	{

	// Check target directory

	TFileName fn;

	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))

		fn = _S16("c:\\sys\\bin\\");

	else

		fn = _S16("c:\\system\\bin\\");

	TInt r = gFs.MkDirAll(fn);

	test.Printf(_L("MkDir %S->%d\n"), &fn, r);

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

	// Make copy from t_xxver2.exe to t_xxvercomp.exe 

	fn.Append(_L("t_xxvercomp.exe"));

	TFileName fn2 = fn;

	TTime now;

	now.HomeTime();

	r = gFileMan->Attribs(fn2, 0, KEntryAttReadOnly|KEntryAttHidden|KEntryAttSystem|KEntryAttArchive, now);

	test.Printf(_L("Attribs %S->%d\n"), &fn2, r);

	r = gFileMan->Delete(fn2);

	test.Printf(_L("Delete %S->%d\n"), &fn2, r);

	fn2 = fn;

	TFileName src = SourcePath;

	src.Append(*ExeArray[0]);

	r = gFileMan->Copy(src, fn2);

	test.Printf(_L("%S->%S (%d)\n"), &src, &fn2, r);

	test(r == KErrNone);

	// Check RLibrary::GetInfoFromHeader  on a correct executable

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

	RLibrary::TInfoV2 info;

	TPckg<RLibrary::TInfoV2> infoBuf(info);

	TUint8* buf;

	RFs fs;

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

	RFile file;

	r=file.Open(fs,fn,0);

	test.Printf(_L("file.Open returns %d\n"), r);

	test(r==KErrNone);

	TInt size;

	test((r=file.Size(size))==KErrNone);

	if(size>RLibrary::KRequiredImageHeaderSize)

		size=RLibrary::KRequiredImageHeaderSize;

	buf=new TUint8[size];

	test(buf!=0);

	TPtr8 header(buf,size);

	test((r=file.Read(header))==KErrNone);

	file.Close();

	r = RLibrary::GetInfoFromHeader(header, infoBuf);

	test.Printf(_L("GetInfoFromHeader returns %d\n"), r);

	test(r==KErrNone);

	test.Printf(_L("Write invalid compression info into the header.\n"));

	E32ImageHeader* e32Header = (E32ImageHeader*) buf;

	e32Header->iCompressionType = 0x00000001;

	test((r=file.Open(fs,fn,EFileWrite))==KErrNone);

	r=file.Write(header);

	test.Printf(_L("file.Write returns %d\n"), r);

	test(r==KErrNone);

	file.Close();

	// Check RLibrary::GetInfoFromHeader on a wrong compression method.

	r = RLibrary::GetInfoFromHeader(header, infoBuf);

	test.Printf(_L("GetInfoFromHeader returns %d\n"), r);

	test(r==KErrCorrupt);

	fs.Close();

	delete buf;

	} // End of TestCompression()

TInt E32Main()

	{

	test.Title();

	// Turn off evil lazy dll unloading

	RLoader l;

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

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

	l.Close();

	TBuf<256> cmdline;

	User::CommandLine(cmdline);

	TLex lex(cmdline);

	TInt options[8];

	TInt i;

	memclr(options, sizeof(options));

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

		{

		lex.SkipSpace();

		if (lex.Eos())

			break;

		lex.Val(options[i]);

		}

	TUint tm = 0xffffffffu;

	if (options[0])

		tm = (TUint)options[0];

	test.Start(_L("Create cleanup stack"));

	CTrapCleanup* ct = CTrapCleanup::New();

	test(ct!=0);

	test.Next(_L("Connect to file server"));

	TInt r = gFs.Connect();

	test(r==KErrNone);

	test.Next(_L("Create CFileMan"));

	TRAP(r, gFileMan=CFileMan::NewL(gFs));

	test(r==KErrNone);

	test.Next(_L("Connect to test driver"));

	r = User::LoadLogicalDevice(_L("d_ldrtst"));

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

	r = LdrTest.Open();

	test(r==KErrNone);

	TFileName fn(RProcess().FileName());

	test.Printf(_L("Process file name = %S\n"), &fn);

	SourcePath[0] = fn[0];	// use same drive as this EXE

	TUint mask;

	TUint nmasks = 1u << KNumDlls;

	for (mask=0; mask<nmasks; ++mask)

		{

		CreateAndPopulateDir(mask);

		if (!(tm&1))

			continue;

		TInt n;

		for (n=0; n<KNumExes; ++n)

			{

			RunExe(mask, n);

			}

		RunExes(mask);

		}

	if (tm & 2)

		{

		test.Next(_L("Test dynamic loading by version"));

		for (mask=0; mask<nmasks; ++mask)

			{

			TInt n;

			for (n=0; n<KNumTestVersions; ++n)

				{

				TestDynamic(mask, n);

				}

			}

		}

	if (tm & 4)

		{

		test.Next(_L("Test get library info"));

		TInt n;

		for (n=0; n<KNumDlls; ++n)

			{

			TestLibraryInfo(n);

			}

		for (n=0; n<KNumExes; ++n)

			{

			TestExeInfo(n);

			}

		}

	if( tm & 8)

		{

		TestCompression();

		}

	delete gFileMan;

	gFs.Close();

	delete ct;

	LdrTest.Close();

	test.End();

	return KErrNone;

	}