// 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_codepaging.cpp

 // This test relies on four dlls which it loads dynamically:

 // - t_codepaging_dll		Very simple dll, contains a single function.  Used for testing state

 // changes	of pages

 // - t_codepaging_dll2	 	Contains 8 pages of data, used for testing the correct data is paged

 // - t_codepaging_dll3		Statically links to t_codepaging_sll, used for testing ReadExportDir

 // - t_codepaging_dll4		Large dll, used for testing code segment that span more than one page

 // table

 // - t_codepaging_dll5		Contains relocatable const data.

 // - t_codepaging_dll6		Contains relocatable writable data.

 // - t_codepaging_dll7		Statically linked to t_codepaging_dll5 to check dependent DLLs

 // are initialised correctly.

 // Suite of tests specifically to test the code paging portion of demand 

 // paging.

 // 002 Exercise ReadExportDir with one code seg mapped already into current process

 // 003 Exercise ReadExportDir with one code seg mapped into different process

 // 004 Check locking of code which then gets unloaded

 // 004.01 Load test driver...

 // 004.02 Load/unload dll

 // 004.03 Load dll again

 // 004.04 Get data from DLL

 // 004.05 Lock DLL data

 // 004.06 Check DLL data

 // 004.07 Close DLL

 // 004.08 Check DLL loaded at different address

 // 004.09 Unlock DLL data

 // 004.10 Check DLL loaded at original address

 // 004.11 Cleanup

 // 005 Test writing to paged code

 // 005.01 Load DLL

 // 005.02 Get data from DLL

 // 005.03 Write to pages in DLL

 // 006 Running tests on drive I:

 // 007 Test accessing pages by executing code

 // 008 Test accessing pages by reading code

 // 009 Test accessing pages by reading code from another process via an alias

 // 010 Test unmapping paged code

 // 011 Test interactions between two processes

 // 012 Test that the contents of a paged DLL are as expected

 // 013 Test relocated const data in DLL

 // 014 Test relocated writable data in DLL

 // 015 Test relocated writable data in dependent DLL

 // 016 Test relocated writable data in preloaded dependent DLL

 // 017 Test relocated writable data in preloaded dependent DLL opened in other process

 // 018 Test killing a thread while it is taking paging faults

 // 019 Test unloading a library while another thread is executing it

 // 020 Test random access to a large dll

 // 021 Test accessing paged code from 2 processes at 1 priority level(s) for 5 seconds

 // 022 Test accessing paged code from 5 processes at 1 priority level(s) for 10 seconds

 // 023 Test accessing paged code from 10 processes at 1 priority level(s) for 20 seconds

 // 024 Test accessing paged code from 5 processes at 2 priority level(s) for 10 seconds

 // 025 Test accessing paged code from 50 processes at 1 priority level(s) for 2 seconds

 // 026 Running tests on drive Z:

 // 027 Test accessing pages by executing code

 // 028 Test accessing pages by reading code

 // 029 Test accessing pages by reading code from another process via an alias

 // 030 Test unmapping paged code

 // 031 Test interactions between two processes

 // 032 Test that the contents of a paged DLL are as expected

 // 033 Test relocated const data in DLL

 // 034 Test relocated writable data in DLL

 // 035 Test relocated writable data in dependent DLL

 // 036 Test relocated writable data in preloaded dependent DLL

 // 037 Test relocated writable data in preloaded dependent DLL opened in other process

 // 038 Test killing a thread while it is taking paging faults

 // 039 Test unloading a library while another thread is executing it

 // 040 Test random access to a large dll

 // 041 Test accessing paged code from 2 processes at 1 priority level(s) for 5 seconds

 // 042 Test accessing paged code from 5 processes at 1 priority level(s) for 10 seconds

 // 043 Test accessing paged code from 10 processes at 1 priority level(s) for 20 seconds

 // 044 Test accessing paged code from 5 processes at 2 priority level(s) for 10 seconds

 // 045 Test accessing paged code from 50 processes at 1 priority level(s) for 2 seconds

 // 

 //

 //! @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 <f32file.h>

 #include <e32math.h>

 #include <dptest.h>

 #include "mmudetect.h"

 #include "d_memorytest.h"

 #include "d_demandpaging.h"

 #include "t_codepaging_dll.h"

 #include "paging_info.h"

 class TPagingDriveInfo

 	{

 public:

 	TChar iDriveLetter;

 	TDriveInfo iDriveInfo;

 	};

 RArray<TPagingDriveInfo> SupportedDrives;

 /// Page attributes, cut-n-paste'd from mmubase.h

 enum TType

 	{

 //	EInvalid=0,			// No physical RAM exists for this page

 //	EFixed=1,			// RAM fixed at boot time

 //	EUnused=2,			// Page is unused

 //	EChunk=3,

 //	ECodeSeg=4,

 //	EHwChunk=5,

 //	EPageTable=6,

 //	EPageDir=7,

 //	EPtInfo=8,

 //	EShadow=9,

 	EPagedROM=10,

 	EPagedCode=11,

 	EPagedData=12,

 	EPagedCache=13,

 	EPagedFree=14,

 	};

 enum TState

 	{

 	EStateNormal 			= 0,	// no special state

 	EStatePagedYoung 		= 1,

 	EStatePagedOld 			= 2,

 	EStatePagedDead 		= 3,	// Not possible on the flexible memory model.

 	EStatePagedLocked 		= 4,

 	EStatePagedOldestClean 	= 5,	// Flexible memory model only.

 	EStatePagedOldestDirty 	= 6,	// Flexible memory model only.

 	};

 /// The possible states for a logical page of RAM loaded code

 enum TPageState

 	{

 	EStateUnmapped,

 	EStatePagedOut,

 	EStateYoung,

 	EStateOld,

 	EStateOldestClean,

 	EStateOldestDirty,

 	ENumPageStates

 	};

 const TUint KPagedStateShift = 8;

 const TUint KPagedStateMask = 0xff00;

 /// The possible states for a physical page of RAM loaded code

 enum TPhysState

 	{

 	EPhysNotPresent,

 	EPhysYoung,

 	EPhysOld,

 	EPhysOldestClean,

 	EPhysOldestDirty,

 	ENumPhysStates

 	};

 /// Names of the logical page states

 const char* StateNames[ENumPageStates] =

 	{

 	"Unmapped",

 	"PagedOut",

 	"Young",

 	"Old",

 	"OldestClean",

 	"OldestDirty"

 	};

 /// Names of the physical page states

 const char* PhysStateNames[ENumPhysStates] =

 	{

 	"NotPresent",

 	"Young",

 	"Old",

 	"OldestClean",

 	"OldestDirty"

 	};

 /// Array of physical page states indexed by logical page state

 TPhysState PhysStateFromPageState[ENumPageStates] =

 	{

 	EPhysNotPresent,

 	EPhysNotPresent,

 	EPhysYoung,

 	EPhysOld,

 	EPhysOldestClean,

 	EPhysOldestDirty,

 	};

 /// The expected logical page state bitmask for each state

 TInt ExpectedPageState[ENumPageStates] =

 	{

 	0,

 	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged,

 	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent | EPageStatePteValid,

 	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent,

 	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent,

 	EPageStatePageTablePresent | EPageStateInRamCode | EPageStatePaged | EPageStatePtePresent

 	};

 /// Extra bits we expect to be set on the multiple memory model

 TInt ExpectedPageStateMultipleExtra[ENumPageStates] =

 	{

 	EPageStateCodeChunkPresent,

 	EPageStateCodeChunkPresent,

 	EPageStateCodeChunkPresent | EPageStatePhysAddrPresent,

 	EPageStateCodeChunkPresent | EPageStatePhysAddrPresent

 	};

 /// Mask for the bits of the page state related to the physicsal page that we check

 TInt PhysStateMask = 0xffff;

 /// The expected physical page state bitmask for each state

 TInt ExpectedPhysState[ENumPhysStates] =

 	{

 	0,

 	EPagedCode | (EStatePagedYoung<<8),

 	EPagedCode | (EStatePagedOld<<8),

 	EPagedCode | (EStatePagedOldestClean<<8),

 	EPagedCode | (EStatePagedOldestDirty<<8)

 	};

 typedef void (*TFunc)(void);

 typedef void (*TFunc1)(TInt aArg1);

 typedef TFunc TTransitionTable[ENumPageStates][ENumPageStates];

 void LoadLibrary();

 void UnloadLibrary();

 void AccessPage();

 void MakeOld();

 void MakeOldest();

 void MakePagedOut();

 TTransitionTable StateTransitions =

 	{

 // Current:			Next:	EStateUnmapped	EStatePagedOut	EStateYoung		EStateOld	EStateOldestClean	EStateOldestDirty	

 /* EStateUnmapped 	*/	{	0,				LoadLibrary,	0,				0,			0,					0			},

 /* EStatePagedOut	*/	{	UnloadLibrary,	0,				AccessPage,		0,			0,					0			},

 /* EStateYoung		*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		MakeOld,	0,					0			},

 /* EStateOld		*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		0,			MakeOldest,			MakeOldest	},

 /* EStateOldestClean*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		0,			0,					0			},

 /* EStateOldestDirty*/	{	UnloadLibrary,	MakePagedOut,	AccessPage,		0,			0,					0			},

 	};

 const TInt KMaxPathLen = 16;

 typedef TPageState TStatePath[KMaxPathLen];

 // Test paths through the possible states that excercises all transitions except those back to unmapped

 // Doesn't consider dirty pages.

 TStatePath TestPathNoOldest =

 	{

 	EStateUnmapped,

 	EStatePagedOut,

 	EStateYoung,

 	EStateOld,

 	EStateYoung,

 	EStateOld,

 	EStatePagedOut,

 	EStateUnmapped,

 	};

 TStatePath TestPathOldest =

 	{

 	EStateUnmapped,

 	EStatePagedOut,

 	EStateYoung,

 	EStateOld,

 	EStateOldestClean,

 	EStateYoung,

 	EStateOld,

 	EStateYoung,

 	EStateOld,

 	EStatePagedOut,

 	EStateYoung,

 	EStateOld,

 	EStateOldestClean,

 	EStatePagedOut,

 	EStateUnmapped,

 	};

 TStatePath* TestPath = NULL;

 /// The different ways of accessing paged code

 enum TAccessMethod

 	{

 	EAccessExec,

 	EAccessRead,

 	EAccessAliasRead

 	};

 _LIT(KLibraryName, "t_codepaging_dll");

 _LIT(KSearchPathTemplate, "?:\\sys\\bin");

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

 RTest test(_L("T_CODEPAGING"));

 #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);

 	}

 //  Server session /////////////////////////////////////////////////////////////

 _LIT(KServerName, "t_codepaging_server");

 class RTestSession : public RSessionBase

 	{

 public:

 	enum TMessage

 		{

 		EKill,

 		EExec,

 		ESetCurrentDrive,

 		EDesRead,

 		ETestPageState,

 		ETestStateTransition,

 		EStartRandomAccessThread

 		};

 public:

 	TInt Connect(TInt aProcessNum);

 	inline void Kill()

 		{ test_noError(RSessionBase::SendReceive(EKill,TIpcArgs())); }

 	inline void Exec(TFunc aFunc)

 		{ test_noError(RSessionBase::SendReceive(EExec,TIpcArgs((TInt)aFunc))); }

 	inline void SetCurrentDrive(TUint16 aDrive)

 		{ test_noError(RSessionBase::SendReceive(ESetCurrentDrive,TIpcArgs(aDrive))); }

 	inline void DesRead(const TDesC8& aData)

 		{ test_noError(RSessionBase::SendReceive(EDesRead,TIpcArgs(&aData))); }

 	inline void TestPageState(TPageState aState, TPhysState aPhysState)

 		{ test_noError(RSessionBase::SendReceive(ETestPageState,TIpcArgs(aState, aPhysState))); }

 	inline void TestStateTransition(TPageState aState)

 		{ test_noError(RSessionBase::SendReceive(ETestStateTransition,TIpcArgs(aState))); }

 	inline void StartRandomAccessThread(TThreadPriority aPriority)

 		{ test_noError(RSessionBase::SendReceive(EStartRandomAccessThread,TIpcArgs(aPriority))); }

 	};

 TInt RTestSession::Connect(TInt aProcessNum)

 	{

 	TBuf<32> name;

 	name.AppendFormat(_L("%S-%d"), &KServerName, aProcessNum);

 	return CreateSession(name,TVersion());

 	}

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

 TBool MovingMemoryModel;

 TBool MultipleMemoryModel;

 TBool FlexibleMemoryModel;

 TBool HaveOldestLists;

 TInt ProcessNum;

 RTestSession OtherProcess;

 RLibrary PagedLibrary;

 TBool LibraryLoaded = EFalse;

 TTestFunction Library_TestFunction = NULL;

 TAccessMethod AccessMethod;

 RLibrary LargeLibrary;

 TBool LargeLibraryLoaded = EFalse;

 const TUint8* LargeDataStart;

 const TUint8* LargeDataEnd;

 const TUint8* LargeDataPtr;

 TInt PagesReadSinceLastAccess = 0;

 TInt LiveListSize;

 TInt PageSize;

 TPageState State;

 TPhysState PhysState;

 TUint16 CurrentDrive;

 TInt LocalDriveNumber;

 RThread RandomAccessThread;

 volatile TBool RandomAccessKill = EFalse;

 TBool CanForcePageOut = ETrue;

 // 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 pageable drives

 void GetSupportedDrives(TBool aVerbose = EFalse)

 	{

 	if (aVerbose)

 		{

 		test.Printf(_L("Supported drives:\n"));

 		test.Printf(_L("     Type             Attr     MedAttr  Filesystem\n"));

 		}

 	RFs fs;

 	test_noError(fs.Connect());

 	TDriveList driveList;

 	TDriveInfo driveInfo;

 	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

 	    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);

 		if ((driveInfo.iDriveAtt & KDriveAttPageable) && (driveInfo.iType == EMediaNANDFlash))

 			NandPageableMediaFound = ETrue;

 		TBool pageable = EFalse;

 		if (driveInfo.iDriveAtt & KDriveAttPageable)

 			pageable = 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 ((fileSystemName == KCompositeName()) && NandPageableMediaFound)

 			pageable = ETrue;

 		if (pageable)

 			{

 			TChar ch;

 			r = fs.DriveToChar(drvNum, ch);

 			test_noError(r);

 			TPagingDriveInfo pagingDriveInfo;

 			pagingDriveInfo.iDriveLetter = ch;

 			pagingDriveInfo.iDriveInfo = driveInfo;

 			r = SupportedDrives.Append(pagingDriveInfo);

 			test_noError(r);

 			}

 		if (aVerbose)

 			{

 			TPtrC16 mediaType = GetMediaType(driveInfo.iType);

 			_LIT(KPageable, "pageable");

 			test.Printf(_L("  %c: %16S %08x %08x %10S %S\n"), 

 						(TInt) ch, &mediaType, driveInfo.iDriveAtt, driveInfo.iMediaAtt,

 						&fileSystemName, (pageable ? &KPageable : &KNullDesC));

 			}

 		}

 	fs.Close();

 	}

 TInt GetPageState(TAny* aPage)

 	{

 	TInt r = UserSvr::HalFunction(EHalGroupVM, EVMPageState, aPage, 0);

 	test_noError(r);

 	return r;

 	}

 // Force a page to be paged in or rejuvenated, to simulate aging of pages in the live list

 void ForcePageIn()

 	{

 	// Find a page that's old or paged out

 	do

 		{

 		LargeDataPtr += PageSize;

 		if (LargeDataPtr >= LargeDataEnd)

 			LargeDataPtr = LargeDataStart;

 		}

 	while (GetPageState((TAny*)LargeDataPtr) & EPageStatePteValid);

 	// and read from it to make it young

 	TUint32 value = *(volatile TUint8*)LargeDataPtr;

 	(void)value;

 	++PagesReadSinceLastAccess;

 	}

 void FlushAllPages()

 	{

 	test_noError(UserSvr::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0));

 	}

 void TestCurrentState()

 	{

 	test_Value(State, State >= 0 && State < ENumPageStates);

 	test_Value(PhysState, PhysState >= 0 && PhysState < ENumPhysStates);

 	TInt stateBits = GetPageState((TAny*)Library_TestFunction);

 	TInt expected = ExpectedPageState[State];

 	if (MultipleMemoryModel)

 		expected |= ExpectedPageStateMultipleExtra[State];

 	TUint physStateIgnore = 0;

 	if (FlexibleMemoryModel)

 		{

 		expected &= ~EPageStatePageTablePresent; // flexible memory model allocates page tables on demand

 		physStateIgnore = 0xff; // flexible memory model doesn't have separate page types for code/data/ROM

 		}

 	test_equal(expected, stateBits & (~PhysStateMask))

 	test_equal(ExpectedPhysState[PhysState] & ~physStateIgnore, stateBits & PhysStateMask & ~physStateIgnore)

 	}

 void TestPageState(TPageState aExpected, TPhysState aExpectedPhys)

 	{

 	RDebug::Printf("%d:  %-12s %-12s", ProcessNum, StateNames[aExpected], PhysStateNames[aExpectedPhys]);

 	test_equal(State, aExpected);

 	test_equal(PhysState, aExpectedPhys);

 	TestCurrentState();

 	}

 TInt PathLength(const TStatePath& aPath)

 	{

 	TInt i = 1;

 	while (aPath[i] != EStateUnmapped && i < KMaxPathLen)

 		++i;

 	return i + 1;

 	}

 TInt FindState(const TStatePath& aPath, TPageState aTarget)

 	{

 	TInt len = PathLength(aPath);

 	TInt j;

 	for (j = 1 ; j < len ; ++j)

 		{

 		if (aPath[j] == aTarget)

 			return j;

 		}

 	return -1;

 	}

 TInt WriteByte(TAny* aArg)

 	{

 	TUint8* ptr = (TUint8*)aArg;

 	*ptr = 23;

 	return KErrNone;

 	}

 void StartOtherProcess(TInt aProcessNum, RTestSession& aSession)

 	{

 	RProcess me, other;

 	TBuf<16> arg;

 	arg.AppendNum(aProcessNum);

 	test_noError(other.Create(me.FileName(), arg));

 	TRequestStatus status;

 	other.Rendezvous(status);

 	other.Resume();

 	User::WaitForRequest(status);

 	test_noError(status.Int());

 	test_equal(EExitPending, other.ExitType());

 	test_noError(aSession.Connect(aProcessNum));

 	other.Close();

 	}

 const TDesC& LibrarySearchPath(TUint16 aDrive)

 	{

 	static TBuf<32> path;

 	path = KSearchPathTemplate;

 	path[0] = aDrive;

 	return path;

 	}

 const TDesC& LibraryName(TInt aLibraryNum, TUint16 aDrive)

 	{

 	// this gives dlls a different name on each drive so we can be sure we're loading the right one

 	static TBuf<32> name;

 	name = KLibraryName;

 	if (aLibraryNum > 1)

 		name.AppendNum(aLibraryNum);

 	if (aDrive != 'Z')

 		name.AppendFormat(_L("_%c"), aDrive);

 	return name;

 	}

 const TDesC& LibraryFilename(TInt aLibraryNum, TUint16 aDrive)

 	{

 	static TBuf<40> filename;

 	filename = LibrarySearchPath(aDrive);

 	filename.AppendFormat(_L("\\%S.dll"), &LibraryName(aLibraryNum, aDrive));

 	return filename;

 	}

 TInt LoadSpecificLibrary(RLibrary& aLibrary, TInt aLibraryNum, TUint16 aDrive)

 	{

 	const TDesC& name = LibraryName(aLibraryNum, aDrive);

 	const TDesC& path = LibrarySearchPath(aDrive);

 	return aLibrary.Load(name, path);

 	}

 TInt GetLocDrvNumber(TUint16 aDrive)

 	{

 	RFs fs;

 	RFile file;

 	TBuf<40> libname = LibraryFilename(1, aDrive);

 	fs.Connect();

 	TInt r=file.Open(fs,libname,EFileRead);

 	if(r!=KErrNone)

 		test.Printf(_L("%d: Error %d: could not open file %S\n"),ProcessNum, r, &libname);

 	test(r==KErrNone);

 	SBlockMapInfo info;

 	TInt64 start=0;

 	r=file.BlockMap(info,start, -1,ETestDebug);

 	if (r!=KErrNone && r!=KErrCompletion)

 		test.Printf(_L("Error %d: could not obtain block map\n"),r);

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

 	TInt locDriveNumber=info.iLocalDriveNumber;

 	file.Close();

 	fs.Close();

 	return locDriveNumber;

 	}

 void LoadLargeLibrary()

 	{

 	test(!LargeLibraryLoaded);

 	test_noError(LoadSpecificLibrary(LargeLibrary, 4, CurrentDrive));

 	TGetAddressOfDataFunction func = (TGetAddressOfDataFunction)LargeLibrary.Lookup(KGetAddressOfDataFunctionOrdinal);

 	TInt size;

 	LargeDataStart = (TUint8*)func(size);

 	test_notNull(LargeDataStart);

 	if (size < LiveListSize*PageSize)

 		{

 		// We need an area of paged data large enough to ensure we can cause a page of our choice to

 		// be paged out.  If the size of the live list for testing is too small, we'll skip some tests

 		CanForcePageOut = EFalse;

 		}

 	LargeDataEnd = LargeDataStart + size;

 	LargeDataPtr = LargeDataStart;

  	LargeLibraryLoaded = ETrue;

 	}

 void UnloadLargeLibrary()

 	{

 	test(LargeLibraryLoaded);

 	LargeLibrary.Close();

 	LargeDataStart = NULL;

 	LargeDataEnd = NULL;

 	LargeDataPtr = NULL;

 	LargeLibraryLoaded = EFalse;

 	}

 // Page in a page and keep aging it to see if it ever reaches an oldest list. 

 TBool SetHaveOldestLists()

 	{

 	AccessMethod = EAccessExec;

 	AccessPage();

 	TInt pagedState = (GetPageState((TAny*)Library_TestFunction) & KPagedStateMask) >> KPagedStateShift;

 	do	

 		{

 		ForcePageIn();

 		pagedState = (GetPageState((TAny*)Library_TestFunction) & KPagedStateMask) >> KPagedStateShift;

 		if (EStatePagedOldestClean == pagedState || EStatePagedOldestDirty == pagedState)

 			break;

 		}

 	while (	PagesReadSinceLastAccess <= LiveListSize);

 	HaveOldestLists = EStatePagedOldestClean == pagedState || EStatePagedOldestDirty == pagedState;

 	return HaveOldestLists;

 	}

 void SetCurrentDrive(TUint16 aDrive)

 	{

 	if (LargeLibraryLoaded)

 		UnloadLargeLibrary();

 	CurrentDrive = aDrive;

 	LocalDriveNumber = GetLocDrvNumber(aDrive);

 	LoadLargeLibrary();

 	if (!Library_TestFunction)

 		{

 		LoadLibrary();

 		Library_TestFunction = (TTestFunction)PagedLibrary.Lookup(KTestFunctionOrdinal);

 		test_notNull(Library_TestFunction);

 		if (SetHaveOldestLists())

 			TestPath = &TestPathOldest;

 		else

 			TestPath = &TestPathNoOldest;

 		UnloadLibrary();

 		FlushAllPages();

 		}

 	}

 // State transition functions //////////////////////////////////////////////////

 void LoadLibrary()

 	{

 	test_noError(LoadSpecificLibrary(PagedLibrary, 1, CurrentDrive));

 	if (MovingMemoryModel)

 		FlushAllPages(); // to make sure pages aren't already mapped

 	LibraryLoaded = ETrue;

 	}

 void UnloadLibrary()

 	{

 	PagedLibrary.Close();

 	LibraryLoaded = EFalse;

 	}

 void AccessPage()

 	{

 	switch (AccessMethod)

 		{

 		case EAccessExec:

 			Library_TestFunction();

 			break;

 		case EAccessRead:

 			{

 			TUint8 x = *(volatile TUint8*)Library_TestFunction;

 			(void)x;

 			}

 			break;

 		case EAccessAliasRead:

 			{

 			TPtrC8 des((TUint8*)Library_TestFunction, 4);  // descriptor header must be in different page to data

 			OtherProcess.DesRead(des);

 			}

 			break;

 		}

 	PagesReadSinceLastAccess = 0;

 	}

 void MakeOld()

 	{

 	TInt initialState = GetPageState((TAny*)Library_TestFunction);

 	do	

 		ForcePageIn();

 	while (PagesReadSinceLastAccess <= LiveListSize &&

 		   initialState == GetPageState((TAny*)Library_TestFunction));

 	TUint pagedState = (GetPageState((TAny*)Library_TestFunction) & KPagedStateMask) >> KPagedStateShift;

 	test_Equal(EStatePagedOld, pagedState);

 	}

 void MakeOldest()

 	{

 	TInt pagedState = (GetPageState((TAny*)Library_TestFunction) & KPagedStateMask) >> KPagedStateShift;

 	do	

 		{

 		ForcePageIn();

 		pagedState = (GetPageState((TAny*)Library_TestFunction) & KPagedStateMask) >> KPagedStateShift;

 		if (EStatePagedOldestClean == pagedState ||	EStatePagedOldestDirty == pagedState)

 			break;

 		}

 	while (PagesReadSinceLastAccess <= LiveListSize);

 	test_Value(pagedState, EStatePagedOldestClean == pagedState || EStatePagedOldestDirty == pagedState);

 	}

 void MakePagedOut()

 	{

 	TInt finalListState1 = EStatePagedOld;

 	TInt finalListState2 = EStatePagedOld;

 	if (HaveOldestLists)

 		{

 		finalListState1 = EStatePagedOldestClean;

 		finalListState2 = EStatePagedOldestDirty;

 		}

 	TInt pagedState = (GetPageState((TAny*)Library_TestFunction) & KPagedStateMask) >> KPagedStateShift;

 	// Get the page onto the final list(s) so it can be detected when it is paged out.

 	while (	pagedState != finalListState1 && pagedState != finalListState2 &&

 			PagesReadSinceLastAccess <= LiveListSize)

 		{

 		ForcePageIn();

 		pagedState = (GetPageState((TAny*)Library_TestFunction) & KPagedStateMask) >> KPagedStateShift;

 		}

 	// Now force the page off the paging lists.

 	pagedState = GetPageState((TAny*)Library_TestFunction);

 	do

 		{

 		ForcePageIn();

 		}

 	while (	PagesReadSinceLastAccess <= LiveListSize &&

 			pagedState == GetPageState((TAny*)Library_TestFunction));

 	}

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

 void Initialise()

 	{

 	CurrentDrive = 'Z';

 	TUint32 memModelAttrs = MemModelAttributes();

 	MovingMemoryModel = ((memModelAttrs & EMemModelTypeMask) == EMemModelTypeMoving);

 	MultipleMemoryModel = ((memModelAttrs & EMemModelTypeMask) == EMemModelTypeMultiple);

 	FlexibleMemoryModel = ((memModelAttrs & EMemModelTypeMask) == EMemModelTypeFlexible);

 	test_noError(UserSvr::HalFunction(EHalGroupKernel, EKernelHalPageSizeInBytes, &PageSize, 0));

 	SVMCacheInfo info;

 	test_noError(UserSvr::HalFunction(EHalGroupVM, EVMHalGetCacheSize, &info, 0));

 	LiveListSize = info.iMaxSize / PageSize;

 	}

 void CopyDllFragmented(RFs& aFs, const TDesC& aSourceName, const TDesC& aDestName)

 	{

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

 	TInt r = aFs.MkDirAll(aDestName);

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

 	TBuf<40> tempName(aDestName);

 	tempName.Append(_L(".tmp"));

 	RFile in, out, temp;

 	test_noError(in.Open(aFs, aSourceName, EFileRead));

 	test_noError(out.Replace(aFs, aDestName, 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();

 		}

 	in.Close();

 	out.Close();

 	temp.Close();

 	}

 void CopyDllToSupportedDrives(RFs& aFs, CFileMan* aFileMan, TInt aLibraryNum)

 	{

 	TBuf<40> source = LibraryFilename(aLibraryNum, 'Z');

 	test.Printf(_L("Copying %S to:\n"), &source);

 	for (TInt i = 0 ; i < SupportedDrives.Count() ; ++i)

 		{

 		TUint8 drive = SupportedDrives[i].iDriveLetter;

 		if (!(SupportedDrives[i].iDriveInfo.iMediaAtt & KMediaAttWriteProtected))

 			{

 			TBuf<40> dest = LibraryFilename(aLibraryNum, drive);

 			CopyDllFragmented(aFs, source, dest);

 			}

 		}

 	}

 void CopyDllsToSupportedDrives()

 	{

 	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);

 	for (TInt i = 1 ; i <= 7 ; ++i)

 		CopyDllToSupportedDrives(fs, fileMan, i);

 	delete fileMan;

 	delete cleanup;	

 	fs.Close();

 	}

 void TestStateTransition(TPageState aNext)

 	{

 	TPhysState nextPhys = PhysStateFromPageState[aNext];

 	RDebug::Printf("%d:  %-12s            -> %-12s", ProcessNum, StateNames[State], StateNames[aNext]);

 	TFunc func = StateTransitions[State][aNext];

 	test_notNull(func);

 	func();

 	State = aNext;

 	PhysState = nextPhys;

 	TestCurrentState();

 	}

 void RunPathTest(const TStatePath& aPath, TInt aStart = 0, TInt aEnd = -1)

 	{

 	if (aEnd == -1)

 		aEnd = PathLength(aPath) - 1;

 	// Check we're already in the starting state

 	TestPageState(aPath[aStart], PhysStateFromPageState[aPath[aStart]]);

 	for (TInt i = aStart + 1 ; i <= aEnd ; ++i)

 		TestStateTransition(aPath[i]);

 	}

 void RunUnmapTest(const TStatePath& aPath)

 	{

 	TInt len = PathLength(aPath);

 	// Test an unmodified code paged page can be unmapped from all the possible 

 	// states it can be in.

 	TInt endState = EStateOld;

 	if (HaveOldestLists)

 		endState = EStateOldestClean;

 	for (TInt i = EStateUnmapped + 1; i <= endState; ++i)

 		{

 		TPageState target = (TPageState)i;

 		RDebug::Printf("\nUnmap from %s:\n", StateNames[target]);

 		TStatePath path;

 		memcpy(path, aPath, sizeof(path));

 		TInt j = FindState(path, target) + 1;

 		test_Value(j, j > 0 && j < len + 1);

 		path[j] = EStateUnmapped;

 		RunPathTest(path, 0, j);

 		}

 	}

 void GoToState(TPageState aState)

 	{

 	if (LibraryLoaded)

 		{

 		UnloadLibrary();

 		State = EStateUnmapped;

 		PhysState = PhysStateFromPageState[State];

 		}

 	TInt i = FindState(*TestPath, aState);

 	test(i != -1);

 	RunPathTest(*TestPath, 0, i);

 	}

 void RunMultiProcessTest()

 	{

 	TStatePath& testPath = *TestPath;

 	TInt len = PathLength(testPath);

 	TInt endState = EStateOld;

 	if (HaveOldestLists)

 		endState = EStateOldestClean;

 	for (TInt i = EStateUnmapped; i <= endState; ++i)

 		{

 		TPageState target = (TPageState)i;

 		RDebug::Printf("\nTesting interaction with second process in state %s:\n", StateNames[target]);

 		GoToState(target);

 		TPageState state2 = testPath[0];  // current state in other process

 		OtherProcess.TestPageState(state2, PhysStateFromPageState[state2]);

 		for (TInt i = 1 ; i < len ; ++i)

 			{

 			TPageState next2 = testPath[i];

 			OtherProcess.TestStateTransition(next2);

 			// Update physical state if affected by transition in other process

 			if ((State == EStateYoung || State == EStateOld || State == EStateOldestClean) &&

 				(state2 != EStateUnmapped && next2 != EStateUnmapped))

 				PhysState = PhysStateFromPageState[next2];

 			// Update logical state in this process if affected by transition in other process

 			if (State == EStateYoung && next2 == EStateOld)

 				State = EStateOld;

 			else if (State == EStateOld && next2 == EStateOldestClean)

 				State = EStateOldestClean;

 			else if ((State == EStateYoung || State == EStateOld || State == EStateOldestClean) &&

 					 (state2 == EStateOld  || state2 == EStateOldestClean) && next2 == EStatePagedOut)

 				State = EStatePagedOut;

 			RDebug::Printf("%d:  %-12s %-12s", ProcessNum, StateNames[State], PhysStateNames[PhysState]);

 			TestCurrentState();

 			state2 = next2;

 			}

 		}

 	if (LibraryLoaded)

 		{

 		UnloadLibrary();

 		State = EStateUnmapped;

 		PhysState = PhysStateFromPageState[State];

 		}	

 	}

 void TestReadExportDir()

 	{

 	RLibrary library;

 	test_noError(LoadSpecificLibrary(library, 3, CurrentDrive));

 	TTestFunction func = (TTestFunction)library.Lookup(KTestFunctionOrdinal);

 	test_notNull(func);

 	test_noError(func());

 	library.Close();

 	}

 void RunReadExportDirTest()

 	{

 	test.Next(_L("Exercise ReadExportDir with one code seg mapped already into current process"));

 	LoadLibrary();

 	TestReadExportDir();

 	UnloadLibrary();

 	test.Next(_L("Exercise ReadExportDir with one code seg mapped into different process"));

 	OtherProcess.Exec(LoadLibrary);

 	TestReadExportDir();

 	OtherProcess.Exec(UnloadLibrary);

 	}

 void RunWriteToPagedCodeTest()

 	{

 	test.Next(_L("Test writing to paged code"));

 	RMemoryTestLdd memoryTest;

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

 	FlushAllPages();

 	TUint8* ptr = (TUint8*)LargeDataStart;

 	while(ptr<LargeDataEnd)

 		{

 		TInt stateBits = GetPageState(ptr);

 		// write to paged out memory should cause exception...

 		test(KErrBadDescriptor==memoryTest.WriteMemory(ptr,0));

 		// page state should be unchanged...

 		test_equal(stateBits,GetPageState(ptr))

 		// page-in in memory...

 		TUint32 value = *(TUint32*)ptr;

 		// page state should be changed...

 		test(stateBits!=GetPageState(ptr));

 		// write to paged out memory should still cause exception...

 		test(KErrBadDescriptor==memoryTest.WriteMemory(ptr,~value));

 		// memory should be unchanged...

 		test(value==*(TUint32*)ptr);

 		ptr += PageSize;

 		}

 	memoryTest.Close();

 	}

 void RunPageLockingTest()

 	{

 	test.Next(_L("Check locking of code which then gets unloaded"));

 	// load test driver...

 	test.Start(_L("Load test driver..."));

 	RDemandPagingTestLdd ldd;

 	TInt r = User::LoadLogicalDevice(KDemandPagingTestLddName);

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

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

 	// load once to get address that code will be loaded at...

 	test.Next(_L("Load/unload dll"));

 	RLibrary library;

 	test_noError(LoadSpecificLibrary(library, 5, CurrentDrive));

 	TGetAddressOfRelocatedDataFunction func = (TGetAddressOfRelocatedDataFunction)library.Lookup(KGetAddressOfDataFunctionOrdinal);

 	test_notNull(func);

 	library.Close();

 	// load again and check it's at the same place...

 	test.Next(_L("Load dll again"));

 	test_noError(LoadSpecificLibrary(library, 5, CurrentDrive));

 	TGetAddressOfRelocatedDataFunction func2 = (TGetAddressOfRelocatedDataFunction)library.Lookup(KGetAddressOfDataFunctionOrdinal);

 	test_equal(func,func2);

 	// get address of data in the DLL...

 	test.Next(_L("Get data from DLL"));

 	void* d;

 	void* c;

 	TInt size;

 	void** data = func(size,d,c);

 	// lock pages...

 	test.Next(_L("Lock DLL data"));

 	r = ldd.Lock(data,size);

 	test_equal(r,1);

 	// check data...

 	test.Next(_L("Check DLL data"));

 	for (TInt i = 0 ; i < size / 4 ; i+=2)

 		{

 		test_equal(c, data[i]);

 		test_equal(d, data[i+1]);

 		}

 	// close library...

 	test.Next(_L("Close DLL"));

 	library.Close();

 	User::After(1000000);

 	if(!FlexibleMemoryModel) // flexible memory model doesn't actually hog virtual address when locked (pinned)

 		{

 		// load again and check it's at a different place

 		// (because the locked memory is hogging the old place)...

 		test.Next(_L("Check DLL loaded at different address"));

 		test_noError(LoadSpecificLibrary(library, 5, CurrentDrive));

 		func2 = (TGetAddressOfRelocatedDataFunction)library.Lookup(KGetAddressOfDataFunctionOrdinal);

 		test(func!=func2);

 		library.Close();

 		User::After(1000000);

 		// unlock pages...

 		test.Next(_L("Unlock DLL data"));

 		r = ldd.Unlock();

 		User::After(1000000);

 		// load again and check it's back at the original place

 		// (because the locked memory now gone)...

 		test.Next(_L("Check DLL loaded at original address"));

 		test_noError(LoadSpecificLibrary(library, 5, CurrentDrive));

 		func2 = (TGetAddressOfRelocatedDataFunction)library.Lookup(KGetAddressOfDataFunctionOrdinal);

 		test(func==func2);

 		library.Close();

 		}

 	// cleanup...

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

 	ldd.Close();

 	test.End();

 	}

 void TestContentsOfPagedDll()

 	{

 	test.Next(_L("Test that the contents of a paged DLL are as expected"));

 	RLibrary library2;

 	test_noError(LoadSpecificLibrary(library2, 2, CurrentDrive));

 	TGetAddressOfDataFunction func = (TGetAddressOfDataFunction)library2.Lookup(KGetAddressOfDataFunctionOrdinal);

 	test_notNull(func);

 	TInt size;

 	TUint* data;

 	data = func(size);

 	test_notNull(data);

 	// Data contents are psuedorandom numbers generated according to the following scheme

 	const TInt A = 1664525;

 	const TInt B = 1013904223;

 	TUint v = 23;

 	for (TInt i = 0 ; i < size / 4 ; ++i)

 		{

 		v = A * v + B;

 		test_equal(v, data[i]);

 		}

 	library2.Close();

 	}

 void CheckRelocatableData(RLibrary& library)

 	{

 	TGetAddressOfRelocatedDataFunction func = (TGetAddressOfRelocatedDataFunction)library.Lookup(KGetAddressOfDataFunctionOrdinal);

 	test_notNull(func);

 	void* d;

 	void* c;

 	TInt size;

 	void** data = func(size,d,c);

 	test_equal(d, data);

 	for (TInt i = 0 ; i < size / 4 ; i+=2)

 		{

 		test_equal(c, data[i]);

 		test_equal(d, data[i+1]);

 		}

 	}

 void OtherProcessCheckRelocatableData()

 	{

 	RLibrary library;

 	test_noError(LoadSpecificLibrary(library, 7, CurrentDrive));

 	CheckRelocatableData(library);

 	library.Close();

 	}

 void TestContentsOfPagedDllWithRelocatedData()

 	{

 	test.Next(_L("Test relocated const data in DLL"));

 	PagingInfo::ResetBenchmarks();

 	RLibrary library;

 	test_noError(LoadSpecificLibrary(library, 5, CurrentDrive));

 	CheckRelocatableData(library);

 	library.Close();

 	PagingInfo::PrintBenchmarks();	// worst case fixups

 	test.Next(_L("Test relocated writable data in DLL"));

 	test_noError(LoadSpecificLibrary(library, 6, CurrentDrive));

 	CheckRelocatableData(library);

 	library.Close();

 	test.Next(_L("Test relocated writable data in dependent DLL"));

 	test_noError(LoadSpecificLibrary(library, 7, CurrentDrive));

 	CheckRelocatableData(library);

 	library.Close();

 	test.Next(_L("Test relocated writable data in preloaded dependent DLL"));

 	RLibrary library2;

 	test_noError(LoadSpecificLibrary(library2, 6, CurrentDrive));

 	test_noError(LoadSpecificLibrary(library, 7, CurrentDrive));

 	CheckRelocatableData(library);

 	library.Close();

 	library2.Close();

 	test.Next(_L("Test relocated writable data in preloaded dependent DLL opened in other process"));

 	test_noError(LoadSpecificLibrary(library2, 6, CurrentDrive));

 	OtherProcess.Exec(OtherProcessCheckRelocatableData);

 	library2.Close();

 	}

 TInt RandomAccessFunc(TAny* aArg)

 	{

 	const TUint8* dataStart = LargeDataStart;

 	const TUint8* dataEnd = LargeDataEnd;	

 	TInt size = dataEnd - dataStart;

 	TUint32 random = (User::FastCounter() << 8) | ProcessNum;

 	TInt i = 0;

 	while (!RandomAccessKill)

 		{

 		random = random*69069+1;

 		TInt offset = random % size;

 		TInt value = dataStart[offset];

 		if (offset != 0 && value != 0)

 			return KErrGeneral;

 		++i;

 		}

 	RDebug::Printf("%d: Performed %d accesses", ProcessNum, i);

 	return KErrNone;

 	}

 void StartRandomAccessThread(TThreadPriority aPriority)

 	{

 	RandomAccessKill = EFalse;

 	test_noError(RandomAccessThread.Create(_L("RandomAccessThread"), RandomAccessFunc, 4096, NULL, 0));

 	RDebug::Printf("%d: starting thread with priority %d", ProcessNum, aPriority);

 	RandomAccessThread.SetPriority(aPriority);

 	RandomAccessThread.Resume();

 	}

 void KillRandomAccessThread()

 	{

 	test_equal(EExitPending, RandomAccessThread.ExitType());

 	TRequestStatus status;

 	RandomAccessThread.Logon(status);

 	RandomAccessKill = ETrue;

 	User::WaitForRequest(status);

 	test_equal(EExitKill, RandomAccessThread.ExitType());

 	test_equal(0, RandomAccessThread.ExitReason());

 	RandomAccessThread.Close();

 	PagedLibrary.Close();

 	}

 void TestLargeDll(TInt aDelay)

 	{

 	test.Next(_L("Test random access to a large dll"));

 	StartRandomAccessThread(EPriorityLess);

 	User::After(aDelay * 1000000);

 	KillRandomAccessThread();

 	}

 void TestKillThreadWhilePaging()

 	{

  	test.Next(_L("Test killing a thread while it is taking paging faults"));

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

 		{

 		RDebug::Printf("  iteration %d", i);

 		StartRandomAccessThread(EPriorityLess);

 		User::After(10000);  // time for ~ 10 paging requests

 		test_equal(EExitPending, RandomAccessThread.ExitType());

 		TRequestStatus status;

 		RandomAccessThread.Logon(status);

 		RandomAccessThread.Terminate(666);

 		User::WaitForRequest(status);

 		test_equal(EExitTerminate, RandomAccessThread.ExitType());

 		test_equal(666, RandomAccessThread.ExitReason());

 		RandomAccessThread.Close();

 		PagedLibrary.Close();

 		}

 	}

 void TestUnloadDllWhilePaging()

 	{

  	test.Next(_L("Test unloading a library while another thread is accessing it"));

 	OtherProcess.Exec(UnloadLargeLibrary);

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

 		{

 		RDebug::Printf("  iteration %d", i);

 		StartRandomAccessThread(EPriorityLess);

 		User::After(10000);  // time for ~ 10 paging requests

 		test_equal(EExitPending, RandomAccessThread.ExitType());

 		TRequestStatus status;

 		RandomAccessThread.Logon(status);

 		UnloadLargeLibrary();

 		PagedLibrary.Close();

 		User::WaitForRequest(status);

 		test_equal(EExitPanic, RandomAccessThread.ExitType());

 		test_equal(3, RandomAccessThread.ExitReason());  // KERN-EXEC 3

 		RandomAccessThread.Close();

 		LoadLargeLibrary();

 		}

 	OtherProcess.Exec(LoadLargeLibrary);

 	}

 void PrintElapsedTime(TTime& aStartTime)

 	{		

 	TTime timeNow;

 	timeNow.UniversalTime();

 	TTimeIntervalSeconds elapsed;

 	test_noError(timeNow.SecondsFrom(aStartTime, elapsed));

 	test.Printf(_L("%d seconds elapsed\n"), elapsed.Int());

 	}

 void TestManyProcesses(TInt aCount, TInt aDelay, TInt aPriorities = 1)

 	{

 	TBuf<128> name;

 	name.AppendFormat(_L("Test accessing paged code from %d processes at %d priority level(s) for %d seconds"),

 					  aCount, aPriorities, aDelay);

 	test.Next(name);

 	TTime startTime;

 	startTime.UniversalTime();

 	// start subprocesses and let them initialise

 	RArray<RTestSession> processes;

 	TInt threadsAtEachPriority = aCount / aPriorities;

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

 		{

 		RTestSession sess;

 		StartOtherProcess(i + 3, sess);

 		test_noError(processes.Append(sess));

 		sess.SetCurrentDrive(CurrentDrive);

 		}

 	test.Printf(_L("Started subprocesses: "));

 	PrintElapsedTime(startTime);

 	// then start random accesses to paged memory

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

 		{

 		TThreadPriority pri;

 		switch (i / threadsAtEachPriority)

 			{

 			case 0:  pri = EPriorityLess; break;

 			default: pri = EPriorityMuchLess; break;

 			}

 		processes[i].StartRandomAccessThread(pri);

 		}

 	test.Printf(_L("Started threads: "));

 	PrintElapsedTime(startTime);

 	test_noError(PagingInfo::ResetAll(LocalDriveNumber,EMediaPagingStatsCode));

 	User::After(aDelay * 1000000);

 	test_noError(PagingInfo::PrintAll(LocalDriveNumber,EMediaPagingStatsCode));

 	test.Printf(_L("Killing subprocesses: "));

 	PrintElapsedTime(startTime);

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

 		{

 		processes[i].Exec(KillRandomAccessThread);

 		processes[i].Kill();

 		processes[i].Close();

 		}

 	test.Printf(_L("Test finished: "));

 	PrintElapsedTime(startTime);

 	processes.Close();

 	}

 void TestCacheSize()

 	{

 	test.Next(_L("Test cache size within bounds"));

 	TUint sizeMin = 0;

 	TUint sizeMax = 0;

 	TUint currentSize = 0;

 	DPTest::CacheSize(sizeMin,sizeMax,currentSize);

 	test.Printf(_L("  minimum size == %d pages\n"), sizeMin >> 12);

 	test.Printf(_L("  maximum size == %d pages\n"), sizeMax >> 12);

 	test.Printf(_L("  current size == %d pages\n"), currentSize >> 12);

 	test(currentSize >= sizeMin);

 	test(currentSize <= sizeMax);

 	}

 void RunUnalignedAliasAccessTest()

 	{

 	test.Next(_L("Test accesses to aliased non-word-aligned data"));

 	for (TInt size = 0 ; size <= 28 ; ++ size)

 		{

 		test.Printf(_L("  size = %d:"), size);

 		for (TInt align = 0 ; align <= 3 ; ++align)

 			{

 			test.Printf(_L(" %d"), align);

 			TPtrC8 des(LargeDataStart + align, size);

 			FlushAllPages();

 			OtherProcess.DesRead(des);			

 			}

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

 		}

 	}

 void TestCodeChunkCreated()

 	{

 	LoadLibrary();

 	TAny* func = (TAny*)PagedLibrary.Lookup(KTestFunctionOrdinal);

 	test_notNull(func);

 	FlushAllPages();

 	test(GetPageState(func) & EPageStateCodeChunkPresent);

 	UnloadLibrary();

 	FlushAllPages();

 	test(!(GetPageState(func) & EPageStateCodeChunkPresent));

 	}

 void TestRepeatedLoading()

 	{

 	test.Next(_L("Test loading/unloading a DLL doesn't leak address space"));

 	for (TInt dll = 1 ; dll <= 7 ; ++dll)

 		{

 		test.Printf(_L("  trying dll %d...\n"), dll);

 		RLibrary library;

 		test_noError(LoadSpecificLibrary(library, dll, CurrentDrive));

 		TLibraryFunction func1 = library.Lookup(1);

 		library.Close();

 		test_noError(LoadSpecificLibrary(library, dll, CurrentDrive));

 		TLibraryFunction func2 = library.Lookup(1);

 		library.Close();

 		test_equal(func1, func2);

 		}

 	}

 void RunDriveIndependantTests()

 	{

 	if (MultipleMemoryModel)

 		{

 		test.Next(_L("Test code chunk created and destroyed correctly"));

 		TestCodeChunkCreated();

 		}

 	SetCurrentDrive('Z');

 	if (CanForcePageOut)

 		{

 		test.Next(_L("Test accessing pages by executing code"));

 		AccessMethod = EAccessExec;

 		RunPathTest(*TestPath);

 		test.Next(_L("Test accessing pages by reading code"));

 		AccessMethod = EAccessRead;

 		RunPathTest(*TestPath);

 		if (!MovingMemoryModel)

 			{

 			test.Next(_L("Test accessing pages by reading code from another process via an alias"));

 			AccessMethod = EAccessAliasRead;

 			RunPathTest(*TestPath);

 			}

 		test.Next(_L("Test unmapping paged code"));

 		AccessMethod = EAccessExec;

 		RunUnmapTest(*TestPath);

 		if (!MovingMemoryModel)

 			{

 			test.Next(_L("Test interactions between two processes"));

 			RunMultiProcessTest();

 			}

 		}

 	RunReadExportDirTest();

 	RunPageLockingTest();

 	RunWriteToPagedCodeTest();

 	RunUnalignedAliasAccessTest();

 	TestRepeatedLoading();

 	}

 void RunPerDriveTests()

 	{

 	TestContentsOfPagedDll();

 	TestContentsOfPagedDllWithRelocatedData();

 	TestKillThreadWhilePaging();

 	TestUnloadDllWhilePaging();

 	TestLargeDll(5);

 	TestManyProcesses(2, 5, 1);

 	TestManyProcesses(5, 10, 1);

 	TestManyProcesses(10, 20, 1);

 	TestManyProcesses(5, 10, 2);

 	TestManyProcesses(50, 2, 1);

 	}

 void RunAllTests()

 	{

 	RunDriveIndependantTests();

 	for (TInt i = 0 ; i < SupportedDrives.Count() ; ++i)

 		{

 		SetCurrentDrive(SupportedDrives[i].iDriveLetter);

 		OtherProcess.SetCurrentDrive(CurrentDrive);

 		TBuf<32> message;

 		message.AppendFormat(_L("Running tests on drive %c:"), (TUint) SupportedDrives[i].iDriveLetter);

 		test.Next(message);		

 		RunPerDriveTests();

 		}

 	TestCacheSize();

 	}

 // Server implementation ///////////////////////////////////////////////////////

 class CTestSession : public CSession2

 	{

 public:

 	virtual void ServiceL(const RMessage2& aMessage);

 	};

 void CTestSession::ServiceL(const RMessage2& aMessage)

 	{

 	TInt r = KErrNone;

 	switch (aMessage.Function())

 		{

 		case RTestSession::EKill:

 			CActiveScheduler::Stop();

 			break;

 		case RTestSession::EExec:

 			((TFunc)aMessage.Int0())();		   

 			break;

 		case RTestSession::ESetCurrentDrive:

 			SetCurrentDrive(aMessage.Int0());

 			break;

 		case RTestSession::EDesRead:

 			{

 			TBuf8<32> buf;

 			if (buf.MaxSize() < aMessage.GetDesLength(0))

 				r = KErrArgument;

 			else

 				r = aMessage.Read(0, buf);

 			}

 			break;

 		case RTestSession::ETestPageState:

 			TestPageState((TPageState)aMessage.Int0(), (TPhysState)aMessage.Int1());

 			break;

 		case RTestSession::ETestStateTransition:

 			TestStateTransition((TPageState)aMessage.Int0());

 			break;

 		case RTestSession::EStartRandomAccessThread:

 			StartRandomAccessThread((TThreadPriority)aMessage.Int0());

 			break;

 		default:

 			r = KErrNotSupported;

 			break;

 		}

 	aMessage.Complete(r);

 	}

 class CTestServer : public CServer2

 	{

 public:

 	CTestServer() : CServer2(0) { }

 	virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

  };

 CSession2* CTestServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const

 	{

 	return new (ELeave) CTestSession();

 	}

 void DoStartServerL()

 	{

 	CActiveScheduler* activeScheduler = new CActiveScheduler;

 	test_notNull(activeScheduler);

 	CActiveScheduler::Install(activeScheduler);

 	CTestServer* server = new CTestServer();

 	test_notNull(server);

 	TBuf<32> name;

 	name.AppendFormat(_L("%S-%d"), &KServerName, ProcessNum);

 	test_noError(server->Start(name));

 	RProcess().Rendezvous(KErrNone);

 	CActiveScheduler::Start();

 	delete server;

 	delete activeScheduler;

 	}

 void StartServer()

 	{

 	CTrapCleanup* cleanupStack = CTrapCleanup::New();

 	test_notNull(cleanupStack);

 	TRAPD(leaveError,DoStartServerL());	

 	test_noError(leaveError);

 	delete cleanupStack;

 	}

 void SecondaryProcess()

 	{

 	TBuf<16> cmd;

 	User::CommandLine(cmd);

 	TLex lex(cmd);

 	lex.Val(ProcessNum);

 	TBuf<32> name;

 	name.AppendFormat(_L("t_codepaging-%d"), ProcessNum);

 	RProcess me;

 	test_noError(me.RenameMe(name));

 	GetSupportedDrives(EFalse);

 	Initialise();

 	SetCurrentDrive('Z');

 	StartServer();

 	}

 void MainProcess()

 	{

 	ProcessNum = 1;

 	test.Title();

 	test.Start(_L("Code paging tests"));

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

 	TUint32 pagingPolicy = E32Loader::PagingPolicy();

 	TBool codePagingSupported = (memModelAttributes & EMemModelAttrCodePaging) != 0;

 	TBool pagingPolicyAllowsPaging = pagingPolicy != EKernelConfigCodePagingPolicyNoPaging;

 	test_Equal(codePagingSupported, pagingPolicyAllowsPaging);

 	if(!codePagingSupported)

 		{

 		test.Printf(_L("TESTS NOT RUN - Code paging not enabled on system.\n"));

 		test.End();

 		return;

 		}

 	GetSupportedDrives(ETrue);

 	test(SupportedDrives.Count() > 0);

 	// Turn off evil lazy dll unloading

 	RLoader l;

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

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

 	l.Close();

 	CopyDllsToSupportedDrives();

 	Initialise();

 	StartOtherProcess(2, OtherProcess);

 	RunAllTests();

 	OtherProcess.Kill();

 	OtherProcess.Close();

 	test.End();

 	}

 TInt E32Main()

 	{

 	if (User::CommandLineLength() == 0)

 		MainProcess();

 	else

 		SecondaryProcess();

 	return 0;

 	}