blob: faa858624a4b14073e9531cfaf4911add0c63eff [file] [log] [blame]
Peter Maydell681c28a2016-02-08 18:08:51 +00001#include "qemu/osdep.h"
Markus Armbruster91fa93e2021-03-18 16:55:11 +01002#include "qapi/compat-policy.h"
Markus Armbruster6b673952018-02-01 12:18:35 +01003#include "qapi/qmp/qdict.h"
Markus Armbruster3d160422020-03-17 12:54:32 +01004#include "qapi/qmp/qjson.h"
Markus Armbruster15280c32018-02-01 12:18:36 +01005#include "qapi/qmp/qnum.h"
Markus Armbruster6b673952018-02-01 12:18:35 +01006#include "qapi/qmp/qstring.h"
Markus Armbrustere688df62018-02-01 12:18:31 +01007#include "qapi/error.h"
Daniel P. Berrangeb3db2112016-09-30 15:45:27 +01008#include "qapi/qobject-input-visitor.h"
Laszlo Ersekd98150f2012-07-17 16:17:05 +02009#include "tests/test-qapi-types.h"
10#include "tests/test-qapi-visit.h"
Markus Armbrustereb815e22018-02-11 10:36:05 +010011#include "test-qapi-commands.h"
Markus Armbruster00ca24f2019-11-20 19:25:48 +010012#include "test-qapi-init-commands.h"
Michael Roth69ed8362011-07-19 14:50:45 -050013
Markus Armbruster1527bad2017-03-03 13:32:25 +010014static QmpCommandList qmp_commands;
15
Markus Armbruster05ebf842021-03-23 10:40:21 +010016UserDefThree *qmp_test_cmd_return_def_three(Error **errp)
Marc-André Lureau967c8852018-07-03 17:56:35 +020017{
18 return NULL;
19}
20
Michael Roth69ed8362011-07-19 14:50:45 -050021void qmp_user_def_cmd(Error **errp)
22{
23}
24
Igor Mammedov7b13f2c2018-05-11 19:15:59 +020025void qmp_test_flags_command(Error **errp)
Peter Xu1a1b11d2018-03-26 14:38:59 +080026{
27}
28
Marc-André Lureauae6bf762018-08-30 17:58:10 +020029void qmp_cmd_success_response(Error **errp)
30{
31}
32
Kevin Wolf04f22362020-10-05 17:58:49 +020033void qmp_coroutine_cmd(Error **errp)
34{
35}
36
Eric Blake972a1102016-03-17 16:48:27 -060037Empty2 *qmp_user_def_cmd0(Error **errp)
38{
39 return g_new0(Empty2, 1);
40}
41
Michael Roth69ed8362011-07-19 14:50:45 -050042void qmp_user_def_cmd1(UserDefOne * ud1, Error **errp)
43{
44}
45
Markus Armbruster91fa93e2021-03-18 16:55:11 +010046FeatureStruct1 *qmp_test_features0(bool has_fs0, FeatureStruct0 *fs0,
47 bool has_fs1, FeatureStruct1 *fs1,
48 bool has_fs2, FeatureStruct2 *fs2,
49 bool has_fs3, FeatureStruct3 *fs3,
50 bool has_fs4, FeatureStruct4 *fs4,
51 bool has_cfs1, CondFeatureStruct1 *cfs1,
52 bool has_cfs2, CondFeatureStruct2 *cfs2,
53 bool has_cfs3, CondFeatureStruct3 *cfs3,
Marc-André Lureau3ad64ed2021-08-04 12:31:02 +040054 bool has_cfs4, CondFeatureStruct4 *cfs4,
Markus Armbruster91fa93e2021-03-18 16:55:11 +010055 Error **errp)
Kevin Wolf8aa3a332019-06-06 17:37:58 +020056{
Markus Armbruster91fa93e2021-03-18 16:55:11 +010057 return g_new0(FeatureStruct1, 1);
Kevin Wolf8aa3a332019-06-06 17:37:58 +020058}
59
Peter Krempa2e2e0df22019-10-18 10:14:52 +020060void qmp_test_command_features1(Error **errp)
61{
62}
63
64void qmp_test_command_features3(Error **errp)
65{
66}
67
68void qmp_test_command_cond_features1(Error **errp)
69{
70}
71
72void qmp_test_command_cond_features2(Error **errp)
73{
74}
75
76void qmp_test_command_cond_features3(Error **errp)
77{
78}
79
Markus Armbrusterab22ad92014-03-01 08:40:28 +010080UserDefTwo *qmp_user_def_cmd2(UserDefOne *ud1a,
81 bool has_udb1, UserDefOne *ud1b,
82 Error **errp)
Michael Roth69ed8362011-07-19 14:50:45 -050083{
84 UserDefTwo *ret;
Anthony Liguori7267c092011-08-20 22:09:37 -050085 UserDefOne *ud1c = g_malloc0(sizeof(UserDefOne));
86 UserDefOne *ud1d = g_malloc0(sizeof(UserDefOne));
Michael Roth69ed8362011-07-19 14:50:45 -050087
88 ud1c->string = strdup(ud1a->string);
Eric Blakeddf21902015-10-26 16:34:49 -060089 ud1c->integer = ud1a->integer;
Markus Armbrusterab22ad92014-03-01 08:40:28 +010090 ud1d->string = strdup(has_udb1 ? ud1b->string : "blah0");
Eric Blakeddf21902015-10-26 16:34:49 -060091 ud1d->integer = has_udb1 ? ud1b->integer : 0;
Michael Roth69ed8362011-07-19 14:50:45 -050092
Eric Blakeb6fcf322015-05-04 09:05:29 -060093 ret = g_new0(UserDefTwo, 1);
94 ret->string0 = strdup("blah1");
Eric Blake6446a592015-05-04 09:05:30 -060095 ret->dict1 = g_new0(UserDefTwoDict, 1);
96 ret->dict1->string1 = strdup("blah2");
97 ret->dict1->dict2 = g_new0(UserDefTwoDictDict, 1);
98 ret->dict1->dict2->userdef = ud1c;
99 ret->dict1->dict2->string = strdup("blah3");
100 ret->dict1->dict3 = g_new0(UserDefTwoDictDict, 1);
101 ret->dict1->has_dict3 = true;
102 ret->dict1->dict3->userdef = ud1d;
103 ret->dict1->dict3->string = strdup("blah4");
Michael Roth69ed8362011-07-19 14:50:45 -0500104
105 return ret;
106}
107
Eric Blakecae95ea2015-10-12 22:22:25 -0600108int64_t qmp_guest_get_time(int64_t a, bool has_b, int64_t b, Error **errp)
Markus Armbrusterc2216a82014-03-01 08:40:29 +0100109{
110 return a + (has_b ? b : 0);
111}
112
Markus Armbruster28770e02015-09-16 13:06:24 +0200113QObject *qmp_guest_sync(QObject *arg, Error **errp)
114{
115 return arg;
116}
117
Eric Blakec8184082016-07-13 21:50:20 -0600118void qmp_boxed_struct(UserDefZero *arg, Error **errp)
119{
120}
121
Markus Armbruster1e65e162021-09-17 16:31:26 +0200122void qmp_boxed_union(UserDefFlatUnion *arg, Error **errp)
Eric Blakec8184082016-07-13 21:50:20 -0600123{
124}
125
Markus Armbruster675b2142019-09-13 22:13:41 +0200126void qmp_boxed_empty(Empty1 *arg, Error **errp)
127{
128}
129
Markus Armbrusterbb5821d2021-09-17 16:31:30 +0200130void qmp___org_qemu_x_command(__org_qemu_x_EnumList *a,
131 __org_qemu_x_StructList *b,
132 __org_qemu_x_Union *c,
133 __org_qemu_x_Alt *d,
134 Error **errp)
Eric Blakee3c4c3d2015-05-14 06:51:01 -0600135{
Eric Blakec43567c2015-11-18 01:52:52 -0700136 /* Also test that 'wchar-t' was munged to 'q_wchar_t' */
137 if (b && b->value && !b->value->has_q_wchar_t) {
138 b->value->q_wchar_t = 1;
139 }
Eric Blakee3c4c3d2015-05-14 06:51:01 -0600140}
141
142
Markus Armbruster3d160422020-03-17 12:54:32 +0100143static QObject *do_qmp_dispatch(bool allow_oob, const char *template, ...)
Markus Armbruster33064592020-03-17 12:54:30 +0100144{
Markus Armbruster3d160422020-03-17 12:54:32 +0100145 va_list ap;
146 QDict *req, *resp;
Markus Armbruster33064592020-03-17 12:54:30 +0100147 QObject *ret;
148
Markus Armbruster3d160422020-03-17 12:54:32 +0100149 va_start(ap, template);
150 req = qdict_from_vjsonf_nofail(template, ap);
151 va_end(ap);
152
Kevin Wolf41725fa2020-10-05 17:58:47 +0200153 resp = qmp_dispatch(&qmp_commands, QOBJECT(req), allow_oob, NULL);
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100154 g_assert(resp);
Markus Armbruster33064592020-03-17 12:54:30 +0100155 ret = qdict_get(resp, "return");
156 g_assert(ret);
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100157 g_assert(qdict_size(resp) == 1);
Markus Armbruster33064592020-03-17 12:54:30 +0100158
159 qobject_ref(ret);
160 qobject_unref(resp);
Markus Armbruster3d160422020-03-17 12:54:32 +0100161 qobject_unref(req);
Markus Armbruster33064592020-03-17 12:54:30 +0100162 return ret;
163}
164
Markus Armbruster3d160422020-03-17 12:54:32 +0100165static void do_qmp_dispatch_error(bool allow_oob, ErrorClass cls,
166 const char *template, ...)
Markus Armbruster33064592020-03-17 12:54:30 +0100167{
Markus Armbruster3d160422020-03-17 12:54:32 +0100168 va_list ap;
169 QDict *req, *resp;
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100170 QDict *error;
Markus Armbruster33064592020-03-17 12:54:30 +0100171
Markus Armbruster3d160422020-03-17 12:54:32 +0100172 va_start(ap, template);
173 req = qdict_from_vjsonf_nofail(template, ap);
174 va_end(ap);
175
Kevin Wolf41725fa2020-10-05 17:58:47 +0200176 resp = qmp_dispatch(&qmp_commands, QOBJECT(req), allow_oob, NULL);
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100177 g_assert(resp);
178 error = qdict_get_qdict(resp, "error");
179 g_assert(error);
180 g_assert_cmpstr(qdict_get_try_str(error, "class"),
181 ==, QapiErrorClass_str(cls));
182 g_assert(qdict_get_try_str(error, "desc"));
183 g_assert(qdict_size(error) == 2);
184 g_assert(qdict_size(resp) == 1);
Markus Armbruster33064592020-03-17 12:54:30 +0100185
186 qobject_unref(resp);
Markus Armbruster3d160422020-03-17 12:54:32 +0100187 qobject_unref(req);
Markus Armbruster33064592020-03-17 12:54:30 +0100188}
189
Michael Roth69ed8362011-07-19 14:50:45 -0500190/* test commands with no input and no return value */
191static void test_dispatch_cmd(void)
192{
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100193 QDict *ret;
Michael Roth69ed8362011-07-19 14:50:45 -0500194
Markus Armbruster3d160422020-03-17 12:54:32 +0100195 ret = qobject_to(QDict,
196 do_qmp_dispatch(false,
Markus Armbruster05ebf842021-03-23 10:40:21 +0100197 "{ 'execute': 'user-def-cmd' }"));
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100198 assert(ret && qdict_size(ret) == 0);
Markus Armbruster33064592020-03-17 12:54:30 +0100199 qobject_unref(ret);
Michael Roth69ed8362011-07-19 14:50:45 -0500200}
201
Peter Xuc55f0702018-10-09 14:27:17 +0800202static void test_dispatch_cmd_oob(void)
203{
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100204 QDict *ret;
Peter Xuc55f0702018-10-09 14:27:17 +0800205
Markus Armbruster3d160422020-03-17 12:54:32 +0100206 ret = qobject_to(QDict,
207 do_qmp_dispatch(true,
208 "{ 'exec-oob': 'test-flags-command' }"));
Markus Armbrusteref9f5f02020-03-17 12:54:31 +0100209 assert(ret && qdict_size(ret) == 0);
Markus Armbruster33064592020-03-17 12:54:30 +0100210 qobject_unref(ret);
Peter Xuc55f0702018-10-09 14:27:17 +0800211}
212
Michael Roth69ed8362011-07-19 14:50:45 -0500213/* test commands that return an error due to invalid parameters */
Peter Maydell51009172016-08-04 11:39:38 +0100214static void test_dispatch_cmd_failure(void)
Michael Roth69ed8362011-07-19 14:50:45 -0500215{
Markus Armbruster3d160422020-03-17 12:54:32 +0100216 /* missing arguments */
217 do_qmp_dispatch_error(false, ERROR_CLASS_GENERIC_ERROR,
Markus Armbruster05ebf842021-03-23 10:40:21 +0100218 "{ 'execute': 'user-def-cmd2' }");
Michael Roth69ed8362011-07-19 14:50:45 -0500219
Markus Armbruster3d160422020-03-17 12:54:32 +0100220 /* extra arguments */
221 do_qmp_dispatch_error(false, ERROR_CLASS_GENERIC_ERROR,
Markus Armbruster05ebf842021-03-23 10:40:21 +0100222 "{ 'execute': 'user-def-cmd',"
Markus Armbruster3d160422020-03-17 12:54:32 +0100223 " 'arguments': { 'a': 66 } }");
Michael Roth69ed8362011-07-19 14:50:45 -0500224}
225
Marc-André Lureauae6bf762018-08-30 17:58:10 +0200226static void test_dispatch_cmd_success_response(void)
227{
228 QDict *req = qdict_new();
229 QDict *resp;
230
231 qdict_put_str(req, "execute", "cmd-success-response");
Kevin Wolf41725fa2020-10-05 17:58:47 +0200232 resp = qmp_dispatch(&qmp_commands, QOBJECT(req), false, NULL);
Marc-André Lureauae6bf762018-08-30 17:58:10 +0200233 g_assert_null(resp);
234 qobject_unref(req);
235}
236
Michael Roth69ed8362011-07-19 14:50:45 -0500237/* test commands that involve both input parameters and return values */
238static void test_dispatch_cmd_io(void)
239{
Markus Armbruster357765f2014-03-01 08:40:27 +0100240 QDict *ret, *ret_dict, *ret_dict_dict, *ret_dict_dict_userdef;
241 QDict *ret_dict_dict2, *ret_dict_dict2_userdef;
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400242 QNum *ret3;
243 int64_t val;
Michael Roth69ed8362011-07-19 14:50:45 -0500244
Markus Armbruster3d160422020-03-17 12:54:32 +0100245 ret = qobject_to(QDict, do_qmp_dispatch(false,
Markus Armbruster05ebf842021-03-23 10:40:21 +0100246 "{ 'execute': 'user-def-cmd2', 'arguments': {"
Markus Armbruster3d160422020-03-17 12:54:32 +0100247 " 'ud1a': { 'integer': 42, 'string': 'hello' },"
248 " 'ud1b': { 'integer': 422, 'string': 'hello2' } } }"));
Michael Roth69ed8362011-07-19 14:50:45 -0500249
Eric Blakeb6fcf322015-05-04 09:05:29 -0600250 assert(!strcmp(qdict_get_str(ret, "string0"), "blah1"));
251 ret_dict = qdict_get_qdict(ret, "dict1");
252 assert(!strcmp(qdict_get_str(ret_dict, "string1"), "blah2"));
253 ret_dict_dict = qdict_get_qdict(ret_dict, "dict2");
Markus Armbruster357765f2014-03-01 08:40:27 +0100254 ret_dict_dict_userdef = qdict_get_qdict(ret_dict_dict, "userdef");
255 assert(qdict_get_int(ret_dict_dict_userdef, "integer") == 42);
256 assert(!strcmp(qdict_get_str(ret_dict_dict_userdef, "string"), "hello"));
257 assert(!strcmp(qdict_get_str(ret_dict_dict, "string"), "blah3"));
Eric Blakeb6fcf322015-05-04 09:05:29 -0600258 ret_dict_dict2 = qdict_get_qdict(ret_dict, "dict3");
Markus Armbruster357765f2014-03-01 08:40:27 +0100259 ret_dict_dict2_userdef = qdict_get_qdict(ret_dict_dict2, "userdef");
260 assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422);
261 assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2"));
262 assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4"));
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200263 qobject_unref(ret);
Markus Armbrusterc2216a82014-03-01 08:40:29 +0100264
Markus Armbruster3d160422020-03-17 12:54:32 +0100265 ret3 = qobject_to(QNum, do_qmp_dispatch(false,
266 "{ 'execute': 'guest-get-time', 'arguments': { 'a': 66 } }"));
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +0400267 g_assert(qnum_get_try_int(ret3, &val));
268 g_assert_cmpint(val, ==, 66);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200269 qobject_unref(ret3);
Michael Roth69ed8362011-07-19 14:50:45 -0500270}
271
Markus Armbrusterd2032592021-03-18 16:55:17 +0100272static void test_dispatch_cmd_deprecated(void)
273{
274 const char *cmd = "{ 'execute': 'test-command-features1' }";
275 QDict *ret;
276
277 memset(&compat_policy, 0, sizeof(compat_policy));
278
279 /* accept */
280 ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
281 assert(ret && qdict_size(ret) == 0);
282 qobject_unref(ret);
283
284 compat_policy.has_deprecated_input = true;
285 compat_policy.deprecated_input = COMPAT_POLICY_INPUT_ACCEPT;
286 ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
287 assert(ret && qdict_size(ret) == 0);
288 qobject_unref(ret);
289
290 compat_policy.deprecated_input = COMPAT_POLICY_INPUT_REJECT;
291 do_qmp_dispatch_error(false, ERROR_CLASS_COMMAND_NOT_FOUND, cmd);
292}
293
Markus Armbrusterdb291642021-03-18 16:55:18 +0100294static void test_dispatch_cmd_arg_deprecated(void)
295{
296 const char *cmd = "{ 'execute': 'test-features0',"
297 " 'arguments': { 'fs1': { 'foo': 42 } } }";
298 QDict *ret;
299
300 memset(&compat_policy, 0, sizeof(compat_policy));
301
302 /* accept */
303 ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
304 assert(ret && qdict_size(ret) == 1);
305 qobject_unref(ret);
306
307 compat_policy.has_deprecated_input = true;
308 compat_policy.deprecated_input = COMPAT_POLICY_INPUT_ACCEPT;
309 ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
310 assert(ret && qdict_size(ret) == 1);
311 qobject_unref(ret);
312
313 compat_policy.deprecated_input = COMPAT_POLICY_INPUT_REJECT;
314 do_qmp_dispatch_error(false, ERROR_CLASS_GENERIC_ERROR, cmd);
315}
316
Markus Armbruster91fa93e2021-03-18 16:55:11 +0100317static void test_dispatch_cmd_ret_deprecated(void)
318{
319 const char *cmd = "{ 'execute': 'test-features0' }";
320 QDict *ret;
321
322 memset(&compat_policy, 0, sizeof(compat_policy));
323
324 /* default accept */
325 ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
326 assert(ret && qdict_size(ret) == 1);
327 qobject_unref(ret);
328
329 compat_policy.has_deprecated_output = true;
330 compat_policy.deprecated_output = COMPAT_POLICY_OUTPUT_ACCEPT;
331 ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
332 assert(ret && qdict_size(ret) == 1);
333 qobject_unref(ret);
334
335 compat_policy.deprecated_output = COMPAT_POLICY_OUTPUT_HIDE;
336 ret = qobject_to(QDict, do_qmp_dispatch(false, cmd));
337 assert(ret && qdict_size(ret) == 0);
338 qobject_unref(ret);
339}
340
Michael Roth5cd5f0d2011-09-15 14:39:54 -0500341/* test generated dealloc functions for generated types */
342static void test_dealloc_types(void)
343{
344 UserDefOne *ud1test, *ud1a, *ud1b;
345 UserDefOneList *ud1list;
346
347 ud1test = g_malloc0(sizeof(UserDefOne));
Eric Blakeddf21902015-10-26 16:34:49 -0600348 ud1test->integer = 42;
Michael Roth5cd5f0d2011-09-15 14:39:54 -0500349 ud1test->string = g_strdup("hi there 42");
350
351 qapi_free_UserDefOne(ud1test);
352
353 ud1a = g_malloc0(sizeof(UserDefOne));
Eric Blakeddf21902015-10-26 16:34:49 -0600354 ud1a->integer = 43;
Michael Roth5cd5f0d2011-09-15 14:39:54 -0500355 ud1a->string = g_strdup("hi there 43");
356
357 ud1b = g_malloc0(sizeof(UserDefOne));
Eric Blakeddf21902015-10-26 16:34:49 -0600358 ud1b->integer = 44;
Michael Roth5cd5f0d2011-09-15 14:39:54 -0500359 ud1b->string = g_strdup("hi there 44");
360
361 ud1list = g_malloc0(sizeof(UserDefOneList));
362 ud1list->value = ud1a;
363 ud1list->next = g_malloc0(sizeof(UserDefOneList));
364 ud1list->next->value = ud1b;
365
366 qapi_free_UserDefOneList(ud1list);
367}
368
Laszlo Ersekd98150f2012-07-17 16:17:05 +0200369/* test generated deallocation on an object whose construction was prematurely
370 * terminated due to an error */
371static void test_dealloc_partial(void)
372{
373 static const char text[] = "don't leak me";
374
375 UserDefTwo *ud2 = NULL;
376 Error *err = NULL;
377
378 /* create partial object */
379 {
380 QDict *ud2_dict;
Eric Blakeb70ce102016-06-09 10:48:38 -0600381 Visitor *v;
Laszlo Ersekd98150f2012-07-17 16:17:05 +0200382
383 ud2_dict = qdict_new();
Eric Blake46f5ac22017-04-27 16:58:17 -0500384 qdict_put_str(ud2_dict, "string0", text);
Laszlo Ersekd98150f2012-07-17 16:17:05 +0200385
Markus Armbruster048abb72017-03-03 13:32:39 +0100386 v = qobject_input_visitor_new(QOBJECT(ud2_dict));
Eric Blakeb70ce102016-06-09 10:48:38 -0600387 visit_type_UserDefTwo(v, NULL, &ud2, &err);
388 visit_free(v);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200389 qobject_unref(ud2_dict);
Laszlo Ersekd98150f2012-07-17 16:17:05 +0200390 }
391
Eric Blake68ab47e2016-04-28 15:45:32 -0600392 /* verify that visit_type_XXX() cleans up properly on error */
Eric Blakea12a5a12015-11-05 23:35:31 -0700393 error_free_or_abort(&err);
Eric Blake68ab47e2016-04-28 15:45:32 -0600394 assert(!ud2);
395
396 /* Manually create a partial object, leaving ud2->dict1 at NULL */
397 ud2 = g_new0(UserDefTwo, 1);
398 ud2->string0 = g_strdup(text);
Laszlo Ersekd98150f2012-07-17 16:17:05 +0200399
400 /* tear down partial object */
401 qapi_free_UserDefTwo(ud2);
402}
403
404
Michael Roth69ed8362011-07-19 14:50:45 -0500405int main(int argc, char **argv)
406{
407 g_test_init(&argc, &argv, NULL);
408
Marc-André Lureau214e4a52018-03-26 17:08:49 +0200409 g_test_add_func("/qmp/dispatch_cmd", test_dispatch_cmd);
Peter Xuc55f0702018-10-09 14:27:17 +0800410 g_test_add_func("/qmp/dispatch_cmd_oob", test_dispatch_cmd_oob);
Marc-André Lureau214e4a52018-03-26 17:08:49 +0200411 g_test_add_func("/qmp/dispatch_cmd_failure", test_dispatch_cmd_failure);
412 g_test_add_func("/qmp/dispatch_cmd_io", test_dispatch_cmd_io);
Marc-André Lureauae6bf762018-08-30 17:58:10 +0200413 g_test_add_func("/qmp/dispatch_cmd_success_response",
414 test_dispatch_cmd_success_response);
Markus Armbrusterd2032592021-03-18 16:55:17 +0100415 g_test_add_func("/qmp/dispatch_cmd_deprecated",
416 test_dispatch_cmd_deprecated);
Markus Armbrusterdb291642021-03-18 16:55:18 +0100417 g_test_add_func("/qmp/dispatch_cmd_arg_deprecated",
418 test_dispatch_cmd_arg_deprecated);
Markus Armbruster91fa93e2021-03-18 16:55:11 +0100419 g_test_add_func("/qmp/dispatch_cmd_ret_deprecated",
420 test_dispatch_cmd_ret_deprecated);
Marc-André Lureau214e4a52018-03-26 17:08:49 +0200421 g_test_add_func("/qmp/dealloc_types", test_dealloc_types);
422 g_test_add_func("/qmp/dealloc_partial", test_dealloc_partial);
Michael Roth69ed8362011-07-19 14:50:45 -0500423
Markus Armbruster1527bad2017-03-03 13:32:25 +0100424 test_qmp_init_marshal(&qmp_commands);
Michael Roth69ed8362011-07-19 14:50:45 -0500425 g_test_run();
426
427 return 0;
428}