1 // Copyright (c) 2006-2010 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 <e32cmn.h>

    24 #include <e32cmn_private.h>

    25 #include <f32dbg.h>

    26 #include <f32file.h>

    27 #include <hal.h>

    28 #include <u32hal.h>

    29 #include <e32property.h>

    30 

    31 #include "t_rmdebug_dll.h"

    32 

    33 #include <rm_debug_api.h>

    34 #include "d_rmdebugthread2.h"

    35 #include "t_rmdebug2.h"

    36 #include "t_rmdebug_app.h"

    37 

    38 #ifdef __MARM_ARMV4__

    39 #include "d_rmdebug_step_test_armv4.h"

    40 #endif

    41 

    42 #ifdef __MARM_ARMV5__

    43 #include "d_rmdebug_step_test.h"

    44 #include "d_rmdebug_bkpt_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 TBool gUseDelay;

    87 

    88 CRunModeAgent::CRunModeAgent()

    89 //

    90 // CRunModeAgent constructor

    91 //

    92 	{

    93 	FillArray();

    94 	RProcess thisProcess;

    95 	iFileName = thisProcess.FileName();

    96 	thisProcess.Close();

    97 	}

    98 

    99 CRunModeAgent* CRunModeAgent::NewL()

   100 //

   101 // CRunModeAgent::NewL

   102 //

   103 	{

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

   105 

   106   	self->ConstructL();

   107 

   108 	return self;

   109 	}

   110 

   111 CRunModeAgent::~CRunModeAgent()

   112 //

   113 // CRunModeAgent destructor

   114 //

   115 	{

   116 	User::FreeLogicalDevice(KDebugDriverFileName);

   117 	iServSession.Close();

   118 	iDebugThread.Close();

   119 	}

   120 

   121 void CRunModeAgent::ConstructL()

   122 //

   123 // CRunModeAgent::ConstructL

   124 //

   125 	{

   126 	// nothing to do here

   127 	}

   128 

   129 void CRunModeAgent::SetupAndAttachToDSS()

   130 //

   131 // CRunModeAgent::SetupAndAttachToDSS

   132 //

   133 	{

   134 	TInt err = StartDebugThread(iDebugThread, KDebugThreadName);

   135 

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

   137 	iThreadID = iDebugThread.Id();

   138 

   139 	if (err != KErrNone)

   140 		{

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

   142 		}

   143 

   144 	err = iServSession.Connect(securityServerVersion);

   145 	if (err != KErrNone)

   146 		{

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

   148 		}

   149 	}

   150 

   151 CRunModeAgent *RunModeAgent;

   152 

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

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

   155 	{

   156 	TTag tag = GetTag(ETagHeaderList, aListId);

   157 

   158 	return (tag.iValue) & aListScope;

   159 	}

   160 

   161 //---------------------------------------------

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

   163 //! @SYMTestType

   164 //! @SYMPREQ PREQ1426

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

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

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

   168 //! @SYMTestPriority High

   169 //! @SYMTestStatus Implemented

   170 //---------------------------------------------

   171 void CRunModeAgent::TestGetXipLibrariesList()

   172 	{

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

   174 

   175 	test(ListingSupported(EXipLibraries, EScopeGlobal));

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

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

   178 

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

   180 	RBuf8 buffer;

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

   182 	TUint32 size = 0;

   183 

   184 	//get the list data

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

   186 

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

   188 	//which should be in the rom

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

   190 

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

   192 	TBool found = EFalse;

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

   194 	const TUint8* ptrEnd = ptr + size;

   195 	while(ptr < ptrEnd)

   196 		{

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

   198 

   199 		//get the name of the library

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

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

   202 			{

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

   204 			//check nothing bad happens towards the end

   205 			found = ETrue;

   206 			}

   207 		//move pointer on to next library

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

   209 		}

   210 	test(found);

   211 

   212 	//do cleanup

   213 	buffer.Close();

   214 	}

   215 

   216 //---------------------------------------------

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

   218 //! @SYMTestType

   219 //! @SYMPREQ PREQ1426

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

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

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

   223 //! @SYMTestPriority High

   224 //! @SYMTestStatus Implemented

   225 //---------------------------------------------

   226 void CRunModeAgent::TestGetExecutablesList()

   227 	{

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

   229 

   230 	test(ListingSupported(EExecutables, EScopeGlobal));

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

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

   233 

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

   235 	RBuf8 buffer;

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

   237 	TUint32 size = 0;

   238 

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

   240 

   241 	//get the list data

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

   243 

   244 	//get this process' name

   245 	RProcess thisProcess;

   246 	TFileName thisProcessName = thisProcess.FileName();

   247 

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

   249 	TBool found = EFalse;

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

   251 	const TUint8* ptrEnd = ptr + size;

   252 	while(ptr < ptrEnd)

   253 		{

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

   255 		//get name

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

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

   258 			{

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

   260 			found = ETrue;

   261 			}

   262 		//move pointer on to next entry

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

   264 		}

   265 	test(found);

   266 

   267 	//clean up

   268 	buffer.Close();

   269 

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

   271 	}

   272 

   273 //---------------------------------------------

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

   275 //! @SYMTestType

   276 //! @SYMPREQ PREQ1426

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

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

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

   280 //! @SYMTestPriority High

   281 //! @SYMTestStatus Implemented

   282 //---------------------------------------------

   283 void CRunModeAgent::TestGetListInvalidData()

   284 	{

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

   286 

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

   288 	RBuf8 buffer;

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

   290 	TUint32 size = 0;

   291 

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

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

   294 

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

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

   297 

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

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

   300 

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

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

   303 

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

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

   306 

   307 	//check that using a process id fails

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

   309 

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

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

   312 

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

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

   315 

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

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

   318 

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

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

   321 

   322 	//cleanup

   323 	buffer.Close();

   324 	}

   325 

   326 //---------------------------------------------

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

   328 //! @SYMTestType

   329 //! @SYMPREQ PREQ1426

   330 //! @SYMTestCaseDesc Test getting the process list

   331 //! @SYMTestActions Get the process listing

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

   333 //! @SYMTestPriority High

   334 //! @SYMTestStatus Implemented

   335 //---------------------------------------------

   336 void CRunModeAgent::TestGetProcessList()

   337 	{

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

   339 

   340 	test(ListingSupported(EProcesses, EScopeGlobal));

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

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

   343 

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

   345 	RBuf8 buffer;

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

   347 	TUint32 size = 0;

   348 

   349 	//get the list data

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

   351 

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

   353 	RProcess thisProcess;

   354 	TFileName thisProcessName = thisProcess.FileName();

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

   356 

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

   358 	TBool found = EFalse;

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

   360 	const TUint8* ptrEnd = ptr + size;

   361 	while(ptr < ptrEnd)

   362 		{

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

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

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

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

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

   368 			{

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

   370 			found = ETrue;

   371 			}

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

   373 		}

   374 

   375 	//check whether the expected result happened

   376 	test(found);

   377 

   378 	//clean up

   379 	buffer.Close();

   380 	}

   381 

   382 //---------------------------------------------

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

   384 //! @SYMTestType

   385 //! @SYMPREQ PREQ1426

   386 //! @SYMTestCaseDesc Test getting the thread list

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

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

   389 //! @SYMTestPriority High

   390 //! @SYMTestStatus Implemented

   391 //---------------------------------------------

   392 void CRunModeAgent::TestGetThreadList()

   393 	{

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

   395 

   396 	test(ListingSupported(EThreads, EScopeGlobal));

   397 	test(ListingSupported(EThreads, EScopeProcessSpecific));

   398 	test(ListingSupported(EThreads, EScopeThreadSpecific));

   399 

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

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

   402 

   403 	TBool found = EFalse;

   404 	

   405 	/* We need these loops because on some system the kernel run mode debugger does not 

   406 	 immediately present the thread in the thread list. 

   407 	 */

   408 	

   409 	for(TInt retryCount = 0; retryCount < 10 && !found; retryCount++ )

   410 		{

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

   412 		User::After(50000);

   413 		found = DoTestGetThreadList(ETrue, EScopeProcessSpecific, RProcess().Id().Id());

   414 		}

   415 	test( found );

   416 	found = EFalse;

   417 

   418 	for(TInt retryCount = 0; retryCount < 10 && !found; retryCount++ )

   419 		{

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

   421 		User::After(50000);

   422 		found = DoTestGetThreadList(ETrue, EScopeGlobal);

   423 		}

   424 	test( found );

   425 

   426 	found = EFalse;

   427 	for(TInt retryCount = 0; retryCount < 10 && !found; retryCount++ )

   428 		{

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

   430 		User::After(50000);

   431 		found = DoTestGetThreadList(ETrue, EScopeThreadSpecific, RThread().Id().Id());

   432 		}

   433 	test( found );

   434 

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

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

   437 	}

   438 			

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

   440 	{

   441 	//create data to pass

   442 	RBuf8 buffer;

   443 	TUint32 size = 0;

   444 

   445 	//perform the call to get the thread list

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

   447 

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

   449 	TFileName name = iDebugThread.FullName();

   450 	RProcess thisProcess;

   451 	TUint64 processId = thisProcess.Id();

   452 	TUint64 threadId = iDebugThread.Id();

   453 

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

   455 	TBool found = EFalse;

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

   457 	const TUint8* ptrEnd = ptr + size;

   458 	while(ptr < ptrEnd)

   459 		{

   460 		TThreadListEntry* entry = (TThreadListEntry*)ptr;

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

   462 

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

   464 			{

   465 			test(entry->iSupervisorStackBaseValid);

   466 			test(entry->iSupervisorStackSizeValid);

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

   468 			found = ETrue;

   469 			break;

   470 			}

   471 

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

   473 		}

   474 

   475 	//clean up

   476 	buffer.Close();

   477 	return found;

   478 

   479 	}

   480 

   481 //---------------------------------------------

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

   483 //! @SYMTestType

   484 //! @SYMPREQ PREQ1426

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

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

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

   488 //! @SYMTestPriority High

   489 //! @SYMTestStatus Implemented

   490 //---------------------------------------------

   491 void CRunModeAgent::TestGetCodeSegsList()

   492 	{

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

   494 

   495 	test(ListingSupported(ECodeSegs, EScopeGlobal));

   496 	test(ListingSupported(ECodeSegs, EScopeProcessSpecific));

   497 	test(ListingSupported(ECodeSegs, EScopeThreadSpecific));

   498 

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

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

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

   502 

   503 #ifndef SYMBIAN_OEM2DEBUG

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

   505 

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

   507 	DoTestGetCodeSegsList(ETrue, EScopeGlobal);

   508 

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

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

   511 

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

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

   514 

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

   516 #endif // SYMBIAN_OEM2DEBUG

   517 

   518 	}

   519 

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

   521 	{

   522 	//create data to pass

   523 	RBuf8 buffer;

   524 	TUint32 size = 0;

   525 

   526 	//perform the call to get the Code segs

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

   528 

   529 	//create memoryInfo to contain info about this process

   530 	RProcess thisProcess;

   531 	TModuleMemoryInfo memoryInfo;

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

   533 

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

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

   536 	RFs fs;

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

   538 	TBool thisFileIsInRom = EFalse;

   539 	if(fs.IsFileInRom(iFileName))

   540 		{

   541 		thisFileIsInRom = ETrue;

   542 		}

   543 

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

   545 	TBool found = EFalse;

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

   547 	const TUint8* ptrEnd = ptr + size;

   548 	while(ptr < ptrEnd)

   549 		{

   550 		TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

   551 

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

   553 			{

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

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

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

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

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

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

   560 				{

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

   562 				found = ETrue;

   563 				}

   564 			}

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

   566 		}

   567 

   568 	//check whether the result was as expected

   569 	test(found == aShouldPass);

   570 

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

   572 	if (aListScope == EScopeGlobal)

   573 	{

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

   575 		found = EFalse;

   576 

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

   578 

   579 		TFileName rmdebugFilename(KRMDebugDriverFileName);

   580 

   581 		// reset the Ptr

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

   583 		ptrEnd = ptr+size;

   584 		while(ptr < ptrEnd)

   585 		{

   586 			TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;

   587 

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

   589 				{

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

   591 					{

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

   593 					found = ETrue;

   594 					}

   595 				}

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

   597 		}

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

   599 	}

   600 

   601 	//clean up

   602 	buffer.Close();

   603 

   604 	}

   605 

   606 

   607 /**

   608  * Get a list from the run mode debug system. Most list calls will initially return KErrTooBig, 

   609  * since the initial size of the buffer is 0. However it is sometimes valid for a list to be empty

   610  * given its filtering and scope. These calls should return KErrNone.

   611  */

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

   613 	{

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

   615 	aBuffer.Close();

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

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

   618 	aSize = 0;

   619 	

   620 	TInt ret = KErrNone;

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

   622 	if(EScopeGlobal == aListScope)

   623 		{

   624 		ret = iServSession.GetList(aListId, aBuffer, aSize);

   625 		}

   626 	else if(EScopeThreadSpecific == aListScope)

   627 		{

   628 		ret = iServSession.GetList((TThreadId)aTargetId, aListId, aBuffer, aSize);

   629 		}

   630 	else if(EScopeProcessSpecific == aListScope)

   631 		{

   632 		ret = iServSession.GetList((TProcessId)aTargetId, aListId, aBuffer, aSize);

   633 		}

   634 	else

   635 		{

   636 		// unknown list scope

   637 		test(0);

   638 		}

   639 

   640 	if( KErrNone == ret )

   641 		{

   642 		/* In the case that there is no data, just return and let the caller check

   643 		the buffer. It is valid for a caller to not expect any data to be returned.

   644 		*/

   645 		return;

   646 		}

   647 	

   648 	// The only other allowed return is KErrTooBig

   649 	test( ret == KErrTooBig );

   650 

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

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

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

   654 

   655 	for(;;)

   656 		{

   657 		TInt err = KErrNone;

   658 		if(EScopeGlobal == aListScope)

   659 			{

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

   661 			}

   662 		else if(EScopeThreadSpecific == aListScope)

   663 			{

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

   665 			}

   666 		else if(EScopeProcessSpecific == aListScope)

   667 			{

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

   669 			}

   670 		else

   671 			{

   672 			// unknown list scope

   673 			test(0);

   674 			}

   675 		if(err == KErrTooBig)

   676 			{

   677 			//wasn't big enough so double it

   678 			aSize = aSize << 1;

   679 			err = aBuffer.ReAlloc(aSize);

   680 			if(err != KErrNone)

   681 				{

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

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

   684 				test(KErrNone == err);

   685 				}

   686 

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

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

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

   690 			test(aSize <= 0x4000);

   691 			}

   692 		else

   693 			{

   694 			test(KErrNone == err);

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

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

   697 			break;

   698 			}

   699 		}

   700 	}

   701 

   702 //---------------------------------------------

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

   704 //! @SYMTestType

   705 //! @SYMPREQ PREQ1426

   706 //! @SYMTestCaseDesc Test reading and writing memory

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

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

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

   710 //! @SYMTestPriority High

   711 //! @SYMTestStatus Implemented

   712 //---------------------------------------------

   713 void CRunModeAgent::TestMemoryAccess()

   714 {

   715 	TInt err;

   716 

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

   718 

   719 	//initialise buffer

   720 	gMemoryAccessBytes.SetLength(0);

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

   722 		{

   723 		gMemoryAccessBytes.Append(i);

   724 		}

   725 

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

   727 	TUint32 dataSize = SYMBIAN_RMDBG_MEMORYSIZE;

   728 

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

   730 	//already 4 byte aligned

   731 	TUint32 size = dataSize;

   732 	if(size % 4 != 0)

   733 		{

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

   735 		}

   736 

   737 	RBuf8 dataBlock;

   738 	err = dataBlock.Create(size);

   739 	test(err==KErrNone);

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

   741 

   742 	//suspend the thread prior to memory operations

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

   744 

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

   746 	test(err==KErrNone);

   747 

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

   749 		{

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

   751 		}

   752 

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

   754 

   755 	// Now reset the buffer

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

   757 		{

   758 		gMemoryAccessBytes[i] = 0;

   759 		}

   760 

   761 	// Write our data into the buffer

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

   763 	test(err==KErrNone);

   764 

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

   766 		{

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

   768 		}

   769 

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

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

   772 

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

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

   775 

   776 	//test address that is not 32 bit aligned

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

   778 	test(err == KErrArgument);

   779 

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

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

   782 	test(err == KErrArgument);

   783 

   784 	//test size > max block size

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

   786 	test(err == KErrArgument);

   787 

   788 	//test access size == 2 bytes

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

   790 	test(err == KErrNotSupported);

   791 

   792 	//test access size == 1 byte

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

   794 	test(err == KErrNotSupported);

   795 

   796 	//test endianess == EEndBE8

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

   798 	test(err == KErrNotSupported);

   799 

   800 	//test endianess == EEndBE32

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

   802 	test(err == KErrNotSupported);

   803 

   804 	//test reading off end of memory

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

   806 	test(err == KErrArgument);

   807 

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

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

   810 	test(err == KErrArgument);

   811 

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

   813 	test(err == KErrBadDescriptor);

   814 

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

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

   817 	test(err == KErrBadDescriptor);

   818 	//end of range check tests

   819 

   820 	//test size == 0

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

   822 	test(err == KErrArgument);

   823 

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

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

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

   827 	test(err == KErrBadDescriptor);

   828 

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

   830 

   831 	//open a handle to the thread

   832 	RThread debugThread;

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

   834 

   835 	//get a reference to the debug process

   836 	RProcess debugProcess;

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

   838 

   839 	//get the memory info for the process

   840 	TProcessMemoryInfo info;

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

   842 

   843 	address = info.iCodeBase;

   844 	if(size <= info.iCodeSize)

   845 		{

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

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

   848 		}

   849 

   850 	// Some performance tests now

   851 	TUint32 bytesRead = 0;

   852 

   853 	// Allocate a data buffer

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

   855 	test(p != 0);

   856 

   857 	TInt nanokernel_tick_period;

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

   859 	test (nanokernel_tick_period != 0);

   860 

   861 	static const TInt KOneMillion = 1000000;

   862 

   863 	TInt nkTicksPerSecond = KOneMillion/nanokernel_tick_period;

   864 

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

   866 

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

   868 		{

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

   870 		test(err==KErrNone);

   871 

   872 		// Increase the count of bytes read

   873 		bytesRead += size;

   874 		}

   875 

   876 	test(bytesRead != 0);

   877 	iMemoryReadKbytesPerSecond = bytesRead/1024;

   878 

   879 	// write memory test

   880 	TUint32 bytesWritten = 0;

   881 

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

   883 

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

   885 		{

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

   887 		test(err==KErrNone);

   888 

   889 		// Increase the count of bytes read

   890 		bytesWritten += size;

   891 		}

   892 

   893 	test (bytesWritten != 0);

   894 	iMemoryWriteKbytesPerSecond = bytesWritten/1024;

   895 

   896 	User::Free(p);

   897 

   898 	//resume the thread

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

   900 

   901 	debugThread.Close();

   902 	dataBlock.Close();

   903 

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

   905 	}

   906 

   907 //---------------------------------------------

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

   909 //! @SYMTestType

   910 //! @SYMPREQ PREQ1426

   911 //! @SYMTestCaseDesc Test suspending and resuming threads

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

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

   914 //! @SYMTestPriority High

   915 //! @SYMTestStatus Implemented

   916 //---------------------------------------------

   917 void CRunModeAgent::TestSuspendResume()

   918 	{

   919 	TInt err;

   920 

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

   922 

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

   924 	// Suspend the thread

   925 	err = iServSession.SuspendThread(iThreadID);

   926 	test(err==KErrNone);

   927 	TInt localtestdata;

   928 	localtestdata = TestData;

   929 

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

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

   932 	User::After(3000000);

   933 

   934 	// Now check data hasnt changed

   935 	test(localtestdata==TestData);

   936 

   937 	// Resume the thread

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

   939 	err = iServSession.ResumeThread(iThreadID);

   940 	test(err==KErrNone);

   941 

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

   943 

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

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

   946 	User::After(3000000);

   947 

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

   949 	// updating the variable

   950 	test(localtestdata!=TestData);

   951 

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

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

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

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

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

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

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

   959 

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

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

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

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

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

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

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

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

   968 	}

   969 

   970 //---------------------------------------------

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

   972 //! @SYMTestType

   973 //! @SYMPREQ PREQ1426

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

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

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

   977 //! @SYMTestPriority High

   978 //! @SYMTestStatus Implemented

   979 //---------------------------------------------

   980 void CRunModeAgent::TestDebugFunctionality()

   981 	{

   982 

   983 	TInt err;

   984 

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

   986 

   987 	TUint32 bufsize = 0;	// Safe default size

   988 

   989 	// Get functionality block size

   990 	err = iServSession.GetDebugFunctionalityBufSize(&bufsize);

   991 	test(err==KErrNone);

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

   993 

   994 	// Ensure we have a finite buffer size

   995 	test(bufsize!=0);

   996 

   997 	// Allocate space for the functionality data

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

   999 

  1000 	// create an empty TPtr8 refering to dftext

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

  1002 

  1003 	// Get the functionality block

  1004 	err = iServSession.GetDebugFunctionality(dftextPtr);

  1005 	test(err==KErrNone);

  1006 

  1007 	// Check that the first entry is correct

  1008 	TTagHeader RefHdr =

  1009 	{

  1010 		ETagHeaderIdCore,ECoreLast,

  1011 	};

  1012 

  1013 	// First header passed from rm_debug.ldd

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

  1015 

  1016 	// Check

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

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

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

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

  1021 

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

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

  1024 	test(header != NULL);

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

  1026 	test(tag != NULL);

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

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

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

  1030 

  1031 	// Remove our temporary buffer

  1032 	CleanupStack::PopAndDestroy(dftext);

  1033 	}

  1034 

  1035 //---------------------------------------------

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

  1037 //! @SYMTestType

  1038 //! @SYMPREQ PREQ1426

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

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

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

  1042 //! @SYMTestPriority High

  1043 //! @SYMTestStatus Implemented

  1044 //---------------------------------------------

  1045 void CRunModeAgent::TestConsecutiveBreakPoints()

  1046 	{

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

  1048 

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

  1050 

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

  1052 	struct TBreakPoint

  1053 		{

  1054 	public:

  1055 		TBreakPoint()

  1056 			:iId(0),

  1057 			iMode((TArchitectureMode)0),

  1058 			iAddress(0)

  1059 			{}

  1060 		TBreakId iId;

  1061 		TArchitectureMode iMode;

  1062 		TUint32 iAddress;

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

  1064 		};

  1065 

  1066 	//an address in the target debug thread

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

  1068 

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

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

  1071 	TUint8 order[6][3] =

  1072 		{

  1073 			{0,1,2},

  1074 			{0,2,1},

  1075 			{1,0,2},

  1076 			{1,2,0},

  1077 			{2,0,1},

  1078 			{2,1,0}

  1079 		};

  1080 

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

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

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

  1084 

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

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

  1087 		{

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

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

  1090 			{

  1091 			// create the three breakpoints and set their modes

  1092 			TBreakPoint bp[3];

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

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

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

  1096 

  1097 			// set the address of each of the breakpoints

  1098 			bp[0].iAddress = address;

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

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

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

  1102 				}

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

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

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

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

  1107 				}

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

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

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

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

  1112 				}

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

  1114 				{

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

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

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

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

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

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

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

  1122 				}

  1123 			}

  1124 		}

  1125 

  1126 	// resume the thread

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

  1128 	}

  1129 

  1130 //---------------------------------------------

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

  1132 //! @SYMTestType

  1133 //! @SYMPREQ PREQ1426

  1134 //! @SYMTestCaseDesc Test breakpoint functionality