// Copyright (c) 2006-2010 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:
// Tests the functionality of the run mode debug device driver.
//
//

#include <e32base.h>
#include <e32base_private.h>
#include <e32cons.h>
#include <e32test.h>
#include <e32ldr.h>
#include <e32cmn.h>
#include <e32cmn_private.h>
#include <f32dbg.h>
#include <f32file.h>
#include <hal.h>
#include <u32hal.h>
#include <e32property.h>

#include "t_rmdebug_dll.h"

#include <rm_debug_api.h>
#include "d_rmdebugthread2.h"
#include "t_rmdebug2.h"
#include "t_rmdebug_app.h"

#ifdef __MARM_ARMV4__
#include "d_rmdebug_step_test_armv4.h"
#endif

#ifdef __MARM_ARMV5__
#include "d_rmdebug_step_test.h"
#include "d_rmdebug_bkpt_test.h"
#endif

#include "d_demand_paging.h"

#ifdef KERNEL_OOM_TESTING
	#ifdef USER_OOM_TESTING
		#error "Cannot define both KERNEL_OOM_TESTING and USER_OOM_TESTING"
	#endif
#endif

_LIT8(KCrashDummyData, "This is a sample write");

using namespace Debug;

const TVersion securityServerVersion(0,1,1);

const TVersion testVersion(2,1,0);

IMPORT_C TInt StartDebugThread(RThread& aServerThread, const TDesC& aDebugThreadName);
IMPORT_D extern TInt TestData;
IMPORT_D extern TTestFunction FunctionChooser;
IMPORT_D extern TBuf8<SYMBIAN_RMDBG_MEMORYSIZE> gMemoryAccessBytes;
IMPORT_C TInt TestFunction();
IMPORT_C void TestPagedCode();
IMPORT_C extern TInt RMDebugDemandPagingTest();

// Device driver name
_LIT(KDebugDriverFileName,"rm_debug.ldd");

#ifdef SYMBIAN_STANDARDDEBUG
LOCAL_D RTest test(_L("T_RMDEBUG2"));
#endif

#ifdef SYMBIAN_OEMDEBUG
LOCAL_D RTest test(_L("T_RMDEBUG2_OEM"));
#endif

#ifdef SYMBIAN_OEM2DEBUG
LOCAL_D RTest test(_L("T_RMDEBUG2_OEM2"));
#endif

TBool gUseDelay;

CRunModeAgent::CRunModeAgent()
//
// CRunModeAgent constructor
//
	{
	FillArray();
	RProcess thisProcess;
	iFileName = thisProcess.FileName();
	thisProcess.Close();
	}

CRunModeAgent* CRunModeAgent::NewL()
//
// CRunModeAgent::NewL
//
	{
	CRunModeAgent* self = new(ELeave) CRunModeAgent();

  	self->ConstructL();

	return self;
	}

CRunModeAgent::~CRunModeAgent()
//
// CRunModeAgent destructor
//
	{
	User::FreeLogicalDevice(KDebugDriverFileName);
	iServSession.Close();
	iDebugThread.Close();
	}

void CRunModeAgent::ConstructL()
//
// CRunModeAgent::ConstructL
//
	{
	// nothing to do here
	}

void CRunModeAgent::SetupAndAttachToDSS()
//
// CRunModeAgent::SetupAndAttachToDSS
//
	{
	TInt err = StartDebugThread(iDebugThread, KDebugThreadName);

	// get the thread id for use in the tests
	iThreadID = iDebugThread.Id();

	if (err != KErrNone)
		{
		User::Panic(_L("Can't start debug thread"), err);
		}

	err = iServSession.Connect(securityServerVersion);
	if (err != KErrNone)
		{
		User::Panic(_L("Can't open server session"), err);
		}
	}

CRunModeAgent *RunModeAgent;

// helper function to check whether the listing of type aListId is supported for a scope of aListScope
TBool CRunModeAgent::ListingSupported(const TListId aListId, const TListScope aListScope)
	{
	TTag tag = GetTag(ETagHeaderList, aListId);

	return (tag.iValue) & aListScope;
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0426
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test getting the list of XIP libraries
//! @SYMTestActions The XIP library list should be successfully obtained
//! @SYMTestExpectedResults The specified ldd file should be present in the obtained listing
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestGetXipLibrariesList()
	{
	test.Next(_L("TestGetXipLibrariesList\n"));

	test(ListingSupported(EXipLibraries, EScopeGlobal));
	test(!ListingSupported(EXipLibraries, EScopeProcessSpecific));
	test(!ListingSupported(EXipLibraries, EScopeThreadSpecific));

	//allocate a very small buffer so the GetList call initially fails
	RBuf8 buffer;
	test(KErrNone == buffer.Create(1));
	TUint32 size = 0;

	//get the list data
	DoGetList(EXipLibraries, EScopeGlobal, buffer, size);

	//search the buffer for entry corresponding to the debug kernel driver
	//which should be in the rom
	_LIT(KRmDebugLddName, "z:\\sys\\bin\\rm_debug.ldd");

	//iterate through the buffer and set found to ETrue if we find the driver
	TBool found = EFalse;
	TUint8* ptr = (TUint8*)buffer.Ptr();
	const TUint8* ptrEnd = ptr + size;
	while(ptr < ptrEnd)
		{
		TXipLibraryListEntry& xipLibrary = *(TXipLibraryListEntry*)ptr;

		//get the name of the library
		TPtr name(&xipLibrary.iName[0], xipLibrary.iNameLength, xipLibrary.iNameLength);
		if(name.CompareF(KRmDebugLddName()) == 0)
			{
			//found the library but continue reading the rest of the buffer to
			//check nothing bad happens towards the end
			found = ETrue;
			}
		//move pointer on to next library
		ptr += Align4(xipLibrary.GetSize());
		}
	test(found);

	//do cleanup
	buffer.Close();
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0427
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test getting the list of executables
//! @SYMTestActions The list of debuggable executable files should be obtained
//! @SYMTestExpectedResults The client exe should appear in the list
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestGetExecutablesList()
	{
	test.Next(_L("TestGetExecutablesList\n"));

	test(ListingSupported(EExecutables, EScopeGlobal));
	test(!ListingSupported(EExecutables, EScopeProcessSpecific));
	test(!ListingSupported(EExecutables, EScopeThreadSpecific));

	//allocate a very small buffer so the GetList call initially fails
	RBuf8 buffer;
	test(KErrNone == buffer.Create(1));
	TUint32 size = 0;

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	//get the list data
	DoGetList(EExecutables, EScopeGlobal, buffer, size);

	//get this process' name
	RProcess thisProcess;
	TFileName thisProcessName = thisProcess.FileName();

	//look through the buffer and check if the target debug thread is there
	TBool found = EFalse;
	TUint8* ptr = (TUint8*)buffer.Ptr();
	const TUint8* ptrEnd = ptr + size;
	while(ptr < ptrEnd)
		{
		TExecutablesListEntry& entry = *(TExecutablesListEntry*)ptr;
		//get name
		TPtr name(&entry.iName[0], entry.iNameLength, entry.iNameLength);
		if( (entry.iIsActivelyDebugged != 0) && (0 == thisProcessName.CompareF(name)) )
			{
			//found this process and asserted it is being actively debugged
			found = ETrue;
			}
		//move pointer on to next entry
		ptr += Align4(entry.GetSize());
		}
	test(found);

	//clean up
	buffer.Close();

	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0428
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test error conditions for the GetList calls
//! @SYMTestActions Multiple calls to test calling GetList with bad arguments
//! @SYMTestExpectedResults All tests should fail with the appropriate error codes
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestGetListInvalidData()
	{
	test.Next(_L("TestGetListInvalidData\n"));

	//allocate a buffer, the size should not matter as expecting all calls to fail
	RBuf8 buffer;
	test(KErrNone == buffer.Create(1));
	TUint32 size = 0;

	//test what happens if we ask for an unsupported list type globally
	test(KErrNotSupported == iServSession.GetList((TListId)1234, buffer, size));

	//test what happens if we ask for an unsupported list type
	test(KErrNotSupported == iServSession.GetList(RThread().Id(), (TListId)1234, buffer, size));

	//test what happens if we try to get a non-global libraries list
	test(KErrArgument == iServSession.GetList(RThread().Id(), EXipLibraries, buffer, size));

	//test what happens if we try to get a non-global executables list
	test(KErrArgument == iServSession.GetList(RThread().Id(), EExecutables, buffer, size));

	//test what happens if we try to get a non-global process list
	test(KErrArgument == iServSession.GetList(RThread().Id(), EProcesses, buffer, size));

	//check that using a process id fails
	test(KErrArgument == iServSession.GetList(RProcess().Id(), EProcesses, buffer, size));

	//check that specifying a non-existant thread id fails
	test(KErrArgument == iServSession.GetList((TThreadId)0x12345678, EThreads, buffer, size));

	//check that specifying a non-existant process id fails
	test(KErrArgument == iServSession.GetList((TProcessId)0x12345678, EThreads, buffer, size));

	//check that specifying a non-existant thread id fails
	test(KErrArgument == iServSession.GetList((TThreadId)0x12345678, ECodeSegs, buffer, size));

	//check that specifying a non-existant process id fails
	test(KErrArgument == iServSession.GetList((TProcessId)0x12345678, ECodeSegs, buffer, size));

	//cleanup
	buffer.Close();
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0429
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test getting the process list
//! @SYMTestActions Get the process listing
//! @SYMTestExpectedResults The process listing should be successfully obtained and the current process should be present in the list
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestGetProcessList()
	{
	test.Next(_L("TestGetProcessList\n"));

	test(ListingSupported(EProcesses, EScopeGlobal));
	test(!ListingSupported(EProcesses, EScopeProcessSpecific));
	test(!ListingSupported(EProcesses, EScopeThreadSpecific));

	//allocate a very small buffer so the GetList call fails
	RBuf8 buffer;
	test(KErrNone == buffer.Create(1));
	TUint32 size = 0;

	//get the list data
	DoGetList(EProcesses, EScopeGlobal, buffer, size);

	//initialise data about the target debug thread to compare the kernel's data against
	RProcess thisProcess;
	TFileName thisProcessName = thisProcess.FileName();
	TUint32 processId = thisProcess.Id().Id();

	//look through the buffer and check if the target debug thread is there
	TBool found = EFalse;
	TUint8* ptr = (TUint8*)buffer.Ptr();
	const TUint8* ptrEnd = ptr + size;
	while(ptr < ptrEnd)
		{
		TProcessListEntry& entry = *(TProcessListEntry*)ptr;
		if( (RProcess().Id().Id() == entry.iProcessId) &&
			(0 == thisProcessName.CompareF(TPtr(&(entry.iNames[0]), entry.iFileNameLength, entry.iFileNameLength))) &&
		 	(0 == thisProcess.FullName().CompareF(TPtr(&(entry.iNames[0]) + entry.iFileNameLength, entry.iDynamicNameLength, entry.iDynamicNameLength))) &&
			0x4321bbbb /* Magic */ == entry.iUid3)
			{
			//if all match then we've found it
			found = ETrue;
			}
		ptr += Align4(entry.GetSize());
		}

	//check whether the expected result happened
	test(found);

	//clean up
	buffer.Close();
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0430
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test getting the thread list
//! @SYMTestActions Get the thread listing globally and for a specified thread or process
//! @SYMTestExpectedResults The thread listings should all be successfully obtained and the current thread should be present in all listings
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestGetThreadList()
	{
	test.Next(_L("TestGetThreadList\n"));

	test(ListingSupported(EThreads, EScopeGlobal));
	test(ListingSupported(EThreads, EScopeProcessSpecific));
	test(ListingSupported(EThreads, EScopeThreadSpecific));

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	//test getting the global list, ETrue as should find the target debug thread
	DoTestGetThreadList(ETrue, EScopeGlobal);

	//test getting this thread's thread list, ETrue as should find the target debug thread
	DoTestGetThreadList(ETrue, EScopeThreadSpecific, RThread().Id().Id());

	//test getting this process's thread list, ETrue as should find the target debug thread
	DoTestGetThreadList(ETrue, EScopeProcessSpecific, RProcess().Id().Id());

	test(KErrNone == iServSession.ResumeThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

void CRunModeAgent::DoTestGetThreadList(const TBool aShouldPass, const TListScope aListScope, const TUint64 aTargetId)
	{
	test.Next(_L("DoTestGetThreadList\n"));

	//create data to pass
	RBuf8 buffer;
	TUint32 size = 0;

	//perform the call to get the Code segs
	DoGetList(EThreads, aListScope, buffer, size, aTargetId);

	//initialise data about the target debug thread to compare the kernel's data against
	TFileName name = iDebugThread.FullName();
	RProcess thisProcess;
	TUint64 processId = thisProcess.Id();
	TUint64 threadId = iDebugThread.Id();

	//look through the buffer and check if the target debug thread is there
	TBool found = EFalse;
	TUint8* ptr = (TUint8*)buffer.Ptr();
	const TUint8* ptrEnd = ptr + size;
	while(ptr < ptrEnd)
		{
		TThreadListEntry* entry = (TThreadListEntry*)ptr;
		TPtr entryName(&(entry->iName[0]), entry->iNameLength, entry->iNameLength);
		if( (threadId == entry->iThreadId) && (processId == entry->iProcessId) && (0 == name.CompareF(entryName)) )
			{
			test(entry->iSupervisorStackBaseValid);
			test(entry->iSupervisorStackSizeValid);
			//if all match then we've found it
			found = ETrue;
			}

		ptr += Align4(entry->GetSize());
		}

	//check whether the expected result happened
	test(found == aShouldPass);

	//clean up
	buffer.Close();

	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0431
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test getting the code segment list
//! @SYMTestActions Get the code segment list global and for a specified thread
//! @SYMTestExpectedResults The listings should be returned successfully
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestGetCodeSegsList()
	{
	test.Next(_L("TestGetCodeSegsList\n"));

	test(ListingSupported(ECodeSegs, EScopeGlobal));
	test(ListingSupported(ECodeSegs, EScopeProcessSpecific));
	test(ListingSupported(ECodeSegs, EScopeThreadSpecific));

	// Cannot perform this test with OEM2 debug token, as the t_rmdebug2 app
	// needs AllFiles, and the OEM2 debug token does not authorise this.
	// It seems reasonable to suppose that it would work anyway

#ifndef SYMBIAN_OEM2DEBUG
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

 	//test getting the global list, ETrue as should find this process' main codeSeg
	DoTestGetCodeSegsList(ETrue, EScopeGlobal);

	//test getting this process' codeSegs, ETrue as should find this process' main codeSeg
	DoTestGetCodeSegsList(ETrue, EScopeProcessSpecific, RProcess().Id().Id());

	//test getting this thread's codeSegs, ETrue as should find this process' main codeSeg
	DoTestGetCodeSegsList(ETrue, EScopeThreadSpecific, RThread().Id().Id());

	test(KErrNone == iServSession.DetachExecutable(iFileName));
#endif // SYMBIAN_OEM2DEBUG

	}

void CRunModeAgent::DoTestGetCodeSegsList(const TBool aShouldPass, const TListScope aListScope, const TUint64 aTargetId)
	{
	//create data to pass
	RBuf8 buffer;
	TUint32 size = 0;

	//perform the call to get the Code segs
	DoGetList(ECodeSegs, aListScope, buffer, size, aTargetId);

	//create memoryInfo to contain info about this process
	RProcess thisProcess;
	TModuleMemoryInfo memoryInfo;
	test(KErrNone == thisProcess.GetMemoryInfo(memoryInfo));

	// check whether this process came from a file in ROM so we know whether to
	// expect the code seg to be XIP or not.
	RFs fs;
	test(KErrNone == fs.Connect());
	TBool thisFileIsInRom = EFalse;
	if(fs.IsFileInRom(iFileName))
		{
		thisFileIsInRom = ETrue;
		}

	//look through the buffer to find this process' main code seg
	TBool found = EFalse;
	TUint8* ptr = (TUint8*)buffer.Ptr();
	const TUint8* ptrEnd = ptr + size;
	while(ptr < ptrEnd)
		{
		TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

		if( (codeSeg->iIsXip == thisFileIsInRom) && (0 == iFileName.CompareF(TPtr(&(codeSeg->iName[0]), codeSeg->iNameLength, codeSeg->iNameLength))) )
			{
			if( (memoryInfo.iCodeBase == codeSeg->iCodeBase) &&
					(memoryInfo.iCodeSize == codeSeg->iCodeSize) &&
					(memoryInfo.iConstDataSize == codeSeg->iConstDataSize) &&
					(memoryInfo.iInitialisedDataBase == codeSeg->iInitialisedDataBase) &&
					(memoryInfo.iInitialisedDataSize == codeSeg->iInitialisedDataSize) &&
					(memoryInfo.iUninitialisedDataSize == codeSeg->iUninitialisedDataSize))
				{
				//all matched so means we've found the codeSeg we're looking for
				found = ETrue;
				}
			}
		ptr += Align4(codeSeg->GetSize());
		}

	//check whether the result was as expected
	test(found == aShouldPass);

	// only care about rm_debug.ldd if we have global scope (belongs to the system not this process)
	if (aListScope == EScopeGlobal)
	{
		// Search for rm_debug.ldd library and check its UID3 is correct
		found = EFalse;

_LIT(KRMDebugDriverFileName,"Z:\\sys\bin\\rm_debug.ldd");

		TFileName rmdebugFilename(KRMDebugDriverFileName);

		// reset the Ptr
		ptr = (TUint8*)buffer.Ptr();
		ptrEnd = ptr+size;
		while(ptr < ptrEnd)
		{
			TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

			if( rmdebugFilename.CompareF(TPtr(&(codeSeg->iName[0]), codeSeg->iNameLength, codeSeg->iNameLength)))
				{
				if(codeSeg->iUid3 == 0x101f7157 /* Magic */)
					{
					//all matched so means we've found the codeSeg we're looking for
					found = ETrue;
					}
				}
			ptr += Align4(codeSeg->GetSize());
		}
		test((TUint32)found == (TUint32)ETrue);
	}

	//clean up
	buffer.Close();

	}

void CRunModeAgent::DoGetList(const TListId aListId, const TListScope aListScope, RBuf8& aBuffer, TUint32& aSize, const TUint64 aTargetId)
	{
	//close the buffer in case there's stuff allocated in it
	aBuffer.Close();
	//initialise it to be one byte big, which will guarantee data won't fit in it
	test(KErrNone == aBuffer.Create(1));
	aSize = 0;

	//should pass this test (assuming we've passed in sensible arguments above...)
	if(EScopeGlobal == aListScope)
		{
		test(KErrTooBig == iServSession.GetList(aListId, aBuffer, aSize));
		}
	else if(EScopeThreadSpecific == aListScope)
		{
		test(KErrTooBig == iServSession.GetList((TThreadId)aTargetId, aListId, aBuffer, aSize));
		}
	else if(EScopeProcessSpecific == aListScope)
		{
		test(KErrTooBig == iServSession.GetList((TProcessId)aTargetId, aListId, aBuffer, aSize));
		}
	else
		{
		// unknown list scope
		test(0);
		}

	//keep allocating larger buffers, beginning with the aSize returned by the above call,
	//and hopefully we'll eventually make a large enough one
	test(KErrNone == aBuffer.ReAlloc(aSize));

	for(;;)
		{
		TInt err = KErrNone;
		if(EScopeGlobal == aListScope)
			{
			err = iServSession.GetList(aListId, aBuffer, aSize);
			}
		else if(EScopeThreadSpecific == aListScope)
			{
			err = iServSession.GetList((TThreadId)aTargetId, aListId, aBuffer, aSize);
			}
		else if(EScopeProcessSpecific == aListScope)
			{
			err = iServSession.GetList((TProcessId)aTargetId, aListId, aBuffer, aSize);
			}
		else
			{
			// unknown list scope
			test(0);
			}
		if(err == KErrTooBig)
			{
			//wasn't big enough so double it
			aSize = aSize << 1;
			err = aBuffer.ReAlloc(aSize);
			if(err != KErrNone)
				{
				//print out a message if couldn't allocate memory and quit
				test.Printf(_L("Out ot memory when attempting to allocate %d bytes."), aSize);
				test(KErrNone == err);
				}

			//fairly arbitrary test, we don't have a max size for these calls.
			//In reality a list would have to have many thousands of elements
			//to break this test which shouldn't really happen
			test(aSize <= 0x4000);
			}
		else
			{
			test(KErrNone == err);
			test(aBuffer.Length() == aSize);
			//break out of the loop if the list has been successfully read in
			break;
			}
		}
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0432
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test reading and writing memory
//! @SYMTestActions Multiple calls to read and write memory, with various sizes and at various locations.
//!	Also test that bad input values cause appropriate errors to be returned.
//! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestMemoryAccess()
{
	TInt err;

	test.Next(_L("TestMemoryAccess - Read Memory\n"));

	//initialise buffer
	gMemoryAccessBytes.SetLength(0);
	for (TInt i=0; i<SYMBIAN_RMDBG_MEMORYSIZE; i++)
		{
		gMemoryAccessBytes.Append(i);
		}

	TUint32 address = (TUint32)(&gMemoryAccessBytes[0]);
	TUint32 dataSize = SYMBIAN_RMDBG_MEMORYSIZE;

	//create size for buffer that is rounded up to nearest 4 bytes if not
	//already 4 byte aligned
	TUint32 size = dataSize;
	if(size % 4 != 0)
		{
		size += (4 - (size % 4));
		}

	RBuf8 dataBlock;
	err = dataBlock.Create(size);
	test(err==KErrNone);
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	//suspend the thread prior to memory operations
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8);
	test(err==KErrNone);

	for (TInt i=0; i<dataSize; i++)
		{
		test(dataBlock.Ptr()[i] == gMemoryAccessBytes[i]);
		}

	test.Next(_L("TestMemoryAccess - Write Memory\n"));

	// Now reset the buffer
	for (TInt i=0; i<dataSize; i++)
		{
		gMemoryAccessBytes[i] = 0;
		}

	// Write our data into the buffer
	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8);
	test(err==KErrNone);

	for (TInt i=0; i<dataSize; i++)
		{
		test(dataBlock.Ptr()[i] == gMemoryAccessBytes[i]);
		}

	//final test that everything's not been going wrong
	test(gMemoryAccessBytes[5] != 0);

	test.Next(_L("TestMemoryAccess - Invalid arguments\n"));
	test.Printf(_L("This test may emit crash-like information. This is intended.\n"));

	//test address that is not 32 bit aligned
	err = iServSession.ReadMemory(iThreadID, address + 1, size, dataBlock, EAccess32, EEndLE8);
	test(err == KErrArgument);

	//test size that is not multiple of 4 bytes
	err = iServSession.WriteMemory(iThreadID, address, size + 2, dataBlock, EAccess32, EEndLE8);
	test(err == KErrArgument);

	//test size > max block size
	err = iServSession.ReadMemory(iThreadID, address, (1<<15), dataBlock, EAccess32, EEndLE8);
	test(err == KErrArgument);

	//test access size == 2 bytes
	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess16, EEndLE8);
	test(err == KErrNotSupported);

	//test access size == 1 byte
	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess8, EEndLE8);
	test(err == KErrNotSupported);

	//test endianess == EEndBE8
	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess32, EEndBE8);
	test(err == KErrNotSupported);

	//test endianess == EEndBE32
	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndBE32);
	test(err == KErrNotSupported);

	//test reading off end of memory
	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x00000101, dataBlock, EAccess32, EEndLE8);
	test(err == KErrArgument);

	//The following three tests check that edge conditions in the range check are handled correctly.
	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x000000FF, dataBlock, EAccess32, EEndLE8);
	test(err == KErrArgument);

	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x000000F0, dataBlock, EAccess32, EEndLE8);
	test(err == KErrBadDescriptor);

	//Third range check test. Check that range check is handled correctly even when base + size wraps to 0.
	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x00000100, dataBlock, EAccess32, EEndLE8);
	test(err == KErrBadDescriptor);
	//end of range check tests

	//test size == 0
	err = iServSession.WriteMemory(iThreadID, address, 0, dataBlock, EAccess32, EEndLE8);
	test(err == KErrArgument);

	//attempt to write to address outside of process data segments,
	//this address corresponds to the vectors so shouldn't be able to write
	err = iServSession.WriteMemory(iThreadID, 0xffff0000, size, dataBlock, EAccess32, EEndLE8);
	test(err == KErrBadDescriptor);

	//attempt to read and write to address in process code segment

	//open a handle to the thread
	RThread debugThread;
	test(debugThread.Open(iThreadID) == KErrNone);

	//get a reference to the debug process
	RProcess debugProcess;
	test(debugThread.Process(debugProcess) == KErrNone);

	//get the memory info for the process
	TProcessMemoryInfo info;
	test(debugProcess.GetMemoryInfo(info) == KErrNone);

	address = info.iCodeBase;
	if(size <= info.iCodeSize)
		{
		test(KErrNone == iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8));
		test(KErrBadDescriptor == iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8));
		}

	// Some performance tests now
	TUint32 bytesRead = 0;

	// Allocate a data buffer
	TUint32* p = (TUint32*)User::Alloc(size);
	test(p != 0);

	TInt nanokernel_tick_period;
	HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);
	test (nanokernel_tick_period != 0);

	static const TInt KOneMillion = 1000000;

	TInt nkTicksPerSecond = KOneMillion/nanokernel_tick_period;

	TUint32 stopTickCount = User::NTickCount() + nkTicksPerSecond;

	while (User::NTickCount() < stopTickCount)
		{
		err = iServSession.ReadMemory(iThreadID, (TUint32)p, size, dataBlock, EAccess32, EEndLE8);
		test(err==KErrNone);

		// Increase the count of bytes read
		bytesRead += size;
		}

	test(bytesRead != 0);
	iMemoryReadKbytesPerSecond = bytesRead/1024;

	// write memory test
	TUint32 bytesWritten = 0;

	stopTickCount = User::NTickCount() + nkTicksPerSecond;

	while (User::NTickCount() < stopTickCount)
		{
		err = iServSession.WriteMemory(iThreadID, (TUint32)p, size, dataBlock, EAccess32, EEndLE8);
		test(err==KErrNone);

		// Increase the count of bytes read
		bytesWritten += size;
		}

	test (bytesWritten != 0);
	iMemoryWriteKbytesPerSecond = bytesWritten/1024;

	User::Free(p);

	//resume the thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));

	debugThread.Close();
	dataBlock.Close();

	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0433
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test suspending and resuming threads
//! @SYMTestActions Multiple calls to suspend and resume threads with and without attaching to the thread
//! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestSuspendResume()
	{
	TInt err;

	test.Next(_L("TestSuspendResume - Suspend\n"));

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	// Suspend the thread
	err = iServSession.SuspendThread(iThreadID);
	test(err==KErrNone);
	TInt localtestdata;
	localtestdata = TestData;

	// Wait 3 seconds (suspends this thread) and hopefully resumes the
	// thread we are controlling via the iServSession.SuspendThread request
	User::After(3000000);

	// Now check data hasnt changed
	test(localtestdata==TestData);

	// Resume the thread
	test.Next(_L("TestSuspendResume - Resume\n"));
	err = iServSession.ResumeThread(iThreadID);
	test(err==KErrNone);

	test(KErrNone == iServSession.DetachExecutable(iFileName));

	// Wait 3 seconds (suspends this thread) and hopefully resumes the
	// thread we are controlling via the iServSession.SuspendThread request
	User::After(3000000);

	// Now check that the thread being controlled has resumed and is
	// updating the variable
	test(localtestdata!=TestData);

	// check that agent can resume thread which it previously detached from
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	test(KErrNone == iServSession.SuspendThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	test(KErrNone == iServSession.ResumeThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));

	// check that agent cannot suspend thread which it previously suspended and then detached from
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	test(KErrNone == iServSession.SuspendThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	test(KErrAlreadyExists == iServSession.SuspendThread(iThreadID));
	test(KErrNone == iServSession.ResumeThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0434
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test getting the debug functionality from the driver
//! @SYMTestActions Get the size and contents of the debug functionality block
//! @SYMTestExpectedResults All tests should pass and the expected data should appear in the functionality block
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestDebugFunctionality()
	{

	TInt err;

	test.Next(_L("TestDebugFunctionality - GetDebugFunctionalityBufSize\n"));

	TUint32 bufsize = 0;	// Safe default size

	// Get functionality block size
	err = iServSession.GetDebugFunctionalityBufSize(&bufsize);
	test(err==KErrNone);
	test.Next(_L("TestDebugFunctionality - GetDebugFunctionality\n"));

	// Ensure we have a finite buffer size
	test(bufsize!=0);

	// Allocate space for the functionality data
	HBufC8* dftext = HBufC8::NewLC(bufsize);

	// create an empty TPtr8 refering to dftext
	TPtr8 dftextPtr(dftext->Des());

	// Get the functionality block
	err = iServSession.GetDebugFunctionality(dftextPtr);
	test(err==KErrNone);

	// Check that the first entry is correct
	TTagHeader RefHdr =
	{
		ETagHeaderIdCore,ECoreLast,
	};

	// First header passed from rm_debug.ldd
	TTagHeader* TestHdr = (TTagHeader*)dftextPtr.Ptr();

	// Check
	test(RefHdr.iTagHdrId==TestHdr->iTagHdrId);
	// this test might fail if the agent is used with a Debug Security Server different from
	// the one it was compiled against. So removing it for now.
	//test(RefHdr.iNumTags==TestHdr->iNumTags);

	// read a value from the data to check it has come through as expected
	TTagHeader* header = GetTagHdr(dftext->Des(), ETagHeaderIdApiConstants);
	test(header != NULL);
	TTag* tag = GetTag(header, EApiConstantsTEventInfoSize);
	test(tag != NULL);
	// this test might fail if the agent is used with a Debug Security Server different from
	// the one it was compiled against. So removing it for now.
	//test(sizeof(TEventInfo) == tag->iValue);

	// Remove our temporary buffer
	CleanupStack::PopAndDestroy(dftext);
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0435
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test setting and clearing consecutive breakpoints
//! @SYMTestActions Set and clear consecutive breakpoints of all combinations of breakpoint types
//! @SYMTestExpectedResults All breakpoints should be set and cleared without error
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestConsecutiveBreakPoints()
	{
	test.Next(_L("TestConsecutiveBreakPoints\n"));

	test(KErrNone == iServSession.SuspendThread(iThreadID));

	// just a temporary structure for storing info about a breakpoint
	struct TBreakPoint
		{
	public:
		TBreakPoint()
			:iId(0),
			iMode((TArchitectureMode)0),
			iAddress(0)
			{}
		TBreakId iId;
		TArchitectureMode iMode;
		TUint32 iAddress;
		inline TInt Size() { return (EArmMode == iMode) ? 4 : 2; }
		};

	//an address in the target debug thread
	TUint32 address = (TUint32)(&TestFunction);

	// there are six orders in which three breakpoints can be set, these are looped
	// through below to check setting and clearing consecutive breakpoints works
	TUint8 order[6][3] =
		{
			{0,1,2},
			{0,2,1},
			{1,0,2},
			{1,2,0},
			{2,0,1},
			{2,1,0}
		};

	// The following code checks that setting and clearing consecutive breakpoints works correctly:
	// It checks that setting all combinations of three arm and thumb breakpoints succeeds, and check that the
	// breakpoints can be set in any order, and then cleared in any order

	// the 3 least significant bits of i control whether each of the three breakpoints should be arm or thumb
	for(TInt i=0; i<8; i++)
		{
		// controls the order in which the breakpoints should be set
		for(TInt j=0; j<6; j++)
			{
			// create the three breakpoints and set their modes
			TBreakPoint bp[3];
			bp[0].iMode = (i&1) ? EArmMode : EThumbMode;
			bp[1].iMode = (i&2) ? EArmMode : EThumbMode;
			bp[2].iMode = (i&4) ? EArmMode : EThumbMode;

			// set the address of each of the breakpoints
			bp[0].iAddress = address;
			if(EArmMode == bp[0].iMode)
				{ // if an arm breakpoint then must be on a four byte boundary
				bp[0].iAddress = Align4(bp[0].iAddress);
				}
			bp[1].iAddress = bp[0].iAddress + bp[0].Size();
			if(EArmMode == bp[1].iMode)
				{ // if an arm breakpoint then must be on a four byte boundary
				bp[1].iAddress = Align4(bp[1].iAddress);
				}
			bp[2].iAddress = bp[1].iAddress + bp[1].Size();
			if(EArmMode == bp[2].iMode)
				{ // if an arm breakpoint then must be on a four byte boundary
				bp[2].iAddress = Align4(bp[2].iAddress);
				}
			for(TInt k=0; k<6; k++)
				{
				// set the three breakpoints in the order defined by j and then clear them in the order defined by k
				test(KErrNone==iServSession.SetBreak(bp[order[j][0]].iId, iThreadID, bp[order[j][0]].iAddress, bp[order[j][0]].iMode));
				test(KErrNone==iServSession.SetBreak(bp[order[j][1]].iId, iThreadID, bp[order[j][1]].iAddress, bp[order[j][1]].iMode));
				test(KErrNone==iServSession.SetBreak(bp[order[j][2]].iId, iThreadID, bp[order[j][2]].iAddress, bp[order[j][2]].iMode));
				test(KErrNone==iServSession.ClearBreak(bp[order[k][0]].iId));
				test(KErrNone==iServSession.ClearBreak(bp[order[k][1]].iId));
				test(KErrNone==iServSession.ClearBreak(bp[order[k][2]].iId));
				}
			}
		}

	// resume the thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0436
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test breakpoint functionality
//! @SYMTestActions Multiple calls to set and clear breakpoints. Checking bad input produces appropriate errors.
//! @SYMTestExpectedResults All tests should pass and the target debug thread should be left unaffected
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestBreakPoints()
	{
	TInt err;

	test.Next(_L("TestBreakPoints - Set\n"));

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	TestConsecutiveBreakPoints();

	//an address in the target debug thread
	TUint32 address = (TUint32)(&TestFunction);

	/*
	 * Ensure that breakpoint operations don't
	 * affect memory read/write by checking that reads/writes
	 * in locations containing breakpoints don't change behaviour
	 * because of the breakpoints.
	 */

	TUint32 size = SYMBIAN_RMDBG_MEMORYSIZE;

	RBuf8 originalDataBlock;
	err = originalDataBlock.Create(size);
	test(err==KErrNone);

	//suspend the thread
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	err = iServSession.ReadMemory(iThreadID, address, size, originalDataBlock, EAccess32, EEndLE8);
	test(err==KErrNone);

	// Test data block for comparison
	RBuf8 testDataBlock;
	err = testDataBlock.Create(size);
	test(err==KErrNone);

	/*
	 * set an arm breakpoint
	 */
	TBreakId armBreakId = 0;
	err = iServSession.SetBreak(armBreakId, iThreadID, address, EArmMode);
	test(err == KErrNone);

	// Ensure that memory read is not corrupted
	err = iServSession.ReadMemory(iThreadID, address, size, testDataBlock, EAccess32, EEndLE8);
	test(err==KErrNone);

	test (testDataBlock == originalDataBlock);

	/*
	 * set a thumb breakpoint
	 */
	TBreakId thumbBreakId = 0;
	err = iServSession.SetBreak(thumbBreakId, iThreadID, address+4, EThumbMode);
	test(err == KErrNone);

	/*
	 * set a thumb2EE breakpoint
	 */
	TBreakId thumb2EEBreakId = 0;
	err = iServSession.SetBreak(thumb2EEBreakId, iThreadID, address+8, EThumb2EEMode);
	test(err == KErrNotSupported);

	/*
	 * overlapping breakpoint (same address/threadId/mode)
	 */
	TBreakId overlapBreakId = 0;
	err = iServSession.SetBreak(overlapBreakId, iThreadID, address, EArmMode);
	test(err == KErrAlreadyExists);

	/*
	 * overlapping breakpoint (different address/same threadId/different mode)
	 *
	 * address - EArmBreakpoint
	 * address+2 - EThumbBreakpoint
	 */
	TBreakId overlap2BreakId = 0;
	err = iServSession.SetBreak(overlap2BreakId, iThreadID, address+2, EThumbMode);
	test(err == KErrAlreadyExists);

	/*
	 * Un-aligned address (arm)
	 */
	TBreakId armUnalignedBreakId = 0;
	err = iServSession.SetBreak(armUnalignedBreakId, iThreadID, address+6, EArmMode);
	test(err == KErrArgument);

	/*
	 * Un-aligned address (thumb)
	 */
	TBreakId thumbUnalignedBreakId = 0;
	err = iServSession.SetBreak(thumbUnalignedBreakId, iThreadID, address+7, EThumbMode);
	test(err == KErrArgument);

	/*
	 * Invalid address (arm)
	 */
	TBreakId armBadAddressBreakId = 0;
	err = iServSession.SetBreak(armBadAddressBreakId, iThreadID, 0 /* address */, EThumbMode);
	test(err == KErrBadDescriptor);

	/*
	 * Different thread, same address. Should fail for the same process, but succeed
	 * for a different process.
	 */

	/*
	 * Invalid thread
	 */
	TBreakId invalidThreadBreakId = 0;
	err = iServSession.SetBreak(invalidThreadBreakId, 0xbabababa, address, EThumbMode);
	test(err == KErrPermissionDenied);

	// Clear the ARM breakpoint
	err = iServSession.ClearBreak(armBreakId);
	test(err == KErrNone);

	// Clear the Thumb breakpoint
	err = iServSession.ClearBreak(thumbBreakId);
	test(err == KErrNone);

	// to do : two threads at the same address
	// to do : two processes at the same address

	// Ensure that memory read is not corrupted after clearing the breakpoints
	err = iServSession.ReadMemory(iThreadID, address, size, testDataBlock, EAccess32, EEndLE8);
	test(err==KErrNone);

	test (testDataBlock == originalDataBlock);

	/*
	 * How fast can we set breakpoints?
	 *
	 * Measure the time by setting/clearing breakpoints for 1 second.
     */
	TInt nanokernel_tick_period;
	HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);
	test (nanokernel_tick_period != 0);

	TInt nkTicksPerSecond = HelpTicksPerSecond();

	TInt breaksPerSecond = 0;

	TUint32 stopTickCount = User::NTickCount() + nkTicksPerSecond;

	while (User::NTickCount() < stopTickCount)
		{
		// set the breakpoint
		TBreakId armBreakId = 0;
		err = iServSession.SetBreak(armBreakId, iThreadID, address, EArmMode);
		test(err == KErrNone);

		// Clear the breakpoint
		err = iServSession.ClearBreak(armBreakId);
		test(err == KErrNone);

		// Update the count of breakpoints
		breaksPerSecond++;

		// Gone wrong if we wrap to negative breakpoints (cannot set 2billion/second!)
		test(breaksPerSecond >0);
		}

	// Store the results for later
	iBreakpointsPerSecond = breaksPerSecond;

	/*
	 * How many breakpoints can we set?
	 */

	TBool done = EFalse;

	// We assume all the breakpoints id's are issued in ascending order
	TInt maxBreakPoints = 0;

	// Temporary buffer
	RArray<TBreakId> breakIdList;

	TUint32 testAddress = address;

	while(!done)
		{
		TBreakId breakId = 0;

		// set the breakpoint
		testAddress += 4;	// ensure the addresses don't overlap

		err = iServSession.SetBreak(breakId, iThreadID, testAddress, EArmMode);
		test (err == KErrNone || err == KErrOverflow);
		if (err != KErrNone)
			{
			// we've reached the limit of the number of breaks we can set
			done = ETrue;
			break;
			}

		// store the id of this breakpoint
		breakIdList.Append(breakId);

		// Increase the count of breakpoints
		maxBreakPoints++;
		test(maxBreakPoints > 0);
		}

	// How many breakpoints can we set?
	iMaxBreakpoints = maxBreakPoints;

	// now clear all those breakpoints again
	while(breakIdList.Count() != 0)
		{
		// Place it into a TBreakId
		TBreakId id = breakIdList[0];

		err = iServSession.ClearBreak(id);
		test(err == KErrNone);

		// next id
		breakIdList.Remove(0);
		}

	breakIdList.Close();

	// close our temporary buffers
	originalDataBlock.Close();
	testDataBlock.Close();

	err = iServSession.ResumeThread(iThreadID);
	test (err == KErrNone);

	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0437
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test modifying breakpoints
//! @SYMTestActions Several calls to modify breakpoints
//! @SYMTestExpectedResults Valid requests should result in the breakpoints being changed, invalid requests should return errors
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestModifyBreak()
	{
	test.Next(_L("TestModifyBreak\n"));

	DoTestModifyBreak(ETrue);
	DoTestModifyBreak(EFalse);
	}

void CRunModeAgent::DoTestModifyBreak(TBool aThreadSpecific)
	{
	test.Printf(_L("DoTestModifyBreak: aThreadSpecific: %d\n"), aThreadSpecific?1:0);

	TInt err;

	RProcess process;
	TProcessId processId = process.Id();
	process.Close();

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	//suspend the thread
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	//an address in the target debug thread
	TUint32 address = (TUint32)(&TestFunction);

	//set an arm mode break point
	TBreakId armBreakId = 0;
	err = aThreadSpecific
		? iServSession.SetBreak(armBreakId, iThreadID, address, EArmMode)
		: iServSession.SetProcessBreak(armBreakId, processId, address, EArmMode);
	test(err == KErrNone);

	/*
	 * Invalid thread
	 */
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, 0xbabababa, address, EArmMode)
		: iServSession.ModifyProcessBreak(armBreakId, 0xbabababa, address, EArmMode);
	test(err == KErrPermissionDenied);

	/*
	 * Valid address
	 */
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, iThreadID, address+4, EArmMode)
		: iServSession.ModifyProcessBreak(armBreakId, processId, address+4, EArmMode);
	test(err == KErrNone);

	/*
	 * Invalid address
	 */
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, iThreadID, 0, EArmMode)
		: iServSession.ModifyProcessBreak(armBreakId, processId, 0, EArmMode);
	test(err == KErrBadDescriptor);

	/*
	 * Thumb mode
	 */
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, iThreadID, address, EThumbMode)
		: iServSession.ModifyProcessBreak(armBreakId, processId, address, EThumbMode);
	test(err == KErrNone);

	/*
	 * Thumb2EE mode
	 */
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, iThreadID, address, EThumb2EEMode)
		: iServSession.ModifyProcessBreak(armBreakId, processId, address, EThumb2EEMode);
	test(err == KErrNotSupported);

	/*
	 * Arm mode
	 */
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, iThreadID, address, EArmMode)
		: iServSession.ModifyProcessBreak(armBreakId, processId, address, EArmMode);
	test(err == KErrNone);

	// Finally, clear the breakpoint
	err = iServSession.ClearBreak(armBreakId);
	test(err == KErrNone);

	//resume the thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0438
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test extracting information about breakpoints
//! @SYMTestActions Several calls to get information about breakpoints
//! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestBreakInfo()
	{
	test.Next(_L("TestBreakInfo\n"));

	DoTestBreakInfo(ETrue);
	DoTestBreakInfo(EFalse);
	}

void CRunModeAgent::DoTestBreakInfo(TBool aThreadSpecific)
	{
	test.Printf(_L("DoTestModifyBreak: aThreadSpecific: %d\n"), aThreadSpecific?1:0);

	TInt err;

	RProcess process;
	TProcessId processId = process.Id();
	process.Close();

	//an address in the target debug thread
	TUint32 address = (TUint32)(&TestFunction);

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	//suspend thread
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	//set an arm mode break point
	TBreakId armBreakId = 0;
	err = aThreadSpecific
		? iServSession.SetBreak(armBreakId, iThreadID, address, EArmMode)
		: iServSession.SetProcessBreak(armBreakId, processId, address, EArmMode);
	test(err == KErrNone);

	// Read back the information and check it is correct
	TThreadId testThreadId = TThreadId(0);
	TProcessId testProcessId = TProcessId(0);
	TUint32 testAddress = 0;
	TArchitectureMode testMode = EArmMode;

	err = aThreadSpecific
		? iServSession.BreakInfo(armBreakId,testThreadId,testAddress, testMode)
		: iServSession.ProcessBreakInfo(armBreakId, testProcessId, testAddress, testMode);
	test (err == KErrNone);
	test (aThreadSpecific ? (testThreadId == iThreadID) : (testProcessId == processId));
	test (testAddress == address);
	test (testMode == EArmMode);

	//change the address
	TUint32 changeAddress = address + 64;
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, iThreadID, changeAddress,EArmMode)
		: iServSession.ModifyProcessBreak(armBreakId, processId, changeAddress, EArmMode);
	test(err == KErrNone);

	// Check the address has changed
	err = aThreadSpecific
		? iServSession.BreakInfo(armBreakId,testThreadId,testAddress, testMode)
		: iServSession.ProcessBreakInfo(armBreakId, testProcessId, testAddress, testMode);
	test (err == KErrNone);
	test (testAddress == changeAddress);

	// change the architecture type
	TArchitectureMode checkMode = EThumbMode;
	err = aThreadSpecific
		? iServSession.ModifyBreak(armBreakId, iThreadID, address,checkMode)
		: iServSession.ModifyProcessBreak(armBreakId, processId, address, checkMode);
	test (err == KErrNone);

	// Check the mode has changed
	err = aThreadSpecific
		? iServSession.BreakInfo(armBreakId,testThreadId,testAddress,testMode)
		: iServSession.ProcessBreakInfo(armBreakId, testProcessId, testAddress, testMode);
	test (err == KErrNone);
	test (testMode == checkMode);

	// clear the breakpoint again
	err = iServSession.ClearBreak(armBreakId);
	test (err == KErrNone);

	//resume thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

// Needed for the RunToBreak test
IMPORT_C extern void RMDebug_BranchTst1();
IMPORT_C extern void RMDebug_BranchTst2();

//---------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-0439
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test hitting various types of breakpoints
//! @SYMTestActions Several calls to register to observe breakpoints and to hit breakpoints of different types
//! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestRunToBreak()
	{
	test.Next(_L("TestRunToBreak\n"));

	DoTestRunToBreak(ETrue);
	DoTestRunToBreak(EFalse);
	}

void CRunModeAgent::DoTestRunToBreak(TBool aThreadSpecific)
	{
	test.Printf(_L("DoTestRunToBreak: aThreadSpecific: %d\n"), aThreadSpecific?1:0);

	TInt err = KErrNone;

	RProcess process;
	TProcessId processId = process.Id();
	process.Close();

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	// we should suspend the thread first, then set the breakpoint
	err = iServSession.SuspendThread(iThreadID);
	test (err == KErrNone);

	// Try to set the breakpoint
	TBreakId armBreakId;
	TUint32 address = (TUint32)(&RMDebug_BranchTst1);

	err = aThreadSpecific
		? iServSession.SetBreak(armBreakId,iThreadID,address,EArmMode)
		: iServSession.SetProcessBreak(armBreakId, processId, address, EArmMode);
	test(err == KErrNone);

	err = aThreadSpecific
		? iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionContinue)
		: iServSession.SetEventAction(iFileName,EEventsProcessBreakPoint, EActionContinue);
	test (err == KErrNone);

	// Continue the thread
	err = iServSession.ResumeThread(iThreadID);
	test (err == KErrNone);

	// wait for the breakpoint to be hit
	TEventInfo info;
	static TRequestStatus status;

	TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));

	iServSession.GetEvent(iFileName,status,infoPtr);

	// Wait for notification of the breakpoint hit event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// info should now be filled with the details
	test(info.iEventType == (aThreadSpecific ? EEventsBreakPoint : EEventsProcessBreakPoint));
	test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == address);
	test(info.iProcessIdValid);
	test(info.iThreadIdValid);

	// Not interested in breakpoint events any more
	err = aThreadSpecific
		? iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionIgnore)
		: iServSession.SetEventAction(iFileName, EEventsProcessBreakPoint, EActionIgnore);
	test (err == KErrNone);

	// Clear the breakpoint again
	err = iServSession.ClearBreak(armBreakId);
	test(err == KErrNone);

	// continue the thread again
	err = iServSession.ResumeThread(iThreadID);
	test (err == KErrNone);
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//---------------------------------------------
//! @SYMTestCaseID KBASE-rmdebug2-2704
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test breakpoints in a loop
//! @SYMTestActions Several calls to register to verify breakpoints are stopping at correct address
//! @SYMTestExpectedResults All tests should pass and the target thread should be left unaffected
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//---------------------------------------------
void CRunModeAgent::TestBreakPointsInLoop()
	{
	test.Next(_L("TestBreakPointsInLoop\n"));

	DoTestBreakPointsInLoop(ETrue);
	DoTestBreakPointsInLoop(EFalse);
	}

void CRunModeAgent::DoTestBreakPointsInLoop(TBool aThreadSpecific)
	{
	test.Printf(_L("DoTestBreakPointsInLoop: aThreadSpecific: %d\n"), aThreadSpecific?1:0);

	TInt err = KErrNone;
	TProcessId processId = RProcess().Id(); 

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	
	// We should suspend the thread first, then set the breakpoint
	err = iServSession.SuspendThread(iThreadID);
	test (err == KErrNone);

	// 2 breakpoints are sufficient to find issues with hitting breakpoints in a loop
	const TInt numOfBreakPointsInLoop = 2;

	TBreakId armBreakId[numOfBreakPointsInLoop];
	TUint32 address[numOfBreakPointsInLoop];
   	
	TUint32 entryAddress = (TUint32)(&RMDebug_Bkpt_Test_Entry);
	TBreakId entryArmBreakId;

	// Copy breakpoint address's in array
	address[0] = (TUint32)(&RMDebug_Bkpt_Test_Loop_Break_1);
	address[1] = (TUint32)(&RMDebug_Bkpt_Test_Loop_Break_2);

	err = aThreadSpecific
		? iServSession.SetBreak(entryArmBreakId,iThreadID,entryAddress,EArmMode)
		: iServSession.SetProcessBreak(entryArmBreakId, processId, entryAddress, EArmMode);
	test(err == KErrNone);

	// Try to set the breakpoints inside loop
	for (TInt i = 0; i < numOfBreakPointsInLoop; i++)
		{
		err = aThreadSpecific
			? iServSession.SetBreak(armBreakId[i],iThreadID,address[i],EArmMode)
			: iServSession.SetProcessBreak(armBreakId[i], processId, address[i], EArmMode);
		test(err == KErrNone);
		}

	err = aThreadSpecific
		? iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionContinue)
		: iServSession.SetEventAction(iFileName,EEventsProcessBreakPoint, EActionContinue);
	test (err == KErrNone);

	// Continue the thread
	err = iServSession.ResumeThread(iThreadID);
	test (err == KErrNone);

	// Wait for the breakpoint to be hit
	TEventInfo info;
	TRequestStatus status;

	TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));
	iServSession.GetEvent(iFileName,status,infoPtr);

	// Wait for notification of breakpoint event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// Info should now be filled with the details
	test(info.iEventType == (aThreadSpecific ? EEventsBreakPoint : EEventsProcessBreakPoint));

	// Have we stopped at the correct breakpoint?
	test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == entryAddress);
	test(info.iProcessIdValid);
	test(info.iThreadIdValid);

	// Don't require the entry breakpoint anymore
	err = iServSession.ClearBreak(entryArmBreakId);
	test(err == KErrNone);
	
	// Stress the system by setting loop count to 100
	const TUint32 loopCount = 100;

	for (TInt i = 0; i < loopCount; i++)
		{
		// Continue the thread
		err = iServSession.ResumeThread(iThreadID);
		test (err == KErrNone);

		// Wait for the breakpoint to be hit
		iServSession.GetEvent(iFileName,status,infoPtr);
		
		// Wait for notification of the breakpoint hit event
		User::WaitForRequest(status);
		test(status==KErrNone);
		
		// Info should now be filled with the details
		test(info.iEventType == (aThreadSpecific ? EEventsBreakPoint : EEventsProcessBreakPoint));
		
		// Have we stopped at the correct breakpoint?
		test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == address[i%numOfBreakPointsInLoop]);
		
		// Check process and thread id too
		test(info.iProcessIdValid);
		test(info.iThreadIdValid);
		}

	// Not interested in breakpoint events any more
	err = aThreadSpecific
		? iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionIgnore)
		: iServSession.SetEventAction(iFileName, EEventsProcessBreakPoint, EActionIgnore);
	test (err == KErrNone);

	// Clear breakpoints
	for (TInt i = 0; i < numOfBreakPointsInLoop; i++)
		{
		err = iServSession.ClearBreak(armBreakId[i]);
		test(err == KErrNone);
		}
	
	// Continue the thread again
	err = iServSession.ResumeThread(iThreadID);
	test (err == KErrNone);
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0440
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Test access to target user-side registers.
//! @SYMTestActions     Suspends a target thread, and reads/writes target thread register contents
//!
//! @SYMTestExpectedResults KErrNone. Should access target registers without problems.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestRegisterAccess()
	{
	TInt err;

	test.Next(_L("TestRegisterAccess - Read\n"));

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	//suspend the thread to read registers
	err = iServSession.SuspendThread(iThreadID);
	test(err==KErrNone);

	//we'll try to read/write registers ERegisterR0 - ERegisterCPSR and ERegisterR13_IRQ
	//this way should get valid register values back, invalid ones and not supported ones, and it
	//means that the register IDs are not completely contiguous

	TInt firstRegister = 0;
	TInt lastRegister = 17;
	TInt numberOfRegisters = (lastRegister - firstRegister) + 1;

	RBuf8 ids;
	err = ids.Create(numberOfRegisters * sizeof(TRegisterInfo));
	test(err == KErrNone);

	for(TInt i=0; i<numberOfRegisters - 1; i++)
		{
		TRegisterInfo reg = (TRegisterInfo)((i + firstRegister)<<8);
		ids.Append(reinterpret_cast<const TUint8*>(&reg), sizeof(TRegisterInfo));
		}

	TRegisterInfo reg = ERegisterR13Irq;
	ids.Append(reinterpret_cast<const TUint8*>(&reg), sizeof(TRegisterInfo));

	//create a buffer to store the register values in
	RBuf8 originalValues;
	err = originalValues.Create(numberOfRegisters*sizeof(TUint32));
	test(err == KErrNone);

	//create a buffer to store the register flags in
	RBuf8 originalFlags;
	err = originalFlags.Create(numberOfRegisters*sizeof(TUint8));
	test(err == KErrNone);

	//read register values
	err = iServSession.ReadRegisters(iThreadID, ids, originalValues, originalFlags);
	test(err == KErrNone);

	//create a buffer containing data to write into the registers
	RBuf8 tempValues;
	err = tempValues.Create(numberOfRegisters*sizeof(TUint32));
	test(err == KErrNone);

	TUint cpsrId = 16;
	for(TUint8 i=0; i<numberOfRegisters*sizeof(TUint32); i++)
		{
		if(i/sizeof(TUint32) == cpsrId)
			{
			//For the CPSR we wish to write data that makes sense - for USR mode we are
			//allowed change all except the mode, ie. we must stay in usr mode. We try that here
			//(allowedCPSRValue[4:0] = 10000) thus not changing the mode.
			TUint32 allowedCPSRValue = 0x50000010;
			tempValues.Append((TUint8*)&allowedCPSRValue, 4);
			i += 3;
			}
		else
			{
			tempValues.Append(&i, 1);
			}
		}

	test.Next(_L("TestRegisterAccess - Write\n"));

	//create a buffer to store the register flags in
	RBuf8 tempWriteFlags;
	err = tempWriteFlags.Create(numberOfRegisters*sizeof(TUint8));
	test(err == KErrNone);

	//write the temp data into the registers
	err = iServSession.WriteRegisters(iThreadID, ids, tempValues, tempWriteFlags);
	test(err == KErrNone);

	//create another buffer to store the register flags in
	RBuf8 tempReadFlags;
	err = tempReadFlags.Create(numberOfRegisters*sizeof(TUint8));
	test(err == KErrNone);

	RBuf8 tempReadValues;
	err = tempReadValues.Create(numberOfRegisters*sizeof(TUint32));
	test(err == KErrNone);

	//read the temp data out again
	err = iServSession.ReadRegisters(iThreadID, ids, tempReadValues, tempReadFlags);
	test(err == KErrNone);

	//check values are correct
	for(TInt i=0; i<numberOfRegisters; i++)
		{
		TRegisterFlag writeFlag;
		err = GetFlag(tempWriteFlags, i, writeFlag);
		test(err == KErrNone);

		TRegisterFlag readFlag;
		err = GetFlag(tempReadFlags, i, readFlag);
		test(err == KErrNone);

		if((writeFlag == EValid) && (readFlag == EValid))
			{
			TUint8 offset = i * sizeof(TUint32);
			for(TUint j = offset; j< offset + sizeof(TUint32); j++)
				{
				test(tempValues.Ptr()[j] == tempReadValues.Ptr()[j]);
				}
			}
		}

	//write the original data into the registers
	err = iServSession.WriteRegisters(iThreadID, ids, originalValues, originalFlags);
	test(err == KErrNone);

	//read the data out again
	err = iServSession.ReadRegisters(iThreadID, ids, tempValues, tempReadFlags);
	test(err == KErrNone);

	//check values are correct
	for(TInt i=0; i<numberOfRegisters; i++)
		{
		TRegisterFlag writeFlag;
		err = GetFlag(originalFlags, i, writeFlag);
		test(err == KErrNone);

		TRegisterFlag readFlag;
		err = GetFlag(tempReadFlags, i, readFlag);
		test(err == KErrNone);

		if((writeFlag == EValid) && (readFlag == EValid))
			{
			TUint8 offset = i * sizeof(TUint32);
			for(TUint j = offset; j< offset + sizeof(TUint32); j++)
				{
				test(tempValues.Ptr()[j] == originalValues.Ptr()[j]);
				}
			}
		}

	test.Next(_L("TestRegisterAccess - Invalid data\n"));

	//create a buffer of max size 1
	RBuf8 emptyBuffer;
	emptyBuffer.Create(1);

	//test register IDs buffer not being a multiple of sizeof(TRegisterInfo)
	err = iServSession.ReadRegisters(iThreadID, emptyBuffer, tempValues, tempReadFlags);
	test(err == KErrArgument);

	//test register values buffer not being a multiple of sizeof(TUint32)
	err = iServSession.ReadRegisters(iThreadID, ids, emptyBuffer, tempReadFlags);
	test(err == KErrArgument);

	//test flags buffer being representing different number of registers from other two
	err = iServSession.ReadRegisters(iThreadID, ids, tempValues, emptyBuffer);
	test(err == KErrArgument);

	//set max length to 0
	emptyBuffer.ReAlloc(0);

	//test ids buffer being of 0 max length
	err = iServSession.ReadRegisters(iThreadID, emptyBuffer, tempValues, tempReadFlags);
	test(err == KErrArgument);

	//do cleanup
	emptyBuffer.Close();
	tempValues.Close();
	tempWriteFlags.Close();
	tempReadFlags.Close();
	tempReadValues.Close();

	test.Next(_L("TestRegisterAccess - Setting PC value\n"));

	//create buffer containing PC register ID
	RBuf8 pcId;
	err = pcId.Create(sizeof(TRegisterInfo));
	test(err == KErrNone);
	TRegisterInfo reg1 = (TRegisterInfo)0x00000f00;
	pcId.Append(reinterpret_cast<const TUint8*>(&reg1), sizeof(TRegisterInfo));

	//create buffer containing desired PC value
	RBuf8 pcValue;
	err = pcValue.Create(sizeof(TUint32));
	test(err == KErrNone);
	TUint32 address = (TUint32)(&TestFunction);
	pcValue.Append(reinterpret_cast<const TUint8*>(&address), sizeof(TUint32));

	//craete buffer for PC flag value
	RBuf8 pcFlag;
	err = pcFlag.Create(sizeof(TUint8));

	//write the new PC value
	err = iServSession.WriteRegisters(iThreadID, pcId, pcValue, pcFlag);
	test(err==KErrNone);

	//get the flag and check the PC value was written ok
	TRegisterFlag flag = ENotSupported;
	err = GetFlag(pcFlag, 0, flag);
	test(err==KErrNone);

	if(flag == EValid)
		{
		/* The PC value was changed to execute the function TestFunction.
		* TestFunction changes the value of TestData to a given value and 
		* then calls RMDebug_BranchTst1.
		* We place a breakpoint on RMDebug_BranchTst1 so that to we are able 
		* to test the value of TestData.
		*/

		test(KErrNone == iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionSuspend));
		TBreakId armBreakId;
		TUint32 address = (TUint32)(&RMDebug_BranchTst1);
		test(KErrNone == iServSession.SetBreak(armBreakId,iThreadID,address,EArmMode));

		// Continue the thread
		test(KErrNone == iServSession.ResumeThread(iThreadID));

		// wait for the breakpoint to be hit
		TEventInfo info;
		static TRequestStatus status;

		TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));
		iServSession.GetEvent(iFileName,status,infoPtr);

		// Wait for notification of the breakpoint hit event
		User::WaitForRequest(status);
		test(status==KErrNone);

		// info should now be filled with the details
		test(info.iEventType == EEventsBreakPoint);
		test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == address);
		test(info.iProcessIdValid);
		test(info.iThreadIdValid);

		test(KErrNone == iServSession.ClearBreak(armBreakId));

		// Finally test the value
		test(TestData == 0xffeeddcc);
		}

	//Make sure we cannot change the CPSR
	test.Next(_L("Verifying we cannot change the CPSR mode from USR Mode"));

	TUint32 disallowedCpsr = 0x50000013;

	RBuf8 cpsrRegId;
	err = cpsrRegId.Create(sizeof(TUint32));
	test(err == KErrNone);

	TRegisterInfo cpsr = (TRegisterInfo)((cpsrId + firstRegister)<<8);
	cpsrRegId.Append(reinterpret_cast<const TUint8*>(&cpsr), sizeof(TRegisterInfo));

	RBuf8 cpsrRegFlags;
	err = cpsrRegFlags.Create(sizeof(TUint8));
	test(err == KErrNone);

	RBuf8 cpsrVal;
	err = cpsrVal.Create(sizeof(TUint32));
	test(err == KErrNone);

	cpsrVal.Append((TUint8*)&disallowedCpsr, 4);

	//attempt to write disallowed CPSR in
	err = iServSession.WriteRegisters(iThreadID, cpsrRegId, cpsrVal, cpsrRegFlags);
	test(err == KErrNone);

	RBuf8 cpsrReadVal;
	err = cpsrReadVal.Create(sizeof(TUint32));
	test(err == KErrNone);

	//Read back the CPSR
	err = iServSession.ReadRegisters(iThreadID, cpsrRegId, cpsrReadVal, cpsrRegFlags);
	test(err == KErrNone);

	//Make sure we havent switched modes ie. its not what we wrote
	TUint32* readVal = (TUint32*)cpsrReadVal.Ptr();
	test(*readVal != disallowedCpsr);

	cpsrRegId.Close();
	cpsrRegFlags.Close();
	cpsrVal.Close();
	cpsrReadVal.Close();

	//write the original values back into here
	err = iServSession.WriteRegisters(iThreadID, ids, originalValues, originalFlags);
	test(err == KErrNone);

	// Resume the thread
	err = iServSession.ResumeThread(iThreadID);
	test(err==KErrNone);

	test(KErrNone == iServSession.DetachExecutable(iFileName));

	//do cleanup
	pcId.Close();
	pcValue.Close();
	pcFlag.Close();
	ids.Close();
	originalValues.Close();
	originalFlags.Close();
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0441
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Test registration/de-registration of debug interest in target exe with the Debug Security Server
//! @SYMTestActions     As per description
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestAttachExecutable()
	{

	test.Next(_L("TestAttachExecutable - Attach\n"));

	//attach to process passively
	test(KErrNone == iServSession.AttachExecutable(iFileName, ETrue));

	//make a thread id for a non-existent thread
	TThreadId threadId(0x12345678);

	//get a handle to the target thread
	RThread targetThread;
	TInt err = targetThread.Open(threadId);
	test(err != KErrNone);

	//not registered for this thread's process (as it doesn't exist)
	//so should fail security check
	err = iServSession.ResumeThread(threadId);
	test(err==KErrPermissionDenied);

	//try to attach to the same process (and fail)
	test(KErrAlreadyExists == iServSession.AttachExecutable(iFileName, EFalse));

	test.Next(_L("TestAttachExecutable - Detach\n"));

	//detach from process
	test(KErrNone == iServSession.DetachExecutable(iFileName));

	//attach non-passively
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	//not registered for this thread's process (as it doesn't exist)
	//so should fail security check
	err = iServSession.ResumeThread(0x12345678);
	test(err==KErrPermissionDenied);
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0442
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests single-stepping target threads.
//! @SYMTestActions     Steps target thread assembly level instructions, mainly branch/change PC
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestStep()
	{
	test.Next(_L("TestStep\n"));

	DoTestStep(EFalse);
	DoTestStep(ETrue);
	}

void CRunModeAgent::DoTestStep(TBool aThreadSpecific)
	{
	test.Printf(_L("DoTestStep: aThreadSpecific: %d\n"), aThreadSpecific?1:0);

	TInt err = KErrNone;

	RProcess process;
	TProcessId processId = process.Id();
	process.Close();

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	//set the target thread to execute the stepping functions
	test(KErrNone == SwitchTestFunction(EStepFunction));

	err = iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionContinue);
	test (err == KErrNone);

	if(!aThreadSpecific)
		{
		err = iServSession.SetEventAction(iFileName, EEventsProcessBreakPoint, EActionContinue);
		test (err == KErrNone);
		}

	TUint32	startAddress;
	TUint32	endAddress;

	/*
	 * RMDebug_StepTest_Non_PC_Modifying
	 */
	test.Next(_L("TestStep - Non-PC modifying\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Non_PC_Modifying);

	endAddress = (TUint32)(&RMDebug_StepTest_Non_PC_Modifying_OK);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1, EFalse, processId);
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Branch
	 */
	test.Next(_L("TestStep - Branch\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Branch);

	endAddress = (TUint32)(&RMDebug_StepTest_Branch_1);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1, EFalse, processId);
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Branch_And_Link
	 */
	test.Next(_L("TestStep - Branch_And_Link\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Branch_And_Link_1);

	endAddress = (TUint32)(&RMDebug_StepTest_Branch_And_Link_2);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1, EFalse, processId);
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_MOV_PC
	 */
	test.Next(_L("TestStep - MOV PC,X\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_MOV_PC_1);

	endAddress = (TUint32)(&RMDebug_StepTest_MOV_PC_2);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1, EFalse, processId);
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_LDR_PC
	 */
	test.Next(_L("TestStep - LDR PC\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_LDR_PC);

	endAddress = (TUint32)(&RMDebug_StepTest_LDR_PC_1);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1, EFalse, processId);
	test(err==KErrNone);

// thumb and interworking tests are not supported on armv4
#ifdef __MARM_ARMV5__

	/*
	 * RMDebug_StepTest_Thumb_Non_PC_Modifying
	 */
	test.Next(_L("TestStep - Thumb Non PC-Modifying\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Thumb_Non_PC_Modifying_1);

	endAddress = (TUint32)(&RMDebug_StepTest_Thumb_Non_PC_Modifying_2);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1, EFalse, processId);
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Thumb_Branch
	 */
	test.Next(_L("TestStep - Thumb Branch\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Thumb_Branch_1);

	endAddress = (TUint32)(&RMDebug_StepTest_Thumb_Branch_2);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1, EFalse, processId);
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Thumb_Branch_And_Link
	 */
	test.Next(_L("TestStep - Thumb Branch_And_Link\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Thumb_Branch_And_Link_2);

	endAddress = (TUint32)(&RMDebug_StepTest_Thumb_Branch_And_Link_3);

	TInt muid=0;
    test(HAL::Get(HAL::EMachineUid, muid)==KErrNone);

	// check if running on ARMv7 core
	if(muid==HAL::EMachineUid_OmapH6 || muid==HAL::EMachineUid_OmapZoom || muid==HAL::EMachineUid_EmuBoard)
        {
        // Note: ARMv7 treats BL instructions as single 32-bit instructions
        err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1, EFalse, processId);
        }
    else
	    {
        // Note: Due to the fact that the stepper treats BL instructions
		// as two instructions (as the hardware does), then we must step
		// the first half instruction first)

		err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,startAddress+2,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress,startAddress+2,EThumbMode,1, EFalse, processId);
		test(err==KErrNone);

	// Now we actually do the BL
	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress+2,endAddress,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress+2,endAddress,EThumbMode,1, EFalse, processId);
        }
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Thumb_Back_Branch_And_Link
	 */
	test.Next(_L("TestStep - Thumb Back_Branch_And_Link\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Thumb_Back_Branch_And_Link_2);

	endAddress = (TUint32)(&RMDebug_StepTest_Thumb_Back_Branch_And_Link_3);

	// check if running on ARMv7 core
	if(muid==HAL::EMachineUid_OmapH6 || muid==HAL::EMachineUid_OmapZoom || muid==HAL::EMachineUid_EmuBoard)
		{
		// Note: ARMv7 treats BL instructions as single 32-bit instructions
		err = aThreadSpecific
			? HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1)
			: HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1, EFalse, processId);
		}
	else
		{
		// Note: Due to the fact that the stepper treats BL instructions
		// as two instructions (as the hardware does), then we must step
		// the first half instruction first)

		err = aThreadSpecific
	   		? HelpTestStep(iThreadID,startAddress,startAddress+2,EThumbMode,1)
			: HelpTestStep(iThreadID,startAddress,startAddress+2,EThumbMode,1, EFalse, processId);
		test(err==KErrNone);

	   	// Now we actually do the BL
		err = aThreadSpecific
   			? HelpTestStep(iThreadID,startAddress+2,endAddress,EThumbMode,1)
			: HelpTestStep(iThreadID,startAddress+2,endAddress,EThumbMode,1, EFalse, processId);
		}
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Thumb_AddPC
	 */
	test.Next(_L("TestStep - Thumb ADD PC, PC, R0\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Thumb_AddPC_2);

	endAddress = (TUint32)(&RMDebug_StepTest_Thumb_AddPC_3);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1, EFalse, processId);
	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Interwork ARM to Thumb
	 */
	test.Next(_L("TestStep - Interworking ARM to Thumb - BLX \n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Interwork_1);

	endAddress = (TUint32)(&RMDebug_StepTest_Interwork_2);

	err = aThreadSpecific // nb initial breakpoint in ARM code
		? HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,1, EFalse, processId);

	test(err==KErrNone);

	/*
	 * RMDebug_StepTest_Interwork Thumb to ARM
	 */
	test.Next(_L("TestStep - Interworking Thumb to ARM - BLX\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_Interwork_2);

	endAddress = (TUint32)(&RMDebug_StepTest_Interwork_3);

	// check if running on ARMv7 core
	if(muid==HAL::EMachineUid_OmapH6 || muid==HAL::EMachineUid_OmapZoom || muid==HAL::EMachineUid_EmuBoard)
        {
        // ARMv7 treats BLX instructions as single 32-bit instructions
        err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress,endAddress,EThumbMode,1, EFalse, processId);
        }
    else
        {
    	// Stepper treats this as a two-stage instruction (just like the hardware)
	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,startAddress+2,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress,startAddress+2,EThumbMode,1, EFalse, processId);
	test(err == KErrNone);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress+2,endAddress,EThumbMode,1)
		: HelpTestStep(iThreadID,startAddress+2,endAddress,EThumbMode,1, EFalse, processId);
        }
	test(err == KErrNone);

#endif // __MARM_ARMV5__

	/*
	 * Test multiple-step of ARM code
	 */
	test.Next(_L("TestStep - ARM Multiple instruction step\n"));

	startAddress = (TUint32)(&RMDebug_StepTest_ARM_Step_Multiple);

	endAddress = (TUint32)(&RMDebug_StepTest_ARM_Step_Multiple_1);

	err = aThreadSpecific
		? HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,5)
		: HelpTestStep(iThreadID,startAddress,endAddress,EArmMode,5, EFalse, processId);
	test(err == KErrNone);
	// stepping performance
	test.Next(_L("TestStep - Steps per second\n"));

	// run until we reach RMDebug_StepTest_Count_1
	TBreakId stepBreakId;
	startAddress = (TUint32)(&RMDebug_StepTest_Count_1);
	endAddress = (TUint32)(&RMDebug_StepTest_Count_2);

	err = aThreadSpecific
		? HelpTestStepSetBreak(stepBreakId,iThreadID,startAddress,EArmMode)
		: HelpTestStepSetBreak(stepBreakId,iThreadID,startAddress,EArmMode,EFalse,processId);
	test (err == KErrNone);

	// wait until we hit the breakpoint
	TEventInfo info;
	err = HelpTestStepWaitForBreak(iFileName,info);
	test (err == KErrNone);

	// Now clear the breakpoint
	err = iServSession.ClearBreak(stepBreakId);
	test(err == KErrNone);

	if(aThreadSpecific)
		{
		// now step the code
		TInt stepsPerSecond = 0;

		TUint32 stopTickCount = User::NTickCount() + HelpTicksPerSecond();

		while (User::NTickCount() < stopTickCount)
			{
			err = iServSession.Step(iThreadID,1);
			test (err == KErrNone);

			// we need to wait now until the step completes before asking for the next step
				{
				TEventInfo info;
				static TRequestStatus status;

				TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));

				iServSession.GetEvent(iFileName,status,infoPtr);

				// Wait for notification of the breakpoint hit event
				User::WaitForRequest(status);
				test(status==KErrNone);
				}

			// Update the count of steps
			stepsPerSecond += 1;

			// Gone wrong if we do too many
			test(stepsPerSecond < 10000);
			}

		iStepsPerSecond = stepsPerSecond;
		test(iStepsPerSecond != 0);
		}

	// finally resume the thread
	err = iServSession.ResumeThread(iThreadID);
	test (err == KErrNone);

	err = iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionIgnore);
	test (err == KErrNone);

	if(!aThreadSpecific)
		{
		err = iServSession.SetEventAction(iFileName, EEventsProcessBreakPoint, EActionIgnore);
		test (err == KErrNone);
		}

	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0443
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests registration and occurrence of target thread event (in this case panic)
//! @SYMTestActions     Registers for a panic in the target thread, causes it, and catches the panic notification.
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestEvents()
	{
	TInt err = KErrNone;

	test.Next(_L("TestEvents\n"));

	TInt panicReason = 12345;

	test.Printf(_L("Thread t_rmdebug.exe::DebugThread should panic with reason %d.\n"), panicReason);

	//attach non-passively
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	RThread threadToPanic;
	test(KErrNone == StartDebugThread(threadToPanic, _L("EventsThread")));
	TThreadId threadToPanicId = threadToPanic.Id();
	TEventInfo info;

	// Set things up to wait for a thread kill event
	err = iServSession.SetEventAction(iFileName, EEventsKillThread, EActionContinue);
	test(err==KErrNone);

	// Wait for an event to occur in this process - nothing should have happened yet.
	static TRequestStatus status;

	TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));

	iServSession.GetEvent(iFileName,status,infoPtr);

	// Test Request cancellation
	err = iServSession.CancelGetEvent(iFileName);
	test (err==KErrNone);

	// Again wait for an event to occur in our process - we will provoke the
	// thread kill event by panic'ing the test thread.
	iServSession.GetEvent(iFileName,status,infoPtr);

	// Panic the debug thread to cause a thread kill event
	threadToPanic.Panic(_L("t_rmdebug panic thread test"), panicReason);

	// Wait for notification of the Thread Kill event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// Check we are really recieving information about the panic
	test(info.iProcessIdValid);
	test(info.iThreadIdValid);
	test(info.iProcessId==RProcess().Id());
	test(info.iThreadId==threadToPanicId);
	test(info.iEventType==EEventsKillThread);
	test(info.iThreadKillInfo.iExitType==EExitPanic);

	// Ignore other panic events
	err = iServSession.SetEventAction(iFileName, EEventsKillThread, EActionIgnore);
	test(err==KErrNone);

	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0444
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests registration and occurence of target thread events in separate process.
//! @SYMTestActions     Registers for a hardware exception and kill thread events, and receives them.
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------
void CRunModeAgent::TestEventsForExternalProcess()
	{
	test.Next(_L("TestEventsForExternalProcess\n"));

	for(TInt main=0; main<3; main++)
		{
		for(TInt extra=0; extra<3; extra++)
			{
			TestEventsWithExtraThreads((TKernelEventAction)main, (TKernelEventAction)extra, 0);
			TestEventsWithExtraThreads((TKernelEventAction)main, (TKernelEventAction)extra, 2);
			}
		}
	}

void CRunModeAgent::TestEventsWithExtraThreads(TKernelEventAction aActionMain, TKernelEventAction aActionExtra, TUint32 aExtraThreads)
	{
	const TInt KNumberOfTypes = 8;
	struct TEventStruct
		{
		public:
		TDebugFunctionType iDebugFunctionType;
		TEventType iEventType;
		};

	TEventStruct type[KNumberOfTypes] =
		{
			{EStackOverflowFunction, EEventsHwExc},
			{EUserPanicFunction, EEventsKillThread},
			{EPrefetchAbortFunction, EEventsHwExc},
			{EDataAbortFunction, EEventsHwExc},
			{EUndefInstructionFunction, EEventsHwExc},
			{EDataReadErrorFunction, EEventsHwExc},
			{EDataWriteErrorFunction, EEventsHwExc},
			{EUserExceptionFunction, EEventsSwExc},
		};

	for(TInt j=0; j<KNumberOfTypes; j++)
		{
		if( gUseDelay ) User::After(500000);

		RDebug::Printf("CRunModeAgent::TestEventsWithExtraThreads type: %d, main action: %d, extra action: %d, extraThreads: %d", 
			j, (TUint32)aActionMain, (TUint32)aActionExtra, aExtraThreads);

		// do this check as it seems to hard to do these cases with the current set up
		if(EEventsKillThread == type[j].iEventType)
			{
			if(EActionSuspend != aActionMain)
				{
				if(aActionMain != aActionExtra)
					{
					return;
					}
				}
			}
		// attach to KRMDebugTestApplication
		test(KErrNone == iServSession.AttachExecutable(KRMDebugTestApplication, EFalse));

		// Set things up to wait for the expected exception in KRMDebugTestApplication
		test(KErrNone == iServSession.SetEventAction(KRMDebugTestApplication, type[j].iEventType, aActionMain));

		if(EActionSuspend != aActionMain)
			{
			test(KErrNone == iServSession.SetEventAction(KRMDebugTestApplication, EEventsKillThread, aActionExtra));
			}

		// declare a TRequestStatus object for asynchronous calls
		TRequestStatus status;

		TEventInfo info;
		TPtr8 infoBuffer = TPtr8((TUint8*)&info,0,sizeof(TEventInfo));
		if(EActionIgnore != aActionMain)
			{
			iServSession.GetEvent(KRMDebugTestApplication(), status, infoBuffer);
			}

		// launch the target process to trigger the expected exception
		RProcess targetProcess;
		test(KErrNone == LaunchProcess(targetProcess, KRMDebugTestApplication(), type[j].iDebugFunctionType, 0, aExtraThreads));
		TProcessId processId(targetProcess.Id());
		targetProcess.Close();

		if(EActionIgnore != aActionMain)
			{
			// wait for notification of the exception
			User::WaitForRequest(status);
			test(KErrNone == status.Int());

			// check that this is the event we were expecting
			test(info.iProcessIdValid);
			test(info.iThreadIdValid);
			test(info.iProcessId==processId);
			test(info.iEventType==type[j].iEventType);
			}

		if(EActionSuspend == aActionMain)
			{
			//RDebug::Printf("CRunModeAgent::TestEventsWithExtraThreads EActionSuspend == aActionMain, j=%d", j);
			// read the thread list, partly to check the call works, and partly to check the thread still exists
			test(ThreadExistsForProcess(info.iThreadId, info.iProcessId));

			// register to catch all the thread kills which will occur
			test(KErrNone == iServSession.SetEventAction(KRMDebugTestApplication, EEventsKillThread, aActionExtra));
			// we specified EActionSuspend earlier so need to call resume on this thread
			test(KErrNone == iServSession.ResumeThread(info.iThreadId));
			}

		// find out how many threads there are in the process and catch all the thread kill events,
		// the number of kill thread events should correspond to the number of extra threads launched,
		// plus one if the main thread panicked with a Sw/Hw exception
		if(EActionIgnore != aActionExtra)
			{
			TInt dyingThreads = aExtraThreads + ( (type[j].iEventType != EEventsKillThread) ? 1 : 0);
			for(TInt k=0; k<dyingThreads; k++)
				{
				//RDebug::Printf("CRunModeAgent::TestEventsWithExtraThreads dyingThreads, k=%d, j=%d", k,j);
				iServSession.GetEvent(KRMDebugTestApplication(), status, infoBuffer);

				// wait for notification of the kill thread
				User::WaitForRequest(status);
				test(KErrNone == status.Int());

				// check that this is the event we were expecting
				test(info.iProcessIdValid);
				test(info.iThreadIdValid);
				test(info.iProcessId==processId);
				test(info.iEventType==EEventsKillThread);
				if(EActionSuspend == aActionExtra)
					{
					// do some calls to check listings work ok at this stage
					test(ProcessExists(info.iProcessId));
					test(ThreadExistsForProcess(info.iThreadId, info.iProcessId));
					// we specified EActionSuspend earlier so need to call resume on this thread
					test(KErrNone == iServSession.ResumeThread(info.iThreadId));
					}
				}
			}

		if( gUseDelay ) User::After(500000);

		// reset the thread kill event
		test(KErrNone == iServSession.SetEventAction(KRMDebugTestApplication(), EEventsKillThread, EActionIgnore));

		// reset events for KRMDebugTestApplication
		test(KErrNone == iServSession.SetEventAction(KRMDebugTestApplication(), type[j].iEventType, EActionIgnore));

		// finished debugging KRMDebugTestApplication so detach
		test(KErrNone == iServSession.DetachExecutable(KRMDebugTestApplication()));
	
		// want to validate that the process has really exited, i.e. we're not accidentally keeping a handle to it...
		TInt waitCount = 10;
		while((waitCount-- > 0) && ProcessExists(processId))
			{
			/* Wait a little while and try again, just in case the process is still being removed.
			This can happen on a very busy system or when a popup for the events is still active
			*/
			RDebug::Printf("CRunModeAgent::TestEventsWithExtraThreads. ProcessExists(id=%d), waiting for it to exit %d", 
				I64LOW(processId), waitCount);
			User::After(500);
			}
		test(!ProcessExists(processId));
		}
	}

// helper function to check whether a thread with id aThreadId exists in the process with id aProcessId
TBool CRunModeAgent::ThreadExistsForProcess(const TThreadId aThreadId, const TProcessId aProcessId)
	{
	TUint32 size;
	RBuf8 buffer;
	test(KErrNone == buffer.Create(1024));
	TInt err = iServSession.GetList(aProcessId, EThreads, buffer, size);
	while(KErrTooBig == err)
		{
		size*=2;
		test(size<=16*1024);
		test(KErrNone == buffer.ReAlloc(size));
		err = iServSession.GetList(aProcessId, EThreads, buffer, size);
		}
	test(KErrNone == err);

	//look through the buffer and check if the target debug thread is there
	TUint8* ptr = (TUint8*)buffer.Ptr();
	const TUint8* ptrEnd = ptr + size;
	while(ptr < ptrEnd)
		{
		TThreadListEntry& entry = *(TThreadListEntry*)ptr;
		if(aThreadId.Id() == entry.iThreadId)
			{
			buffer.Close();
			return ETrue;
			}
		ptr += Align4(entry.GetSize());
		}
	buffer.Close();
	return EFalse;
	}

// helper function to check whether a process with id aProcessId exists
TBool CRunModeAgent::ProcessExists(const TProcessId aProcessId)
	{
	TUint32 size;
	RBuf8 buffer;
	test(KErrNone == buffer.Create(1024));
	TInt err = iServSession.GetList(EProcesses, buffer, size);
	while(KErrTooBig == err)
		{
		size*=2;
		test(size<=16*1024);
		test(KErrNone == buffer.ReAlloc(size));
		err = iServSession.GetList(EProcesses, buffer, size);
		}
	test(KErrNone == err);

	//look through the buffer and check if the target debug thread is there
	TUint8* ptr = (TUint8*)buffer.Ptr();
	const TUint8* ptrEnd = ptr + size;
	while(ptr < ptrEnd)
		{
		TProcessListEntry& entry = *(TProcessListEntry*)ptr;
		if(aProcessId.Id() == entry.iProcessId)
			{
			buffer.Close();
			return ETrue;
			}
		ptr += Align4(entry.GetSize());
		}
	buffer.Close();
	return EFalse;
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0445
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests basic debug functions work on demand-paged target threads
//! @SYMTestActions     Checks it can r/w memory, set breakpoints etc in a demand paged target.
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestDemandPaging(void)
	{
	test.Next(_L("TestDemandPaging\n"));

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	// get the address of a function in code that will be paged in
	TUint32 address = (TUint32)(&RMDebugDemandPagingTest);
	const TUint32 armInstSize = 4;

	// read the memory at &RMDebugDemandPagingTest to check that reading memory in demand paged code works
	TUint32 demandPagedInst = 0;
	TPtr8 demandPagedInstBuf((TUint8*)&demandPagedInst, armInstSize);
	test(KErrNone == iServSession.ReadMemory(iThreadID, address, armInstSize, demandPagedInstBuf, EAccess32, EEndLE8));

	// this is the MOVS instruction that we expect to find in RMDebugDemandPagingTest
	TUint32 expectedDemandPagedInst = 0xe1b02000;

	// check that the instruction we read is as expected
	test(demandPagedInst == expectedDemandPagedInst);

	// set event action for break points
	test(KErrNone == iServSession.SetEventAction(RProcess().FileName(), EEventsBreakPoint, EActionContinue));

	// set an arm breakpoint on RMDebugDemandPagingTest
	TBreakId armBreakId = 0;
	test(KErrNone == iServSession.SetBreak(armBreakId, iThreadID, address, EArmMode));

	// Ensure that after setting the breakpoint the memory read returns the correct value
	TUint32 demandPagedInstWithBreakPoint = 0;
	TPtr8 spinForeverInstWithBreakPointBuf((TUint8*)&demandPagedInstWithBreakPoint, armInstSize);
	test(KErrNone == iServSession.ReadMemory(iThreadID, address, armInstSize, spinForeverInstWithBreakPointBuf, EAccess32, EEndLE8));
	test(demandPagedInst == demandPagedInstWithBreakPoint);

	// switch the target thread to run the demand paging function
	test(KErrNone == SwitchTestFunction(EDemandPagingFunction));

	// set up event watcher to catch breakpoint being hit in demand paged code
	TEventInfo info;
	static TRequestStatus status;
	TPtr8 infoPtr((TUint8*)&info,sizeof(TEventInfo));
	iServSession.GetEvent(RProcess().FileName(), status, infoPtr);

	// resume the thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));
	// wait for notification of the breakpoint hit event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// info should now be filled with the details
	test(info.iProcessIdValid);
	test(info.iThreadIdValid);
	test(info.iEventType == EEventsBreakPoint);
	test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == address);

	// remove the break point and resume the thread
	test(KErrNone == iServSession.ClearBreak(armBreakId));

	// switch the target thread to run the default function
	test(KErrNone == SwitchTestFunction(EDefaultFunction));

	test(KErrNone == iServSession.ResumeThread(iThreadID));
	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

// Names of some test programs used for testing security
_LIT(KRMDebugSecurity0FileName,"z:\\sys\\bin\\t_rmdebug_security0.exe"); // Debuggable
_LIT(KRMDebugSecurity1FileName,"z:\\sys\\bin\\t_rmdebug_security1.exe"); // Not debuggable
_LIT(KRMDebugSecurity2FileName,"z:\\sys\\bin\\t_rmdebug_security2.exe"); // AllFiles
_LIT(KRMDebugSecurity3FileName,"z:\\sys\\bin\\t_rmdebug_security3.exe"); // TCB AllFiles

// include the test header file here
#include "rm_debug_kerneldriver.h"

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0446
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests Debug Device Driver is locked to the SID of the Debug Security Svr.
//! @SYMTestActions     Loads rm-debug.ldd and tries to open a handle to it. This should fail.
//!
//! @SYMTestExpectedResults KErrPermissionDenied.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestDriverSecurity(void)
	{
	test.Next(_L("TestDriverSecurity\n"));

	RRM_DebugDriver kernelDriver;

	// Load the debug device driver
	TInt err = User::LoadLogicalDevice( KDebugDriverFileName );
	test((KErrNone == err) || (KErrAlreadyExists == err));

	// we were allowed to load the driver, or its already loaded.

	// Try to open a handle to the driver - this should return KErrPermissionDenied as we don't have the DSS SID
	TRM_DebugDriverInfo driverInfo;
	driverInfo.iUserLibraryEnd = 0;
	err = kernelDriver.Open(driverInfo);
	test((err == KErrInUse) || (err == KErrPermissionDenied));

	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0447
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests Debug driver can only be access via the DSS. Also tests DSS cannot
//!						be subverted. Tests functionality of two representative OEM Debug Tokens.
//! @SYMTestActions     Tries to open rm_debug.ldd (should fail). Tries to debug various processes
//!						(only debuggable one should succeed). Checks that DSS behaves correctly
//!						when different versions are passed in to Connect().
//!
//! @SYMTestExpectedResults KErrPermissionDenied.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestSecurity(void)
	{
	// Things to test
	//
	// try to use debug driver directly ( should have the wrong UID/SID value!)
	test.Next(_L("TestSecurity - Bypass Debug Security Server to Debug Device Driver - DSS running\n"));

	// Things to test
	//
	// Load the debug device driver
	RRM_DebugDriver kernelDriver;
	TInt err = User::LoadLogicalDevice( KDebugDriverFileName );
	test((KErrNone == err) || (KErrAlreadyExists == err));

	// we were allowed to load the driver, or its already loaded.

	// Try to open handle a to the driver - this should return KErrPermission/KErrInUse as we don't have the DSS SID
	// and we expect the DSS to already be using it.
	TRM_DebugDriverInfo driverInfo;
	driverInfo.iUserLibraryEnd = 0;
	err = kernelDriver.Open(driverInfo);
	test(err == KErrInUse);

	// Try requesting an unsupported version of DSS
	test.Next(_L("TestSecurity - requesting unsupported versions of DSS\n"));
	RSecuritySvrSession dss;
	err = dss.Connect(TVersion(999999, 0, 0));
	test(err == KErrNotSupported); // Prior to DEF142018 this would crash, causing a KErrServerTerminated
	err = dss.Connect(TVersion(KDebugServMajorVersionNumber, 999999, 0));
	test(err == KErrNotSupported); // Explicitly asking for a minor version should give KErrNotSupported too if it's newer than what's running.
	err = dss.Connect(TVersion(KDebugServMajorVersionNumber, 0, 0));
	test(err == KErrNone); // But the correct major version and no explicit minor version should always succeed
	dss.Close();
	
	//
	// Attach to the Debug Security Server (passive)
	//
	test.Next(_L("TestSecurity - Attach to the Debug Security Server (passive)\n"));

	_LIT(KSecurityServerProcessName, "z:\\sys\\bin\\rm_debug_svr.exe");

	test(KErrPermissionDenied == iServSession.AttachExecutable(KSecurityServerProcessName, ETrue));

	//
	// Attach to the Debug Security Server (active)
	//
	test.Next(_L("TestSecurity - Attach to the Debug Security Server (active)\n"));

	test(KErrPermissionDenied == iServSession.AttachExecutable(KSecurityServerProcessName, EFalse));

	//
	// Attach to Process 0
	//
	// Target: Debuggable
	//
	test.Next(_L("TestSecurity - Attach to test process 0\n"));

	// Agent can debug the target app as it is marked debuggable - ie capabilities are ignored)
	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity0FileName,ETrue);

	//
	// Attach to Process - 1
	//
	// Target: Non-debuggable for ordinary debug agent, debuggable for OEM/OEM2 token authorised agent
	//
	// Note: This target app has no PlatSec capabilities
	//
	// Agent cannot debug the app unless it has an OEM/OEM2 Debug Token
	test.Next(_L("TestSecurity - Attach to test process 1\n"));

#ifdef SYMBIAN_STANDARDDEBUG
	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity1FileName,EFalse);
#endif

#ifdef SYMBIAN_OEMDEBUG
	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity1FileName,ETrue);
#endif

#ifdef SYMBIAN_OEM2DEBUG
	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity1FileName,ETrue);
#endif

	//
	// Attach to Process - 2
	//
	// Target: Non-debuggable for ordinary debug agent, non-debuggable for OEM2 authorised agent (insufficient caps)
	//
	// Note: This target app has AllFiles capability
	//
	// Agent cannot debug the app unless it has an OEM Debug Token
	test.Next(_L("TestSecurity - Attach to test process 2\n"));

#ifdef SYMBIAN_STANDARDDEBUG
	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity2FileName,EFalse);
#endif

#ifdef SYMBIAN_OEMDEBUG
	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity2FileName,ETrue);
#endif

#ifdef SYMBIAN_OEM2DEBUG
	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity2FileName,EFalse);
#endif

	//
	// Attach to Process - 3
	//
	// Target: Non-debuggable for ordinary debug agent, non-debuggable for OEM authorised agent (insufficient caps)
	//
	// Note: This target app has AllFiles and TCB and NetworkControl capabilities
	//
	test.Next(_L("TestSecurity - Attach to test process 3\n"));

	HelpTestSecurityAttachDetachExecutable(KRMDebugSecurity3FileName,EFalse);

	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0543
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Validates that a dll can be built which #include's the rm_debug_api.h header, i.e. rm_debug_api.h contains no static data.
//! @SYMTestActions     Calls a dummy function in t_rmdebug_dll.dll which implies the dll has been built correctly.
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------
void CRunModeAgent::TestDllUsage(void)
	{
	test.Next(_L("TestDllUsage\n"));
	test(KUidDebugSecurityServer == GetDSSUid());
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0812
//! @SYMTestType
//! @SYMPREQ            PREQ1700
//! @SYMTestCaseDesc    Writes a known data to the crash flash and validates the data written
//!						using the read operation and finally erase the data. In the absence
//!						of an OEM debug token, access to the crash partition should not be allowed
//! @SYMTestActions     Invoke the flash write method in DSS and call the read method in DSS
//!						to validate the data is written correctly and then erase the written area
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------
void CRunModeAgent::TestCrashFlash(void)
	{
#if  defined (SYMBIAN_STANDARDDEBUG)  || defined (SYMBIAN_OEM2DEBUG)

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-006 Testing We cannot Erase the Crash Flash with insufficient privileges"));

	TUint32 size = 0;
	TInt err = iServSession.EraseCrashLog(0, 1);
	test(KErrPermissionDenied == err);

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-005 Testing We can't Write to the Crash Flash with insufficient privileges"));

	err = iServSession.WriteCrashConfig(0, KCrashDummyData, size);
	test(KErrPermissionDenied == err);
	test(size == 0);

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-008 Testing We can't Read from the Crash Flash with insufficient privileges"));

	TUint32 readSize = 0x10;
	RBuf8 buf;
	buf.CleanupClosePushL();
	err = buf.Create(readSize);

	test(err == KErrNone);

	err = iServSession.ReadCrashLog(0, buf, readSize);
	test(KErrPermissionDenied == err);

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-004 Testing Writing To an invalid location"));

	TUint32 writeSize = 0;
	err = iServSession.WriteCrashConfig(0xFFFFFFFF, KCrashDummyData, writeSize);

	test(err == KErrPermissionDenied);

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-003 Testing Reading from an invalid location"));

	buf.FillZ();
	err = iServSession.ReadCrashLog(0, buf, writeSize);

	test(err == KErrPermissionDenied);

	CleanupStack::PopAndDestroy(&buf);

#endif

#ifdef SYMBIAN_OEMDEBUG

	TInt err = KErrNone;

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-007 Testing We can Erase the Crash Flash with sufficient privileges"));

	err = iServSession.EraseCrashLog(0, 1);

	// For platforms where NAND flash is not currently supported we get a KErrNotSupported - this is still a pass
	if (KErrNotSupported == err)
		{
		test.Printf(_L("Nand flash not supported - continue"));
		return;
		}

 	//For platforms without a flash partition we get KErrNotFound - this is still a pass
 	if(KErrNotFound == err)
 		{
 		test.Printf(_L("Platform has no flash partition - continue"));
 		return;
 		}

	test(KErrNone == err);

	//Read back the start of the block to make sure its 0xFFFFFFFF
	const TUint numBytesToCheck = 0x80;  //We dont know the block size
	TBuf8<numBytesToCheck> eraseCheck;
	eraseCheck.SetLength(numBytesToCheck);

	err = iServSession.ReadCrashLog(0, eraseCheck, numBytesToCheck);
	test(err == KErrNone);

	TBool dataIsOk = ETrue;
	for(TUint cnt = 0; cnt < numBytesToCheck; cnt++)
		{
		if(eraseCheck[cnt] != 0xFF)
			{
			dataIsOk = EFalse;
			}
		}

	test(dataIsOk);

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-002 Testing We can Write to the Crash Flash with sufficient privileges"));

	TUint32 writeSize = 0;
	err = iServSession.WriteCrashConfig(0, KCrashDummyData, writeSize);

	test(writeSize == KCrashDummyData().Length());

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-001 Testing We can Read from the Crash Flash with sufficient privileges"));

	RBuf8 buf;
	buf.CleanupClosePushL();
	err = buf.Create(writeSize);

	test(err == KErrNone);

	buf.FillZ();

	err = iServSession.ReadCrashLog(0, buf, writeSize);

	test(0 == buf.Compare(KCrashDummyData));

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-004 Testing Writing To an invalid location"));

	writeSize = 0;
	err = iServSession.WriteCrashConfig(0xFFFFFFFF, KCrashDummyData, writeSize);

	test(err == KErrArgument);

	test.Next(_L("@SYMTestCaseID:DT-debug-securityserver-003 Testing Reading from an invalid location"));

	buf.FillZ();
	err = iServSession.ReadCrashLog(0xFFFFFFFF, buf, writeSize);

	test(err == KErrArgument);

	CleanupStack::PopAndDestroy(&buf);

#endif
	}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0735
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests the Kill Process functionality. Only can kill a debuggable process.
//! @SYMTestActions     Launches a debuggable and non-debuggable process and tries to kill both.
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------
void CRunModeAgent::TestKillProcess(void)
	{
	test.Next(_L("TestKillProcess\n"));

	// Kill a debuggable process

	// check that killing a process is supported
	TTag tag = GetTag(ETagHeaderIdKillObjects, EFunctionalityKillProcess);
	test(tag.iValue);
	// check that killing a thread is not supported
	tag = GetTag(ETagHeaderIdKillObjects, EFunctionalityKillThread);
	test(!tag.iValue);

	// attach first!
	TInt err = iServSession.AttachExecutable(KRMDebugTestApplication, EFalse /* Active */);
	test(err == KErrNone);

	// first launch a debuggable process
	RProcess process;
	err = LaunchProcess(process, KRMDebugTestApplication(),ESpinForever, 0, 0);
	test (err == KErrNone);

	// try to find the process in the list
_LIT(KRMDebugAppName, "t_rmdebug_app");

	TBool found = ProcessExists(KRMDebugAppName);
	test (found);

	TInt processId = process.Id();
	process.Close();

	// program now running, so try to kill it
	err = iServSession.KillProcess(processId, 0 /* kill reason */);
	test(err == KErrNone);

	User::After(2000000);	// should die within two seconds.

	// can we still find it? Should be gone
	found = ProcessExists(KRMDebugAppName);
	test (!found);

	// release the program again.
	err = iServSession.DetachExecutable(KRMDebugTestApplication);
	test(err == KErrNone);

	// Try to kill a non-debuggable process and fail.

	// first launch a non-debuggable process
	RProcess process2;
	err = LaunchProcess(process2, KRMDebugSecurity1FileName(),ESpinForever, 0, 0);
	test (err == KErrNone);

	// try to find the process in the list
_LIT(KRMDebugAppName2, "t_rmdebug_security1");

	TBool found2 = ProcessExists(KRMDebugAppName2);
	test (found2);

	TInt process2Id = process2.Id();
	process2.Close();

	// program now running, so try to kill it
	err = iServSession.KillProcess(process2Id, 0 /* kill reason */);
	test(err == KErrPermissionDenied);

	User::After(2000000);	// should die within two seconds if it is going to die.

	// can we still find it? Should be still around!
	found2 = ProcessExists(KRMDebugAppName2);
	test (found2);

	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-1388
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Tests the correct operation of the AddProcess and Remove Process
//! @SYMTestActions     1. Registers for AddProcess and Remove Process events
//!                     2. Starts a test process z:\sys\bin\t_rmdebug_security0.exe
//!                     3. Wait for the AddProcess event to be reported
//!                     4. Kill the newly started test process
//!                     5. Wait for the RemoveProcess event to be reported
//!                     6. Tell the DSS it is no longer interested in AddProcess and RemoveProcess events
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestAddRemoveProcessEvents()
	{
	test.Next(_L("TestAddRemoveProcessEvents\n"));

	// attach to a process (e.g. one of the simple security test programs)
	// launch the security program
	// wait for the add event
	// continue the program.
	// wait for the remove event
	// detach process

	test(KErrNone == iServSession.AttachExecutable(KRMDebugSecurity0FileName, EFalse));

	test(KErrNone == iServSession.SetEventAction(KRMDebugSecurity0FileName,EEventsAddProcess, EActionContinue));

	test(KErrNone == iServSession.SetEventAction(KRMDebugSecurity0FileName,EEventsRemoveProcess, EActionContinue));

	// Creator thread ID of the current thread (to be creator of test application)
	TInt creatorThreadId = RThread().Id();

	RProcess process;
	TInt err = process.Create(KRMDebugSecurity0FileName, KNullDesC, EOwnerProcess);
	test (err == KErrNone);

	// Rendezvous with process
	TRequestStatus status;
	process.Rendezvous(status);

	// Start the test program
	process.Resume();
	User::WaitForRequest(status);
	test(status==KErrNone);

	// Wait for the addprocess event
	TEventInfo info;
	TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));

	iServSession.GetEvent(KRMDebugSecurity0FileName,status,infoPtr);

	// Wait for notification of the addprocess hit event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// Check this was the right kind of event
	test(info.iEventType == EEventsAddProcess);

	const TInt uid3offset = 2;

	// Get UID3 for current process
	TUint32 Uid3 = process.Type()[uid3offset].iUid;

	// Check correct UID3 is returned from the driver
    test(info.iAddProcessInfo.iUid3 == Uid3);

    // Check correct creator ID for test application is returned from the driver
    test(info.iAddProcessInfo.iCreatorThreadId == creatorThreadId);

	// Kill the process, as we don't need it anymore
	process.Kill(KErrNone);

	// Wait for the remove process event
	iServSession.GetEvent(KRMDebugSecurity0FileName,status,infoPtr);

	// Wait for notification of the remove process hit event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// Check this was the right kind of event
	test(info.iEventType == EEventsRemoveProcess);

	test(KErrNone == iServSession.SetEventAction(KRMDebugSecurity0FileName,EEventsRemoveProcess, EActionIgnore));

	test(KErrNone == iServSession.SetEventAction(KRMDebugSecurity0FileName,EEventsAddProcess, EActionIgnore));

	test(KErrNone == iServSession.DetachExecutable(KRMDebugSecurity0FileName));

	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-0736
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Checks that process break points can be set, and that they can co-exist alongside thread breakpoints
//! @SYMTestActions     Checks that process break points can be set, and that they can co-exist alongside thread breakpoints
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------
void CRunModeAgent::TestProcessBreakPoints(void)
	{
	test.Next(_L("TestProcessBreakPoints\n"));

	// check that process breakpoints are supported
	TTag tag = GetTag(ETagHeaderIdBreakpoints, EBreakpointProcess);
	test(tag.iValue);

	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	// Try to set the breakpoint
	TBreakId breakId;
	TUint32 address = (TUint32)(&RMDebug_BranchTst1);
	RProcess process;
	TProcessId processId = process.Id();
	process.Close();

	test(KErrNone == iServSession.SetProcessBreak(breakId, processId, address, EArmMode));
	test(KErrAlreadyExists == iServSession.SetBreak(breakId, iThreadID, address, EArmMode));
	test(KErrAlreadyExists == iServSession.SetBreak(breakId, iThreadID, address, EThumbMode));
	test(KErrAlreadyExists == iServSession.SetProcessBreak(breakId, processId, address, EArmMode));
	test(KErrAlreadyExists == iServSession.SetProcessBreak(breakId, processId, address, EThumbMode));
	test(KErrNone == iServSession.ClearBreak(breakId));

	test(KErrNone == iServSession.SetBreak(breakId, iThreadID, address, EArmMode));
	test(KErrAlreadyExists == iServSession.SetProcessBreak(breakId, processId, address, EArmMode));
	test(KErrAlreadyExists == iServSession.SetProcessBreak(breakId, processId, address, EThumbMode));
	test(KErrNone == iServSession.ClearBreak(breakId));

	test(KErrNone == iServSession.ResumeThread(iThreadID));

	test(KErrNone == iServSession.DetachExecutable(iFileName));
	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID      KBase-T-RMDEBUG2-1309
//! @SYMTestType
//! @SYMPREQ            PREQ1426
//! @SYMTestCaseDesc    Checks that in the case of multiple low priority events (user traces in this case) we can still receive higher
//!				priority events should the buffer reach a critical level
//! @SYMTestActions     Run to first breakpoint in our test code. Then multiple trace events are issued. We should still be able to hit
//!				the second breakpoint
//!
//! @SYMTestExpectedResults KErrNone.
//! @SYMTestPriority        High
//! @SYMTestStatus          Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestMultipleTraceEvents(void)
	{
	test.Next(_L("TestMultipleTraceEvents\n"));

	//attach to target debug process
	test(KErrNone == iServSession.AttachExecutable(iFileName, EFalse));

	//and suspend the thread
	test(KErrNone == iServSession.SuspendThread(iThreadID));

	//register interest in BP's & trace events and trace ignored events
	test(KErrNone == iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionSuspend));
	test(KErrNone == iServSession.SetEventAction(iFileName,EEventsUserTrace, EActionContinue));
	test(KErrNone == iServSession.SetEventAction(iFileName,EEventsUserTracesLost, EActionContinue));

	// Try to set the breakpoints
	TBreakId armBreakId;
	TBreakId armBreakId2;
	TUint32 address = (TUint32)(&RMDebug_BranchTst1);
	TUint32 address2 = (TUint32)(&RMDebug_StepTest_Non_PC_Modifying);

	test(KErrNone == iServSession.SetBreak(armBreakId,iThreadID,address,EArmMode));
	test(KErrNone == iServSession.SetBreak(armBreakId2,iThreadID,address2,EArmMode));

	//set the target thread to execute the trace test function
	test(KErrNone == SwitchTestFunction(EMultipleTraceCalls));

	// Continue the thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));

	// wait for the breakpoint to be hit
	TEventInfo info;
	static TRequestStatus status;

	TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));
	iServSession.GetEvent(iFileName,status,infoPtr);

	// Wait for notification of the 1st breakpoint hit event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// info should now be filled with the details
	test(info.iEventType == EEventsBreakPoint);
	test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == address);
	test(info.iProcessIdValid);
	test(info.iThreadIdValid);

	// Continue the thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));

	//Now we try to hit the second breakpoint. This will occur after a number of trace calls. If we hit this breakpoint it
	//means many trace calls are not preventing us hitting breakpoints.
	iServSession.GetEvent(iFileName,status,infoPtr);

	// Wait for notification of the 2nd breakpoint hit event
	User::WaitForRequest(status);
	test(status==KErrNone);

	TBool receivedTracesLost = EFalse;

	while(info.iEventType == EEventsUserTrace || info.iEventType == EEventsUserTracesLost)
		{
		//ensure we get told traces are being thrown away - we generate enough to flood the buffer
		if(info.iEventType == EEventsUserTracesLost)
			{
			receivedTracesLost = ETrue;

			// Now stop the target thread from generating trace events
			test(KErrNone == SwitchTestFunction(EDoNothing));
			}
		else
			{
			// Its EEventsUserTrace, so delay us in getting the next event so that it will be more 
			// likely to get a EEventsUserTracesLost next time. 
			// This is important on SMP since the platform can process lots of events, and thus
			// withouth the delay it is difficult for this test to reproduce the abnormal situation of 
			// lost trace packets
			User::After(200000);
			}

		iServSession.GetEvent(iFileName,status,infoPtr);

		// Wait for notification of the 2nd breakpoint hit event
		User::WaitForRequest(status);
		test(status==KErrNone);
		}

	//make sure we got told traces were lost
	test(receivedTracesLost != EFalse);

	// info should now be filled with the details of our breakpoint.
	test(info.iEventType == EEventsBreakPoint);
	test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == address2);
	test(info.iProcessIdValid);
	test(info.iThreadIdValid);

	//dont care for breakpoints or trace events no more
	test(KErrNone == iServSession.SetEventAction(iFileName,EEventsBreakPoint, EActionIgnore));
	test(KErrNone == iServSession.SetEventAction(iFileName,EEventsUserTrace, EActionIgnore));
	test(KErrNone == iServSession.SetEventAction(iFileName,EEventsUserTracesLost, EActionIgnore));

	//clear the breaks we set
	test(KErrNone == iServSession.ClearBreak(armBreakId));
	test(KErrNone == iServSession.ClearBreak(armBreakId2));

	// Continue the thread
	test(KErrNone == iServSession.ResumeThread(iThreadID));

	//attach to target debug process
	test(KErrNone == iServSession.DetachExecutable(iFileName));

	}

//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBase-T-RMDEBUG2-2441
//! @SYMTestType
//! @SYMPREQ PREQ1426
//! @SYMTestCaseDesc Test clearing of a process breakpoint once the process has been killed.
//! @SYMTestActions Creates a new process then tries to set a process breakpoint and then kills the process which should clear the previously set breakpoint. Then repeat the step once again.
//! @SYMTestExpectedResults KErrNone
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------

void CRunModeAgent::TestProcessKillBreakpoint(void)
	{
	test.Next(_L("TestProcessKillBreakpoint\n"));
	//SID retrieved, used in Define/Attach of the property
	iMySid.iUid = RProcess().SecureId();

	static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

	//define a property to pass on the address from the other process we would try to debug
	test ( KErrNone == RProperty::Define(iMySid, EMyPropertyInteger, RProperty::EInt, KAllowAllPolicy, KAllowAllPolicy));
	    //define a global semaphore to synchronise with debuggable process publishing the property
	test ( KErrNone == iAddressGlobSem.CreateGlobal(_L("RMDebugGlobSem"), 0) );

	DoTestProcessKillBreakpoint();
	// called once again
	// to check if we can set the breakpoint once again after the process gets killed
	DoTestProcessKillBreakpoint();

	//delete the property
	test ( KErrNone == RProperty::Delete(iMySid, EMyPropertyInteger));
	//close the semaphore
	iAddressGlobSem.Close();
	}

void CRunModeAgent::DoTestProcessKillBreakpoint()
	{
	test.Printf(_L("\nDoTestProcessKillBreakpoint\n"));

	TInt err = KErrNone;

	// check that killing a process is supported
	TTag tag = GetTag(ETagHeaderIdKillObjects, EFunctionalityKillProcess);
	test(tag.iValue);
	// check that killing a thread is not supported
	tag = GetTag(ETagHeaderIdKillObjects, EFunctionalityKillThread);
	test(!tag.iValue);

	// attach first!
	test ( KErrNone == iServSession.AttachExecutable(KRMDebugTestApplication, EFalse/*  Active */));

	// first launch a debuggable process
	RProcess processDebug;
	test ( KErrNone == LaunchProcess(processDebug, KRMDebugTestApplication(),ESpinForeverWithBreakPoint, 0, 0));

	// try to find the process in the list
	_LIT(KRMDebugAppName, "t_rmdebug_app");
	TBool found = ProcessExists(KRMDebugAppName);
	test (found);

	//search for the main thread created
   _LIT(KThreadWildCard, "t_rmdebug_app*");
	TProcessId processDebugId = processDebug.Id();
	TThreadId threadDebugId;

   	TFindThread find(KThreadWildCard);
	TFullName name;
	found = EFalse;
	while(find.Next(name)==KErrNone && !found)
		{
		RThread thread;
		err = thread.Open(find);
       	if (err == KErrNone)
			{
			RProcess process;
			thread.Process(process);
			if (((TUint32)process.Id() == processDebugId))
				{
				TFullName fullname = thread.FullName();
				test.Printf(_L("Match Found Name %lS Process ID%ld Thread Id %ld"), &fullname, process.Id().Id(), thread.Id().Id());
				found = ETrue;
				threadDebugId = thread.Id();
				}
			process.Close();
			}
			thread.Close();
   		}

	test (found); //check if we actually found the thread we want to debug

	//get the value(property) for the breakpoint address for the process to debug
	TInt address;
	RProperty integerProperty;
	test ( KErrNone == integerProperty.Attach(iMySid, EMyPropertyInteger, EOwnerThread));

	//waiting on semaphore to be sure that the property is set
	iAddressGlobSem.Wait();

	test ( KErrNone == integerProperty.Get(address));
	integerProperty.Close();

	test.Printf(_L("Address retrieved to set breakpoint 0x%8x"), address);

	//suspend the thread before we set a breakpoint
	test ( KErrNone == iServSession.SuspendThread(threadDebugId));

	//set a process breakpoint
	TBreakId breakId;
	test(KErrNone == iServSession.SetProcessBreak(breakId, processDebugId, address, EArmMode));

	test(KErrNone ==iServSession.SetEventAction(KRMDebugTestApplication,EEventsProcessBreakPoint, EActionContinue));

	//resume the thread now
	test(KErrNone == iServSession.ResumeThread(threadDebugId));

	// wait for the breakpoint to be hit
	static TRequestStatus status;
	TEventInfo info;
	TPtr8 infoPtr((TUint8*)&info,0,sizeof(TEventInfo));
	iServSession.GetEvent(KRMDebugTestApplication,status,infoPtr);
	// Wait for notification of the breakpoint hit event
	User::WaitForRequest(status);
	test(status==KErrNone);

	// info should now be filled with the details
	test(info.iEventType ==  EEventsProcessBreakPoint);
	test(info.iThreadBreakPointInfo.iRmdArmExcInfo.iR15 == address);
	test(info.iProcessIdValid);
	test(info.iThreadIdValid);

	// Not interested in breakpoint events any more
	test(KErrNone == iServSession.SetEventAction(KRMDebugTestApplication, EEventsProcessBreakPoint, EActionIgnore));

	// program now running, so try to kill it which should clear all the breakpoints
	test(KErrNone == iServSession.KillProcess(processDebugId, 0  /* kill reason */ ));

	processDebug.Close();
	User::After(2000000);	// should die within two seconds.

	// can we still find it? Should be gone
	found = ProcessExists(KRMDebugAppName);
	test (!found);

	// release the program again
	test(KErrNone == iServSession.DetachExecutable(KRMDebugTestApplication));

	}

void CRunModeAgent::HelpTestSecurityAttachDetachExecutable(const TDesC& aProcessName, TBool aExpectSuccess)
	{
	RProcess process;
	TInt err = process.Create(aProcessName, KNullDesC, EOwnerProcess);
	test (err == KErrNone);

	// rendezvous with process
	TRequestStatus status;
	process.Rendezvous(status);

	// start the test program
	process.Resume();
	User::WaitForRequest(status);
	test(status==KErrNone);

	// attach to the program (passively)
	err = iServSession.AttachExecutable(aProcessName, EFalse);

	if( gUseDelay ) User::After(500000);

	// Do we expect to successfully attach
	if (aExpectSuccess)
	{
		// Yes
		test(KErrNone == err);

		// Now detach again
		test(KErrNone == iServSession.DetachExecutable(aProcessName));
		if( gUseDelay ) User::After(500000);
	}
	else
	{
		// No
		test(KErrPermissionDenied == err);

		// Just to be sure, try active attachment
		test(KErrPermissionDenied == iServSession.AttachExecutable(aProcessName, ETrue));
		if( gUseDelay ) User::After(500000);
	}

	// Kill the process, as we don't need it anymore
	process.Kill(KErrNone);
	if( gUseDelay ) User::After(500000);
	}

void CRunModeAgent::ReportPerformance(void)
//
// Reports performance metrics from all the tests
//
	{
	test.Printf(_L("\nPerformance\n"));
	test.Printf(_L("========================\n"));

	// Memory
	test.Printf(_L("Memory read: %d KBytes/sec\n"),iMemoryReadKbytesPerSecond);
	test.Printf(_L("Memory write: %d KBytes/sec\n"),iMemoryWriteKbytesPerSecond);

	// Registers
	// to do

	// events
	// to do

	// Breakpoints
	test.Printf(_L("Breakpoint set/clear: %d/sec\n"),iBreakpointsPerSecond);
	test.Printf(_L("Maximum number of breakpoints: %d\n"),iMaxBreakpoints);

	// Stepping
	test.Printf(_L("Stepping speed: %d/sec\n"),iStepsPerSecond);

	// Runtime
	TInt ticks = HelpGetTestTicks();
	test (ticks != 0);

	TInt nkTicksPerSecond = HelpTicksPerSecond();
	test (nkTicksPerSecond != 0);

	test.Printf(_L("Total test runtime: %d seconds\n"),ticks/nkTicksPerSecond);

	// Final sizes of executables/rom/ram etc
	// to do

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

/**
 * Helper code for the stepping tests. Sets a breakpoint in a running thread.
 * It suspends the thread, sets the breakpoint, and resumes the thread.
 *
 * @param aBreakId - Reference to a TBreakId which will be set when the breakpoint is set
 * @param aThreadId - The thread id for which we should set the breakpoint.
 * @param aBreakAddress - The address to set the breakpoint
 * @param aMode - The architecture of the breakpoint to be set (ARM/Thumb/Thumb2EE)
 * @return KErrNone if successful. One of the other system wide error codes otherwise.
 */
TInt CRunModeAgent::HelpTestStepSetBreak(TBreakId& aBreakId, TThreadId aThreadId, const TUint32 aBreakAddress, TArchitectureMode aMode, TBool aThreadSpecific, TProcessId aProcessId)
	{
	TInt err = KErrNone;

	// Suspend the thread
	err = iServSession.SuspendThread(aThreadId);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStepSetBreak - Failed to suspend thread\n"));
		return err;
		}

	// Set the breakpoint
	err = aThreadSpecific
		? iServSession.SetBreak(aBreakId,aThreadId,aBreakAddress,aMode)
		: iServSession.SetProcessBreak(aBreakId, aProcessId, aBreakAddress, aMode);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStepSetBreak - Failed to set breakpoint\n"));
		return err;
		}

	// Continue the thread
	err = iServSession.ResumeThread(aThreadId);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStepSetBreak - Failed to resume thread\n"));
		return err;
		}

	return KErrNone;
	}

/**
 * Helper code for the stepping tests. Clears a breakpoint in a running thread.
 * It suspends the thread, clears the breakpoint, and resumes the thread.
 *
 * @param aBreakId - Reference to a TBreakId which will be set when the breakpoint is set
 * @return KErrNone if successful. One of the other system wide error codes otherwise.
 */
TInt CRunModeAgent::HelpTestStepClearBreak(TBreakId aBreakId, const TThreadId aThreadId, TBool aThreadSpecific)
	{
	TInt err = KErrNone;

	// Find out what thread id we need to suspend
	TThreadId threadId;
	TProcessId processId;
	TUint32 address;
	TArchitectureMode mode;

	err = aThreadSpecific
		? iServSession.BreakInfo(aBreakId, threadId, address, mode)
		: iServSession.ProcessBreakInfo(aBreakId, processId, address, mode);
	if (err != KErrNone )
		{
		test.Printf(_L("HelpTestStepClearBreak - failed to obtain information for breakpoint\n"));
		return err;
		}
	if(aThreadSpecific && aThreadId != threadId)
		{
		test.Printf(_L("HelpTestStepClearBreak - mismatched thread Ids\n"));
		return KErrGeneral;
		}

	// Suspend the thread
	err = iServSession.SuspendThread(aThreadId);
	if (!(err == KErrNone || err == KErrAlreadyExists))
		{
		test.Printf(_L("HelpTestStepClearBreak - failed to suspend thread\n"));
		return err;
		}

	// Clear the breakpoint
	err = iServSession.ClearBreak(aBreakId);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStepClearBreak - failed to clear breakpoint\n"));
		return err;
		}

	// Continue the thread
	err = iServSession.ResumeThread(aThreadId);
	if (!(err == KErrNone || err == KErrNotFound))
		{
		test.Printf(_L("HelpTestStepClearBreak - failed to resume thread\n"));
		return err;
		}

	return KErrNone;
	}

/**
 * Helper code for the stepping tests. Waits for a previously set breakpoint to be hit.
 *
 * @param aProcessName - The name of the process in which the breakpoint is set. E.g. z:\sys\bin\app.exe
 * @param aEventInfo - The event information block which is filled in when the breakpoint is hit.
 * @return KErrNone if successful. One of the other system wide error codes otherwise.
 */
TInt CRunModeAgent::HelpTestStepWaitForBreak(const TDesC& aProcessName, TEventInfo& aEventInfo)
	{
	static TRequestStatus status;

	TPtr8 infoPtr((TUint8*)&aEventInfo,0,sizeof(TEventInfo));

	iServSession.GetEvent(aProcessName,status,infoPtr);

	// Wait for notification of the breakpoint hit event
	User::WaitForRequest(status);
	if (status == KErrNone)
		{
		return KErrNone;
		}
	else
		{
		return KErrGeneral;
		}
	}

/**
 * Helper code for the stepping tests. Reads the current target PC for a given thread.
 *
 * @param aThreadId - Thread id for which to read the current target PC.
 * @param aPc - Reference to a TUint32 which will be set to the current target PC.
 * @return KErrNone if successful. One of the other system wide error codes otherwise.
 */
TInt CRunModeAgent::HelpTestStepReadPC(TThreadId aThreadId, TUint32& aPC)
	{
	TInt err = KErrNone;

	//create buffer containing PC register ID
	RBuf8 pcId;
	err = pcId.Create(sizeof(TRegisterInfo));
	if (err != KErrNone)
		{
		return err;
		}

	TRegisterInfo reg1 = (TRegisterInfo)0x00000f00;
	pcId.Append(reinterpret_cast<const TUint8*>(&reg1), sizeof(TRegisterInfo));

	//create buffer containing desired PC value
	TPtr8 pcValue((TUint8*)&aPC,4,4);

	//create buffer for PC flag value
	RBuf8 pcFlag;
	err = pcFlag.Create(sizeof(TUint8));

	//read the new PC value
	err = iServSession.ReadRegisters(aThreadId, pcId, pcValue, pcFlag);
	if (err != KErrNone)
		{
		//delete temporary buffers
		pcId.Close();
		pcFlag.Close();
		return err;
		}

	//get the flag and check the PC value was read ok
	TRegisterFlag flag = ENotSupported;
	err = GetFlag(pcFlag, 0, flag);
	if (err != KErrNone)
		{
		//delete temporary buffers
		pcId.Close();
		pcFlag.Close();
		return err;
		}

	if (flag == EValid)
		{
		//delete temporary buffers
		pcId.Close();
		pcFlag.Close();
		return KErrNone;
		}
	else
		{
		//delete temporary buffers
		pcId.Close();
		pcFlag.Close();
		return err;
		}
	}

/**
 * Helper code for the stepping tests. Single steps a given thread from aStartAddress to aEndAddress. Note
 * that it reaches aStartAddress by setting a breakpoint at that address and waiting until it is hit.
 *
 * @param aThreadId - Thread id for which to read the current target PC.
 * @param aStartAddress - The target address at which stepping will start.
 * @param aEndAddress - The target address at which stepping will end.
 * @param aMode - The architecture of the breakpoint which must be set at the start address (ARM/Thumb/Thumb2EE).
 * @return KErrNone if successful. One of the other system wide error codes otherwise.
 */
TInt CRunModeAgent::HelpTestStep(TThreadId aThreadId, TUint32 aStartAddress, TUint32 aEndAddress, TArchitectureMode aMode, TUint aNumSteps, TBool aThreadSpecific, TProcessId aProcessId)
	{
	TInt err = KErrNone;

	// Ensure that the supplied addresses are word/half-word aligned as appropriate.
	if (aMode == EArmMode)
		{
		// ARM breakpoints must be word-aligned (2 lsb must be zero)
		aStartAddress &= 0xFFFFFFFC;
		aEndAddress &= 0xFFFFFFFC;
		}
	else if (aMode == EThumbMode)
		{
		// Thumb breakpoints must be half-word aligned (lsb must be zero)
		aStartAddress &= 0xFFFFFFFE;
		aEndAddress	 &= 0xFFFFFFFE;
		}
	else if (aMode == EThumb2EEMode)
	{
		// Thumb2EE breakpoints are not currently supported
		return KErrNotSupported;
	}

	// Set breakpoint at the start address
	TBreakId tempBreakId;
	TEventInfo info;

	err = HelpTestStepSetBreak(tempBreakId,aThreadId,aStartAddress,aMode,aThreadSpecific,aProcessId);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStep - Failed to set breakpoint at aStartAddress 0x%08x\n"),aStartAddress);
		return err;
		}

	// wait for the breakpoint to be hit
	err = HelpTestStepWaitForBreak(iFileName,info);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStep - Failed to hit the breakpoint at aStartAddress 0x%08x\n"),aStartAddress);
		return err;
		}

	// Check the PC == aStartAddress
	TUint32 pc = 0;
	err = HelpTestStepReadPC(aThreadId,pc);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStep - Failed to read the PC after hitting breakpoint at aStartAddress 0x%08x\n"),aStartAddress);
		return err;
		}

	if (pc != aStartAddress)
		{
		test.Printf(_L("HelpTestStep - Incorrect PC value after hitting breakpoint (expected 0x%08x actual 0x%08x)\n"),aStartAddress,pc);
		return KErrGeneral;
		}

	err = iServSession.Step(aThreadId,aNumSteps);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStep - Failed to do step from 0x%08x to 0x%08x\n"),aStartAddress,aEndAddress,aNumSteps);
		return err;
		}

	// only one 'completed step' event in the buffer.
	err = HelpTestStepWaitForBreak(iFileName,info);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStep - Could not read breakpoint event info after stepping"));
		return err;
		}
	// end

	// Check PC == aEndAddress
	err = HelpTestStepReadPC(aThreadId,pc);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStep - failed read the PC after stepping\n"));
		return err;
		}
	if (pc != aEndAddress)
		{
		test.Printf(_L("HelpTestStep - Incorrect PC value after stepping (expected 0x%08x actual 0x%08x)\n"),aEndAddress,pc);
		return KErrGeneral;
		}

	// Clear the breakpoint
	err = HelpTestStepClearBreak(tempBreakId, aThreadId, aThreadSpecific);
	if (err != KErrNone)
		{
		test.Printf(_L("HelpTestStep - failed to clear temporary breakpoint\n"));
		return err;
		}

	return KErrNone;
	}

/**
 * Helper code for the stepping tests. Returns the number of nanokernel ticks in one second.
 *
 * @return Number of nanokernel ticks. 0 if unsuccesful.
 */
TInt CRunModeAgent::HelpTicksPerSecond(void)
	{
	TInt nanokernel_tick_period;
	HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);

	ASSERT(nanokernel_tick_period != 0);

	static const TInt KOneMillion = 1000000;

	return KOneMillion/nanokernel_tick_period;
	}

/**
  Given aTestNumber runs the appropriate test inside heap markers

  @param aTestNumber test to run, corresponds to an entry in iTestArray

  @panic Panic if aTestNumber is not in valid range
  */
void CRunModeAgent::RunTest(TInt aTestNumber)
	{
	if( (aTestNumber<0) || (aTestNumber>=KMaxTests) )
		{
		User::Panic(_L("Test number out of range"), aTestNumber);
		}
	__UHEAP_MARK;
	(this->*(iTestArray[aTestNumber].iFunctionPtr))();
	__UHEAP_MARKEND;
	}

void CRunModeAgent::PrintVersion()
	{
	test.Printf(_L("\nt_rmdebug2.exe\nVersion: %S\n"), &(testVersion.Name()));
	test.Printf(_L("Press any key...\n"));
	test.Getch();
	}

void CRunModeAgent::PrintUsage()
	{
	test.Printf(_L("Invoke with arguments:\n"));
	test.Printf(_L("-r: run specified tests in reverse order\n"));
	test.Printf(_L("-h: display usage information\n"));
	test.Printf(_L("-v: display version\n"));
	test.Printf(_L("-d: use delays\n"));
	test.Printf(_L("<number>: test number to run, can specify more than one from the following list:\n"));
	test.Printf(_L("Press any key for list...\n"));
	test.Getch();
	// if there are too many of these they won't fit on the screen! Stick another Getch() in if there get too many
	for(TInt i=0; i<KMaxTests; i++)
		{
		test.Printf(_L("%2d: %S\n"), i, &(iTestArray[i].iFunctionName));
		}
	test.Printf(_L("Press any key...\n"));
	test.Getch();
	}

/**
  Parse the command line, see CRunModeAgent::PrintUsage for syntax
  */
void CRunModeAgent::ParseCommandLineL(TUint32& aMode, RArray<TInt>& aTests)
	{
	// get the length of the command line arguments
	TInt argc = User::CommandLineLength();

	// allocate a buffer for the command line arguments and extract the data to it
	HBufC* commandLine = HBufC::NewLC(argc);
	TPtr commandLineBuffer = commandLine->Des();
	User::CommandLine(commandLineBuffer);

	// reset mode
	aMode = (TTestMode)0;

	// create a lexer and read through the command line
	TLex lex(*commandLine);
	while (!lex.Eos())
		{
		// expecting the first character to be a '-'
		if (lex.Get() == '-')
			{
			TChar arg = lex.Get();
			switch (arg)
				{
				case 'v':
					//print out the help
					aMode |= EModeVersion;
					break;
				case 'h':
					//print out the help
					aMode |= EModeHelp;
					break;
				case 'r':
					//store the fact that we want to run in reverse
					aMode |= EModeReverse;
					break;
				case 'd':
					//store the fact that we want to run in reverse
					gUseDelay = EFalse;
					RDebug::Printf("Not using delays");
					break;
				default:
					// unknown argument so leave
					User::Leave(KErrArgument);
				}
			}
		else
			{
			lex.UnGet();
			TInt testNumber;
			User::LeaveIfError(lex.Val(testNumber));
			if( (testNumber<0) || (testNumber>=KMaxTests) )
				{
				User::Leave(KErrArgument);
				}
			aTests.AppendL(testNumber);
			}
		lex.SkipSpace();
		}
	// if no tests specified then run them all
	if(aTests.Count() == 0)
		{
		aMode |= EModeAll;
		}

	// do clean up
	CleanupStack::PopAndDestroy(commandLine);
	}

void CRunModeAgent::ClientAppL()
//
// Performs each test in turn
//
	{
	test.Start(_L("ClientAppL"));

	RArray<TInt> testsToRun;
	TUint32 testMode = 0;
	ParseCommandLineL(testMode, testsToRun);

	//if help or version mode specified then just print out the relevant stuff and quit
	if((testMode & EModeHelp) || (testMode & EModeVersion))
		{
		if(testMode & EModeHelp)
			{
			PrintUsage();
			}
		if(testMode & EModeVersion)
			{
			PrintVersion();
			}
		test.End();
		return;
		}

	if(testMode & EModeAll)
		{
		for(TInt i=0; i<KMaxTests; i++)
			{
			testsToRun.AppendL(i);
			}
		}

	// if EModeReverse specified then reverse the array elements
	TInt numberOfTests = testsToRun.Count();
	if(testMode & EModeReverse)
		{
		for(TInt i=0; i<(numberOfTests>>1); i++)
			{
			TInt temp = testsToRun[i];
			testsToRun[i] = testsToRun[numberOfTests - (i+1)];
			testsToRun[numberOfTests - (i+1)] = temp;
			}
		}

	__UHEAP_MARK;
	SetupAndAttachToDSS();
	__UHEAP_MARKEND;

	HelpStartTestTimer();
	for(TInt i=0; i<numberOfTests; i++)
		{
		RunTest(testsToRun[i]);
		if( gUseDelay ) User::After(500000);
		}
	testsToRun.Close();

	HelpStopTestTimer();

	ReportPerformance();

	test.End();
	}

/**
  Fill the test array with pointers to each test.
  */
void CRunModeAgent::FillArray()
	{
	iTestArray[0].iFunctionPtr = &CRunModeAgent::TestDriverSecurity;
	iTestArray[0].iFunctionName = _L("TestDriverSecurity");
	iTestArray[1].iFunctionPtr = &CRunModeAgent::TestDllUsage;
	iTestArray[1].iFunctionName = _L("TestDllUsage");
	iTestArray[2].iFunctionPtr = &CRunModeAgent::TestSecurity;
	iTestArray[2].iFunctionName = _L("TestSecurity");
	iTestArray[3].iFunctionPtr = &CRunModeAgent::TestAttachExecutable;
	iTestArray[3].iFunctionName = _L("TestAttachExecutable");
	iTestArray[4].iFunctionPtr = &CRunModeAgent::TestGetExecutablesList;
	iTestArray[4].iFunctionName = _L("TestGetExecutablesList");
	iTestArray[5].iFunctionPtr = &CRunModeAgent::TestGetProcessList;
	iTestArray[5].iFunctionName = _L("TestGetProcessList");
	iTestArray[6].iFunctionPtr = &CRunModeAgent::TestGetXipLibrariesList;
	iTestArray[6].iFunctionName = _L("TestGetXipLibrariesList");
	iTestArray[7].iFunctionPtr = &CRunModeAgent::TestGetThreadList;
	iTestArray[7].iFunctionName = _L("TestGetThreadList");
	iTestArray[8].iFunctionPtr = &CRunModeAgent::TestGetCodeSegsList;
	iTestArray[8].iFunctionName = _L("TestGetCodeSegsList");
	iTestArray[9].iFunctionPtr = &CRunModeAgent::TestGetListInvalidData;
	iTestArray[9].iFunctionName = _L("TestGetListInvalidData");
	iTestArray[10].iFunctionPtr = &CRunModeAgent::TestMemoryAccess;
	iTestArray[10].iFunctionName = _L("TestMemoryAccess");
	iTestArray[11].iFunctionPtr = &CRunModeAgent::TestDebugFunctionality;
	iTestArray[11].iFunctionName = _L("TestDebugFunctionality");
	iTestArray[12].iFunctionPtr = &CRunModeAgent::TestSuspendResume;
	iTestArray[12].iFunctionName = _L("TestSuspendResume");
	iTestArray[13].iFunctionPtr = &CRunModeAgent::TestBreakPoints;
	iTestArray[13].iFunctionName = _L("TestBreakPoints");
	iTestArray[14].iFunctionPtr = &CRunModeAgent::TestModifyBreak;
	iTestArray[14].iFunctionName = _L("TestModifyBreak");
	iTestArray[15].iFunctionPtr = &CRunModeAgent::TestBreakInfo;
	iTestArray[15].iFunctionName = _L("TestBreakInfo");
	iTestArray[16].iFunctionPtr = &CRunModeAgent::TestRunToBreak;
	iTestArray[16].iFunctionName = _L("TestRunToBreak");
	iTestArray[17].iFunctionPtr = &CRunModeAgent::TestBreakPointsInLoop;
	iTestArray[17].iFunctionName = _L("TestBreakPointsInLoop");
	iTestArray[18].iFunctionPtr = &CRunModeAgent::TestRegisterAccess;
	iTestArray[18].iFunctionName = _L("TestRegisterAccess");
	iTestArray[19].iFunctionPtr = &CRunModeAgent::TestStep;
	iTestArray[19].iFunctionName = _L("TestStep");
	iTestArray[20].iFunctionPtr = &CRunModeAgent::TestDemandPaging;
	iTestArray[20].iFunctionName = _L("TestDemandPaging");
	iTestArray[21].iFunctionPtr = &CRunModeAgent::TestEventsForExternalProcess;
	iTestArray[21].iFunctionName = _L("TestEventsForExternalProcess");
	iTestArray[22].iFunctionPtr = &CRunModeAgent::TestEvents;
	iTestArray[22].iFunctionName = _L("TestEvents");
	iTestArray[23].iFunctionPtr = &CRunModeAgent::TestKillProcess;
	iTestArray[23].iFunctionName = _L("TestKillProcess");
	iTestArray[24].iFunctionPtr = &CRunModeAgent::TestProcessBreakPoints;
	iTestArray[24].iFunctionName = _L("TestProcessBreakPoints");
	iTestArray[25].iFunctionPtr = &CRunModeAgent::TestMultipleTraceEvents;
	iTestArray[25].iFunctionName = _L("TestMultipleTraceEvents");
	iTestArray[26].iFunctionPtr = &CRunModeAgent::TestAddRemoveProcessEvents;
	iTestArray[26].iFunctionName = _L("TestAddRemoveProcessEvents");
	iTestArray[27].iFunctionPtr = &CRunModeAgent::TestCrashFlash;
	iTestArray[27].iFunctionName = _L("TestCrashFlash");
	iTestArray[28].iFunctionPtr = &CRunModeAgent::TestProcessKillBreakpoint;
	iTestArray[28].iFunctionName = _L("TestProcessKillBreakpoint");
	};

GLDEF_C TInt E32Main()
//
// Entry point for run mode debug driver test
//
	{
   TInt ret = KErrNone;

	// client
	CTrapCleanup* trap = CTrapCleanup::New();
	if (!trap)
		return KErrNoMemory;
   	test.Title();
   RunModeAgent = CRunModeAgent::NewL();
   if (RunModeAgent != NULL)
       {
        __UHEAP_MARK;
	    TRAP(ret,RunModeAgent->ClientAppL());
	    __UHEAP_MARKEND;

	    delete RunModeAgent;
       }

	delete trap;

	return ret;
	}

/**
Helper function to get the aOffset'th value from aFlags

@param aFlags descriptor containing TRegisterFlag type flags
@param aOffset index of flag value to extract from aFlags
@param aFlagValue the flag value if function returned successfully

@return KErrNone if value was read successfully, KErrTooBig if aOffset is
        greater than aFlags.Length()
*/
TInt CRunModeAgent::GetFlag(const TDes8& aFlags, const TUint aOffset, TRegisterFlag &aFlagValue) const
	{
	//get pointer to data
	const TUint8 *ptr = aFlags.Ptr();

	//check aOffset is valid
	TUint length = aFlags.Length();
	if(aOffset >= length)
		return KErrTooBig;

	//get flag value
	aFlagValue = (TRegisterFlag)ptr[aOffset];
	return KErrNone;
	}

/**
  Helper function to set the value of FunctionChooser in the target debug thread.

  @param aTestFunction TTestFunction enum to set FunctionChooser to

  @return KErrNone if the value was set correctly, or one of the other system wide error codes
  */
TInt CRunModeAgent::SwitchTestFunction(TTestFunction aTestFunction)
	{
	//suspend the target thread
	TInt suspendError = iServSession.SuspendThread(iThreadID);
	if(! ( (suspendError == KErrNone) || (suspendError == KErrAlreadyExists) ) )
		{
		//the thread is not suspended so exit
		return suspendError;
		}

	//get the address of FunctionChooser
	TUint32 functionChooserAddress = (TUint32)&FunctionChooser;
	//put the new value for FunctionChooser into a descriptor
	TPtr8 functionBuf((TUint8*)&aTestFunction, sizeof(TTestFunction), sizeof(TTestFunction));
	//write the new value into the target thread
	TInt writeError = iServSession.WriteMemory(iThreadID, functionChooserAddress, sizeof(TTestFunction), functionBuf, EAccess32, EEndLE8);

	if(KErrNone == suspendError)
		{
		//if this function suspended the target thread then we need to resume it
		TInt resumeError = iServSession.ResumeThread(iThreadID);
		if(KErrNone != resumeError)
			{
			//resuming failed so return the error
			return resumeError;
			}
		}

	//suspending and resuming was successful so return the error code from the WriteMemory call
	return writeError;
	}

/**
  Launch a separate process to debug.

  @param aProcess the RProcess object to use to create the process
  @param aFileName file name of the executable to create the process from
  @param aFunctionType function that the target process should call on execution
  @param aDelay delay before the new process should call the function represented by aFunctionType
  @param aExtraThreads number of extra threads to create in the child process

  @return KErrNone on success, or one of the other system wide error codes
  */
TInt CRunModeAgent::LaunchProcess(RProcess& aProcess, const TDesC& aFileName, TDebugFunctionType aFunctionType, TUint32 aDelay, TUint32 aExtraThreads)
	{
	// at the moment we support two arguments, this number might have to be increased to support arguments
	const TUint KMaxCommandLineLength = 32;

	// create a command line buffer
	RBuf commandLine;
	commandLine.Create(KMaxCommandLineLength);

	// append the command line arguments to the buffer
	_LIT(KFArg, "-f");
	commandLine.Append(KFArg());
	commandLine.AppendNum(aFunctionType);

	_LIT(KSpace, " ");
	commandLine.Append(KSpace());

	_LIT(KDArg, "-d");
	commandLine.Append(KDArg());
	commandLine.AppendNum(aDelay);

	commandLine.Append(KSpace());

	_LIT(KEArg, "-e");
	commandLine.Append(KEArg());
	commandLine.AppendNum(aExtraThreads);

	// create the new process, matching on file name only, not specifying uid values
	TInt err = aProcess.Create(aFileName, commandLine);	// owned by the process

	// check that there was no error raised
	if(err != KErrNone)
		{
		commandLine.Close();
		return err;
		}

	TRequestStatus status = KRequestPending;
	aProcess.Rendezvous(status);

	commandLine.Close();	// after target thread starts

	if(KRequestPending != status.Int())
		{
		// startup failed so kill the process
		aProcess.Kill(KErrNone);
		return status.Int();
		}
	else
		{
		// start up succeeded so resume the process
		aProcess.Resume();
		User::WaitForRequest(status);
		if(KErrNone != status.Int())
			{
			aProcess.Kill(KErrNone);
			}
		return status.Int();
		}
	}

/**
  Helper function to read a tag header from a debug functionality block

  @param aDebugFunctionalityBlock block to read header from
  @param aTagHdrId header type to find

  @return pointer to the header, or NULL if not available
  */
TTagHeader* CRunModeAgent::GetTagHdr(const TDesC8& aDebugFunctionalityBlock, const TTagHeaderId aTagHdrId) const
	{
	TUint8* ptr = (TUint8*) aDebugFunctionalityBlock.Ptr();
	TUint8* blockEnd = ptr + aDebugFunctionalityBlock.Size();

	while(ptr < blockEnd)
		{
		TTagHeader* header = (TTagHeader*)ptr;
		if(header->iTagHdrId == aTagHdrId)
			{
			return header;
			}
		ptr += sizeof(TTagHeader) + (header->iNumTags * sizeof(TTag));
		}
	return NULL;
	}

/**
  Helper function to read a tag from a debug functionality block

  @param aTagHdr pointer to a tag header in a debug functionality block
  @param aElement element to return from the header's data

  @return pointer to the tag, or NULL if not available
  */
TTag* CRunModeAgent::GetTag(const TTagHeader* aTagHdr, const TInt aElement) const
	{
	TUint8* ptr = (TUint8*)aTagHdr + sizeof(TTagHeader);
	TUint8* blockEnd = ptr + (aTagHdr->iNumTags * sizeof(TTag));

	while(ptr < blockEnd)
		{
		TTag* tag = (TTag*)ptr;
		if(tag->iTagId == aElement)
			{
			return tag;
			}
		ptr += sizeof(TTag);
		}
	return NULL;
	}

TTag CRunModeAgent::GetTag(const TTagHeaderId aTagHdrId, const TInt aElement)
	{
	TUint32 bufsize = 0;	// Safe default size

	// Get functionality block size
	test(KErrNone == iServSession.GetDebugFunctionalityBufSize(&bufsize));

	// Ensure we have a finite buffer size
	test(bufsize!=0);

	// Allocate space for the functionality data
	HBufC8* dftext = HBufC8::NewLC(bufsize);

	// create an empty TPtr8 refering to dftext
	TPtr8 dftextPtr(dftext->Des());

	// Get the functionality block
	test(KErrNone == iServSession.GetDebugFunctionality(dftextPtr));

	// read a value from the data to check it has come through as expected
	TTagHeader* header = GetTagHdr(dftext->Des(), aTagHdrId);
	test(header != NULL);
	TTag* tag = GetTag(header, aElement);
	test(tag != NULL);

	TTag tagToReturn = *tag;

	// Remove our temporary buffer
	CleanupStack::PopAndDestroy(dftext);

	return tagToReturn;
	}

/**
  Helper function which returns a Boolean indicating with a process with the
  specified name is currently running.

  @param aProcessName - Name of the process to find
  @return ETrue if found, EFalse otherwise
  */
TBool CRunModeAgent::ProcessExists(const TDesC& aProcessName)
	{
	TInt    err=KErrNone;
	TBool	found = FALSE;

_LIT(KWildCard,"*");

	TFindProcess find(KWildCard);
	TFullName name;
	while(find.Next(name)==KErrNone)
		{
		RProcess process;
		err = process.Open(find);
		if (err == KErrNone)
			{
			if (name.Find(aProcessName) != KErrNotFound)
				{
					found = TRUE;
				}
			process.Close();
			}
	   }

	return found;
	}
