// Copyright (c) 2008-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\t_wdpstress.cpp

 // Data Paging Stress Tests

 // Common command lines:

 // t_wdpstress lowmem

 // debug - switch on debugging information

 // silent - no output to the screen or serial port

 // single - run the tests in a single thread

 // multiple <numThreads> - run the tests in multiple threads where <numThreads> (max 50 simultaneous threads)

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

 // lowmem - low memory tests

 // stack - perform autotest only with stack paging tests

 // chunk - perform autotest only with chunk paging tests 			

 // commit - perform autotest only with committing and decommitting paging tests 

 // ipc - perform autotest only with ipc pinning tests 			

 // all - perform autotest with all paging tests(ipc, stack, chunk and commit)

 // badserver - perform ipc pinning tests with dead server

 // iters <count> - the number of times to loop 

 // 

 //

 //! @SYMTestCaseID			KBASE-T_WDPSTRESS-xxx

 //! @SYMTestType			UT

 //! @SYMPREQ				PREQ1954

 //! @SYMTestCaseDesc		Writable Data Paging Stress Tests

 //! @SYMTestActions			

 //! @SYMTestExpectedResults All tests should pass.

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 //

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include <e32ver.h>

 RTest test(_L("T_WDPSTRESS"));

 #include <e32rom.h>

 #include <u32hal.h>

 #include <f32file.h>

 #include <e32svr.h>

 #include <e32hal.h>

 #include <f32dbg.h>

 #include <e32msgqueue.h>

 #include <e32math.h>

 #include <dptest.h>

 #include <hal.h>

 #include "testdefs.h"

 #ifdef __X86__

 #define TEST_ON_UNPAGED

 #endif

 #include "t_pagestress.h"

 TBool   	TestDebug					= EFalse;

 TBool		TestSilent					= EFalse;

 TBool		TestExit					= EFalse;

 TInt		gPerformTestLoop			= 10;					// Number of times to perform test on a thread

 const TUint KMaxTestThreads				= 20;					// The maximum number of threads allowed to run simultaniously

 TInt		gNumTestThreads				= KMaxTestThreads;		// The number of threads to run simultaneously

 #define TEST_INTERLEAVE_PRIO			EPriorityMore

 TBool		TestWeAreTheTestBase		= EFalse;

 #define TEST_NONE		0x0

 #define TEST_IPC		0x1

 #define TEST_STACK		0x2

 #define TEST_CHUNK		0x4

 #define TEST_COMMIT		0x8

 #define TEST_ALL		(TEST_COMMIT | TEST_CHUNK | TEST_STACK | TEST_IPC)

 TUint32		gSetTests					= TEST_ALL;

 TUint32		gTestWhichTests				= gSetTests;

 TBuf<32>	gTestNameBuffer;

 TBool		gTestPrioChange				= EFalse;				

 TBool		gTestStopMedia				= EFalse;

 TBool		gTestMediaAccess			= EFalse;

 TBool		gTestInterleave				= EFalse;

 TBool		gTestBadServer				= EFalse;

 #define TEST_LM_NUM_FREE	0

 #define TEST_LM_BLOCKSIZE	1

 #define TEST_LM_BLOCKS_FREE	4

 RPageStressTestLdd Ldd;

 RSemaphore	TestMultiSem;

 RMsgQueue<TBuf <64> >	TestMsgQueue;

 TBool		gIsDemandPaged			= ETrue;

 TBool		gTestRunning				= EFalse;				// To control when to stop flushing

 TBool		gMaxChunksReached			= EFalse;				// On moving memory model, the number of chunks per process is capped

 TInt		gPageSize;											// The number of bytes per page

 TUint		gPageShift;

 TUint		gChunksAllocd				= 0;					// The total number of chunks that have been allocated

 TUint		gMaxChunks					= 0;					// The max amount of chunks after which KErrOverflow will be returned

 RHeap*		gThreadHeap					= NULL;					

 RHeap*		gStackHeap					= NULL;

 TInt		gTestType					= -1;					// The type of test that is to be performed

 #define TEST_NEXT(__args) \

 	if (!TestSilent)\

 		test.Next __args;

 #define RDBGD_PRINT(__args)\

 	if (TestDebug)\

 	RDebug::Printf __args ;\

 #define RDBGS_PRINT(__args)\

 	if (!TestSilent)\

 	RDebug::Printf __args ;\

 #define DEBUG_PRINT(__args)\

 if (!TestSilent)\

 	{\

 	if (aTestArguments.iMsgQueue && aTestArguments.iBuffer && aTestArguments.iTheSem)\

 		{\

 		aTestArguments.iBuffer->Zero();\

 		aTestArguments.iBuffer->Format __args ;\

 		aTestArguments.iTheSem->Wait();\

 		aTestArguments.iMsgQueue->SendBlocking(*aTestArguments.iBuffer);\

 		aTestArguments.iTheSem->Signal();\

 		}\

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

 			{\

 			Ldd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

 			__operation;\

 			}\

 		RUNTEST1(__condition);\

 		}\

 	else\

 		{\

 		__operation;\

 		RUNTEST1(__condition);\

 		}

 #define DOTEST1(__operation, __condition)\

 	if (aTestArguments.iLowMem) \

 		{\

 		__operation;\

 		while (!__condition)\

 			{\

 			Ldd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

 			__operation;\

 			}\

 		RUNTEST1(__condition);\

 		}\

 	else\

 		{\

 		__operation;\

 		RUNTEST1(__condition);\

 		}

 struct SThreadExitResults

 	{

 	TInt					iExitType;

 	TInt					iExitReason;

 	};

 SThreadExitResults* gResultsArray;

 const TInt KExitTypeReset = -1;

 struct SPerformTestArgs

 	{

 	TInt					iThreadIndex;

 	RMsgQueue<TBuf <64> >	*iMsgQueue; 

 	TBuf<64>				*iBuffer;

 	RSemaphore				*iTheSem;

 	TBool					iLowMem;

 	TInt					iTestType;

 	};

 TInt DoTest(TInt gTestType, TBool aLowMem = EFalse);

 enum

 	{

 	ETestSingle, 

 	ETestMultiple,

 	ETestMedia,

 	ETestLowMem,

 	ETestInterleave,

 	ETestCommit, 

 	ETestTypes,

 	// This is at the moment manual

 	ETestBadServer, 

 	ETestTypeEnd, 

 	};

 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_KErrNone(r);

 	return meminfo().iFreeRamInBytes;

 	}

 const TUint KStackSize = 20 * 4096;

 TUint stackLimit = 150;//*** NEED TO WORK OUT HOW MUCH STACK WE HAVE***

 /**

 Recursive function

 */

 void CallRecFunc(TUint aNum, TInt aThreadIndex)

 	{

 	RDBGD_PRINT(("ThreadId %d CallRecFunc, aNum = %d\n", aThreadIndex, aNum));

 	if (aNum >= stackLimit)

 		{// To avoid a stack overflow

 		return;

 		}

 	else

 		{

 		CallRecFunc(++aNum, aThreadIndex);

 		User::After(0);

 		}

 	RDBGD_PRINT(("ThreadId %d CRF(%d)Returning...", aThreadIndex, aNum));

 	return;

 	}

 /**

 Thread that calls a recursive function

 */

 TInt ThreadFunc(TAny* aThreadIndex)

 	{

 	for (TUint i=0; i<1; i++)

 		{

 		CallRecFunc(0, (TInt)aThreadIndex);

 		}

 	RDBGD_PRINT(("ThreadId %d ThreadFunc Returning...", (TInt)aThreadIndex));

 	return KErrNone;

 	}

 /**

 Thread continuously flushes the paging cache

 */

 TInt FlushFunc(TAny* /*aPtr*/)

 	{

 	RThread().SetPriority(EPriorityMore);

 	while(gTestRunning)

 		{

 		DPTest::FlushCache();	

 		User::After((Math::Random()&0xfff)*10);

 		}

 	return KErrNone;

 	}

 //

 // TestStackPaging

 //

 // Create a paged thread which calls a recursive function.

 // Calls to function will be placed on the stack, which is data paged

 //

 TInt TestStackPaging(SPerformTestArgs& aTestArguments)

 	{

 	RDBGD_PRINT(("Creating test thread"));

 	TBuf<16> runThreadName;

 	runThreadName = _L("");

 	TThreadCreateInfo threadCreateInfo(runThreadName, ThreadFunc, KStackSize, (TAny*) aTestArguments.iThreadIndex);

 	threadCreateInfo.SetCreateHeap(KMinHeapSize, KMinHeapSize);

 	//threadCreateInfo.SetUseHeap(NULL);

 	threadCreateInfo.SetPaging(TThreadCreateInfo::EPaged);

 	RThread testThread;

 	TInt r;

 	for(;;)

 		{

 		r = testThread.Create(threadCreateInfo);

 		if(r != KErrNoMemory)

 			break;

 		if(!aTestArguments.iLowMem)

 			break;

 		if(Ldd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE) != KErrNone)

 			break;

 		RDBGD_PRINT(("TestStackPaging released some RAM\n"));

 		}

 	RDBGD_PRINT(("TID(%d) TestStackPaging create r = %d freeRam = %d\n", aTestArguments.iThreadIndex, r, FreeRam()));

 	if (r != KErrNone)

 		return r;

 	TRequestStatus threadStatus;

 	testThread.Logon(threadStatus);

 	RDBGD_PRINT(("resuming test thread"));

 	testThread.Resume();

 	RDBGD_PRINT(("waiting for threadstatus"));

 	User::WaitForRequest(threadStatus);

 	RDBGD_PRINT(("Killing threads\n"));

 	testThread.Close();

 	return KErrNone;

 	}

 //--------------------------Server Pinning stuff-----------------------------------------------------

 _LIT(KTestServer,"CTestServer");

 const TUint KSemServer = 0;

 class CTestServer : public CServer2

 	{

 public:

 	CTestServer(TInt aPriority);

 protected:

 	//override the pure virtual functions:

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

 	};

 class CTestSession : public CSession2

 	{

 public:

 	enum TTestMode

 		{

 		EStop,

 		ERead,

 		EWrite,

 		EReadWrite,

 		};

 //Override pure virtual

 	IMPORT_C virtual void ServiceL(const RMessage2& aMessage);

 private:

 	TInt ReadWrite(const RMessage2& aMessage, TBool aRead, TBool aWrite);

 	TBool iClientDied;

 	};

 class CMyActiveScheduler : public CActiveScheduler

 	{

 public:

 	virtual void Error(TInt anError) const; //override pure virtual error function

 	};

 class RSession : public RSessionBase

 	{

 public:

 	TInt PublicSendReceive(TInt aFunction, const TIpcArgs &aPtr)

 		{

 		return (SendReceive(aFunction, aPtr));

 		}

 	TInt PublicCreateSession(const TDesC& aServer,TInt aMessageSlots)

 		{

 		return (CreateSession(aServer,User::Version(),aMessageSlots));

 		}

 	};

 struct SServerArgs

 	{

 	TBool iBadServer;

 	RSemaphore iSemArray;

 	};

 SServerArgs gServerArgsArray[KMaxTestThreads];

 CTestServer::CTestServer(TInt aPriority)

 //

 // Constructor - sets name

 //

 	: CServer2(aPriority)

 	{}

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

 //

 // Virtual fn - checks version supported and creates a CTestSession

 //

 	{

 	TVersion version(KE32MajorVersionNumber,KE32MinorVersionNumber,KE32BuildVersionNumber);

 	if (User::QueryVersionSupported(version,aVersion)==EFalse)

 		User::Leave(KErrNotSupported);

 	CTestSession* newCTestSession = new CTestSession;

 	if (newCTestSession==NULL)

 		User::Panic(_L("NewSessionL failure"), KErrNoMemory);

 	return(newCTestSession);

 	}

 TInt CTestSession::ReadWrite(const RMessage2& aMessage, TBool aRead, TBool aWrite)

 	{

 	TInt r = KErrNone;

 	for (TUint argIndex = 0; argIndex < 4; argIndex++)

 		{

 		// Get the length of the descriptor and verify it is as expected.

 		TInt length = aMessage.GetDesLength(argIndex);

 		if (length < KErrNone)

 			{

 			RDebug::Printf("  Error getting descriptor length %d", length);

 			return length;

 			}

 		if (aRead)

 			{

 			// Now read the descriptor

 			HBufC8* des = HBufC8::New(length);

 			if (!des)

 				return KErrNoMemory;

 			TPtr8 desPtr = des->Des();

 			r = aMessage.Read(argIndex, desPtr);

 			if (r != KErrNone)

 				{

 				delete des;

 				return r;

 				}

 			//TODO: Verify the descriptor

 			delete des;

 			}

 		if (aWrite)

 			{

 			// Now write to the maximum length of the descriptor.

 			TInt max = length;

 			HBufC8* argTmp = HBufC8::New(max);

 			if (!argTmp)

 				return KErrNoMemory;

 			TPtr8 argPtr = argTmp->Des();

 			argPtr.SetLength(max);

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

 				argPtr[i] = (TUint8)argIndex;

 			r = aMessage.Write(argIndex, argPtr);

 			delete argTmp;

 			if (r != KErrNone)

 				return r;

 			}

 		}

 	return KErrNone;

 	}

 void CTestSession::ServiceL(const RMessage2& aMessage)

 //

 // Virtual message-handler

 //

 	{

 	TInt r = KErrNone;

 	iClientDied = EFalse;

 	switch (aMessage.Function())

 		{

 		case EStop:

 			RDBGD_PRINT(("Stopping server"));

 			CActiveScheduler::Stop();

 			break;

 		case ERead:

 			r = ReadWrite(aMessage, ETrue, EFalse);

 			break;

 		case EWrite:

 			r = ReadWrite(aMessage, EFalse, ETrue);

 			break;

 		case EReadWrite:

 			r = ReadWrite(aMessage, ETrue, ETrue);

 			break;

 		default:

 			r = KErrNotSupported;

 		}

  	aMessage.Complete(r);

 	// If descriptors aren't as expected then panic so the test will fail.

 	if (r != KErrNone)

 		User::Panic(_L("ServiceL failure"), r);

 	}

 // CTestSession funtions

 void CMyActiveScheduler::Error(TInt anError) const

 //

 // Virtual error handler

 //

 	{

 	User::Panic(_L("CMyActiveScheduer::Error"), anError);

 	}

 TInt ServerThread(TAny* aThreadIndex)

 //

 // Passed as the server thread in 2 tests - sets up and runs CTestServer

 //

 	{

 	RDBGD_PRINT(("ServerThread"));

 	TUint threadIndex = (TUint)aThreadIndex;

 	TBuf<16> serverName;

 	serverName = _L("ServerName_");

 	serverName.AppendNum(threadIndex);

 	CMyActiveScheduler* pScheduler = new CMyActiveScheduler;

 	if (pScheduler == NULL)

 		{

 		gServerArgsArray[threadIndex].iBadServer = ETrue;

 		gServerArgsArray[threadIndex].iSemArray.Signal();

 		return KErrNoMemory;

 		}

 	CActiveScheduler::Install(pScheduler);

 	CTestServer* pServer = new CTestServer(0);

 	if (pServer == NULL)

 		{

 		gServerArgsArray[threadIndex].iBadServer = ETrue;

 		gServerArgsArray[threadIndex].iSemArray.Signal();

 		delete pScheduler;

 		return KErrNoMemory;

 		}

 	//Starting a CServer2 also Adds it to the ActiveScheduler

 	TInt r = pServer->Start(serverName);

 	if (r != KErrNone)

 		{

 		gServerArgsArray[threadIndex].iBadServer = ETrue;

 		gServerArgsArray[threadIndex].iSemArray.Signal();

 		delete pScheduler;

 		delete pServer;

 		return r;

 		}

 	RDBGD_PRINT(("Start ActiveScheduler and signal to client"));

 	RDBGD_PRINT(("There might be something going on beneath this window\n"));

 	gServerArgsArray[threadIndex].iSemArray.Signal();

 	CActiveScheduler::Start();

 	delete pScheduler;

 	delete pServer;

 	return KErrNone;

 	}

 TInt BadServerThread(TAny* /*aThreadIndex*/)

 //

 // Passed as the server thread in 2 tests - sets up and runs CTestServer

 //

 	{

 	RDBGD_PRINT(("BadServerThread"));

 	CMyActiveScheduler* pScheduler = new CMyActiveScheduler;

 	if (pScheduler == NULL)

 		{

 		RDBGD_PRINT(("BST:Fail1"));

 		gServerArgsArray[KSemServer].iBadServer = ETrue;

 		gServerArgsArray[KSemServer].iSemArray.Signal();

 		return KErrNoMemory;

 		}

 	CActiveScheduler::Install(pScheduler);

 	CTestServer* pServer = new CTestServer(0);

 	if (pServer == NULL)

 		{

 		RDBGD_PRINT(("BST:Fail2"));

 		gServerArgsArray[KSemServer].iBadServer = ETrue;

 		gServerArgsArray[KSemServer].iSemArray.Signal();

 		delete pScheduler;

 		return KErrNoMemory;

 		}

 	//pServer->SetPinClientDescriptors(ETrue);

 	//Starting a CServer2 also Adds it to the ActiveScheduler

 	TInt r = pServer->Start(KTestServer);

 	if (r != KErrNone)

 		{

 		RDBGD_PRINT(("BST:Fail3"));

 		gServerArgsArray[KSemServer].iBadServer = ETrue;

 		gServerArgsArray[KSemServer].iSemArray.Signal();

 		delete pScheduler;

 		delete pServer;

 		return r;

 		}

 	RDBGD_PRINT(("Start ActiveScheduler and signal to client"));

 	RDBGD_PRINT(("There might be something going on beneath this window\n"));

 	gServerArgsArray[KSemServer].iSemArray.Signal();

 	CActiveScheduler::Start();

 	delete pScheduler;

 	delete pServer;

 	RDBGD_PRINT(("BST:Pass1"));

 	return KErrNone;

 	}

 TInt SendMessages(TUint aIters, TUint aSize, TDesC& aServerName, TInt aIndex, TBool aLowMem = EFalse)

 //

 // Passed as the first client thread - signals the server to do several tests

 //

 	{

 	HBufC8* argTmp1;

 	HBufC8* argTmp2;

 	HBufC8* argTmp3;

 	HBufC8* argTmp4;

 	DOTEST((argTmp1 = HBufC8::New(aSize)), (argTmp1 != NULL));

 	*argTmp1 = (const TUint8*)"argTmp1";

 	TPtr8 ptr1 = argTmp1->Des();

 	DOTEST((argTmp2 = HBufC8::New(aSize)), (argTmp2 != NULL));

 	*argTmp2 = (const TUint8*)"argTmp2";

 	TPtr8 ptr2 = argTmp2->Des();

 	DOTEST((argTmp3 = HBufC8::New(aSize)), (argTmp3 != NULL));

 	*argTmp3 = (const TUint8*)"argTmp3";

 	TPtr8 ptr3 = argTmp3->Des();

 	DOTEST((argTmp4 = HBufC8::New(aSize)), (argTmp1 != NULL));

 	*argTmp4 = (const TUint8*)"argTmp4";

 	TPtr8 ptr4 = argTmp4->Des();

 	RSession session;

 	TInt r = KErrNone;

 	if(gTestBadServer)

 		{//Don't do bad server tests with lowmem

 		r = session.PublicCreateSession(aServerName,5);

 		}

 	else

 		{

 		DOTEST((r = session.PublicCreateSession(aServerName,5)), (r != KErrNoMemory));

 		}

 	if (r != KErrNone)

 		{

 		RDBGD_PRINT(("SendMessages[%d] failed to create session r = %d", aIndex, r));

 		return r;

 		}

 	if(gTestBadServer)

 		{

 		RThread::Rendezvous(KErrNone);

 		RDBGD_PRINT(("Wait on sem %d", aIndex));

 		//gServerArgsArray[KSemCliSessStarted].iSemArray.Wait();

 		}

 	RDBGD_PRINT(("ID (%d)ReadWrite" ,aIndex));

 	for (TUint i = 0; i < aIters; i++)

 		{

 		TUint mode = (i&0x3) + CTestSession::ERead;

 		switch(mode)

 			{

 			case CTestSession::ERead:

 				DOTEST((r = session.PublicSendReceive(CTestSession::ERead, TIpcArgs(&ptr1, &ptr2, &ptr3, &ptr4).PinArgs())), 

 						(r != KErrNoMemory));

 				if (r != KErrNone)

 					return r;

 				break;

 			case CTestSession::EWrite:

 				DOTEST((r = session.PublicSendReceive(CTestSession::EWrite, TIpcArgs(&ptr1, &ptr2, &ptr3, &ptr4).PinArgs())), 

 						(r != KErrNoMemory));

 				if (r != KErrNone)

 					return r;

 				break;

 			case CTestSession::EReadWrite:

 				DOTEST((r = session.PublicSendReceive(CTestSession::EReadWrite, TIpcArgs(&ptr1, &ptr2, &ptr3, &ptr4).PinArgs())), 

 						(r != KErrNoMemory));

 				if (r != KErrNone)

 					return r;

 				break;

 			}

 		}

 	RDBGD_PRINT(("ID(%d) Closing session", aIndex));

 	session.Close();

 	return r;

 	}

 TInt TestIPCPinning(SPerformTestArgs& aTestArguments)

 	{

 	TInt r = KErrNone;

 	// Create the server thread it needs to have a unpaged stack and heap.

 	TBuf<16> serverThreadName;

 	serverThreadName = _L("ServerThread_");

 	serverThreadName.AppendNum(aTestArguments.iThreadIndex);

 	TThreadCreateInfo serverInfo(serverThreadName, ServerThread, KDefaultStackSize, (TAny *) aTestArguments.iThreadIndex);

 	serverInfo.SetUseHeap(NULL);

 	gServerArgsArray[aTestArguments.iThreadIndex].iBadServer = EFalse;

 	// Create the semaphores for the IPC pinning tests

 	DOTEST1((r = gServerArgsArray[aTestArguments.iThreadIndex].iSemArray.CreateLocal(0)), (r != KErrNoMemory));

 	if (r != KErrNone)

 		{

 		RDBGD_PRINT(("Failed to create semaphonre[%d] r = %d", aTestArguments.iThreadIndex, r));

 		return r;

 		}

 	RThread serverThread;

 	TInt r1 = KErrNone;

 	DOTEST1((r1 = serverThread.Create(serverInfo)), (r1 != KErrNoMemory));

 	if (r1 != KErrNone)

 		{

 		RDBGD_PRINT(("Failed to create server thread[%d] r1 = %d", aTestArguments.iThreadIndex, r1));

 		return r1;

 		}

 	TRequestStatus serverStat;

 	serverThread.Logon(serverStat);

 	serverThread.Resume();

 	// Wait for the server to start and then create a session to it.

 	TBuf<16> serverName;

 	serverName = _L("ServerName_");

 	serverName.AppendNum(aTestArguments.iThreadIndex);

 	gServerArgsArray[aTestArguments.iThreadIndex].iSemArray.Wait();

 	// First check that the server started successfully

 	if (gServerArgsArray[aTestArguments.iThreadIndex].iBadServer)

 		return KErrServerTerminated;

 	RSession session;

 	DOTEST1((r1 = session.PublicCreateSession(serverName,5)), (r1 != KErrNoMemory));

 	if (r1 != KErrNone)

 		{

 		RDBGD_PRINT(("Failed to create session[%d] r1 = %d", aTestArguments.iThreadIndex, r1));

 		return r1;

 		}

 	r1 = SendMessages(50, 10, serverName, aTestArguments.iThreadIndex, aTestArguments.iLowMem);

 	if (r1 != KErrNone)

 		{

 		RDBGD_PRINT(("SendMessages[%d] r1 = %d", aTestArguments.iThreadIndex, r1));

 		return r1;

 		}

 	TInt r2 = KErrNone;

 	// Signal to stop ActiveScheduler and wait for server to stop.

 	session.PublicSendReceive(CTestSession::EStop, TIpcArgs());

 	session.Close();

 	User::WaitForRequest(serverStat);

 	if (serverThread.ExitType() == EExitKill &&

 		serverThread.ExitReason() != KErrNone)	

 		{

 		r2 = serverThread.ExitReason();

 		}

 	if (serverThread.ExitType() != EExitKill)	

 		{

 		RDBGD_PRINT(("Server thread panic'd"));

 		r2 = KErrGeneral;

 		}

 	serverThread.Close();

 	gServerArgsArray[aTestArguments.iThreadIndex].iSemArray.Close();

 	if (r1 != KErrNone)

 		return r1;

 	return r2;

 	}

 TInt ClientThread(TAny* aClientThread)

 	{

 	TInt r = KErrNone;

 	TBuf<16> serverName;

 	serverName = KTestServer;

 	RDBGD_PRINT(("CT(%d):Sending Messages" ,aClientThread));

 	r = SendMessages(500, 10, serverName, (TInt) aClientThread);

 	if (r != KErrNone)

 		{

 		RDBGD_PRINT(("SendMessages[%d] r = %d", (TInt) aClientThread, r));

 		return r;

 		}

 	return r;

 	}

 TInt TestIPCBadServer(SPerformTestArgs& aTestArguments)

 	{

 	TInt cliRet = KErrNone;

 	TInt serRet = KErrNone;

 	// Create the server thread it needs to have a unpaged stack and heap.

 	TBuf<16> serverThreadName;

 	serverThreadName = _L("BadServerThread");

 	TThreadCreateInfo serverInfo(serverThreadName, BadServerThread, KDefaultStackSize, NULL);

 	serverInfo.SetUseHeap(NULL);

 	// Create the semaphores for the IPC pinning tests

 	DOTEST1((serRet = gServerArgsArray[KSemServer].iSemArray.CreateLocal(0)), (serRet != KErrNoMemory));

 	if (serRet != KErrNone)

 		{

 		RDBGD_PRINT(("Failed to create semaphonre[%d] serRet = %d", KSemServer, serRet));

 		return serRet;

 		}

 	RThread serverThread;

 	DOTEST1((serRet = serverThread.Create(serverInfo)), (serRet != KErrNoMemory));

 	if (serRet != KErrNone)

 		{

 		RDBGD_PRINT(("Failed to create server thread serRet = %d", serRet));

 		return serRet;

 		}

 	TRequestStatus serverStat;

 	serverThread.Logon(serverStat);

 	serverThread.Resume();

 	// Wait for the server to start and then create a session to it.

 	gServerArgsArray[KSemServer].iSemArray.Wait();

 	// First check that the server started successfully

 	if (gServerArgsArray[KSemServer].iBadServer)

 		return KErrServerTerminated;

 	//create client threads

 	const TUint KNumClientThreads = 50;	

 	RThread clientThreads[KNumClientThreads];

 	TRequestStatus clientStarted[KNumClientThreads];

 	TRequestStatus clientStats[KNumClientThreads];

 	// Create the client threads

 	TBuf<16> clientThreadName;

 	TUint i;

 	for (i = 0; i < KNumClientThreads; i++)

 		{

 		clientThreadName = _L("clientThread_");

 		clientThreadName.AppendNum(i);

 		TThreadCreateInfo clientInfo(clientThreadName, ClientThread, KDefaultStackSize, (TAny*)i);

 		clientInfo.SetPaging(TThreadCreateInfo::EPaged);

 		clientInfo.SetCreateHeap(KMinHeapSize, KMinHeapSize);

 		cliRet = clientThreads[i].Create(clientInfo);

 		if (cliRet != KErrNone)

 			{

 			RDBGD_PRINT(("Failed to create client thread [%d] cliRet = %d", i, cliRet));

 			return cliRet;

 			}

 		clientThreads[i].Rendezvous(clientStarted[i]);	

 		clientThreads[i].Logon(clientStats[i]);

 		clientThreads[i].Resume();

 		}

 	// Wait for creation of the client thread sessions

 	for (i = 0; i < KNumClientThreads; i++)

 		{

 		User::WaitForRequest(clientStarted[i]);

 		if (clientStarted[i].Int() != KErrNone)

 			return clientStarted[i].Int();

 		}

 	// Once the messages are being sent, create a session to the

 	// same server and signal to stop ActiveScheduler

 	RSession session;

 	serRet = session.PublicCreateSession(KTestServer,5);

 	if (serRet != KErrNone)

 		{

 		RDBGD_PRINT(("Failed to create session serRet = %d", serRet));

 		return serRet;

 		}

 	session.PublicSendReceive(CTestSession::EStop, TIpcArgs());

 	session.Close();

 	// Wait for the client thread to end.

 	cliRet = KErrNone;

 	for (i = 0; i < KNumClientThreads; i++)

 		{

 		User::WaitForRequest(clientStats[i]);

 		RDBGD_PRINT(("Thread complete clientStats[%d] = %d", i, clientStats[i].Int()));

 		if (clientStats[i].Int() != KErrNone && 

 			clientStats[i].Int() != KErrServerTerminated)

 			{

 			cliRet = clientStats[i].Int();

 			}

 		}

 	// Check that the server ended correctly

 	serRet = KErrNone;

 	User::WaitForRequest(serverStat);

 	if (serverThread.ExitType() == EExitKill &&

 		serverThread.ExitReason() != KErrNone)	

 		{

 		serRet = serverThread.ExitReason();

 		}

 	if (serverThread.ExitType() != EExitKill)	

 		{

 		RDBGD_PRINT(("Server thread panic'd"));

 		serRet = KErrGeneral;

 		}

 	// Close all the server thread and client threads

 	for (i = 0; i < KNumClientThreads; i++)

 		{

 		clientThreads[i].Close();

 		}

 	serverThread.Close();

 	if (cliRet != KErrNone)

 		return cliRet;

 	return serRet;

 	}

 //

 // RemoveChunkAlloc

 //

 // Remove ALL chunks allocated

 //

 // @param aChunkArray The array that stores a reference to the chunks created.

 // @param aChunkArraySize The size of aChunkArray.

 //

 void RemoveChunkAlloc(RChunk*& aChunkArray, TUint aChunkArraySize)

 	{

 	if (aChunkArray == NULL)

 		{// The chunk array has already been deleted.

 		return;

 		}

 	for (TUint i = 0; i < aChunkArraySize; i++)

 		{

 		if (aChunkArray[i].Handle() != NULL)

 			{

 			aChunkArray[i].Close();

 			gChunksAllocd --;

 			if (gChunksAllocd < gMaxChunks)

 				gMaxChunksReached = EFalse;

 			}

 		}

 	delete[] aChunkArray;

 	aChunkArray = NULL;

 	}	

 TInt WriteToChunk(RChunk* aChunkArray, TUint aChunkArraySize)

 	{

 	for (TUint j = 0; j < aChunkArraySize; j++) 

 		{

 		if (aChunkArray[j].Handle() != NULL)

 			{

 			TUint32* base = (TUint32*)aChunkArray[j].Base();

 			TUint32* end = (TUint32*)(aChunkArray[j].Base() + aChunkArray[j].Size());

 			for (TUint32 k = 0; base < end; k++)

 				{

 				*base++ = k; // write index to the chunk

 				}

 			}		

 		}

 	return KErrNone;

 	}

 TUint32 ReadByte(volatile TUint32* aPtr)

 	{

 	return *aPtr;

 	}

 TInt ReadChunk(RChunk* aChunkArray, TUint aChunkArraySize)

 	{

 	for (TUint j=0; j < aChunkArraySize; j++) //Read all open chunks

 		{

 		if (aChunkArray[j].Handle() != NULL)

 			{

 			TUint32* base = (TUint32*)aChunkArray[j].Base();

 			TUint32* end = (TUint32*)(aChunkArray[j].Base() + aChunkArray[j].Size());

 			for (TUint32 k = 0; base < end; k++)

 				{

 				TUint value = ReadByte((volatile TUint32*)base++);

 				if (value != k)

 					{

 					RDBGS_PRINT(("Read value incorrect expected 0x%x got 0x%x", k, value));

 					return KErrGeneral;

 					}

 				}

 			}		

 		}

 	return KErrNone;

 	}

 TInt CreateChunks(SPerformTestArgs& aTestArguments, RChunk*& aChunkArray, TUint aChunkArraySize)

 	{

 	TInt r = KErrNone;

 	TUint chunkSize = 1 << gPageShift;

 	// Allocate as many chunks as is specified, either with the default chunk size or a specified chunk size

 	if (aChunkArray == NULL)

 		{

 		DOTEST1((aChunkArray = new RChunk[aChunkArraySize]), (aChunkArray != NULL));

 		if (aChunkArray == NULL)

 			return KErrNoMemory;

 		}

 	TChunkCreateInfo createInfo;

 	createInfo.SetNormal(chunkSize, chunkSize);

 	createInfo.SetPaging(TChunkCreateInfo::EPaged);

 	// Create chunks for each RChunk with a NULL handle.

 	for (TUint i = 0; i < aChunkArraySize; i++)

 		{

 		DOTEST1((r = aChunkArray[i].Create(createInfo)), (r != KErrNoMemory));

 		if (r != KErrNone)

 			{

 			if (r == KErrOverflow)

 				{

 				gMaxChunks = gChunksAllocd;

 				RDBGD_PRINT(("Max Chunks Allowed = %d", gMaxChunks));

 				gMaxChunksReached = ETrue;

 				}

 			return r;

 			}

 		gChunksAllocd++;

 		RDBGD_PRINT(("TID(%d) aChunkArray[%d], r = %d", aTestArguments.iThreadIndex, i, r));

 		}

 	RDBGD_PRINT(("TID(%d) created chunks r = %d", aTestArguments.iThreadIndex, r));

 	return KErrNone;

 	}

 //

 // TestChunkPaging

 //

 // Create a number of chunks and write to them

 // read the chunk back to ensure the values are correct

 //

 TInt TestChunkPaging(SPerformTestArgs& aTestArguments)

 	{

 	TInt r = KErrNone;

 	const TUint KNumChunks = 10;

 	if(gMaxChunksReached)

 		{// We cant create any more chunks as the max number has been reached

 		return KErrNone;

 		}

 	RChunk* chunkArray = NULL;	

 	r = CreateChunks(aTestArguments, chunkArray, KNumChunks);

 	if (r != KErrNone)

 		{

 		if (r == KErrOverflow)

 			{

 			RDBGD_PRINT(("Max number of chunks reached"));

 			RemoveChunkAlloc(chunkArray, KNumChunks);

 			return KErrNone;

 			}

 		RDBGD_PRINT(("TID(%d) CreateChunks r = %d", aTestArguments.iThreadIndex, r));

 		return r;

 		}

 	r = WriteToChunk(chunkArray, KNumChunks);

 	if (r != KErrNone)

 		{

 		RemoveChunkAlloc(chunkArray, KNumChunks);

 		RDBGD_PRINT(("TID(%d) WriteToChunk r = %d", aTestArguments.iThreadIndex, r));

 		return r;

 		}

 	r = ReadChunk(chunkArray, KNumChunks);

 	if (r != KErrNone)

 		{

 		RemoveChunkAlloc(chunkArray, KNumChunks);

 		RDBGD_PRINT(("TID(%d) ReadChunk r = %d", aTestArguments.iThreadIndex, r));

 		return r;

 		} 

 	RemoveChunkAlloc(chunkArray, KNumChunks);

 	return KErrNone;

 	}

 //

 // TestChunkCommit

 //

 // Create a chunk

 // commit a page at a time, write to that page and then decommit the page

 //

 TInt TestChunkCommit(SPerformTestArgs& aTestArguments)

 	{

 	TInt r = KErrNone;

 	RChunk testChunk;

 	TUint chunkSize = 70 << gPageShift;

 	TChunkCreateInfo createInfo;

 	createInfo.SetDisconnected(0, 0, chunkSize);

 	createInfo.SetPaging(TChunkCreateInfo::EPaged);

 	DOTEST1((r = testChunk.Create(createInfo)), (r != KErrNoMemory));

 	if (r != KErrNone)

 		{

 		return r;

 		}

 	TUint offset = 0;

 	while(offset < chunkSize)

 		{

 		// Commit a page

 		DOTEST1((r = testChunk.Commit(offset,gPageSize)), (r != KErrNoMemory));

 		if (r != KErrNone)

 			{

 			return r;

 			}

 		// Write to the page

 		TUint8* pageStart = testChunk.Base() + offset;

 		*pageStart = 0xed;

 		// Decommit the page

 		r = testChunk.Decommit(offset, gPageSize);

 		if (r != KErrNone)

 			{

 			return r;

 			}

 		offset += gPageSize;

 		}

 	testChunk.Close();

 	return r;

 	}

 //

 // 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(SPerformTestArgs& aTestArguments)

 	{

 	TInt r = KErrNone;

 	TUint start = User::TickCount();

 	DEBUG_PRINT1((_L("%S : thread Starting %d\n"), &gTestNameBuffer, aTestArguments.iThreadIndex));

 	// now select how we do the test...

 	TInt	iterIndex = 0;

 	if (TEST_ALL == (gTestWhichTests & TEST_ALL))

 		{

 		#define LOCAL_ORDER_INDEX1	6

 		#define LOCAL_ORDER_INDEX2	4

 		TInt	order[LOCAL_ORDER_INDEX1][LOCAL_ORDER_INDEX2] = {	{TEST_STACK, TEST_CHUNK,TEST_COMMIT, TEST_IPC},

 																	{TEST_STACK, TEST_COMMIT,  TEST_CHUNK, TEST_IPC},

 																	{TEST_CHUNK,TEST_STACK, TEST_COMMIT, TEST_IPC},

 																	{TEST_CHUNK,TEST_COMMIT,  TEST_STACK, TEST_IPC},

 																	{TEST_COMMIT,  TEST_STACK, TEST_CHUNK, TEST_IPC},

 																	{TEST_COMMIT,  TEST_CHUNK,TEST_STACK, TEST_IPC}};

 		TInt	whichOrder = 0;

 		iterIndex = 0;

 		for (iterIndex = 0; iterIndex < gPerformTestLoop; iterIndex ++)

 			{

 			DEBUG_PRINT1((_L("iterIndex = %d\n"), iterIndex));

 			TInt    selOrder = ((aTestArguments.iThreadIndex + 1) * (iterIndex + 1)) % LOCAL_ORDER_INDEX1;

 			for (whichOrder = 0; whichOrder < LOCAL_ORDER_INDEX2; whichOrder ++)

 				{

 				DEBUG_PRINT1((_L("whichOrder = %d\n"), whichOrder));

 				switch (order[selOrder][whichOrder])

 					{

 					case TEST_STACK:

 					DEBUG_PRINT1((_L("%S : %d Iter %d Stack\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 					r = TestStackPaging(aTestArguments);

 					DEBUG_PRINT1((_L("ThreadId %d Finished TestStackPaging() r = %d\n"), aTestArguments.iThreadIndex, r));

 					if (r != KErrNone)

 						return r;

 					break;

 					case TEST_CHUNK:

 					DEBUG_PRINT1((_L("%S : %d Iter %d Chunk\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 					r = TestChunkPaging(aTestArguments);

 					DEBUG_PRINT1((_L("ThreadId %d Finished TestChunkPaging() r = %d\n"), aTestArguments.iThreadIndex, r));

 					if (r != KErrNone)

 						return r;

 					break;

 					case TEST_COMMIT:

 					DEBUG_PRINT1((_L("%S : %d Iter %d Commit\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 					r = TestChunkCommit(aTestArguments);

 					DEBUG_PRINT1((_L("ThreadId %d Finished TestChunkCommit() r = %d\n"), aTestArguments.iThreadIndex, r));

 					if (r != KErrNone)

 						return r;

 					break;

 					case TEST_IPC:

 					if (gTestBadServer)

 						{

 						DEBUG_PRINT1((_L("%S : %d Iter %d IPC-BadServer\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 						r = TestIPCBadServer(aTestArguments);

 						DEBUG_PRINT1((_L("ThreadId %d Finished TestIPCBadServer() r = %d\n"), aTestArguments.iThreadIndex, r));

 						}

 					else

 						{

 						DEBUG_PRINT1((_L("%S : %d Iter %d IPC\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 						// Limit the IPC pinning stuff to 2 loops else will take a long time to run

 						if (gNumTestThreads > 1 && gPerformTestLoop > 2)

 							break;

 						r = TestIPCPinning(aTestArguments);

 						DEBUG_PRINT1((_L("ThreadId %d Finished TestIPCPinning() r = %d\n"), aTestArguments.iThreadIndex, r));

 						if (r != KErrNone)

 							return r;

 						}

 					break;

 					default: // this is really an error.

 					break;

 					}

 				iterIndex++;

 				}

 			}

 		}

 	else

 		{

 		if (gTestWhichTests & TEST_STACK)

 			{

 			for (iterIndex = 0; iterIndex < gPerformTestLoop; iterIndex ++)

 				{

 				DEBUG_PRINT1((_L("%S : %d Iter %d Stack\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 				r = TestStackPaging(aTestArguments);

 				DEBUG_PRINT1((_L("ThreadId %d Finished TestStackPaging() r = %d\n"), aTestArguments.iThreadIndex, r));

 				if (r != KErrNone)

 						return r;

 				}

 			}

 		if (gTestWhichTests & TEST_CHUNK)

 			{

 			for (iterIndex = 0; iterIndex < gPerformTestLoop; iterIndex ++)

 				{

 				DEBUG_PRINT1((_L("%S : %d Iter %d Chunk\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 				r = TestChunkPaging(aTestArguments);

 				DEBUG_PRINT1((_L("ThreadId %d Finished TestChunkPaging() r = %d\n"), aTestArguments.iThreadIndex, r));

 				if (r != KErrNone)

 						return r;

 				}

 			}

 		if (gTestWhichTests & TEST_COMMIT)

 			{

 			for (iterIndex = 0; iterIndex < gPerformTestLoop; iterIndex ++)

 				{

 				DEBUG_PRINT1((_L("%S : %d Iter %d Commit\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 				r = TestChunkCommit(aTestArguments);

 				DEBUG_PRINT1((_L("ThreadId %d Finished TestChunkCommit() r = %d\n"), aTestArguments.iThreadIndex, r));

 				if (r != KErrNone)

 					return r;

 				}

 			}

 		if (gTestWhichTests & TEST_IPC)

 			{

 			// In multiple thread case limit IPC test to 2 loops else will take a long time

 			TInt loops = (gPerformTestLoop <= 2 && gNumTestThreads) ? gPerformTestLoop : 2;

 			for (iterIndex = 0; iterIndex < loops; iterIndex ++)

 				{

 				if (gTestBadServer)

 					{

 					r = TestIPCBadServer(aTestArguments);

 					DEBUG_PRINT1((_L("ThreadId %d Finished TestIPCBadServer() r = %d\n"), aTestArguments.iThreadIndex, r));

 					}

 				else

 					{

 					DEBUG_PRINT1((_L("%S : %d Iter %d IPC\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, iterIndex));

 					r = TestIPCPinning(aTestArguments);

 					DEBUG_PRINT1((_L("ThreadId %d Finished TestIPCPinning() r = %d\n"), aTestArguments.iThreadIndex, r));

 					if (r != KErrNone)

 						return r;

 					}

 				}

 			}

 		}

 	DEBUG_PRINT1((_L("%S : thread Exiting %d (tickcount %u)\n"), &gTestNameBuffer, aTestArguments.iThreadIndex, (User::TickCount() - start)));

 	return r;

 	}

 //

 // MultipleTestThread

 //

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

 //

 LOCAL_C TInt MultipleTestThread(TAny* aTestArgs)

 	{

 	TInt r = KErrNone;

 	TBuf<64>					localBuffer;

 	if (gTestInterleave)	

 		{

 		RThread				thisThread;

 		thisThread.SetPriority((TThreadPriority) TEST_INTERLEAVE_PRIO);

 		}

 	SPerformTestArgs& testArgs = *(SPerformTestArgs*)aTestArgs;

 	testArgs.iBuffer = &localBuffer;

 	RDBGD_PRINT(("Performing test thread ThreadID(%d)\n", testArgs.iThreadIndex));

 	r = PerformTestThread(testArgs);

 	return r;

 	}

 //

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

 	}

 //

 // PerformRomAndFileSystemAccess

 // 

 // 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(SPerformTestArgs& aTestArguments)

 	{

 	TUint maxBytes = KMaxTUint;

 	TInt startTime = User::TickCount();

 	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, 

 	TUint size = end - start - gPageSize;

 	if(size > maxBytes)

 		size = maxBytes;

 	TUint32 random = 1;

 	TPtrC8 rom;

 	TUint8 *theAddr;

 	//TInt		drvNum = TestBootedFromMmc ? FindMMCDriveNumber(fs) : FindFsNANDDrive(fs);

 	TInt drvNum = FindMMCDriveNumber(fs);

 	TBuf<32>	filename = _L("d:\\Pageldrtst.tmp");

 	if (drvNum >= 0)

 		{

 		filename[0] = (TUint16)('a' + drvNum);

 		DEBUG_PRINT1((_L("%S : Filename %S\n"), &gTestNameBuffer, &filename));

 		}

 	else

 		DEBUG_PRINT((_L("PerformRomAndFileSystemAccessThread : error getting drive num\n")));

 	for(TInt i = (size >> gPageShift); i > 0; --i)

 		{

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

 		if (KErrNone != file.Replace(fs, filename, EFileWrite))

 			{

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

 			}

 		random = random * 69069 + 1;

 		theAddr = (TUint8*)(start+((TInt64(random)*TInt64(size))>>32));

 		if (theAddr + gPageSize > end)

 			{

 			DEBUG_PRINT1((_L("%S : address is past the end 0x%x / 0x%x\n"), &gTestNameBuffer, (TInt)theAddr, (TInt)end));

 			}

 		rom.Set(theAddr,gPageSize);

 		DEBUG_PRINT1((_L("%S : Writing the file\n"), &gTestNameBuffer));

 		TInt ret = file.Write(rom);

 		if (ret != KErrNone)

 			{

 			DEBUG_PRINT1((_L("%S : Write returned error %d\n"), &gTestNameBuffer, ret));

 			}

 		DEBUG_PRINT1((_L("%S : Closing the file\n"), &gTestNameBuffer));

 		file.Close();

 		DEBUG_PRINT1((_L("%S : Deleting the file\n"), &gTestNameBuffer));

 		ret = fs.Delete(filename);

 		if (KErrNone != ret)

 			{

 			DEBUG_PRINT1((_L("%S : Delete returned error %d\n"), &gTestNameBuffer, ret));

 			}

 		if (gTestStopMedia)

 			break;

 		}

 	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* aTestArgs)

 	{

 	TBuf<64>					localBuffer;

 	SPerformTestArgs& testArgs = *(SPerformTestArgs*)aTestArgs;

 	testArgs.iBuffer = &localBuffer;

 	PerformRomAndFileSystemAccessThread(testArgs);

 	return KErrNone;

 	}

 //

 // StartFlushing

 //

 // Create a thread that will continuously flush the paging cache

 //

 void StartFlushing(TRequestStatus &aStatus, RThread &aFlushThread, TBool aLowMem = EFalse)

 	{

 	TInt ret;

 	gTestRunning = ETrue;

 	TThreadCreateInfo flushThreadInfo(_L("FlushThread"), FlushFunc, KDefaultStackSize,NULL);

 	flushThreadInfo.SetCreateHeap(KMinHeapSize, KMinHeapSize);

 	if (!aLowMem)

 		{

 		test_KErrNone(aFlushThread.Create(flushThreadInfo));

 		}

 	else

 		{

 		DOTEST((ret = aFlushThread.Create(flushThreadInfo)), (ret != KErrNoMemory));

 		test_KErrNone(ret);

 		}

 	aFlushThread.Logon(aStatus);

 	aFlushThread.Resume();

 	}

 //

 // FinishFlushing

 //

 // Close the thread flushing the paging cache

 //

 void FinishFlushing(TRequestStatus &aStatus, RThread &aFlushThread)

 	{

 	gTestRunning = EFalse;

 	User::WaitForRequest(aStatus);

 	// TO DO: Check Exit tyoe

 	CLOSE_AND_WAIT(aFlushThread);

 	}

 //

 // ResetResults

 // 

 // Clear the previous results from the results array

 //

 TInt ResetResults()

 	{

 	for (TUint i = 0; i < KMaxTestThreads; i++)

 		{

 		gResultsArray[i].iExitType = KExitTypeReset;

 		gResultsArray[i].iExitReason = KErrNone;

 		}

 	return KErrNone;

 	}

 //

 // CheckResults

 //

 // Check that the results are as expected

 //

 TInt CheckResults()

 	{

 	TUint i;

 	for (i = 0; i < KMaxTestThreads; i++)

 		{

 		if (gResultsArray[i].iExitType == KExitTypeReset)

 			continue;

 		RDBGD_PRINT(("%S : Thread %d ExitType(%d) ExitReason(%d)...\n", 

 					&gTestNameBuffer, i, gResultsArray[i].iExitType, gResultsArray[i].iExitReason));

 		}

 	for (i = 0; i < KMaxTestThreads; i++)

 		{

 		if (gResultsArray[i].iExitType == KExitTypeReset)

 			continue;

 		if (gResultsArray[i].iExitType != EExitKill)

 			{

 			RDBGS_PRINT(("Thread %d ExitType(%d) Expected(%d)\n", i, gResultsArray[i].iExitType, EExitKill));

 			return KErrGeneral;

 			}

 		// Allow for No Memory as we can run out of memory due to high number of threads and

 		// Overflow as the number of chunks that can be created on moving memory model is capped

 		if (gResultsArray[i].iExitReason != KErrNone &&

 			gResultsArray[i].iExitReason != KErrNoMemory &&

 			gResultsArray[i].iExitReason != KErrOverflow)

 			{

 			RDBGS_PRINT(("Thread %d ExitReason(%d) Expected either %d, %d or %d\n", 

 							i, gResultsArray[i].iExitReason, KErrNone, KErrNoMemory, KErrOverflow));

 			return KErrGeneral;

 			}

 		}

 	return KErrNone;

 	}

 //

 // PrintOptions

 //

 // Print out the options of the test

 //

 void PrintOptions()

 	{

 	SVMCacheInfo  tempPages;

 	if (gIsDemandPaged)

 		{

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

 		test.Printf(_L("PerformAutoTest : Start cache info: iMinSize 0x%x iMaxSize 0x%x iCurrentSize 0x%x iMaxFreeSize 0x%x\n"),

 					 tempPages.iMinSize, tempPages.iMaxSize, tempPages.iCurrentSize ,tempPages.iMaxFreeSize);

 		}

 	test.Printf(_L("Loops (%d), Threads (%d), Tests: "), gPerformTestLoop, gNumTestThreads);

 	if (TEST_ALL == (gTestWhichTests & TEST_ALL))

 		{

 		test.Printf(_L("All, "));

 		}

 	else if (gTestWhichTests & TEST_STACK)

 		{

 		test.Printf(_L("Stack, "));

 		}

 	else if (gTestWhichTests & TEST_CHUNK)

 		{

 		test.Printf(_L("Chunk, "));

 		}

 	else if (gTestWhichTests & TEST_COMMIT)

 		{

 		test.Printf(_L("Commit, "));

 		}

 	else if (gTestWhichTests & TEST_IPC)

 		{

 		test.Printf(_L("IPC Pinning, "));

 		}

 	else

 		{

 		test.Printf(_L("?, "));

 		}

 	test.Printf(_L("\nOptions: "));

 	if(gTestInterleave)

 		test.Printf(_L("Interleave "));

 	if(gTestPrioChange)

 		test.Printf(_L("Priority "));

 	if(gTestMediaAccess)

 		test.Printf(_L("Media"));

 	if(gTestBadServer)

 		test.Printf(_L("BadServer"));

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

 	}

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

 	{

 	SVMCacheInfo  tempPages;

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

 	if (gIsDemandPaged)

 		{

 		// get the old cache info

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

 		// set the cache to our test value

 		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)tempPages.iMinSize,(TAny*)(tempPages.iMaxSize * gNumTestThreads));

 		}

 	if (!TestSilent)

 		PrintOptions();

 	TUint startTime = User::TickCount();

 	TInt			 index;

 	TInt ret = KErrNone;

 	TBuf<16> multiThreadName;

 	TBuf<16> rerunThreadName;

 	ResetResults();

 	TRequestStatus flushStatus;

 	RThread flushThread;

 	StartFlushing(flushStatus, flushThread, aLowMem);

 	DOTEST((gThreadHeap = User::ChunkHeap(NULL, 0x1000, 0x1000)), (gThreadHeap != NULL));

 	test_NotNull(gThreadHeap);

 	DOTEST((gStackHeap = User::ChunkHeap(NULL, 0x1000, 0x1000)), (gStackHeap != NULL));

 	test_NotNull(gStackHeap);

 	TThreadCreateInfo	*pThreadCreateInfo = (TThreadCreateInfo *)User::AllocZ(sizeof(TThreadCreateInfo) * gNumTestThreads);

 	RThread				*pTheThreads  = (RThread *)User::AllocZ(sizeof(RThread) * gNumTestThreads);

 	TInt				*pThreadInUse = (TInt *)User::AllocZ(sizeof(TInt) * gNumTestThreads);

 	TRequestStatus	mediaStatus;

 	RThread			mediaThread;

 	DOTEST((ret = TestMsgQueue.CreateLocal(gNumTestThreads * 10, EOwnerProcess)),

 	       (KErrNone == ret));

 	DOTEST((ret = TestMultiSem.CreateLocal(1)),

 	       (KErrNone == ret));

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

 	SPerformTestArgs mediaArgs;

 	mediaArgs.iMsgQueue = &TestMsgQueue; 

 	mediaArgs.iTheSem = &TestMultiSem;

 	mediaArgs.iLowMem = aLowMem;

 	if (gTestMediaAccess)

 		{

 		TThreadCreateInfo mediaInfo(_L(""),PerformRomAndFileSystemAccess,KDefaultStackSize,(TAny*)&mediaArgs);

 		mediaInfo.SetUseHeap(NULL);

 		mediaInfo.SetPaging(TThreadCreateInfo::EPaged);

 		gTestStopMedia = EFalse;

 		ret = mediaThread.Create(mediaInfo);

 		if (ret != KErrNone)

 			return ret;

 		mediaThread.Logon(mediaStatus);

 		RUNTEST1(mediaStatus == KRequestPending);

 		mediaThread.Resume();

 		}

 	TThreadCreateInfo** infoPtrs = new TThreadCreateInfo*[gNumTestThreads]; 

 	if (infoPtrs == NULL)

 		return KErrNoMemory;

 	SPerformTestArgs *testArgs = new SPerformTestArgs[gNumTestThreads];

 	if (testArgs == NULL)

 		return KErrNoMemory;

 	Mem::FillZ(testArgs, gNumTestThreads * sizeof(SPerformTestArgs));

 	for (index = 0; index < gNumTestThreads; index++)

 		{

 		RDBGD_PRINT(("%S : Starting thread.%d!\n", &gTestNameBuffer, index));

 		multiThreadName = _L("TestThread_");

 		multiThreadName.AppendNum(index);

 		testArgs[index].iThreadIndex = index;

 		testArgs[index].iMsgQueue = &TestMsgQueue; 

 		testArgs[index].iTheSem = &TestMultiSem;

 		testArgs[index].iLowMem = aLowMem;

 		RDBGD_PRINT(("Creating thread.%d!\n", index));

 		infoPtrs[index] = new TThreadCreateInfo(multiThreadName, MultipleTestThread, KDefaultStackSize, (TAny*)&testArgs[index]);

 		if (infoPtrs[index] == NULL)

 			continue;

 		infoPtrs[index]->SetCreateHeap(KMinHeapSize, KMinHeapSize);

 		infoPtrs[index]->SetPaging(TThreadCreateInfo::EPaged);

 		//infoPtrs[index]->SetUseHeap(gThreadHeap);

 		DOTEST((ret = pTheThreads[index].Create(*infoPtrs[index])), (ret != KErrNoMemory));

 		if (ret != KErrNone)

 			continue;

 		pTheThreads[index].Resume();

 		pThreadInUse[index] = 1;

 		}

 	// now process any messages sent from the child threads.

 	TBool		anyUsed = ETrue;

 	TBuf<64>	localBuffer;

 	while(anyUsed)

 		{

 		anyUsed = EFalse;

 		// check the message queue and call printf if we get a message.

 		while (KErrNone == TestMsgQueue.Receive(localBuffer))

 			{

 			if (!TestSilent)

 				test.Printf(localBuffer);

 			}

 		// walk through the thread list to check which are still alive.

 		for (index = 0; index < gNumTestThreads; index++)

 			{

 			if (pThreadInUse[index])

 				{

 				if (pTheThreads[index].ExitType() != EExitPending)

 					{

 					if (aLowMem &&

 						pTheThreads[index].ExitType() == EExitKill &&

 						pTheThreads[index].ExitReason() == KErrNoMemory &&

 						Ldd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE) == KErrNone)

 						{// If thread was killed with no memory in a low mem scenario

 						// then release some RAM and restart the thread again

 						anyUsed = ETrue;

 						RDBGD_PRINT(("Thread index %d EExitKill KErrNoMemory\n", index));

 						CLOSE_AND_WAIT(pTheThreads[index]);

 						RDBGD_PRINT(("Re-running Thread index %d\n", index));

 						rerunThreadName = _L("RRTestThread_");

 						rerunThreadName.AppendNum(index);

 						delete infoPtrs[index];				

 						infoPtrs[index] = new TThreadCreateInfo(rerunThreadName, MultipleTestThread, KDefaultStackSize, (TAny*)&testArgs[index]);

 						if (infoPtrs[index] == NULL)

 							continue;

 						infoPtrs[index]->SetCreateHeap(KMinHeapSize, KMinHeapSize);

 						infoPtrs[index]->SetPaging(TThreadCreateInfo::EPaged);

 						//infoPtrs[index]->SetUseHeap(gThreadHeap);

 						ret = pTheThreads[index].Create(*infoPtrs[index]);

 						if (ret != KErrNone)

 							continue;

 						pTheThreads[index].Resume();

 						pThreadInUse[index] = 1;

 						continue;

 						}

 					if (pTheThreads[index].ExitType() == EExitPanic)

 						{

 						RDBGD_PRINT(("%S : Thread Panic'd  %d...\n", &gTestNameBuffer, index));	

 						}

 					//Store the results but let all the threads finish

 					gResultsArray[index].iExitType = pTheThreads[index].ExitType();

 					gResultsArray[index].iExitReason = pTheThreads[index].ExitReason();

 					pThreadInUse[index] = EFalse;

 					pTheThreads[index].Close();

 					}

 				else

 					{

 					anyUsed = ETrue;

 					}

 				}

 			}

 		User::AfterHighRes(50000);

 		}

 	if (gTestMediaAccess)

 		{

 		gTestStopMedia = ETrue;

 		RDBGD_PRINT(("%S : Waiting for media thread to exit...\n", &gTestNameBuffer));	

 		User::WaitForRequest(mediaStatus);

 		mediaThread.Close();

 		}

 	TestMsgQueue.Close();

 	TestMultiSem.Close();

 	// cleanup the resources and exit.

 	User::Free(pTheThreads);

 	User::Free(pThreadInUse);

 	User::Free(pThreadCreateInfo);

 	delete infoPtrs;

 	delete testArgs;

 	FinishFlushing(flushStatus, flushThread);

 	gThreadHeap->Close();

 	gStackHeap->Close();

 	thisThread.SetPriority(savedThreadPriority);

 	ret = CheckResults();

 	RDBGS_PRINT(("Test Complete (%u ticks)\n", User::TickCount() - startTime));

 	if (gIsDemandPaged)

 		{

 		// put the cache back to the the original values.

 		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)tempPages.iMinSize,(TAny*)tempPages.iMaxSize);

 		}

 	return ret;

 	}

 //

 // DoSingleTest

 // 

 // Perform the single thread test,.

 //

 LOCAL_C TInt DoSingleTest(TBool aLowMem = EFalse)

 	{

 	TUint origThreadCount = gNumTestThreads;

 	gNumTestThreads = 1;

 	TInt r = DoMultipleTest(aLowMem);

 	gNumTestThreads = origThreadCount;

 	return r;

 	}

 //

 // 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("-?")))

 				{

 				RDBGS_PRINT(("\nUsage:  %S n", &gTestNameBuffer));

 				RDBGS_PRINT(("\ndebug: Prints out tracing in the test"));

 				RDBGS_PRINT(("\n[single | multiple <numThreads>] : Specify to run in a single thread or multiple threads and how many"));

 				RDBGS_PRINT(("\n[ipc | stack | chunk| commit| all | badserver] : which type of test to run "));

 				RDBGS_PRINT(("\n-> ipc: IPC Pinning tests"));

 				RDBGS_PRINT(("\n-> stack: Stack paging tests"));

 				RDBGS_PRINT(("\n-> chunk: Chunk paging tests"));

 				RDBGS_PRINT(("\n-> commit: Chunk committing tests"));

 				RDBGS_PRINT(("\n-> all: All the above tests"));

 				RDBGS_PRINT(("\n-> badserver: IPC Pinning tests with a dead server"));

 				RDBGS_PRINT(("\n[iters <iters>] : Number of loops each test should perform"));

 				RDBGS_PRINT(("\n[media] : Perform multiple test with media activity in the background"));

 				RDBGS_PRINT(("\n[lowmem] : Perform testing in low memory situations "));

 				RDBGS_PRINT(("\n[interleave]: Perform test with thread interleaving\n\n"));

 				test.Getch();

 				TestExit = ETrue;

 				break;

 				}

 			else if (token == _L("debug"))

 				{

 				if (!TestSilent)

 					{

 					TestDebug = ETrue;

 					gTestPrioChange = ETrue;

 					}

 				}

 			else if (token == _L("silent"))

 				{

 				TestSilent = ETrue;

 				TestDebug = EFalse;

 				}

 			else if (token == _L("single"))

 				{

 				gTestType = ETestSingle;

 				}

 			else if (token == _L("multiple"))

 				{

 				TPtrC val=lex.NextToken();

 				TLex lexv(val);

 				TInt value;

 				if (lexv.Val(value) == KErrNone)

 					{

 					if ((value <= 0) || (value > (TInt)KMaxTestThreads))

 						{

 						gNumTestThreads = KMaxTestThreads;

 						}

 					else

 						{

 						gNumTestThreads = value;

 						}

 					}

 				else

 					{

 					RDBGS_PRINT(("Bad value for thread count '%S' was ignored.\n", &val));

 					}

 				gTestType = ETestMultiple;

 				}

 			else if (token == _L("prio"))

 				{

 				gTestPrioChange = !gTestPrioChange;

 				}

 			else if (token == _L("lowmem"))

 				{

 				gTestType = ETestLowMem;

 				}

 			else if (token == _L("media"))

 				{

 				gTestType = ETestMedia;

 				}

 			else if (token == _L("stack"))

 				{

 				gSetTests = TEST_STACK;

 				}

 			else if (token == _L("chunk"))

 				{

 				gSetTests = TEST_CHUNK;

 				}

 			else if (token == _L("commit"))

 				{

 				gTestType = ETestCommit;

 				gSetTests = TEST_COMMIT;

 				}

 			else if (token == _L("ipc"))

 				{

 				gSetTests = TEST_IPC;

 				}

 			else if (token == _L("badserver"))

 				{

 				gTestType = ETestBadServer;

 				}

 			else if (token == _L("all"))

 				{

 				gSetTests = TEST_ALL;

 				}

 			else  if (token == _L("iters"))

 				{

 				TPtrC val=lex.NextToken();

 				TLex lexv(val);

 				TInt value;

 				if (lexv.Val(value) == KErrNone)

 					{

 					gPerformTestLoop = value;

 					}

 				else

 					{

 					RDBGS_PRINT(("Bad value for loop count '%S' was ignored.\n", &val));

 					retVal = EFalse;

 					break;

 					}

 				}

 			else  if (token == _L("interleave"))

 				{

 				gTestType = ETestInterleave;

 				}

 			else

 				{

 				if ((foundArgs == EFalse) && (token.Length() == 1))

 					{

 					// Single letter argument...only run on 'd'

 					if (token.CompareF(_L("d")) == 0)

 						{

 						break;

 						}

 					else

 						{

 						if (!TestSilent)

 							{

 							test.Title();

 							test.Start(_L("Skipping non drive 'd' - Test Exiting."));

 							test.End();

 							}

 						foundArgs = ETrue;

 						TestExit = ETrue;

 						break;

 						}

 					}

 				RDBGS_PRINT(("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(void)

 	{

 	if (!TestSilent)

 		{

 		TFileName  filename(RProcess().FileName());

 		TParse	myParse;

 		myParse.Set(filename, NULL, NULL);

 		gTestNameBuffer.Zero();

 		gTestNameBuffer.Append(myParse.Name());

 		gTestNameBuffer.Append(_L(".exe"));

 		TestWeAreTheTestBase = !gTestNameBuffer.Compare(_L("t_wdpstress.exe"));

 		}

 	else

 		{

 		gTestNameBuffer.Zero();

 		gTestNameBuffer.Append(_L("t_wdpstress.exe"));

 		}

 	}

 //

 // PerformAutoTest

 //

 // Perform the autotest

 //

 TInt PerformAutoTest()

 	{

 	TInt r = KErrNone;

 	// Run all the different types of test

 	for (TUint testType = 0; testType < ETestTypes; testType++)

 		{

 		r = DoTest(testType);

 		if (r != KErrNone)

 			return r;

 		}

 	return r;

 	}

 //

 // DoLowMemTest

 //

 // Low Memory Test

 //

 TInt DoLowMemTest()

 	{

 	TInt r = User::LoadLogicalDevice(KPageStressTestLddName);

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

 	RUNTEST(Ldd.Open(),KErrNone);

 	SVMCacheInfo  tempPages;

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

 	if (gIsDemandPaged)

 		{

 		// get the old cache info

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

 		TInt	minSize = 8 << gPageShift;

 		TInt	maxSize = 256 << gPageShift;

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

 		}

 	// First load some pages onto the page cache 

 	gPerformTestLoop = 1;

 	r = DoTest(ETestSingle);

 	test_KErrNone(r);

 	Ldd.DoConsumeRamSetup(TEST_LM_NUM_FREE, TEST_LM_BLOCKSIZE);

 	TEST_NEXT((_L("Single thread with Low memory.")));

 	gNumTestThreads	= KMaxTestThreads / 2;

 	gPerformTestLoop = 20;

 	r = DoTest(ETestSingle, ETrue);

 	Ldd.DoConsumeRamFinish();

 	test_KErrNone(r);

 	TEST_NEXT((_L("Multiple thread with Low memory.")));

 	// First load some pages onto the page cache 

 	gPerformTestLoop = 1;

 	r = DoTest(ETestSingle);

 	test_KErrNone(r);

 	Ldd.DoConsumeRamSetup(TEST_LM_NUM_FREE, TEST_LM_BLOCKSIZE);

 	gPerformTestLoop = 10;

 	gNumTestThreads	= KMaxTestThreads / 2;

 	r = DoTest(ETestMultiple, ETrue);

 	Ldd.DoConsumeRamFinish();

 	test_KErrNone(r);

 	TEST_NEXT((_L("Multiple thread with Low memory, with starting free ram.")));

 	// First load some pages onto the page cache 

 	gPerformTestLoop = 1;

 	r = DoTest(ETestSingle);

 	test_KErrNone(r);

 	Ldd.DoConsumeRamSetup(32, TEST_LM_BLOCKSIZE);

 	gPerformTestLoop = 10;

 	gNumTestThreads	= KMaxTestThreads / 2;

 	r = DoTest(ETestMultiple, ETrue);

 	Ldd.DoConsumeRamFinish();

 	test_KErrNone(r);

 	TEST_NEXT((_L("Close test driver")));

 	Ldd.Close();

 	RUNTEST(User::FreeLogicalDevice(KPageStressTestLddName), KErrNone);

 	if (gIsDemandPaged)

 		{

 		TInt minSize = tempPages.iMinSize;

 		TInt maxSize = tempPages.iMaxSize;

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

 		}

 	return r;

 	}

 void RestoreDefaults()

 	{

 	gPerformTestLoop			= 10;					

 	gNumTestThreads				= KMaxTestThreads;	

 	gTestInterleave				= EFalse;

 	gTestWhichTests				= gSetTests;

 	gTestPrioChange				= EFalse;

 	gTestStopMedia				= EFalse;

 	gTestMediaAccess			= EFalse;

 	}

 TInt DoTest(TInt gTestType, TBool aLowMem)

 	{

 	TInt r = KErrNone;

 	switch(gTestType)

 		{

 		case ETestSingle:

 			TEST_NEXT((_L("Single thread")));

 			r = DoSingleTest(aLowMem);

 			break;

 		case ETestMultiple:

 			TEST_NEXT((_L("Multiple thread")));

 			r = DoMultipleTest(aLowMem);

 			break;

 		case ETestLowMem:

 			TEST_NEXT((_L("Low Memory Tests")));

 			r = DoLowMemTest();

 			break;

 		case ETestMedia:

 			TEST_NEXT((_L("Background Media Activity Tests")));

 			gTestMediaAccess = ETrue;

 			gPerformTestLoop = 2;					

 			gNumTestThreads	= KMaxTestThreads / 2;	

 			r = DoMultipleTest(aLowMem);

 			break;

 		case ETestCommit:

 			TEST_NEXT((_L("Committing and Decommitting Tests")));	

 			gTestWhichTests = TEST_COMMIT;

 			r = DoSingleTest(aLowMem);

 			break;

 		case ETestInterleave:

 			TEST_NEXT((_L("Testing multiple with thread interleaving")));

 			gTestInterleave = ETrue;

 			r = DoMultipleTest(aLowMem);

 			break;

 		case ETestBadServer:

 			TEST_NEXT((_L("Testing multiple with thread interleaving")));

 			gTestBadServer = ETrue;

 			gTestWhichTests = TEST_IPC;

 			r = DoSingleTest(aLowMem);

 			break;

 		}

 	RestoreDefaults();

 	return r;

 	}

 //

 // E32Main

 //

 // Main entry point.

 //

 TInt E32Main()

 	{

 #ifndef TEST_ON_UNPAGED

 	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();

 	if(!romHeader->iPageableRomStart)

 		{

 		gIsDemandPaged = EFalse;

 		}

 #endif

 	TUint start = User::TickCount();

 	gResultsArray = (SThreadExitResults *)User::AllocZ(sizeof(SThreadExitResults) * KMaxTestThreads);

 	if (gResultsArray == NULL)

 		return KErrNoMemory;

 	AreWeTheTestBase();

 	RestoreDefaults();

 	TBool parseResult = ParseCommandLine();

 	if (TestExit)

 		{

 		return KErrNone;

 		}

 	// Retrieve the page size and use it to detemine the page shift (assumes 32-bit system).

 	TInt r = HAL::Get(HAL::EMemoryPageSize, gPageSize);

 	if (r != KErrNone)

 		{

 		RDBGS_PRINT(("Cannot obtain the page size\n"));

 		return r;

 		}

 	else

 		{

 		RDBGS_PRINT(("page size = %d\n", gPageSize));

 		}

 	TUint32 pageMask = gPageSize;

 	TUint i = 0;

 	for (; i < 32; i++)

 		{

 		if (pageMask & 1)

 			{

 			if (pageMask & ~1u)

 				{

 				test.Printf(_L("ERROR - page size not a power of 2"));

 				return KErrNotSupported;

 				}

 			gPageShift = i;

 			break;

 			}

 		pageMask >>= 1;

 		}

 	TInt  minSize = 8 << gPageShift;

 	TInt  maxSize = 64 << gPageShift; 

 	SVMCacheInfo  tempPages;

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

 	if (gIsDemandPaged)

 		{

 		// 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("Writable Data Paging stress tests..."));

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

 		}

 	if (parseResult)

 		{

 		if (!TestSilent)

 			{

 			extern TInt *CheckLdmiaInstr(void);

 			test.Printf(_L("%S : CheckLdmiaInstr\n"), &gTestNameBuffer);

 			TInt   *theAddr = CheckLdmiaInstr();

 			test.Printf(_L("%S : CheckLdmiaInstr complete 0x%x...\n"), &gTestNameBuffer, (TInt)theAddr);

 			}

 		if (gTestType < 0 || gTestType >= ETestTypeEnd)

 			{

 			r = PerformAutoTest();

 			test_KErrNone(r);

 			}

 		else

 			{

 			r = DoTest(gTestType);

 			test_KErrNone(r);

 			}

 		}

 	else

 		{

 		r = PerformAutoTest();

 		test_KErrNone(r);

 		}

 	if (gIsDemandPaged)

 		{

 		minSize = tempPages.iMinSize;

 		maxSize = tempPages.iMaxSize;

 		// put the cache back to the the original values.

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

 		}

 	if (!TestSilent)

 		{

 		test.Printf(_L("%S : Complete (%u ticks)\n"), &gTestNameBuffer, User::TickCount() - start);	

 		test.End();

 		}

 	User::Free(gResultsArray);

 	gResultsArray = NULL;

 	return 0;

 	}