libqtest: Convert macros to functions and clean up documentation

libqtest.h provides a number of shortcut macros to avoid tests feeding
it the QTestState they operate on. Most of these can easily be turned
into static inline functions, so let's do that for clarity.
This avoids getting off-by-one error messages when passing wrong args.

Some macros had a val argument but documented @value argument. Fix this.

While touching things, enforce gtk-doc markup for return values and for
referencing types.

Signed-off-by: Andreas Färber <afaerber@suse.de>
Signed-off-by: Andreas Färber <afaerber@suse.de>
Message-id: 1361051043-27944-2-git-send-email-afaerber@suse.de
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>

1 files changed, 110 insertions, 50 deletions

diff --git a/tests/libqtest.h b/tests/libqtest.h
index 110e2ecdaf..a111c9cddb 100644
--- a/tests/libqtest.h
+++ b/tests/libqtest.h
@@ -26,12 +26,14 @@ extern QTestState *global_qtest;
 /**
  * qtest_init:
  * @extra_args: other arguments to pass to QEMU.
+ *
+ * Returns: #QTestState instance.
  */
 QTestState *qtest_init(const char *extra_args);
 
 /**
  * qtest_quit:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  *
  * Shut down the QEMU process associated to @s.
  */
@@ -39,7 +41,7 @@ void qtest_quit(QTestState *s);
 
 /**
  * qtest_qmp:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @fmt...: QMP message to send to qemu
  *
  * Sends a QMP message to QEMU
@@ -48,16 +50,16 @@ void qtest_qmp(QTestState *s, const char *fmt, ...);
 
 /**
  * qtest_get_irq:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @num: Interrupt to observe.
  *
- * Return the level of the @num interrupt.
+ * Returns: The level of the @num interrupt.
  */
 bool qtest_get_irq(QTestState *s, int num);
 
 /**
  * qtest_irq_intercept_in:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @string: QOM path of a device.
  *
  * Associate qtest irqs with the GPIO-in pins of the device
@@ -67,7 +69,7 @@ void qtest_irq_intercept_in(QTestState *s, const char *string);
 
 /**
  * qtest_irq_intercept_out:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @string: QOM path of a device.
  *
  * Associate qtest irqs with the GPIO-out pins of the device
@@ -77,7 +79,7 @@ void qtest_irq_intercept_out(QTestState *s, const char *string);
 
 /**
  * qtest_outb:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: I/O port to write to.
  * @value: Value being written.
  *
@@ -87,7 +89,7 @@ void qtest_outb(QTestState *s, uint16_t addr, uint8_t value);
 
 /**
  * qtest_outw:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: I/O port to write to.
  * @value: Value being written.
  *
@@ -97,7 +99,7 @@ void qtest_outw(QTestState *s, uint16_t addr, uint16_t value);
 
 /**
  * qtest_outl:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: I/O port to write to.
  * @value: Value being written.
  *
@@ -107,7 +109,7 @@ void qtest_outl(QTestState *s, uint16_t addr, uint32_t value);
 
 /**
  * qtest_inb:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: I/O port to read from.
  *
  * Returns an 8-bit value from an I/O port.
@@ -116,7 +118,7 @@ uint8_t qtest_inb(QTestState *s, uint16_t addr);
 
 /**
  * qtest_inw:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: I/O port to read from.
  *
  * Returns a 16-bit value from an I/O port.
@@ -125,7 +127,7 @@ uint16_t qtest_inw(QTestState *s, uint16_t addr);
 
 /**
  * qtest_inl:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: I/O port to read from.
  *
  * Returns a 32-bit value from an I/O port.
@@ -134,7 +136,7 @@ uint32_t qtest_inl(QTestState *s, uint16_t addr);
 
 /**
  * qtest_memread:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: Guest address to read from.
  * @data: Pointer to where memory contents will be stored.
  * @size: Number of bytes to read.
@@ -145,7 +147,7 @@ void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size);
 
 /**
  * qtest_memwrite:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
  * @addr: Guest address to write to.
  * @data: Pointer to the bytes that will be written to guest memory.
  * @size: Number of bytes to write.
@@ -156,10 +158,11 @@ void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
 
 /**
  * qtest_clock_step_next:
- * @s: QTestState instance to operate on.
+ * @s: #QTestState instance to operate on.
+ *
+ * Advance the vm_clock to the next deadline.
  *
- * Advance the vm_clock to the next deadline.  Return the current
- * value of the vm_clock in nanoseconds.
+ * Returns: The current value of the vm_clock in nanoseconds.
  */
 int64_t qtest_clock_step_next(QTestState *s);
 
@@ -168,8 +171,9 @@ int64_t qtest_clock_step_next(QTestState *s);
  * @s: QTestState instance to operate on.
  * @step: Number of nanoseconds to advance the clock by.
  *
- * Advance the vm_clock by @step nanoseconds.  Return the current
- * value of the vm_clock in nanoseconds.
+ * Advance the vm_clock by @step nanoseconds.
+ *
+ * Returns: The current value of the vm_clock in nanoseconds.
  */
 int64_t qtest_clock_step(QTestState *s, int64_t step);
 
@@ -179,14 +183,15 @@ int64_t qtest_clock_step(QTestState *s, int64_t step);
  * @val: Nanoseconds value to advance the clock to.
  *
  * Advance the vm_clock to @val nanoseconds since the VM was launched.
- * Return the current value of the vm_clock in nanoseconds.
+ *
+ * Returns: The current value of the vm_clock in nanoseconds.
  */
 int64_t qtest_clock_set(QTestState *s, int64_t val);
 
 /**
  * qtest_get_arch:
  *
- * Returns the architecture for the QEMU executable under test.
+ * Returns: The architecture for the QEMU executable under test.
  */
 const char *qtest_get_arch(void);
 
@@ -197,7 +202,7 @@ const char *qtest_get_arch(void);
  *
  * Add a GTester testcase with the given name and function.
  * The path is prefixed with the architecture under test, as
- * returned by qtest_get_arch.
+ * returned by qtest_get_arch().
  */
 void qtest_add_func(const char *str, void (*fn));
 
@@ -205,12 +210,16 @@ void qtest_add_func(const char *str, void (*fn));
  * qtest_start:
  * @args: other arguments to pass to QEMU
  *
- * Start QEMU and assign the resulting QTestState to a global variable.
- * The global variable is used by "shortcut" macros documented below.
+ * Start QEMU and assign the resulting #QTestState to a global variable.
+ * The global variable is used by "shortcut" functions documented below.
+ *
+ * Returns: #QTestState instance.
  */
-#define qtest_start(args) (            \
-    global_qtest = qtest_init((args)) \
-        )
+static inline QTestState *qtest_start(const char *args)
+{
+    global_qtest = qtest_init(args);
+    return global_qtest;
+}
 
 /**
  * qmp:
@@ -224,9 +233,12 @@ void qtest_add_func(const char *str, void (*fn));
  * get_irq:
  * @num: Interrupt to observe.
  *
- * Return the level of the @num interrupt.
+ * Returns: The level of the @num interrupt.
  */
-#define get_irq(num) qtest_get_irq(global_qtest, num)
+static inline bool get_irq(int num)
+{
+    return qtest_get_irq(global_qtest, num);
+}
 
 /**
  * irq_intercept_in:
@@ -235,7 +247,10 @@ void qtest_add_func(const char *str, void (*fn));
  * Associate qtest irqs with the GPIO-in pins of the device
  * whose path is specified by @string.
  */
-#define irq_intercept_in(string) qtest_irq_intercept_in(global_qtest, string)
+static inline void irq_intercept_in(const char *string)
+{
+    qtest_irq_intercept_in(global_qtest, string);
+}
 
 /**
  * qtest_irq_intercept_out:
@@ -244,7 +259,10 @@ void qtest_add_func(const char *str, void (*fn));
  * Associate qtest irqs with the GPIO-out pins of the device
  * whose path is specified by @string.
  */
-#define irq_intercept_out(string) qtest_irq_intercept_out(global_qtest, string)
+static inline void irq_intercept_out(const char *string)
+{
+    qtest_irq_intercept_out(global_qtest, string);
+}
 
 /**
  * outb:
@@ -253,7 +271,10 @@ void qtest_add_func(const char *str, void (*fn));
  *
  * Write an 8-bit value to an I/O port.
  */
-#define outb(addr, val) qtest_outb(global_qtest, addr, val)
+static inline void outb(uint16_t addr, uint8_t value)
+{
+    qtest_outb(global_qtest, addr, value);
+}
 
 /**
  * outw:
@@ -262,7 +283,10 @@ void qtest_add_func(const char *str, void (*fn));
  *
  * Write a 16-bit value to an I/O port.
  */
-#define outw(addr, val) qtest_outw(global_qtest, addr, val)
+static inline void outw(uint16_t addr, uint16_t value)
+{
+    qtest_outw(global_qtest, addr, value);
+}
 
 /**
  * outl:
@@ -271,31 +295,49 @@ void qtest_add_func(const char *str, void (*fn));
  *
  * Write a 32-bit value to an I/O port.
  */
-#define outl(addr, val) qtest_outl(global_qtest, addr, val)
+static inline void outl(uint16_t addr, uint32_t value)
+{
+    qtest_outl(global_qtest, addr, value);
+}
 
 /**
  * inb:
  * @addr: I/O port to read from.
  *
- * Returns an 8-bit value from an I/O port.
+ * Reads an 8-bit value from an I/O port.
+ *
+ * Returns: Value read.
  */
-#define inb(addr) qtest_inb(global_qtest, addr)
+static inline uint8_t inb(uint16_t addr)
+{
+    return qtest_inb(global_qtest, addr);
+}
 
 /**
  * inw:
  * @addr: I/O port to read from.
  *
- * Returns a 16-bit value from an I/O port.
+ * Reads a 16-bit value from an I/O port.
+ *
+ * Returns: Value read.
  */
-#define inw(addr) qtest_inw(global_qtest, addr)
+static inline uint16_t inw(uint16_t addr)
+{
+    return qtest_inw(global_qtest, addr);
+}
 
 /**
  * inl:
  * @addr: I/O port to read from.
  *
- * Returns a 32-bit value from an I/O port.
+ * Reads a 32-bit value from an I/O port.
+ *
+ * Returns: Value read.
  */
-#define inl(addr) qtest_inl(global_qtest, addr)
+static inline uint32_t inl(uint16_t addr)
+{
+    return qtest_inl(global_qtest, addr);
+}
 
 /**
  * memread:
@@ -305,7 +347,10 @@ void qtest_add_func(const char *str, void (*fn));
  *
  * Read guest memory into a buffer.
  */
-#define memread(addr, data, size) qtest_memread(global_qtest, addr, data, size)
+static inline void memread(uint64_t addr, void *data, size_t size)
+{
+    qtest_memread(global_qtest, addr, data, size);
+}
 
 /**
  * memwrite:
@@ -315,32 +360,47 @@ void qtest_add_func(const char *str, void (*fn));
  *
  * Write a buffer to guest memory.
  */
-#define memwrite(addr, data, size) qtest_memwrite(global_qtest, addr, data, size)
+static inline void memwrite(uint64_t addr, const void *data, size_t size)
+{
+    qtest_memwrite(global_qtest, addr, data, size);
+}
 
 /**
  * clock_step_next:
  *
- * Advance the vm_clock to the next deadline.  Return the current
- * value of the vm_clock in nanoseconds.
+ * Advance the vm_clock to the next deadline.
+ *
+ * Returns: The current value of the vm_clock in nanoseconds.
  */
-#define clock_step_next() qtest_clock_step_next(global_qtest)
+static inline int64_t clock_step_next(void)
+{
+    return qtest_clock_step_next(global_qtest);
+}
 
 /**
  * clock_step:
  * @step: Number of nanoseconds to advance the clock by.
  *
- * Advance the vm_clock by @step nanoseconds.  Return the current
- * value of the vm_clock in nanoseconds.
+ * Advance the vm_clock by @step nanoseconds.
+ *
+ * Returns: The current value of the vm_clock in nanoseconds.
  */
-#define clock_step(step) qtest_clock_step(global_qtest, step)
+static inline int64_t clock_step(int64_t step)
+{
+    return qtest_clock_step(global_qtest, step);
+}
 
 /**
  * clock_set:
  * @val: Nanoseconds value to advance the clock to.
  *
  * Advance the vm_clock to @val nanoseconds since the VM was launched.
- * Return the current value of the vm_clock in nanoseconds.
+ *
+ * Returns: The current value of the vm_clock in nanoseconds.
  */
-#define clock_set(val) qtest_clock_set(global_qtest, val)
+static inline int64_t clock_set(int64_t val)
+{
+    return qtest_clock_set(global_qtest, val);
+}
 
 #endif