// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

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

 				{