1 /* 2 * QTest 3 * 4 * Copyright IBM, Corp. 2012 5 * Copyright Red Hat, Inc. 2012 6 * Copyright SUSE LINUX Products GmbH 2013 7 * 8 * Authors: 9 * Anthony Liguori <aliguori@us.ibm.com> 10 * Paolo Bonzini <pbonzini@redhat.com> 11 * Andreas Färber <afaerber@suse.de> 12 * 13 * This work is licensed under the terms of the GNU GPL, version 2 or later. 14 * See the COPYING file in the top-level directory. 15 * 16 */ 17 #ifndef LIBQTEST_H 18 #define LIBQTEST_H 19 20 #include "qapi/qmp/qobject.h" 21 #include "qapi/qmp/qdict.h" 22 23 typedef struct QTestState QTestState; 24 25 /** 26 * qtest_initf: 27 * @fmt...: Format for creating other arguments to pass to QEMU, formatted 28 * like sprintf(). 29 * 30 * Convenience wrapper around qtest_init(). 31 * 32 * Returns: #QTestState instance. 33 */ 34 QTestState *qtest_initf(const char *fmt, ...) GCC_FMT_ATTR(1, 2); 35 36 /** 37 * qtest_vinitf: 38 * @fmt: Format for creating other arguments to pass to QEMU, formatted 39 * like vsprintf(). 40 * @ap: Format arguments. 41 * 42 * Convenience wrapper around qtest_init(). 43 * 44 * Returns: #QTestState instance. 45 */ 46 QTestState *qtest_vinitf(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0); 47 48 /** 49 * qtest_init: 50 * @extra_args: other arguments to pass to QEMU. CAUTION: these 51 * arguments are subject to word splitting and shell evaluation. 52 * 53 * Returns: #QTestState instance. 54 */ 55 QTestState *qtest_init(const char *extra_args); 56 57 /** 58 * qtest_init_without_qmp_handshake: 59 * @extra_args: other arguments to pass to QEMU. CAUTION: these 60 * arguments are subject to word splitting and shell evaluation. 61 * 62 * Returns: #QTestState instance. 63 */ 64 QTestState *qtest_init_without_qmp_handshake(const char *extra_args); 65 66 /** 67 * qtest_init_with_serial: 68 * @extra_args: other arguments to pass to QEMU. CAUTION: these 69 * arguments are subject to word splitting and shell evaluation. 70 * @sock_fd: pointer to store the socket file descriptor for 71 * connection with serial. 72 * 73 * Returns: #QTestState instance. 74 */ 75 QTestState *qtest_init_with_serial(const char *extra_args, int *sock_fd); 76 77 /** 78 * qtest_quit: 79 * @s: #QTestState instance to operate on. 80 * 81 * Shut down the QEMU process associated to @s. 82 */ 83 void qtest_quit(QTestState *s); 84 85 /** 86 * qtest_qmp_fds: 87 * @s: #QTestState instance to operate on. 88 * @fds: array of file descriptors 89 * @fds_num: number of elements in @fds 90 * @fmt...: QMP message to send to qemu, formatted like 91 * qobject_from_jsonf_nofail(). See parse_escape() for what's 92 * supported after '%'. 93 * 94 * Sends a QMP message to QEMU with fds and returns the response. 95 */ 96 QDict *qtest_qmp_fds(QTestState *s, int *fds, size_t fds_num, 97 const char *fmt, ...) 98 GCC_FMT_ATTR(4, 5); 99 100 /** 101 * qtest_qmp: 102 * @s: #QTestState instance to operate on. 103 * @fmt...: QMP message to send to qemu, formatted like 104 * qobject_from_jsonf_nofail(). See parse_escape() for what's 105 * supported after '%'. 106 * 107 * Sends a QMP message to QEMU and returns the response. 108 */ 109 QDict *qtest_qmp(QTestState *s, const char *fmt, ...) 110 GCC_FMT_ATTR(2, 3); 111 112 /** 113 * qtest_qmp_send: 114 * @s: #QTestState instance to operate on. 115 * @fmt...: QMP message to send to qemu, formatted like 116 * qobject_from_jsonf_nofail(). See parse_escape() for what's 117 * supported after '%'. 118 * 119 * Sends a QMP message to QEMU and leaves the response in the stream. 120 */ 121 void qtest_qmp_send(QTestState *s, const char *fmt, ...) 122 GCC_FMT_ATTR(2, 3); 123 124 /** 125 * qtest_qmp_send_raw: 126 * @s: #QTestState instance to operate on. 127 * @fmt...: text to send, formatted like sprintf() 128 * 129 * Sends text to the QMP monitor verbatim. Need not be valid JSON; 130 * this is useful for negative tests. 131 */ 132 void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...) 133 GCC_FMT_ATTR(2, 3); 134 135 /** 136 * qtest_vqmp_fds: 137 * @s: #QTestState instance to operate on. 138 * @fds: array of file descriptors 139 * @fds_num: number of elements in @fds 140 * @fmt: QMP message to send to QEMU, formatted like 141 * qobject_from_jsonf_nofail(). See parse_escape() for what's 142 * supported after '%'. 143 * @ap: QMP message arguments 144 * 145 * Sends a QMP message to QEMU with fds and returns the response. 146 */ 147 QDict *qtest_vqmp_fds(QTestState *s, int *fds, size_t fds_num, 148 const char *fmt, va_list ap) 149 GCC_FMT_ATTR(4, 0); 150 151 /** 152 * qtest_vqmp: 153 * @s: #QTestState instance to operate on. 154 * @fmt: QMP message to send to QEMU, formatted like 155 * qobject_from_jsonf_nofail(). See parse_escape() for what's 156 * supported after '%'. 157 * @ap: QMP message arguments 158 * 159 * Sends a QMP message to QEMU and returns the response. 160 */ 161 QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap) 162 GCC_FMT_ATTR(2, 0); 163 164 /** 165 * qtest_qmp_vsend_fds: 166 * @s: #QTestState instance to operate on. 167 * @fds: array of file descriptors 168 * @fds_num: number of elements in @fds 169 * @fmt: QMP message to send to QEMU, formatted like 170 * qobject_from_jsonf_nofail(). See parse_escape() for what's 171 * supported after '%'. 172 * @ap: QMP message arguments 173 * 174 * Sends a QMP message to QEMU and leaves the response in the stream. 175 */ 176 void qtest_qmp_vsend_fds(QTestState *s, int *fds, size_t fds_num, 177 const char *fmt, va_list ap) 178 GCC_FMT_ATTR(4, 0); 179 180 /** 181 * qtest_qmp_vsend: 182 * @s: #QTestState instance to operate on. 183 * @fmt: QMP message to send to QEMU, formatted like 184 * qobject_from_jsonf_nofail(). See parse_escape() for what's 185 * supported after '%'. 186 * @ap: QMP message arguments 187 * 188 * Sends a QMP message to QEMU and leaves the response in the stream. 189 */ 190 void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap) 191 GCC_FMT_ATTR(2, 0); 192 193 /** 194 * qtest_receive: 195 * @s: #QTestState instance to operate on. 196 * 197 * Reads a QMP message from QEMU and returns the response. 198 */ 199 QDict *qtest_qmp_receive(QTestState *s); 200 201 /** 202 * qtest_qmp_eventwait: 203 * @s: #QTestState instance to operate on. 204 * @s: #event event to wait for. 205 * 206 * Continuously polls for QMP responses until it receives the desired event. 207 */ 208 void qtest_qmp_eventwait(QTestState *s, const char *event); 209 210 /** 211 * qtest_qmp_eventwait_ref: 212 * @s: #QTestState instance to operate on. 213 * @s: #event event to wait for. 214 * 215 * Continuously polls for QMP responses until it receives the desired event. 216 * Returns a copy of the event for further investigation. 217 */ 218 QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event); 219 220 /** 221 * qtest_qmp_receive_success: 222 * @s: #QTestState instance to operate on 223 * @event_cb: Event callback 224 * @opaque: Argument for @event_cb 225 * 226 * Poll QMP messages until a command success response is received. 227 * If @event_cb, call it for each event received, passing @opaque, 228 * the event's name and data. 229 * Return the success response's "return" member. 230 */ 231 QDict *qtest_qmp_receive_success(QTestState *s, 232 void (*event_cb)(void *opaque, 233 const char *name, 234 QDict *data), 235 void *opaque); 236 237 /** 238 * qtest_hmp: 239 * @s: #QTestState instance to operate on. 240 * @fmt...: HMP command to send to QEMU, formats arguments like sprintf(). 241 * 242 * Send HMP command to QEMU via QMP's human-monitor-command. 243 * QMP events are discarded. 244 * 245 * Returns: the command's output. The caller should g_free() it. 246 */ 247 char *qtest_hmp(QTestState *s, const char *fmt, ...) GCC_FMT_ATTR(2, 3); 248 249 /** 250 * qtest_hmpv: 251 * @s: #QTestState instance to operate on. 252 * @fmt: HMP command to send to QEMU, formats arguments like vsprintf(). 253 * @ap: HMP command arguments 254 * 255 * Send HMP command to QEMU via QMP's human-monitor-command. 256 * QMP events are discarded. 257 * 258 * Returns: the command's output. The caller should g_free() it. 259 */ 260 char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap) 261 GCC_FMT_ATTR(2, 0); 262 263 void qtest_module_load(QTestState *s, const char *prefix, const char *libname); 264 265 /** 266 * qtest_get_irq: 267 * @s: #QTestState instance to operate on. 268 * @num: Interrupt to observe. 269 * 270 * Returns: The level of the @num interrupt. 271 */ 272 bool qtest_get_irq(QTestState *s, int num); 273 274 /** 275 * qtest_irq_intercept_in: 276 * @s: #QTestState instance to operate on. 277 * @string: QOM path of a device. 278 * 279 * Associate qtest irqs with the GPIO-in pins of the device 280 * whose path is specified by @string. 281 */ 282 void qtest_irq_intercept_in(QTestState *s, const char *string); 283 284 /** 285 * qtest_irq_intercept_out: 286 * @s: #QTestState instance to operate on. 287 * @string: QOM path of a device. 288 * 289 * Associate qtest irqs with the GPIO-out pins of the device 290 * whose path is specified by @string. 291 */ 292 void qtest_irq_intercept_out(QTestState *s, const char *string); 293 294 /** 295 * qtest_set_irq_in: 296 * @s: QTestState instance to operate on. 297 * @string: QOM path of a device 298 * @name: IRQ name 299 * @irq: IRQ number 300 * @level: IRQ level 301 * 302 * Force given device/irq GPIO-in pin to the given level. 303 */ 304 void qtest_set_irq_in(QTestState *s, const char *string, const char *name, 305 int irq, int level); 306 307 /** 308 * qtest_outb: 309 * @s: #QTestState instance to operate on. 310 * @addr: I/O port to write to. 311 * @value: Value being written. 312 * 313 * Write an 8-bit value to an I/O port. 314 */ 315 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value); 316 317 /** 318 * qtest_outw: 319 * @s: #QTestState instance to operate on. 320 * @addr: I/O port to write to. 321 * @value: Value being written. 322 * 323 * Write a 16-bit value to an I/O port. 324 */ 325 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value); 326 327 /** 328 * qtest_outl: 329 * @s: #QTestState instance to operate on. 330 * @addr: I/O port to write to. 331 * @value: Value being written. 332 * 333 * Write a 32-bit value to an I/O port. 334 */ 335 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value); 336 337 /** 338 * qtest_inb: 339 * @s: #QTestState instance to operate on. 340 * @addr: I/O port to read from. 341 * 342 * Returns an 8-bit value from an I/O port. 343 */ 344 uint8_t qtest_inb(QTestState *s, uint16_t addr); 345 346 /** 347 * qtest_inw: 348 * @s: #QTestState instance to operate on. 349 * @addr: I/O port to read from. 350 * 351 * Returns a 16-bit value from an I/O port. 352 */ 353 uint16_t qtest_inw(QTestState *s, uint16_t addr); 354 355 /** 356 * qtest_inl: 357 * @s: #QTestState instance to operate on. 358 * @addr: I/O port to read from. 359 * 360 * Returns a 32-bit value from an I/O port. 361 */ 362 uint32_t qtest_inl(QTestState *s, uint16_t addr); 363 364 /** 365 * qtest_writeb: 366 * @s: #QTestState instance to operate on. 367 * @addr: Guest address to write to. 368 * @value: Value being written. 369 * 370 * Writes an 8-bit value to memory. 371 */ 372 void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value); 373 374 /** 375 * qtest_writew: 376 * @s: #QTestState instance to operate on. 377 * @addr: Guest address to write to. 378 * @value: Value being written. 379 * 380 * Writes a 16-bit value to memory. 381 */ 382 void qtest_writew(QTestState *s, uint64_t addr, uint16_t value); 383 384 /** 385 * qtest_writel: 386 * @s: #QTestState instance to operate on. 387 * @addr: Guest address to write to. 388 * @value: Value being written. 389 * 390 * Writes a 32-bit value to memory. 391 */ 392 void qtest_writel(QTestState *s, uint64_t addr, uint32_t value); 393 394 /** 395 * qtest_writeq: 396 * @s: #QTestState instance to operate on. 397 * @addr: Guest address to write to. 398 * @value: Value being written. 399 * 400 * Writes a 64-bit value to memory. 401 */ 402 void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value); 403 404 /** 405 * qtest_readb: 406 * @s: #QTestState instance to operate on. 407 * @addr: Guest address to read from. 408 * 409 * Reads an 8-bit value from memory. 410 * 411 * Returns: Value read. 412 */ 413 uint8_t qtest_readb(QTestState *s, uint64_t addr); 414 415 /** 416 * qtest_readw: 417 * @s: #QTestState instance to operate on. 418 * @addr: Guest address to read from. 419 * 420 * Reads a 16-bit value from memory. 421 * 422 * Returns: Value read. 423 */ 424 uint16_t qtest_readw(QTestState *s, uint64_t addr); 425 426 /** 427 * qtest_readl: 428 * @s: #QTestState instance to operate on. 429 * @addr: Guest address to read from. 430 * 431 * Reads a 32-bit value from memory. 432 * 433 * Returns: Value read. 434 */ 435 uint32_t qtest_readl(QTestState *s, uint64_t addr); 436 437 /** 438 * qtest_readq: 439 * @s: #QTestState instance to operate on. 440 * @addr: Guest address to read from. 441 * 442 * Reads a 64-bit value from memory. 443 * 444 * Returns: Value read. 445 */ 446 uint64_t qtest_readq(QTestState *s, uint64_t addr); 447 448 /** 449 * qtest_memread: 450 * @s: #QTestState instance to operate on. 451 * @addr: Guest address to read from. 452 * @data: Pointer to where memory contents will be stored. 453 * @size: Number of bytes to read. 454 * 455 * Read guest memory into a buffer. 456 */ 457 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size); 458 459 /** 460 * qtest_rtas_call: 461 * @s: #QTestState instance to operate on. 462 * @name: name of the command to call. 463 * @nargs: Number of args. 464 * @args: Guest address to read args from. 465 * @nret: Number of return value. 466 * @ret: Guest address to write return values to. 467 * 468 * Call an RTAS function 469 */ 470 uint64_t qtest_rtas_call(QTestState *s, const char *name, 471 uint32_t nargs, uint64_t args, 472 uint32_t nret, uint64_t ret); 473 474 /** 475 * qtest_bufread: 476 * @s: #QTestState instance to operate on. 477 * @addr: Guest address to read from. 478 * @data: Pointer to where memory contents will be stored. 479 * @size: Number of bytes to read. 480 * 481 * Read guest memory into a buffer and receive using a base64 encoding. 482 */ 483 void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size); 484 485 /** 486 * qtest_memwrite: 487 * @s: #QTestState instance to operate on. 488 * @addr: Guest address to write to. 489 * @data: Pointer to the bytes that will be written to guest memory. 490 * @size: Number of bytes to write. 491 * 492 * Write a buffer to guest memory. 493 */ 494 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size); 495 496 /** 497 * qtest_bufwrite: 498 * @s: #QTestState instance to operate on. 499 * @addr: Guest address to write to. 500 * @data: Pointer to the bytes that will be written to guest memory. 501 * @size: Number of bytes to write. 502 * 503 * Write a buffer to guest memory and transmit using a base64 encoding. 504 */ 505 void qtest_bufwrite(QTestState *s, uint64_t addr, 506 const void *data, size_t size); 507 508 /** 509 * qtest_memset: 510 * @s: #QTestState instance to operate on. 511 * @addr: Guest address to write to. 512 * @patt: Byte pattern to fill the guest memory region with. 513 * @size: Number of bytes to write. 514 * 515 * Write a pattern to guest memory. 516 */ 517 void qtest_memset(QTestState *s, uint64_t addr, uint8_t patt, size_t size); 518 519 /** 520 * qtest_clock_step_next: 521 * @s: #QTestState instance to operate on. 522 * 523 * Advance the QEMU_CLOCK_VIRTUAL to the next deadline. 524 * 525 * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds. 526 */ 527 int64_t qtest_clock_step_next(QTestState *s); 528 529 /** 530 * qtest_clock_step: 531 * @s: QTestState instance to operate on. 532 * @step: Number of nanoseconds to advance the clock by. 533 * 534 * Advance the QEMU_CLOCK_VIRTUAL by @step nanoseconds. 535 * 536 * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds. 537 */ 538 int64_t qtest_clock_step(QTestState *s, int64_t step); 539 540 /** 541 * qtest_clock_set: 542 * @s: QTestState instance to operate on. 543 * @val: Nanoseconds value to advance the clock to. 544 * 545 * Advance the QEMU_CLOCK_VIRTUAL to @val nanoseconds since the VM was launched. 546 * 547 * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds. 548 */ 549 int64_t qtest_clock_set(QTestState *s, int64_t val); 550 551 /** 552 * qtest_big_endian: 553 * @s: QTestState instance to operate on. 554 * 555 * Returns: True if the architecture under test has a big endian configuration. 556 */ 557 bool qtest_big_endian(QTestState *s); 558 559 /** 560 * qtest_get_arch: 561 * 562 * Returns: The architecture for the QEMU executable under test. 563 */ 564 const char *qtest_get_arch(void); 565 566 /** 567 * qtest_add_func: 568 * @str: Test case path. 569 * @fn: Test case function 570 * 571 * Add a GTester testcase with the given name and function. 572 * The path is prefixed with the architecture under test, as 573 * returned by qtest_get_arch(). 574 */ 575 void qtest_add_func(const char *str, void (*fn)(void)); 576 577 /** 578 * qtest_add_data_func: 579 * @str: Test case path. 580 * @data: Test case data 581 * @fn: Test case function 582 * 583 * Add a GTester testcase with the given name, data and function. 584 * The path is prefixed with the architecture under test, as 585 * returned by qtest_get_arch(). 586 */ 587 void qtest_add_data_func(const char *str, const void *data, 588 void (*fn)(const void *)); 589 590 /** 591 * qtest_add_data_func_full: 592 * @str: Test case path. 593 * @data: Test case data 594 * @fn: Test case function 595 * @data_free_func: GDestroyNotify for data 596 * 597 * Add a GTester testcase with the given name, data and function. 598 * The path is prefixed with the architecture under test, as 599 * returned by qtest_get_arch(). 600 * 601 * @data is passed to @data_free_func() on test completion. 602 */ 603 void qtest_add_data_func_full(const char *str, void *data, 604 void (*fn)(const void *), 605 GDestroyNotify data_free_func); 606 607 /** 608 * qtest_add: 609 * @testpath: Test case path 610 * @Fixture: Fixture type 611 * @tdata: Test case data 612 * @fsetup: Test case setup function 613 * @ftest: Test case function 614 * @fteardown: Test case teardown function 615 * 616 * Add a GTester testcase with the given name, data and functions. 617 * The path is prefixed with the architecture under test, as 618 * returned by qtest_get_arch(). 619 */ 620 #define qtest_add(testpath, Fixture, tdata, fsetup, ftest, fteardown) \ 621 do { \ 622 char *path = g_strdup_printf("/%s/%s", qtest_get_arch(), testpath); \ 623 g_test_add(path, Fixture, tdata, fsetup, ftest, fteardown); \ 624 g_free(path); \ 625 } while (0) 626 627 void qtest_add_abrt_handler(GHookFunc fn, const void *data); 628 629 /** 630 * qtest_qmp_assert_success: 631 * @qts: QTestState instance to operate on 632 * @fmt...: QMP message to send to qemu, formatted like 633 * qobject_from_jsonf_nofail(). See parse_escape() for what's 634 * supported after '%'. 635 * 636 * Sends a QMP message to QEMU and asserts that a 'return' key is present in 637 * the response. 638 */ 639 void qtest_qmp_assert_success(QTestState *qts, const char *fmt, ...) 640 GCC_FMT_ATTR(2, 3); 641 642 QDict *qmp_fd_receive(int fd); 643 void qmp_fd_vsend_fds(int fd, int *fds, size_t fds_num, 644 const char *fmt, va_list ap) GCC_FMT_ATTR(4, 0); 645 void qmp_fd_vsend(int fd, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0); 646 void qmp_fd_send(int fd, const char *fmt, ...) GCC_FMT_ATTR(2, 3); 647 void qmp_fd_send_raw(int fd, const char *fmt, ...) GCC_FMT_ATTR(2, 3); 648 void qmp_fd_vsend_raw(int fd, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0); 649 QDict *qmp_fdv(int fd, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0); 650 QDict *qmp_fd(int fd, const char *fmt, ...) GCC_FMT_ATTR(2, 3); 651 652 /** 653 * qtest_cb_for_every_machine: 654 * @cb: Pointer to the callback function 655 * @skip_old_versioned: true if versioned old machine types should be skipped 656 * 657 * Call a callback function for every name of all available machines. 658 */ 659 void qtest_cb_for_every_machine(void (*cb)(const char *machine), 660 bool skip_old_versioned); 661 662 /** 663 * qtest_qmp_device_add_qdict: 664 * @qts: QTestState instance to operate on 665 * @drv: Name of the device that should be added 666 * @arguments: QDict with properties for the device to intialize 667 * 668 * Generic hot-plugging test via the device_add QMP command with properties 669 * supplied in form of QDict. Use NULL for empty properties list. 670 */ 671 void qtest_qmp_device_add_qdict(QTestState *qts, const char *drv, 672 const QDict *arguments); 673 674 /** 675 * qtest_qmp_device_add: 676 * @qts: QTestState instance to operate on 677 * @driver: Name of the device that should be added 678 * @id: Identification string 679 * @fmt...: QMP message to send to qemu, formatted like 680 * qobject_from_jsonf_nofail(). See parse_escape() for what's 681 * supported after '%'. 682 * 683 * Generic hot-plugging test via the device_add QMP command. 684 */ 685 void qtest_qmp_device_add(QTestState *qts, const char *driver, const char *id, 686 const char *fmt, ...) GCC_FMT_ATTR(4, 5); 687 688 /** 689 * qtest_qmp_device_del: 690 * @qts: QTestState instance to operate on 691 * @id: Identification string 692 * 693 * Generic hot-unplugging test via the device_del QMP command. 694 */ 695 void qtest_qmp_device_del(QTestState *qts, const char *id); 696 697 /** 698 * qmp_rsp_is_err: 699 * @rsp: QMP response to check for error 700 * 701 * Test @rsp for error and discard @rsp. 702 * Returns 'true' if there is error in @rsp and 'false' otherwise. 703 */ 704 bool qmp_rsp_is_err(QDict *rsp); 705 706 /** 707 * qmp_assert_error_class: 708 * @rsp: QMP response to check for error 709 * @class: an error class 710 * 711 * Assert the response has the given error class and discard @rsp. 712 */ 713 void qmp_assert_error_class(QDict *rsp, const char *class); 714 715 /** 716 * qtest_probe_child: 717 * @s: QTestState instance to operate on. 718 * 719 * Returns: true if the child is still alive. 720 */ 721 bool qtest_probe_child(QTestState *s); 722 723 /** 724 * qtest_set_expected_status: 725 * @s: QTestState instance to operate on. 726 * @status: an expected exit status. 727 * 728 * Set expected exit status of the child. 729 */ 730 void qtest_set_expected_status(QTestState *s, int status); 731 732 QTestState *qtest_inproc_init(QTestState **s, bool log, const char* arch, 733 void (*send)(void*, const char*)); 734 735 void qtest_client_inproc_recv(void *opaque, const char *str); 736 #endif 737