1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Tests the functionality of the run mode debug device driver.

    15 //

    16 //

    17 

    18 #include <e32base.h>

    19 #include <e32base_private.h>

    20 #include <e32cons.h>

    21 #include <e32test.h>

    22 #include <e32ldr.h>

    23 #include <e32svr.h>

    24 #include <e32cmn.h>

    25 #include <e32cmn_private.h>

    26 #include <f32dbg.h>

    27 #include <f32file.h>

    28 #include <hal.h>

    29 #include <u32hal.h>

    30 #include <e32property.h>

    31 

    32 #include "t_rmdebug_dll.h"

    33 

    34 #include <rm_debug_api.h>

    35 #include "d_rmdebugthread2.h"

    36 #include "t_rmdebug2.h"

    37 #include "t_rmdebug_app.h"

    38 

    39 #ifdef __MARM_ARMV4__

    40 #include "d_rmdebug_step_test_armv4.h"

    41 #endif

    42 

    43 #ifdef __MARM_ARMV5__

    44 #include "d_rmdebug_step_test.h"

    45 #endif

    46 

    47 #include "d_demand_paging.h"

    48 

    49 #ifdef KERNEL_OOM_TESTING

    50 	#ifdef USER_OOM_TESTING

    51 		#error "Cannot define both KERNEL_OOM_TESTING and USER_OOM_TESTING"

    52 	#endif

    53 #endif

    54 

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

    56 

    57 using namespace Debug;

    58 

    59 const TVersion securityServerVersion(0,1,1);

    60 

    61 const TVersion testVersion(2,1,0);

    62 

    63 IMPORT_C TInt StartDebugThread(RThread& aServerThread, const TDesC& aDebugThreadName);

    64 IMPORT_D extern TInt TestData;

    65 IMPORT_D extern TTestFunction FunctionChooser;

    66 IMPORT_D extern TBuf8<SYMBIAN_RMDBG_MEMORYSIZE> gMemoryAccessBytes;

    67 IMPORT_C TInt TestFunction();

    68 IMPORT_C void TestPagedCode();

    69 IMPORT_C extern TInt RMDebugDemandPagingTest();

    70 

    71 // Device driver name

    72 _LIT(KDebugDriverFileName,"rm_debug.ldd");

    73 

    74 #ifdef SYMBIAN_STANDARDDEBUG

    75 LOCAL_D RTest test(_L("T_RMDEBUG2"));

    76 #endif

    77 

    78 #ifdef SYMBIAN_OEMDEBUG

    79 LOCAL_D RTest test(_L("T_RMDEBUG2_OEM"));

    80 #endif

    81 

    82 #ifdef SYMBIAN_OEM2DEBUG

    83 LOCAL_D RTest test(_L("T_RMDEBUG2_OEM2"));

    84 #endif

    85 

    86 CRunModeAgent::CRunModeAgent()

    87 //

    88 // CRunModeAgent constructor

    89 //

    90 	{

    91 	FillArray();

    92 	RProcess thisProcess;

    93 	iFileName = thisProcess.FileName();

    94 	thisProcess.Close();

    95 	}

    96 

    97 CRunModeAgent* CRunModeAgent::NewL()

    98 //

    99 // CRunModeAgent::NewL

   100 //

   101 	{

   102 	CRunModeAgent* self = new(ELeave) CRunModeAgent();

   103 

   104   	self->ConstructL();

   105 

   106 	return self;

   107 	}

   108 

   109 CRunModeAgent::~CRunModeAgent()

   110 //

   111 // CRunModeAgent destructor

   112 //

   113 	{

   114 	User::FreeLogicalDevice(KDebugDriverFileName);

   115 	iServSession.Close();

   116 	iDebugThread.Close();

   117 	}

   118 

   119 void CRunModeAgent::ConstructL()

   120 //

   121 // CRunModeAgent::ConstructL

   122 //

   123 	{

   124 	// nothing to do here

   125 	}

   126 

   127 void CRunModeAgent::SetupAndAttachToDSS()

   128 //

   129 // CRunModeAgent::SetupAndAttachToDSS

   130 //

   131 	{

   132 	TInt err = StartDebugThread(iDebugThread, KDebugThreadName);

   133 

   134 	// get the thread id for use in the tests

   135 	iThreadID = iDebugThread.Id();

   136 

   137 	if (err != KErrNone)

   138 		{

   139 		User::Panic(_L("Can't start debug thread"), err);

   140 		}

   141 

   142 	err = iServSession.Connect(securityServerVersion);

   143 	if (err != KErrNone)

   144 		{

   145 		User::Panic(_L("Can't open server session"), err);

   146 		}

   147 	}

   148 

   149 CRunModeAgent *RunModeAgent;

   150 

   151 // helper function to check whether the listing of type aListId is supported for a scope of aListScope

   152 TBool CRunModeAgent::ListingSupported(const TListId aListId, const TListScope aListScope)

   153 	{

   154 	TTag tag = GetTag(ETagHeaderList, aListId);

   155 

   156 	return (tag.iValue) & aListScope;

   157 	}

   158 

   159 //---------------------------------------------

   160 //! @SYMTestCaseID KBase-T-RMDEBUG2-0426

   161 //! @SYMTestType

   162 //! @SYMPREQ PREQ1426

   163 //! @SYMTestCaseDesc Test getting the list of XIP libraries

   164 //! @SYMTestActions The XIP library list should be successfully obtained

   165 //! @SYMTestExpectedResults The specified ldd file should be present in the obtained listing

   166 //! @SYMTestPriority High

   167 //! @SYMTestStatus Implemented

   168 //---------------------------------------------

   169 void CRunModeAgent::TestGetXipLibrariesList()

   170 	{

   171 	test.Next(_L("TestGetXipLibrariesList\n"));

   172 

   173 	test(ListingSupported(EXipLibraries, EScopeGlobal));

   174 	test(!ListingSupported(EXipLibraries, EScopeProcessSpecific));

   175 	test(!ListingSupported(EXipLibraries, EScopeThreadSpecific));

   176 

   177 	//allocate a very small buffer so the GetList call initially fails

   178 	RBuf8 buffer;

   179 	test(KErrNone == buffer.Create(1));

   180 	TUint32 size = 0;

   181 

   182 	//get the list data

   183 	DoGetList(EXipLibraries, EScopeGlobal, buffer, size);

   184 

   185 	//search the buffer for entry corresponding to the debug kernel driver

   186 	//which should be in the rom

   187 	_LIT(KRmDebugLddName, "z:\\sys\\bin\\rm_debug.ldd");

   188 

   189 	//iterate through the buffer and set found to ETrue if we find the driver

   190 	TBool found = EFalse;

   191 	TUint8* ptr = (TUint8*)buffer.Ptr();

   192 	const TUint8* ptrEnd = ptr + size;

   193 	while(ptr < ptrEnd)

   194 		{

   195 		TXipLibraryListEntry& xipLibrary = *(TXipLibraryListEntry*)ptr;

   196 

   197 		//get the name of the library

   198 		TPtr name(&xipLibrary.iName[0], xipLibrary.iNameLength, xipLibrary.iNameLength);

   199 		if(name.CompareF(KRmDebugLddName()) == 0)

   200 			{

   201 			//found the library but continue reading the rest of the buffer to

   202 			//check nothing bad happens towards the end

   203 			found = ETrue;

   204 			}

   205 		//move pointer on to next library

   206 		ptr += Align4(xipLibrary.GetSize());

   207 		}

   208 	test(found);

   209 

   210 	//do cleanup

   211 	buffer.Close();

   212 	}

   213 

   214 //---------------------------------------------

   215 //! @SYMTestCaseID KBase-T-RMDEBUG2-0427

   216 //! @SYMTestType

   217 //! @SYMPREQ PREQ1426

   218 //! @SYMTestCaseDesc Test getting the list of executables

   219 //! @SYMTestActions The list of debuggable executable files should be obtained

   220 //! @SYMTestExpectedResults The client exe should appear in the list

   221 //! @SYMTestPriority High

   222 //! @SYMTestStatus Implemented

   223 //---------------------------------------------

   224 void CRunModeAgent::TestGetExecutablesList()

   225 	{

   226 	test.Next(_L("TestGetExecutablesList\n"));

   227 

   228 	test(ListingSupported(EExecutables, EScopeGlobal));

   229 	test(!ListingSupported(EExecutables, EScopeProcessSpecific));

   230 	test(!ListingSupported(EExecutables, EScopeThreadSpecific));

   231 

   232 	//allocate a very small buffer so the GetList call initially fails

   233 	RBuf8 buffer;

   234 	test(KErrNone == buffer.Create(1));

   235 	TUint32 size = 0;

   236 

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

   238 

   239 	//get the list data

   240 	DoGetList(EExecutables, EScopeGlobal, buffer, size);

   241 

   242 	//get this process' name

   243 	RProcess thisProcess;

   244 	TFileName thisProcessName = thisProcess.FileName();

   245 

   246 	//look through the buffer and check if the target debug thread is there

   247 	TBool found = EFalse;

   248 	TUint8* ptr = (TUint8*)buffer.Ptr();

   249 	const TUint8* ptrEnd = ptr + size;

   250 	while(ptr < ptrEnd)

   251 		{

   252 		TExecutablesListEntry& entry = *(TExecutablesListEntry*)ptr;

   253 		//get name

   254 		TPtr name(&entry.iName[0], entry.iNameLength, entry.iNameLength);

   255 		if( (entry.iIsActivelyDebugged != 0) && (0 == thisProcessName.CompareF(name)) )

   256 			{

   257 			//found this process and asserted it is being actively debugged

   258 			found = ETrue;

   259 			}

   260 		//move pointer on to next entry

   261 		ptr += Align4(entry.GetSize());

   262 		}

   263 	test(found);

   264 

   265 	//clean up

   266 	buffer.Close();

   267 

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

   269 	}

   270 

   271 //---------------------------------------------

   272 //! @SYMTestCaseID KBase-T-RMDEBUG2-0428

   273 //! @SYMTestType

   274 //! @SYMPREQ PREQ1426

   275 //! @SYMTestCaseDesc Test error conditions for the GetList calls

   276 //! @SYMTestActions Multiple calls to test calling GetList with bad arguments

   277 //! @SYMTestExpectedResults All tests should fail with the appropriate error codes

   278 //! @SYMTestPriority High

   279 //! @SYMTestStatus Implemented

   280 //---------------------------------------------

   281 void CRunModeAgent::TestGetListInvalidData()

   282 	{

   283 	test.Next(_L("TestGetListInvalidData\n"));

   284 

   285 	//allocate a buffer, the size should not matter as expecting all calls to fail

   286 	RBuf8 buffer;

   287 	test(KErrNone == buffer.Create(1));

   288 	TUint32 size = 0;

   289 

   290 	//test what happens if we ask for an unsupported list type globally

   291 	test(KErrNotSupported == iServSession.GetList((TListId)1234, buffer, size));

   292 

   293 	//test what happens if we ask for an unsupported list type

   294 	test(KErrNotSupported == iServSession.GetList(RThread().Id(), (TListId)1234, buffer, size));

   295 

   296 	//test what happens if we try to get a non-global libraries list

   297 	test(KErrArgument == iServSession.GetList(RThread().Id(), EXipLibraries, buffer, size));

   298 

   299 	//test what happens if we try to get a non-global executables list

   300 	test(KErrArgument == iServSession.GetList(RThread().Id(), EExecutables, buffer, size));

   301 

   302 	//test what happens if we try to get a non-global process list

   303 	test(KErrArgument == iServSession.GetList(RThread().Id(), EProcesses, buffer, size));

   304 

   305 	//check that using a process id fails

   306 	test(KErrArgument == iServSession.GetList(RProcess().Id(), EProcesses, buffer, size));

   307 

   308 	//check that specifying a non-existant thread id fails

   309 	test(KErrArgument == iServSession.GetList((TThreadId)0x12345678, EThreads, buffer, size));

   310 

   311 	//check that specifying a non-existant process id fails

   312 	test(KErrArgument == iServSession.GetList((TProcessId)0x12345678, EThreads, buffer, size));

   313 

   314 	//check that specifying a non-existant thread id fails

   315 	test(KErrArgument == iServSession.GetList((TThreadId)0x12345678, ECodeSegs, buffer, size));

   316 

   317 	//check that specifying a non-existant process id fails

   318 	test(KErrArgument == iServSession.GetList((TProcessId)0x12345678, ECodeSegs, buffer, size));

   319 

   320 	//cleanup

   321 	buffer.Close();

   322 	}

   323 

   324 //---------------------------------------------

   325 //! @SYMTestCaseID KBase-T-RMDEBUG2-0429

   326 //! @SYMTestType

   327 //! @SYMPREQ PREQ1426

   328 //! @SYMTestCaseDesc Test getting the process list

   329 //! @SYMTestActions Get the process listing

   330 //! @SYMTestExpectedResults The process listing should be successfully obtained and the current process should be present in the list

   331 //! @SYMTestPriority High

   332 //! @SYMTestStatus Implemented

   333 //---------------------------------------------

   334 void CRunModeAgent::TestGetProcessList()

   335 	{

   336 	test.Next(_L("TestGetProcessList\n"));

   337 

   338 	test(ListingSupported(EProcesses, EScopeGlobal));

   339 	test(!ListingSupported(EProcesses, EScopeProcessSpecific));

   340 	test(!ListingSupported(EProcesses, EScopeThreadSpecific));

   341 

   342 	//allocate a very small buffer so the GetList call fails

   343 	RBuf8 buffer;

   344 	test(KErrNone == buffer.Create(1));

   345 	TUint32 size = 0;

   346 

   347 	//get the list data

   348 	DoGetList(EProcesses, EScopeGlobal, buffer, size);

   349 

   350 	//initialise data about the target debug thread to compare the kernel's data against

   351 	RProcess thisProcess;

   352 	TFileName thisProcessName = thisProcess.FileName();

   353 	TUint32 processId = thisProcess.Id().Id();

   354 

   355 	//look through the buffer and check if the target debug thread is there

   356 	TBool found = EFalse;

   357 	TUint8* ptr = (TUint8*)buffer.Ptr();

   358 	const TUint8* ptrEnd = ptr + size;

   359 	while(ptr < ptrEnd)

   360 		{

   361 		TProcessListEntry& entry = *(TProcessListEntry*)ptr;

   362 		if( (RProcess().Id().Id() == entry.iProcessId) &&

   363 			(0 == thisProcessName.CompareF(TPtr(&(entry.iNames[0]), entry.iFileNameLength, entry.iFileNameLength))) &&

   364 		 	(0 == thisProcess.FullName().CompareF(TPtr(&(entry.iNames[0]) + entry.iFileNameLength, entry.iDynamicNameLength, entry.iDynamicNameLength))) &&

   365 			0x4321bbbb /* Magic */ == entry.iUid3)

   366 			{

   367 			//if all match then we've found it

   368 			found = ETrue;

   369 			}

   370 		ptr += Align4(entry.GetSize());

   371 		}

   372 

   373 	//check whether the expected result happened

   374 	test(found);

   375 

   376 	//clean up

   377 	buffer.Close();

   378 	}

   379 

   380 //---------------------------------------------

   381 //! @SYMTestCaseID KBase-T-RMDEBUG2-0430

   382 //! @SYMTestType

   383 //! @SYMPREQ PREQ1426

   384 //! @SYMTestCaseDesc Test getting the thread list

   385 //! @SYMTestActions Get the thread listing globally and for a specified thread or process

   386 //! @SYMTestExpectedResults The thread listings should all be successfully obtained and the current thread should be present in all listings

   387 //! @SYMTestPriority High

   388 //! @SYMTestStatus Implemented

   389 //---------------------------------------------

   390 void CRunModeAgent::TestGetThreadList()

   391 	{

   392 	test.Next(_L("TestGetThreadList\n"));

   393 

   394 	test(ListingSupported(EThreads, EScopeGlobal));

   395 	test(ListingSupported(EThreads, EScopeProcessSpecific));

   396 	test(ListingSupported(EThreads, EScopeThreadSpecific));

   397 

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

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

   400 

   401 	//test getting the global list, ETrue as should find the target debug thread

   402 	DoTestGetThreadList(ETrue, EScopeGlobal);

   403 

   404 	//test getting this thread's thread list, ETrue as should find the target debug thread

   405 	DoTestGetThreadList(ETrue, EScopeThreadSpecific, RThread().Id().Id());

   406 

   407 	//test getting this process's thread list, ETrue as should find the target debug thread

   408 	DoTestGetThreadList(ETrue, EScopeProcessSpecific, RProcess().Id().Id());

   409 

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

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

   412 	}

   413 

   414 void CRunModeAgent::DoTestGetThreadList(const TBool aShouldPass, const TListScope aListScope, const TUint64 aTargetId)

   415 	{

   416 	test.Next(_L("DoTestGetThreadList\n"));

   417 

   418 	//create data to pass

   419 	RBuf8 buffer;

   420 	TUint32 size = 0;

   421 

   422 	//perform the call to get the Code segs

   423 	DoGetList(EThreads, aListScope, buffer, size, aTargetId);

   424 

   425 	//initialise data about the target debug thread to compare the kernel's data against

   426 	TFileName name = iDebugThread.FullName();

   427 	RProcess thisProcess;

   428 	TUint64 processId = thisProcess.Id();

   429 	TUint64 threadId = iDebugThread.Id();

   430 

   431 	//look through the buffer and check if the target debug thread is there

   432 	TBool found = EFalse;

   433 	TUint8* ptr = (TUint8*)buffer.Ptr();

   434 	const TUint8* ptrEnd = ptr + size;

   435 	while(ptr < ptrEnd)

   436 		{

   437 		TThreadListEntry* entry = (TThreadListEntry*)ptr;

   438 		TPtr entryName(&(entry->iName[0]), entry->iNameLength, entry->iNameLength);

   439 		if( (threadId == entry->iThreadId) && (processId == entry->iProcessId) && (0 == name.CompareF(entryName)) )

   440 			{

   441 			test(entry->iSupervisorStackBaseValid);

   442 			test(entry->iSupervisorStackSizeValid);

   443 			//if all match then we've found it

   444 			found = ETrue;

   445 			}

   446 

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

   448 		}

   449 

   450 	//check whether the expected result happened

   451 	test(found == aShouldPass);

   452 

   453 	//clean up

   454 	buffer.Close();

   455 

   456 	}

   457 

   458 //---------------------------------------------

   459 //! @SYMTestCaseID KBase-T-RMDEBUG2-0431

   460 //! @SYMTestType

   461 //! @SYMPREQ PREQ1426

   462 //! @SYMTestCaseDesc Test getting the code segment list

   463 //! @SYMTestActions Get the code segment list global and for a specified thread

   464 //! @SYMTestExpectedResults The listings should be returned successfully

   465 //! @SYMTestPriority High

   466 //! @SYMTestStatus Implemented

   467 //---------------------------------------------

   468 void CRunModeAgent::TestGetCodeSegsList()

   469 	{

   470 	test.Next(_L("TestGetCodeSegsList\n"));

   471 

   472 	test(ListingSupported(ECodeSegs, EScopeGlobal));

   473 	test(ListingSupported(ECodeSegs, EScopeProcessSpecific));

   474 	test(ListingSupported(ECodeSegs, EScopeThreadSpecific));

   475 

   476 	// Cannot perform this test with OEM2 debug token, as the t_rmdebug2 app

   477 	// needs AllFiles, and the OEM2 debug token does not authorise this.

   478 	// It seems reasonable to suppose that it would work anyway

   479 

   480 #ifndef SYMBIAN_OEM2DEBUG

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

   482 

   483  	//test getting the global list, ETrue as should find this process' main codeSeg

   484 	DoTestGetCodeSegsList(ETrue, EScopeGlobal);

   485 

   486 	//test getting this process' codeSegs, ETrue as should find this process' main codeSeg

   487 	DoTestGetCodeSegsList(ETrue, EScopeProcessSpecific, RProcess().Id().Id());

   488 

   489 	//test getting this thread's codeSegs, ETrue as should find this process' main codeSeg

   490 	DoTestGetCodeSegsList(ETrue, EScopeThreadSpecific, RThread().Id().Id());

   491 

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

   493 #endif // SYMBIAN_OEM2DEBUG

   494 

   495 	}

   496 

   497 void CRunModeAgent::DoTestGetCodeSegsList(const TBool aShouldPass, const TListScope aListScope, const TUint64 aTargetId)

   498 	{

   499 	//create data to pass

   500 	RBuf8 buffer;

   501 	TUint32 size = 0;

   502 

   503 	//perform the call to get the Code segs

   504 	DoGetList(ECodeSegs, aListScope, buffer, size, aTargetId);

   505 

   506 	//create memoryInfo to contain info about this process

   507 	RProcess thisProcess;

   508 	TModuleMemoryInfo memoryInfo;

   509 	test(KErrNone == thisProcess.GetMemoryInfo(memoryInfo));

   510 

   511 	// check whether this process came from a file in ROM so we know whether to

   512 	// expect the code seg to be XIP or not.

   513 	RFs fs;

   514 	test(KErrNone == fs.Connect());

   515 	TBool thisFileIsInRom = EFalse;

   516 	if(fs.IsFileInRom(iFileName))

   517 		{

   518 		thisFileIsInRom = ETrue;

   519 		}

   520 

   521 	//look through the buffer to find this process' main code seg

   522 	TBool found = EFalse;

   523 	TUint8* ptr = (TUint8*)buffer.Ptr();

   524 	const TUint8* ptrEnd = ptr + size;

   525 	while(ptr < ptrEnd)

   526 		{

   527 		TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

   528 

   529 		if( (codeSeg->iIsXip == thisFileIsInRom) && (0 == iFileName.CompareF(TPtr(&(codeSeg->iName[0]), codeSeg->iNameLength, codeSeg->iNameLength))) )

   530 			{

   531 			if( (memoryInfo.iCodeBase == codeSeg->iCodeBase) &&

   532 					(memoryInfo.iCodeSize == codeSeg->iCodeSize) &&

   533 					(memoryInfo.iConstDataSize == codeSeg->iConstDataSize) &&

   534 					(memoryInfo.iInitialisedDataBase == codeSeg->iInitialisedDataBase) &&

   535 					(memoryInfo.iInitialisedDataSize == codeSeg->iInitialisedDataSize) &&

   536 					(memoryInfo.iUninitialisedDataSize == codeSeg->iUninitialisedDataSize))

   537 				{

   538 				//all matched so means we've found the codeSeg we're looking for

   539 				found = ETrue;

   540 				}

   541 			}

   542 		ptr += Align4(codeSeg->GetSize());

   543 		}

   544 

   545 	//check whether the result was as expected

   546 	test(found == aShouldPass);

   547 

   548 	// only care about rm_debug.ldd if we have global scope (belongs to the system not this process)

   549 	if (aListScope == EScopeGlobal)

   550 	{

   551 		// Search for rm_debug.ldd library and check its UID3 is correct

   552 		found = EFalse;

   553 

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

   555 

   556 		TFileName rmdebugFilename(KRMDebugDriverFileName);

   557 

   558 		// reset the Ptr

   559 		ptr = (TUint8*)buffer.Ptr();

   560 		ptrEnd = ptr+size;

   561 		while(ptr < ptrEnd)

   562 		{

   563 			TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

   564 

   565 			if( rmdebugFilename.CompareF(TPtr(&(codeSeg->iName[0]), codeSeg->iNameLength, codeSeg->iNameLength)))

   566 				{

   567 				if(codeSeg->iUid3 == 0x101f7157 /* Magic */)

   568 					{

   569 					//all matched so means we've found the codeSeg we're looking for

   570 					found = ETrue;

   571 					}

   572 				}

   573 			ptr += Align4(codeSeg->GetSize());

   574 		}

   575 		test((TUint32)found == (TUint32)ETrue);

   576 	}

   577 

   578 	//clean up

   579 	buffer.Close();

   580 

   581 	}

   582 

   583 void CRunModeAgent::DoGetList(const TListId aListId, const TListScope aListScope, RBuf8& aBuffer, TUint32& aSize, const TUint64 aTargetId)

   584 	{

   585 	//close the buffer in case there's stuff allocated in it

   586 	aBuffer.Close();

   587 	//initialise it to be one byte big, which will guarantee data won't fit in it

   588 	test(KErrNone == aBuffer.Create(1));

   589 	aSize = 0;

   590 

   591 	//should pass this test (assuming we've passed in sensible arguments above...)

   592 	if(EScopeGlobal == aListScope)

   593 		{

   594 		test(KErrTooBig == iServSession.GetList(aListId, aBuffer, aSize));

   595 		}

   596 	else if(EScopeThreadSpecific == aListScope)

   597 		{

   598 		test(KErrTooBig == iServSession.GetList((TThreadId)aTargetId, aListId, aBuffer, aSize));

   599 		}

   600 	else if(EScopeProcessSpecific == aListScope)

   601 		{

   602 		test(KErrTooBig == iServSession.GetList((TProcessId)aTargetId, aListId, aBuffer, aSize));

   603 		}

   604 	else

   605 		{

   606 		// unknown list scope

   607 		test(0);

   608 		}

   609 

   610 	//keep allocating larger buffers, beginning with the aSize returned by the above call,

   611 	//and hopefully we'll eventually make a large enough one

   612 	test(KErrNone == aBuffer.ReAlloc(aSize));

   613 

   614 	for(;;)

   615 		{

   616 		TInt err = KErrNone;

   617 		if(EScopeGlobal == aListScope)

   618 			{

   619 			err = iServSession.GetList(aListId, aBuffer, aSize);

   620 			}

   621 		else if(EScopeThreadSpecific == aListScope)

   622 			{

   623 			err = iServSession.GetList((TThreadId)aTargetId, aListId, aBuffer, aSize);

   624 			}

   625 		else if(EScopeProcessSpecific == aListScope)

   626 			{

   627 			err = iServSession.GetList((TProcessId)aTargetId, aListId, aBuffer, aSize);

   628 			}

   629 		else

   630 			{

   631 			// unknown list scope

   632 			test(0);

   633 			}

   634 		if(err == KErrTooBig)

   635 			{

   636 			//wasn't big enough so double it

   637 			aSize = aSize << 1;

   638 			err = aBuffer.ReAlloc(aSize);

   639 			if(err != KErrNone)

   640 				{

   641 				//print out a message if couldn't allocate memory and quit

   642 				test.Printf(_L("Out ot memory when attempting to allocate %d bytes."), aSize);

   643 				test(KErrNone == err);

   644 				}

   645 

   646 			//fairly arbitrary test, we don't have a max size for these calls.

   647 			//In reality a list would have to have many thousands of elements

   648 			//to break this test which shouldn't really happen

   649 			test(aSize <= 0x4000);

   650 			}

   651 		else

   652 			{

   653 			test(KErrNone == err);

   654 			test(aBuffer.Length() == aSize);

   655 			//break out of the loop if the list has been successfully read in

   656 			break;

   657 			}

   658 		}

   659 	}

   660 

   661 //---------------------------------------------

   662 //! @SYMTestCaseID KBase-T-RMDEBUG2-0432

   663 //! @SYMTestType

   664 //! @SYMPREQ PREQ1426

   665 //! @SYMTestCaseDesc Test reading and writing memory

   666 //! @SYMTestActions Multiple calls to read and write memory, with various sizes and at various locations.

   667 //!	Also test that bad input values cause appropriate errors to be returned.

   668 //! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected

   669 //! @SYMTestPriority High

   670 //! @SYMTestStatus Implemented

   671 //---------------------------------------------

   672 void CRunModeAgent::TestMemoryAccess()

   673 {

   674 	TInt err;

   675 

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

   677 

   678 	//initialise buffer

   679 	gMemoryAccessBytes.SetLength(0);

   680 	for (TInt i=0; i<SYMBIAN_RMDBG_MEMORYSIZE; i++)

   681 		{

   682 		gMemoryAccessBytes.Append(i);

   683 		}

   684 

   685 	TUint32 address = (TUint32)(&gMemoryAccessBytes[0]);

   686 	TUint32 dataSize = SYMBIAN_RMDBG_MEMORYSIZE;

   687 

   688 	//create size for buffer that is rounded up to nearest 4 bytes if not

   689 	//already 4 byte aligned

   690 	TUint32 size = dataSize;

   691 	if(size % 4 != 0)

   692 		{

   693 		size += (4 - (size % 4));

   694 		}

   695 

   696 	RBuf8 dataBlock;

   697 	err = dataBlock.Create(size);

   698 	test(err==KErrNone);

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

   700 

   701 	//suspend the thread prior to memory operations

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

   703 

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

   705 	test(err==KErrNone);

   706 

   707 	for (TInt i=0; i<dataSize; i++)

   708 		{

   709 		test(dataBlock.Ptr()[i] == gMemoryAccessBytes[i]);

   710 		}

   711 

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

   713 

   714 	// Now reset the buffer

   715 	for (TInt i=0; i<dataSize; i++)

   716 		{

   717 		gMemoryAccessBytes[i] = 0;

   718 		}

   719 

   720 	// Write our data into the buffer

   721 	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8);

   722 	test(err==KErrNone);

   723 

   724 	for (TInt i=0; i<dataSize; i++)

   725 		{

   726 		test(dataBlock.Ptr()[i] == gMemoryAccessBytes[i]);

   727 		}

   728 

   729 	//final test that everything's not been going wrong

   730 	test(gMemoryAccessBytes[5] != 0);

   731 

   732 	test.Next(_L("TestMemoryAccess - Invalid arguments\n"));

   733 	test.Printf(_L("This test may emit crash-like information. This is intended.\n"));

   734 

   735 	//test address that is not 32 bit aligned

   736 	err = iServSession.ReadMemory(iThreadID, address + 1, size, dataBlock, EAccess32, EEndLE8);

   737 	test(err == KErrArgument);

   738 

   739 	//test size that is not multiple of 4 bytes

   740 	err = iServSession.WriteMemory(iThreadID, address, size + 2, dataBlock, EAccess32, EEndLE8);

   741 	test(err == KErrArgument);

   742 

   743 	//test size > max block size

   744 	err = iServSession.ReadMemory(iThreadID, address, (1<<15), dataBlock, EAccess32, EEndLE8);

   745 	test(err == KErrArgument);

   746 

   747 	//test access size == 2 bytes

   748 	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess16, EEndLE8);

   749 	test(err == KErrNotSupported);

   750 

   751 	//test access size == 1 byte

   752 	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess8, EEndLE8);

   753 	test(err == KErrNotSupported);

   754 

   755 	//test endianess == EEndBE8

   756 	err = iServSession.ReadMemory(iThreadID, address, size, dataBlock, EAccess32, EEndBE8);

   757 	test(err == KErrNotSupported);

   758 

   759 	//test endianess == EEndBE32

   760 	err = iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndBE32);

   761 	test(err == KErrNotSupported);

   762 

   763 	//test reading off end of memory

   764 	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x00000101, dataBlock, EAccess32, EEndLE8);

   765 	test(err == KErrArgument);

   766 

   767 	//The following three tests check that edge conditions in the range check are handled correctly.

   768 	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x000000FF, dataBlock, EAccess32, EEndLE8);

   769 	test(err == KErrArgument);

   770 

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

   772 	test(err == KErrBadDescriptor);

   773 

   774 	//Third range check test. Check that range check is handled correctly even when base + size wraps to 0.

   775 	err = iServSession.ReadMemory(iThreadID, 0xffffff00, 0x00000100, dataBlock, EAccess32, EEndLE8);

   776 	test(err == KErrBadDescriptor);

   777 	//end of range check tests

   778 

   779 	//test size == 0

   780 	err = iServSession.WriteMemory(iThreadID, address, 0, dataBlock, EAccess32, EEndLE8);

   781 	test(err == KErrArgument);

   782 

   783 	//attempt to write to address outside of process data segments,

   784 	//this address corresponds to the vectors so shouldn't be able to write

   785 	err = iServSession.WriteMemory(iThreadID, 0xffff0000, size, dataBlock, EAccess32, EEndLE8);

   786 	test(err == KErrBadDescriptor);

   787 

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

   789 

   790 	//open a handle to the thread

   791 	RThread debugThread;

   792 	test(debugThread.Open(iThreadID) == KErrNone);

   793 

   794 	//get a reference to the debug process

   795 	RProcess debugProcess;

   796 	test(debugThread.Process(debugProcess) == KErrNone);

   797 

   798 	//get the memory info for the process

   799 	TProcessMemoryInfo info;

   800 	test(debugProcess.GetMemoryInfo(info) == KErrNone);

   801 

   802 	address = info.iCodeBase;

   803 	if(size <= info.iCodeSize)

   804 		{

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

   806 		test(KErrBadDescriptor == iServSession.WriteMemory(iThreadID, address, size, dataBlock, EAccess32, EEndLE8));

   807 		}

   808 

   809 	// Some performance tests now

   810 	TUint32 bytesRead = 0;

   811 

   812 	// Allocate a data buffer

   813 	TUint32* p = (TUint32*)User::Alloc(size);

   814 	test(p != 0);

   815 

   816 	TInt nanokernel_tick_period;

   817 	HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);

   818 	test (nanokernel_tick_period != 0);

   819 

   820 	static const TInt KOneMillion = 1000000;

   821 

   822 	TInt nkTicksPerSecond = KOneMillion/nanokernel_tick_period;

   823 

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

   825 

   826 	while (User::NTickCount() < stopTickCount)

   827 		{

   828 		err = iServSession.ReadMemory(iThreadID, (TUint32)p, size, dataBlock, EAccess32, EEndLE8);

   829 		test(err==KErrNone);

   830 

   831 		// Increase the count of bytes read

   832 		bytesRead += size;

   833 		}

   834 

   835 	test(bytesRead != 0);

   836 	iMemoryReadKbytesPerSecond = bytesRead/1024;

   837 

   838 	// write memory test

   839 	TUint32 bytesWritten = 0;

   840 

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

   842 

   843 	while (User::NTickCount() < stopTickCount)

   844 		{

   845 		err = iServSession.WriteMemory(iThreadID, (TUint32)p, size, dataBlock, EAccess32, EEndLE8);

   846 		test(err==KErrNone);

   847 

   848 		// Increase the count of bytes read

   849 		bytesWritten += size;

   850 		}

   851 

   852 	test (bytesWritten != 0);

   853 	iMemoryWriteKbytesPerSecond = bytesWritten/1024;

   854 

   855 	User::Free(p);

   856 

   857 	//resume the thread

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

   859 

   860 	debugThread.Close();

   861 	dataBlock.Close();

   862 

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

   864 	}

   865 

   866 //---------------------------------------------

   867 //! @SYMTestCaseID KBase-T-RMDEBUG2-0433

   868 //! @SYMTestType

   869 //! @SYMPREQ PREQ1426

   870 //! @SYMTestCaseDesc Test suspending and resuming threads

   871 //! @SYMTestActions Multiple calls to suspend and resume threads with and without attaching to the thread

   872 //! @SYMTestExpectedResults All tests should pass and the target process should be left unaffected

   873 //! @SYMTestPriority High

   874 //! @SYMTestStatus Implemented

   875 //---------------------------------------------

   876 void CRunModeAgent::TestSuspendResume()

   877 	{

   878 	TInt err;

   879 

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

   881 

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

   883 	// Suspend the thread

   884 	err = iServSession.SuspendThread(iThreadID);

   885 	test(err==KErrNone);

   886 	TInt localtestdata;

   887 	localtestdata = TestData;

   888 

   889 	// Wait 3 seconds (suspends this thread) and hopefully resumes the

   890 	// thread we are controlling via the iServSession.SuspendThread request

   891 	User::After(3000000);

   892 

   893 	// Now check data hasnt changed

   894 	test(localtestdata==TestData);

   895 

   896 	// Resume the thread

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

   898 	err = iServSession.ResumeThread(iThreadID);

   899 	test(err==KErrNone);

   900 

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

   902 

   903 	// Wait 3 seconds (suspends this thread) and hopefully resumes the

   904 	// thread we are controlling via the iServSession.SuspendThread request

   905 	User::After(3000000);

   906 

   907 	// Now check that the thread being controlled has resumed and is

   908 	// updating the variable

   909 	test(localtestdata!=TestData);

   910 

   911 	// check that agent can resume thread which it previously detached from

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

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

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

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

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

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

   918 

   919 	// check that agent cannot suspend thread which it previously suspended and then detached from

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

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

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

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

   924 	test(KErrAlreadyExists == iServSession.SuspendThread(iThreadID));

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

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

   927 	}

   928 

   929 //---------------------------------------------

   930 //! @SYMTestCaseID KBase-T-RMDEBUG2-0434

   931 //! @SYMTestType

   932 //! @SYMPREQ PREQ1426

   933 //! @SYMTestCaseDesc Test getting the debug functionality from the driver

   934 //! @SYMTestActions Get the size and contents of the debug functionality block

   935 //! @SYMTestExpectedResults All tests should pass and the expected data should appear in the functionality block

   936 //! @SYMTestPriority High

   937 //! @SYMTestStatus Implemented

   938 //---------------------------------------------

   939 void CRunModeAgent::TestDebugFunctionality()

   940 	{

   941 

   942 	TInt err;

   943 

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

   945 

   946 	TUint32 bufsize = 0;	// Safe default size

   947 

   948 	// Get functionality block size

   949 	err = iServSession.GetDebugFunctionalityBufSize(&bufsize);

   950 	test(err==KErrNone);

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

   952 

   953 	// Ensure we have a finite buffer size

   954 	test(bufsize!=0);

   955 

   956 	// Allocate space for the functionality data

   957 	HBufC8* dftext = HBufC8::NewLC(bufsize);

   958 

   959 	// create an empty TPtr8 refering to dftext

   960 	TPtr8 dftextPtr(dftext->Des());

   961 

   962 	// Get the functionality block

   963 	err = iServSession.GetDebugFunctionality(dftextPtr);

   964 	test(err==KErrNone);

   965 

   966 	// Check that the first entry is correct

   967 	TTagHeader RefHdr =

   968 	{

   969 		ETagHeaderIdCore,ECoreLast,

   970 	};

   971 

   972 	// First header passed from rm_debug.ldd

   973 	TTagHeader* TestHdr = (TTagHeader*)dftextPtr.Ptr();

   974 

   975 	// Check

   976 	test(RefHdr.iTagHdrId==TestHdr->iTagHdrId);

   977 	// this test might fail if the agent is used with a Debug Security Server different from

   978 	// the one it was compiled against. So removing it for now.

   979 	//test(RefHdr.iNumTags==TestHdr->iNumTags);

   980 

   981 	// read a value from the data to check it has come through as expected

   982 	TTagHeader* header = GetTagHdr(dftext->Des(), ETagHeaderIdApiConstants);

   983 	test(header != NULL);

   984 	TTag* tag = GetTag(header, EApiConstantsTEventInfoSize);

   985 	test(tag != NULL);

   986 	// this test might fail if the agent is used with a Debug Security Server different from

   987 	// the one it was compiled against. So removing it for now.

   988 	//test(sizeof(TEventInfo) == tag->iValue);

   989 

   990 	// Remove our temporary buffer

   991 	CleanupStack::PopAndDestroy(dftext);

   992 	}

   993 

   994 //---------------------------------------------

   995 //! @SYMTestCaseID KBase-T-RMDEBUG2-0435

   996 //! @SYMTestType

   997 //! @SYMPREQ PREQ1426

   998 //! @SYMTestCaseDesc Test setting and clearing consecutive breakpoints

   999 //! @SYMTestActions Set and clear consecutive breakpoints of all combinations of breakpoint types

  1000 //! @SYMTestExpectedResults All breakpoints should be set and cleared without error

  1001 //! @SYMTestPriority High

  1002 //! @SYMTestStatus Implemented

  1003 //---------------------------------------------

  1004 void CRunModeAgent::TestConsecutiveBreakPoints()

  1005 	{

  1006 	test.Next(_L("TestConsecutiveBreakPoints\n"));

  1007 

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

  1009 

  1010 	// just a temporary structure for storing info about a breakpoint

  1011 	struct TBreakPoint

  1012 		{

  1013 	public:

  1014 		TBreakPoint()

  1015 			:iId(0),

  1016 			iMode((TArchitectureMode)0),

  1017 			iAddress(0)

  1018 			{}

  1019 		TBreakId iId;

  1020 		TArchitectureMode iMode;

  1021 		TUint32 iAddress;

  1022 		inline TInt Size() { return (EArmMode == iMode) ? 4 : 2; }

  1023 		};

  1024 

  1025 	//an address in the target debug thread

  1026 	TUint32 address = (TUint32)(&TestFunction);

  1027 

  1028 	// there are six orders in which three breakpoints can be set, these are looped

  1029 	// through below to check setting and clearing consecutive breakpoints works

  1030 	TUint8 order[6][3] =

  1031 		{

  1032 			{0,1,2},

  1033 			{0,2,1},

  1034 			{1,0,2},

  1035 			{1,2,0},

  1036 			{2,0,1},

  1037 			{2,1,0}

  1038 		};

  1039 

  1040 	// The following code checks that setting and clearing consecutive breakpoints works correctly:

  1041 	// It checks that setting all combinations of three arm and thumb breakpoints succeeds, and check that the

  1042 	// breakpoints can be set in any order, and then cleared in any order

  1043 

  1044 	// the 3 least significant bits of i control whether each of the three breakpoints should be arm or thumb

  1045 	for(TInt i=0; i<8; i++)

  1046 		{

  1047 		// controls the order in which the breakpoints should be set

  1048 		for(TInt j=0; j<6; j++)

  1049 			{

  1050 			// create the three breakpoints and set their modes

  1051 			TBreakPoint bp[3];

  1052 			bp[0].iMode = (i&1) ? EArmMode : EThumbMode;

  1053 			bp[1].iMode = (i&2) ? EArmMode : EThumbMode;

  1054 			bp[2].iMode = (i&4) ? EArmMode : EThumbMode;

  1055 

  1056 			// set the address of each of the breakpoints

  1057 			bp[0].iAddress = address;

  1058 			if(EArmMode == bp[0].iMode)

  1059 				{ // if an arm breakpoint then must be on a four byte boundary

  1060 				bp[0].iAddress = Align4(bp[0].iAddress);

  1061 				}

  1062 			bp[1].iAddress = bp[0].iAddress + bp[0].Size();

  1063 			if(EArmMode == bp[1].iMode)

  1064 				{ // if an arm breakpoint then must be on a four byte boundary

  1065 				bp[1].iAddress = Align4(bp[1].iAddress);

  1066 				}

  1067 			bp[2].iAddress = bp[1].iAddress + bp[1].Size();

  1068 			if(EArmMode == bp[2].iMode)

  1069 				{ // if an arm breakpoint then must be on a four byte boundary

  1070 				bp[2].iAddress = Align4(bp[2].iAddress);

  1071 				}

  1072 			for(TInt k=0; k<6; k++)

  1073 				{

  1074 				// set the three breakpoints in the order defined by j and then clear them in the order defined by k

  1075 				test(KErrNone==iServSession.SetBreak(bp[order[j][0]].iId, iThreadID, bp[order[j][0]].iAddress, bp[order[j][0]].iMode));

  1076 				test(KErrNone==iServSession.SetBreak(bp[order[j][1]].iId, iThreadID, bp[order[j][1]].iAddress, bp[order[j][1]].iMode));

  1077 				test(KErrNone==iServSession.SetBreak(bp[order[j][2]].iId, iThreadID, bp[order[j][2]].iAddress, bp[order[j][2]].iMode));

  1078 				test(KErrNone==iServSession.ClearBreak(bp[order[k][0]].iId));

  1079 				test(KErrNone==iServSession.ClearBreak(bp[order[k][1]].iId));

  1080 				test(KErrNone==iServSession.ClearBreak(bp[order[k][2]].iId));

  1081 				}

  1082 			}

  1083 		}

  1084 

  1085 	// resume the thread

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

  1087 	}

  1088 

  1089 //---------------------------------------------

  1090 //! @SYMTestCaseID KBase-T-RMDEBUG2-0436

  1091 //! @SYMTestType

  1092 //! @SYMPREQ PREQ1426

  1093 //! @SYMTestCaseDesc Test breakpoint functionality

  1094 //! @SYMTestActions Multiple calls to set and clear breakpoints. Checking bad input produces appropriate errors.

  1095 //! @SYMTestExpectedResults All tests should pass and the target debug thread should be left unaffected

  1096 //! @SYMTestPriority High

  1097 //! @SYMTestStatus Implemented

  1098 //---------------------------------------------

  1099 void CRunModeAgent::TestBreakPoints()

  1100 	{

  1101 	TInt err;

  1102 

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

  1104 

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

  1106 

  1107 	TestConsecutiveBreakPoints();

  1108 

  1109 	//an address in the target debug thread

  1110 	TUint32 address = (TUint32)(&TestFunction);

  1111 

  1112 	/*

  1113 	 * Ensure that breakpoint operations don't

  1114 	 * affect memory read/write by checking that reads/writes

  1115 	 * in locations containing breakpoints don't change behaviour

  1116 	 * because of the breakpoints.

  1117 	 */

  1118 

  1119 	TUint32 size = SYMBIAN_RMDBG_MEMORYSIZE;

  1120 

  1121 	RBuf8 originalDataBlock;

  1122 	err = originalDataBlock.Create(size);

  1123 	test(err==KErrNone);

  1124 

  1125 	//suspend the thread

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

  1127 

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

  1129 	test(err==KErrNone);

  1130 

  1131 	// Test data block for comparison

  1132 	RBuf8 testDataBlock;

  1133 	err = testDataBlock.Create(size);

  1134 	test(err==KErrNone);