Merge remote-tracking branch 'remotes/armbru/tags/pull-monitor-2020-02-15-v2' into...
[qemu.git] / tests / test-keyval.c
1 /*
2 * Unit tests for parsing of KEY=VALUE,... strings
3 *
4 * Copyright (C) 2017 Red Hat Inc.
5 *
6 * Authors:
7 * Markus Armbruster <armbru@redhat.com>,
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 */
12
13 #include "qemu/osdep.h"
14 #include "qemu/units.h"
15 #include "qapi/error.h"
16 #include "qapi/qmp/qdict.h"
17 #include "qapi/qmp/qlist.h"
18 #include "qapi/qmp/qstring.h"
19 #include "qapi/qobject-input-visitor.h"
20 #include "test-qapi-visit.h"
21 #include "qemu/cutils.h"
22 #include "qemu/option.h"
23
24 static void test_keyval_parse(void)
25 {
26 Error *err = NULL;
27 QDict *qdict, *sub_qdict;
28 char long_key[129];
29 char *params;
30
31 /* Nothing */
32 qdict = keyval_parse("", NULL, &error_abort);
33 g_assert_cmpuint(qdict_size(qdict), ==, 0);
34 qobject_unref(qdict);
35
36 /* Empty key (qemu_opts_parse() accepts this) */
37 qdict = keyval_parse("=val", NULL, &err);
38 error_free_or_abort(&err);
39 g_assert(!qdict);
40
41 /* Empty key fragment */
42 qdict = keyval_parse(".", NULL, &err);
43 error_free_or_abort(&err);
44 g_assert(!qdict);
45 qdict = keyval_parse("key.", NULL, &err);
46 error_free_or_abort(&err);
47 g_assert(!qdict);
48
49 /* Invalid non-empty key (qemu_opts_parse() doesn't care) */
50 qdict = keyval_parse("7up=val", NULL, &err);
51 error_free_or_abort(&err);
52 g_assert(!qdict);
53
54 /* Overlong key */
55 memset(long_key, 'a', 127);
56 long_key[127] = 'z';
57 long_key[128] = 0;
58 params = g_strdup_printf("k.%s=v", long_key);
59 qdict = keyval_parse(params + 2, NULL, &err);
60 error_free_or_abort(&err);
61 g_assert(!qdict);
62
63 /* Overlong key fragment */
64 qdict = keyval_parse(params, NULL, &err);
65 error_free_or_abort(&err);
66 g_assert(!qdict);
67 g_free(params);
68
69 /* Long key (qemu_opts_parse() accepts and truncates silently) */
70 params = g_strdup_printf("k.%s=v", long_key + 1);
71 qdict = keyval_parse(params + 2, NULL, &error_abort);
72 g_assert_cmpuint(qdict_size(qdict), ==, 1);
73 g_assert_cmpstr(qdict_get_try_str(qdict, long_key + 1), ==, "v");
74 qobject_unref(qdict);
75
76 /* Long key fragment */
77 qdict = keyval_parse(params, NULL, &error_abort);
78 g_assert_cmpuint(qdict_size(qdict), ==, 1);
79 sub_qdict = qdict_get_qdict(qdict, "k");
80 g_assert(sub_qdict);
81 g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
82 g_assert_cmpstr(qdict_get_try_str(sub_qdict, long_key + 1), ==, "v");
83 qobject_unref(qdict);
84 g_free(params);
85
86 /* Crap after valid key */
87 qdict = keyval_parse("key[0]=val", NULL, &err);
88 error_free_or_abort(&err);
89 g_assert(!qdict);
90
91 /* Multiple keys, last one wins */
92 qdict = keyval_parse("a=1,b=2,,x,a=3", NULL, &error_abort);
93 g_assert_cmpuint(qdict_size(qdict), ==, 2);
94 g_assert_cmpstr(qdict_get_try_str(qdict, "a"), ==, "3");
95 g_assert_cmpstr(qdict_get_try_str(qdict, "b"), ==, "2,x");
96 qobject_unref(qdict);
97
98 /* Even when it doesn't in qemu_opts_parse() */
99 qdict = keyval_parse("id=foo,id=bar", NULL, &error_abort);
100 g_assert_cmpuint(qdict_size(qdict), ==, 1);
101 g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "bar");
102 qobject_unref(qdict);
103
104 /* Dotted keys */
105 qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
106 g_assert_cmpuint(qdict_size(qdict), ==, 2);
107 sub_qdict = qdict_get_qdict(qdict, "a");
108 g_assert(sub_qdict);
109 g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
110 sub_qdict = qdict_get_qdict(sub_qdict, "b");
111 g_assert(sub_qdict);
112 g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
113 g_assert_cmpstr(qdict_get_try_str(sub_qdict, "c"), ==, "2");
114 g_assert_cmpstr(qdict_get_try_str(qdict, "d"), ==, "3");
115 qobject_unref(qdict);
116
117 /* Inconsistent dotted keys */
118 qdict = keyval_parse("a.b=1,a=2", NULL, &err);
119 error_free_or_abort(&err);
120 g_assert(!qdict);
121 qdict = keyval_parse("a.b=1,a.b.c=2", NULL, &err);
122 error_free_or_abort(&err);
123 g_assert(!qdict);
124
125 /* Trailing comma is ignored */
126 qdict = keyval_parse("x=y,", NULL, &error_abort);
127 g_assert_cmpuint(qdict_size(qdict), ==, 1);
128 g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, "y");
129 qobject_unref(qdict);
130
131 /* Except when it isn't */
132 qdict = keyval_parse(",", NULL, &err);
133 error_free_or_abort(&err);
134 g_assert(!qdict);
135
136 /* Value containing ,id= not misinterpreted as qemu_opts_parse() does */
137 qdict = keyval_parse("x=,,id=bar", NULL, &error_abort);
138 g_assert_cmpuint(qdict_size(qdict), ==, 1);
139 g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, ",id=bar");
140 qobject_unref(qdict);
141
142 /* Anti-social ID is left to caller (qemu_opts_parse() rejects it) */
143 qdict = keyval_parse("id=666", NULL, &error_abort);
144 g_assert_cmpuint(qdict_size(qdict), ==, 1);
145 g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "666");
146 qobject_unref(qdict);
147
148 /* Implied value not supported (unlike qemu_opts_parse()) */
149 qdict = keyval_parse("an,noaus,noaus=", NULL, &err);
150 error_free_or_abort(&err);
151 g_assert(!qdict);
152
153 /* Implied value, key "no" (qemu_opts_parse(): negated empty key) */
154 qdict = keyval_parse("no", NULL, &err);
155 error_free_or_abort(&err);
156 g_assert(!qdict);
157
158 /* Implied key */
159 qdict = keyval_parse("an,aus=off,noaus=", "implied", &error_abort);
160 g_assert_cmpuint(qdict_size(qdict), ==, 3);
161 g_assert_cmpstr(qdict_get_try_str(qdict, "implied"), ==, "an");
162 g_assert_cmpstr(qdict_get_try_str(qdict, "aus"), ==, "off");
163 g_assert_cmpstr(qdict_get_try_str(qdict, "noaus"), ==, "");
164 qobject_unref(qdict);
165
166 /* Implied dotted key */
167 qdict = keyval_parse("val", "eins.zwei", &error_abort);
168 g_assert_cmpuint(qdict_size(qdict), ==, 1);
169 sub_qdict = qdict_get_qdict(qdict, "eins");
170 g_assert(sub_qdict);
171 g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
172 g_assert_cmpstr(qdict_get_try_str(sub_qdict, "zwei"), ==, "val");
173 qobject_unref(qdict);
174
175 /* Implied key with empty value (qemu_opts_parse() accepts this) */
176 qdict = keyval_parse(",", "implied", &err);
177 error_free_or_abort(&err);
178 g_assert(!qdict);
179
180 /* Likewise (qemu_opts_parse(): implied key with comma value) */
181 qdict = keyval_parse(",,,a=1", "implied", &err);
182 error_free_or_abort(&err);
183 g_assert(!qdict);
184
185 /* Empty key is not an implied key */
186 qdict = keyval_parse("=val", "implied", &err);
187 error_free_or_abort(&err);
188 g_assert(!qdict);
189 }
190
191 static void check_list012(QList *qlist)
192 {
193 static const char *expected[] = { "null", "eins", "zwei" };
194 int i;
195 QString *qstr;
196
197 g_assert(qlist);
198 for (i = 0; i < ARRAY_SIZE(expected); i++) {
199 qstr = qobject_to(QString, qlist_pop(qlist));
200 g_assert(qstr);
201 g_assert_cmpstr(qstring_get_str(qstr), ==, expected[i]);
202 qobject_unref(qstr);
203 }
204 g_assert(qlist_empty(qlist));
205 }
206
207 static void test_keyval_parse_list(void)
208 {
209 Error *err = NULL;
210 QDict *qdict, *sub_qdict;
211
212 /* Root can't be a list */
213 qdict = keyval_parse("0=1", NULL, &err);
214 error_free_or_abort(&err);
215 g_assert(!qdict);
216
217 /* List elements need not be in order */
218 qdict = keyval_parse("list.0=null,list.2=zwei,list.1=eins",
219 NULL, &error_abort);
220 g_assert_cmpint(qdict_size(qdict), ==, 1);
221 check_list012(qdict_get_qlist(qdict, "list"));
222 qobject_unref(qdict);
223
224 /* Multiple indexes, last one wins */
225 qdict = keyval_parse("list.1=goner,list.0=null,list.01=eins,list.2=zwei",
226 NULL, &error_abort);
227 g_assert_cmpint(qdict_size(qdict), ==, 1);
228 check_list012(qdict_get_qlist(qdict, "list"));
229 qobject_unref(qdict);
230
231 /* List at deeper nesting */
232 qdict = keyval_parse("a.list.1=eins,a.list.00=null,a.list.2=zwei",
233 NULL, &error_abort);
234 g_assert_cmpint(qdict_size(qdict), ==, 1);
235 sub_qdict = qdict_get_qdict(qdict, "a");
236 g_assert_cmpint(qdict_size(sub_qdict), ==, 1);
237 check_list012(qdict_get_qlist(sub_qdict, "list"));
238 qobject_unref(qdict);
239
240 /* Inconsistent dotted keys: both list and dictionary */
241 qdict = keyval_parse("a.b.c=1,a.b.0=2", NULL, &err);
242 error_free_or_abort(&err);
243 g_assert(!qdict);
244 qdict = keyval_parse("a.0.c=1,a.b.c=2", NULL, &err);
245 error_free_or_abort(&err);
246 g_assert(!qdict);
247
248 /* Missing list indexes */
249 qdict = keyval_parse("list.1=lonely", NULL, &err);
250 error_free_or_abort(&err);
251 g_assert(!qdict);
252 qdict = keyval_parse("list.0=null,list.2=eins,list.02=zwei", NULL, &err);
253 error_free_or_abort(&err);
254 g_assert(!qdict);
255 }
256
257 static void test_keyval_visit_bool(void)
258 {
259 Error *err = NULL;
260 Visitor *v;
261 QDict *qdict;
262 bool b;
263
264 qdict = keyval_parse("bool1=on,bool2=off", NULL, &error_abort);
265 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
266 qobject_unref(qdict);
267 visit_start_struct(v, NULL, NULL, 0, &error_abort);
268 visit_type_bool(v, "bool1", &b, &error_abort);
269 g_assert(b);
270 visit_type_bool(v, "bool2", &b, &error_abort);
271 g_assert(!b);
272 visit_check_struct(v, &error_abort);
273 visit_end_struct(v, NULL);
274 visit_free(v);
275
276 qdict = keyval_parse("bool1=offer", NULL, &error_abort);
277 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
278 qobject_unref(qdict);
279 visit_start_struct(v, NULL, NULL, 0, &error_abort);
280 visit_type_bool(v, "bool1", &b, &err);
281 error_free_or_abort(&err);
282 visit_end_struct(v, NULL);
283 visit_free(v);
284 }
285
286 static void test_keyval_visit_number(void)
287 {
288 Error *err = NULL;
289 Visitor *v;
290 QDict *qdict;
291 uint64_t u;
292
293 /* Lower limit zero */
294 qdict = keyval_parse("number1=0", NULL, &error_abort);
295 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
296 qobject_unref(qdict);
297 visit_start_struct(v, NULL, NULL, 0, &error_abort);
298 visit_type_uint64(v, "number1", &u, &error_abort);
299 g_assert_cmpuint(u, ==, 0);
300 visit_check_struct(v, &error_abort);
301 visit_end_struct(v, NULL);
302 visit_free(v);
303
304 /* Upper limit 2^64-1 */
305 qdict = keyval_parse("number1=18446744073709551615,number2=-1",
306 NULL, &error_abort);
307 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
308 qobject_unref(qdict);
309 visit_start_struct(v, NULL, NULL, 0, &error_abort);
310 visit_type_uint64(v, "number1", &u, &error_abort);
311 g_assert_cmphex(u, ==, UINT64_MAX);
312 visit_type_uint64(v, "number2", &u, &error_abort);
313 g_assert_cmphex(u, ==, UINT64_MAX);
314 visit_check_struct(v, &error_abort);
315 visit_end_struct(v, NULL);
316 visit_free(v);
317
318 /* Above upper limit */
319 qdict = keyval_parse("number1=18446744073709551616",
320 NULL, &error_abort);
321 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
322 qobject_unref(qdict);
323 visit_start_struct(v, NULL, NULL, 0, &error_abort);
324 visit_type_uint64(v, "number1", &u, &err);
325 error_free_or_abort(&err);
326 visit_end_struct(v, NULL);
327 visit_free(v);
328
329 /* Below lower limit */
330 qdict = keyval_parse("number1=-18446744073709551616",
331 NULL, &error_abort);
332 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
333 qobject_unref(qdict);
334 visit_start_struct(v, NULL, NULL, 0, &error_abort);
335 visit_type_uint64(v, "number1", &u, &err);
336 error_free_or_abort(&err);
337 visit_end_struct(v, NULL);
338 visit_free(v);
339
340 /* Hex and octal */
341 qdict = keyval_parse("number1=0x2a,number2=052",
342 NULL, &error_abort);
343 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
344 qobject_unref(qdict);
345 visit_start_struct(v, NULL, NULL, 0, &error_abort);
346 visit_type_uint64(v, "number1", &u, &error_abort);
347 g_assert_cmpuint(u, ==, 42);
348 visit_type_uint64(v, "number2", &u, &error_abort);
349 g_assert_cmpuint(u, ==, 42);
350 visit_check_struct(v, &error_abort);
351 visit_end_struct(v, NULL);
352 visit_free(v);
353
354 /* Trailing crap */
355 qdict = keyval_parse("number1=3.14,number2=08",
356 NULL, &error_abort);
357 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
358 qobject_unref(qdict);
359 visit_start_struct(v, NULL, NULL, 0, &error_abort);
360 visit_type_uint64(v, "number1", &u, &err);
361 error_free_or_abort(&err);
362 visit_type_uint64(v, "number2", &u, &err);
363 error_free_or_abort(&err);
364 visit_end_struct(v, NULL);
365 visit_free(v);
366 }
367
368 static void test_keyval_visit_size(void)
369 {
370 Error *err = NULL;
371 Visitor *v;
372 QDict *qdict;
373 uint64_t sz;
374
375 /* Lower limit zero */
376 qdict = keyval_parse("sz1=0", NULL, &error_abort);
377 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
378 qobject_unref(qdict);
379 visit_start_struct(v, NULL, NULL, 0, &error_abort);
380 visit_type_size(v, "sz1", &sz, &error_abort);
381 g_assert_cmpuint(sz, ==, 0);
382 visit_check_struct(v, &error_abort);
383 visit_end_struct(v, NULL);
384 visit_free(v);
385
386 /* Note: precision is 53 bits since we're parsing with strtod() */
387
388 /* Around limit of precision: 2^53-1, 2^53, 2^53+1 */
389 qdict = keyval_parse("sz1=9007199254740991,"
390 "sz2=9007199254740992,"
391 "sz3=9007199254740993",
392 NULL, &error_abort);
393 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
394 qobject_unref(qdict);
395 visit_start_struct(v, NULL, NULL, 0, &error_abort);
396 visit_type_size(v, "sz1", &sz, &error_abort);
397 g_assert_cmphex(sz, ==, 0x1fffffffffffff);
398 visit_type_size(v, "sz2", &sz, &error_abort);
399 g_assert_cmphex(sz, ==, 0x20000000000000);
400 visit_type_size(v, "sz3", &sz, &error_abort);
401 g_assert_cmphex(sz, ==, 0x20000000000000);
402 visit_check_struct(v, &error_abort);
403 visit_end_struct(v, NULL);
404 visit_free(v);
405
406 /* Close to signed upper limit 0x7ffffffffffffc00 (53 msbs set) */
407 qdict = keyval_parse("sz1=9223372036854774784," /* 7ffffffffffffc00 */
408 "sz2=9223372036854775295", /* 7ffffffffffffdff */
409 NULL, &error_abort);
410 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
411 qobject_unref(qdict);
412 visit_start_struct(v, NULL, NULL, 0, &error_abort);
413 visit_type_size(v, "sz1", &sz, &error_abort);
414 g_assert_cmphex(sz, ==, 0x7ffffffffffffc00);
415 visit_type_size(v, "sz2", &sz, &error_abort);
416 g_assert_cmphex(sz, ==, 0x7ffffffffffffc00);
417 visit_check_struct(v, &error_abort);
418 visit_end_struct(v, NULL);
419 visit_free(v);
420
421 /* Close to actual upper limit 0xfffffffffffff800 (53 msbs set) */
422 qdict = keyval_parse("sz1=18446744073709549568," /* fffffffffffff800 */
423 "sz2=18446744073709550591", /* fffffffffffffbff */
424 NULL, &error_abort);
425 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
426 qobject_unref(qdict);
427 visit_start_struct(v, NULL, NULL, 0, &error_abort);
428 visit_type_size(v, "sz1", &sz, &error_abort);
429 g_assert_cmphex(sz, ==, 0xfffffffffffff800);
430 visit_type_size(v, "sz2", &sz, &error_abort);
431 g_assert_cmphex(sz, ==, 0xfffffffffffff800);
432 visit_check_struct(v, &error_abort);
433 visit_end_struct(v, NULL);
434 visit_free(v);
435
436 /* Beyond limits */
437 qdict = keyval_parse("sz1=-1,"
438 "sz2=18446744073709550592", /* fffffffffffffc00 */
439 NULL, &error_abort);
440 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
441 qobject_unref(qdict);
442 visit_start_struct(v, NULL, NULL, 0, &error_abort);
443 visit_type_size(v, "sz1", &sz, &err);
444 error_free_or_abort(&err);
445 visit_type_size(v, "sz2", &sz, &err);
446 error_free_or_abort(&err);
447 visit_end_struct(v, NULL);
448 visit_free(v);
449
450 /* Suffixes */
451 qdict = keyval_parse("sz1=8b,sz2=1.5k,sz3=2M,sz4=0.1G,sz5=16777215T",
452 NULL, &error_abort);
453 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
454 qobject_unref(qdict);
455 visit_start_struct(v, NULL, NULL, 0, &error_abort);
456 visit_type_size(v, "sz1", &sz, &error_abort);
457 g_assert_cmpuint(sz, ==, 8);
458 visit_type_size(v, "sz2", &sz, &error_abort);
459 g_assert_cmpuint(sz, ==, 1536);
460 visit_type_size(v, "sz3", &sz, &error_abort);
461 g_assert_cmphex(sz, ==, 2 * MiB);
462 visit_type_size(v, "sz4", &sz, &error_abort);
463 g_assert_cmphex(sz, ==, GiB / 10);
464 visit_type_size(v, "sz5", &sz, &error_abort);
465 g_assert_cmphex(sz, ==, 16777215ULL * TiB);
466 visit_check_struct(v, &error_abort);
467 visit_end_struct(v, NULL);
468 visit_free(v);
469
470 /* Beyond limit with suffix */
471 qdict = keyval_parse("sz1=16777216T", NULL, &error_abort);
472 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
473 qobject_unref(qdict);
474 visit_start_struct(v, NULL, NULL, 0, &error_abort);
475 visit_type_size(v, "sz1", &sz, &err);
476 error_free_or_abort(&err);
477 visit_end_struct(v, NULL);
478 visit_free(v);
479
480 /* Trailing crap */
481 qdict = keyval_parse("sz1=0Z,sz2=16Gi", NULL, &error_abort);
482 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
483 qobject_unref(qdict);
484 visit_start_struct(v, NULL, NULL, 0, &error_abort);
485 visit_type_size(v, "sz1", &sz, &err);
486 error_free_or_abort(&err);
487 visit_type_size(v, "sz2", &sz, &err);
488 error_free_or_abort(&err);
489 visit_end_struct(v, NULL);
490 visit_free(v);
491 }
492
493 static void test_keyval_visit_dict(void)
494 {
495 Error *err = NULL;
496 Visitor *v;
497 QDict *qdict;
498 int64_t i;
499
500 qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
501 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
502 qobject_unref(qdict);
503 visit_start_struct(v, NULL, NULL, 0, &error_abort);
504 visit_start_struct(v, "a", NULL, 0, &error_abort);
505 visit_start_struct(v, "b", NULL, 0, &error_abort);
506 visit_type_int(v, "c", &i, &error_abort);
507 g_assert_cmpint(i, ==, 2);
508 visit_check_struct(v, &error_abort);
509 visit_end_struct(v, NULL);
510 visit_check_struct(v, &error_abort);
511 visit_end_struct(v, NULL);
512 visit_type_int(v, "d", &i, &error_abort);
513 g_assert_cmpint(i, ==, 3);
514 visit_check_struct(v, &error_abort);
515 visit_end_struct(v, NULL);
516 visit_free(v);
517
518 qdict = keyval_parse("a.b=", NULL, &error_abort);
519 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
520 qobject_unref(qdict);
521 visit_start_struct(v, NULL, NULL, 0, &error_abort);
522 visit_start_struct(v, "a", NULL, 0, &error_abort);
523 visit_type_int(v, "c", &i, &err); /* a.c missing */
524 error_free_or_abort(&err);
525 visit_check_struct(v, &err);
526 error_free_or_abort(&err); /* a.b unexpected */
527 visit_end_struct(v, NULL);
528 visit_check_struct(v, &error_abort);
529 visit_end_struct(v, NULL);
530 visit_free(v);
531 }
532
533 static void test_keyval_visit_list(void)
534 {
535 Error *err = NULL;
536 Visitor *v;
537 QDict *qdict;
538 char *s;
539
540 qdict = keyval_parse("a.0=,a.1=I,a.2.0=II", NULL, &error_abort);
541 /* TODO empty list */
542 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
543 qobject_unref(qdict);
544 visit_start_struct(v, NULL, NULL, 0, &error_abort);
545 visit_start_list(v, "a", NULL, 0, &error_abort);
546 visit_type_str(v, NULL, &s, &error_abort);
547 g_assert_cmpstr(s, ==, "");
548 g_free(s);
549 visit_type_str(v, NULL, &s, &error_abort);
550 g_assert_cmpstr(s, ==, "I");
551 g_free(s);
552 visit_start_list(v, NULL, NULL, 0, &error_abort);
553 visit_type_str(v, NULL, &s, &error_abort);
554 g_assert_cmpstr(s, ==, "II");
555 g_free(s);
556 visit_check_list(v, &error_abort);
557 visit_end_list(v, NULL);
558 visit_check_list(v, &error_abort);
559 visit_end_list(v, NULL);
560 visit_check_struct(v, &error_abort);
561 visit_end_struct(v, NULL);
562 visit_free(v);
563
564 qdict = keyval_parse("a.0=,b.0.0=head", NULL, &error_abort);
565 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
566 qobject_unref(qdict);
567 visit_start_struct(v, NULL, NULL, 0, &error_abort);
568 visit_start_list(v, "a", NULL, 0, &error_abort);
569 visit_check_list(v, &err); /* a[0] unexpected */
570 error_free_or_abort(&err);
571 visit_end_list(v, NULL);
572 visit_start_list(v, "b", NULL, 0, &error_abort);
573 visit_start_list(v, NULL, NULL, 0, &error_abort);
574 visit_type_str(v, NULL, &s, &error_abort);
575 g_assert_cmpstr(s, ==, "head");
576 g_free(s);
577 visit_type_str(v, NULL, &s, &err); /* b[0][1] missing */
578 error_free_or_abort(&err);
579 visit_end_list(v, NULL);
580 visit_end_list(v, NULL);
581 visit_check_struct(v, &error_abort);
582 visit_end_struct(v, NULL);
583 visit_free(v);
584 }
585
586 static void test_keyval_visit_optional(void)
587 {
588 Visitor *v;
589 QDict *qdict;
590 bool present;
591 int64_t i;
592
593 qdict = keyval_parse("a.b=1", NULL, &error_abort);
594 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
595 qobject_unref(qdict);
596 visit_start_struct(v, NULL, NULL, 0, &error_abort);
597 visit_optional(v, "b", &present);
598 g_assert(!present); /* b missing */
599 visit_optional(v, "a", &present);
600 g_assert(present); /* a present */
601 visit_start_struct(v, "a", NULL, 0, &error_abort);
602 visit_optional(v, "b", &present);
603 g_assert(present); /* a.b present */
604 visit_type_int(v, "b", &i, &error_abort);
605 g_assert_cmpint(i, ==, 1);
606 visit_optional(v, "a", &present);
607 g_assert(!present); /* a.a missing */
608 visit_check_struct(v, &error_abort);
609 visit_end_struct(v, NULL);
610 visit_check_struct(v, &error_abort);
611 visit_end_struct(v, NULL);
612 visit_free(v);
613 }
614
615 static void test_keyval_visit_alternate(void)
616 {
617 Error *err = NULL;
618 Visitor *v;
619 QDict *qdict;
620 AltStrObj *aso;
621 AltNumEnum *ane;
622 AltEnumBool *aeb;
623
624 /*
625 * Can't do scalar alternate variants other than string. You get
626 * the string variant if there is one, else an error.
627 * TODO make it work for unambiguous cases like AltEnumBool below
628 */
629 qdict = keyval_parse("a=1,b=2,c=on", NULL, &error_abort);
630 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
631 qobject_unref(qdict);
632 visit_start_struct(v, NULL, NULL, 0, &error_abort);
633 visit_type_AltStrObj(v, "a", &aso, &error_abort);
634 g_assert_cmpint(aso->type, ==, QTYPE_QSTRING);
635 g_assert_cmpstr(aso->u.s, ==, "1");
636 qapi_free_AltStrObj(aso);
637 visit_type_AltNumEnum(v, "b", &ane, &err);
638 error_free_or_abort(&err);
639 visit_type_AltEnumBool(v, "c", &aeb, &err);
640 error_free_or_abort(&err);
641 visit_end_struct(v, NULL);
642 visit_free(v);
643 }
644
645 static void test_keyval_visit_any(void)
646 {
647 Visitor *v;
648 QDict *qdict;
649 QObject *any;
650 QList *qlist;
651 QString *qstr;
652
653 qdict = keyval_parse("a.0=null,a.1=1", NULL, &error_abort);
654 v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
655 qobject_unref(qdict);
656 visit_start_struct(v, NULL, NULL, 0, &error_abort);
657 visit_type_any(v, "a", &any, &error_abort);
658 qlist = qobject_to(QList, any);
659 g_assert(qlist);
660 qstr = qobject_to(QString, qlist_pop(qlist));
661 g_assert_cmpstr(qstring_get_str(qstr), ==, "null");
662 qobject_unref(qstr);
663 qstr = qobject_to(QString, qlist_pop(qlist));
664 g_assert_cmpstr(qstring_get_str(qstr), ==, "1");
665 g_assert(qlist_empty(qlist));
666 qobject_unref(qstr);
667 qobject_unref(any);
668 visit_check_struct(v, &error_abort);
669 visit_end_struct(v, NULL);
670 visit_free(v);
671 }
672
673 int main(int argc, char *argv[])
674 {
675 g_test_init(&argc, &argv, NULL);
676 g_test_add_func("/keyval/keyval_parse", test_keyval_parse);
677 g_test_add_func("/keyval/keyval_parse/list", test_keyval_parse_list);
678 g_test_add_func("/keyval/visit/bool", test_keyval_visit_bool);
679 g_test_add_func("/keyval/visit/number", test_keyval_visit_number);
680 g_test_add_func("/keyval/visit/size", test_keyval_visit_size);
681 g_test_add_func("/keyval/visit/dict", test_keyval_visit_dict);
682 g_test_add_func("/keyval/visit/list", test_keyval_visit_list);
683 g_test_add_func("/keyval/visit/optional", test_keyval_visit_optional);
684 g_test_add_func("/keyval/visit/alternate", test_keyval_visit_alternate);
685 g_test_add_func("/keyval/visit/any", test_keyval_visit_any);
686 g_test_run();
687 return 0;
688 }