libqtest: Rename qmp_assert_error_class() to qmp_expect_error_and_unref()
[qemu.git] / tests / qtest / libqos / libqtest.h
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_expect_error_and_unref:
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_expect_error_and_unref(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