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

 	}