// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32test\debug\t_codemodifier.cpp
// Overview:
// Exercises Kernel's Code Modifier. This is common use case for run-mode debuggers.
// API Information:
// DebugSupport::InitialiseCodeModifier
// DebugSupport::CloseCodeModifier
// DebugSupport::ModifyCode
// DebugSupport::RestoreCode
// Kern::ThreadRawRead
// Kern::ThreadRawWrite
// Details:
// -Three applications are running in the test:
// - t_codemodifier.exe client
// - t_codemodifier.exe server (XIP code)
// - t_codemodifier2.exe client (non-XIP code)
// -Test1 -Checks that the TestFunc (that will be altered by breakpoints) is really deadly if un-altered.
// -Test2 -Checks Code Modifier if data segment address is passed to set breakpoint.	
// -Test3 -Checks Code Modifier if invalid address is passed to set breakpoint.Kern::ThreadRawRead\Write is also checked.	
// -Test4 -Replaces BRK instruction in TestFunc with NOP using 1.2 and 4 bytes long breakpoints. Executes the 
// function in the servers.
// -Test5 -Repeats Test4 (for XIP server only) with previously shedowed TestFunc
// -Test6 -Tests scenario when a process terminates while there are still associated breakpoints.
// -Test7 -Tests out-of-breakpoints scenario
// -Test8 -Tests breakpoint-already-exists scenario
// -Test9 -Tests CodeModifier closing when there are still active breakpoints.	Breakpoints in this test occupies more then
// one shadowed page.
// -Test10-A random stress test. Sets/Clears random brekpoints in CodeArea of the both servers. Then replaces
// all BRKs with NOPs in CodeArea and executes them.
// -Test11-Checks that overlaping breakpoints are rejected.
// Platforms/Drives/Compatibility:
// Hardware (Automatic). Not supported on emulator.
// Assumptions/Requirement/Pre-requisites:
// Failures and causes:
// Base Port information:
// 
//

#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <e32ldr.h>
#include <e32ldr_private.h>
#include <f32dbg.h>
#include "d_codemodifier.h"
#include "../misc/prbs.h"

LOCAL_D RTest test(_L("T_CODEMODIFIER"));
_LIT(KServerXIP,"ServerXIP");
_LIT(KServerNONXIP,"ServerNONXIP");
_LIT(KAppXIP,"t_codemodifier.exe");
_LIT(KAppNONXIP,"t_codemodifier2.exe");

extern void TestFunc();
extern void CodeArea();

//------------client globals---------------------
RCodeModifierDevice Device;

/**	These addresses/names is all the client needs to test a server.
	There are XIP and non-XIP server in the test*/
struct SServerData
	{
	TInt  		 iThreadId;
	TUint 		 iVarAddr;
	TUint 		 iFuncAddr;
	TUint 		 iInvalidAddr;
	TUint 		 iCodeAreaAddr;
	const TDesC* iAppName;
	const TDesC* iServerName;
	RProcess 	 iProcess;
	} ServerData[2];

/**Will hold assembler instructions that make TestFunc.*/
struct STestFunc
	{
	TInt iBRK;
	TInt iNOP;
	TInt iRET;
	} TestFuncCode;

/**ServerData[0] is about XIP server, ServerData[1] is non-XIP server*/
enum TWhichServer
	{
	EXip = 0,
	ENonxip = 1
	};

/**Server*/
class CCodeModifierServer : public CServer2
	{
public:
	static CCodeModifierServer* New(TInt aPriority);
private:
	CCodeModifierServer(TInt aPriority) : CServer2(aPriority){}
	CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;
public:
	TInt iTestVar;
	RChunk chunk;
	};

CCodeModifierServer* CCodeModifierServer::New(TInt aPriority)
	{
	return new CCodeModifierServer(aPriority);
	}

/**Server side session*/
class CCodeModifierSession : public CSession2
	{
public:
	enum TCommand {EStop, EGetServerInfo, ERunTestFunc, ERunCodeAreaFunc};
private:
	void ServiceL(const RMessage2& aMessage);
	};

/*Client-side session*/
class RCodeModifierSession : private RSessionBase
	{
public:
	/**Updates ServerData[aServer] with data from the server*/
	static TInt GetServerInfo(TInt aServer)
		{
		TPtr8 ptr((TUint8*)&ServerData[aServer].iThreadId, 5*sizeof(TInt),5*sizeof(TInt));
		TIpcArgs args(&ptr);
		return Control(CCodeModifierSession::EGetServerInfo,aServer,args);
		};
	/**Stops the server*/	
	static TInt Stop(TInt aServer)
		{TIpcArgs args;return Control(CCodeModifierSession::EStop,aServer, args);};
	/**Issues the command to server to run TestFunc*/
	static TInt RunTestFunc(TInt aServer)
		{TIpcArgs args;return Control(CCodeModifierSession::ERunTestFunc,aServer,args);};
	/**Issues the command to server to run CodeArea*/
	static TInt RunCodeAreaFunc(TInt aServer)
		{TIpcArgs args;return Control(CCodeModifierSession::ERunCodeAreaFunc,aServer,args);};
private:
	/*Executes a synchronius client-server request*/
	static TInt Control(CCodeModifierSession::TCommand aRequest, TInt aServer, TIpcArgs& aArgs)
		{
		RCodeModifierSession p;
		TInt r = p.CreateSession(*ServerData[aServer].iServerName, TVersion(), 0);
		if (r == KErrNone)
			p.SendReceive(aRequest, aArgs);
		p.Close();
		return r;
		};
	};

//------------server globals---------------------
CCodeModifierServer* CodeModifierServer;

/**Creates a new client for this server.*/
CSession2* CCodeModifierServer::NewSessionL(const TVersion&, const RMessage2&) const
	{
	return new(ELeave) CCodeModifierSession();
	}

/**Session entry point on the server side.*/
void CCodeModifierSession::ServiceL(const RMessage2& aMessage)
	{
	TInt r=KErrNone;
	switch (aMessage.Function())
		{
	case EGetServerInfo:		//Pass threadId and addresses to the client
		{
		struct SInfo
			{
			TInt  iThreadId;
			TUint iVarAddr;
			TUint iFuncAddr;
			TUint iInvalidAddr;
			TUint iCodeAreaAddr;
			} info;
		RThread thread;
		info.iThreadId =    (TInt) thread.Id();
		info.iVarAddr =     (TUint) &CodeModifierServer->iTestVar;
		info.iInvalidAddr = (TUint)CodeModifierServer->chunk.Base()+0x1000;
		info.iFuncAddr =    (TUint)&TestFunc;
		info.iCodeAreaAddr =(TUint)&CodeArea;
		TPtrC8 ptr((TUint8*)&info, sizeof(SInfo));
		r=aMessage.Write(0,ptr);
		}
		break;

	case ERunTestFunc:			//Execute TestFunc
		TestFunc();
		break;

	case ERunCodeAreaFunc:			//Execute CodeArea
		CodeArea();
		break;

	case EStop:					//This will stop the server thread.
		CActiveScheduler::Stop();
		break;

	default:
		r=KErrNotSupported;
		}
	aMessage.Complete(r);
	}

/**Server application entry point*/
LOCAL_C TInt ServerEntryPoint(TInt aServer)
	{
	TInt r=0;
	__UHEAP_MARK;
	
	CActiveScheduler *pR=new CActiveScheduler;
	if (!pR)
		User::Panic(_L("SVR:Could't create Active Scheduler\n"), KErrNoMemory);
	CActiveScheduler::Install(pR);

	CodeModifierServer = CCodeModifierServer::New(0);
	if(!CodeModifierServer)
		{
		delete pR;
		User::Panic(_L("SVR:Create svr error\n"), KErrNoMemory);
		}

	//Create a chunk with a hole between addresses 0x1000 & 0x2000
	r=CodeModifierServer->chunk.CreateDisconnectedLocal(0,0,0x200000);
	test_KErrNone(r);
	r=CodeModifierServer->chunk.Commit(0,0x1000);
	test_KErrNone(r);
	r=CodeModifierServer->chunk.Commit(0x2000,0x1000);
	test_KErrNone(r);

	//We decide here which server to start.
	if (aServer==0)
		r=CodeModifierServer->Start(KServerXIP);
	else
		r=CodeModifierServer->Start(KServerNONXIP);
		
	if (r!=KErrNone)
		{
		delete CodeModifierServer;
		delete pR;
		User::Panic(_L("SVR:Error starting server\n"), r);
		}
	RProcess::Rendezvous(KErrNone);
	CActiveScheduler::Start();

	//We come here on CActiveScheduler::Stop()
	delete CodeModifierServer;
	delete pR;
	__UHEAP_MARKEND;
	return(KErrNone);
	}

//Initializes the globals and switch off lazy (un)loader. Called just once at the start.
void UpdateClientsGlobals()
	{
	TInt* ptr = (TInt*)TestFunc;
	TestFuncCode.iBRK = *(ptr++);
	TestFuncCode.iNOP = *(ptr++);
	TestFuncCode.iRET = *(ptr++);
	test.Printf(_L("UpdateClientsGlobals BRK:%x NOP:%x RET:%x\n"),TestFuncCode.iBRK,TestFuncCode.iNOP,TestFuncCode.iRET);

	ServerData[0].iAppName=&KAppXIP;
	ServerData[1].iAppName=&KAppNONXIP;
	ServerData[0].iServerName=&KServerXIP;
	ServerData[1].iServerName=&KServerNONXIP;

	//Turn off lazy dll (un)loader.
	//If we don't this, the second run of the test (within 2 minutes of the first one) would fail.
	RLoader l;
	test_KErrNone(l.Connect());
	test_KErrNone(l.CancelLazyDllUnload());
	l.Close();
	}
	
//Starts the server (0-XIP 1-NONXIP server)
//Obtains data from the server
//Updates the driver with the threadID of the server
void StartAndUpdate(TInt aServer)
	{
	TRequestStatus status;
	RProcess& p = ServerData[aServer].iProcess;
	test.Printf(_L("StartAndUpdate %d\n"),aServer);
	//Starts the server
	TInt r = p.Create(*ServerData[aServer].iAppName,*ServerData[aServer].iServerName);
	test_KErrNone(r);
	p.Rendezvous(status);
	p.Resume();
	User::WaitForRequest(status);
	test.Printf(_L("%d returned\n"),status.Int());
	test_KErrNone(status.Int());
	//Get threadId and addresses from the server
	test_KErrNone(RCodeModifierSession::GetServerInfo(aServer));
	SServerData& s = ServerData[aServer];
	test.Printf(_L("ServerData:TId:%x VA:%x FA:%x IA:%x CA:%x \n"),s.iThreadId,s.iVarAddr,s.iFuncAddr,s.iInvalidAddr,s.iCodeAreaAddr);
	//Update threadID of the server in device driver
	test_KErrNone(Device.ThreadId(aServer, s.iThreadId));
	}

//Kills the server(by forcing to execute TestFunc), then restarts it.
void KillAndRestart(TInt aServer)
	{
	test.Printf(_L("KillAndRestart %d\n"),aServer);
	TInt r=RCodeModifierSession::RunTestFunc(aServer);
	test.Printf(_L("%d returned\n"),r);

	test.Printf(_L("Check the server died\n"));
	r = RCodeModifierSession::GetServerInfo(aServer);
	test.Printf(_L("%d returned\n"),r);
	test(r!=KErrNone);
	
	StartAndUpdate(aServer);
	}

//Terminates the server
void TerminateServer(TInt aServer)
	{
	TRequestStatus status;
	RProcess& p = ServerData[aServer].iProcess;

	test.Printf(_L("TerminateServer %d\n"),aServer);
	test_KErrNone(RCodeModifierSession::Stop(aServer));
	p.Logon(status);
	User::WaitForRequest(status);
	test_Equal(EExitKill, p.ExitType());
	CLOSE_AND_WAIT(p);
	}

//Starts LDD
void StartDriver()
	{
	test.Printf(_L("StartDriver\n"));
	TInt r = User::LoadLogicalDevice(KCodeModifierName);
	test_Value(r, r==KErrNone || r==KErrAlreadyExists);
	if((r = Device.Open())!=KErrNone)	
		{
		User::FreeLogicalDevice(KCodeModifierName);
		test.Printf(_L("Could not open LDD"));
		test(0);
		}
	}

//Unloads LDD
void StopDriver()
	{
	test.Printf(_L("StopDriver\n"));
	Device.Close();
	User::FreeLogicalDevice(KCodeModifierName);
	}

//Checks that TestFunc in servers is really deadly if we do not alter the code
void Test1()
	{
	test.Printf(_L("Test1\n"));
	KillAndRestart(EXip);
	}

//Passing data segment address to set breakpoint.
//The actual behaviour depends of the memory model
//ARMv5: KErrBadDescriptor (-38) is returned
//ARMv6: Will return 0
//We have to make sure here that nothing panics or take any nasty behaviour.
void Test2(TInt aServer)
	{
	TInt val;
	test.Printf(_L("Test2 %d\n"), aServer);
	test_KErrNone(Device.InitialiseCodeModifier(10));

	//Write/read data through ThreadRowWrite/Read
	test_KErrNone(Device.WriteWord(aServer, ServerData[aServer].iVarAddr,/*value*/1));
	test_KErrNone(Device.ReadWord(aServer, ServerData[aServer].iVarAddr,&val));
	test_Equal(1, val);
		
	//Set breakpoint
	TInt r=Device.WriteCode(aServer, ServerData[aServer].iVarAddr,/*value*/5, /*size*/4);
	test.Printf(_L("returns %d\n"),r);

	test_KErrNone(Device.CloseCodeModifier());
	}

//Passing invalid address to set breakpoint.
void Test3(TInt aServer)
	{
	TInt val;
	test.Printf(_L("Test3 %d\n"), aServer);
	test_KErrNone(Device.InitialiseCodeModifier(10));

	//Write/read by ThreadRowWrite/Read
	test_Equal(KErrBadDescriptor, Device.WriteWord(aServer, ServerData[aServer].iInvalidAddr,/*value*/1));
	test_Equal(KErrBadDescriptor, Device.ReadWord(aServer, ServerData[aServer].iInvalidAddr,&val));
		
	//Set breakpoints
	test_Equal(KErrBadDescriptor, Device.WriteCode(aServer, ServerData[aServer].iInvalidAddr,/*value*/5, /*size*/1));
	test_Equal(KErrBadDescriptor, Device.WriteCode(aServer, ServerData[aServer].iInvalidAddr,/*value*/5, /*size*/2));
	test_Equal(KErrBadDescriptor, Device.WriteCode(aServer, ServerData[aServer].iInvalidAddr,/*value*/5, /*size*/4));

	test_KErrNone(Device.CloseCodeModifier());
	}

//Replace BRK in TestFunc in server using 1,2 and 4 long breakpoints.
//Check the content of test func.
//Execute Test Func
void Test4(TInt aServer)
	{
	TInt var;
	test.Printf(_L("Test4 %d\n"), aServer);

	//Try to write code segment throught Kern::ThreadRowWrite
	test_Equal(KErrBadDescriptor, Device.WriteWord(aServer, ServerData[aServer].iFuncAddr,/*value*/1));

	test_KErrNone(Device.InitialiseCodeModifier(10));

	test.Printf(_L("Replace byte 3 of the 1st instruction\n"));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iFuncAddr+3,TestFuncCode.iNOP>>24, /*size*/1));
	test_KErrNone(Device.ReadWord(aServer,ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test((TUint)var == ((TestFuncCode.iBRK & 0xffffff) | (TestFuncCode.iNOP & 0xff000000)));

	test.Printf(_L("Replace byte 2 of the 1st instruction\n"));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iFuncAddr+2,TestFuncCode.iNOP>>16, /*size*/1));
	test_KErrNone(Device.ReadWord(aServer,ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test((TUint)var == ((TestFuncCode.iBRK & 0xffff) | (TestFuncCode.iNOP & 0xffff0000)));

	test.Printf(_L("Replace bytes 0 & 1 of the 1st instruction\n"));
	var = TestFuncCode.iNOP | 0xff0000; //byte 3 is messed up - but it won't be writen into code bacause iSize is 2
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iFuncAddr,var, /*size*/2));
	test_KErrNone(Device.ReadWord(aServer,ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test_Equal(TestFuncCode.iNOP, var);

	//We have replaced BRK with NOP. It should be safe now for the server to execute TestFunc.
	test.Printf(_L("Run TestFunc in server and check the server is still alive\n"));
	test_KErrNone(RCodeModifierSession::RunTestFunc(aServer));
	test_KErrNone(RCodeModifierSession::GetServerInfo(aServer));//Any call will work here

	test.Printf(_L("Revert bytes 0 & 1\n"));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iFuncAddr));
	test_KErrNone(Device.ReadWord(aServer, ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test((TUint)var == ((TestFuncCode.iBRK & 0xffff) | (TestFuncCode.iNOP & 0xffff0000)));

	test.Printf(_L("Revert byte 2\n"));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iFuncAddr+2));
	test_KErrNone(Device.ReadWord(aServer, ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test((TUint)var == ((TestFuncCode.iBRK & 0xffffff) | (TestFuncCode.iNOP & 0xff000000)));

	test.Printf(_L("Revert byte 3\n"));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iFuncAddr+3));
	test_KErrNone(Device.ReadWord(aServer, ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test(var == TestFuncCode.iBRK);

	test.Printf(_L("Replace the 1st instruction with the 2nd one in TestFunc\n"));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iFuncAddr,TestFuncCode.iNOP, /*size*/4));
	test_KErrNone(Device.ReadWord(aServer,ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test(var == TestFuncCode.iNOP);

	//We have replaced BRK with NOP. It should be safe now for the server to execute TestFunc.
	test.Printf(_L("Run TestFunc in server and check the server is still alive\n"));
	test_KErrNone(RCodeModifierSession::RunTestFunc(aServer));
	test_KErrNone(RCodeModifierSession::GetServerInfo(aServer));//Any call will work here

	test_KErrNone(Device.CloseCodeModifier());
	}

//Executes Test4 but with previously shadowed page
void Test5(TInt aServer)
	{
	test.Printf(_L("Test5 %d\n"), aServer);

	test_KErrNone(Device.AllocShadowPage(ServerData[aServer].iFuncAddr));
	Test4(aServer);	
	test_KErrNone(Device.FreeShadowPage(ServerData[aServer].iFuncAddr));
	}

//Tests scenario when a process terminates while there are still associated breakpoints.
void Test6(TInt aServer)
	{
	TInt var;
	test.Printf(_L("Test6 %d\n"), aServer);

	test_KErrNone(Device.InitialiseCodeModifier(10));

	test.Printf(_L("Replace the 1st instruction (BRK) with the 2nd one (NOP) in TestFunc\n"));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iFuncAddr,TestFuncCode.iNOP, /*size*/4));
	test_KErrNone(Device.ReadWord(aServer,ServerData[aServer].iFuncAddr, &var));
	test.Printf(_L("%xH returned\n"),var);
	test(var == TestFuncCode.iNOP);

	TerminateServer(aServer);
	//After application has stopped, Kernel should clean the breakpoint associated to the server's process....
	
	StartAndUpdate(aServer);
	KillAndRestart(aServer);//... and TestFunct must be deadly again.

	test_KErrNone(Device.CloseCodeModifier());
	}

//Tests out-of-breakpoints scenario
void Test7(TInt aServer)
	{
	test.Printf(_L("Test7 %d\n"), aServer);
	test_KErrNone(Device.InitialiseCodeModifier(1));

	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr,TestFuncCode.iNOP, /*size*/4));
	test_Equal(KErrNoMemory, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+4,TestFuncCode.iNOP, /*size*/4));

	test_KErrNone(Device.CloseCodeModifier());
	}

//Tests breakpoint-already-exists scenario
void Test8(TInt aServer)
	{
	test.Printf(_L("Test8 %d\n"), aServer);
	test_KErrNone(Device.InitialiseCodeModifier(1));

	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr,TestFuncCode.iNOP, /*size*/4));
	test_Equal(KErrAlreadyExists, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr,TestFuncCode.iNOP, /*size*/4));

	test_KErrNone(Device.CloseCodeModifier());
	}

//Tests CodeModifier closing when there are still breakpoints.
//Breakpoints in this test occupies more then one shadowed page.
void Test9()
	{
	TInt var;
	test.Printf(_L("Test9\n"));
	test_KErrNone(Device.InitialiseCodeModifier(10));

	//Put NOPs at the beginning of the code area
	test_KErrNone(Device.WriteCode(EXip, ServerData[EXip].iCodeAreaAddr,TestFuncCode.iNOP, /*size*/4));
	test_KErrNone(Device.WriteCode(ENonxip, ServerData[ENonxip].iCodeAreaAddr,TestFuncCode.iNOP, /*size*/4));

	//Put NOPs at the end of the code area (there are 1024 BRK instructions in CodeArea
	test_KErrNone(Device.WriteCode(EXip, ServerData[EXip].iCodeAreaAddr+1024*sizeof(TInt),TestFuncCode.iNOP, /*size*/4));
	test_KErrNone(Device.WriteCode(ENonxip, ServerData[ENonxip].iCodeAreaAddr+1024*sizeof(TInt),TestFuncCode.iNOP, /*size*/4));

	//Check NOPs are there
	test_KErrNone(Device.ReadWord(EXip,ServerData[EXip].iCodeAreaAddr, &var));
	test_Equal(TestFuncCode.iNOP, var);
	test_KErrNone(Device.ReadWord(ENonxip,ServerData[ENonxip].iCodeAreaAddr, &var));
	test_Equal(TestFuncCode.iNOP, var);
	test_KErrNone(Device.ReadWord(EXip,ServerData[EXip].iCodeAreaAddr+1024*sizeof(TInt), &var));
	test_Equal(TestFuncCode.iNOP, var);
	test_KErrNone(Device.ReadWord(ENonxip,ServerData[ENonxip].iCodeAreaAddr+1024*sizeof(TInt), &var));
	test_Equal(TestFuncCode.iNOP, var);

	//Close Code Modifier. It should revert the changes in the code.
	test_KErrNone(Device.CloseCodeModifier());

	//Check BRKs are back
	test_KErrNone(Device.ReadWord(EXip,ServerData[EXip].iCodeAreaAddr, &var));
	test_Equal(TestFuncCode.iBRK, var);
	test_KErrNone(Device.ReadWord(ENonxip,ServerData[ENonxip].iCodeAreaAddr, &var));
	test_Equal(TestFuncCode.iBRK, var);
	test_KErrNone(Device.ReadWord(EXip,ServerData[EXip].iCodeAreaAddr+1023*sizeof(TInt), &var));
	test_Equal(TestFuncCode.iBRK, var);
	test_KErrNone(Device.ReadWord(ENonxip,ServerData[ENonxip].iCodeAreaAddr+1023*sizeof(TInt), &var));
	test_Equal(TestFuncCode.iBRK, var);
	}



//Used in test 10 to keep the list of breakpoints
class TBrks:public CBase //derived from CBase as we need data initialized to 0
	{
public:	
	TInt iCounter;				//Counts the number of the active brakpoints
	TInt8 iBreakpoint[1025][2];		//0 - no breakpoint, 1-breakpoint set in CodeArea of XIP Server & NON-XIP server
	};

//Performs a random stress test on breakpoint pool.
//There are 1025*2 words in CodeArea in xip and non-xip server.
//A word is randomly picked up to set or clear 4 bytes long breakpoint.
void Test10()
	{
	TInt i,index,whichServer,var;
	TBrks* brks = new TBrks;
	test((TInt)brks);//fail if no memory
	TUint iSeed[2];
	iSeed[0]=User::TickCount();
	iSeed[1]=0;
	test.Printf(_L("Test10 iSeed=%x\n"), iSeed[0]);

	test_KErrNone(Device.InitialiseCodeModifier(2050));//enought to replace all BRK instructions in CodeArea with NOPs in both servers

	for (i=0; i<1000;i++)
		{
		index=Random(iSeed)%2050;
		whichServer = index>1024 ? 1 : 0;
		if (index >1024)
			index-=1025;
		
		TInt8& brk = brks->iBreakpoint[index][whichServer];
		 if (brk)
		 	{//Remove breakpoint
		 	brk = 0;
			test_KErrNone(Device.RestoreCode(whichServer, ServerData[whichServer].iCodeAreaAddr+index*sizeof(TInt)));
			brks->iCounter--;
		 	}
		 else
		 	{//Set breakpoint
		 	brk = 1;
			test_KErrNone(Device.WriteCode(whichServer, ServerData[whichServer].iCodeAreaAddr+index*sizeof(TInt),TestFuncCode.iNOP, /*size*/4));
			brks->iCounter++;	 	
		 	}
		}
	
	test.Printf(_L("Breakpoints left:%d\n"), brks->iCounter);

	//Check the content of the CodeArea in both XIP and Non-XIP Server
	for (i=0; i<2050;i++)
		{
		whichServer = i>1024 ? 1 : 0;
		if (i<=1024)index = i;
		else		index = i-1025;

		test_KErrNone(Device.ReadWord(whichServer,ServerData[whichServer].iCodeAreaAddr+index*sizeof(TInt), &var));
		if(brks->iBreakpoint[index][whichServer])
			test(var == TestFuncCode.iNOP); //Well, breakpoint is actually NOP ...
		else
			test(var == TestFuncCode.iBRK); //... while the original content is BRK instruction
		}

	//Now, apply breakpoints on all remaining addresses
	for (i=0; i<2050;i++)
		{
		whichServer = i>1024 ? 1 : 0;
		if (i<=1024)index = i;
		else		index = i-1025;

		if(!brks->iBreakpoint[index][whichServer])
			test_KErrNone(Device.WriteCode(whichServer, ServerData[whichServer].iCodeAreaAddr+index*sizeof(TInt),TestFuncCode.iNOP, /*size*/4));
		}

	//All BRKs are replaced with NOPs in CodeArea function in both Servers. It should be safe to call the function.
	test_KErrNone(RCodeModifierSession::RunCodeAreaFunc(EXip));
	test_KErrNone(RCodeModifierSession::GetServerInfo(EXip));//This will check the server is still alive
	test_KErrNone(RCodeModifierSession::RunCodeAreaFunc(ENonxip));
	test_KErrNone(RCodeModifierSession::GetServerInfo(ENonxip));//This will check the server is still alive

	test_KErrNone(Device.CloseCodeModifier()); //This will also remove all breakpoints
	delete brks;
	}

//Tests out-of-breakpoints scenario
void Test11(TInt aServer)
	{
	test.Printf(_L("Test11 %d\n"), aServer);
	test_KErrNone(Device.InitialiseCodeModifier(10));

	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+4, /*aValue*/0, /*size*/4));

	//4 bytes breakpoint
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/4));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/2));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+2, /*aValue*/0, /*size*/2));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/1));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+1, /*aValue*/0, /*size*/1));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+2, /*aValue*/0, /*size*/1));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+3, /*aValue*/0, /*size*/1));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr));

	//2 bytes breakpoint aligned to word
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/2));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/4));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/1));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+1, /*aValue*/0, /*size*/1));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+2, /*aValue*/0, /*size*/2));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr+2));

	//2 bytes breakpoint aligned to word+2
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+2, /*aValue*/0, /*size*/2));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/4));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+2, /*aValue*/0, /*size*/1));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+3, /*aValue*/0, /*size*/1));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/2));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr+2));

	//1 byte breakpoint
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/1));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/4));
	test_Equal(KErrAccessDenied, Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr, /*aValue*/0, /*size*/2));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+1, /*aValue*/0, /*size*/1));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+2, /*aValue*/0, /*size*/1));
	test_KErrNone(Device.WriteCode(aServer, ServerData[aServer].iCodeAreaAddr+3, /*aValue*/0, /*size*/1));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr+1));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr+2));
	test_KErrNone(Device.RestoreCode(aServer, ServerData[aServer].iCodeAreaAddr+3));

	test_KErrNone(Device.CloseCodeModifier());
	}


void ClientAppL()
	{
	test.Start(_L("ClientAppL"));
	UpdateClientsGlobals();
	StartDriver();	
	StartAndUpdate(EXip);
	StartAndUpdate(ENonxip);
	
// All tests run with the following pre-conditions:
// - both XIP and nonXIP server are running.
// - device driver has updated servers' threadIDs (used for setting breakpoints and reading/writing data).
// - all global variables (ServerData, TestFuncCode)are valid.
// - CodeModifier is not installed.
	Test1();
	Test2(EXip);
	Test2(ENonxip);
	Test3(EXip);
	Test3(ENonxip);
	Test4(EXip);
	Test4(ENonxip);
	Test5(EXip);
	Test6(EXip);
	Test7(EXip);
	Test8(EXip);
	Test9();
	Test10();
	Test11(EXip);
	Test11(ENonxip);
	TerminateServer(EXip);
	TerminateServer(ENonxip);
	StopDriver();	
	test.End();
	}

/**Entry point for both client and server apps*/
TInt E32Main()
	{
	//Chech if we are client, XIP server or nonXIP server
	TBuf<64> c;
	User::CommandLine(c);
	if (c.FindF(KServerXIP) >= 0) 
		return ServerEntryPoint(EXip);
	if (c.FindF(KServerNONXIP) >= 0) 
		return ServerEntryPoint(ENonxip);
	
	// client
	CTrapCleanup* trap = CTrapCleanup::New();
	if (!trap)
		return KErrNoMemory;
	test.Title();
	__UHEAP_MARK;
	TRAPD(r,ClientAppL());
	__UHEAP_MARKEND;
	delete trap;
	return r;
	}