Changeset 5685 in vbox

Timestamp:

Nov 11, 2007 11:11:40 AM (17 years ago)

Author:

vboxsync

Message:

testcase framework.

Location:

trunk/src/VBox/Debugger

Files:

• DBGCInternal.h (modified) (1 diff)
• DBGConsole.cpp (modified) (3 diffs)
• Makefile.kmk (modified) (2 diffs)
• testcase/tstDBGCParser.cpp (modified) (2 diffs)
• testcase/tstDBGCStubs.cpp (added)

trunk/src/VBox/Debugger/DBGCInternal.h

@@ -328 +328 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
+int     dbgcCreate(PDBGC *ppDbgc, PDBGCBACK pBack, unsigned fFlags);
+int     dbgcRun(PDBGC pDbgc);
+void    dbgcDestroy(PDBGC pDbgc);
+
 int     dbgcBpAdd(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);
 int     dbgcBpUpdate(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);

trunk/src/VBox/Debugger/DBGConsole.cpp

@@ -1820 +1820 @@
 
 /**
- * Make a console instance.
- *
- * This will not return until either an 'exit' command is issued or a error code
- * indicating connection loss is encountered.
- *
- * @returns VINF_SUCCESS if console termination caused by the 'exit' command.
- * @returns The VBox status code causing the console termination.
- *
- * @param   pVM         VM Handle.
- * @param   pBack       Pointer to the backend structure. This must contain
- *                      a full set of function pointers to service the console.
- * @param   fFlags      Reserved, must be zero.
- * @remark  A forced termination of the console is easiest done by forcing the
- *          callbacks to return fatal failures.
- */
-DBGDECL(int) DBGCCreate(PVM pVM, PDBGCBACK pBack, unsigned fFlags)
+ * Run the debugger console.
+ *
+ * @returns VBox status.
+ * @param   pDbgc   Pointer to the debugger console instance data.
+ */
+int dbgcRun(PDBGC pDbgc)
+{
+    /*
+     * Main Debugger Loop.
+     *
+     * This loop will either block on waiting for input or on waiting on
+     * debug events. If we're forwarding the log we cannot wait for long
+     * before we must flush the log.
+     */
+    int rc = VINF_SUCCESS;
+    for (;;)
+    {
+        if (pDbgc->pVM && DBGFR3CanWait(pDbgc->pVM))
+        {
+            /*
+             * Wait for a debug event.
+             */
+            PCDBGFEVENT pEvent;
+            rc = DBGFR3EventWait(pDbgc->pVM, pDbgc->fLog ? 1 : 32, &pEvent);
+            if (VBOX_SUCCESS(rc))
+            {
+                rc = dbgcProcessEvent(pDbgc, pEvent);
+                if (VBOX_FAILURE(rc))
+                    break;
+            }
+            else if (rc != VERR_TIMEOUT)
+                break;
+
+            /*
+             * Check for input.
+             */
+            if (pDbgc->pBack->pfnInput(pDbgc->pBack, 0))
+            {
+                rc = dbgcProcessInput(pDbgc);
+                if (VBOX_FAILURE(rc))
+                    break;
+            }
+        }
+        else
+        {
+            /*
+             * Wait for input. If Logging is enabled we'll only wait very briefly.
+             */
+            if (pDbgc->pBack->pfnInput(pDbgc->pBack, pDbgc->fLog ? 1 : 1000))
+            {
+                rc = dbgcProcessInput(pDbgc);
+                if (VBOX_FAILURE(rc))
+                    break;
+            }
+        }
+
+        /*
+         * Forward log output.
+         */
+        if (pDbgc->fLog)
+        {
+            rc = dbgcProcessLog(pDbgc);
+            if (VBOX_FAILURE(rc))
+                break;
+        }
+    }
+
+    return rc;
+}
+
+
+/**
+ * Creates a a new instance.
+ *
+ * @returns VBox status code.
+ * @param   ppDbgc      Where to store the pointer to the instance data.
+ * @param   pBack       Pointer to the backend.
+ * @param   fFlags      The flags.
+ */
+int dbgcCreate(PDBGC *ppDbgc, PDBGCBACK pBack, unsigned fFlags)
 {
     /*
      * Validate input.
      */
-    AssertReturn(VALID_PTR(pVM), VERR_INVALID_PARAMETER);
-    AssertReturn(VALID_PTR(pBack), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pBack, VERR_INVALID_POINTER);
     AssertMsgReturn(!fFlags, ("%#x", fFlags), VERR_INVALID_PARAMETER);
 
     /*
-     * Allocate and initialize instance data
-     */
-    PDBGC   pDbgc = (PDBGC)RTMemAllocZ(sizeof(*pDbgc));
+     * Allocate and initialize.
+     */
+    PDBGC pDbgc = (PDBGC)RTMemAllocZ(sizeof(*pDbgc));
     if (!pDbgc)
         return VERR_NO_MEMORY;
@@ -1879 +1942 @@
     dbgcInitOpCharBitMap();
 
-    /*
-     * Print welcome message.
-     */
-    int rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
-        "Welcome to the VirtualBox Debugger!\n");
-    if (VBOX_FAILURE(rc))
-        goto l_failure;
-
-    /*
-     * Attach to the VM.
-     */
-    rc = DBGFR3Attach(pVM);
-    if (VBOX_FAILURE(rc))
-    {
-        rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to attach to VM %p\n", pDbgc->pVM);
-        goto l_failure;
-    }
-    pDbgc->pVM = pVM;
-
-    /*
-     * Print commandline and auto select result.
-     */
-    rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
-        "Current VM is %08x\n" /** @todo get and print the VM name! */
-        "VBoxDbg> ",
-        pDbgc->pVM);
-    if (VBOX_FAILURE(rc))
-        goto l_failure;
-
-    /*
-     * Main Debugger Loop.
-     *
-     * This loop will either block on waiting for input or on waiting on
-     * debug events. If we're forwarding the log we cannot wait for long
-     * before we must flush the log.
-     */
-    for (rc = 0;;)
-    {
-        if (pDbgc->pVM && DBGFR3CanWait(pDbgc->pVM))
-        {
-            /*
-             * Wait for a debug event.
-             */
-            PCDBGFEVENT pEvent;
-            rc = DBGFR3EventWait(pDbgc->pVM, pDbgc->fLog ? 1 : 32, &pEvent);
-            if (VBOX_SUCCESS(rc))
-            {
-                rc = dbgcProcessEvent(pDbgc, pEvent);
-                if (VBOX_FAILURE(rc))
-                    break;
-            }
-            else if (rc != VERR_TIMEOUT)
-                break;
-
-            /*
-             * Check for input.
-             */
-            if (pBack->pfnInput(pDbgc->pBack, 0))
-            {
-                rc = dbgcProcessInput(pDbgc);
-                if (VBOX_FAILURE(rc))
-                    break;
-            }
-        }
-        else
-        {
-            /*
-             * Wait for input. If Logging is enabled we'll only wait very briefly.
-             */
-            if (pBack->pfnInput(pDbgc->pBack, pDbgc->fLog ? 1 : 1000))
-            {
-                rc = dbgcProcessInput(pDbgc);
-                if (VBOX_FAILURE(rc))
-                    break;
-            }
-        }
-
-        /*
-         * Forward log output.
-         */
-        if (pDbgc->fLog)
-        {
-            rc = dbgcProcessLog(pDbgc);
-            if (VBOX_FAILURE(rc))
-                break;
-        }
-    }
-
-
-l_failure:
-    /*
-     * Cleanup console debugger session.
-     */
+    *ppDbgc = pDbgc;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Destroys a DBGC instance created by dbgcCreate.
+ *
+ * @param   pDbgc   Pointer to the debugger console instance data.
+ */
+void dbgcDestroy(PDBGC pDbgc)
+{
+    AssertPtr(pDbgc);
+
     /* Disable log hook. */
     if (pDbgc->fLog)
@@ -1984 +1967 @@
     /* finally, free the instance memory. */
     RTMemFree(pDbgc);
-
+}
+
+
+/**
+ * Make a console instance.
+ *
+ * This will not return until either an 'exit' command is issued or a error code
+ * indicating connection loss is encountered.
+ *
+ * @returns VINF_SUCCESS if console termination caused by the 'exit' command.
+ * @returns The VBox status code causing the console termination.
+ *
+ * @param   pVM         VM Handle.
+ * @param   pBack       Pointer to the backend structure. This must contain
+ *                      a full set of function pointers to service the console.
+ * @param   fFlags      Reserved, must be zero.
+ * @remark  A forced termination of the console is easiest done by forcing the
+ *          callbacks to return fatal failures.
+ */
+DBGDECL(int) DBGCCreate(PVM pVM, PDBGCBACK pBack, unsigned fFlags)
+{
+    /*
+     * Validate input.
+     */
+    AssertPtrNullReturn(pVM, VERR_INVALID_POINTER);
+
+    /*
+     * Allocate and initialize instance data
+     */
+    PDBGC pDbgc;
+    int rc = dbgcCreate(&pDbgc, pBack, fFlags);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /*
+     * Print welcome message.
+     */
+    rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
+                                 "Welcome to the VirtualBox Debugger!\n");
+
+    /*
+     * Attach to the specified VM.
+     */
+    if (RT_SUCCESS(rc) && pVM)
+    {
+        rc = DBGFR3Attach(pVM);
+        if (RT_SUCCESS(rc))
+        {
+            pDbgc->pVM = pVM;
+            rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
+                                         "Current VM is %08x\n" /** @todo get and print the VM name! */
+                                         "VBoxDbg> ",
+                                         pDbgc->pVM);
+        }
+        else
+            rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to attach to VM %p\n", pDbgc->pVM);
+    }
+    else
+        rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
+                                     "VBoxDbg> ");
+
+    /*
+     * Run the main loop.
+     */
+    if (RT_SUCCESS(rc))
+        rc = dbgcRun(pDbgc);
+
+    /*
+     * Cleanup console debugger session.
+     */
+    dbgcDestroy(pDbgc);
     return rc;
 }

trunk/src/VBox/Debugger/Makefile.kmk

@@ -59 +59 @@
 # This stubs all the VBoxVMM APIs.
 #
-tstDBGCParser_TEMPLATE = VBOXR3EXE
+tstDBGCParser_TEMPLATE = VBOXR3TSTEXE
+tstDBGCParser_DEFS = IN_DBGF_R3 IN_CPUM_R3 IN_MM_R3 IN_PGM_R3 IN_SELM_R3
 tstDBGCParser_SOURCES = \
-        testcase/tstDBGCParser.cpp
+        testcase/tstDBGCParser.cpp \
+        testcase/tstDBGCStubs.cpp
 tstDBGCParser_LIBS = \
         $(TARGET_Debugger) \
@@ -73 +75 @@
 VBoxDbg_DEFS = IN_DBG_R3
 VBoxDbg_CXXFLAGS.linux = $(TEMPLATE_VBOXQTGUI_CXXFLAGS.linux) -O2
-VBoxDbg_CXXFLAGS.win = -wd4244
 VBoxDbg_INCS = \
         . \

trunk/src/VBox/Debugger/testcase/tstDBGCParser.cpp

@@ -29 +29 @@
 
 /*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+static DECLCALLBACK(bool) tstDBGCBackInput(PDBGCBACK pBack, uint32_t cMillies);
+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                                                           *
 *******************************************************************************/
 /** Global error counter. */
 static unsigned g_cErrors = 0;
+/** The DBGC backend structure for use in this testcase. */
+static DBGCBACK g_tstBack =
+{
+    tstDBGCBackInput,
+    tstDBGCBackRead,
+    tstDBGCBackWrite
+};
+/** For keeping track of output prefixing. */
+static bool g_fPendingPrefix = true;
+
+
+/**
+ * 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.
+ */
+static DECLCALLBACK(bool) tstDBGCBackInput(PDBGCBACK pBack, uint32_t cMillies)
+{
+    RTPrintf("tstDBGCParser: tstDBGCBackInput was called!\n");
+    g_cErrors++;
+    return false;
+}
+
+
+/**
+ * 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)
+{
+    RTPrintf("tstDBGCParser: tstDBGCBackRead was called!\n");
+    g_cErrors++;
+    return VERR_INTERNAL_ERROR;
+}
+
+
+/**
+ * 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)
+{
+    const char *pch = (const char *)pvBuf;
+    *pcbWritten = cbBuf;
+    while (cbBuf-- > 0)
+    {
+        if (g_fPendingPrefix)
+        {
+            RTPrintf("tstDBGCParser: OUTPUT: ");
+            g_fPendingPrefix = false;
+        }
+        if (*pch == '\n')
+            g_fPendingPrefix = true;
+        RTPrintf("%c", *pch);
+        pch++;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Completes the output, making sure that we're in
+ * the 1 position of a new line.
+ */
+static void tstCompleteOutput(void)
+{
+    if (!g_fPendingPrefix)
+        RTPrintf("\n");
+    g_fPendingPrefix = true;
+}
+
 
 
@@ -45 +146 @@
 
     /*
-     *
+     * Create a DBGC instance.
      */
+    PDBGC pDbgc;
+    int rc = dbgcCreate(&pDbgc, &g_tstBack, 0);
+    if (RT_SUCCESS(rc))
+    {
+
+        dbgcDestroy(pDbgc);
+    }