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

		{