tstDBGCParser.cpp revision c9cc4dc782381dceb4de3f0b5b9255dddde34b34
/* $Id$ */
/** @file
* DBGC Testcase - Command Parser.
*/
/*
* Copyright (C) 2006-2011 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include "../DBGCInternal.h"
/*******************************************************************************
* Internal Functions *
*******************************************************************************/
static DECLCALLBACK(int) tstDBGCBackRead(PDBGCBACK pBack, void *pvBuf, size_t cbBuf, size_t *pcbRead);
static DECLCALLBACK(int) tstDBGCBackWrite(PDBGCBACK pBack, const void *pvBuf, size_t cbBuf, size_t *pcbWritten);
/*******************************************************************************
* Global Variables *
*******************************************************************************/
/** The test handle. */
/** The DBGC backend structure for use in this testcase. */
{
};
/** For keeping track of output prefixing. */
static bool g_fPendingPrefix = true;
/** Pointer to the current input position. */
const char *g_pszInput = NULL;
/** The output of the last command. */
static char g_szOutput[1024];
/** The current offset into g_szOutput. */
static size_t g_offOutput = 0;
/**
* Checks if there is input.
*
* @returns true if there is input ready.
* @returns false if there not input ready.
* @param pBack Pointer to the backend structure supplied by
* the backend. The backend can use this to find
* it's instance data.
* @param cMillies Number of milliseconds to wait on input data.
*/
{
return g_pszInput != NULL
&& *g_pszInput != '\0';
}
/**
* Read input.
*
* @returns VBox status code.
* @param pBack Pointer to the backend structure supplied by
* the backend. The backend can use this to find
* it's instance data.
* @param pvBuf Where to put the bytes we read.
* @param cbBuf Maximum nymber of bytes to read.
* @param pcbRead Where to store the number of bytes actually read.
* If NULL the entire buffer must be filled for a
* successful return.
*/
static DECLCALLBACK(int) tstDBGCBackRead(PDBGCBACK pBack, void *pvBuf, size_t cbBuf, size_t *pcbRead)
{
if (g_pszInput && *g_pszInput)
{
g_pszInput += cb;
}
else
*pcbRead = 0;
return VINF_SUCCESS;
}
/**
* Write (output).
*
* @returns VBox status code.
* @param pBack Pointer to the backend structure supplied by
* the backend. The backend can use this to find
* it's instance data.
* @param pvBuf What to write.
* @param cbBuf Number of bytes to write.
* @param pcbWritten Where to store the number of bytes actually written.
* If NULL the entire buffer must be successfully written.
*/
static DECLCALLBACK(int) tstDBGCBackWrite(PDBGCBACK pBack, const void *pvBuf, size_t cbBuf, size_t *pcbWritten)
{
if (pcbWritten)
*pcbWritten = cbBuf;
while (cbBuf-- > 0)
{
if (g_fPendingPrefix)
{
g_fPendingPrefix = false;
}
if (*pch == '\n')
g_fPendingPrefix = true;
/* buffer output */
{
}
/* advance */
pch++;
}
return VINF_SUCCESS;
}
/**
* Ready / busy notification.
*
* @param pBack Pointer to the backend structure supplied by
* the backend. The backend can use this to find
* it's instance data.
* @param fReady Whether it's ready (true) or busy (false).
*/
{
}
/**
* Completes the output, making sure that we're in
* the 1 position of a new line.
*/
static void tstCompleteOutput(void)
{
if (!g_fPendingPrefix)
g_fPendingPrefix = true;
}
/**
* Checks if two DBGC variables are identical
*
* @returns
* @param pVar1 .
* @param pVar2 .
*/
{
if (!pVar1)
return false;
return true;
return false;
{
case DBGCVAR_TYPE_GC_FLAT:
return false;
break;
case DBGCVAR_TYPE_GC_FAR:
return false;
return false;
break;
case DBGCVAR_TYPE_GC_PHYS:
return false;
break;
case DBGCVAR_TYPE_HC_FLAT:
return false;
break;
case DBGCVAR_TYPE_HC_PHYS:
return false;
break;
case DBGCVAR_TYPE_NUMBER:
return false;
break;
case DBGCVAR_TYPE_STRING:
case DBGCVAR_TYPE_SYMBOL:
return false;
break;
default:
AssertFailedReturn(false);
}
return false;
switch (pVar1->enmRangeType)
{
case DBGCVAR_RANGE_NONE:
break;
case DBGCVAR_RANGE_ELEMENTS:
case DBGCVAR_RANGE_BYTES:
return false;
break;
default:
AssertFailedReturn(false);
}
return true;
}
/**
* Tries one command string.
* @param pDbgc Pointer to the debugger instance.
* @param pszCmds The command to test.
* @param rcCmd The expected result.
* @param fNoExecute When set, the command is not executed.
* @param pszExpected Expected output. This does not need to include all
* of the output, just the start of it. Thus the
* prompt can be omitted.
* @param cArgs The number of expected arguments. -1 if we don't
* want to check the parsed arguments.
* @param va Info about expected parsed arguments. For each
* argument a DBGCVARTYPE, value (depends on type),
* DBGCVARRANGETYPE and optionally range value.
*/
static void tstTryExV(PDBGC pDbgc, const char *pszCmds, int rcCmd, bool fNoExecute, const char *pszExpected,
{
g_offOutput = 0;
else
else if ( !fNoExecute
&& pszExpected
if (cArgs >= 0)
{
{
switch (ExpectedArg.enmType)
{
default:
ExpectedArg.u.u64Number = 0;
break;
}
switch (ExpectedArg.enmRangeType)
{
default:
ExpectedArg.u64Range = 0;
break;
}
"Arg #%u\n"
"actual: enmType=%u u64=%#RX64 enmRangeType=%u u64Range=%#RX64\n"
"expected: enmType=%u u64=%#RX64 enmRangeType=%u u64Range=%#RX64\n",
iArg,
}
}
}
/**
* Tries one command string.
*
* @param pDbgc Pointer to the debugger instance.
* @param pszCmds The command to test.
* @param rcCmd The expected result.
* @param fNoExecute When set, the command is not executed.
* @param pszExpected Expected output. This does not need to include all
* of the output, just the start of it. Thus the
* prompt can be omitted.
* @param cArgs The number of expected arguments. -1 if we don't
* want to check the parsed arguments.
* @param ... Info about expected parsed arguments. For each
* argument a DBGCVARTYPE, value (depends on type),
* DBGCVARRANGETYPE and optionally range value.
*/
static void tstTryEx(PDBGC pDbgc, const char *pszCmds, int rcCmd, bool fNoExecute, const char *pszExpected, int32_t cArgs, ...)
{
}
/**
* Tries one command string without executing it.
*
* @param pDbgc Pointer to the debugger instance.
* @param pszCmds The command to test.
* @param rcCmd The expected result.
*/
{
}
#ifdef SOME_UNUSED_FUNCTION
/**
* Tries to execute one command string.
* @param pDbgc Pointer to the debugger instance.
* @param pszCmds The command to test.
* @param rcCmd The expected result.
* @param pszExpected Expected output. This does not need to include all
* of the output, just the start of it. Thus the
* prompt can be omitted.
*/
{
}
#endif
/**
* Test an operator on an expression resulting a plain number.
*
* @param pDbgc Pointer to the debugger instance.
* @param pszExpr The express to test.
* @param u64Expect The expected result.
*/
{
char szCmd[80];
char szExpected[80];
}
/*
*
* CodeView emulation commands.
* CodeView emulation commands.
* CodeView emulation commands.
*
*/
{
RTTestISub("codeview - ba");
}
{
RTTestISub("codeview - bc");
}
{
RTTestISub("codeview - bc");
}
{
RTTestISub("codeview - be");
}
{
RTTestISub("codeview - bl");
}
{
RTTestISub("codeview - bp");
}
{
RTTestISub("codeview - br");
}
{
RTTestISub("codeview - d");
}
{
RTTestISub("codeview - da");
}
{
RTTestISub("codeview - db");
}
{
RTTestISub("codeview - dd");
}
{
RTTestISub("codeview - dg");
}
{
RTTestISub("codeview - dga");
}
{
RTTestISub("codeview - di");
}
{
RTTestISub("codeview - dia");
}
{
RTTestISub("codeview - dl");
}
{
RTTestISub("codeview - dla");
}
{
RTTestISub("codeview - dpd");
}
{
RTTestISub("codeview - dpda");
}
{
RTTestISub("codeview - dpdb");
}
{
RTTestISub("codeview - dpdg");
}
{
RTTestISub("codeview - dpdh");
}
{
RTTestISub("codeview - dph");
}
{
RTTestISub("codeview - dphg");
}
{
RTTestISub("codeview - dphh");
}
{
RTTestISub("codeview - dq");
}
{
RTTestISub("codeview - dt");
}
{
RTTestISub("codeview - dt16");
}
{
RTTestISub("codeview - dt32");
}
{
RTTestISub("codeview - dt64");
}
{
RTTestISub("codeview - dw");
}
{
RTTestISub("codeview - eb");
}
{
RTTestISub("codeview - ew");
}
{
RTTestISub("codeview - ed");
}
{
RTTestISub("codeview - eq");
}
{
RTTestISub("codeview - g");
}
{
RTTestISub("codeview - k");
}
{
RTTestISub("codeview - kg");
}
{
RTTestISub("codeview - kh");
}
{
RTTestISub("codeview - lm");
}
{
RTTestISub("codeview - lmo");
}
{
RTTestISub("codeview - ln");
}
{
RTTestISub("codeview - ls");
}
{
RTTestISub("codeview - m");
}
{
RTTestISub("codeview - r");
}
{
RTTestISub("codeview - rg");
}
{
RTTestISub("codeview - rg32");
}
{
RTTestISub("codeview - rg64");
}
{
RTTestISub("codeview - rh");
}
{
RTTestISub("codeview - rt");
}
{
RTTestISub("codeview - s");
}
{
RTTestISub("codeview - sa");
}
{
RTTestISub("codeview - sb");
}
{
RTTestISub("codeview - sd");
}
{
RTTestISub("codeview - sq");
}
{
RTTestISub("codeview - su");
}
{
RTTestISub("codeview - sw");
}
{
RTTestISub("codeview - t");
}
{
RTTestISub("codeview - y");
}
{
RTTestISub("codeview - u64");
}
{
RTTestISub("codeview - u32");
}
{
RTTestISub("codeview - u16");
}
{
RTTestISub("codeview - uv86");
}
/*
* Common commands.
*/
{
RTTestISub("common - bye/exit/quit");
/* These have the same parameter descriptor and handler, the command really
just has a couple of aliases.*/
}
{
RTTestISub("common - cpu");
}
{
RTTestISub("common - echo");
/* The idea here is that since the prefered input is a string, we
definitely won't be mistaking number like beginnings as numbers. */
tstTryEx(pDbgc, "echo 1234567890abcdefghijklmn\n", VINF_SUCCESS, false, "1234567890abcdefghijklmn", -1);
/* The idea here is that we'll perform the + operation and then convert the
result to a string (hex). */
}
{
RTTestISub("common - format");
}
{
RTTestISub("common - detect");
}
{
RTTestISub("common - harakiri");
}
{
RTTestISub("common - help");
}
{
RTTestISub("common - info");
}
{
RTTestISub("common - loadimage");
}
{
RTTestISub("common - loadmap");
}
{
RTTestISub("common - loadplugin");
}
{
RTTestISub("common - loadseg");
}
{
RTTestISub("common - loadsyms");
}
{
RTTestISub("common - loadvars");
}
{
RTTestISub("common - log");
}
{
RTTestISub("common - logdest");
}
{
RTTestISub("common - logflags");
}
{
RTTestISub("common - runscript");
}
{
RTTestISub("common - set");
}
{
RTTestISub("common - showplugins");
}
{
RTTestISub("common - showvars");
}
{
RTTestISub("common - stop");
}
{
RTTestISub("common - unloadplugin");
}
{
RTTestISub("common - unset");
}
{
RTTestISub("common - writecore");
}
/*
* Basic tests.
*/
{
RTTestISub("Odd cases");
}
{
RTTestISub("Operators");
}
{
RTTestISub("Fundamental parsing");
}
int main()
{
/*
* Init.
*/
if (rc)
return rc;
/*
* Create a DBGC instance.
*/
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
/*
* Perform basic tests first.
*/
if (RTTestErrorCount(g_hTest) == 0)
if (RTTestErrorCount(g_hTest) == 0)
/*
* Test commands.
*/
if (RTTestErrorCount(g_hTest) == 0)
{
}
}
}
/*
* Summary
*/
return RTTestSummaryAndDestroy(g_hTest);
}