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

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

//

//

#include <e32base.h>

#include <e32base_private.h>

#include <e32cons.h>

#include <e32test.h>

#include <e32ldr.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <f32dbg.h>

#include <f32file.h>

#include <hal.h>

#include <u32hal.h>

#include <e32property.h>

#include "t_rmdebug_dll.h"

#include <rm_debug_api.h>

#include "d_rmdebugthread2.h"

#include "t_rmdebug2.h"

#include "t_rmdebug_app.h"

#ifdef __MARM_ARMV4__

#include "d_rmdebug_step_test_armv4.h"

#endif

#ifdef __MARM_ARMV5__

#include "d_rmdebug_step_test.h"

#endif

#include "d_demand_paging.h"

#ifdef KERNEL_OOM_TESTING

	#ifdef USER_OOM_TESTING

		#error "Cannot define both KERNEL_OOM_TESTING and USER_OOM_TESTING"

	#endif

#endif

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

using namespace Debug;

const TVersion securityServerVersion(0,1,1);

const TVersion testVersion(2,1,0);

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

IMPORT_D extern TInt TestData;

IMPORT_D extern TTestFunction FunctionChooser;

IMPORT_D extern TBuf8<SYMBIAN_RMDBG_MEMORYSIZE> gMemoryAccessBytes;

IMPORT_C TInt TestFunction();

IMPORT_C void TestPagedCode();

IMPORT_C extern TInt RMDebugDemandPagingTest();

// Device driver name

_LIT(KDebugDriverFileName,"rm_debug.ldd");

#ifdef SYMBIAN_STANDARDDEBUG

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

#endif

#ifdef SYMBIAN_OEMDEBUG

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

#endif

#ifdef SYMBIAN_OEM2DEBUG

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

#endif

CRunModeAgent::CRunModeAgent()

//

// CRunModeAgent constructor

//

	{

	FillArray();

	RProcess thisProcess;

	iFileName = thisProcess.FileName();

	thisProcess.Close();

	}

CRunModeAgent* CRunModeAgent::NewL()

//

// CRunModeAgent::NewL

//

	{

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

  	self->ConstructL();

	return self;

	}

CRunModeAgent::~CRunModeAgent()

//

// CRunModeAgent destructor

//

	{

	User::FreeLogicalDevice(KDebugDriverFileName);

	iServSession.Close();

	iDebugThread.Close();

	}

void CRunModeAgent::ConstructL()

//

// CRunModeAgent::ConstructL

//

	{

	// nothing to do here

	}

void CRunModeAgent::SetupAndAttachToDSS()

//

// CRunModeAgent::SetupAndAttachToDSS

//

	{

	TInt err = StartDebugThread(iDebugThread, KDebugThreadName);

	// get the thread id for use in the tests

	iThreadID = iDebugThread.Id();

	if (err != KErrNone)

		{

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

		}

	err = iServSession.Connect(securityServerVersion);

	if (err != KErrNone)

		{

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

		}

	}

CRunModeAgent *RunModeAgent;

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

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

	{

	TTag tag = GetTag(ETagHeaderList, aListId);

	return (tag.iValue) & aListScope;

	}

//---------------------------------------------

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

//! @SYMTestType

//! @SYMPREQ PREQ1426

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

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

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

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

//---------------------------------------------

void CRunModeAgent::TestGetXipLibrariesList()

	{

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

	test(ListingSupported(EXipLibraries, EScopeGlobal));

	test(!ListingSupported(EXipLibraries, EScopeProcessSpecific));

	test(!ListingSupported(EXipLibraries, EScopeThreadSpecific));

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

	RBuf8 buffer;

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

	TUint32 size = 0;

	//get the list data

	DoGetList(EXipLibraries, EScopeGlobal, buffer, size);

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

	//which should be in the rom

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

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

	TBool found = EFalse;

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

	const TUint8* ptrEnd = ptr + size;

	while(ptr < ptrEnd)

		{

		TXipLibraryListEntry& xipLibrary = *(TXipLibraryListEntry*)ptr;

		//get the name of the library

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

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

			{

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

			//check nothing bad happens towards the end

			found = ETrue;

			}

		//move pointer on to next library

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

		}

	test(found);

	//do cleanup

	buffer.Close();

	}

//---------------------------------------------

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

//! @SYMTestType

//! @SYMPREQ PREQ1426

//! @SYMTestCaseDesc Test getting the list of executables

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

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

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

//---------------------------------------------

void CRunModeAgent::TestGetExecutablesList()

	{

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

	test(ListingSupported(EExecutables, EScopeGlobal));

	test(!ListingSupported(EExecutables, EScopeProcessSpecific));

	test(!ListingSupported(EExecutables, EScopeThreadSpecific));

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

	RBuf8 buffer;

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

	TUint32 size = 0;

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

	//get the list data

	DoGetList(EExecutables, EScopeGlobal, buffer, size);

	//get this process' name

	RProcess thisProcess;

	TFileName thisProcessName = thisProcess.FileName();

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

	TBool found = EFalse;

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

	const TUint8* ptrEnd = ptr + size;

	while(ptr < ptrEnd)

		{

		TExecutablesListEntry& entry = *(TExecutablesListEntry*)ptr;

		//get name

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

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

			{

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

			found = ETrue;

			}

		//move pointer on to next entry

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

		}

	test(found);

	//clean up

	buffer.Close();

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

	}

//---------------------------------------------

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

//! @SYMTestType

//! @SYMPREQ PREQ1426

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

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

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

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

//---------------------------------------------

void CRunModeAgent::TestGetListInvalidData()

	{

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

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

	RBuf8 buffer;

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

	TUint32 size = 0;

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

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

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

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

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

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

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

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

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

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

	//check that using a process id fails

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

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

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

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

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

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

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

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

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

	//cleanup

	buffer.Close();

	}

//---------------------------------------------

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

//! @SYMTestType

//! @SYMPREQ PREQ1426

//! @SYMTestCaseDesc Test getting the process list

//! @SYMTestActions Get the process listing

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

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

//---------------------------------------------

void CRunModeAgent::TestGetProcessList()

	{

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

	test(ListingSupported(EProcesses, EScopeGlobal));

	test(!ListingSupported(EProcesses, EScopeProcessSpecific));

	test(!ListingSupported(EProcesses, EScopeThreadSpecific));

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

	RBuf8 buffer;

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

	TUint32 size = 0;

	//get the list data

	DoGetList(EProcesses, EScopeGlobal, buffer, size);

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

	RProcess thisProcess;

	TFileName thisProcessName = thisProcess.FileName();

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

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

	TBool found = EFalse;

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

	const TUint8* ptrEnd = ptr + size;

	while(ptr < ptrEnd)

		{

		TProcessListEntry& entry = *(TProcessListEntry*)ptr;

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

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

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

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

			{

			//if all match then we've found it

			found = ETrue;

			}

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

		}

	//check whether the expected result happened

	test(found);

	//clean up

	buffer.Close();

	}

//---------------------------------------------

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

//! @SYMTestType

//! @SYMPREQ PREQ1426

//! @SYMTestCaseDesc Test getting the thread list

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

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

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

//---------------------------------------------

void CRunModeAgent::TestGetThreadList()

	{

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

	test(ListingSupported(EThreads, EScopeGlobal));

	test(ListingSupported(EThreads, EScopeProcessSpecific));

	test(ListingSupported(EThreads, EScopeThreadSpecific));

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

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

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

	DoTestGetThreadList(ETrue, EScopeGlobal);

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

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

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

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

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

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

	}

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

	{

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

	//create data to pass

	RBuf8 buffer;

	TUint32 size = 0;

	//perform the call to get the Code segs

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

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

	TFileName name = iDebugThread.FullName();

	RProcess thisProcess;

	TUint64 processId = thisProcess.Id();

	TUint64 threadId = iDebugThread.Id();

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

	TBool found = EFalse;

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

	const TUint8* ptrEnd = ptr + size;

	while(ptr < ptrEnd)

		{

		TThreadListEntry* entry = (TThreadListEntry*)ptr;

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

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

			{

			test(entry->iSupervisorStackBaseValid);

			test(entry->iSupervisorStackSizeValid);

			//if all match then we've found it

			found = ETrue;

			}

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

		}

	//check whether the expected result happened

	test(found == aShouldPass);

	//clean up

	buffer.Close();

	}

//---------------------------------------------

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

//! @SYMTestType

//! @SYMPREQ PREQ1426

//! @SYMTestCaseDesc Test getting the code segment list

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

//! @SYMTestExpectedResults The listings should be returned successfully

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

//---------------------------------------------

void CRunModeAgent::TestGetCodeSegsList()

	{

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

	test(ListingSupported(ECodeSegs, EScopeGlobal));

	test(ListingSupported(ECodeSegs, EScopeProcessSpecific));

	test(ListingSupported(ECodeSegs, EScopeThreadSpecific));

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

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

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

#ifndef SYMBIAN_OEM2DEBUG

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

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

	DoTestGetCodeSegsList(ETrue, EScopeGlobal);

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

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

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

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

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

#endif // SYMBIAN_OEM2DEBUG

	}

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

	{

	//create data to pass

	RBuf8 buffer;

	TUint32 size = 0;

	//perform the call to get the Code segs

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

	//create memoryInfo to contain info about this process

	RProcess thisProcess;

	TModuleMemoryInfo memoryInfo;

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

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

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

	RFs fs;

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

	TBool thisFileIsInRom = EFalse;

	if(fs.IsFileInRom(iFileName))

		{

		thisFileIsInRom = ETrue;

		}

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

	TBool found = EFalse;

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

	const TUint8* ptrEnd = ptr + size;

	while(ptr < ptrEnd)

		{

		TCodeSegListEntry* codeSeg = (TCodeSegListEntry*)ptr;