// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// f32test\demandpaging\loader\t_pageldrtst.cpp
// Demand Paging Loader Stress Tests
// Demand Paging Loader stress tests attempt to cause as much paging as possible
// whilst putting the system various types of load.
// t_pageldrtst.exe is the root of the tests, it in turn will start copies of 
// itself stored in various types of media (t_pageldrtst_rom.exe for example).
// It also loads DLLs from various media, each DLL containing simple functions 
// that are aligned on page boundaries, so each function call is likely to 
// cause a page fault.
// Usage:
// t_pageldrtst and t_pageldrtst_rom
// Common command lines:
// t_pageldrtst - run the auto test suite
// t_pageldrtst lowmem - run the low memory tests
// t_pageldrtst chunks - run the chunk tests
// t_pageldrtst chunks+ - run the chunk tests (same as used in autotest)
// t_pageldrtst echunks - run the really stressful chunk tests
// t_pageldrtst auto debug - run the autotest but with debug output to the serial port
// t_pageldrtst d_exc - run the d_exc tests
// Arguments:
// single - run the tests in a single thread
// multiple <numThreads> - run the tests in multiple threads where <numThreads>
// auto - dummy param to trick the tests into running the auto test suite with extra params
// fullauto - param to make the tests perform the full automatic stress test
// interleave - force thread interleaving
// prio - each thread reschedules in between each function call, causes lots of context changes
// media - perform media access during the tests, very stressful
// mmc - only use the mmc media for media access to test file caching
// min - min cache size in pages
// max - max cache size in pages
// chunks - simple chunk stress tests
// chunks+ - the chunk auto tests
// echunks - extremem chunks tests
// nochunkdata - don't check the integrity of the data in the chunks
// lowmem - low memory tests
// dll - only load dll's
// exe - only start exe's (t_pagestress)
// self - only start copies of self (t_pageldrtst from various media)
// complete - dll, exe and self.
// rom - only load from ROM
// base - only load the base DLL and exe's (from code)
// mixed - rom and base.
// all_media - load dlls and exes from all media
// debug - switch on debugging information
// silent - no output to the screen or serial port
// noclean - don't delete copied files on exit
// d_exc - run the d_exc tests
// global - load dlls once globally
// thread - load dlls once per thread
// func - load dlls in the test function (default and most stressful)
// forward - patern in which to execute function calls 
// backward - patern in which to execute function calls 			
// random - patern in which to execute function calls 			
// all - patern in which to execute function calls (forward, backward and random)
// inst - for debugging a parameter passed to a spawned exe to give it an id.
// iters <count> - the number of times to loop (a '-' means run forever)
// reaper - test the reaper.
// btrace - test the btrace code.
// defrag - test the ram defrag code.
// stressfree - set the page cache to stress free size and run tests.
// t_pageldrtst causes a large ammount of paging by repeatedly calling 
// functions from multiple DLLs which include 64 functions which have 
// been aligned on page boundaries from multiple threads, whilst causing 
// background paging by spawning copies of itself and t_pagestress.
// The test also endeavours to stress the loader by loading and unloading
// DLLs from multiple threads from various types of media at the same 
// time as stressing the media, testing chunks, the reaper and changing
// thread priorities.
// 002 Load thrashing, test rapid loading and unloading of DLLs from 
// multiple threads (DEF100158)
// 003 Multiple threads loading DLLs in random pattern
// 004 Multiple threads loading EXE, SELF and DLLs in random pattern with
// all media, loaded in thread with prio change
// 005 Multiple threads loading EXE, SELF and DLLs in random pattern with
// all media, loaded globally with prio change
// 006 Multiple threads loading EXE, SELF and DLLs in random pattern with
// all media, loaded in func with process interleaving
// 007 Multiple threads loading EXE, SELF and DLLs in random pattern with
// all media, loaded in func with process interleaving, prio change
// and media access
// 008 Low Memory setup test
// 009 Low Memory, Multiple threads loading EXE, SELF and DLLs in random 
// pattern, loaded in func.
// 010 Low Memory setup test
// 011 Low Memory, Multiple threads loading EXE, SELF and DLLs in random 
// pattern, loaded in func with process interleaving, 
// prio change and media access
// 012 Close test driver
// 013 Chunk tests, Multiple threads loading EXE, SELF and DLLs in random 
// pattern with ROM / ROFS media, loaded in func with prio change 
// 014 Reaper tests with Multiple threads loading EXE, SELF and DLLs in random 
// pattern with all media 
// 015 Reaper tests with Multiple threads loading EXE, SELF and DLLs in random 
// pattern with all media, prio change and process interleaving
// 016 d_exc check test
// 
//

//! @SYMTestCaseID			KBASE-T_PAGELDRTST-0326
//! @SYMTestType			UT
//! @SYMPREQ				PREQ1110
//! @SYMTestCaseDesc		Demand Paging Loader Stress Tests
//! @SYMTestActions			001 Demand Paging loader stress tests...
//! @SYMTestExpectedResults All tests should pass.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented

#include <e32test.h>
#include <e32rom.h>
#include <e32svr.h>
#include <u32hal.h>
#include <f32file.h>
#include <f32dbg.h>
#include <e32msgqueue.h>
#include <e32math.h>
#include <e32btrace.h>
#include <d32btrace.h>
#include <d32locd.h>
#include <hal.h>

#include "t_hash.h"
#include "paging_info.h"

#ifndef TEST_AUTOTEST
#define TEST_RUN_REAPERTEST
#define TEST_RUN_LOWMEMTEST
#define TEST_RUN_DEFRAGTEST
#define TEST_RUN_D_EXCTEST
#define TEST_RUN_CHUNKTEST
#define TEST_RUN_AUTOTEST
RTest test(_L("T_PAGELDRTST"));
#else
#ifdef TEST_RUN_REAPERTEST
RTest test(_L("T_PAGELDRTST_REAPER"));
#endif
#ifdef TEST_RUN_LOWMEMTEST
RTest test(_L("T_PAGELDRTST_LOWMEM"));
#endif
#ifdef TEST_RUN_DEFRAGTEST
RTest test(_L("T_PAGELDRTST_DEFRAG"));
#endif
#ifdef TEST_RUN_D_EXCTEST
RTest test(_L("T_PAGELDRTST_D_EXC"));
#endif
#ifdef TEST_RUN_CHUNKTEST
RTest test(_L("T_PAGELDRTST_CHUNK"));
#endif
#ifdef TEST_RUN_AUTOTEST
RTest test(_L("T_PAGELDRTST_AUTO"));
#endif
#endif //TEST_AUTOTEST

const TInt KMessageBufSize = 80;
typedef TBuf<KMessageBufSize> TMessageBuf;

//#define TEST_SHORT_TEST
//#define TEST_THRASHING_TEST
//#define TEST_ADD_FAT_MEDIA
#define TEST_DONT_RESET_STATS
#define TEST_MINIMAL_STATS
//#define TEST_KERN_HEAP
#define TEST_ADD_FRAGD_MEDIA
#ifdef TEST_ADD_FRAGD_MEDIA
#endif

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
//#define WANT_FS_CACHE_STATS 
#endif

#ifdef __X86__
#define TEST_ON_UNPAGED
#define TEST_NO_DEXC_IN_AUTO
#endif


#include "t_pagestress.h"
#include "t_pageldrtstdll.h"

#include "t_ramstress.h"

TBool		TestDebug					= EFalse;
TBool		TestSilent					= EFalse;
TBool		TestExit					= EFalse;
#define TEST_EXE			0x01
#define TEST_DLL			0x02
#define TEST_SELF			0x04
#define TEST_EXE_SELF		(TEST_EXE | TEST_SELF)
#define TEST_EXE_SELF_DLL	(TEST_EXE | TEST_SELF | TEST_DLL)
TInt		TestLoading				    = TEST_EXE_SELF_DLL;

#define TEST_MEDIA_BASE			(1 << KTestMediaBase)
#define TEST_MEDIA_ROM			(1 << KTestMediaRom)
#define TEST_MEDIA_ROFS			(1 << KTestMediaRofs)
#define TEST_MEDIA_EXT			(1 << KTestMediaExt)
#define TEST_MEDIA_FAT			(1 << KTestMediaFat)
#define TEST_MEDIA_MMC			(1 << KTestMediaMmc)
#define TEST_MEDIA_ROM_BASE		(TEST_MEDIA_ROM | TEST_MEDIA_BASE)
#define TEST_MEDIA_ALL		(TEST_MEDIA_ROM | TEST_MEDIA_BASE | TEST_MEDIA_ROFS | TEST_MEDIA_EXT | TEST_MEDIA_MMC)

typedef enum
{
	KTestMediaBase = 0,
	KTestMediaRom,
	KTestMediaExt,
	KTestMediaRofs,
#ifdef TEST_ADD_FAT_MEDIA
	KTestMediaFat,  // this is the last one that is always present.
#endif
	KTestMediaMmc,
#ifdef TEST_ADD_FRAGD_MEDIA
	KTestMediaNandFrag,
	KTestMediaMmcFrag,
#endif
	KTestMediaCOUNT,
}ETestMediaType;
#ifdef TEST_ADD_FAT_MEDIA
#define TEST_MEDIA_COUNT_HACK   (KTestMediaFat + 1)
#else
#define TEST_MEDIA_COUNT_HACK   (KTestMediaRofs + 1)
#endif

typedef enum
{
	KTestMediaAccessNone = 0,
	KTestMediaAccessBasic,
	KTestMediaAccessMultipleThreads,
	KTestMediaAccessMultiplePattern,
	KTestMediaAccessMixed,
	KTestMediaAccessCOUNT,
}ETestMediaAccess;

TInt		TestWhichMedia			    = TEST_MEDIA_ROM_BASE;
TInt		DriveNumber=-1;   // Parameter - Which drive?  -1 = autodetect.
TBool		TestSingle					= EFalse;
TBool		TestMultiple				= EFalse;
TInt		TestMaxLoops				= 20;
#define TEST_2MEDIA_THREADS		20
#define TEST_ALLMEDIA_THREADS	20
TInt		TestMultipleThreadCount		= TEST_2MEDIA_THREADS;
TInt		TestInstanceId				= 0;
TBool		TestWeAreTheTestBase        = EFalse;
TBool		TestBootedFromMmc			= EFalse;
TBool		TestOnlyFromMmc				= EFalse;
TBool		TestD_Exc					= EFalse;
TBool		TestNoClean					= EFalse;
TBool		TestFullAutoTest			= EFalse;
#define TEST_DLL_GLOBAL		0x01
#define TEST_DLL_THREAD		0x02
#define TEST_DLL_FUNC		0x04
TInt		TestLoadDllHow				= TEST_DLL_FUNC;
TBool		TestIsAutomated				= EFalse;

#define TEST_INTERLEAVE_PRIO		EPriorityMore//EPriorityRealTime //23 // KNandThreadPriority - 1
TBool		TestInterleave				= EFalse;
TFileName	TestNameBuffer;
TBool		TestPrioChange				= EFalse;

volatile TBool		TestStopMedia				= EFalse;
ETestMediaAccess TestMediaAccess        = KTestMediaAccessNone;
#define TEST_NUM_FILES		5

RSemaphore	TestMultiSem;
RMsgQueue<TMessageBuf> TestMsgQueue;

#define TEST_LM_NUM_FREE	0
#define TEST_LM_BLOCKSIZE	1
#define TEST_LM_BLOCKS_FREE	4
TBool		TestLowMem					= EFalse;
TBool		TestingLowMem				= EFalse;
RPageStressTestLdd PagestressLdd;
RRamStressTestLdd  RamstressLdd;

TBool		TestBtrace					= EFalse;
TBool		TestDefrag					= EFalse;
TBool		TestChunks					= EFalse;
TBool		TestChunksPlus				= EFalse;
TBool		TestExtremeChunks			= EFalse;
TBool		TestChunkData				= ETrue;
TBool		TestingChunks				= EFalse;
volatile TBool		TestDefragTestEnd			= EFalse;
TBool		TestingDefrag				= EFalse;
volatile TBool		TestThreadsExit				= EFalse;
TInt		TestPageSize				= 4096;
RChunk		TestChunk;
TInt		TestCommitEnd = 0;
TUint8*		TestChunkBase = NULL;
#define TEST_NUM_PAGES			64
#define TEST_NUM_CHUNK_PAGES	(TEST_NUM_PAGES * 2)
TBool		TestChunkPageState[TEST_NUM_CHUNK_PAGES];

TBool		TestReaper					= EFalse;
TBool		TestingReaper				= EFalse;
TBool		TestingReaperCleaningFiles  = EFalse;
#define TEST_REAPER_ITERS			20
#define TEST_DOT_PERIOD				30
TBool		TestStressFree				= EFalse;
TInt		TestMinCacheSize = 64 * 4096;
TInt		TestMaxCacheSize = 128 * 4096;
TBool		TestIsDemandPaged = ETrue;
#define TEST_MAX_ZONE_THREADS		8
TUint		TestZoneCount = 0;
TInt TickPeriod = 15625;

#define TEST_NONE		0x0
#define TEST_THRASH		0x1
#define TEST_FORWARD	0x2
#define TEST_BACKWARD	0x4
#define TEST_RANDOM		0x8
#define TEST_ALL		(TEST_RANDOM | TEST_BACKWARD | TEST_FORWARD)
TUint32	TestWhichTests				= TEST_ALL;
_LIT(KRomPath, "z:\\sys\\bin\\");
_LIT(KMmcDefaultPath, "d:\\sys\\bin\\");

#define EXISTS(__val) ((__val == KErrNone) ? &KFileExists : &KFileMissing)
_LIT(KSysHash,"?:\\Sys\\Hash\\");
_LIT(KTestBlank, "");
_LIT(KFileExists, "Exists");
_LIT(KFileMissing, "Missing");
_LIT(KMultipleTest, "Multiple");
_LIT(KSingleTest,   "Single  ");
_LIT(KTestExe, "Exe ");
_LIT(KTestDll, "Dll ");
_LIT(KTestSelf, "Self ");
_LIT(KTestBase, "Base ");
_LIT(KTestRom, "ROM ");
_LIT(KTestAll, "All ");
_LIT(KTestGlobal, "Global");
_LIT(KTestThread, "Thread");
_LIT(KTestFunc,  "Func");
_LIT(KTestInter, "Interleave ");
_LIT(KTestPrio, "Prio ");
_LIT(KTestMedia, "Media ");
_LIT(KTestLowMem, "LowMem ");
_LIT(KTestChunking, "Chunks ");
_LIT(KTestEChunking, "EChunks ");
_LIT(KTestChunkingPlus, "Chunks+ ");
_LIT(KTestReaper, "Reaper ");
_LIT(KTestThrash, "Thrash ");
_LIT(KTestForward, "Forward ");
_LIT(KTestBackward, "Backward ");
_LIT(KTestRandom, "Random ");

typedef struct 
	{
	TBool				testFullAutoOnly;
	TInt				testLoading;
	TInt				testWhichMedia;
	TBool				testMultiple;
	TInt				testMaxLoops;
	TInt				testMultipleThreadCount;
	TBool				testLoadDllHow;
	TBool				testInterleave;
	TBool				testPrioChange;
	ETestMediaAccess	testMediaAccess;
	TUint32				testWhichTests;
	TBool				testLowMem;
	TInt				testFreeRam;
	}TTheTests; 

typedef struct
	{
	TInt	ok;
	TInt	fail;
	}TChunkTestPair;

typedef struct
	{
	TChunkTestPair	lock;
	TChunkTestPair	unlock;
	TChunkTestPair	decommit;
	TChunkTestPair	commit;
	TChunkTestPair	check;
	}
TChunkTestStats;

TChunkTestStats	TestChunkStats[TEST_NUM_CHUNK_PAGES];


TPtrC TestPsExeNames[KTestMediaCOUNT] = {	_L("t_pagestress.exe"), 
											_L("t_pagestress_rom.exe"), 
											_L("t_pagestress_ext.exe"), 
											_L("t_pagestress_rofs.exe"), 
#ifdef TEST_ADD_FAT_MEDIA
											_L("t_pagestress_fat.exe"),
#endif
											_L("t_pagestress_mmc.exe"),
#ifdef TEST_ADD_FRAGD_MEDIA
											_L("t_pagestress_nfr.exe"),
											_L("t_pagestress_mfr.exe"),
#endif
											};

TPtrC TestPlExeNames[KTestMediaCOUNT] = {	_L("t_pageldrtst.exe"), 
											_L("t_pageldrtst_rom.exe"), 
											_L("t_pageldrtst_ext.exe"), 
											_L("t_pageldrtst_rofs.exe"), 
#ifdef TEST_ADD_FAT_MEDIA
											_L("t_pageldrtst_fat.exe"),
#endif
											_L("t_pageldrtst_mmc.exe"),
#ifdef TEST_ADD_FRAGD_MEDIA
											_L("t_pageldrtst_nfr.exe"),
											_L("t_pageldrtst_mfr.exe"),
#endif
											};

_LIT(KDllBaseName,   "t_pageldrtst");

TPtrC TestPlExtNames[KTestMediaCOUNT] = {	_L(".dll"),
											_L("_rom.dll"),
											_L("_ext.dll"),
											_L("_rofs.dll"),
#ifdef TEST_ADD_FAT_MEDIA
											_L("_fat.dll"),
#endif
											_L("_mmc.dll"),
#ifdef TEST_ADD_FRAGD_MEDIA
											_L("_nfr.dll"),
											_L("_mfr.dll"),
#endif
											};


TBool TestDllExesExist[KTestMediaCOUNT] = { EFalse, 
											EFalse,
											EFalse,
											EFalse,
#ifdef TEST_ADD_FAT_MEDIA
											EFalse,
#endif
											EFalse,
#ifdef TEST_ADD_FRAGD_MEDIA
											EFalse,
											EFalse,
#endif
											};
#define DBGS_PRINT(__args)\
	if (!TestSilent) test.Printf __args;

#define DBGD_PRINT(__args)\
	if (TestDebug) test.Printf __args;

void SendDebugMessage(RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
					  TMessageBuf            *aBuffer = NULL,
					  RSemaphore	 		 *aTheSem = NULL)
	{
	for (;;)
		{
		aTheSem->Wait();
		TInt r = aMsgQueue->Send(*aBuffer);
		aTheSem->Signal();
		if (r != KErrOverflow)
			return;
		User::After(0);
		}
	}

#define DEBUG_PRINT(__args)\
if (!TestSilent) \
	{\
	if (aMsgQueue && aBuffer && aTheSem)\
		{\
		aBuffer->Zero();\
		aBuffer->Format __args ;\
		SendDebugMessage(aMsgQueue, aBuffer, aTheSem);\
		}\
	else\
		{\
		test.Printf __args ;\
		}\
	}

#define RUNTEST(__test, __error)\
	if (!TestSilent)\
		test(__test == __error);\
	else\
		__test;

#define RUNTEST1(__test)\
	if (!TestSilent)\
		test(__test);


#define DEBUG_PRINT1(__args)\
if (TestDebug)\
	{\
	DEBUG_PRINT(__args)\
	}

#define DOTEST(__operation, __condition)\
	if (aLowMem) \
		{\
		__operation;\
		while (!__condition)\
			{\
			DBGD_PRINT((_L("Releasing some memory on line %d\n"), __LINE__));\
			if (pTheSem)\
				pTheSem->Wait();\
			PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\
			if (pTheSem)\
				pTheSem->Signal();\
			__operation;\
			}\
		RUNTEST1(__condition);\
		}\
	else\
		{\
		__operation;\
		RUNTEST1(__condition);\
		}

#define DOTEST1(__var, __func, __ok, __fail)\
	if (aLowMem) \
		{\
		__var = __func;\
		while (__var == __fail)\
			{\
			DBGD_PRINT((_L("Releasing some memory on line %d\n"), __LINE__));\
			if (pTheSem)\
				pTheSem->Wait();\
			PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\
			if (pTheSem)\
				pTheSem->Signal();\
			__var = __func;\
			}\
		if (__var != __ok)\
			DBGS_PRINT((_L("Failing on line %d with error %d\n"), __LINE__, __var));\
		RUNTEST1(__var == __ok);\
		}\
	else\
		{\
		__var = __func;\
		RUNTEST1(__var == __ok);\
		}

#define DOLOADALLOC(__numDlls, __pTheLibs, __theSem)\
	if (TestingLowMem)\
		{\
		__pTheLibs = (PageLdrRLibrary *)User::AllocZ(sizeof(PageLdrRLibrary) * __numDlls);\
		while (__pTheLibs == NULL)\
			{\
			DEBUG_PRINT1((_L("Releasing some memory for alloc on line %d\n"), __LINE__));\
			if (__theSem)\
				__theSem->Wait();\
			PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\
			if (__theSem)\
				__theSem->Signal();\
			__pTheLibs = (PageLdrRLibrary *)User::AllocZ(sizeof(PageLdrRLibrary) * __numDlls);\
			}\
		}\
	else\
		{\
		__pTheLibs = (PageLdrRLibrary *)User::AllocZ(sizeof(PageLdrRLibrary) * __numDlls);\
		if (__pTheLibs == NULL)\
			return KErrGeneral;\
		}

#define TEST_NEXT(__args) \
	if (!TestSilent)\
		test.Next __args;

void DoStats();
void CheckFilePresence(TBool aDoFileCopy);
void CleanupFiles(TBool silent);
typedef TInt (*TCallFunction)(TUint32 funcIndex, TInt param1, TInt param2);

class PageLdrRLibrary : public RLibrary
	{
public:
	TInt TestLoadLibrary(const TDesC& aFileName, TInt aThreadIndex, RMsgQueue<TMessageBuf> *aMsgQueue, TMessageBuf *aBuffer, RSemaphore  *aTheSem);
	TInt CloseLibrary();
	
public:	
	TBool				iInUse;
	TUint32				iFuncCount;
	TLibraryFunction	iInitFunc;
	TLibraryFunction	iFunctionCountFunc;
	TCallFunction       iCallFunctionFunc;
	TLibraryFunction	iSetCloseFunc;
	};

TInt PageLdrRLibrary::CloseLibrary()
	{
	if (iInUse)
		{
		if (iSetCloseFunc)
			(iSetCloseFunc)();
		Close();
		iFuncCount = 0;
		iInitFunc = NULL;
		iFunctionCountFunc = NULL;
		iCallFunctionFunc = NULL;
		iSetCloseFunc = NULL;
		iInUse = EFalse;
		}
	return KErrNone;
	}

PageLdrRLibrary		theGlobalLibs[PAGELDRTST_MAX_DLLS * KTestMediaCOUNT];

////////////////////////////////////////////////////////////
// Template functions encapsulating ControlIo magic
//
GLDEF_D template <class C>
GLDEF_C TInt controlIo(RFs &fs, TInt drv, TInt fkn, C &c)
{
    TPtr8 ptrC((TUint8 *)&c, sizeof(C), sizeof(C));

    TInt r = fs.ControlIo(drv, fkn, ptrC);

    return r;
}

//
// FreeRam
//
// Get available free ram.
//

TInt FreeRam()
	{
	// wait for any async cleanup in the supervisor to finish first...
	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);

	TMemoryInfoV1Buf meminfo;
	TInt r=UserHal::MemoryInfo(meminfo);
	test (r==KErrNone);
	return meminfo().iFreeRamInBytes;
	}

//
// FindFsNANDDrive
//
// Find the NAND drive
//

static TInt FindFsNANDDrive(RFs& aFs)
	{
	TDriveList driveList;
	TDriveInfo driveInfo;
	TInt r=aFs.DriveList(driveList);
    if (r == KErrNone)
		{
		for (TInt drvNum= (DriveNumber<0)?0:DriveNumber; drvNum<KMaxDrives; ++drvNum)
			{
			if(!driveList[drvNum])
				continue;   //-- skip unexisting drive

			if (aFs.Drive(driveInfo, drvNum) == KErrNone)
				{
				if(driveInfo.iMediaAtt&KMediaAttPageable)
					{
					TBool readOnly = driveInfo.iMediaAtt & KMediaAttWriteProtected;		// skip ROFS partitions
					if(!readOnly && (driveInfo.iType != EMediaHardDisk))
						{
						if ((drvNum==DriveNumber) || (DriveNumber<0))		// only test if running on this drive
							{
							return (drvNum);
							}
						}
					}
				}
			}
		}
	return (-1);
	}

//
// FindMMCDriveNumber
// 
// Find the first read write drive.
//

TInt FindMMCDriveNumber(RFs& aFs)
	{
	TDriveInfo driveInfo;
	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)
		{
		TInt r = aFs.Drive(driveInfo, drvNum);
		if (r >= 0)
			{
			if (driveInfo.iType == EMediaHardDisk)
				return (drvNum);
			}
		}
	return -1;
	}


//
// PageLdrRLibrary::TestLoadLibrary
//
// Load a library and initialise information about that library
//

TInt PageLdrRLibrary::TestLoadLibrary(const TDesC&           aFileName,
									  TInt					 aThreadIndex,
									  RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
									  TMessageBuf           *aBuffer = NULL,
									  RSemaphore			*aTheSem = NULL)
	{
	TInt retVal = KErrNone;
	if (TestingLowMem)
		{
		TBool whinged = EFalse;
		TInt initialFreeRam = 0;
		TInt freeRam = 0;

		while (1)
			{
			initialFreeRam = FreeRam();
			retVal = Load(aFileName);
			freeRam = FreeRam();
			if (retVal == KErrNoMemory)
				{
				if (!whinged && (freeRam > (4 * TestPageSize)))
					{
					whinged = ETrue;
					DEBUG_PRINT1((_L("Load() %d pages %S\n"), (freeRam / TestPageSize), &aFileName));
					if (TestIsDemandPaged)
						{
						SVMCacheInfo  tempPages;
						UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);

						DEBUG_PRINT1((_L("DPC : min %d max %d curr %d\n"), 
									tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize));
						DEBUG_PRINT1((_L("    : maxFree %d freeRam %d\n"),
									tempPages.iMaxFreeSize, FreeRam()));
						}
					}
				DEBUG_PRINT1((_L("Load() releasing some memory for %S (%d)\n"), &aFileName, retVal));
				if (aTheSem)
					aTheSem->Wait();
				PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);
				if (aTheSem)
					aTheSem->Signal();
				}
			else
				{
				if (whinged)
					{
					DEBUG_PRINT((_L("Load() Ok %d pages (%d) %S\n"), ((initialFreeRam - freeRam) / TestPageSize), (freeRam / TestPageSize), &aFileName));
					}
				break;
				}
			}
		}
	else
		{
		DEBUG_PRINT1((_L("Loading %S (%d)\n"), &aFileName, aThreadIndex));	 
		retVal = Load(aFileName);
		if (retVal != KErrNone)
			{
			DEBUG_PRINT1((_L("Load failed %S (%d)\n"), &aFileName, aThreadIndex));	 
			if (TestingReaper )
				{
				TInt tempIndex = 0;
				TBool whinged = EFalse;
				while (    (   (retVal == KErrNotFound) 
							|| (retVal == KErrPermissionDenied) 
							|| (retVal == KErrCorrupt) 
							|| (retVal == KErrInUse)) 
						&& (    TestingReaperCleaningFiles
							|| (tempIndex < TEST_REAPER_ITERS)))
					{
					User::After(2000000);
					if (!whinged)
						{
						DEBUG_PRINT((_L("Load() retrying load for %S (%d)\n"), &aFileName, retVal));
						whinged = ETrue;
						}
					retVal = Load(aFileName);
					if (!TestingReaperCleaningFiles)
						{
						tempIndex ++;
						}
					}
				if (retVal != KErrNone)
					{
					DEBUG_PRINT((_L("Load() failing for %S (%d) idx %d\n"), &aFileName, retVal, tempIndex));
					}
				}
			else if (TestingDefrag)
				{
				TInt tempIndex = 0;
				TBool whinged = EFalse;
				while ((retVal == KErrGeneral) && (tempIndex < 10))
					{
					User::After(20000);
					if (!whinged)
						{
						DEBUG_PRINT((_L("Load() retrying load for %S (%d)\n"), &aFileName, retVal));
						whinged = ETrue;
						}
					retVal = Load(aFileName);
					tempIndex ++;
					}
				if (retVal != KErrNone)
					{
					DEBUG_PRINT((_L("Load() failing for %S (%d) idx %d\n"), &aFileName, retVal, tempIndex));
					}
				}
			}
		}
	DEBUG_PRINT1((_L("Loaded %S (%d)\n"), &aFileName, aThreadIndex));	 
	if (retVal == KErrNone)
		{
		iInUse = ETrue;
		iInitFunc = Lookup(PAGELDRTST_FUNC_Init);
		iFunctionCountFunc = Lookup(PAGELDRTST_FUNC_FunctionCount);
		iCallFunctionFunc = (TCallFunction)Lookup(PAGELDRTST_FUNC_CallFunction);
		iSetCloseFunc = Lookup(PAGELDRTST_FUNC_SetClose);
		if (   (iInitFunc != NULL)
			&& (iFunctionCountFunc != NULL)
			&& (iCallFunctionFunc != NULL)
			&& (iSetCloseFunc != NULL))
			{
			retVal = (iInitFunc)();
			if (retVal == KErrNone)
				{
				iFuncCount = (iFunctionCountFunc)();
				if (iFuncCount != 0)
					{
					DEBUG_PRINT1((_L("Loaded ok %S (%d)\n"), &aFileName, aThreadIndex));	 
					return KErrNone;	
					}
				retVal = KErrGeneral;
				DEBUG_PRINT((_L("!!! bad count %S (%d)\n"), &aFileName, aThreadIndex));	 
				}
			else
				{
				DEBUG_PRINT((_L("!!! init failed %S (%d)\n"), &aFileName, aThreadIndex));	 
				retVal = KErrGeneral;
				}
			}
		else
			{
			DEBUG_PRINT((_L("!!! missing %S (%d)\n"), &aFileName, aThreadIndex));	 
			retVal = KErrGeneral;
			}
		}
	else
		{
		DEBUG_PRINT((_L("Load() failed %S %d\n"), &aFileName, retVal));
#ifdef WANT_FS_CACHE_STATS
		RFs			 fs;
		if (KErrNone != fs.Connect())
			{
			DEBUG_PRINT(_L("TestLoadLibrary : Can't connect to the FS\n"));
			}
		else
			{
			TFileCacheStats stats1;
			TInt drvNum = FindMMCDriveNumber(fs); 
			controlIo(fs,drvNum, KControlIoFileCacheStats, stats1);
		
			DEBUG_PRINT((_L("FSC: drv %d %c free %d used %d locked %d\n"),
						drvNum, 'a' + drvNum,
						stats1.iFreeCount,
						stats1.iUsedCount,
						stats1.iLockedSegmentCount));
			DEBUG_PRINT((_L("   : alloc %d lock %d closed %d\n"),
						stats1.iAllocatedSegmentCount,
						stats1.iFileCount,
						stats1.iFilesOnClosedQueue));
			fs.Close();
			}
#endif //WANT_FS_CACHE_STATS 

		if (TestIsDemandPaged)
			{
			SVMCacheInfo  tempPages;
			UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);

			DEBUG_PRINT((_L("DPC : min %d max %d curr %d\n"), 
						tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize));
			DEBUG_PRINT((_L("    : maxFree %d freeRam %d\n"),
						tempPages.iMaxFreeSize, FreeRam()));
			}
		}
	return retVal;
	}

//
// GetNumDlls
//
// Work out how many Dlls we will play with
//
TInt GetNumDlls()
	{
	TInt maxDllIndex;

	switch (TestWhichMedia)
		{
		default:
		case TEST_MEDIA_BASE:	
		case TEST_MEDIA_ROM:
			maxDllIndex = PAGELDRTST_MAX_DLLS;
		break;

		case TEST_MEDIA_ROM_BASE:
			maxDllIndex = PAGELDRTST_MAX_DLLS * 2;
		break;

		case TEST_MEDIA_ALL:
			maxDllIndex = PAGELDRTST_MAX_DLLS * KTestMediaCOUNT;
		break;
		}
	return maxDllIndex;
	}

//
// LoadTheLibs
//
// Open DLLs for use in the tests.
//

TInt LoadTheLibs(PageLdrRLibrary       *aTheLibs,
                 TInt                   aLibCount,
				 TInt				    aThreadIndex, 
                 RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
				 TMessageBuf           *aBuffer = NULL, 
				 RSemaphore			   *aTheSem = NULL)
	{
	TBuf<128>			nameBuffer;
	TInt				dllIndex = 0;
	TInt				realDllIndex = 0;
	TInt				dllOffset = -1;
	TInt				testWhich;
	RThread				thisThread;

	memset(aTheLibs, 0, sizeof(*aTheLibs) * aLibCount);
	for (dllIndex = 0; dllIndex < aLibCount; dllIndex ++)
		{
		realDllIndex = (dllIndex + aThreadIndex) % PAGELDRTST_MAX_DLLS;
//		realDllIndex = (dllIndex) % PAGELDRTST_MAX_DLLS;
		if (realDllIndex == 0)
			dllOffset ++;

		if ((TestWhichMedia & TEST_MEDIA_ALL) == TEST_MEDIA_ALL)
			testWhich = (dllIndex + dllOffset) % KTestMediaCOUNT;
		else if ((TestWhichMedia & TEST_MEDIA_ALL) == TEST_MEDIA_ROM_BASE)
			testWhich = ((dllIndex + dllOffset) & 1) ? KTestMediaBase : KTestMediaRom;
		else if (TestWhichMedia & TEST_MEDIA_BASE )
			testWhich = KTestMediaBase;
		else
			testWhich = KTestMediaRom;
		
		if (!TestDllExesExist[testWhich])
			testWhich = KTestMediaBase;

		nameBuffer.Format(_L("%S%d%S"), &KDllBaseName, realDllIndex, &TestPlExtNames[testWhich]);
		
		DEBUG_PRINT1((_L("LoadTheLibs[%02d] - loading %S\n"), aThreadIndex, &nameBuffer));
		TInt theErr = aTheLibs[dllIndex].TestLoadLibrary(nameBuffer, aThreadIndex, aMsgQueue, aBuffer, aTheSem);
		if (theErr != KErrNone)
			{
			DEBUG_PRINT((_L("LoadTheLibs[%02d] - fail %S %d\n"), aThreadIndex, &nameBuffer, theErr));
			return KErrGeneral;
			}
		else
			{
			DEBUG_PRINT1((_L("LoadTheLibs[%02d] - loaded %S OK\n"), aThreadIndex, &nameBuffer));
			}
		if (TestThreadsExit)
			{
			DEBUG_PRINT((_L("LoadTheLibs[%02d] - cancelled\n"), aThreadIndex));
			return KErrCancel;
			}
		if (TestPrioChange)
			{
			TThreadPriority originalThreadPriority = thisThread.Priority();
			DEBUG_PRINT1((_L("LoadTheLibs[%02d] before priority change\n"), aThreadIndex));
			thisThread.SetPriority(EPriorityLess);
			User::AfterHighRes(0);
			thisThread.SetPriority(originalThreadPriority);
			DEBUG_PRINT1((_L("LoadTheLibs[%02d] after priority change\n"), aThreadIndex));
			}
		}
	DEBUG_PRINT((_L("LoadTheLibs[%02d] done\n"), aThreadIndex));
	return KErrNone;
	}

//
// CloseTheLibs
//
// Close the DLLs that we have previously opened
//

void CloseTheLibs (PageLdrRLibrary       *aTheLibs,
                   TInt                   aLibCount)
	{
	TInt				dllIndex = 0;
	
	for (dllIndex = 0; dllIndex < aLibCount; dllIndex ++)
		{
		aTheLibs[dllIndex].CloseLibrary();
		}
	memset(aTheLibs, 0, sizeof(*aTheLibs) * aLibCount);
	}

//
// RunThreadForward
//
// Walk through the function pointer array (forwards) calling each function
//

TInt RunThreadForward(TInt				     aThreadIndex, 
					  PageLdrRLibrary		*aTheLibs,
					  TInt					 aMaxDllIndex,
					  RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
					  TMessageBuf			*aBuffer = NULL, 
					  RSemaphore			*aTheSem = NULL)
	{
	TInt				seed = 1;
	TUint32				index = 0;
	RThread				thisThread;
	PageLdrRLibrary    *pTheLibs = NULL;
	TInt				dllIndex = 0;

	if (TestLoadDllHow == TEST_DLL_FUNC)
		{
		DOLOADALLOC(aMaxDllIndex, pTheLibs, aTheSem);
		if (pTheLibs)
			{
			TInt retVal = LoadTheLibs(pTheLibs, aMaxDllIndex, aThreadIndex, aMsgQueue, aBuffer, aTheSem);
			if (retVal != KErrNone)
				{
				DEBUG_PRINT((_L("Forward[%d] - load fail\n"), aThreadIndex));
				CloseTheLibs (pTheLibs, aMaxDllIndex);
				User::Free(pTheLibs);
				return retVal;
				}
			}
		else
			{
			DEBUG_PRINT((_L("Forward[%d] - alloc fail\n"), aThreadIndex));
			return KErrGeneral;
			}
		}
	else
		{
		pTheLibs = aTheLibs;
		}
	
	for (dllIndex = 0; dllIndex < aMaxDllIndex; dllIndex ++)
		{
		index = 0;
		while (index < pTheLibs[dllIndex].iFuncCount)
			{
			if (TestPrioChange)
				{
				TThreadPriority originalThreadPriority = thisThread.Priority();
				thisThread.SetPriority(EPriorityLess);
				User::AfterHighRes(0);
				thisThread.SetPriority(originalThreadPriority);
				}
			if (pTheLibs[dllIndex].iCallFunctionFunc)
				seed = pTheLibs[dllIndex].iCallFunctionFunc(index, seed, index);
			else
				DEBUG_PRINT((_L("Forward[%d] : dll %d was NULL\n"), aThreadIndex, dllIndex));
			index ++;
			if (TestThreadsExit)
				break;
			}
		if (TestThreadsExit)
			break;
		}
	if (TestLoadDllHow == TEST_DLL_FUNC)
		{
		CloseTheLibs(pTheLibs, aMaxDllIndex);
		User::Free(pTheLibs);
		}
	return KErrNone;
	}

//
// RunThreadBackward
//
// Walk through the function pointer array (backwards) calling each function
//

TInt RunThreadBackward(TInt				      aThreadIndex, 
					   PageLdrRLibrary		 *aTheLibs,
					   TInt					  aMaxDllIndex,
					   RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
					   TMessageBuf			 *aBuffer = NULL,
					   RSemaphore			 *aTheSem = NULL)
	{
	TInt				seed = 1;
	TUint32				index = 0;
	RThread				thisThread;
	PageLdrRLibrary    *pTheLibs = NULL;
	TInt				dllIndex = 0;

	if (TestLoadDllHow == TEST_DLL_FUNC)
		{
		DOLOADALLOC(aMaxDllIndex, pTheLibs, aTheSem);
		if (pTheLibs)
			{
			TInt retVal = LoadTheLibs(pTheLibs, aMaxDllIndex, aThreadIndex, aMsgQueue, aBuffer, aTheSem);
			if (retVal != KErrNone)
				{
				DEBUG_PRINT((_L("Backward[%d] - load fail\n"), aThreadIndex));
				CloseTheLibs (pTheLibs, aMaxDllIndex);
				User::Free(pTheLibs);
				return retVal;
				}
			}
		else
			{
			DEBUG_PRINT((_L("Backward[%d] - alloc fail\n"), aThreadIndex));
			return KErrGeneral;
			}
		}	
	else
		{
		pTheLibs = aTheLibs;
		}

	for (dllIndex = aMaxDllIndex - 1; dllIndex >= 0; dllIndex --)
		{
		index = pTheLibs[dllIndex].iFuncCount;
		while (index > 0)
			{
			if (TestPrioChange)
				{
				TThreadPriority originalThreadPriority = thisThread.Priority();
				thisThread.SetPriority(EPriorityLess);
				User::AfterHighRes(0);
				thisThread.SetPriority(originalThreadPriority);
				}
			if (pTheLibs[dllIndex].iCallFunctionFunc)
				seed = pTheLibs[dllIndex].iCallFunctionFunc(index, seed, index);
			else
				DEBUG_PRINT((_L("Backward[%d] : dll %d was NULL\n"), aThreadIndex, dllIndex));
			index --;
			if (TestThreadsExit)
				break;
			}
		if (TestThreadsExit)
			break;
		}
	if (TestLoadDllHow == TEST_DLL_FUNC)
		{
		CloseTheLibs(pTheLibs, aMaxDllIndex);
		User::Free(pTheLibs);
		}
	return KErrNone;
	}

//
// RunThreadRandom
//
// Walk through the function pointer array in a random order a number of times calling each function
//

TInt RunThreadRandom(TInt				    aThreadIndex, 
					 PageLdrRLibrary	   *aTheLibs,
					 TInt				    aMaxDllIndex,
					 RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
					 TMessageBuf		   *aBuffer = NULL,
					 RSemaphore			   *aTheSem = NULL)
	{
	TInt				seed = 1;
	TUint				randNum;
	RThread				thisThread;
	PageLdrRLibrary    *pTheLibs = NULL;
	TUint				dllIndex = 0;
	
	if (TestLoadDllHow == TEST_DLL_FUNC)
		{
		DOLOADALLOC(aMaxDllIndex, pTheLibs, aTheSem);
		if (pTheLibs)
			{
			TInt retVal = LoadTheLibs(pTheLibs, aMaxDllIndex, aThreadIndex, aMsgQueue, aBuffer, aTheSem);
			if (retVal != KErrNone)
				{
				DEBUG_PRINT((_L("Random[%d] - load fail\n"), aThreadIndex));
				CloseTheLibs (pTheLibs, aMaxDllIndex);
				User::Free(pTheLibs);
				return retVal;
				}
			}
		else
			{
			DEBUG_PRINT((_L("Random[%d] - alloc fail\n"), aThreadIndex));
			return KErrGeneral;
			}
		}
	else
		{
		pTheLibs = aTheLibs;
		}

	
	TUint funcCount = (TUint)pTheLibs[0].iFuncCount;
	TInt iterCount = aMaxDllIndex * funcCount;
	
	// reduce the time for auto tests by reducing the number of cycles.
	if (TestIsAutomated)
		iterCount /= 4;

	while (iterCount > 0)
		{
		if (TestPrioChange)
			{
			TThreadPriority originalThreadPriority = thisThread.Priority();
			thisThread.SetPriority(EPriorityLess);
			User::AfterHighRes(0);
			thisThread.SetPriority(originalThreadPriority);
			}
		
		randNum = (TUint)Math::Random();
		dllIndex = randNum % (TUint)aMaxDllIndex;

		randNum %= funcCount;

		if (   (randNum < funcCount)
		    && ((TInt)dllIndex < aMaxDllIndex))
			{
			if (pTheLibs[dllIndex].iCallFunctionFunc)
				{
				seed = pTheLibs[dllIndex].iCallFunctionFunc(randNum, seed, randNum);
				}
			else
				DEBUG_PRINT((_L("Random[%d] : dll %d was NULL\n"), aThreadIndex, dllIndex));
			}
		else
			{
			DEBUG_PRINT((_L("Random[%d] : %d ERROR dllIndex %u rand %u\n"), aThreadIndex, iterCount, dllIndex, randNum));
			}
		
		--iterCount;
		if (TestThreadsExit)
			break;
		}

	if (TestLoadDllHow == TEST_DLL_FUNC)
		{
		CloseTheLibs(pTheLibs, aMaxDllIndex);
		User::Free(pTheLibs);
		}
	return KErrNone;
	}


//
// ThrashThreadLoad
//
// Load and unload the DLLs rapidly to show up a timing window in the kernel.
//

TInt ThrashThreadLoad (TInt				      aThreadIndex, 
					   PageLdrRLibrary		 *aTheLibs,
					   TInt					  aMaxDllIndex,
					   RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
					   TMessageBuf			 *aBuffer = NULL,
					   RSemaphore			 *aTheSem = NULL)
	{
	if (TestLoadDllHow == TEST_DLL_FUNC)
		{
		PageLdrRLibrary    *pTheLibs = NULL;
		DOLOADALLOC(aMaxDllIndex, pTheLibs, aTheSem);
		if (pTheLibs)
			{
			TInt retVal = LoadTheLibs(pTheLibs, aMaxDllIndex, aThreadIndex, aMsgQueue, aBuffer, aTheSem);
			if (retVal != KErrNone)
				{
				DEBUG_PRINT((_L("Thrash[%d] - load fail\n"), aThreadIndex));
				CloseTheLibs (pTheLibs, aMaxDllIndex);
				User::Free(pTheLibs);
				return retVal;
				}
			}
		else
			{
			DEBUG_PRINT((_L("Thrash[%d] - alloc fail\n"), aThreadIndex));
			return KErrGeneral;
			}

		CloseTheLibs(pTheLibs, aMaxDllIndex);
		User::Free(pTheLibs);
		}
	return KErrNone;
	}


//
// PerformTestThread
//
// This is the function that actually does the work.
// It is complicated a little because test.Printf can only be called from the first thread that calls it 
// so if we are using multiple threads we need to use a message queue to pass the debug info from the
// child threads back to the parent for the parent to then call printf.
//
//

LOCAL_C TInt PerformTestThread(TInt					  aThreadIndex, 
							   RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 
							   TMessageBuf			 *aBuffer = NULL,
							   RSemaphore			 *aTheSem = NULL)
	{
	TUint start = User::TickCount();

	TFullName n(RThread().Name());

	DEBUG_PRINT((_L("%S : thread %d Executing %S\n"), &TestNameBuffer, aThreadIndex, &n));
	
	// now select how we do the test...
	TInt	iterIndex;

	PageLdrRLibrary    *pTheLibs = theGlobalLibs;
	TInt				maxDllIndex = GetNumDlls();

	switch (TestLoadDllHow)
		{
		case TEST_DLL_THREAD:
			pTheLibs = NULL;
			DOLOADALLOC(maxDllIndex, pTheLibs, aTheSem);
			if (pTheLibs)
				{
				TInt retVal = LoadTheLibs(pTheLibs, maxDllIndex, aThreadIndex, aMsgQueue, aBuffer, aTheSem);
				if (retVal != KErrNone)
					{
					DEBUG_PRINT((_L("Perform[%d] - load fail\n"), aThreadIndex));
					CloseTheLibs (pTheLibs, maxDllIndex);
					User::Free(pTheLibs);
					return retVal;
					}
				}
			else
				{
				DEBUG_PRINT((_L("Perform[%d] - alloc fail\n"), aThreadIndex));
				return KErrGeneral;
				}
		break;

		case TEST_DLL_GLOBAL:
			pTheLibs = theGlobalLibs;
		break;

		case TEST_DLL_FUNC:
		default:
		// do nowt
		break;
		}

	TInt    retVal = KErrNone;
	if (TEST_ALL == (TestWhichTests & TEST_ALL))
		{
		#define LOCAL_ORDER_INDEX1	6
		#define LOCAL_ORDER_INDEX2	3
		TInt	order[LOCAL_ORDER_INDEX1][LOCAL_ORDER_INDEX2] = {	{TEST_FORWARD, TEST_BACKWARD,TEST_RANDOM},
																	{TEST_FORWARD, TEST_RANDOM,  TEST_BACKWARD},
																	{TEST_BACKWARD,TEST_FORWARD, TEST_RANDOM},
																	{TEST_BACKWARD,TEST_RANDOM,  TEST_FORWARD},
																	{TEST_RANDOM,  TEST_FORWARD, TEST_BACKWARD},
																	{TEST_RANDOM,  TEST_BACKWARD,TEST_FORWARD}};
		TInt	whichOrder = 0;

		for (iterIndex = 0; ; )
			{
			TInt    selOrder = ((aThreadIndex + 1) * (iterIndex + 1)) % LOCAL_ORDER_INDEX1;
			for (whichOrder = 0; whichOrder < LOCAL_ORDER_INDEX2; whichOrder ++)
				{
				switch (order[selOrder][whichOrder])
					{
						case TEST_FORWARD:
						DEBUG_PRINT((_L("%S : %d Iter %d.%d Forward\n"),
							&TestNameBuffer, aThreadIndex, iterIndex, whichOrder));
						retVal = RunThreadForward(aThreadIndex, pTheLibs, maxDllIndex, aMsgQueue, aBuffer, aTheSem);
						break;

						case TEST_BACKWARD:
						DEBUG_PRINT((_L("%S : %d Iter %d.%d Backward\n"),
							&TestNameBuffer, aThreadIndex, iterIndex, whichOrder));
						retVal = RunThreadBackward(aThreadIndex, pTheLibs, maxDllIndex, aMsgQueue, aBuffer, aTheSem);
						break;

						case TEST_RANDOM:
						DEBUG_PRINT((_L("%S : %d Iter %d.%d Random\n"),
							&TestNameBuffer, aThreadIndex, iterIndex, whichOrder));
						retVal = RunThreadRandom(aThreadIndex, pTheLibs, maxDllIndex, aMsgQueue, aBuffer, aTheSem);
						break;
						
						default: // this is really an error.
						break;
					}
				DEBUG_PRINT((_L("%S : %d Iter %d.%d finished %d\n"),
					&TestNameBuffer, aThreadIndex, iterIndex, whichOrder, retVal));
				if ((retVal == KErrCancel) && iterIndex > 0)
					retVal = KErrNone;
				if ((retVal != KErrNone) || TestThreadsExit)
					break;
				}
			if ((retVal != KErrNone) || TestThreadsExit)
				break;
			if (++iterIndex >= TestMaxLoops)
				break;
			User::AfterHighRes(TEST_DOT_PERIOD/3*1000000);
			}
		}
	else
		{
		if (TestWhichTests & TEST_FORWARD)
			{
			for (iterIndex = 0; ; )
				{
				DEBUG_PRINT((_L("%S : %d Iter %d Forward\n"), &TestNameBuffer, aThreadIndex, iterIndex));
				retVal = RunThreadForward(aThreadIndex, pTheLibs, maxDllIndex, aMsgQueue, aBuffer, aTheSem);
				DEBUG_PRINT((_L("%S : %d Iter %d finished %d\n"), &TestNameBuffer, aThreadIndex, iterIndex, retVal));
				if ((retVal == KErrCancel) && iterIndex > 0)
					retVal = KErrNone;
				if ((retVal != KErrNone) || TestThreadsExit)
					break;
				if (++iterIndex >= TestMaxLoops)
					break;
				User::AfterHighRes(TEST_DOT_PERIOD/3*1000000);
				}
			}
			
		if (TestWhichTests & TEST_BACKWARD)
			{
			for (iterIndex = 0; ; )
				{
				DEBUG_PRINT((_L("%S : %d Iter %d Backward\n"), &TestNameBuffer, aThreadIndex, iterIndex));
				retVal = RunThreadBackward(aThreadIndex, pTheLibs, maxDllIndex, aMsgQueue, aBuffer, aTheSem);
				DEBUG_PRINT((_L("%S : %d Iter %d finished %d\n"), &TestNameBuffer, aThreadIndex, iterIndex, retVal));
				if ((retVal == KErrCancel) && iterIndex > 0)
					retVal = KErrNone;
				if ((retVal != KErrNone) || TestThreadsExit)
					break;
				if (++iterIndex >= TestMaxLoops)
					break;
				User::AfterHighRes(TEST_DOT_PERIOD/3*1000000);
				}
			}

		if (TestWhichTests & TEST_RANDOM)
			{
			for (iterIndex = 0; ; )
				{
				DEBUG_PRINT((_L("%S : %d Iter %d Random\n"), &TestNameBuffer, aThreadIndex, iterIndex));
				retVal = RunThreadRandom(aThreadIndex, pTheLibs, maxDllIndex, aMsgQueue, aBuffer, aTheSem);
				DEBUG_PRINT((_L("%S : %d Iter %d finished %d\n"), &TestNameBuffer, aThreadIndex, iterIndex, retVal));
				if ((retVal == KErrCancel) && iterIndex > 0)
					retVal = KErrNone;
				if ((retVal != KErrNone) || TestThreadsExit)
					break;
				if (++iterIndex >= TestMaxLoops)
					break;
				User::AfterHighRes(TEST_DOT_PERIOD/3*1000000);
				}
			}
		
		if (TestWhichTests & TEST_THRASH)
			{
			for (iterIndex = 0; ; )
				{
				DEBUG_PRINT((_L("%S : %d Iter %d Thrash Load\n"), &TestNameBuffer, aThreadIndex, iterIndex));
				retVal = ThrashThreadLoad(aThreadIndex, pTheLibs, maxDllIndex, aMsgQueue, aBuffer, aTheSem);
				DEBUG_PRINT((_L("%S : %d Iter %d finished %d\n"), &TestNameBuffer, aThreadIndex, iterIndex, retVal));
				if ((retVal == KErrCancel) && iterIndex > 0)
					retVal = KErrNone;
				if ((retVal != KErrNone) || TestThreadsExit)
					break;
				if (++iterIndex >= TestMaxLoops)
					break;
				User::AfterHighRes(TEST_DOT_PERIOD/3*1000000);
				}
			}
		}

	if (TestLoadDllHow == TEST_DLL_THREAD)
		{
		CloseTheLibs(pTheLibs, maxDllIndex);
		User::Free(pTheLibs);
		}

	DEBUG_PRINT((_L("%S : thread %d Exit (tick %u)\n"), &TestNameBuffer, aThreadIndex, User::TickCount() - start));
	return retVal;
	}


//
// MultipleTestThread
//
// Thread function, one created for each thread in a multiple thread test.
//

LOCAL_C TInt MultipleTestThread(TAny* aUseTb)
	{
	TInt			ret;
	TMessageBuf		localBuffer;

	if (TestInterleave)	
		{
		RThread				thisThread;
		thisThread.SetPriority((TThreadPriority) TEST_INTERLEAVE_PRIO);
		}

	ret = PerformTestThread((TInt) aUseTb, &TestMsgQueue, &localBuffer, &TestMultiSem);
	if (!TestingChunks)
		{
		if (ret != KErrNone) 
			User::Panic(_L("LOAD"), KErrGeneral);
		}
	return KErrNone;
	}

//
// StartExe
//
// Start an executable.
//

TInt StartExe(RProcess& aTheProcesses, TRequestStatus* aPrStatus, TInt aIndex, TBool aLoadSelf, TBool aLowMem, RSemaphore *pTheSem = NULL)
	{
	TBuf<256>		buffer;
	TInt			testWhich = KTestMediaRom;
	//y_LIT(KTestDebug, "debug");
	_LIT(KTestSilent, "silent");

	if ((TestWhichMedia & TEST_MEDIA_ALL) == TEST_MEDIA_ALL)
		testWhich = aIndex % KTestMediaCOUNT;
	else if ((TestWhichMedia & TEST_MEDIA_ALL) == TEST_MEDIA_ROM_BASE)
		testWhich = (aIndex & 1) ? KTestMediaBase : KTestMediaRom;
	else if (TestWhichMedia & TEST_MEDIA_BASE )
		testWhich = KTestMediaBase;
	else
		testWhich = KTestMediaRom;

	if (!TestDllExesExist[testWhich])
		testWhich = KTestMediaBase;

	buffer.Zero();
	TInt ret;
	if (aLoadSelf)
		{
		buffer.Format(_L("single random dll %S iters %d inst %d"),
			/* TestDebug ? &KTestDebug : */ &KTestSilent, TestMaxLoops, aIndex);
		if (TestExtremeChunks)
			buffer.Append(_L(" echunks"));
		else if (TestChunksPlus)
			buffer.Append(_L(" chunks prio"));
		if (TestChunkData == EFalse)
			buffer.Append(_L(" nochunkdata"));
		DBGS_PRINT((_L("%S : Starting Process %d %S %S\n"),
			&TestNameBuffer, aIndex, &TestPlExeNames[testWhich], &buffer));
		DOTEST1(ret,aTheProcesses.Create(TestPlExeNames[testWhich],buffer),KErrNone, KErrNoMemory);
		}
	else
		{
		buffer.Format(_L("single random %S iters %d inst %d"),
			/* TestDebug ? &KTestDebug : */ &KTestSilent, TestMaxLoops, aIndex);
		DBGS_PRINT((_L("%S : Starting Process %d %S %S\n"),
			&TestNameBuffer, aIndex, &TestPsExeNames[testWhich], &buffer));
		DOTEST1(ret,aTheProcesses.Create(TestPsExeNames[testWhich],buffer),KErrNone, KErrNoMemory);
		}
	if (ret == KErrNone)
		{
		if(aPrStatus)
			{
			aTheProcesses.Logon(*aPrStatus);
			RUNTEST1(*aPrStatus == KRequestPending);	
			}
		aTheProcesses.Resume();
		}
	return ret;
	}

//
// PerformRomAndFileSystemAccessThread
// 
// Access the rom and dump it out to one of the writeable partitions...
// really just to make the media server a little busy during the test.
//
TInt PerformRomAndFileSystemAccessThread(TInt					aThreadId,
										 RMsgQueue<TMessageBuf> *aMsgQueue, 
										 TMessageBuf		   *aBuffer,
										 RSemaphore			   *aTheSem,
										 TBool					aLowMem)
	{
	RThread		 thisThread;
	TUint		 maxBytes = KMaxTUint;
	TInt		 startTime = User::TickCount();
	RSemaphore	*pTheSem = aTheSem;
	RFs fs;
	RFile file;

	if (KErrNone != fs.Connect())
		{
		DEBUG_PRINT(_L("PerformRomAndFileSystemAccessThread : Can't connect to the FS\n"));
		return KErrGeneral;
		}

	// get info about the ROM...
	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();
	TUint8* start;
	TUint8* end;
	if(romHeader->iPageableRomStart)
		{
		start = (TUint8*)romHeader + romHeader->iPageableRomStart;
		end = start + romHeader->iPageableRomSize;
		}
	else
		{
		start = (TUint8*)romHeader;
		end = start + romHeader->iUncompressedSize;
		}
	if (end <= start)
		return KErrGeneral;

	// read all ROM pages in a random order...and write out to file in ROFs
	TInt pageSize = 0;
	UserSvr::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&pageSize,0);

	TUint size = end - start - pageSize;
	if(size > maxBytes)
		size = maxBytes;

	TUint32 random = 1 + aThreadId;
	TPtrC8  sourceData;
	TUint8* theAddr;
	HBufC8* checkData;

	DOTEST((checkData = HBufC8::New(pageSize + 10)),
	       (checkData != NULL));
	
	if (!checkData)
		{
		DEBUG_PRINT((_L("RomAndFSThread %S : failed to alloc read buffer\n"), &TestNameBuffer));
		}

	TInt		drvNum = (TestBootedFromMmc || TestOnlyFromMmc) ? FindMMCDriveNumber(fs) : FindFsNANDDrive(fs);
	TBuf<32>	filename;
	
	filename.Format(_L("?:\\Pageldrtst%d.tmp"), aThreadId);
	if (drvNum >= 0)
		{
		DEBUG_PRINT((_L("%S : Filename %S\n"), &TestNameBuffer, &filename));
		}
	else
		{
		DEBUG_PRINT((_L("RomAndFSThread : error getting drive num\n")));
		drvNum = 3; //make it 'd' by default.
		}
	filename[0] = 'a' + drvNum;

#ifdef WANT_FS_CACHE_STATS 
	TInt allocatedSegmentCount = 0;
	TInt filesOnClosedQueue = 0;
#endif
	TInt ret;
	while(1)
		{
		for(TInt i = size / (pageSize); i>0; --i)
			{
			DEBUG_PRINT1((_L("%S : Opening the file\n"), &TestNameBuffer));
			DOTEST((ret = file.Replace(fs, filename, EFileWrite)),
				   (KErrNone == ret));

			random = random * 69069 + 1;
			theAddr = (TUint8 *)(start + ((TInt64(random) * TInt64(size - pageSize)) >> 32));
			sourceData.Set(theAddr,pageSize);
			DEBUG_PRINT1((_L("%S : Writing the file\n"), &TestNameBuffer));
			ret = file.Write(sourceData);
			if (ret != KErrNone)
				{
				DEBUG_PRINT((_L("%S : Write returned error %d\n"), &TestNameBuffer, ret));
				}
			DEBUG_PRINT1((_L("%S : Closing the file\n"), &TestNameBuffer));
			file.Close();
			
			if (checkData)
				{
				TPtr8  theBuf = checkData->Des();

#ifdef WANT_FS_CACHE_STATS 
				// Page cache
				TFileCacheStats stats1;
				TFileCacheStats stats2;
				ret = controlIo(fs,drvNum, KControlIoFileCacheStats, stats1);
				if ((ret != KErrNone) && (ret != KErrNotSupported))
					{
					DEBUG_PRINT((_L("%S : KControlIoFileCacheStats 1 failed %d\n"), &TestNameBuffer, ret));
					}

				if (aThreadId & 1)
					{
					// flush closed files queue
					ret = fs.ControlIo(drvNum, KControlIoFlushClosedFiles);
					if (ret != KErrNone)
						{
						DEBUG_PRINT((_L("%S : KControlIoFlushClosedFiles failed %d\n"), &TestNameBuffer, ret));
						}
					}
				else
#endif //WANT_FS_CACHE_STATS 
					{
					// rename file to make sure it has cleared the cache.				
					TBuf<32>	newname;
					newname.Format(_L("d:\\Pageldrtst%d.temp"), aThreadId);
					if (drvNum >= 0)
						{
						newname[0] = 'a' + drvNum;
						}
					fs.Rename(filename, newname);
					filename = newname;
					}
#ifdef WANT_FS_CACHE_STATS 
				ret = controlIo(fs,drvNum, KControlIoFileCacheStats, stats2);
				if (ret != KErrNone && ret != KErrNotSupported)
					{
					DEBUG_PRINT((_L("%S : KControlIoFileCacheStats2 failed %d\n"), &TestNameBuffer, ret));
					}

				allocatedSegmentCount = (allocatedSegmentCount > stats1.iAllocatedSegmentCount) ? allocatedSegmentCount : stats1.iAllocatedSegmentCount;
				filesOnClosedQueue = (filesOnClosedQueue > stats1.iFilesOnClosedQueue) ? filesOnClosedQueue : stats1.iFilesOnClosedQueue;
#endif //WANT_FS_CACHE_STATS 

				DOTEST((ret = file.Open(fs, filename, EFileRead)),
					   (KErrNone == ret));
				// now read back the page that we wrote and compare with the source.
				ret = file.Read(0, theBuf, pageSize);
				if (ret == KErrNone)
					{		
					ret = sourceData.Compare(theBuf);
					if (ret != 0)
						{
						DEBUG_PRINT((_L("%S : read compare error %d\n"), &TestNameBuffer, ret));
						}
					}
				else
					{
					DEBUG_PRINT((_L("%S : failed read compare, error %d\n"), &TestNameBuffer, ret));
					}
				file.Close();
				}
			DEBUG_PRINT1((_L("%S : Deleting the file\n"), &TestNameBuffer));
			ret = fs.Delete(filename);
			if (KErrNone != ret)
				{
				DEBUG_PRINT((_L("%S [%d] Delete %S Failed %d!\n"), &TestNameBuffer, aThreadId, &filename, ret));
				}
		
			if (TestPrioChange)
				{
				TThreadPriority originalThreadPriority = thisThread.Priority();
				DEBUG_PRINT1((_L("%S [%d] media thread before priority change, stop = %d\n"), &TestNameBuffer, aThreadId, TestStopMedia));
				thisThread.SetPriority(EPriorityLess);
				User::AfterHighRes(0);
				thisThread.SetPriority(originalThreadPriority);
				DEBUG_PRINT1((_L("%S [%d] media thread after priority change, stop = %d\n"), &TestNameBuffer, aThreadId, TestStopMedia));
				}
			if (TestStopMedia)
				break;
			}
		if (TestStopMedia)
			break;
		}

#ifdef WANT_FS_CACHE_STATS 
	DEBUG_PRINT((_L("%S : [%d] allocPageCount %d filesClosedQueue %d \n"),&TestNameBuffer, aThreadId,allocatedSegmentCount,filesOnClosedQueue));
#endif //WANT_FS_CACHE_STATS 

	if (checkData)
		{
		delete checkData;
		}
	fs.Close();
	DEBUG_PRINT1((_L("Done in %d ticks\n"), User::TickCount() - startTime));
	return KErrNone;
	}

//
// PerformFileSystemAccessThread
// 
// Access the rom and dump it out to one of the writeable partitions...
// really just to make the media server a little busy during the test.
//
TInt PerformFileSystemAccessThread(TInt					    aThreadId,
								   RMsgQueue<TMessageBuf>   *aMsgQueue, 
								   TMessageBuf	           *aBuffer,
								   RSemaphore			   *aTheSem,
								   TBool					aLowMem)
	{
	RThread		 thisThread;
	TInt		 startTime = User::TickCount();
	RSemaphore	*pTheSem = aTheSem;
	RFs			 fs;
	RFile		 file;
	if (KErrNone != fs.Connect())
		{
		DEBUG_PRINT(_L("PerformFileSystemAccessThread : Can't connect to the FS\n"));
		return KErrGeneral;
		}

	// read all ROM pages in a random order...and write out to file in ROFs
	TInt pageSize = 0;
	UserSvr::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&pageSize,0);

	HBufC8* checkData;
	HBufC8* sourceData;
	TUint32 random = 1 + aThreadId;
	TInt	dataSize = pageSize + (pageSize / 2);
	
	DOTEST((sourceData = HBufC8::New(dataSize)),
	       (sourceData != NULL));
	if (!sourceData)
		{
		DEBUG_PRINT((_L("RomAndFSThread %S : failed to alloc read buffer\n"), &TestNameBuffer));
		fs.Close();
		return KErrGeneral;
		}

	DOTEST((checkData = HBufC8::New(dataSize)),
	       (checkData != NULL));
	if (!checkData)
		{
		DEBUG_PRINT((_L("RomAndFSThread %S : failed to alloc read buffer\n"), &TestNameBuffer));
		}

	TInt		drvNum = (TestBootedFromMmc || TestOnlyFromMmc) ? FindMMCDriveNumber(fs) : FindFsNANDDrive(fs);
	TBuf<32>	filename;
	
	if (drvNum < 0)
		{
		drvNum = 3; //make it 'd' by default.
		DEBUG_PRINT((_L("FSAccessThread : error getting drive num\n")));
		}

#ifdef WANT_FS_CACHE_STATS 
	TInt allocatedSegmentCount = 0;
	TInt filesOnClosedQueue = 0;
#endif
	TInt fileIndex;
	TInt ret;

	TPtr8  pBuf = sourceData->Des();
	
	while (1)
		{
		TUint32 randomStart = random;
		// write the file
		for (fileIndex = 0; fileIndex < TEST_NUM_FILES; fileIndex ++)
			{
			filename.Format(_L("%c:\\pldrtst%d_%d.tmp"), 'a' + drvNum, aThreadId, fileIndex);

			DEBUG_PRINT1((_L("%S : Opening the file\n"), &TestNameBuffer));

			DOTEST ((ret = file.Replace(fs, filename, EFileWrite)),
				   (KErrNone == ret));

			pBuf.Zero();			
			if (fileIndex & 1)
				{
				TInt fillSize = dataSize / sizeof(TUint32);
				while (fillSize > 0)
					{
					random = random * 69069 + 1;
					pBuf.Append((const TUint8 *) &random, sizeof(random));
					fillSize --;
					}
				}
			else
				{
				pBuf.Fill('x',dataSize);
				}
		

			DEBUG_PRINT1((_L("%S : Writing the file\n"), &TestNameBuffer));
			ret = file.Write(sourceData->Des());
			if (ret != KErrNone)
				{
				DEBUG_PRINT((_L("%S : Write returned error %d\n"), &TestNameBuffer, ret));
				}
			DEBUG_PRINT1((_L("%S : Closing the file\n"), &TestNameBuffer));
			file.Close();
			}

		random = randomStart;
		// check the file
		for (fileIndex = 0; fileIndex < TEST_NUM_FILES; fileIndex ++)
			{
			filename.Format(_L("%c:\\pldrtst%d_%d.tmp"), 'a' + drvNum, aThreadId, fileIndex);
			
			if (checkData)
				{
				TPtr8  theBuf = checkData->Des();

#ifdef WANT_FS_CACHE_STATS 
				// Page cache
				TFileCacheStats stats1;
				TFileCacheStats stats2;
				ret = controlIo(fs,drvNum, KControlIoFileCacheStats, stats1);
				if ((ret != KErrNone) && (ret != KErrNotSupported))
					{
					DEBUG_PRINT((_L("%S : KControlIoFileCacheStats 1 failed %d\n"), &TestNameBuffer, ret));
					}

				if (aThreadId & 1)
					{
					// flush closed files queue
					ret = fs.ControlIo(drvNum, KControlIoFlushClosedFiles);
					if (ret != KErrNone)
						{
						DEBUG_PRINT((_L("%S : KControlIoFlushClosedFiles failed %d\n"), &TestNameBuffer, ret));
						}
					}
				else
#endif //WANT_FS_CACHE_STATS 
					{
					// rename file to make sure it has cleared the cache.				
					TBuf<32>	newname;
					newname.Format(_L("%c:\\pldrtst%d_%d.temp"), 'a' + drvNum, aThreadId, fileIndex);
					fs.Rename(filename, newname);
					filename = newname;
					}
#ifdef WANT_FS_CACHE_STATS 
				ret = controlIo(fs,drvNum, KControlIoFileCacheStats, stats2);
				if (ret != KErrNone && ret != KErrNotSupported)
					{
					DEBUG_PRINT((_L("%S : KControlIoFileCacheStats2 failed %d\n"), &TestNameBuffer, ret));
					}
				allocatedSegmentCount = (allocatedSegmentCount > stats1.iAllocatedSegmentCount) ? allocatedSegmentCount : stats1.iAllocatedSegmentCount;
				filesOnClosedQueue = (filesOnClosedQueue > stats1.iFilesOnClosedQueue) ? filesOnClosedQueue : stats1.iFilesOnClosedQueue;
#endif //WANT_FS_CACHE_STATS 

				DOTEST((ret = file.Open(fs, filename, EFileRead)),
					   (KErrNone == ret));
				// now read back the page that we wrote and compare with the source.
				ret = file.Read(0, theBuf, dataSize);
				if (ret == KErrNone)
					{
					pBuf.Zero();			
					if (fileIndex & 1)
						{
						TInt fillSize = dataSize / sizeof(TUint32);
						while (fillSize > 0)
							{
							random = random * 69069 + 1;
							pBuf.Append((const TUint8 *) &random, sizeof(random));
							fillSize --;
							}
						}
					else
						{
						pBuf.Fill('x',dataSize);
						}

					ret = sourceData->Des().Compare(theBuf);
					if (ret != 0)
						{
						DEBUG_PRINT((_L("%S :compare error %S %d\n"), &TestNameBuffer, &filename, ret));
						}
					}
				else
					{
					DEBUG_PRINT((_L("%S : failed read compare, error %d\n"), &TestNameBuffer, ret));
					}
				file.Close();
				}
			DEBUG_PRINT1((_L("%S : Deleting the file\n"), &TestNameBuffer));
			ret = fs.Delete(filename);
			if (KErrNone != ret)
				{
				DEBUG_PRINT((_L("%S [%d] Delete %S Failed %d!\n"), &TestNameBuffer, aThreadId, &filename, ret));
				}
			if (TestPrioChange)
				{
				TThreadPriority originalThreadPriority = thisThread.Priority();
				thisThread.SetPriority(EPriorityLess);
				User::AfterHighRes(0);
				thisThread.SetPriority(originalThreadPriority);
				}
			if (TestStopMedia)
				break;
			}
		if (TestStopMedia)
			break;
		}
#ifdef WANT_FS_CACHE_STATS 
	DEBUG_PRINT((_L("%S : [%d] allocPageCount %d filesClosedQueue %d \n"),&TestNameBuffer, aThreadId,allocatedSegmentCount,filesOnClosedQueue));
#endif //WANT_FS_CACHE_STATS 

	if (checkData)
		{
		delete checkData;
		}
	delete sourceData;
	fs.Close();
	DEBUG_PRINT1((_L("Done in %d ticks\n"), User::TickCount() - startTime));
	return KErrNone;
	}

//
// PerformRomAndFileSystemAccess
//
// Thread function, kicks off the file system access.
//

LOCAL_C TInt PerformRomAndFileSystemAccess(TAny* aParam)
	{
	TMessageBuf			localBuffer;
	TInt				threadId = (TInt) aParam;
	TInt				retVal = KErrGeneral;

	if (TestInterleave)	
		{
		RThread				thisThread;
		thisThread.SetPriority((TThreadPriority) TEST_INTERLEAVE_PRIO);
		}

	switch (TestMediaAccess)
		{
		default:
		break;
		
		case KTestMediaAccessBasic:
		case KTestMediaAccessMultipleThreads:
			retVal = PerformRomAndFileSystemAccessThread(threadId, &TestMsgQueue, &localBuffer, &TestMultiSem, TestingLowMem);	
		break;
				
		case KTestMediaAccessMultiplePattern:
			retVal = PerformFileSystemAccessThread(threadId, &TestMsgQueue, &localBuffer, &TestMultiSem, TestingLowMem);
		break;

		case KTestMediaAccessMixed:
			if (threadId < ((TestMultipleThreadCount + 1) / 2))
				retVal = PerformRomAndFileSystemAccessThread(threadId, &TestMsgQueue, &localBuffer, &TestMultiSem, TestingLowMem);	
			else
				retVal = PerformFileSystemAccessThread(threadId, &TestMsgQueue, &localBuffer, &TestMultiSem, TestingLowMem);
		break;
		}
	return retVal;
	}


//
// DisplayTestBanner
// 
// Output a header showing the test parameters.
//

void DisplayTestBanner(TBool aMultiple)
	{
	DBGS_PRINT((_L("%S : what = %S%S%S(0x%x), media = %S%S%S(0x%x)\n"),
				aMultiple ? &KMultipleTest : &KSingleTest,
				TestLoading & TEST_EXE ? &KTestExe : &KTestBlank,
 				TestLoading & TEST_DLL ? &KTestDll : &KTestBlank,
 				TestLoading & TEST_SELF ? &KTestSelf : &KTestBlank,
				TestLoading,
				TestWhichMedia & TEST_MEDIA_BASE ? &KTestBase : &KTestBlank,
				TestWhichMedia & TEST_MEDIA_ROM ? &KTestRom : &KTestBlank,
				(TestWhichMedia & TEST_MEDIA_ALL) == TEST_MEDIA_ALL ? &KTestAll : &KTestBlank,
				TestWhichMedia));
	DBGS_PRINT((_L("         : maxLoops = %d, threads = %d, loadHow = %S (0x%x)\n"),
				TestMaxLoops,
				TestMultipleThreadCount,
				TestLoadDllHow == TEST_DLL_GLOBAL ? &KTestGlobal : TestLoadDllHow == TEST_DLL_THREAD ? &KTestThread : &KTestFunc, TestLoadDllHow));
	DBGS_PRINT((_L("         : options = %S%S%S%S%S%S, which = %S%S%S%S (0x%x)\n"),
				TestInterleave ? &KTestInter : &KTestBlank,
				TestPrioChange ? &KTestPrio: &KTestBlank,
				(TestMediaAccess == KTestMediaAccessNone) ? &KTestBlank : &KTestMedia,
				TestingLowMem ? &KTestLowMem : &KTestBlank, 
				TestExtremeChunks ? &KTestEChunking : TestChunksPlus ? &KTestChunkingPlus : TestingChunks ? &KTestChunking : &KTestBlank, 
				TestingReaper ? &KTestReaper : &KTestBlank, 
				TestWhichTests & TEST_THRASH ? &KTestThrash : &KTestBlank,
				TestWhichTests & TEST_FORWARD ? &KTestForward : &KTestBlank,
				TestWhichTests & TEST_BACKWARD ? &KTestBackward : &KTestBlank,
				TestWhichTests & TEST_RANDOM ? &KTestRandom : &KTestBlank,
				TestWhichTests));
	}

//
// DoSingleTest
// 
// Perform the single thread test, spawning a number of threads.
//

LOCAL_C TInt DoSingleTest(TBool aLowMem = EFalse)
	{
	TUint        start = User::TickCount();
	RSemaphore	*pTheSem = NULL;
	TInt ret = KErrNone;
	DisplayTestBanner(EFalse);

	if (aLowMem)
		{
		DOTEST1(ret,TestMultiSem.CreateLocal(1),KErrNone, KErrNoMemory);
		pTheSem = &TestMultiSem;
		}
	if (TestLoading & TEST_EXE)
		{
		RProcess		theProcess;
		TRequestStatus	status;
		
		if (StartExe(theProcess, &status, 0, EFalse, aLowMem, pTheSem) == KErrNone)
			{
			User::WaitForRequest(status);
			if (theProcess.ExitType() == EExitPanic)
				{
				DBGS_PRINT((_L("%S : Process Panic'd...\n"), &TestNameBuffer));	
				}
			theProcess.Close();
			}
		}

	if (TestLoading & TEST_SELF)
		{
		RProcess		theProcess;
		TRequestStatus	status;
		
		if (StartExe(theProcess, &status, 0, ETrue, aLowMem,pTheSem) == KErrNone)
			{
			User::WaitForRequest(status);
			if (theProcess.ExitType() == EExitPanic)
				{
				DBGS_PRINT((_L("%S : Process Panic'd...\n"), &TestNameBuffer));
				}
			theProcess.Close();
			}
		}

	if (TestLoading	& TEST_DLL)
		{
		TInt maxDlls = GetNumDlls();
		if (TestLoadDllHow == TEST_DLL_GLOBAL)
			{
			TInt retVal = LoadTheLibs(theGlobalLibs, maxDlls, TestInstanceId, NULL, NULL, pTheSem);
			if (retVal != KErrNone)
				{
				DBGS_PRINT((_L("DoSingleTest - unable to load libs\n") ));
				CloseTheLibs (theGlobalLibs, PAGELDRTST_MAX_DLLS);
				if (aLowMem)
					{
					TestMultiSem.Close();
					}
				return KErrGeneral;
				}
			}

		ret = PerformTestThread((TInt) TestInstanceId, NULL, NULL, pTheSem);

		if (TestLoadDllHow == TEST_DLL_GLOBAL)
			{
			CloseTheLibs(theGlobalLibs, maxDlls);
			}
		}
	if (aLowMem)
		{
		TestMultiSem.Close();
		}

	if (!TestSilent)
		{
		TInt end = User::TickCount();
		TInt time = TUint((TUint64)(end-start)*(TUint64)TickPeriod/(TUint64)1000000);
		DBGS_PRINT((_L("\n%S : Single Test : (%u seconds)\n"), &TestNameBuffer, time));
		}

	return ret;
	}

//
// FillPage
//
// Fill a page with test data
//

void FillPage(TUint aOffset)
	{
	if (TestChunkData)
		{
		TUint32* ptr = (TUint32 *)((TUint8 *)TestChunkBase+aOffset);
		TUint32* ptrEnd = (TUint32 *)((TUint8 *)ptr + TestPageSize);
		do 
			{
			*ptr = 0x55000000 + aOffset;
			ptr ++;
			aOffset += 4;
			}
		while(ptr<ptrEnd);
		}
	}

//
// CheckPage
//
// Check a page matches test data....
//

TBool CheckPage(TUint index, TUint aOffset)
	{
	TBool ret = ETrue;
	if (TestChunkData)
		{
		TUint32* ptr = (TUint32 *)((TUint8 *)TestChunkBase+aOffset);
		TUint32* ptrEnd = (TUint32 *)((TUint8 *)ptr + TestPageSize);
		do
			{
			if (*ptr != (0x55000000 + aOffset)) 
				break;
			ptr ++;
			aOffset += 4;
			}
		while(ptr<ptrEnd);
		if (ptr==ptrEnd)
			{
			TestChunkStats[index].check.ok ++;
			}
		else
			{
			TestChunkStats[index].check.fail ++;
			ret = EFalse;
			}
		}
	return ret;
	}

//
// DoSomeChunking
//
// Lock and unlock various pages in a chunk...
//
TUint   TestChunkingIndex = 0;
TUint   TestChunkingIndexFails = 0;

void DoSomeChunking()
	{
	TUint       iters = TEST_NUM_CHUNK_PAGES / 4;
	TBool		lockit = EFalse;
	TBool		decomit = EFalse;
	TUint		index;
	TInt		ret;
	TInt		theOffset;
	
	while (iters)
		{
		TestChunkingIndex = TestChunkingIndex * 69069 + 1;
		index = TUint64((TUint64)TestChunkingIndex*(TUint64)TEST_NUM_CHUNK_PAGES)>>32;
		if (index >= TEST_NUM_CHUNK_PAGES)
			TestChunkingIndexFails ++;

		theOffset = index * TestPageSize;
		if (theOffset < TestCommitEnd)
			{
			if (lockit)
				{
				if (decomit)
					{
					ret = TestChunk.Decommit(theOffset,TestPageSize);
					if (KErrNone == ret)
						TestChunkStats[index].decommit.ok ++;
					else
						TestChunkStats[index].decommit.fail ++;
					ret = TestChunk.Commit(theOffset,TestPageSize);
					if (KErrNone == ret)
						{
						TestChunkStats[index].commit.ok ++;
						FillPage(theOffset);
						TestChunkPageState[index] = ETrue;
						}
					else
						{
						TestChunkStats[index].commit.fail ++;
						TestChunkPageState[index] = EFalse;
						}
					ret = KErrNone;
					}
				else
					{
					ret = TestChunk.Lock(theOffset,TestPageSize);
					if (KErrNone == ret)
						{
						TestChunkStats[index].lock.ok ++;
						if (!CheckPage(index, theOffset))
							FillPage(theOffset);
						TestChunkPageState[index] = ETrue;
						}
					else
						{
						TestChunkStats[index].lock.fail ++;
						TestChunkPageState[index] = EFalse;
						}
					}
				decomit = !decomit;
				}
			else
				{
				if (TestChunkPageState[index])
					{
					// this one should still be locked so the data should be ok.
					if (KErrNone == TestChunk.Lock(theOffset,TestPageSize))
						{				
						TestChunkStats[index].lock.ok ++;
						CheckPage(index, theOffset);
						}
					else
						TestChunkStats[index].lock.fail ++;
					}
				ret = TestChunk.Unlock(theOffset,TestPageSize);
				if (KErrNone == ret)
					TestChunkStats[index].unlock.ok ++;
				else
					TestChunkStats[index].unlock.fail ++;
				TestChunkPageState[index] = EFalse;
				}
			if (KErrNone != ret)			
				{
				// so now we need to commit another page in this pages place.
				ret = TestChunk.Commit(theOffset,TestPageSize);
				if (KErrNone != ret)
					{
					TestChunkStats[index].commit.fail ++;
					//DBGS_PRINT((_L("%S : DoSomeChunking[%03d] index %03d failed to commit a page  %d\n"), &TestNameBuffer, iters, index, ret));
					TestChunkPageState[index] = EFalse;
					}
				else
					{
					TestChunkStats[index].commit.ok ++;
					FillPage(theOffset);
					TestChunkPageState[index] = ETrue;
					}
				}
			lockit = !lockit;
			}
		else
			{
			RDebug::Printf("DoSomeChunking - offset was bad %d / %d", theOffset, TestCommitEnd);
			}
		iters --;
		}
	}

//
// DoMultipleTest
// 
// Perform the multiple thread test, spawning a number of threads.
// It is complicated a little because test.Printf can only be called from the first thread that calls it 
// so if we are using multiple threads we need to use a message queue to pass the debug info from the
// child threads back to the parent for the parent to then call printf.
//

TInt DoMultipleTest(TBool aLowMem = EFalse)
	{
	TInt			 index;
	TUint            start = User::TickCount();
	RThread			*pTheThreads = NULL;
	TInt			*pThreadInUse = NULL;

	RProcess		*pTheProcesses = NULL;
	TInt			*pProcessInUse = NULL;

	RThread			*pMedThreads = NULL;
	TInt			*pMedInUse = NULL;

	TRequestStatus	mediaStatus;
	RThread			mediaThread;
	TInt ret;

	RSemaphore	*pTheSem = NULL;

	DisplayTestBanner(ETrue);
	
	TestThreadsExit = EFalse;

	DOTEST1(ret,TestMultiSem.CreateLocal(1),KErrNone, KErrNoMemory);
	
	pTheSem = &TestMultiSem;
	if (TestLoading & TEST_DLL)
		{
		DOTEST((pTheThreads  = (RThread *)User::AllocZ(sizeof(RThread) * TestMultipleThreadCount)),
		       (pTheThreads != NULL))
		DOTEST((pThreadInUse = (TInt *)User::AllocZ(sizeof(TInt) * TestMultipleThreadCount)),
		       (pThreadInUse != NULL));
		RUNTEST1(pTheThreads && pThreadInUse);
		if (!(pTheThreads && pThreadInUse))
			return KErrGeneral;
		}

	if (TestLoading & TEST_EXE_SELF)
		{
		DOTEST((pTheProcesses = (RProcess *)User::AllocZ(sizeof(RProcess) * TestMultipleThreadCount)),
		       (pTheProcesses != NULL));
		DOTEST((pProcessInUse = (TInt *)User::AllocZ(sizeof(TInt) * TestMultipleThreadCount)),
		       (pProcessInUse != NULL));
		RUNTEST1(pTheProcesses && pProcessInUse);
		if (!(pTheProcesses && pProcessInUse))
			return KErrGeneral;
		}
	
	if (!TestSilent)
		{
		DOTEST1(ret,TestMsgQueue.CreateLocal(TestMultipleThreadCount * 10, EOwnerProcess),KErrNone, KErrNoMemory);
		if (ret != KErrNone)
			return KErrGeneral;
		}

	if (TestMediaAccess != KTestMediaAccessNone)
		{
		if (TestMediaAccess != KTestMediaAccessBasic)
			{
			TestStopMedia = EFalse;
			DOTEST((pMedThreads  = (RThread *)User::AllocZ(sizeof(RThread) * TestMultipleThreadCount)),
				   (pMedThreads != NULL))
			DOTEST((pMedInUse = (TInt *)User::AllocZ(sizeof(TInt) * TestMultipleThreadCount)),
				   (pMedInUse != NULL));
			RUNTEST1(pMedThreads && pMedInUse);
			if (!(pMedThreads && pMedInUse))
				return KErrGeneral;

			for (index = 0; index < TestMultipleThreadCount; index++)
				{
				DBGS_PRINT((_L("%S : Starting Media Thread %d\n"), &TestNameBuffer, index));
				DOTEST1(ret,pMedThreads[index].Create(KTestBlank,PerformRomAndFileSystemAccess,KDefaultStackSize,NULL,(TAny*) index),KErrNone, KErrNoMemory);
				if (ret == KErrNone)
					{
					pMedThreads[index].Resume();
					pMedInUse[index] = 1;
					}
				User::AfterHighRes(0);
				}
			}
		else
			{
			TestStopMedia = EFalse;
			DOTEST1(ret,mediaThread.Create(KTestBlank,PerformRomAndFileSystemAccess,KDefaultStackSize,NULL,(TAny *) 0),KErrNone, KErrNoMemory);
			if (ret == KErrNone)
				{
				mediaThread.Logon(mediaStatus);
				RUNTEST1(mediaStatus == KRequestPending);	
				mediaThread.Resume();
				}
			}
		}

	TInt maxDlls = GetNumDlls();
	if (TestLoadDllHow == TEST_DLL_GLOBAL)
		{
		TInt retVal = LoadTheLibs(theGlobalLibs, maxDlls, 0, NULL, NULL, NULL);
		if (retVal != KErrNone)
			{
			DBGS_PRINT((_L("DoMultipleTest - unable to load libs\n")));
			CloseTheLibs (theGlobalLibs, maxDlls);
			if (!TestSilent)
				{
				TestMsgQueue.Close();
				}
			TestMultiSem.Close();
			return KErrGeneral;
			}
		}

	// make sure we have a priority higher than that of the threads we spawn...
	RThread thisThread;
	TThreadPriority savedThreadPriority = thisThread.Priority();
	const TThreadPriority KMainThreadPriority = EPriorityMuchMore;
	__ASSERT_COMPILE(KMainThreadPriority>TEST_INTERLEAVE_PRIO);
	thisThread.SetPriority(KMainThreadPriority);
	

	for (index = 0; index < TestMultipleThreadCount; index++)
		{
		if (TestLoading & TEST_EXE_SELF)
			{
			if (KErrNone == StartExe(pTheProcesses[index], 0, index + ((TestLoading & TEST_DLL) ? TestMultipleThreadCount : 0), ((TestLoading & TEST_EXE_SELF) == TEST_EXE_SELF) ? (index & 2) : (TestLoading & TEST_SELF), aLowMem, pTheSem))
				{
				User::AfterHighRes(0);
				pProcessInUse[index] = 1;
				}
			}
		
	
		if (TestLoading & TEST_DLL)
			{
			DBGS_PRINT((_L("%S : Starting Thread %d\n"), &TestNameBuffer, index));
			DOTEST1(ret,pTheThreads[index].Create(KTestBlank,MultipleTestThread,KDefaultStackSize,NULL,(TAny*) index),KErrNone, KErrNoMemory);
			if (ret == KErrNone)
				{
				pTheThreads[index].Resume();
				User::AfterHighRes(0);
				pThreadInUse[index] = 1;
				}
			}
		}

	// wait for any child threads to exit and process any debug messages they pass back to the parent.
	TBool		anyUsed = ETrue;
	TMessageBuf	localBuffer;
	
	TInt		processOk = 0;
	TInt		threadOk = 0;
	TInt		processPanic = 0;
	TInt		threadPanic = 0;
	TUint		end = start;
	TUint		now;
	TUint		time;
	TUint		killNext = 0;
	TUint		numDots = 0;
	TUint		maxDots = (10*60)/TEST_DOT_PERIOD;	// No individual test should take longer than 10 minutes!
													// Most have been tuned to take between 2 and 8 minutes.
													// The autotests should not take more than 120 minutes total.

	while(anyUsed)
		{
		TInt threadCount = 0;
		TInt processCount = 0;
		anyUsed = EFalse;

		// check the message queue and call printf if we get a message.
		if (!TestSilent)
			{
			while (KErrNone == TestMsgQueue.Receive(localBuffer))
				{
				DBGS_PRINT((localBuffer));
				}
			}

		// walk through the thread list to check which are still alive.
		for (index = 0; index < TestMultipleThreadCount; index++)
			{
			if (TestLoading & TEST_DLL)
				{
				if (pThreadInUse[index])
					{
					if (pTheThreads[index].ExitType() != EExitPending)
						{
						if (pTheThreads[index].ExitType() == EExitPanic)
							{
							DBGS_PRINT((_L("%S : Thread %d Panic'd after %u ticks \n"),
								&TestNameBuffer, index, User::TickCount() - start));	
							threadPanic ++;
							}
						else
							{
							DBGS_PRINT((_L("%S : Thread %d Exited after %u ticks \n"),
								&TestNameBuffer, index, User::TickCount() - start));	
							threadOk ++;
							}
						pTheThreads[index].Close();
						pThreadInUse[index] = EFalse;
						}
					else
						{
						threadCount += 1;
						anyUsed = ETrue;
						if (TestThreadsExit)
							{
							now = User::TickCount();
							time = TUint((TUint64)(now-end)*(TUint64)TickPeriod/(TUint64)1000000);
							if (time > TEST_DOT_PERIOD)
								{
								DBGS_PRINT((_L("%S : Thread %d still running\n"), &TestNameBuffer, index));	
								}
							time = TUint((TUint64)(now-killNext)*(TUint64)TickPeriod/(TUint64)1000000);
							const TUint killTimeStep = (TEST_DOT_PERIOD+9)/10; // 1/10th of a dot
							if(time>TEST_DOT_PERIOD+killTimeStep)
								{
								killNext += killTimeStep*1000000/TickPeriod;
								DBGS_PRINT((_L("%S : killing Thread %d\n"), &TestNameBuffer, index));	
								pTheThreads[index].Kill(KErrNone);
								pTheThreads[index].Close();
								pThreadInUse[index] = EFalse;
								}
							}
						}
					}
				}
			if (TestLoading & TEST_EXE_SELF)
				{
				if (pProcessInUse[index])
					{
					if (pTheProcesses[index].ExitType() != EExitPending)
						{
						if (pTheProcesses[index].ExitType() == EExitPanic)
							{
							DBGS_PRINT((_L("%S : Process %d Panic'd after %u ticks \n"),
								&TestNameBuffer,
								index + ((TestLoading & TEST_DLL) ? TestMultipleThreadCount : 0),
								User::TickCount() - start));	
							processPanic ++;
							}
						else
							{
							DBGS_PRINT((_L("%S : Process %d Exited after %u ticks \n"),
								&TestNameBuffer,
								index + ((TestLoading & TEST_DLL) ? TestMultipleThreadCount : 0),
								User::TickCount() - start));	
							processOk ++;
							}

						pTheProcesses[index].Close();
						pProcessInUse[index] = EFalse;
						}
					else
						{
						processCount += 1;
						anyUsed = ETrue;
						if (TestThreadsExit)
							{
							now = User::TickCount();
							time = TUint((TUint64)(now-end)*(TUint64)TickPeriod/(TUint64)1000000);
							if (time > TEST_DOT_PERIOD)
								{
								DBGS_PRINT((_L("%S : Process %d still running; killing it.\n"),
									&TestNameBuffer, index));
								pTheProcesses[index].Kill(EExitKill);
								pTheProcesses[index].Close();
								pProcessInUse[index] = EFalse;
								}
							
							}
						}
					}
				}
			}

		now = User::TickCount();
		time = TUint((TUint64)(now-end)*(TUint64)TickPeriod/(TUint64)1000000);

		DBGD_PRINT((_L("%S : %d seconds (%d ticks) %d threads, %d processes still alive\n"),
			&TestNameBuffer, time, now, threadCount, processCount));

		if (time > TEST_DOT_PERIOD)
			{
			DBGS_PRINT((_L(".")));
			numDots ++;
			end += TEST_DOT_PERIOD*1000000/TickPeriod;
			if (TestingReaper)
				{
				TestingReaperCleaningFiles = ETrue;
				CleanupFiles(EFalse);
				CheckFilePresence(ETrue);
				TestingReaperCleaningFiles = EFalse;
				}
			if ((numDots >= maxDots) && (!TestThreadsExit))
				{
				DBGS_PRINT((_L("Taking longer than %d dots...exiting test case."), maxDots));
				TestThreadsExit = ETrue;
				killNext = end;
				}
			}

		if (TestingChunks)
			{
			DoSomeChunking();
			}

#ifdef TEST_THRASHING_TEST
		User::AfterHighRes(1000);
#else
		User::AfterHighRes(TickPeriod);
#endif
		}

	DBGD_PRINT((_L("%S : all test threads presumably gone now\n"), &TestNameBuffer));

	if (TestMediaAccess != KTestMediaAccessNone)
		{
		if (TestMediaAccess != KTestMediaAccessBasic)
			{
			TBool killMedia = EFalse;
			TestStopMedia = ETrue;
			anyUsed = ETrue;
			DBGS_PRINT((_L("%S : Waiting for media threads to exit...\n"), &TestNameBuffer));	
			end = User::TickCount();
			while (anyUsed)
				{
				anyUsed = EFalse;

				// check the message queue and call printf if we get a message.
				if (!TestSilent)
					{
					while (KErrNone == TestMsgQueue.Receive(localBuffer))
						{
						DBGS_PRINT((localBuffer));
						}
					}

				for (index = 0; index < TestMultipleThreadCount; index++)
					{
					if (pMedInUse[index])
						{
						if (pMedThreads[index].ExitType() != EExitPending)
							{
							if (pMedThreads[index].ExitType() == EExitPanic)
								{
								DBGS_PRINT((_L("%S : Media Thread %d Panic'd after %u ticks \n"),
									&TestNameBuffer, index, User::TickCount() - start));	
								threadPanic ++;
								}
							else
								{
								DBGS_PRINT((_L("%S : Media Thread %d Exited after %u ticks \n"),
									&TestNameBuffer, index, User::TickCount() - start));	
								threadOk ++;
								}
							pMedInUse[index] = EFalse;
							}
						else
							{
							anyUsed = ETrue;
							if (killMedia)
								{
								DBGS_PRINT((_L("%S : Media Thread %d still going after %u ticks; killing it!\n"),
									&TestNameBuffer, index, User::TickCount() - start));	
								pMedThreads[index].Kill(EExitKill);
								}
							}
						}
					}
				now = User::TickCount();
				time = TUint((TUint64)(now-end)*(TUint64)TickPeriod/(TUint64)1000000);
				if (time > TEST_DOT_PERIOD)
					{
					DBGS_PRINT((_L(".")));
					end += TEST_DOT_PERIOD*1000000/TickPeriod;
					killMedia = ETrue;
					}

				User::AfterHighRes(50000);

				}
			DBGS_PRINT((_L("%S : Media threads exited...\n"), &TestNameBuffer));	
			User::Free(pMedThreads);
			User::Free(pMedInUse);
			}
		else
			{
			TestStopMedia = ETrue;
			DBGS_PRINT((_L("%S : Waiting for media thread to exit...\n"), &TestNameBuffer));	
			end = User::TickCount();
			while (mediaThread.ExitType() == EExitPending)
				{
				now = User::TickCount();
				time = TUint((TUint64)(now-end)*(TUint64)TickPeriod/(TUint64)1000000);
				if (time > TEST_DOT_PERIOD)
					{
					DBGS_PRINT((_L("%S : Media thread still going after %u seconds; killing it!\n"),
						&TestNameBuffer, time));
					mediaThread.Kill(EExitKill);
					}
				User::AfterHighRes(50000);
				}
			User::WaitForRequest(mediaStatus);
			mediaThread.Close();
			DBGS_PRINT((_L("%S : Media thread exited...\n"), &TestNameBuffer));	
			}
		}

	DBGD_PRINT((_L("%S : all media threads presumably gone now\n"), &TestNameBuffer));

	if (!TestSilent)
		{
		TestMsgQueue.Close();
		}
	TestMultiSem.Close();

	DBGD_PRINT((_L("%S : about to close the libraries\n"), &TestNameBuffer));

	if (TestLoadDllHow == TEST_DLL_GLOBAL)
		{
		CloseTheLibs(theGlobalLibs, maxDlls);
		}

	TestThreadsExit = EFalse;

	DBGD_PRINT((_L("%S : cleaning up\n"), &TestNameBuffer));

	// cleanup the resources and exit.
	if (TestLoading & TEST_EXE_SELF)
		{
		User::Free(pTheProcesses);
		User::Free(pProcessInUse);
		}

	// cleanup the resources and exit.
	if (TestLoading & TEST_DLL)
		{
		User::Free(pTheThreads);
		User::Free(pThreadInUse);
		}

	if (!TestSilent)
		{
		end = User::TickCount();
		time = TUint((TUint64)(end-start)*(TUint64)TickPeriod/(TUint64)1000000);
		DBGS_PRINT((_L("\n%S : Multiple Test : (%u seconds)\n\tThreads panic'd = %d Ok = %d\n\tProcess panic'd = %d Ok = %d\n"), &TestNameBuffer, time, threadPanic, threadOk, processPanic, processOk));
		}

	thisThread.SetPriority(savedThreadPriority);

	return (threadPanic | processPanic) ? KErrGeneral : KErrNone;
	}

//
// DoChunkTests
//
// Allocate a chunk and assign some pages to it...
// Then do a multiple test.
//

void DoChunkTests()
	{
	SVMCacheInfo  tempPages;
	memset(&tempPages, 0, sizeof(tempPages));
	if (TestIsDemandPaged)
		{
		// Shrink the page cache down to the minimum.
		UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);

		DBGS_PRINT((_L("Start : min %d max %d current %d maxFree %d freeRam %d\n"),
					 tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize ,tempPages.iMaxFreeSize, FreeRam()));

		// set the cache small 
		TInt minSize = 16 * TestPageSize;
		TInt maxSize = TEST_NUM_PAGES * TestPageSize;
		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);
		}

	if (KErrNone != TestChunk.CreateDisconnectedLocal(0,0,TEST_NUM_CHUNK_PAGES *TestPageSize))
		{
		DBGS_PRINT((_L("DoChunkTests - create failed.\n")));
		return;
		}
	TestChunkBase = TestChunk.Base();
	if (TestChunkBase == NULL)
		{
		RDebug::Printf("DoChunkTests - TestChunkBase was NULL");
		TestChunk.Close();
		return;
		}
	TInt retVal = KErrNone;
	TUint index = 0;
	TestCommitEnd = 0;
	memset(TestChunkPageState, 0, sizeof(TestChunkPageState));
	memset(TestChunkStats,0,sizeof(TestChunkStats));
	while(index < TEST_NUM_CHUNK_PAGES)
		{
		retVal = TestChunk.Commit(TestCommitEnd,TestPageSize);
		if (KErrNone != retVal)
			{
			DBGS_PRINT((_L("%S : TestChunk.Commit returned %d for 0x%08x...\n"), &TestNameBuffer, retVal, TestCommitEnd));	
			break;
			}
		TestChunkPageState[index] = ETrue;
		FillPage(TestCommitEnd);
		TestCommitEnd += TestPageSize;
		index ++;
		}
	RUNTEST1(retVal == KErrNone);
	
	// now do some testing....
	TestingChunks = ETrue;
	TestInterleave = EFalse;
	TestPrioChange = ETrue;
	TestMediaAccess = KTestMediaAccessNone;
	// temp
	TestWhichMedia = TEST_MEDIA_ROM_BASE;

	if (TestChunksPlus)
		{
		TestMaxLoops = 1;
		TestMultipleThreadCount	= 40;
		}
	else if (TestExtremeChunks)
		{
		TestMaxLoops = 10;
		TestMultipleThreadCount	= 12;
		}
	else
		{
		TestMaxLoops = 3;
		TestMultipleThreadCount	= 20;
		}
	TestWhichTests = TEST_RANDOM;

	TestLoading = TEST_EXE_SELF_DLL;
	TestLoadDllHow = TEST_DLL_FUNC;
	TestChunkingIndexFails = 0;

	TEST_NEXT((_L("Multiple threads random with chunks.")));
	RUNTEST(DoMultipleTest(), KErrNone);
	
	TestingChunks = EFalse;

	// clean up.
	UserSvr::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0);
	TestChunk.Close();

	if (TestIsDemandPaged)
		{
		// put the cache back to the the original values.
		TInt minSize = tempPages.iMinSize;
		TInt maxSize = tempPages.iMaxSize;

		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);

		UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);

		DBGS_PRINT((_L("Finish : min %d max %d current %d maxFree %d freeRam %d\n"),
					 tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize ,tempPages.iMaxFreeSize, FreeRam()));
		}
	TChunkTestStats  stats;

	memset(&stats, 0, sizeof(stats));
	DBGS_PRINT((_L("Stats : (pass/fail) \nindex\t\tlock\t\tunlock\t\tcommit\t\tdecommit\t\tcheck\n")));
	for (index = 0; index < TEST_NUM_CHUNK_PAGES; index ++)
		{
		DBGS_PRINT((_L("%u\t\t%d/%d\t\t%d/%d\t\t%d/%d\t\t%d/%d\t\t%d/%d\n"), 
					index,
					TestChunkStats[index].lock.ok, TestChunkStats[index].lock.fail,
					TestChunkStats[index].unlock.ok, TestChunkStats[index].unlock.fail,
					TestChunkStats[index].commit.ok, TestChunkStats[index].commit.fail,
					TestChunkStats[index].decommit.ok, TestChunkStats[index].decommit.fail,
					TestChunkStats[index].check.ok, TestChunkStats[index].check.fail));

		stats.lock.ok += TestChunkStats[index].lock.ok;
		stats.lock.fail += TestChunkStats[index].lock.fail;
		stats.unlock.ok += TestChunkStats[index].unlock.ok;
		stats.unlock.fail += TestChunkStats[index].unlock.fail;
		stats.decommit.ok += TestChunkStats[index].decommit.ok;
		stats.decommit.fail += TestChunkStats[index].decommit.fail;
		stats.commit.ok += TestChunkStats[index].commit.ok;
		stats.commit.fail += TestChunkStats[index].commit.fail;
		stats.check.ok += TestChunkStats[index].check.ok;
		stats.check.fail += TestChunkStats[index].check.fail;
		}

	DBGS_PRINT((_L("Total Stats (p/f): \n\t lock %d / %d\n\t unlock  %d / %d\n\t commit %d / %d\n\t decommit %d / %d\n\t check %d / %d\n"), 
				stats.lock.ok, stats.lock.fail,
				stats.unlock.ok, stats.unlock.fail,
				stats.commit.ok, stats.commit.fail,
				stats.decommit.ok, stats.decommit.fail,
				stats.check.ok, stats.check.fail));
	DBGS_PRINT((_L("TestChunkingIndexFails %d\n"), TestChunkingIndexFails));

	}

//
// DoReaperTests
//
// Test the reaper by deleting the transient files and re-creating them.
//

void DoReaperTests(void)
	{
	// make sure we have the full complement of files.
	CheckFilePresence(ETrue);
	
	// now do some testing....
	TestInterleave = EFalse;
	TestPrioChange = EFalse;
	TestMediaAccess = KTestMediaAccessNone;
	// temp
	TestWhichMedia = TEST_MEDIA_ALL;
	TestMaxLoops = 3;
	TestMultipleThreadCount	= 12;
	TestWhichTests = TEST_RANDOM;

	TestLoading = TEST_EXE_SELF_DLL;
	TestLoadDllHow = TEST_DLL_FUNC;
	
	TestingReaper = ETrue;

	TEST_NEXT((_L("Reaper tests.")));
	RUNTEST(DoMultipleTest(), KErrNone);
	TestInterleave = ETrue;
	TestPrioChange = ETrue;
	TEST_NEXT((_L("Reaper tests 2.")));
	RUNTEST(DoMultipleTest(), KErrNone);
	
	TestingReaper = EFalse;
	}

//
// DoBtraceTest
//
// Test the paging BTrace function.
//

void DoBtraceTest(void)
	{
#define LE4(a) ((*((a) + 3) << 24) + (*((a) + 2) << 16) + (*((a) + 1) << 8) + *(a))

	RBTrace bTraceHandle;
	
	TInt r = bTraceHandle.Open();
	test(r == KErrNone);
	
	r = bTraceHandle.ResizeBuffer(0x200000); 
	test(r == KErrNone);
	bTraceHandle.SetFilter(BTrace::EPaging, ETrue);

	// Enable trace
	bTraceHandle.Empty();
	bTraceHandle.SetMode(RBTrace::EEnable);
	
	TestLoading             = TEST_EXE_SELF_DLL;
	TestWhichMedia          = TEST_MEDIA_ROM_BASE;
	TestMaxLoops            = 2;
	TestMultipleThreadCount = 10;
	TestLoadDllHow          = TEST_DLL_FUNC;
	TestInterleave          = ETrue;
	TestPrioChange          = ETrue;
	TestMediaAccess         = KTestMediaAccessNone;
	TestWhichTests          = TEST_RANDOM;		
	TestingLowMem			= EFalse;

	RUNTEST(DoMultipleTest(TestingLowMem), KErrNone);

	bTraceHandle.SetMode(0);

	// analyse the btrace logs and display on the serial port.
	TUint8* pDataStart;
	TInt	dataSize;
	TUint8* pTemp;
	TUint8* pThis;
	TUint8* pEnd;
	TBuf<128>	data;
	while (1)
		{
		dataSize = bTraceHandle.GetData(pDataStart);
		if (dataSize <= 0)
			{
			break;
			}
		pEnd = pDataStart + dataSize;
		pTemp = pDataStart;
		while (pTemp < pEnd)
			{
			TUint8	recSize		= pTemp[BTrace::ESizeIndex];
			TUint8	recFlags	= pTemp[BTrace::EFlagsIndex];
			TUint8	recCat		= pTemp[BTrace::ECategoryIndex];
			TUint8	recSub		= pTemp[BTrace::ESubCategoryIndex];
			TUint32 addr[4];
			pThis = pTemp;

			data.Zero();
			// step over the header.
			data.Format(_L("size %d cat %d sub %d flg 0x%02x "), recSize, recCat, recSub, recFlags);
			pTemp += 4; 
					
			if (recFlags & BTrace::EHeader2Present)
				{
				data.AppendFormat(_L("h2 0x%08x "), LE4(pTemp));
				pTemp += 4;
				}
			if (recFlags & BTrace::ETimestampPresent)
				{
				data.AppendFormat(_L("ts 0x%08x "), LE4(pTemp));
				pTemp += 4;
				}
			if (recFlags & BTrace::ETimestamp2Present)
				{
				data.AppendFormat(_L("ts2 0x%08x "), LE4(pTemp));
				pTemp += 4;
				}
			if (recFlags & BTrace::EContextIdPresent)
				{
				data.AppendFormat(_L("cId 0x%08x "), LE4(pTemp));
				pTemp += 4;
				}
			TInt index;
			for (index = 0; index < 4; index ++)
				{
				if (recSize > pTemp - pThis)
					{
					addr[index] = LE4(pTemp);
					pTemp += 4;
					}
				else
					addr[index] = 0;
				}

			switch(recCat)
				{
				case BTrace::EPaging:
					{
					switch (recSub)
						{
						case BTrace::EPagingPageInBegin:
						/**
						- 4 bytes containing the virtual address which was accessed, causing this paging event.
						- 4 bytes containing the virtual address of the instuction which caused this paging event.
						  (The PC value.)
						**/
						test.Printf(_L("PageInBegin    : %S addr 0x%08x inst 0x%08x\n"), &data, addr[0], addr[1]);
						break;

						/**
						- 0 bytes. (No extra data.)
						*/
						case BTrace::EPagingPageInUnneeded:
						test.Printf(_L("PageInUnneeded : %S\n"), &data);
						break;

						/**
						- 4 bytes containing the physical address of the page 'paged in'.
						- 4 bytes containing the virtual address of the page 'paged in'.
						*/
						case BTrace::EPagingPageInROM:
						test.Printf(_L("PageInROM      : %S phys 0x%08x virt 0x%08x\n"), &data, addr[0], addr[1]);
						break;

						/**
						- 4 bytes containing the physical address of the page being 'paged out'.
						- 4 bytes containing the virtual address of the page being 'paged out'.
						*/
						case BTrace::EPagingPageOutROM:
						test.Printf(_L("PageOutROM     : %S phys 0x%08x virt 0x%08x\n"), &data, addr[0], addr[1]);
						break;

						/**
						- 4 bytes containing the physical address of the page being 'paged in'.
						*/
						case BTrace::EPagingPageInFree:
						test.Printf(_L("PageInFree     : %S phys 0x%08x\n"), &data, addr[0]);
						break;

						/**
						- 4 bytes containing the physical address of the page being 'paged out'.
						*/
						case BTrace::EPagingPageOutFree:
						test.Printf(_L("PageOutFree    : %S phys 0x%08x\n"), &data, addr[0]);
						break;

						/**
						- 4 bytes containing the physical address of the page being rejuvenated, (made young).
						- 4 bytes containing the virtual address which was accessed, causing this paging event.
						- 4 bytes containing the virtual address of the instuction which caused this paging event.
						  (The PC value.)
						*/
						case BTrace::EPagingRejuvenate:
						test.Printf(_L("Rejuvenate     : %S phys 0x%08x virt 0x%08x inst 0x%08x\n"), &data, addr[0], addr[1], addr[2]);
						break;

						/**
						- 4 bytes containing the physical address of the page accessed.
						- 4 bytes containing the virtual address which was accessed, causing this paging event.
						- 4 bytes containing the virtual address of the instuction which caused this paging event.
						  (The PC value.)
						*/
						case BTrace::EPagingPageNop:
						test.Printf(_L("PageNop        : %S phys 0x%08x virt 0x%08x inst 0x%08x\n"), &data, addr[0], addr[1], addr[2]);
						break;

						/**
						- 4 bytes containing the physical address of the page being locked.
						- 4 bytes containing the value of the lock count after the paged was locked.
						*/
						case BTrace::EPagingPageLock:
						test.Printf(_L("PageLock       : %S phys 0x%08x lock 0x%08x\n"), &data, addr[0], addr[1]);
						break;

						/**
						- 4 bytes containing the physical address of the page being unlocked.
						- 4 bytes containing the value of the lock count before the paged was unlocked.
						*/
						case BTrace::EPagingPageUnlock:
						test.Printf(_L("PageUnlock     : %S phys 0x%08x lock 0x%08x\n"), &data, addr[0], addr[1]);
						break;
		
						/**
						- 4 bytes containing the physical address of the page being 'paged out'.
						- 4 bytes containing the virtual address of the page being 'paged out'.
						*/
						case BTrace::EPagingPageOutCache:
						test.Printf(_L("PageOutCache   : %S phys 0x%08x virt 0x%08x\n"), &data, addr[0], addr[1]);
						break;
		
						/**
						- 4 bytes containing the physical address of the page 'paged in'.
						- 4 bytes containing the virtual address of the page 'paged in'.
						*/
						case BTrace::EPagingPageInCode:
						test.Printf(_L("PageInCode     : %S phys 0x%08x virt 0x%08x\n"), &data, addr[0], addr[1]);
						break;

						/**
						- 4 bytes containing the physical address of the page being 'paged out'.
						- 4 bytes containing the virtual address of the page being 'paged out'.
						*/
						case BTrace::EPagingPageOutCode:
						test.Printf(_L("PageOutCode    : %S phys 0x%08x virt 0x%08x\n"), &data, addr[0], addr[1]);
						break;
		
						/**
						- 4 bytes containing the physical address of the page 'paged in'.
						- 4 bytes containing the virtual address of the page 'paged in'.
						*/
						case BTrace::EPagingMapCode:
						test.Printf(_L("MapCode        : %S phys 0x%08x virt 0x%08x\n"), &data, addr[0], addr[1]);
						break;
						
						/**
						- 4 bytes containing the physical address of the page being aged, (made old).
						*/
						case BTrace::EPagingAged:
						test.Printf(_L("Aged           : %S phys 0x%08x\n"), &data, addr[0]);
						break;
						}
					}
				break;

				default:
				
				break;
				}
			pTemp = BTrace::NextRecord(pThis);
			}
		bTraceHandle.DataUsed();
		}
	bTraceHandle.Close();
	}

//
// ParseCommandLine 
//
// read the arguments passed from the command line and set global variables to 
// control the tests.
//

TBool ParseCommandLine()
	{
	TBuf<256> args;
	User::CommandLine(args);
	TLex	lex(args);
	TBool	retVal = ETrue;
	
	// initially test for arguments, the parse them, if not apply some sensible defaults.
	TBool	foundArgs = EFalse;	
		
	FOREVER
		{
		TPtrC  token=lex.NextToken();
		if(token.Length()!=0)
			{
			if ((token == _L("help")) || (token == _L("-h")) || (token == _L("-?")))
				{
				DBGS_PRINT((_L("\nUsage: [ single | multiple <numThreads>] [ dll | exe | self | complete ] [func | thread | global ] [ rom | base | mixed | mall ] [reaper] [chunks|echunks|chunks+ {nochunkdata}] [prio] [media] [lowmem] [forward | backward | random | all] [loadGlobal | loadThread | loadFunc] [interleave] [d_exc] [btrace] [defrag] [noclean] [min <pages>] [max <pages>] [stressfree] [iters <iters>]\n'-' indicated infinity.\n\n")));
				test.Getch();
				}
			else  if (token == _L("mmc"))
				{
				TestOnlyFromMmc = ETrue;
				}
			else  if (token == _L("min"))
				{
				TPtrC val=lex.NextToken();
				TLex lexv(val);
				TInt value;
				lexv.Val(value);
				TestMinCacheSize = value * 4096;
				}
			else  if (token == _L("max"))
				{
				TPtrC val=lex.NextToken();
				TLex lexv(val);
				TInt value;
				lexv.Val(value);
				TestMaxCacheSize = value * 4096;
				}
			else  if (token == _L("interleave"))
				{
				TestInterleave = ETrue;
				}
			else if (token == _L("auto"))
				{
				TestFullAutoTest = EFalse;
				retVal = EFalse;
				}
			else if (token == _L("stressfree"))
				{
				TestStressFree = !TestStressFree;
				retVal = EFalse;
				}
			else if (token == _L("fullauto"))
				{
				TestFullAutoTest = ETrue;
				retVal = EFalse;
				}
			else if (token == _L("prio"))
				{
				TestPrioChange = !TestPrioChange;
				}
			else if (token == _L("media"))
				{
				TestMediaAccess = KTestMediaAccessBasic;
				}
			else if (token == _L("reaper"))
				{
				TestReaper = ETrue;
				}
			else if (token == _L("btrace"))
				{
				TestBtrace = ETrue;
				}
			else if (token == _L("defrag"))
				{
				TestDefrag = ETrue;
				}
			else if (token == _L("echunks"))
				{
				TestChunks = ETrue;
				TestExtremeChunks = ETrue;
				}
			else if (token == _L("chunks+"))
				{
				TestChunks = ETrue;
				TestChunksPlus = ETrue;
				}
			else if (token == _L("chunks"))
				{
				TestChunks = ETrue;
				}
			else if (token == _L("nochunkdata"))
				{
				TestChunkData = EFalse;
				}
			else if (token == _L("lowmem"))
				{
				TestLowMem = ETrue;
				}
			else if (token == _L("dll"))
				{
				TestLoading = TEST_DLL;
				}
			else if (token == _L("exe"))
				{
				TestLoading = TEST_EXE;
				}
			else if (token == _L("self"))
				{
				TestLoading = TEST_SELF;
				}
			else if (token == _L("complete"))
				{
				TestLoading |= TEST_EXE_SELF_DLL;
				}
			else if (token == _L("rom"))
				{
				TestWhichMedia = TEST_MEDIA_ROM;
				}
			else if (token == _L("base"))
				{
				TestWhichMedia = TEST_MEDIA_BASE;
				}
			else if (token == _L("mixed"))
				{
				TestWhichMedia |= TEST_MEDIA_ROM_BASE;
				}
			else if (token == _L("all_media"))
				{
				TestWhichMedia |= TEST_MEDIA_ALL;
				}
			else if (token == _L("debug"))
				{
				if (!TestSilent)
					{
					TestDebug = ETrue;
					TestPrioChange = ETrue;
					}
				}
			else if (token == _L("silent"))
				{
				TestSilent = ETrue;
				TestDebug = EFalse;
				}
			else if (token == _L("noclean"))
				{
				TestNoClean = ETrue;
				}
			else if (token == _L("d_exc"))
				{
				TestD_Exc = ETrue;
				}
			else if (token == _L("global"))
				{
				TestLoadDllHow = TEST_DLL_GLOBAL;
				}	
			else if (token == _L("thread"))
				{
				TestLoadDllHow = TEST_DLL_THREAD;
				}	
			else if (token == _L("func"))
				{
				TestLoadDllHow = TEST_DLL_FUNC;
				}	
			else if (token == _L("single"))
				{
				TestSingle = ETrue;
				}
			else if (token == _L("multiple"))
				{
				TPtrC val=lex.NextToken();
				TLex lexv(val);
				TInt value;

				if (lexv.Val(value)==KErrNone)
					{
					if ((value <= 0) || (value > 100))
						{
						TestMultipleThreadCount = 10;
						}
					else
						{
						TestMultipleThreadCount = value;
						}
					}
				else
					{
					DBGS_PRINT((_L("Bad value for thread count '%S' was ignored.\n"), &val));
					retVal = EFalse;
					break;
					}
				TestMultiple = ETrue;
				}
			else if (token == _L("forward"))
				{
				TestWhichTests = TEST_FORWARD;
				}
			else if (token == _L("backward"))
				{
				TestWhichTests = TEST_BACKWARD;
				}
			else if (token == _L("random"))
				{
				TestWhichTests = TEST_RANDOM;
				}
			else if (token == _L("all"))
				{
				TestWhichTests = TEST_ALL;
				}
			else  if (token == _L("inst"))
				{
				TPtrC val=lex.NextToken();
				TLex lexv(val);
				TInt value;

				if (lexv.Val(value)==KErrNone)
					{
					TestInstanceId = value;
					}
				}
			else  if (token == _L("iters"))
				{
				TPtrC val=lex.NextToken();
				TLex lexv(val);
				TInt value;

				if (val==_L("-"))
					{
					TestMaxLoops = KMaxTInt;
					}
				else
					{
					if (lexv.Val(value)==KErrNone)
						{
						TestMaxLoops = value;
						}
					else
						{
						DBGS_PRINT((_L("Bad value for thread count '%S' was ignored.\n"), &val));
						retVal = EFalse;
						break;
						}
					}
				}
			else
				{
				if ((foundArgs == EFalse) && (token.Length() == 1))
					{
					// Single letter argument...only run on 'd'
					if (token.CompareF(_L("d")) == 0)
						{

						TestFullAutoTest = EFalse;
						TestIsAutomated = ETrue;
						break;
						}
					else
						{
						if (!TestSilent)
							{
							test.Title();
							test.Start(_L("Skipping non drive 'd' - Test Exiting."));
							test.End();
							}
						foundArgs = ETrue;
						TestExit = ETrue;
						break;
						}
					}
				DBGS_PRINT((_L("Unknown argument '%S' was ignored.\n"), &token));
				break;
				}
			foundArgs = ETrue;
			}
		else
			{
			break;
			}
		}
	if (!foundArgs)
		{
		retVal = EFalse;
		}
	return retVal;
	}

//
// AreWeTheTestBase
//
// Test whether we are the root of the tests.
//
void AreWeTheTestBase()
	{
	if (!TestSilent)
		{
		TFileName  filename(RProcess().FileName());

		TParse	myParse;
		myParse.Set(filename, NULL, NULL);
		TestNameBuffer.Zero();
		TestNameBuffer.Append(myParse.Name());
		TestNameBuffer.Append(_L(".exe"));

		TestWeAreTheTestBase = !TestNameBuffer.Compare(TestPlExeNames[KTestMediaBase]);

		RFs fs;
		if (KErrNone == fs.Connect())
			{
			TEntry  anEntry;
			TInt retVal = fs.Entry(_L("z:\\test\\mmcdemandpaginge32tests.bat"), anEntry);
			if (retVal == KErrNone)
				{
				TestBootedFromMmc = ETrue;
				}
			else
				{
				TestBootedFromMmc = EFalse;
				}
			fs.Close();
			}
		}
	else
		{
		TestNameBuffer.Zero();
		TestNameBuffer.Append(_L("t_pageldrtst.exe"));
		}
	}
#define  MEDNONE	KTestMediaAccessNone
#define MEDBASIC	KTestMediaAccessBasic
#define MEDMTHRE	KTestMediaAccessMultipleThreads
#define MEDMPATT	KTestMediaAccessMultiplePattern
#define MEDMIX		KTestMediaAccessMixed

TTheTests TheAutoTests[] =
	{// fullOnly,           loading,               media,  multi, loops, threads,         loadHow,  inter,   prio,    media,  whichTests, lowmem, free, testName
#ifdef TEST_SHORT_TEST
		{ EFalse,          TEST_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      24,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL Load (ALL Media) Multiple thread all."), },
#else
		{ EFalse,          TEST_DLL,     TEST_MEDIA_BASE,  ETrue,     5,      24,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_THRASH, EFalse,    0, }, //_L("DLL Load (ROM) Multiple thread Thrash."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     5,      20,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_ALL,    EFalse,    0, }, //_L("DLL Load (ROM/ROFS) Single thread all."), },
		{  ETrue,          TEST_EXE, TEST_MEDIA_ROM_BASE, EFalse,     5,      20,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_ALL,    EFalse,    0, }, //_L("Exe Load (ROM/ROFS) Single thread."), },
		{  ETrue,         TEST_SELF, TEST_MEDIA_ROM_BASE, EFalse,     5,      20,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_ALL,    EFalse,    0, }, //_L("Self Load (ROM/ROFS) Single thread."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     5,      20,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL Load (ROM/ROFS) Multiple thread all."), },
		{ EFalse,          TEST_DLL,      TEST_MEDIA_ALL,  ETrue,     3,      20,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL Load (ALL Media) Multiple thread all."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16,   TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads."), },
		{ EFalse, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16,   TEST_DLL_FUNC, EFalse,  ETrue,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with prio."), },
		{ EFalse, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      10,   TEST_DLL_FUNC, EFalse, EFalse, MEDBASIC, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with media access."), },
		{ EFalse, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      12,   TEST_DLL_FUNC, EFalse,  ETrue, MEDBASIC, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with media access and prio."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16, TEST_DLL_THREAD, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load thread (All Media) Multiple threads."), },
		{ EFalse, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16, TEST_DLL_THREAD, EFalse,  ETrue,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load thread (All Media) Multiple threads with prio."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      12, TEST_DLL_THREAD, EFalse,  ETrue, MEDBASIC, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load thread (All Media) Multiple threads with media access and prio."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16, TEST_DLL_GLOBAL, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load global (All Media) Multiple threads."), },
		{ EFalse, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16, TEST_DLL_GLOBAL, EFalse,  ETrue,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load global (All Media) Multiple threads with prio."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      12, TEST_DLL_GLOBAL, EFalse,  ETrue, MEDBASIC, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load global (All Media) Multiple threads with media access and prio."), },
		{ EFalse, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16,   TEST_DLL_FUNC,  ETrue, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with interleave."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16,   TEST_DLL_FUNC,  ETrue,  ETrue,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with interleave, prio."), },

		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      16,   TEST_DLL_FUNC,  ETrue,  ETrue, MEDBASIC, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with interleave, media and prio."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      12,   TEST_DLL_FUNC,  ETrue,  ETrue, MEDMTHRE, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with interleave, multi media and prio."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      12,   TEST_DLL_FUNC,  ETrue,  ETrue, MEDMPATT, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with interleave, media and prio."), },
		{  ETrue, TEST_EXE_SELF_DLL,      TEST_MEDIA_ALL,  ETrue,     2,      12,   TEST_DLL_FUNC,  ETrue,  ETrue,   MEDMIX, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load (All Media) Multiple threads with interleave, media and prio."), },
		{ EFalse, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     2,      10,   TEST_DLL_FUNC,  ETrue,  ETrue,   MEDMIX, TEST_RANDOM, EFalse,    0, }, //_L("DLL/EXE/SELF Load Multiple threads with interleave, media and prio."), },
#endif // TEST_SHORT_TEST
	};
#define NUM_AUTO_TESTS (TInt)(sizeof(TheAutoTests) / sizeof(TTheTests))

//
// PerformAutoTest
//
// The autotest.
//

void PerformAutoTest(TBool aReduceTime = EFalse)
	{
	TInt        testIndex;
	TTheTests  *pTest = &TheAutoTests[0];
	
	DoStats();

	for (testIndex = 0; testIndex < NUM_AUTO_TESTS; testIndex ++, pTest++)
		{
		if (   (   !TestWeAreTheTestBase 
			    && (   (pTest->testLoadDllHow != TEST_DLL_FUNC)
				    || !pTest->testMultiple))
			|| ((TestFullAutoTest == EFalse) && (pTest->testFullAutoOnly)))
			{
			continue;
			}
		
		TestLoading             = pTest->testLoading;
		TestWhichMedia          = pTest->testWhichMedia;
		TestMaxLoops            = aReduceTime ? 1 : pTest->testMaxLoops;
		TestMultipleThreadCount = aReduceTime ? 10 : pTest->testMultipleThreadCount;
		TestLoadDllHow          = pTest->testLoadDllHow;
		TestInterleave          = pTest->testInterleave;
		TestPrioChange          = pTest->testPrioChange;
		TestMediaAccess         = pTest->testMediaAccess;
		if (aReduceTime && (TestMediaAccess != MEDBASIC) && (TestMediaAccess != MEDNONE))
			{
			continue;
			}
		TestWhichTests          = pTest->testWhichTests;		
		TestingLowMem			= pTest->testLowMem;
		if (!TestSilent)
			{
			test.Next(_L("Auto Test"));
			}
		if (pTest->testMultiple)
			{
			RUNTEST(DoMultipleTest(ETrue), KErrNone);
			}
		else
			{
			RUNTEST(DoSingleTest(ETrue), KErrNone);
			}

		DoStats();

#ifdef TEST_KERN_HEAP
		__KHEAP_MARK;
		__KHEAP_CHECK(0);
		__KHEAP_MARKEND;
#endif
		}
#ifdef TEST_KERN_HEAP
	__KHEAP_MARK;
	__KHEAP_CHECK(0);
	__KHEAP_MARKEND;
#endif
	}

TTheTests TheLowMemTests[] =
	{// fullOnly,           loading,               media,  multi, loops, threads,       loadHow,  inter,   prio,    media,  whichTests, lowmem, free, testName
#ifndef TEST_SHORT_TEST
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Single thread with Low memory (init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE, EFalse,     5,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM,  ETrue,    0, }, //_L("Single thread with Low memory."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory (init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     2,      16, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory ."), },
		{ EFalse,          TEST_DLL, TEST_MEDIA_ALL,      EFalse,     5,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory and All media(init)."), },
		{ EFalse, TEST_EXE_SELF_DLL, TEST_MEDIA_ALL,       ETrue,     2,      12, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory and All media."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory, with starting free ram (init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     2,      16, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM,  ETrue,   32, }, //_L("Multiple thread with Low memory, with starting free ram."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,      16, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory and prio and media access(init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     2,      16, TEST_DLL_FUNC, EFalse,  ETrue, MEDBASIC, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory and prio and media access."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory interleave, prio and media access(init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     2,      16, TEST_DLL_FUNC,  ETrue,  ETrue, MEDBASIC, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory interleave, prio and media access."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory interleave, media access and All media (init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ALL,       ETrue,     2,      16, TEST_DLL_FUNC,  ETrue, EFalse, MEDBASIC, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory interleave, media access and All media + loading."), },
		{ EFalse,		   TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,    10,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Single thread with Low memory (init)."), },
		{ EFalse,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     5,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM,  ETrue,    0, }, //_L("Single thread with Low memory."), },
#endif //TEST_SHORT_TEST
		{ EFalse,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,    10,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory interleave, prio, media access and All media (init)."), },
		{ EFalse, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     2,      16, TEST_DLL_FUNC,  ETrue,  ETrue, MEDBASIC, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory interleave, prio, media access and All media + loading."), },
		{ EFalse,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     5,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory interleave, prio, media access and All media (init)."), },
		{ EFalse, TEST_EXE_SELF_DLL, TEST_MEDIA_ROM_BASE,  ETrue,     2,      10, TEST_DLL_FUNC,  ETrue,  ETrue, MEDMTHRE, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory interleave, prio, multi media access and All media + loading."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory interleave, prio, media access and All media (init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ALL,       ETrue,     2,      16, TEST_DLL_FUNC,  ETrue,  ETrue, MEDBASIC, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory interleave, prio, media access and All media + loading."), },
		{  ETrue,          TEST_DLL, TEST_MEDIA_ROM_BASE, EFalse,     1,       1, TEST_DLL_FUNC, EFalse, EFalse,  MEDNONE, TEST_RANDOM, EFalse,    0, }, //_L("Multiple thread with Low memory interleave, prio, media access and All media (init)."), },
		{  ETrue, TEST_EXE_SELF_DLL, TEST_MEDIA_ALL,       ETrue,     2,      16, TEST_DLL_FUNC,  ETrue,  ETrue, MEDMTHRE, TEST_RANDOM,  ETrue,    0, }, //_L("Multiple thread with Low memory interleave, prio, multi media access and All media + loading."), },

	};
#define NUM_LOWMEM_TESTS (TInt)(sizeof(TheLowMemTests) / sizeof(TTheTests))

//
// DoLowMemTest
//
// Low Memory Test
//
void DoLowMemTest(TBool aEnableAllMedia = EFalse)
	{
	TInt r = User::LoadLogicalDevice(KPageStressTestLddName);
	RUNTEST1(r==KErrNone || r==KErrAlreadyExists);
	RUNTEST(PagestressLdd.Open(),KErrNone);
	RUNTEST(PagestressLdd.DoSetDebugFlag((TInt)TestDebug),KErrNone);
	
	SVMCacheInfo  tempPages;
	memset(&tempPages, 0, sizeof(tempPages));
	if (TestIsDemandPaged)
		{
		// get the old cache info
		UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);
		TInt minSize = 8 * 4096;
		TInt maxSize = 256 * 4096;
		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);
		}

	TInt		testIndex;
	TTheTests  *pTest = &TheLowMemTests[0];
	for (testIndex = 0; testIndex < NUM_LOWMEM_TESTS; testIndex ++, pTest++)
		{
		if (   (!aEnableAllMedia && (pTest->testWhichMedia == TEST_MEDIA_ALL))
		    || ((TestFullAutoTest == EFalse) && (pTest->testFullAutoOnly)))
			{
			continue;
			}

		TestLoading             = pTest->testLoading;
		TestWhichMedia          = pTest->testWhichMedia;
		TestMaxLoops            = pTest->testMaxLoops;
		TestMultipleThreadCount = pTest->testMultipleThreadCount;
		TestLoadDllHow          = pTest->testLoadDllHow;
		TestInterleave          = pTest->testInterleave;
		TestPrioChange          = pTest->testPrioChange;
		TestMediaAccess         = pTest->testMediaAccess;
		TestWhichTests          = pTest->testWhichTests;		
		TestingLowMem			= pTest->testLowMem;
		if (!TestSilent)
			{
			test.Next(_L("Low Memory"));
			}
		if (pTest->testLowMem)
			{
			PagestressLdd.DoConsumeRamSetup(pTest->testFreeRam, TEST_LM_BLOCKSIZE);
			}

		if (pTest->testMultiple)
			{
			RUNTEST(DoMultipleTest(pTest->testLowMem), KErrNone);
			}
		else
			{
			RUNTEST(DoSingleTest(pTest->testLowMem), KErrNone);
			}

		if (pTest->testLowMem)
			{
			PagestressLdd.DoConsumeRamFinish();
			}

		DoStats();
#ifdef TEST_KERN_HEAP
		__KHEAP_MARK;
		__KHEAP_CHECK(0);
		__KHEAP_MARKEND;
#endif
		}

	if (!TestSilent)
		{
		test.Next(_L("Close test driver"));
		}
	PagestressLdd.Close();
	RUNTEST(User::FreeLogicalDevice(KPageStressTestLddName), KErrNone);

	if (TestIsDemandPaged)
		{
		TInt minSize = tempPages.iMinSize;
		TInt maxSize = tempPages.iMaxSize;
		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);
		}

#ifdef TEST_KERN_HEAP
	__KHEAP_MARK;
	__KHEAP_CHECK(0);
	__KHEAP_MARKEND;
#endif
	TestingLowMem = EFalse;

	}

//
// MultipleDefragThread
//
// Thread function, one created for each zone in a multiple thread test.
//

LOCAL_C TInt MultipleDefragThread(TAny* aUseTb)
	{
	TInt numZones = 1;
	TInt zoneId = (TInt)aUseTb;

	if (TestZoneCount > TEST_MAX_ZONE_THREADS)
		{
		numZones = TestZoneCount / TEST_MAX_ZONE_THREADS;
		}

	while (1)
		{
		TInt index = 0;
		TInt tempy = 0;
		for (; index < numZones; index ++)
			{
			User::AfterHighRes(TEST_MAX_ZONE_THREADS*TickPeriod/4);
			tempy = zoneId + (TEST_MAX_ZONE_THREADS * index);
			if (tempy < (TInt)TestZoneCount)
				{
				RamstressLdd.DoMovePagesInZone(tempy);
				}
			if (TestDefragTestEnd)
				break;
			}
		if (TestDefragTestEnd)
			break;
		}	
	return KErrNone;
	}

//
// DoDefragAutoTest
//
// Call the auto tests whilst defraging in the background.
//

void DoDefragAutoTest()
	{
	TUint	localZoneCount = TestZoneCount;
	if (TestZoneCount > TEST_MAX_ZONE_THREADS)
		{
		localZoneCount = TEST_MAX_ZONE_THREADS;
		}
	TInt			size =    (sizeof(RThread) * localZoneCount) 
							+ (sizeof(TInt) * localZoneCount);
	TUint8*			pBuf = (TUint8*)User::AllocZ(size);

	test(pBuf != NULL);
	RThread			*pTheThreads = (RThread*)pBuf;
	TInt			*pThreadInUse = (TInt*)(pTheThreads + localZoneCount);
	TInt			 ret;
	TUint			 index;
	for (index = 0; index < localZoneCount; index ++)
		{
		DBGS_PRINT((_L("%S : Starting Defrag Thread %d\n"), &TestNameBuffer, index));
		ret = pTheThreads[index].Create(KTestBlank,MultipleDefragThread,KDefaultStackSize,NULL,(TAny*) index);
		if (ret == KErrNone)
			{
			pTheThreads[index].Resume();
			pThreadInUse[index] = 1;
			}
		else
			{
			DBGS_PRINT((_L("%S : Starting Defrag Thread Failed %d\n"), &TestNameBuffer, index));
			}
		}

	// Do the full auto tests...
	PerformAutoTest(TestIsDemandPaged);

	TestDefragTestEnd = ETrue;
	RamstressLdd.DoSetEndFlag(1);
	TBool	anyUsed = ETrue;

	DBGS_PRINT((_L("%S : Waiting for Defrag Threads to exit...\n"), &TestNameBuffer));	
	TUint killNext = User::TickCount();
	while(anyUsed)
		{
		anyUsed = EFalse;
		
		// walk through the thread list to check which are still alive.
		for (index = 0; index < localZoneCount; index++)
			{
			if (pThreadInUse[index])
				{
				if (pTheThreads[index].ExitType() != EExitPending)
					{
					if (pTheThreads[index].ExitType() == EExitPanic)
						{
						DBGS_PRINT((_L("%S : Defrag Thread %d Panic'd\n"), &TestNameBuffer, index));	
						}
					else
						{
						DBGS_PRINT((_L("%S : Defrag Thread %d Exited\n"), &TestNameBuffer, index));	
						}
					pTheThreads[index].Close();
					pThreadInUse[index] = EFalse;
					}
				else
					{
					anyUsed = ETrue;
					TUint now = User::TickCount();
					TUint time = TUint((TUint64)(now-killNext)*(TUint64)TickPeriod/(TUint64)1000000);
					const TUint killTimeStep = (TEST_DOT_PERIOD+9)/10; // 1/10th of a dot
					if(time>TEST_DOT_PERIOD+killTimeStep)
						{
						killNext += killTimeStep*1000000/TickPeriod;
						DBGS_PRINT((_L("%S : killing Defrag Thread %d\n"), &TestNameBuffer, index));	
						pTheThreads[index].Kill(KErrNone);
						pTheThreads[index].Close();
						pThreadInUse[index] = EFalse;
						}
					}
				}
			}
		User::After(500000);
		}
	DBGS_PRINT((_L("%S : Defrag Threads exited...\n"), &TestNameBuffer));	
	RamstressLdd.DoSetEndFlag(0);
	User::Free(pBuf);
	}

//
// DoDefragTest
//
// Test the ram defrag code.
//

void DoDefragTest(void)
	{
	SVMCacheInfo  tempPages;
	memset(&tempPages, 0, sizeof(tempPages));

	test.Next(_L("Ram Defrag : Get the number of zones"));
	// first get the number of zones
	TInt ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneCount,&TestZoneCount,0);
	if(ret==KErrNotSupported)
		{
		test.Next(_L("TESTS NOT RUN - Ram Defrag appears to not be supported.\n"));
		return;
		}
	test(ret == KErrNone);
	test(TestZoneCount != 0);
	test.Printf(_L("RAM Zones (count=%u)\n"),TestZoneCount);

	// now get the config of each of the zones.
	TUint						index;
	struct SRamZoneConfig		config;
	struct SRamZoneUtilisation	util;
	test.Next(_L("Ram Defrag : Get info about the zones"));
	for (index = 0; index < TestZoneCount; index ++)
		{
		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)index, (TAny*)&config);
		test(ret == KErrNone);
		test.Printf(_L("config : id=%d index=%d base=0x%08x end=0x%08x pages=%d pref=%d flags=0x%x\n"),
					config.iZoneId,config.iZoneIndex,config.iPhysBase,config.iPhysEnd,config.iPhysPages, 
					config.iPref,config.iFlags);

		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&util);
		test(ret == KErrNone);
		test.Printf(_L("usage  : id=%d index=%d pages=%d free=%d unknown=%d fixed=%d move=%d discard=%d other=%d\n"),
					util.iZoneId,util.iZoneIndex,util.iPhysPages,util.iFreePages,
					util.iAllocUnknown,util.iAllocFixed,util.iAllocMovable,util.iAllocDiscardable,util.iAllocOther);
		}
	// Now test for zones out of range.
	test.Next(_L("Ram Defrag : test out of range indexes"));
	ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)(TestZoneCount + 1), (TAny*)&config);
	test(ret != KErrNone);
	ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)(TestZoneCount + 1), (TAny*)&util);
	test(ret != KErrNone);

	ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)-1, (TAny*)&config);
	test(ret != KErrNone);
	ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)-1, (TAny*)&util);
	test(ret != KErrNone);
	test.Next(_L("Ram Defrag : test out of range enums"));
	ret = UserSvr::HalFunction(EHalGroupRam,-1, 0, 0);
	test(ret != KErrNone);
	ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation + 1,0, 0);
	test(ret != KErrNone);

	TInt r = User::LoadLogicalDevice(KRamStressTestLddName);
	RUNTEST1(r==KErrNone || r==KErrAlreadyExists);
	RUNTEST(RamstressLdd.Open(),KErrNone);
	//TestDebug = ETrue;
	RUNTEST(RamstressLdd.DoSetDebugFlag((TInt)TestDebug),KErrNone);

	test.Next(_L("Ram Defrag : set VM cache to stress free..."));

	if (TestIsDemandPaged)
		{
		// get the old cache info
		UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);

		TInt minSize = 512 * 4096;
		TInt maxSize = 32767 * 4096;
		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);
		}

	test.Next(_L("Ram Defrag : move all pages in all zone in 1 thread..."));

	for (index = 0; index < TestZoneCount; index ++)
		{
		test.Printf(_L("Ram Defrag : moving pages in zone %u\n"),index);
		ret = RamstressLdd.DoMovePagesInZone(index);
		if (ret != KErrNone)
			{
			test.Printf(_L("Ram Defrag : moving pages in zone failed %u err=%d\n"), index, ret);
			}
		}


	test.Next(_L("Ram Defrag : Get info after test"));
	for (index = 0; index < TestZoneCount; index ++)
		{
		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&util);
		test(ret == KErrNone);
		test.Printf(_L("usage  : id=%d index=%d pages=%d free=%d unknown=%d fixed=%d move=%d discard=%d other=%d\n"),
					util.iZoneId,util.iZoneIndex,util.iPhysPages,util.iFreePages,
					util.iAllocUnknown,util.iAllocFixed,util.iAllocMovable,util.iAllocDiscardable,util.iAllocOther);
		}

	test.Next(_L("Ram Defrag : Page moving on multiple threads with auto test running."));

	TestingDefrag = ETrue;
	TestDefragTestEnd = EFalse;

	DoDefragAutoTest();
	TestingDefrag = EFalse;
	/*
	 * End of test cleanup.
	 */

	test.Next(_L("Ram Defrag : reset VM cache back to stressed."));
	if (TestIsDemandPaged)
		{
		TInt minSize = tempPages.iMinSize;
		TInt maxSize = tempPages.iMaxSize;
		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);
		}
	RamstressLdd.Close();
	test.Next(_L("Ram Defrag : Done"));
	}

//
// PerformExceptionThread
//
// Generate a Panic
//

LOCAL_C TInt PerformExceptionThread(TAny* )
	{
	User::AfterHighRes(1000000);
	// this line will cause a Kern::Exec 0 !!!
	test.Printf(_L("Hello World\n"));

	return KErrNone;
	}

//
// DoExceptionInAnotherThread
//
// Test the d_exc and minkda functionality with faulting processes.
//

void DoExceptionInAnotherThread(void)
	{
	TRequestStatus	theStatus;
	RThread			theThread;
	
	TInt ret = theThread.Create(KTestBlank,PerformExceptionThread,KDefaultStackSize,NULL,NULL);
	test(ret == KErrNone);
	theThread.Logon(theStatus);
	RUNTEST1(theStatus == KRequestPending);	
	theThread.Resume();
	theThread.Close();
	User::WaitForRequest(theStatus);
	}

//
// DoTestD_Exc
//
// Test the d_exc and minkda functionality with faulting processes.
//

TInt DoTestD_Exc()
	{
	if (!TestSilent)
		{
		test.Next(_L("DoTestD_Exc : d_exc check test."));
		}
	DBGS_PRINT((_L("%S : DoTestD_Exc start...\n"), &TestNameBuffer));	
	// first we need to spawn d_exc.exe
	RProcess dexcProcess;
	TInt ret = dexcProcess.Create(_L("d_exc.exe"),_L("-b"));
	RUNTEST1(KErrNone == ret);
	TRequestStatus dexcStatus;
	dexcProcess.Logon(dexcStatus);
	RUNTEST1(dexcStatus == KRequestPending);	
	dexcProcess.Resume();

	DBGS_PRINT((_L("%S : DoTestD_Exc started d_exc.exe\n"), &TestNameBuffer));	

	DoExceptionInAnotherThread();

	DBGS_PRINT((_L("%S : DoTestD_Exc test completed\n"), &TestNameBuffer));	
	// check that d_exc and minkda don't die!
	RUNTEST1(dexcProcess.ExitType() == EExitPending);

	DBGS_PRINT((_L("%S : DoTestD_Exc d_exc still running\n"), &TestNameBuffer));	
	
	// kill off d_exc!
	dexcProcess.Kill(KErrNone);
	dexcProcess.Close();
	User::WaitForRequest(dexcStatus);
	DBGS_PRINT((_L("%S : DoTestD_Exc d_exc killed and exiting\n"), &TestNameBuffer));	
	return KErrNone;
	}

/**
	Get name of the hash file used for an EXE or DLL which has been
	copied to writable media.

	@param	aOrigName		Name of EXE or DLL which has been copied to
							writable media.  This does not have to be
							qualified because only the name and extension
							are used.
	@param	aHashName		On return this is set to the absolute filename
							which should contain the file's hash.  This
							function does not create the file, or its containing
							directory.
 */

static void GetHashFileName(const TDesC& aOrigName, TDes& aHashName)
	{
	aHashName.Copy(KSysHash);
	aHashName[0] = (TUint8) RFs::GetSystemDriveChar();
	const TParsePtrC ppc(aOrigName);
	aHashName.Append(ppc.NameAndExt());
	}

//
// HashFile
// take hash of files require full drive:/path/name.ext
//

void HashFile(const TDesC& aFileName, RFs& aFs)
	{
	CSHA1* sha1 = CSHA1::NewL();
	CleanupStack::PushL(sha1);
	
	TBuf<50> hashfile;
	hashfile = KSysHash;
	hashfile[0] = (TUint8) RFs::GetSystemDriveChar();
	
	TInt r = aFs.MkDirAll(hashfile);
	RUNTEST1(r==KErrNone || r==KErrAlreadyExists);

	RFile fDest;
	r = fDest.Open(aFs, aFileName, EFileRead | EFileStream);
	if (r != KErrNone)
		{
		if (TestingReaper && (r == KErrInUse))
			{
			TBool whinged = EFalse;
			while (r == KErrInUse)
				{
				User::After(2000000);
				if (!whinged)
					{
					DBGS_PRINT((_L("HashFile() retrying Open for %S (%d)\n"), &aFileName, r));
					whinged = ETrue;
					}
				r = fDest.Open(aFs, aFileName, EFileRead | EFileStream);
				}

			}
		else
			{
			DBGS_PRINT((_L("fDest.Open returned %d\n"), r));
			}
		}
	User::LeaveIfError(r);
	CleanupClosePushL(fDest);

	TBool done;
	TBuf8<512> content;
	do
		{
		r = fDest.Read(content);
		if (r!=KErrNone)
			DBGS_PRINT((_L("fDest.Read returned %d\n"), r));	
		User::LeaveIfError(r);
		done = (content.Length() == 0);
		if (! done)
			sha1->Update(content);
		} while (! done);
	CleanupStack::PopAndDestroy(&fDest);

	// write hash to \sys\hash
	TBuf8<SHA1_HASH> hashVal = sha1->Final();

	TFileName fnSrc(aFileName);
	GetHashFileName(aFileName, fnSrc);
	RFile fHash;
	r = fHash.Replace(aFs, fnSrc, EFileWrite | EFileStream);
	if (r != KErrNone)
		DBGS_PRINT((_L("fHash.Replace returned %d\n"), r));
	User::LeaveIfError(r);
	CleanupClosePushL(fHash);
	r = fHash.Write(hashVal);
	if (r != KErrNone)
		DBGS_PRINT((_L("fHash.Write returned %d\n"), r));
	User::LeaveIfError(r);

	CleanupStack::PopAndDestroy(2, sha1);
	}

//
// CopyFileToMMc
//
// Copy a file to the MMC card and create a hash of it.
//

TInt CopyFileToMMc(RFs& aFs,CFileMan* aFileMan, TPtrC aPath, TPtrC  aOldFilename, TPtrC  aNewFilename)
	{
	TInt retVal = aFs.MkDirAll(aPath);
	RUNTEST1(retVal==KErrNone || retVal==KErrAlreadyExists);

	TFileName newPath;
	TFileName oldPath;

	oldPath.Format(_L("%S%S"),&KRomPath, &aOldFilename);
	newPath.Format(_L("%S%S"),&aPath, &aNewFilename);
	DBGD_PRINT((_L("Copying %S to %S\n"), &oldPath, &newPath));
	retVal = aFileMan->Copy(oldPath, newPath, CFileMan::EOverWrite);
	if (retVal == KErrNone)
		{
		retVal = aFileMan->Attribs(newPath, KEntryAttNormal, KEntryAttReadOnly, 0);
		if (retVal != KErrNone)
			{
			DBGS_PRINT((_L("%S :   Attribs failed (%d)\n"), &newPath, retVal));
			}
		TEntry  anEntry;
		retVal = aFs.Entry(newPath, anEntry);
		if (retVal != KErrNone)
			{
			DBGS_PRINT((_L("%S : aFs.Entry failed (%d)\n"), &newPath, retVal));
			}
		TRAPD(r, HashFile(newPath, aFs));
		RUNTEST1(r == KErrNone);
		}
	else
		DBGS_PRINT((_L("Failed to copy file %d\n"), retVal));
	DBGD_PRINT((_L("%S : now %S (%d)\n"), &newPath, EXISTS(retVal), retVal));
	return retVal;
	}

//
// CopyAndFragmentFiles
//
// Copy the test files to a specified location edeavouring to fragment as much as possible.
//

TBool CopyAndFragmentFiles(RFs& aFs,CFileMan* aFileMan, TPtrC aPath, ETestMediaType aMediaType)
	{
	TInt retVal = aFs.MkDirAll(aPath);
	RUNTEST1(retVal==KErrNone || retVal==KErrAlreadyExists);
#define FILECOUNTMAX (PAGELDRTST_MAX_DLLS + 2)
	RFile	theInFiles[FILECOUNTMAX];
	RFile	theOutFiles[FILECOUNTMAX];
	TInt	inFileSize[FILECOUNTMAX];
	TInt	inFilePos[FILECOUNTMAX];
	TBool	fileOk[FILECOUNTMAX];

	TInt	  index;
	TFileName newPath;
	TFileName oldPath;

	for (index = 0; index < FILECOUNTMAX; index ++)
		{
		inFileSize[index] = 0;
		inFilePos[index] = 0;
		fileOk[index] = EFalse;

		if (index < PAGELDRTST_MAX_DLLS)
			{
			oldPath.Format(_L("%S%S%d%S"), &KRomPath, &KDllBaseName, index, &TestPlExtNames[KTestMediaBase]);
			newPath.Format(_L("%S%S%d%S"), &aPath, &KDllBaseName, index, &TestPlExtNames[aMediaType]);
			}
		else if (index < (PAGELDRTST_MAX_DLLS + 1))
			{
			oldPath.Format(_L("%S%S"), &KRomPath, &TestPsExeNames[KTestMediaBase]);
			newPath.Format(_L("%S%S"), &aPath, &TestPsExeNames[aMediaType]);
			}
		else
			{
			oldPath.Format(_L("%S%S"), &KRomPath, &TestPlExeNames[KTestMediaBase]);
			newPath.Format(_L("%S%S"), &aPath, &TestPlExeNames[aMediaType]);
			}

		retVal = theInFiles[index].Open(aFs, oldPath, EFileRead);
		if (retVal != KErrNone)
			{
			DBGS_PRINT((_L("%S : Failed to open for read (%d)\n"), &oldPath, retVal));
			break;
			}
		retVal = theInFiles[index].Size(inFileSize[index]);
		if (retVal != KErrNone)
			{
			theInFiles[index].Close();
			DBGS_PRINT((_L("%S : Failed to get file size (%d)\n"), &newPath, retVal));
			break;
			}
		retVal = theOutFiles[index].Replace(aFs, newPath, EFileWrite);
		if (retVal != KErrNone)
			{
			theInFiles[index].Close();
			DBGS_PRINT((_L("%S : Failed to open for write (%d)\n"), &newPath, retVal));
			break;
			}

		fileOk[index] = ETrue;
		}

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

	do
		{
		stillGoing = EFalse;
		for (index = 0; index < FILECOUNTMAX; index ++)
			{
			if (!fileOk[index])
				break;
			if (inFilePos[index] < inFileSize[index])
				{
				retVal = theInFiles[index].Read(buffer);
				if (retVal != KErrNone)
					{
					DBGS_PRINT((_L("theInFiles[%d] read failed (%d)\n"), index, retVal));
					break;
					}
				retVal = theOutFiles[index].Write(buffer);
				if (retVal != KErrNone)
					{
					DBGS_PRINT((_L("theOutFiles[%d] Write failed (%d)\n"), index, retVal));
					break;
					}
				retVal = theOutFiles[index].Flush();
				if (retVal != KErrNone)
					{
					DBGS_PRINT((_L("theOutFiles[%d] flush failed (%d)\n"), index, retVal));
					break;
					}
				inFilePos[index] += buffer.Length();
				if (inFilePos[index] < inFileSize[index])
					stillGoing = ETrue;
				}
			}
		}
	while (stillGoing);

	TBool allOk = retVal == KErrNone;
	for (index = 0; index < FILECOUNTMAX; index ++)
		{
		if (!fileOk[index])
			{
			allOk = EFalse;
			break;
			}
		theInFiles[index].Close();
		theOutFiles[index].Close();
		if (index < PAGELDRTST_MAX_DLLS)
			{
			newPath.Format(_L("%S%S%d%S"), &aPath, &KDllBaseName, index, &TestPlExtNames[aMediaType]);
			}
		else if (index < (PAGELDRTST_MAX_DLLS + 1))
			{
			newPath.Format(_L("%S%S"), &aPath, &TestPsExeNames[aMediaType]);
			}
		else
			{
			newPath.Format(_L("%S%S"), &aPath, &TestPlExeNames[aMediaType]);
			}

		retVal = aFileMan->Attribs(newPath, KEntryAttNormal, KEntryAttReadOnly, 0);
		if (retVal != KErrNone)
			{
			DBGS_PRINT((_L("%S : Attribs failed (%d)\n"), &newPath, retVal));
			allOk = EFalse;
			}
		TEntry  anEntry;
		retVal = aFs.Entry(newPath, anEntry);
		if (retVal != KErrNone)
			{
			DBGS_PRINT((_L("%S : aFs.Entry failed (%d)\n"), &newPath, retVal));
			allOk = EFalse;
			}
		TRAPD(r, HashFile(newPath, aFs));
		if (r != KErrNone)
			{
			allOk = EFalse;
			}
		DBGD_PRINT((_L("%S : %S!\n"), &newPath, EXISTS(!allOk)));
		}
	return allOk;
	}

//
// CheckFilePresence
//
// Checks all the files required for the test are present and copies some tests to the MMC card
//

void CheckFilePresence(TBool aDoFileCopy)
	{
	TUint start = User::TickCount();

	RFs fs;
	if (KErrNone != fs.Connect())
		{
		DBGS_PRINT(_L("CheckFilePresence : Can't connect to the FS\n"));
		return ;
		}

	TFileName filename;
	TFileName newFilename;
	TEntry anEntry;
	TInt   index;
	TInt   retVal;
	TInt   dllIndex;

	// now we need to add the MMC files
	TInt drvNum = FindMMCDriveNumber(fs);
	TBuf<32>	mmcPath;
	mmcPath.Format(_L("%S"),&KMmcDefaultPath);
	if (drvNum >= 0)
		mmcPath[0] = 'a' + drvNum;

	TBool	allOk;
	//TInt  indexMax = aDoFileCopy ? KTestMediaMmc : KTestMediaCOUNT; 
	for (index = 0; index < TEST_MEDIA_COUNT_HACK; index ++)
		{
		allOk = ETrue;	
		filename.Format(_L("%S%S"),(index == KTestMediaMmc) ? & mmcPath : &KRomPath, &TestPsExeNames[index]);
		if (KErrNone != fs.Entry(filename, anEntry))
			allOk = EFalse;

		filename.Format(_L("%S%S"),(index == KTestMediaMmc) ? & mmcPath : &KRomPath, &TestPlExeNames[index]);
		if (KErrNone != fs.Entry(filename, anEntry))
			allOk = EFalse;

		for (dllIndex = 0; dllIndex < PAGELDRTST_MAX_DLLS; dllIndex ++)
			{
			filename.Format(_L("%S%S%d%S"), (index == KTestMediaMmc) ? & mmcPath : &KRomPath, &KDllBaseName, dllIndex, &TestPlExtNames[index]);
			if (KErrNone != fs.Entry(filename, anEntry))
				allOk = EFalse;
			}
		TestDllExesExist[index] = allOk;
		DBGS_PRINT((_L("%S : %S!\n"), &TestPsExeNames[index], EXISTS(!TestDllExesExist[index])));
		}
	TInt nandDrvNum = FindFsNANDDrive(fs);
	if (aDoFileCopy && (drvNum >= 0) && (nandDrvNum >= 0))
		{
		CTrapCleanup* cleanupStack = CTrapCleanup::New();
		if(!cleanupStack)
			DBGS_PRINT((_L("Cleanup stack failed\n")));	
		CFileMan* pFileMan = NULL;
		TRAP(retVal, pFileMan = CFileMan::NewL(fs));
	
		// First make a clean copy of the DLLs to the MMC card.
		allOk = ETrue;			
		if (KErrNone != CopyFileToMMc(fs, pFileMan, mmcPath, TestPsExeNames[KTestMediaBase], TestPsExeNames[KTestMediaMmc]))
			allOk = EFalse;
		if (KErrNone != CopyFileToMMc(fs, pFileMan, mmcPath, TestPlExeNames[KTestMediaBase], TestPlExeNames[KTestMediaMmc]))
			allOk = EFalse;
		for (dllIndex = 0; dllIndex < PAGELDRTST_MAX_DLLS; dllIndex ++)
			{
			filename.Format(_L("%S%d%S"), &KDllBaseName, dllIndex, &TestPlExtNames[KTestMediaBase]);
			newFilename.Format(_L("%S%d%S"), &KDllBaseName, dllIndex, &TestPlExtNames[KTestMediaMmc]);
			if (KErrNone != CopyFileToMMc(fs, pFileMan, mmcPath, filename, newFilename))
				allOk = EFalse;
			}
		TestDllExesExist[KTestMediaMmc] = allOk;
		DBGS_PRINT((_L("%S : %S! (Drive %c)\n"), &TestPsExeNames[index], EXISTS(!TestDllExesExist[index]), mmcPath[0]));
#ifdef TEST_ADD_FRAGD_MEDIA
		//now make some fragmented files on the MMC card.
		TestDllExesExist[KTestMediaMmcFrag] = CopyAndFragmentFiles(fs, pFileMan, mmcPath, KTestMediaMmcFrag);
		DBGS_PRINT((_L("%S : %S! (Drive %c)\n"), &TestPsExeNames[KTestMediaMmcFrag], EXISTS(!TestDllExesExist[KTestMediaMmcFrag]), mmcPath[0]));

		//now make some fragmented files on the NAND card.
		if (nandDrvNum >= 0)
			{
			mmcPath[0] = 'a' + nandDrvNum;
			TestDllExesExist[KTestMediaNandFrag] = CopyAndFragmentFiles(fs, pFileMan, mmcPath, KTestMediaNandFrag);
			DBGS_PRINT((_L("%S : %S! (Drive %c)\n"), &TestPsExeNames[KTestMediaNandFrag], EXISTS(!TestDllExesExist[KTestMediaNandFrag]), mmcPath[0]));
			}
		else
			DBGS_PRINT((_L("CheckFilePresence : Failed to get NAND drive number\n")));
#endif // TEST_ADD_FRAGD_MEDIA
		delete pFileMan; pFileMan = NULL;
		delete cleanupStack; cleanupStack = NULL;
		}

	fs.Close();

	TUint end = User::TickCount();
	TUint time = TUint((TUint64)(end-start)*(TUint64)TickPeriod/(TUint64)1000000);
	DBGS_PRINT((_L("CheckFilePresence : %d secs elapsed\n"), time));
	}

//
// DoDeleteFile
//
// Delete a file and remove the hash
//

void DoDeleteFile(CFileMan* aFileMan, TBool aSilent,TFileName& aFileName )
	{
	TFileName hashName;
	RLoader l;
	test(l.Connect() == KErrNone);

	DBGD_PRINT((_L("Deleting %S ...\n"), &aFileName));
	if (!aSilent)
		DBGD_PRINT((_L("Deleting %S\n"), &aFileName));
	TInt retVal = aFileMan->Delete(aFileName);
	if (retVal != KErrNone)
		{
		if (TestingReaper)
			{
			aFileMan->Attribs(aFileName, KEntryAttNormal, KEntryAttReadOnly, 0);
			retVal = l.Delete(aFileName);
			if (retVal != KErrNone)
				{
				DBGS_PRINT((_L("RLoader::Delete %S Failed %d\n"), &aFileName, retVal));
				}
			}
		else
			{
			if (!aSilent)
				DBGS_PRINT((_L("Deleting %S Failed %d\n"), &aFileName, retVal));
			}
		}
	GetHashFileName(aFileName, hashName);
	retVal = aFileMan->Delete(hashName);
	if (retVal != KErrNone)
		{
		if (TestingReaper && (retVal == KErrInUse))
			{
			retVal = l.Delete(hashName);
			if (retVal != KErrNone)
				{
				DBGS_PRINT((_L("RLoader::Delete %S Failed %d\n"), &hashName, retVal));
				}
			}
		else
			{
			if (!aSilent)
				DBGS_PRINT((_L("Deleting %S Failed %d\n"), &hashName, retVal));
			}
		}
	l.Close();
	}

//
// CleanupFiles
//
// Remove any copied files and created directories.
//

void CleanupFiles(TBool silent)
	{
	TUint start = User::TickCount();

	RFs fs;
	if (KErrNone != fs.Connect())
		{
		DBGS_PRINT(_L("CleanupFiles : Can't connect to the FS\n"));
		return ;
		}

	CTrapCleanup* cleanupStack = CTrapCleanup::New();
	if(!cleanupStack)
		if (!silent)
			DBGS_PRINT((_L("Cleanup stack failed\n")));	
	
	CFileMan* pFileMan = NULL;
	TInt retVal;
	TRAP(retVal, pFileMan = CFileMan::NewL(fs));
	
	TFileName newPath;
	TInt index;
	TInt dllIndex;

	TBuf<32>	path;
	path.Format(_L("%S"),&KMmcDefaultPath);
	TInt mmcDrvNum = FindMMCDriveNumber(fs);
	TInt nandDrvNum = FindFsNANDDrive(fs);
	for (index = KTestMediaMmc; index < KTestMediaCOUNT; index ++)
		{
#ifdef TEST_ADD_FRAGD_MEDIA
		if (index == KTestMediaNandFrag)
			{
			if (nandDrvNum < 0)
				continue;
			path[0] = 'a' + nandDrvNum;
			}
		else
			{
			if (mmcDrvNum < 0)
				continue;
			path[0] = 'a' + mmcDrvNum;
			}
#else
		path[0] = 'a' + mmcDrvNum;
#endif
		newPath.Format(_L("%S%S"),&path, &TestPsExeNames[index]);
		DoDeleteFile(pFileMan, silent,  newPath);

		newPath.Format(_L("%S%S"),&path, &TestPlExeNames[index]);
		DoDeleteFile(pFileMan, silent,  newPath);
		
		for (dllIndex = 0; dllIndex < PAGELDRTST_MAX_DLLS; dllIndex ++)
			{
			newPath.Format(_L("%S%S%d%S"), &path, &KDllBaseName, dllIndex, &TestPlExtNames[index]);
			DoDeleteFile(pFileMan, silent,  newPath);
			}
		}
	if (nandDrvNum >= 0)
		{
		path[0] = 'a' + nandDrvNum;
		fs.RmDir(path);
		}
	if (mmcDrvNum >= 0)
		{
		path[0] = 'a' + mmcDrvNum;
		fs.RmDir(path);
		}

	delete pFileMan; pFileMan = NULL;
	delete cleanupStack; cleanupStack = NULL;
	fs.Close();
	TUint end = User::TickCount();
	TUint time = TUint((TUint64)(end-start)*(TUint64)TickPeriod/(TUint64)1000000);
	DBGS_PRINT((_L("CleanupFiles : %d secs elapsed\n"), time));
	}

#ifdef _DEBUG

//
// FindLocalDriveNumber
//
// Find the local drive
//

TInt FindLocalDriveNumber(RFs &aFs, TInt aFsDrvNum)
	{
	RFile file;
	TBuf<256> fileName;	
	fileName.Append((TChar)('A' + aFsDrvNum));
	fileName+=_L(":\\f32-tst\\");
	TInt r=aFs.MkDirAll(fileName);
	TInt locDriveNumber = -1;
	if (r==KErrNone || r== KErrAlreadyExists)
		{
		fileName += _L("tempy.txt");
		r=file.Replace(aFs,fileName,EFileWrite);
		if (r!=KErrNone)
			DBGS_PRINT((_L("FindLocalDriveNumber : Error %d: file '%S' could not be created\n"),r,&fileName));
		RUNTEST1(r==KErrNone);
		r=file.Write(_L8("Flies as big as sparrows indoletly buzzing in the warm air, heavy with the stench of rotting carcasses"));
		if (r!=KErrNone)
			{
			DBGS_PRINT((_L("FindLocalDriveNumber : Error %d: could not write to file %d (%S)\n"),r,aFsDrvNum, &fileName));
			}
		else
			{
			// write caching may be enabled to flush the cache...
			TRequestStatus flushStatus;
			file.Flush(flushStatus);
			User::WaitForRequest(flushStatus);
			// get the block map
			SBlockMapInfo info;
			TInt64 start=0;
			r=file.BlockMap(info, start, -1,ETestDebug);
			if (r==KErrNone || r==KErrCompletion)
				{
				locDriveNumber=info.iLocalDriveNumber;
				DBGD_PRINT((_L("FindLocalDriveNumber : locDriveNumber  %d\n"), locDriveNumber));
				}
			else
				DBGS_PRINT((_L("FindLocalDriveNumber : Error %d: error getting blockmap for drive %d (%S)\n"),r,aFsDrvNum, &fileName));
			}
		aFs.Delete(fileName);
		file.Close();
		}
	else
		DBGS_PRINT((_L("FindLocalDriveNumber : Error %d: error creating dir	\n"),r));
	return locDriveNumber;
	}

//
// ResetConcurrencyStats
//
// Reset the stats
//

void ResetConcurrencyStats(RFs& aFs)
	{
	if(TestBootedFromMmc)
		{
		TInt fsDriveNum = FindMMCDriveNumber(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);
			if (locDriveNumber >= 0)
				{
				RUNTEST(PagingInfo::ResetConcurrency(locDriveNumber,EMediaPagingStatsRomAndCode),KErrNone);
				}
			else
				DBGS_PRINT((_L("ResetConcurrencyStats MMC : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("ResetConcurrencyStats MMC : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	else
		{
		TInt fsDriveNum = FindFsNANDDrive(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);
			if (locDriveNumber >= 0)
				{
				RUNTEST(PagingInfo::ResetConcurrency(locDriveNumber,EMediaPagingStatsRomAndCode),KErrNone);
				}
			else
				DBGS_PRINT((_L("ResetConcurrencyStats NAND : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("ResetConcurrencyStats NAND : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	}

//
// ResetBenchmarks
//
// Reset the stats
//

void ResetBenchmarks(RFs& aFs)
	{
	if(TestBootedFromMmc)
		{
		TInt fsDriveNum = FindMMCDriveNumber(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);
			if (locDriveNumber >= 0)
				{
				RUNTEST(PagingInfo::ResetBenchmarks(locDriveNumber,EMediaPagingStatsRomAndCode),KErrNone);
				}
			else
				DBGS_PRINT((_L("ResetBenchmarks MMC : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("ResetBenchmarks MMC : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	else
		{
		TInt fsDriveNum = FindFsNANDDrive(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);
			if (locDriveNumber >= 0)
				{
				RUNTEST(PagingInfo::ResetBenchmarks(locDriveNumber,EMediaPagingStatsRomAndCode),KErrNone);
				}
			else
				DBGS_PRINT((_L("ResetBenchmarks NAND : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("ResetBenchmarks NAND : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	}

//
// DisplayConcurrencyStats
//
// Display the stats
//

void DisplayConcurrencyStats(RFs& aFs)
	{
	if(TestBootedFromMmc)
		{
		TInt fsDriveNum = FindMMCDriveNumber(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);
			if (locDriveNumber >= 0)
				{
				DBGS_PRINT((_L("MMC stats\n")));
				RUNTEST1(PagingInfo::PrintConcurrency(locDriveNumber,EMediaPagingStatsRomAndCode)==KErrNone);
				}
			else
				DBGS_PRINT((_L("DisplayConcurrencyStats MMC : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("DisplayConcurrencyStats MMC : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	else
		{
		TInt fsDriveNum = FindFsNANDDrive(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);

			if (locDriveNumber >= 0)
				{
				DBGS_PRINT((_L("NAND stats\n")));
				RUNTEST1(PagingInfo::PrintConcurrency(locDriveNumber,EMediaPagingStatsRomAndCode)==KErrNone);
				}
			else
				DBGS_PRINT((_L("DisplayConcurrencyStats NAND : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("DisplayConcurrencyStats NAND : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	}

void DisplayBenchmarks(RFs& aFs)
	{
	if(TestBootedFromMmc)
		{
		TInt fsDriveNum = FindMMCDriveNumber(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);
			if(locDriveNumber>=0)
				{
				DBGS_PRINT((_L("MMC benchmarks\n")));
				RUNTEST1(PagingInfo::PrintBenchmarks(locDriveNumber,EMediaPagingStatsRomAndCode)==KErrNone);
				}
			else
				DBGS_PRINT((_L("DisplayBenchmarks MMC : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("DisplayBenchmarks MMC : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	else
		{
		TInt fsDriveNum = FindFsNANDDrive(aFs);
		if (fsDriveNum >= 0)
			{
			TInt locDriveNumber = FindLocalDriveNumber(aFs, fsDriveNum);
			if(locDriveNumber>=0)
				{
				DBGS_PRINT((_L("NAND benchmarks\n")));
				RUNTEST1(PagingInfo::PrintBenchmarks(locDriveNumber,EMediaPagingStatsRomAndCode)==KErrNone);
				}
			else
				DBGS_PRINT((_L("DisplayBenchmarks NAND : Failed to get locDriveNumber %d (%d)\n"), locDriveNumber, fsDriveNum));
			}
		else
			DBGS_PRINT((_L("DisplayBenchmarks NAND : Failed to get fsDriveNum %d\n"), fsDriveNum));
		}
	}

#endif

void DoStats()
	{
	if (TestIsDemandPaged)
		{
		SVMCacheInfo  tempPages;
		UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);
		DBGS_PRINT((_L("DPC : min %d max %d curr %d\n"), 
					tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize));
		DBGS_PRINT((_L("    : maxFree %d freeRam %d\n"),
					tempPages.iMaxFreeSize, FreeRam()));
		}

#ifdef _DEBUG
	if (TestWeAreTheTestBase && !TestSilent)
		{
		RFs fs;
		if (KErrNone != fs.Connect())
			{
			DBGS_PRINT(_L("ResetConcurrencyStats : Can't connect to the FS\n"));
			return;
			}

#ifndef TEST_MINIMAL_STATS
		DisplayConcurrencyStats(fs);
		DisplayBenchmarks(fs);
#endif
#ifndef TEST_DONT_RESET_STATS
		ResetConcurrencyStats(fs);
		ResetBenchmarks(fs);
#endif
		fs.Close();
		}
#endif
	}


//
// E32Main
//
// Main entry point.
//

TInt E32Main()
	{
	COMPLETE_POST_BOOT_SYSTEM_TASKS();
#ifndef TEST_ON_UNPAGED
	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();
	if(!romHeader->iPageableRomStart)
		{
		TestIsDemandPaged = EFalse;
		}
#endif
	HAL::Get(HAL::ESystemTickPeriod, TickPeriod);

	SVMCacheInfo  tempPages;
	memset(&tempPages, 0, sizeof(tempPages));

	TBool parseResult = ParseCommandLine();

	if (TestExit)
		{
		return KErrNone;
		}

	TUint start = User::TickCount();
	
	AreWeTheTestBase();	

	if (TestIsDemandPaged)
		{
		TInt  minSize = TestMinCacheSize;
		TInt  maxSize = TestMaxCacheSize;

		SVMCacheInfo  tempPages;

		// get the old cache info
		UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&tempPages,0);
		// set the cache to our test value
		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);
		}
	if (!TestSilent)
		{
		test.Title();
		test.Start(_L("Demand Paging loader stress tests..."));
		test.Printf(_L("%S (%d)\n"), &TestNameBuffer, TestWeAreTheTestBase);
		test.Printf(_L("TestBootedFromMmc %d\n"), TestBootedFromMmc);

		if (TestWeAreTheTestBase)
			CleanupFiles(ETrue);

		CheckFilePresence(TestWeAreTheTestBase);
		}

	if (parseResult)
		{
		if (TestLowMem)
			{
			DoLowMemTest(ETrue);
			}
		if (TestSingle)
			{
			RUNTEST(DoSingleTest(),KErrNone);
			}
		if (TestMultiple)
			{
			RUNTEST(DoMultipleTest(),KErrNone);
			}
		if (TestD_Exc)
			{
			RUNTEST(DoTestD_Exc(),KErrNone);
			}
		if (TestChunks)
			{
			DoChunkTests();
			}
		if (TestReaper)
			{
			DoReaperTests();
			}
		if (TestBtrace)
			{
			DoBtraceTest();
			}
		if (TestDefrag)
			{
			DoDefragTest();
			}
		}
	else
		{
#ifdef _DEBUG
		if (TestWeAreTheTestBase)
			{
			RFs fs;
			if (KErrNone == fs.Connect())
				{
				//fs.SetDebugRegister(KCACHE);
				ResetConcurrencyStats(fs);
				ResetBenchmarks(fs);
				fs.Close();
				}
			}
#endif

		while (1)
			{
			if (TestIsDemandPaged)
				{
#ifdef TEST_RUN_AUTOTEST
				PerformAutoTest();
#endif //TEST_RUN_AUTOTEST

#ifndef	TEST_SHORT_TEST
#ifdef TEST_RUN_LOWMEMTEST
				DoLowMemTest(ETrue);
#endif //TEST_RUN_LOWMEMTEST
#ifdef TEST_RUN_CHUNKTEST
				DoChunkTests();
#endif //TEST_RUN_CHUNKTEST
#ifdef TEST_RUN_REAPERTEST
				DoReaperTests();
#endif //TEST_RUN_REAPERTEST
#endif //TEST_SHORT_TEST
				}

#ifdef TEST_RUN_DEFRAGTEST
			DoDefragTest();
#endif //TEST_RUN_DEFRAGTEST

			if (TestStressFree)
				{
				TInt minSize = 512 * 4096;
				TInt maxSize = 32767 * 4096;
				UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);

				test.Printf(_L("%S Stress Free!!\n"), &TestNameBuffer, TestWeAreTheTestBase);
				TestStressFree = EFalse;
				}
			else
				{
				break;
				}
			}

#ifndef TEST_SHORT_TEST
#ifndef TEST_NO_DEXC_IN_AUTO
#ifdef TEST_RUN_D_EXCTEST
		RUNTEST(DoTestD_Exc(),KErrNone);
#endif //TEST_RUN_D_EXCTEST
#endif //TEST_NO_DEXC_IN_AUTO
		if (TestWeAreTheTestBase && TestFullAutoTest && TestIsDemandPaged)
			{
			RProcess		theProcess;
			TRequestStatus	status;

			TInt retVal = theProcess.Create(_L("t_pageldrtst_rom.exe"),_L("fullauto"));
			if (retVal != KErrNotFound)
				{
				RUNTEST1(KErrNone == retVal);
				theProcess.Logon(status);
				RUNTEST1(status == KRequestPending);	
				theProcess.Resume();
#ifdef TEST_THRASHING_TEST
				while (1)
					{
					if (theProcess.ExitType() != EExitPending)
						{
						RUNTEST1(theProcess.ExitType() != EExitPanic);
						break;
						}
					User::AfterHighRes(1);
					}
				User::WaitForRequest(status);
#else
				User::WaitForRequest(status);
				if (theProcess.ExitType() != EExitPending)
					{
					RUNTEST1(theProcess.ExitType() != EExitPanic);
					}
#endif //TEST_THRASHING_TEST
				theProcess.Close();
				}
			}
#endif //TEST_SHORT_TEST
#ifdef _DEBUG
		if (TestWeAreTheTestBase && !TestSilent)
			{
			RFs fs;
			if (KErrNone == fs.Connect())
				{
				DisplayConcurrencyStats(fs);
				DisplayBenchmarks(fs);
				fs.Close();
				}
			}
#endif
		}

	if (TestWeAreTheTestBase && !TestNoClean)
		CleanupFiles(EFalse);

	if (TestIsDemandPaged)
		{
		TInt minSize = tempPages.iMinSize;
		TInt maxSize = tempPages.iMaxSize;
		// put the cache back to the the original values.
		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)minSize,(TAny*)maxSize);
		}
	if (!TestSilent)
		{
		TUint end = User::TickCount();
		TUint time = TUint((TUint64)(end-start)*(TUint64)TickPeriod/(TUint64)1000000);
		test.Printf(_L("%S : Complete (%u seconds)\n"), &TestNameBuffer, time);	
		test.End();
		}
	return KErrNone;
	}
