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