VirtualBox

source: vbox/trunk/src/VBox/Debugger/testcase/tstDBGCParser.cpp@ 48935

Last change on this file since 48935 was 44528, checked in by vboxsync, 12 years ago

header (C) fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 37.3 KB
Line 
1/* $Id: tstDBGCParser.cpp 44528 2013-02-04 14:27:54Z vboxsync $ */
2/** @file
3 * DBGC Testcase - Command Parser.
4 */
5
6/*
7 * Copyright (C) 2006-2012 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#include <VBox/dbg.h>
22#include "../DBGCInternal.h"
23
24#include <iprt/string.h>
25#include <iprt/test.h>
26#include <VBox/err.h>
27
28
29/*******************************************************************************
30* Internal Functions *
31*******************************************************************************/
32static DECLCALLBACK(bool) tstDBGCBackInput(PDBGCBACK pBack, uint32_t cMillies);
33static DECLCALLBACK(int) tstDBGCBackRead(PDBGCBACK pBack, void *pvBuf, size_t cbBuf, size_t *pcbRead);
34static DECLCALLBACK(int) tstDBGCBackWrite(PDBGCBACK pBack, const void *pvBuf, size_t cbBuf, size_t *pcbWritten);
35static DECLCALLBACK(void) tstDBGCBackSetReady(PDBGCBACK pBack, bool fReady);
36
37
38/*******************************************************************************
39* Global Variables *
40*******************************************************************************/
41/** The test handle. */
42static RTTEST g_hTest = NIL_RTTEST;
43
44/** The DBGC backend structure for use in this testcase. */
45static DBGCBACK g_tstBack =
46{
47 tstDBGCBackInput,
48 tstDBGCBackRead,
49 tstDBGCBackWrite,
50 tstDBGCBackSetReady
51};
52/** For keeping track of output prefixing. */
53static bool g_fPendingPrefix = true;
54/** Pointer to the current input position. */
55const char *g_pszInput = NULL;
56/** The output of the last command. */
57static char g_szOutput[1024];
58/** The current offset into g_szOutput. */
59static size_t g_offOutput = 0;
60
61
62/**
63 * Checks if there is input.
64 *
65 * @returns true if there is input ready.
66 * @returns false if there not input ready.
67 * @param pBack Pointer to the backend structure supplied by
68 * the backend. The backend can use this to find
69 * it's instance data.
70 * @param cMillies Number of milliseconds to wait on input data.
71 */
72static DECLCALLBACK(bool) tstDBGCBackInput(PDBGCBACK pBack, uint32_t cMillies)
73{
74 return g_pszInput != NULL
75 && *g_pszInput != '\0';
76}
77
78
79/**
80 * Read input.
81 *
82 * @returns VBox status code.
83 * @param pBack Pointer to the backend structure supplied by
84 * the backend. The backend can use this to find
85 * it's instance data.
86 * @param pvBuf Where to put the bytes we read.
87 * @param cbBuf Maximum nymber of bytes to read.
88 * @param pcbRead Where to store the number of bytes actually read.
89 * If NULL the entire buffer must be filled for a
90 * successful return.
91 */
92static DECLCALLBACK(int) tstDBGCBackRead(PDBGCBACK pBack, void *pvBuf, size_t cbBuf, size_t *pcbRead)
93{
94 if (g_pszInput && *g_pszInput)
95 {
96 size_t cb = strlen(g_pszInput);
97 if (cb > cbBuf)
98 cb = cbBuf;
99 *pcbRead = cb;
100 memcpy(pvBuf, g_pszInput, cb);
101 g_pszInput += cb;
102 }
103 else
104 *pcbRead = 0;
105 return VINF_SUCCESS;
106}
107
108
109/**
110 * Write (output).
111 *
112 * @returns VBox status code.
113 * @param pBack Pointer to the backend structure supplied by
114 * the backend. The backend can use this to find
115 * it's instance data.
116 * @param pvBuf What to write.
117 * @param cbBuf Number of bytes to write.
118 * @param pcbWritten Where to store the number of bytes actually written.
119 * If NULL the entire buffer must be successfully written.
120 */
121static DECLCALLBACK(int) tstDBGCBackWrite(PDBGCBACK pBack, const void *pvBuf, size_t cbBuf, size_t *pcbWritten)
122{
123 const char *pch = (const char *)pvBuf;
124 if (pcbWritten)
125 *pcbWritten = cbBuf;
126 while (cbBuf-- > 0)
127 {
128 /* screen/log output */
129 if (g_fPendingPrefix)
130 {
131 RTTestPrintfNl(g_hTest, RTTESTLVL_ALWAYS, "OUTPUT: ");
132 g_fPendingPrefix = false;
133 }
134 if (*pch == '\n')
135 g_fPendingPrefix = true;
136 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "%c", *pch);
137
138 /* buffer output */
139 if (g_offOutput < sizeof(g_szOutput) - 1)
140 {
141 g_szOutput[g_offOutput++] = *pch;
142 g_szOutput[g_offOutput] = '\0';
143 }
144
145 /* advance */
146 pch++;
147 }
148 return VINF_SUCCESS;
149}
150
151
152/**
153 * Ready / busy notification.
154 *
155 * @param pBack Pointer to the backend structure supplied by
156 * the backend. The backend can use this to find
157 * it's instance data.
158 * @param fReady Whether it's ready (true) or busy (false).
159 */
160static DECLCALLBACK(void) tstDBGCBackSetReady(PDBGCBACK pBack, bool fReady)
161{
162}
163
164
165/**
166 * Completes the output, making sure that we're in
167 * the 1 position of a new line.
168 */
169static void tstCompleteOutput(void)
170{
171 if (!g_fPendingPrefix)
172 RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "\n");
173 g_fPendingPrefix = true;
174}
175
176
177/**
178 * Checks if two DBGC variables are identical
179 *
180 * @returns
181 * @param pVar1 .
182 * @param pVar2 .
183 */
184bool DBGCVarAreIdentical(PCDBGCVAR pVar1, PCDBGCVAR pVar2)
185{
186 if (!pVar1)
187 return false;
188 if (pVar1 == pVar2)
189 return true;
190
191 if (pVar1->enmType != pVar2->enmType)
192 return false;
193 switch (pVar1->enmType)
194 {
195 case DBGCVAR_TYPE_GC_FLAT:
196 if (pVar1->u.GCFlat != pVar2->u.GCFlat)
197 return false;
198 break;
199 case DBGCVAR_TYPE_GC_FAR:
200 if (pVar1->u.GCFar.off != pVar2->u.GCFar.off)
201 return false;
202 if (pVar1->u.GCFar.sel != pVar2->u.GCFar.sel)
203 return false;
204 break;
205 case DBGCVAR_TYPE_GC_PHYS:
206 if (pVar1->u.GCPhys != pVar2->u.GCPhys)
207 return false;
208 break;
209 case DBGCVAR_TYPE_HC_FLAT:
210 if (pVar1->u.pvHCFlat != pVar2->u.pvHCFlat)
211 return false;
212 break;
213 case DBGCVAR_TYPE_HC_PHYS:
214 if (pVar1->u.HCPhys != pVar2->u.HCPhys)
215 return false;
216 break;
217 case DBGCVAR_TYPE_NUMBER:
218 if (pVar1->u.u64Number != pVar2->u.u64Number)
219 return false;
220 break;
221 case DBGCVAR_TYPE_STRING:
222 case DBGCVAR_TYPE_SYMBOL:
223 if (RTStrCmp(pVar1->u.pszString, pVar2->u.pszString) != 0)
224 return false;
225 break;
226 default:
227 AssertFailedReturn(false);
228 }
229
230 if (pVar1->enmRangeType != pVar2->enmRangeType)
231 return false;
232 switch (pVar1->enmRangeType)
233 {
234 case DBGCVAR_RANGE_NONE:
235 break;
236
237 case DBGCVAR_RANGE_ELEMENTS:
238 case DBGCVAR_RANGE_BYTES:
239 if (pVar1->u64Range != pVar2->u64Range)
240 return false;
241 break;
242 default:
243 AssertFailedReturn(false);
244 }
245
246 return true;
247}
248
249/**
250 * Tries one command string.
251 * @param pDbgc Pointer to the debugger instance.
252 * @param pszCmds The command to test.
253 * @param rcCmd The expected result.
254 * @param fNoExecute When set, the command is not executed.
255 * @param pszExpected Expected output. This does not need to include all
256 * of the output, just the start of it. Thus the
257 * prompt can be omitted.
258 * @param cArgs The number of expected arguments. -1 if we don't
259 * want to check the parsed arguments.
260 * @param va Info about expected parsed arguments. For each
261 * argument a DBGCVARTYPE, value (depends on type),
262 * DBGCVARRANGETYPE and optionally range value.
263 */
264static void tstTryExV(PDBGC pDbgc, const char *pszCmds, int rcCmd, bool fNoExecute, const char *pszExpected,
265 int32_t cArgs, va_list va)
266{
267 RT_ZERO(g_szOutput);
268 g_offOutput = 0;
269 g_pszInput = pszCmds;
270 if (strchr(pszCmds, '\0')[-1] == '\n')
271 RTTestPrintfNl(g_hTest, RTTESTLVL_ALWAYS, "RUNNING: %s", pszCmds);
272 else
273 RTTestPrintfNl(g_hTest, RTTESTLVL_ALWAYS, "RUNNING: %s\n", pszCmds);
274
275 pDbgc->rcCmd = VERR_INTERNAL_ERROR;
276 dbgcProcessInput(pDbgc, fNoExecute);
277 tstCompleteOutput();
278
279 if (pDbgc->rcCmd != rcCmd)
280 RTTestFailed(g_hTest, "rcCmd=%Rrc expected =%Rrc\n", pDbgc->rcCmd, rcCmd);
281 else if ( !fNoExecute
282 && pszExpected
283 && strncmp(pszExpected, g_szOutput, strlen(pszExpected)))
284 RTTestFailed(g_hTest, "Wrong output - expected \"%s\"", pszExpected);
285
286 if (cArgs >= 0)
287 {
288 PCDBGCVAR paArgs = pDbgc->aArgs;
289 for (int32_t iArg = 0; iArg < cArgs; iArg++)
290 {
291 DBGCVAR ExpectedArg;
292 ExpectedArg.enmType = (DBGCVARTYPE)va_arg(va, int/*DBGCVARTYPE*/);
293 switch (ExpectedArg.enmType)
294 {
295 case DBGCVAR_TYPE_GC_FLAT: ExpectedArg.u.GCFlat = va_arg(va, RTGCPTR); break;
296 case DBGCVAR_TYPE_GC_FAR: ExpectedArg.u.GCFar.sel = va_arg(va, int /*RTSEL*/);
297 ExpectedArg.u.GCFar.off = va_arg(va, uint32_t); break;
298 case DBGCVAR_TYPE_GC_PHYS: ExpectedArg.u.GCPhys = va_arg(va, RTGCPHYS); break;
299 case DBGCVAR_TYPE_HC_FLAT: ExpectedArg.u.pvHCFlat = va_arg(va, void *); break;
300 case DBGCVAR_TYPE_HC_PHYS: ExpectedArg.u.HCPhys = va_arg(va, RTHCPHYS); break;
301 case DBGCVAR_TYPE_NUMBER: ExpectedArg.u.u64Number = va_arg(va, uint64_t); break;
302 case DBGCVAR_TYPE_STRING: ExpectedArg.u.pszString = va_arg(va, const char *); break;
303 case DBGCVAR_TYPE_SYMBOL: ExpectedArg.u.pszString = va_arg(va, const char *); break;
304 default:
305 RTTestFailed(g_hTest, "enmType=%u iArg=%u\n", ExpectedArg.enmType, iArg);
306 ExpectedArg.u.u64Number = 0;
307 break;
308 }
309 ExpectedArg.enmRangeType = (DBGCVARRANGETYPE)va_arg(va, int /*DBGCVARRANGETYPE*/);
310 switch (ExpectedArg.enmRangeType)
311 {
312 case DBGCVAR_RANGE_NONE: ExpectedArg.u64Range = 0; break;
313 case DBGCVAR_RANGE_ELEMENTS: ExpectedArg.u64Range = va_arg(va, uint64_t); break;
314 case DBGCVAR_RANGE_BYTES: ExpectedArg.u64Range = va_arg(va, uint64_t); break;
315 default:
316 RTTestFailed(g_hTest, "enmRangeType=%u iArg=%u\n", ExpectedArg.enmRangeType, iArg);
317 ExpectedArg.u64Range = 0;
318 break;
319 }
320
321 if (!DBGCVarAreIdentical(&ExpectedArg, &paArgs[iArg]))
322 RTTestFailed(g_hTest,
323 "Arg #%u\n"
324 "actual: enmType=%u u64=%#RX64 enmRangeType=%u u64Range=%#RX64\n"
325 "expected: enmType=%u u64=%#RX64 enmRangeType=%u u64Range=%#RX64\n",
326 iArg,
327 paArgs[iArg].enmType, paArgs[iArg].u.u64Number, paArgs[iArg].enmRangeType, paArgs[iArg].u64Range,
328 ExpectedArg.enmType, ExpectedArg.u.u64Number, ExpectedArg.enmRangeType, ExpectedArg.u64Range);
329 }
330 }
331}
332
333/**
334 * Tries one command string.
335 *
336 * @param pDbgc Pointer to the debugger instance.
337 * @param pszCmds The command to test.
338 * @param rcCmd The expected result.
339 * @param fNoExecute When set, the command is not executed.
340 * @param pszExpected Expected output. This does not need to include all
341 * of the output, just the start of it. Thus the
342 * prompt can be omitted.
343 * @param cArgs The number of expected arguments. -1 if we don't
344 * want to check the parsed arguments.
345 * @param ... Info about expected parsed arguments. For each
346 * argument a DBGCVARTYPE, value (depends on type),
347 * DBGCVARRANGETYPE and optionally range value.
348 */
349static void tstTryEx(PDBGC pDbgc, const char *pszCmds, int rcCmd, bool fNoExecute, const char *pszExpected, int32_t cArgs, ...)
350{
351 va_list va;
352 va_start(va, cArgs);
353 tstTryExV(pDbgc, pszCmds, rcCmd, fNoExecute, pszExpected, cArgs, va);
354 va_end(va);
355}
356
357
358/**
359 * Tries one command string without executing it.
360 *
361 * @param pDbgc Pointer to the debugger instance.
362 * @param pszCmds The command to test.
363 * @param rcCmd The expected result.
364 */
365static void tstTry(PDBGC pDbgc, const char *pszCmds, int rcCmd)
366{
367 return tstTryEx(pDbgc, pszCmds, rcCmd, true /*fNoExecute*/, NULL, -1);
368}
369
370
371#ifdef SOME_UNUSED_FUNCTION
372/**
373 * Tries to execute one command string.
374 * @param pDbgc Pointer to the debugger instance.
375 * @param pszCmds The command to test.
376 * @param rcCmd The expected result.
377 * @param pszExpected Expected output. This does not need to include all
378 * of the output, just the start of it. Thus the
379 * prompt can be omitted.
380 */
381static void tstTryExec(PDBGC pDbgc, const char *pszCmds, int rcCmd, const char *pszExpected)
382{
383 return tstTryEx(pDbgc, pszCmds, rcCmd, false /*fNoExecute*/, pszExpected, -1);
384}
385#endif
386
387
388/**
389 * Test an operator on an expression resulting a plain number.
390 *
391 * @param pDbgc Pointer to the debugger instance.
392 * @param pszExpr The express to test.
393 * @param u64Expect The expected result.
394 */
395static void tstNumOp(PDBGC pDbgc, const char *pszExpr, uint64_t u64Expect)
396{
397 char szCmd[80];
398 RTStrPrintf(szCmd, sizeof(szCmd), "format %s\n", pszExpr);
399
400 char szExpected[80];
401 RTStrPrintf(szExpected, sizeof(szExpected),
402 "Number: hex %llx dec 0i%lld oct 0t%llo", u64Expect, u64Expect, u64Expect);
403
404 return tstTryEx(pDbgc, szCmd, VINF_SUCCESS, false /*fNoExecute*/, szExpected, -1);
405}
406
407
408/*
409 *
410 * CodeView emulation commands.
411 * CodeView emulation commands.
412 * CodeView emulation commands.
413 *
414 */
415
416
417static void testCodeView_ba(PDBGC pDbgc)
418{
419 RTTestISub("codeview - ba");
420 tstTry(pDbgc, "ba x 1 0f000:0000\n", VINF_SUCCESS);
421 tstTry(pDbgc, "ba x 1 0f000:0000 0\n", VINF_SUCCESS);
422 tstTry(pDbgc, "ba x 1 0f000:0000 0 ~0\n", VINF_SUCCESS);
423 tstTry(pDbgc, "ba x 1 0f000:0000 0 ~0 \"command\"\n", VINF_SUCCESS);
424 tstTry(pDbgc, "ba x 1 0f000:0000 0 ~0 \"command\" too_many\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
425 tstTry(pDbgc, "ba x 1\n", VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS);
426
427 tstTryEx(pDbgc, "ba x 1 0f000:1234 5 1000 \"command\"\n", VINF_SUCCESS,
428 true /*fNoExecute*/, NULL /*pszExpected*/, 6 /*cArgs*/,
429 DBGCVAR_TYPE_STRING, "x", DBGCVAR_RANGE_BYTES, UINT64_C(1),
430 DBGCVAR_TYPE_NUMBER, UINT64_C(1), DBGCVAR_RANGE_NONE,
431 DBGCVAR_TYPE_GC_FAR, 0xf000, UINT32_C(0x1234), DBGCVAR_RANGE_NONE,
432 DBGCVAR_TYPE_NUMBER, UINT64_C(0x5), DBGCVAR_RANGE_NONE,
433 DBGCVAR_TYPE_NUMBER, UINT64_C(0x1000), DBGCVAR_RANGE_NONE,
434 DBGCVAR_TYPE_STRING, "command", DBGCVAR_RANGE_BYTES, UINT64_C(7));
435
436 tstTryEx(pDbgc, "ba x 1 %0f000:1234 5 1000 \"command\"\n", VINF_SUCCESS,
437 true /*fNoExecute*/, NULL /*pszExpected*/, 6 /*cArgs*/,
438 DBGCVAR_TYPE_STRING, "x", DBGCVAR_RANGE_BYTES, UINT64_C(1),
439 DBGCVAR_TYPE_NUMBER, UINT64_C(1), DBGCVAR_RANGE_NONE,
440 DBGCVAR_TYPE_GC_FLAT, UINT64_C(0xf1234), DBGCVAR_RANGE_NONE,
441 DBGCVAR_TYPE_NUMBER, UINT64_C(0x5), DBGCVAR_RANGE_NONE,
442 DBGCVAR_TYPE_NUMBER, UINT64_C(0x1000), DBGCVAR_RANGE_NONE,
443 DBGCVAR_TYPE_STRING, "command", DBGCVAR_RANGE_BYTES, UINT64_C(7));
444
445 tstTry(pDbgc, "ba x 1 bad:bad 5 1000 \"command\"\n", VINF_SUCCESS);
446 tstTry(pDbgc, "ba x 1 %bad:bad 5 1000 \"command\"\n", VERR_DBGC_PARSE_CONVERSION_FAILED);
447
448 tstTryEx(pDbgc, "ba f 1 0f000:1234 5 1000 \"command\"\n", VINF_SUCCESS,
449 true /*fNoExecute*/, NULL /*pszExpected*/, 6 /*cArgs*/,
450 DBGCVAR_TYPE_STRING, "f", DBGCVAR_RANGE_BYTES, UINT64_C(1),
451 DBGCVAR_TYPE_NUMBER, UINT64_C(1), DBGCVAR_RANGE_NONE,
452 DBGCVAR_TYPE_GC_FAR, 0xf000, UINT32_C(0x1234), DBGCVAR_RANGE_NONE,
453 DBGCVAR_TYPE_NUMBER, UINT64_C(0x5), DBGCVAR_RANGE_NONE,
454 DBGCVAR_TYPE_NUMBER, UINT64_C(0x1000), DBGCVAR_RANGE_NONE,
455 DBGCVAR_TYPE_STRING, "command", DBGCVAR_RANGE_BYTES, UINT64_C(7));
456
457 tstTry(pDbgc, "ba x 1 0f000:1234 qnx 1000 \"command\"\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
458 tstTry(pDbgc, "ba x 1 0f000:1234 5 qnx \"command\"\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
459 tstTry(pDbgc, "ba x qnx 0f000:1234 5 1000 \"command\"\n", VERR_DBGC_PARSE_INVALID_NUMBER);
460 tstTry(pDbgc, "ba x 1 qnx 5 1000 \"command\"\n", VERR_DBGC_PARSE_INVALID_NUMBER);
461}
462
463
464static void testCodeView_bc(PDBGC pDbgc)
465{
466 RTTestISub("codeview - bc");
467}
468
469
470static void testCodeView_bd(PDBGC pDbgc)
471{
472 RTTestISub("codeview - bc");
473}
474
475
476static void testCodeView_be(PDBGC pDbgc)
477{
478 RTTestISub("codeview - be");
479}
480
481
482static void testCodeView_bl(PDBGC pDbgc)
483{
484 RTTestISub("codeview - bl");
485}
486
487
488static void testCodeView_bp(PDBGC pDbgc)
489{
490 RTTestISub("codeview - bp");
491}
492
493
494static void testCodeView_br(PDBGC pDbgc)
495{
496 RTTestISub("codeview - br");
497}
498
499
500static void testCodeView_d(PDBGC pDbgc)
501{
502 RTTestISub("codeview - d");
503}
504
505
506static void testCodeView_da(PDBGC pDbgc)
507{
508 RTTestISub("codeview - da");
509}
510
511
512static void testCodeView_db(PDBGC pDbgc)
513{
514 RTTestISub("codeview - db");
515}
516
517
518static void testCodeView_dd(PDBGC pDbgc)
519{
520 RTTestISub("codeview - dd");
521}
522
523
524static void testCodeView_dg(PDBGC pDbgc)
525{
526 RTTestISub("codeview - dg");
527}
528
529
530static void testCodeView_dga(PDBGC pDbgc)
531{
532 RTTestISub("codeview - dga");
533}
534
535
536static void testCodeView_di(PDBGC pDbgc)
537{
538 RTTestISub("codeview - di");
539}
540
541
542static void testCodeView_dia(PDBGC pDbgc)
543{
544 RTTestISub("codeview - dia");
545}
546
547
548static void testCodeView_dl(PDBGC pDbgc)
549{
550 RTTestISub("codeview - dl");
551}
552
553
554static void testCodeView_dla(PDBGC pDbgc)
555{
556 RTTestISub("codeview - dla");
557}
558
559
560static void testCodeView_dpd(PDBGC pDbgc)
561{
562 RTTestISub("codeview - dpd");
563}
564
565
566static void testCodeView_dpda(PDBGC pDbgc)
567{
568 RTTestISub("codeview - dpda");
569}
570
571
572static void testCodeView_dpdb(PDBGC pDbgc)
573{
574 RTTestISub("codeview - dpdb");
575}
576
577
578static void testCodeView_dpdg(PDBGC pDbgc)
579{
580 RTTestISub("codeview - dpdg");
581}
582
583
584static void testCodeView_dpdh(PDBGC pDbgc)
585{
586 RTTestISub("codeview - dpdh");
587}
588
589
590static void testCodeView_dph(PDBGC pDbgc)
591{
592 RTTestISub("codeview - dph");
593}
594
595
596static void testCodeView_dphg(PDBGC pDbgc)
597{
598 RTTestISub("codeview - dphg");
599}
600
601
602static void testCodeView_dphh(PDBGC pDbgc)
603{
604 RTTestISub("codeview - dphh");
605}
606
607
608static void testCodeView_dq(PDBGC pDbgc)
609{
610 RTTestISub("codeview - dq");
611}
612
613
614static void testCodeView_dt(PDBGC pDbgc)
615{
616 RTTestISub("codeview - dt");
617}
618
619
620static void testCodeView_dt16(PDBGC pDbgc)
621{
622 RTTestISub("codeview - dt16");
623}
624
625
626static void testCodeView_dt32(PDBGC pDbgc)
627{
628 RTTestISub("codeview - dt32");
629}
630
631
632static void testCodeView_dt64(PDBGC pDbgc)
633{
634 RTTestISub("codeview - dt64");
635}
636
637
638static void testCodeView_dw(PDBGC pDbgc)
639{
640 RTTestISub("codeview - dw");
641}
642
643
644static void testCodeView_eb(PDBGC pDbgc)
645{
646 RTTestISub("codeview - eb");
647}
648
649
650static void testCodeView_ew(PDBGC pDbgc)
651{
652 RTTestISub("codeview - ew");
653}
654
655
656static void testCodeView_ed(PDBGC pDbgc)
657{
658 RTTestISub("codeview - ed");
659}
660
661
662static void testCodeView_eq(PDBGC pDbgc)
663{
664 RTTestISub("codeview - eq");
665}
666
667
668static void testCodeView_g(PDBGC pDbgc)
669{
670 RTTestISub("codeview - g");
671}
672
673
674static void testCodeView_k(PDBGC pDbgc)
675{
676 RTTestISub("codeview - k");
677}
678
679
680static void testCodeView_kg(PDBGC pDbgc)
681{
682 RTTestISub("codeview - kg");
683}
684
685
686static void testCodeView_kh(PDBGC pDbgc)
687{
688 RTTestISub("codeview - kh");
689}
690
691
692static void testCodeView_lm(PDBGC pDbgc)
693{
694 RTTestISub("codeview - lm");
695}
696
697
698static void testCodeView_lmo(PDBGC pDbgc)
699{
700 RTTestISub("codeview - lmo");
701}
702
703
704static void testCodeView_ln(PDBGC pDbgc)
705{
706 RTTestISub("codeview - ln");
707}
708
709
710static void testCodeView_ls(PDBGC pDbgc)
711{
712 RTTestISub("codeview - ls");
713}
714
715
716static void testCodeView_m(PDBGC pDbgc)
717{
718 RTTestISub("codeview - m");
719}
720
721
722static void testCodeView_r(PDBGC pDbgc)
723{
724 RTTestISub("codeview - r");
725}
726
727
728static void testCodeView_rg(PDBGC pDbgc)
729{
730 RTTestISub("codeview - rg");
731}
732
733
734static void testCodeView_rg32(PDBGC pDbgc)
735{
736 RTTestISub("codeview - rg32");
737}
738
739
740static void testCodeView_rg64(PDBGC pDbgc)
741{
742 RTTestISub("codeview - rg64");
743}
744
745
746static void testCodeView_rh(PDBGC pDbgc)
747{
748 RTTestISub("codeview - rh");
749}
750
751
752static void testCodeView_rt(PDBGC pDbgc)
753{
754 RTTestISub("codeview - rt");
755}
756
757
758static void testCodeView_s(PDBGC pDbgc)
759{
760 RTTestISub("codeview - s");
761}
762
763
764static void testCodeView_sa(PDBGC pDbgc)
765{
766 RTTestISub("codeview - sa");
767}
768
769
770static void testCodeView_sb(PDBGC pDbgc)
771{
772 RTTestISub("codeview - sb");
773}
774
775
776static void testCodeView_sd(PDBGC pDbgc)
777{
778 RTTestISub("codeview - sd");
779}
780
781
782static void testCodeView_sq(PDBGC pDbgc)
783{
784 RTTestISub("codeview - sq");
785}
786
787
788static void testCodeView_su(PDBGC pDbgc)
789{
790 RTTestISub("codeview - su");
791}
792
793
794static void testCodeView_sw(PDBGC pDbgc)
795{
796 RTTestISub("codeview - sw");
797}
798
799
800static void testCodeView_t(PDBGC pDbgc)
801{
802 RTTestISub("codeview - t");
803}
804
805
806static void testCodeView_y(PDBGC pDbgc)
807{
808 RTTestISub("codeview - y");
809}
810
811
812static void testCodeView_u64(PDBGC pDbgc)
813{
814 RTTestISub("codeview - u64");
815}
816
817
818static void testCodeView_u32(PDBGC pDbgc)
819{
820 RTTestISub("codeview - u32");
821}
822
823
824static void testCodeView_u16(PDBGC pDbgc)
825{
826 RTTestISub("codeview - u16");
827}
828
829
830static void testCodeView_uv86(PDBGC pDbgc)
831{
832 RTTestISub("codeview - uv86");
833}
834
835
836/*
837 * Common commands.
838 */
839
840static void testCommon_bye_exit_quit(PDBGC pDbgc)
841{
842 RTTestISub("common - bye/exit/quit");
843 /* These have the same parameter descriptor and handler, the command really
844 just has a couple of aliases.*/
845 tstTry(pDbgc, "bye\n", VINF_SUCCESS);
846 tstTry(pDbgc, "bye x\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
847 tstTry(pDbgc, "bye 1\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
848 tstTry(pDbgc, "bye %bad:bad\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
849 tstTry(pDbgc, "exit\n", VINF_SUCCESS);
850 tstTry(pDbgc, "quit\n", VINF_SUCCESS);
851}
852
853
854static void testCommon_cpu(PDBGC pDbgc)
855{
856 RTTestISub("common - cpu");
857 tstTry(pDbgc, "cpu\n", VINF_SUCCESS);
858 tstTry(pDbgc, "cpu 1\n", VINF_SUCCESS);
859 tstTry(pDbgc, "cpu 1 1\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
860 tstTry(pDbgc, "cpu emt\n", VERR_DBGC_PARSE_INVALID_NUMBER);
861 tstTry(pDbgc, "cpu @eax\n", VINF_SUCCESS);
862 tstTry(pDbgc, "cpu %bad:bad\n", VERR_DBGC_PARSE_CONVERSION_FAILED);
863 tstTry(pDbgc, "cpu '1'\n", VERR_DBGC_PARSE_INVALID_NUMBER);
864}
865
866
867static void testCommon_echo(PDBGC pDbgc)
868{
869 RTTestISub("common - echo");
870 tstTry(pDbgc, "echo\n", VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS);
871 tstTry(pDbgc, "echo 1\n", VINF_SUCCESS);
872 tstTryEx(pDbgc, "echo 1 2 3 4 5 6\n", VINF_SUCCESS, false, "1 2 3 4 5 6", -1);
873
874 /* The idea here is that since the prefered input is a string, we
875 definitely won't be confused by the number like beginning. */
876 tstTryEx(pDbgc, "echo 1234567890abcdefghijklmn\n", VINF_SUCCESS, false, "1234567890abcdefghijklmn", -1);
877
878 /* The idea here is that we'll perform the + operation and then convert the
879 result to a string (hex). */
880 tstTryEx(pDbgc, "echo 1 + 1\n", VINF_SUCCESS, false, "2", -1);
881 tstTryEx(pDbgc, "echo \"1 + 1\"\n", VINF_SUCCESS, false, "1 + 1", -1);
882
883 tstTryEx(pDbgc, "echo 0i10 + 6\n", VINF_SUCCESS, false, "10", -1);
884 tstTryEx(pDbgc, "echo \"0i10 + 6\"\n", VINF_SUCCESS, false, "0i10 + 6", -1);
885
886 tstTryEx(pDbgc, "echo %f000:0010\n", VINF_SUCCESS, false, "%00000000000f0010", -1);
887 tstTryEx(pDbgc, "echo \"%f000:0010\"\n", VINF_SUCCESS, false, "%f000:0010", -1);
888
889 tstTry(pDbgc, "echo %bad:bad\n", VERR_DBGC_PARSE_CONVERSION_FAILED);
890}
891
892
893static void testCommon_format(PDBGC pDbgc)
894{
895 RTTestISub("common - format");
896}
897
898
899static void testCommon_detect(PDBGC pDbgc)
900{
901 RTTestISub("common - detect");
902}
903
904
905static void testCommon_harakiri(PDBGC pDbgc)
906{
907 RTTestISub("common - harakiri");
908}
909
910
911static void testCommon_help(PDBGC pDbgc)
912{
913 RTTestISub("common - help");
914}
915
916
917static void testCommon_info(PDBGC pDbgc)
918{
919 RTTestISub("common - info");
920 tstTry(pDbgc, "info 12fg\n", VINF_SUCCESS);
921 tstTry(pDbgc, "info fflags argument\n", VINF_SUCCESS);
922}
923
924
925static void testCommon_loadimage(PDBGC pDbgc)
926{
927 RTTestISub("common - loadimage");
928}
929
930
931static void testCommon_loadmap(PDBGC pDbgc)
932{
933 RTTestISub("common - loadmap");
934}
935
936
937static void testCommon_loadplugin(PDBGC pDbgc)
938{
939 RTTestISub("common - loadplugin");
940}
941
942
943static void testCommon_loadseg(PDBGC pDbgc)
944{
945 RTTestISub("common - loadseg");
946}
947
948
949static void testCommon_loadsyms(PDBGC pDbgc)
950{
951 RTTestISub("common - loadsyms");
952}
953
954
955static void testCommon_loadvars(PDBGC pDbgc)
956{
957 RTTestISub("common - loadvars");
958}
959
960
961static void testCommon_log(PDBGC pDbgc)
962{
963 RTTestISub("common - log");
964}
965
966
967static void testCommon_logdest(PDBGC pDbgc)
968{
969 RTTestISub("common - logdest");
970}
971
972
973static void testCommon_logflags(PDBGC pDbgc)
974{
975 RTTestISub("common - logflags");
976}
977
978
979static void testCommon_runscript(PDBGC pDbgc)
980{
981 RTTestISub("common - runscript");
982}
983
984
985static void testCommon_set(PDBGC pDbgc)
986{
987 RTTestISub("common - set");
988}
989
990
991static void testCommon_showplugins(PDBGC pDbgc)
992{
993 RTTestISub("common - showplugins");
994}
995
996
997static void testCommon_showvars(PDBGC pDbgc)
998{
999 RTTestISub("common - showvars");
1000}
1001
1002
1003static void testCommon_stop(PDBGC pDbgc)
1004{
1005 RTTestISub("common - stop");
1006}
1007
1008
1009static void testCommon_unloadplugin(PDBGC pDbgc)
1010{
1011 RTTestISub("common - unloadplugin");
1012}
1013
1014
1015static void testCommon_unset(PDBGC pDbgc)
1016{
1017 RTTestISub("common - unset");
1018}
1019
1020
1021static void testCommon_writecore(PDBGC pDbgc)
1022{
1023 RTTestISub("common - writecore");
1024}
1025
1026
1027
1028/*
1029 * Basic tests.
1030 */
1031
1032static void testBasicsOddCases(PDBGC pDbgc)
1033{
1034 RTTestISub("Odd cases");
1035 tstTry(pDbgc, "r @rax\n", VINF_SUCCESS);
1036 tstTry(pDbgc, "r @eax\n", VINF_SUCCESS);
1037 tstTry(pDbgc, "r @ah\n", VINF_SUCCESS);
1038 tstTry(pDbgc, "r @notavalidregister\n", VERR_DBGF_REGISTER_NOT_FOUND);
1039}
1040
1041
1042static void testBasicsOperators(PDBGC pDbgc)
1043{
1044 RTTestISub("Operators");
1045 tstNumOp(pDbgc, "1", 1);
1046 tstNumOp(pDbgc, "1", 1);
1047 tstNumOp(pDbgc, "1", 1);
1048
1049 tstNumOp(pDbgc, "+1", 1);
1050 tstNumOp(pDbgc, "++++++1", 1);
1051
1052 tstNumOp(pDbgc, "-1", UINT64_MAX);
1053 tstNumOp(pDbgc, "--1", 1);
1054 tstNumOp(pDbgc, "---1", UINT64_MAX);
1055 tstNumOp(pDbgc, "----1", 1);
1056
1057 tstNumOp(pDbgc, "~0", UINT64_MAX);
1058 tstNumOp(pDbgc, "~1", UINT64_MAX-1);
1059 tstNumOp(pDbgc, "~~0", 0);
1060 tstNumOp(pDbgc, "~~1", 1);
1061
1062 tstNumOp(pDbgc, "!1", 0);
1063 tstNumOp(pDbgc, "!0", 1);
1064 tstNumOp(pDbgc, "!42", 0);
1065 tstNumOp(pDbgc, "!!42", 1);
1066 tstNumOp(pDbgc, "!!!42", 0);
1067 tstNumOp(pDbgc, "!!!!42", 1);
1068
1069 tstNumOp(pDbgc, "1 +1", 2);
1070 tstNumOp(pDbgc, "1 + 1", 2);
1071 tstNumOp(pDbgc, "1+1", 2);
1072 tstNumOp(pDbgc, "1+ 1", 2);
1073
1074 tstNumOp(pDbgc, "1 - 1", 0);
1075 tstNumOp(pDbgc, "99 - 90", 9);
1076
1077 tstNumOp(pDbgc, "2 * 2", 4);
1078
1079 tstNumOp(pDbgc, "2 / 2", 1);
1080 tstNumOp(pDbgc, "2 / 0", UINT64_MAX);
1081 tstNumOp(pDbgc, "0i1024 / 0i4", 256);
1082
1083 tstNumOp(pDbgc, "8 mod 7", 1);
1084
1085 tstNumOp(pDbgc, "1<<1", 2);
1086 tstNumOp(pDbgc, "1<<0i32", UINT64_C(0x0000000100000000));
1087 tstNumOp(pDbgc, "1<<0i48", UINT64_C(0x0001000000000000));
1088 tstNumOp(pDbgc, "1<<0i63", UINT64_C(0x8000000000000000));
1089
1090 tstNumOp(pDbgc, "fedcba0987654321>>0i04", UINT64_C(0x0fedcba098765432));
1091 tstNumOp(pDbgc, "fedcba0987654321>>0i32", UINT64_C(0xfedcba09));
1092 tstNumOp(pDbgc, "fedcba0987654321>>0i48", UINT64_C(0x0000fedc));
1093
1094 tstNumOp(pDbgc, "0ef & 4", 4);
1095 tstNumOp(pDbgc, "01234567891 & fff", UINT64_C(0x00000000891));
1096 tstNumOp(pDbgc, "01234567891 & ~fff", UINT64_C(0x01234567000));
1097
1098 tstNumOp(pDbgc, "1 | 1", 1);
1099 tstNumOp(pDbgc, "0 | 4", 4);
1100 tstNumOp(pDbgc, "4 | 0", 4);
1101 tstNumOp(pDbgc, "4 | 4", 4);
1102 tstNumOp(pDbgc, "1 | 4 | 2", 7);
1103
1104 tstNumOp(pDbgc, "1 ^ 1", 0);
1105 tstNumOp(pDbgc, "1 ^ 0", 1);
1106 tstNumOp(pDbgc, "0 ^ 1", 1);
1107 tstNumOp(pDbgc, "3 ^ 1", 2);
1108 tstNumOp(pDbgc, "7 ^ 3", 4);
1109
1110 tstNumOp(pDbgc, "7 || 3", 1);
1111 tstNumOp(pDbgc, "1 || 0", 1);
1112 tstNumOp(pDbgc, "0 || 1", 1);
1113 tstNumOp(pDbgc, "0 || 0", 0);
1114
1115 tstNumOp(pDbgc, "0 && 0", 0);
1116 tstNumOp(pDbgc, "1 && 0", 0);
1117 tstNumOp(pDbgc, "0 && 1", 0);
1118 tstNumOp(pDbgc, "1 && 1", 1);
1119 tstNumOp(pDbgc, "4 && 1", 1);
1120}
1121
1122
1123static void testBasicsFundametalParsing(PDBGC pDbgc)
1124{
1125 RTTestISub("Fundamental parsing");
1126 tstTry(pDbgc, "stop\n", VINF_SUCCESS);
1127 tstTry(pDbgc, "format 1\n", VINF_SUCCESS);
1128 tstTry(pDbgc, "format \n", VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS);
1129 tstTry(pDbgc, "format 0 1 23 4\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
1130 tstTry(pDbgc, "format 'x'\n", VINF_SUCCESS);
1131 tstTry(pDbgc, "format 'x' 'x'\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
1132 tstTry(pDbgc, "format 'x''x'\n", VINF_SUCCESS);
1133 tstTry(pDbgc, "format 'x'\"x\"\n", VERR_DBGC_PARSE_EXPECTED_BINARY_OP);
1134 tstTry(pDbgc, "format 'x'1\n", VERR_DBGC_PARSE_EXPECTED_BINARY_OP);
1135 tstTry(pDbgc, "format (1)1\n", VERR_DBGC_PARSE_EXPECTED_BINARY_OP);
1136 tstTry(pDbgc, "format (1)(1)\n", VERR_DBGC_PARSE_EXPECTED_BINARY_OP);
1137 tstTry(pDbgc, "format (1)''\n", VERR_DBGC_PARSE_EXPECTED_BINARY_OP);
1138 tstTry(pDbgc, "format nosuchfunction(1)\n", VERR_DBGC_PARSE_FUNCTION_NOT_FOUND);
1139 tstTry(pDbgc, "format nosuchfunction(1,2,3)\n", VERR_DBGC_PARSE_FUNCTION_NOT_FOUND);
1140 tstTry(pDbgc, "format nosuchfunction()\n", VERR_DBGC_PARSE_FUNCTION_NOT_FOUND);
1141 tstTry(pDbgc, "format randu32()\n", VINF_SUCCESS);
1142 tstTryEx(pDbgc, "format %0\n", VINF_SUCCESS, false, "Guest flat address: %00000000", -1);
1143 tstTryEx(pDbgc, "format %eax\n", VINF_SUCCESS, false, "Guest flat address: %cafebabe", -1);
1144 tstTry(pDbgc, "sa 3 23 4 'q' \"21123123\" 'b' \n", VINF_SUCCESS);
1145 tstTry(pDbgc, "sa 3,23, 4,'q' ,\"21123123\" , 'b' \n", VINF_SUCCESS);
1146}
1147
1148
1149int main()
1150{
1151 /*
1152 * Init.
1153 */
1154 int rc = RTTestInitAndCreate("tstDBGCParser", &g_hTest);
1155 if (rc)
1156 return rc;
1157 RTTestBanner(g_hTest);
1158
1159 /*
1160 * Create a DBGC instance.
1161 */
1162 RTTestSub(g_hTest, "dbgcCreate");
1163 PDBGC pDbgc;
1164 rc = dbgcCreate(&pDbgc, &g_tstBack, 0);
1165 if (RT_SUCCESS(rc))
1166 {
1167 pDbgc->pVM = (PVM)pDbgc;
1168 rc = dbgcProcessInput(pDbgc, true /* fNoExecute */);
1169 tstCompleteOutput();
1170 if (RT_SUCCESS(rc))
1171 {
1172 /*
1173 * Perform basic tests first.
1174 */
1175 testBasicsFundametalParsing(pDbgc);
1176 if (RTTestErrorCount(g_hTest) == 0)
1177 testBasicsOperators(pDbgc);
1178 if (RTTestErrorCount(g_hTest) == 0)
1179 testBasicsOddCases(pDbgc);
1180
1181 /*
1182 * Test commands.
1183 */
1184 if (RTTestErrorCount(g_hTest) == 0)
1185 {
1186 testCodeView_ba(pDbgc);
1187 testCodeView_bc(pDbgc);
1188 testCodeView_bd(pDbgc);
1189 testCodeView_be(pDbgc);
1190 testCodeView_bl(pDbgc);
1191 testCodeView_bp(pDbgc);
1192 testCodeView_br(pDbgc);
1193 testCodeView_d(pDbgc);
1194 testCodeView_da(pDbgc);
1195 testCodeView_db(pDbgc);
1196 testCodeView_dd(pDbgc);
1197 testCodeView_dg(pDbgc);
1198 testCodeView_dga(pDbgc);
1199 testCodeView_di(pDbgc);
1200 testCodeView_dia(pDbgc);
1201 testCodeView_dl(pDbgc);
1202 testCodeView_dla(pDbgc);
1203 testCodeView_dpd(pDbgc);
1204 testCodeView_dpda(pDbgc);
1205 testCodeView_dpdb(pDbgc);
1206 testCodeView_dpdg(pDbgc);
1207 testCodeView_dpdh(pDbgc);
1208 testCodeView_dph(pDbgc);
1209 testCodeView_dphg(pDbgc);
1210 testCodeView_dphh(pDbgc);
1211 testCodeView_dq(pDbgc);
1212 testCodeView_dt(pDbgc);
1213 testCodeView_dt16(pDbgc);
1214 testCodeView_dt32(pDbgc);
1215 testCodeView_dt64(pDbgc);
1216 testCodeView_dw(pDbgc);
1217 testCodeView_eb(pDbgc);
1218 testCodeView_ew(pDbgc);
1219 testCodeView_ed(pDbgc);
1220 testCodeView_eq(pDbgc);
1221 testCodeView_g(pDbgc);
1222 testCodeView_k(pDbgc);
1223 testCodeView_kg(pDbgc);
1224 testCodeView_kh(pDbgc);
1225 testCodeView_lm(pDbgc);
1226 testCodeView_lmo(pDbgc);
1227 testCodeView_ln(pDbgc);
1228 testCodeView_ls(pDbgc);
1229 testCodeView_m(pDbgc);
1230 testCodeView_r(pDbgc);
1231 testCodeView_rg(pDbgc);
1232 testCodeView_rg32(pDbgc);
1233 testCodeView_rg64(pDbgc);
1234 testCodeView_rh(pDbgc);
1235 testCodeView_rt(pDbgc);
1236 testCodeView_s(pDbgc);
1237 testCodeView_sa(pDbgc);
1238 testCodeView_sb(pDbgc);
1239 testCodeView_sd(pDbgc);
1240 testCodeView_sq(pDbgc);
1241 testCodeView_su(pDbgc);
1242 testCodeView_sw(pDbgc);
1243 testCodeView_t(pDbgc);
1244 testCodeView_y(pDbgc);
1245 testCodeView_u64(pDbgc);
1246 testCodeView_u32(pDbgc);
1247 testCodeView_u16(pDbgc);
1248 testCodeView_uv86(pDbgc);
1249
1250 testCommon_bye_exit_quit(pDbgc);
1251 testCommon_cpu(pDbgc);
1252 testCommon_echo(pDbgc);
1253 testCommon_format(pDbgc);
1254 testCommon_detect(pDbgc);
1255 testCommon_harakiri(pDbgc);
1256 testCommon_help(pDbgc);
1257 testCommon_info(pDbgc);
1258 testCommon_loadimage(pDbgc);
1259 testCommon_loadmap(pDbgc);
1260 testCommon_loadplugin(pDbgc);
1261 testCommon_loadseg(pDbgc);
1262 testCommon_loadsyms(pDbgc);
1263 testCommon_loadvars(pDbgc);
1264 testCommon_log(pDbgc);
1265 testCommon_logdest(pDbgc);
1266 testCommon_logflags(pDbgc);
1267 testCommon_runscript(pDbgc);
1268 testCommon_set(pDbgc);
1269 testCommon_showplugins(pDbgc);
1270 testCommon_showvars(pDbgc);
1271 testCommon_stop(pDbgc);
1272 testCommon_unloadplugin(pDbgc);
1273 testCommon_unset(pDbgc);
1274 testCommon_writecore(pDbgc);
1275 }
1276 }
1277
1278 dbgcDestroy(pDbgc);
1279 }
1280
1281 /*
1282 * Summary
1283 */
1284 return RTTestSummaryAndDestroy(g_hTest);
1285}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette