diff -r 000000000000 -r a41df078684a kerneltest/e32test/rm_debug/d_rmdebugthread2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/rm_debug/d_rmdebugthread2.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,205 @@ +// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Implements a debug thread for testing. +// +// + +#include +#include +#include +#include +#include "d_rmdebugthread2.h" + +#include "d_rmdebug_step_test.h" +#include "d_demand_paging.h" + +EXPORT_C TBuf8 gMemoryAccessBytes; +IMPORT_C extern void RMDebug_BranchTst1(); +IMPORT_C extern TInt RMDebugDemandPagingTest(); + +EXPORT_C TInt TestData; +EXPORT_C TTestFunction FunctionChooser; + +const TInt NUMBER_TRACE_CALLS = 200; + +EXPORT_C TInt TestFunction() + { + //set TestData to an arbitrary value which we check for in t_rmdebug + TestData = 0xffeeddcc; + + User::After(3000000); // pause three seconds. + + return 0; + } + +/** + Wrapper around RMDebugDemandPagingTest, need to pause for a short time to + allow time in t_rmdebug.cpp to issue a User::WaitForRequest to catch the break point + */ +EXPORT_C void TestPagedCode() + { + User::After(100000); + + // call the function in paged code + RMDebugDemandPagingTest(); + } + +EXPORT_C void TestMultipleTraceCalls() + { + //arbitrary function to set a BP on + RMDebug_BranchTst1(); + + for(TInt cnt = NUMBER_TRACE_CALLS; cnt>0; cnt--) + { + RDebug::Printf("Trace event"); + } + + //another arbitrary function to set a BP on + RMDebug_StepTest_Non_PC_Modifying(); + } + +CDebugServThread::CDebugServThread() +// +// Empty constructor +// + { + } + +GLDEF_C TInt CDebugServThread::ThreadFunction(TAny*) +// +// Generic thread function for testing +// + { + // set FunctionChooser to run the default function + FunctionChooser = EDefaultFunction; + + CTrapCleanup* cleanup=CTrapCleanup::New(); + if (cleanup == NULL) + { + User::Leave(KErrNoMemory); + } + + RThread::Rendezvous(KErrNone); + + TestData = 1; + + while(TestData != 0xFFFFFFFF) + { + switch(FunctionChooser) + { + case EDemandPagingFunction: + TestPagedCode(); + break; + case EDefaultFunction: + // the default function is the stepping test functions + case EStepFunction: + { + RMDebug_BranchTst1(); + + // Single stepping test support code + + // ARM tests + RMDebug_StepTest_Non_PC_Modifying(); + + RMDebug_StepTest_Branch(); + + RMDebug_StepTest_Branch_And_Link(); + + RMDebug_StepTest_MOV_PC(); + + RMDebug_StepTest_LDR_PC(); + +// thumb/interworking tests not supported on armv4 +#ifdef __MARM_ARMV5__ + + // Thumb tests + RMDebug_StepTest_Thumb_Non_PC_Modifying(); + + RMDebug_StepTest_Thumb_Branch(); + + RMDebug_StepTest_Thumb_Branch_And_Link(); + + RMDebug_StepTest_Thumb_Back_Branch_And_Link(); + + // ARM <-> Thumb interworking tests + RMDebug_StepTest_Interwork(); + + RMDebug_StepTest_Thumb_AddPC(); + +#endif // __MARM_ARMV5__ + + // Single-stepping performance + RMDebug_StepTest_Count(); + + // multiple step test + RMDebug_StepTest_ARM_Step_Multiple(); + + TestData++; + + // Wait 50mSecs. // (suspends this thread) + User::After(50000); + + break; + } + case EMultipleTraceCalls: + TestMultipleTraceCalls(); + break; + default: + //do nothing + break; + } + } + + delete cleanup; + + return (KErrNone); + } + +EXPORT_C TInt StartDebugThread(RThread& aDebugThread, const TDesC& aDebugThreadName) +// +// Starts a test thread +// +{ + TInt res=KErrNone; + + // Create the thread + res = aDebugThread.Create( aDebugThreadName, + CDebugServThread::ThreadFunction, + KDefaultStackSize, + KDebugThreadDefaultHeapSize, + KDebugThreadDefaultHeapSize, + NULL + ); + + // Check that the creation worked + if (res == KErrNone) + { + TRequestStatus rendezvousStatus; + + aDebugThread.SetPriority(EPriorityNormal); + // Make a request for a rendezvous + aDebugThread.Rendezvous(rendezvousStatus); + // Set the thread as ready for execution + aDebugThread.Resume(); + // Wait for the resumption + User::WaitForRequest(rendezvousStatus); + } + else + { + // Close the handle. + aDebugThread.Close(); + } + + return res; + }