// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of 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\mmu\t_wsd_tst.cpp
// Test exporting and importing writable static data in DLLs.
// This test relies on three dlls:
// - t_wsd_dl1_[cx][pu]		Which is statically linked, and exports both code & data
// - t_wsd_dl2_[cx][pu]		Which is dyanamically loaded, and imports code & writable static data from
// - t_wsd_dl3_[cx][pu]		Which exports code and writable static data
// The [cx] suffix indicates code-in-RAM vs XIP (ROM), and [pu] indicate paged or unpaged code.
//

//! @SYMTestCaseID			KBASE-T_CODEPAGING-0335
//! @SYMTestType			UT
//! @SYMPREQ				PREQ1110
//! @SYMTestCaseDesc		Demand Paging Code Paging tests.
//! @SYMTestActions			001 Code paging tests
//! @SYMTestExpectedResults All tests should pass.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented

#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <e32math.h>
#include <f32file.h>
#include <f32dbg.h>

#include "mmudetect.h"
#include "t_wsd_tst.h"

// Global data /////////////////////////////////////////////////////////////////

_LIT(KSearchPathTemplate, "%c:\\sys\\bin");		// drive letter
_LIT(KLibraryName, "t_wsd_dl%d_%c%c");			// [23] [cx] [pu]

TInt TheFailure = KErrNone;
TChar CurrentDrive = 'Z';

void SetCurrentDrive(TChar aDrive)
	{
	CurrentDrive = aDrive;
	}

class TPagingDriveInfo
	{
public:
	TChar iDriveLetter;
	TDriveInfo iDriveInfo;
	};

RArray<TPagingDriveInfo> SupportedDrives;

// RTest stuff /////////////////////////////////////////////////////////////////

RTest test(_L("T_WSD"));

#define test_noError(x) { TInt _r = (x); if (_r < 0) HandleError(_r, __LINE__); }
#define test_notNull(x) { TAny* _a = (TAny*)(x); if (_a == NULL) HandleNull(__LINE__); }
#define test_equal(e, a) { TInt _e = TInt(e); TInt _a = TInt(a); if (_e != _a) HandleNotEqual(_e, _a, __LINE__); }

void HandleError(TInt aError, TInt aLine)
	{
	test.Printf(_L("Error %d\n"), aError);
	test.operator()(EFalse, aLine);
	}

void HandleNull(TInt aLine)
	{
	test.Printf(_L("Null value\n"));
	test.operator()(EFalse, aLine);
	}

void HandleNotEqual(TInt aExpected, TInt aActual, TInt aLine)
	{
	test.Printf(_L("Expected 0x%x but got 0x%x\n"), aExpected, aActual);
	test.operator()(EFalse, aLine);
	}

// Utility functions ///////////////////////////////////////////////////////////

TPtrC16 GetMediaType(TInt aMediaType)
	{
	_LIT(KMediaNotPresent, "MediaNotPresent");
	_LIT(KMediaUnknown, "MediaUnknown");
	_LIT(KMediaFloppy, "MediaFloppy");
	_LIT(KMediaHardDisk, "MediaHardDisk");
	_LIT(KMediaCdRom, "MediaCdRom");
	_LIT(KMediaRam, "MediaRam");
	_LIT(KMediaFlash, "MediaFlash");
	_LIT(KMediaRom, "MediaRom");
	_LIT(KMediaRemote, "MediaRemote");
	_LIT(KMediaNANDFlash, "MediaNANDFlash");
	_LIT(KMediaUnKnown, "MediaUnKnown");

	switch (aMediaType)
		{
	case EMediaNotPresent:
		return KMediaNotPresent();
	case EMediaUnknown:
		return KMediaUnknown();
	case EMediaFloppy:
		return KMediaFloppy();
	case EMediaHardDisk:
		return KMediaHardDisk();
	case EMediaCdRom:
		return KMediaCdRom();
	case EMediaRam:
		return KMediaRam();
	case EMediaFlash:
		return KMediaFlash();
	case EMediaRom:
		return KMediaRom();
	case EMediaRemote:
		return KMediaRemote();
	case EMediaNANDFlash:
		return KMediaNANDFlash();
	default:
		return KMediaUnKnown();
		}
	}

// Get the list of testable drives
void GetSupportedDrives(TBool aVerbose = EFalse)
	{
	TUint32 memModelAttributes = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);
	TBool codePagingSupported = (memModelAttributes & EMemModelAttrCodePaging) != 0;
	TUint32 pagingPolicy = E32Loader::PagingPolicy();
	TBool pagingPolicyAllowsPaging = pagingPolicy != EKernelConfigCodePagingPolicyNoPaging;
	test_Equal(codePagingSupported, pagingPolicyAllowsPaging);
	if (codePagingSupported)
		test.Printf(_L("Code paging is enabled.\n"));
	else
		test.Printf(_L("Code paging is NOT enabled.\n"));

	if (aVerbose)
		{
		test.Printf(_L("Available drives:\n"));
		test.Printf(_L("     Type             Attr     MedAttr  Filesystem\n"));
		}

	RFs fs;
	test_noError(fs.Connect());

	TDriveList driveList;
	TInt r = fs.DriveList(driveList);
	test_noError(r);

	TBool NandPageableMediaFound = EFalse;
	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)
		{
		if (!driveList[drvNum])
			continue;   //-- skip unexisting drive

		TDriveInfo driveInfo;
		r = fs.Drive(driveInfo, drvNum);
		test_noError(r);

		TChar ch;
		r = fs.DriveToChar(drvNum, ch);
		test_noError(r);

		TBuf<256> fileSystemName;
		r = fs.FileSystemName(fileSystemName, drvNum);
		test_noError(r);

		// Decide which drives to exclude:
		//		Locked/nonwritable drives, except the Z: ROM drive
		//		Win32 drives on the emulator
		//		Remote/nonlocal, removable/noninternal, redirected, substed drives
		//	All others are included by default iff code paging is supported
		//	If not, only the Z: ROM/XIP drive is tested
		_LIT(KWin32FS, "Win32");
		TBool include = codePagingSupported;
		if (driveInfo.iDriveAtt & KDriveAttRom)
			include = (ch == 'Z');
		else if (driveInfo.iMediaAtt & (KMediaAttWriteProtected|KMediaAttLocked))
			include = EFalse;
		else if (fileSystemName == KWin32FS())
			include = EFalse;
		else if (driveInfo.iDriveAtt & (KDriveAttRedirected|KDriveAttSubsted|KDriveAttRemovable|KDriveAttRemote))
			include = EFalse;
		else if ((KDriveAttInternal|KDriveAttLocal) & ~driveInfo.iDriveAtt)
			include = EFalse;

		if (include)
			{
			TPagingDriveInfo pagingDriveInfo;
			pagingDriveInfo.iDriveLetter = ch;
			pagingDriveInfo.iDriveInfo = driveInfo;
			r = SupportedDrives.Append(pagingDriveInfo);
			test_noError(r);
			}

		TBool pageable = EFalse;
		if (driveInfo.iDriveAtt & KDriveAttPageable)
			{
			pageable = ETrue;
			if (driveInfo.iType == EMediaNANDFlash)
				NandPageableMediaFound = ETrue;
			}

		// If we've already found a pageable NAND drive, then assume the
		// Z: drive is pageable too if it's got a composite file system
		_LIT(KCompositeName,"Composite");
		if (NandPageableMediaFound && fileSystemName == KCompositeName())
			pageable = ETrue;

		if (aVerbose)
			{
			TPtrC16 mediaType = GetMediaType(driveInfo.iType);
			_LIT(KPageable, "pageable");
			test.Printf(_L("%c  %c: %16S %08x %08x %10S %S\n"),
						include ? '*' : ' ', (TUint)ch, &mediaType,
						driveInfo.iDriveAtt, driveInfo.iMediaAtt,
			            &fileSystemName, (pageable ? &KPageable : &KNullDesC));
			}
		}

	fs.Close();
	}

const TDesC& LibrarySearchPath(TChar aDrive)
	{
	static TBuf<64> path;
	path.Format(KSearchPathTemplate, (TUint)aDrive);
	return path;
	}

const TDesC& LibraryName(TChar aDrive, TInt aLibNo, TBool aRam, TBool aPaged)
	{
	// this gives DLL#2 a different name on each drive so we can be sure we're loading the right one
	static TBuf<64> name;
	name.Format(KLibraryName, aLibNo, aRam ? 'c' : 'x', aPaged ? 'p' : 'u');
	if (aLibNo == 2 && aDrive != 'Z')
		name.AppendFormat(_L("_%c"), (TUint)aDrive);
	return name;
	}

const TDesC& LibraryFilename(TChar aDrive, TInt aLibNo, TBool aRam, TBool aPaged)
	{
	static TBuf<64> filename;
	filename = LibrarySearchPath(aDrive);
	filename.AppendFormat(_L("\\%S.dll"), &LibraryName(aDrive, aLibNo, aRam, aPaged));
	return filename;
	}

TInt LoadSpecificLibrary(RLibrary& aLibrary, TChar aDrive, TInt aLibNo, TBool aRam, TBool aPaged)
	{
	const TDesC& path = LibrarySearchPath(aDrive);
	const TDesC& name = LibraryName(aDrive, aLibNo, aRam, aPaged);
	TInt err = aLibrary.Load(name, path);
	TBuf<256> message;
	message.Format(_L("Loading %S\\%S.dll returns %d\n"), &path, &name, err);
	test.Printf(message);
	return err;
	}

// Test functions //////////////////////////////////////////////////////////////

void CopyDllToCurrentDrive(RFs& aFs, TBool aPaged, TInt aLibNo)
	{
	TBuf<64> source = LibraryFilename('Z', aLibNo, ETrue, aPaged);
	TBuf<64> dest = LibraryFilename(CurrentDrive, aLibNo, ETrue, aPaged);
	test.Printf(_L("Copying %S to %S\n"), &source, &dest);

	TInt r = aFs.MkDirAll(dest);
	test(r == KErrNone || r == KErrAlreadyExists);

	TBuf<64> tempName(dest);
	tempName.Append(_L(".tmp"));

	RFile in, out, temp;
	test_noError(in.Open(aFs, source, EFileRead));
	test_noError(out.Replace(aFs, dest, EFileWrite));
	test_noError(temp.Replace(aFs, tempName, EFileWrite));

	const TInt KBufferSize = 3333;
	TBuf8<KBufferSize> buffer;

	test_noError(temp.Write(buffer));
	test_noError(temp.Flush());

	TInt size;
	test_noError(in.Size(size));
	TInt pos = 0;
	while (pos < size)
		{
		test_noError(in.Read(buffer));
		test_noError(out.Write(buffer));
		test_noError(out.Flush());
		test_noError(temp.Write(buffer));
		test_noError(temp.Flush());
		pos += buffer.Length();
		}

	out.SetAtt(KEntryAttNormal, KEntryAttReadOnly|
								KEntryAttHidden|
								KEntryAttSystem|
								KEntryAttArchive|
								KEntryAttXIP);

	in.Close();
	out.Close();
	temp.Close();
	}

void CopyDllsToCurrentDrive()
	{
	RFs fs;
	test_noError(fs.Connect());

	CopyDllToCurrentDrive(fs, EFalse, 2);		// Unpaged library 2
	CopyDllToCurrentDrive(fs, EFalse, 3);		// Unpaged library 3
	CopyDllToCurrentDrive(fs, ETrue, 2);		// Paged library 2
	CopyDllToCurrentDrive(fs, ETrue, 3);		// Paged library 3

	fs.Close();
	}

void EraseDllsFromCurrentDrive()
	{
	RFs fs;
	test_noError(fs.Connect());

	CTrapCleanup* cleanup = CTrapCleanup::New();
	test_notNull(cleanup);

	CFileMan* fileMan = NULL;
	TRAPD(r, fileMan = CFileMan::NewL(fs));
	test_noError(r);

	TBuf<64> libdir = LibrarySearchPath(CurrentDrive);
	test.Printf(_L("Erasing %S\n"), &libdir);
	fileMan->RmDir(libdir);

	delete fileMan;
	delete cleanup;
	fs.Close();
	}

void CheckRelocatableData(RLibrary& library)
	{
	TGetAddressOfDataFunction func = (TGetAddressOfDataFunction)library.Lookup(KGetAddressOfDataFunctionOrdinal);
	test_notNull(func);

	TInt size;
	void* codeAddr;
	void* dataAddr;
	void*** dataPtrPtr = (void***)func(size, codeAddr, dataAddr);
	void **dp = (void **)dataAddr;

	for (TInt i = 0; i < size/4; i += 2)
		{
		test_equal(dp[i], codeAddr);
		test_equal(dp[i+1], dataAddr);
		}

	test_equal(*dataPtrPtr, dp);
	}

void CheckWritableStaticData(RLibrary& library)
	{
	TInt (*func)(void) = (TInt (*)(void))library.Lookup(KCheckWritableStaticDataFunctionOrdinal);
	RDebug::Printf("CheckWritableStaticData() is export %d at %08x", KCheckWritableStaticDataFunctionOrdinal, func);
	test_notNull(func);
	TInt err = func();
	RDebug::Printf("CheckWritableStaticData() returned %d", err);
	// test_noError(err);
	if (TheFailure == KErrNone)
		TheFailure = err;
	}

void RunPerDriveTests(TBool aPaged, TBool aRam)
	{
	TBuf<64> message = _L("Running ");
	if (!aPaged)
		message.Append(_L("un"));
	message.AppendFormat(_L("paged R%cM tests on drive %c:"),
		aRam ? 'A' : 'O', (TUint)CurrentDrive);
	test.Next(message);

	RFs fs;
	test_noError(fs.Connect());
	fs.SetDebugRegister(KFLDR);

	// Explicitly loading dl2 will implicitly load dl3 as well
	RLibrary dl2;
	test_noError(LoadSpecificLibrary(dl2, CurrentDrive, 2, aRam, aPaged));
	CheckRelocatableData(dl2);
	CheckWritableStaticData(dl2);
	dl2.Close();

	fs.SetDebugRegister(0);
	fs.Close();
	}

TInt E32Main()
	{
	test.Title();
	test.Start(_L("WSD tests"));

	// Check static linkage to dl1
	test_noError(CheckExportedDataAddress(&ExportedData));

	GetSupportedDrives(ETrue);
	test(SupportedDrives.Count() > 0);

	// Turn off evil lazy dll unloading
	RLoader l;
	test(l.Connect()==KErrNone);
	test(l.CancelLazyDllUnload()==KErrNone);
	l.Close();

	// Make sure there aren't any DLLs left over from earlier tests
	TInt i = SupportedDrives.Count();
	while (--i >= 0)
		{
		SetCurrentDrive(SupportedDrives[i].iDriveLetter);
		if (CurrentDrive != 'Z')
				EraseDllsFromCurrentDrive();
		}

	// We want to test all supported drives in order of increasing priority, so
	// that the CurrentDrive is always the hghest priority of those tested so far.
	// Therefore, if Z (XIP ROM, lowest priority) is a valid test drive, do it first
	i = SupportedDrives.Count();
	if (--i >= 0)
		{
		SetCurrentDrive(SupportedDrives[i].iDriveLetter);
		if (CurrentDrive == 'Z')
			{
			// ROM (XIP) tests can only be run from Z:
			RunPerDriveTests(EFalse, EFalse);		// Unpaged ROM
			RunPerDriveTests(ETrue, EFalse);		// Paged ROM
			RunPerDriveTests(EFalse, ETrue);		// Unpaged RAM
			RunPerDriveTests(ETrue, ETrue);			// Paged RAM
			}
		}

	// Now run the RAM-based versions from each remaining drive in turn
	for (i = 0; i < SupportedDrives.Count(); ++i)
		{
		SetCurrentDrive(SupportedDrives[i].iDriveLetter);
		if (CurrentDrive != 'Z')
			{
			CopyDllsToCurrentDrive();
			RunPerDriveTests(EFalse, ETrue);			// Unpaged RAM
			RunPerDriveTests(ETrue, ETrue);				// Paged RAM
			}
		}

	test_noError(TheFailure);
	test.End();
	return 0;
	}