xref: /openbmc/qemu/tests/unit/test-qemu-opts.c (revision 6fdc5bc1)
1 /*
2  * QemuOpts unit-tests.
3  *
4  * Copyright (C) 2014 Leandro Dorileo <l@dorileo.org>
5  *
6  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
7  * See the COPYING.LIB file in the top-level directory.
8  */
9 
10 #include "qemu/osdep.h"
11 #include "qemu/units.h"
12 #include "qemu/option.h"
13 #include "qemu/option_int.h"
14 #include "qapi/error.h"
15 #include "qapi/qmp/qdict.h"
16 #include "qapi/qmp/qstring.h"
17 #include "qemu/config-file.h"
18 
19 
20 static QemuOptsList opts_list_01 = {
21     .name = "opts_list_01",
22     .head = QTAILQ_HEAD_INITIALIZER(opts_list_01.head),
23     .desc = {
24         {
25             .name = "str1",
26             .type = QEMU_OPT_STRING,
27             .help = "Help texts are preserved in qemu_opts_append",
28             .def_value_str = "default",
29         },{
30             .name = "str2",
31             .type = QEMU_OPT_STRING,
32         },{
33             .name = "str3",
34             .type = QEMU_OPT_STRING,
35         },{
36             .name = "number1",
37             .type = QEMU_OPT_NUMBER,
38             .help = "Having help texts only for some options is okay",
39         },{
40             .name = "number2",
41             .type = QEMU_OPT_NUMBER,
42         },
43         { /* end of list */ }
44     },
45 };
46 
47 static QemuOptsList opts_list_02 = {
48     .name = "opts_list_02",
49     .head = QTAILQ_HEAD_INITIALIZER(opts_list_02.head),
50     .desc = {
51         {
52             .name = "str1",
53             .type = QEMU_OPT_STRING,
54         },{
55             .name = "str2",
56             .type = QEMU_OPT_STRING,
57         },{
58             .name = "bool1",
59             .type = QEMU_OPT_BOOL,
60         },{
61             .name = "bool2",
62             .type = QEMU_OPT_BOOL,
63         },{
64             .name = "size1",
65             .type = QEMU_OPT_SIZE,
66         },{
67             .name = "size2",
68             .type = QEMU_OPT_SIZE,
69         },{
70             .name = "size3",
71             .type = QEMU_OPT_SIZE,
72         },
73         { /* end of list */ }
74     },
75 };
76 
77 static QemuOptsList opts_list_03 = {
78     .name = "opts_list_03",
79     .implied_opt_name = "implied",
80     .head = QTAILQ_HEAD_INITIALIZER(opts_list_03.head),
81     .desc = {
82         /* no elements => accept any params */
83         { /* end of list */ }
84     },
85 };
86 
87 static QemuOptsList opts_list_04 = {
88     .name = "opts_list_04",
89     .head = QTAILQ_HEAD_INITIALIZER(opts_list_04.head),
90     .merge_lists = true,
91     .desc = {
92         {
93             .name = "str3",
94             .type = QEMU_OPT_STRING,
95         },
96         { /* end of list */ }
97     },
98 };
99 
100 static void register_opts(void)
101 {
102     qemu_add_opts(&opts_list_01);
103     qemu_add_opts(&opts_list_02);
104     qemu_add_opts(&opts_list_03);
105     qemu_add_opts(&opts_list_04);
106 }
107 
108 static void test_find_unknown_opts(void)
109 {
110     QemuOptsList *list;
111     Error *err = NULL;
112 
113     /* should not return anything, we don't have an "unknown" option */
114     list = qemu_find_opts_err("unknown", &err);
115     g_assert(list == NULL);
116     error_free_or_abort(&err);
117 }
118 
119 static void test_qemu_find_opts(void)
120 {
121     QemuOptsList *list;
122 
123     /* we have an "opts_list_01" option, should return it */
124     list = qemu_find_opts("opts_list_01");
125     g_assert(list != NULL);
126     g_assert_cmpstr(list->name, ==, "opts_list_01");
127 }
128 
129 static void test_qemu_opts_create(void)
130 {
131     QemuOptsList *list;
132     QemuOpts *opts;
133 
134     list = qemu_find_opts("opts_list_01");
135     g_assert(list != NULL);
136     g_assert(QTAILQ_EMPTY(&list->head));
137     g_assert_cmpstr(list->name, ==, "opts_list_01");
138 
139     /* should not find anything at this point */
140     opts = qemu_opts_find(list, NULL);
141     g_assert(opts == NULL);
142 
143     /* create the opts */
144     opts = qemu_opts_create(list, NULL, 0, &error_abort);
145     g_assert(opts != NULL);
146     g_assert(!QTAILQ_EMPTY(&list->head));
147 
148     /* now we've create the opts, must find it */
149     opts = qemu_opts_find(list, NULL);
150     g_assert(opts != NULL);
151 
152     qemu_opts_del(opts);
153 
154     /* should not find anything at this point */
155     opts = qemu_opts_find(list, NULL);
156     g_assert(opts == NULL);
157 }
158 
159 static void test_qemu_opt_get(void)
160 {
161     QemuOptsList *list;
162     QemuOpts *opts;
163     const char *opt = NULL;
164 
165     list = qemu_find_opts("opts_list_01");
166     g_assert(list != NULL);
167     g_assert(QTAILQ_EMPTY(&list->head));
168     g_assert_cmpstr(list->name, ==, "opts_list_01");
169 
170     /* should not find anything at this point */
171     opts = qemu_opts_find(list, NULL);
172     g_assert(opts == NULL);
173 
174     /* create the opts */
175     opts = qemu_opts_create(list, NULL, 0, &error_abort);
176     g_assert(opts != NULL);
177     g_assert(!QTAILQ_EMPTY(&list->head));
178 
179     /* haven't set anything to str2 yet */
180     opt = qemu_opt_get(opts, "str2");
181     g_assert(opt == NULL);
182 
183     qemu_opt_set(opts, "str2", "value", &error_abort);
184 
185     /* now we have set str2, should know about it */
186     opt = qemu_opt_get(opts, "str2");
187     g_assert_cmpstr(opt, ==, "value");
188 
189     qemu_opt_set(opts, "str2", "value2", &error_abort);
190 
191     /* having reset the value, the returned should be the reset one */
192     opt = qemu_opt_get(opts, "str2");
193     g_assert_cmpstr(opt, ==, "value2");
194 
195     qemu_opts_del(opts);
196 
197     /* should not find anything at this point */
198     opts = qemu_opts_find(list, NULL);
199     g_assert(opts == NULL);
200 }
201 
202 static void test_qemu_opt_get_bool(void)
203 {
204     QemuOptsList *list;
205     QemuOpts *opts;
206     bool opt;
207 
208     list = qemu_find_opts("opts_list_02");
209     g_assert(list != NULL);
210     g_assert(QTAILQ_EMPTY(&list->head));
211     g_assert_cmpstr(list->name, ==, "opts_list_02");
212 
213     /* should not find anything at this point */
214     opts = qemu_opts_find(list, NULL);
215     g_assert(opts == NULL);
216 
217     /* create the opts */
218     opts = qemu_opts_create(list, NULL, 0, &error_abort);
219     g_assert(opts != NULL);
220     g_assert(!QTAILQ_EMPTY(&list->head));
221 
222     /* haven't set anything to bool1 yet, so defval should be returned */
223     opt = qemu_opt_get_bool(opts, "bool1", false);
224     g_assert(opt == false);
225 
226     qemu_opt_set_bool(opts, "bool1", true, &error_abort);
227 
228     /* now we have set bool1, should know about it */
229     opt = qemu_opt_get_bool(opts, "bool1", false);
230     g_assert(opt == true);
231 
232     /* having reset the value, opt should be the reset one not defval */
233     qemu_opt_set_bool(opts, "bool1", false, &error_abort);
234 
235     opt = qemu_opt_get_bool(opts, "bool1", true);
236     g_assert(opt == false);
237 
238     qemu_opts_del(opts);
239 
240     /* should not find anything at this point */
241     opts = qemu_opts_find(list, NULL);
242     g_assert(opts == NULL);
243 }
244 
245 static void test_qemu_opt_get_number(void)
246 {
247     QemuOptsList *list;
248     QemuOpts *opts;
249     uint64_t opt;
250 
251     list = qemu_find_opts("opts_list_01");
252     g_assert(list != NULL);
253     g_assert(QTAILQ_EMPTY(&list->head));
254     g_assert_cmpstr(list->name, ==, "opts_list_01");
255 
256     /* should not find anything at this point */
257     opts = qemu_opts_find(list, NULL);
258     g_assert(opts == NULL);
259 
260     /* create the opts */
261     opts = qemu_opts_create(list, NULL, 0, &error_abort);
262     g_assert(opts != NULL);
263     g_assert(!QTAILQ_EMPTY(&list->head));
264 
265     /* haven't set anything to number1 yet, so defval should be returned */
266     opt = qemu_opt_get_number(opts, "number1", 5);
267     g_assert(opt == 5);
268 
269     qemu_opt_set_number(opts, "number1", 10, &error_abort);
270 
271     /* now we have set number1, should know about it */
272     opt = qemu_opt_get_number(opts, "number1", 5);
273     g_assert(opt == 10);
274 
275     /* having reset it, the returned should be the reset one not defval */
276     qemu_opt_set_number(opts, "number1", 15, &error_abort);
277 
278     opt = qemu_opt_get_number(opts, "number1", 5);
279     g_assert(opt == 15);
280 
281     qemu_opts_del(opts);
282 
283     /* should not find anything at this point */
284     opts = qemu_opts_find(list, NULL);
285     g_assert(opts == NULL);
286 }
287 
288 static void test_qemu_opt_get_size(void)
289 {
290     QemuOptsList *list;
291     QemuOpts *opts;
292     uint64_t opt;
293     QDict *dict;
294 
295     list = qemu_find_opts("opts_list_02");
296     g_assert(list != NULL);
297     g_assert(QTAILQ_EMPTY(&list->head));
298     g_assert_cmpstr(list->name, ==, "opts_list_02");
299 
300     /* should not find anything at this point */
301     opts = qemu_opts_find(list, NULL);
302     g_assert(opts == NULL);
303 
304     /* create the opts */
305     opts = qemu_opts_create(list, NULL, 0, &error_abort);
306     g_assert(opts != NULL);
307     g_assert(!QTAILQ_EMPTY(&list->head));
308 
309     /* haven't set anything to size1 yet, so defval should be returned */
310     opt = qemu_opt_get_size(opts, "size1", 5);
311     g_assert(opt == 5);
312 
313     dict = qdict_new();
314     g_assert(dict != NULL);
315 
316     qdict_put_str(dict, "size1", "10");
317 
318     qemu_opts_absorb_qdict(opts, dict, &error_abort);
319     g_assert(error_abort == NULL);
320 
321     /* now we have set size1, should know about it */
322     opt = qemu_opt_get_size(opts, "size1", 5);
323     g_assert(opt == 10);
324 
325     /* reset value */
326     qdict_put_str(dict, "size1", "15");
327 
328     qemu_opts_absorb_qdict(opts, dict, &error_abort);
329     g_assert(error_abort == NULL);
330 
331     /* test the reset value */
332     opt = qemu_opt_get_size(opts, "size1", 5);
333     g_assert(opt == 15);
334 
335     qdict_del(dict, "size1");
336     g_free(dict);
337 
338     qemu_opts_del(opts);
339 
340     /* should not find anything at this point */
341     opts = qemu_opts_find(list, NULL);
342     g_assert(opts == NULL);
343 }
344 
345 static void test_qemu_opt_unset(void)
346 {
347     QemuOpts *opts;
348     const char *value;
349     int ret;
350 
351     /* dynamically initialized (parsed) opts */
352     opts = qemu_opts_parse(&opts_list_03, "key=value", false, NULL);
353     g_assert(opts != NULL);
354 
355     /* check default/parsed value */
356     value = qemu_opt_get(opts, "key");
357     g_assert_cmpstr(value, ==, "value");
358 
359     /* reset it to value2 */
360     qemu_opt_set(opts, "key", "value2", &error_abort);
361 
362     value = qemu_opt_get(opts, "key");
363     g_assert_cmpstr(value, ==, "value2");
364 
365     /* unset, valid only for "accept any" */
366     ret = qemu_opt_unset(opts, "key");
367     g_assert(ret == 0);
368 
369     /* after reset the value should be the parsed/default one */
370     value = qemu_opt_get(opts, "key");
371     g_assert_cmpstr(value, ==, "value");
372 
373     qemu_opts_del(opts);
374 }
375 
376 static void test_qemu_opts_reset(void)
377 {
378     QemuOptsList *list;
379     QemuOpts *opts;
380     uint64_t opt;
381 
382     list = qemu_find_opts("opts_list_01");
383     g_assert(list != NULL);
384     g_assert(QTAILQ_EMPTY(&list->head));
385     g_assert_cmpstr(list->name, ==, "opts_list_01");
386 
387     /* should not find anything at this point */
388     opts = qemu_opts_find(list, NULL);
389     g_assert(opts == NULL);
390 
391     /* create the opts */
392     opts = qemu_opts_create(list, NULL, 0, &error_abort);
393     g_assert(opts != NULL);
394     g_assert(!QTAILQ_EMPTY(&list->head));
395 
396     /* haven't set anything to number1 yet, so defval should be returned */
397     opt = qemu_opt_get_number(opts, "number1", 5);
398     g_assert(opt == 5);
399 
400     qemu_opt_set_number(opts, "number1", 10, &error_abort);
401 
402     /* now we have set number1, should know about it */
403     opt = qemu_opt_get_number(opts, "number1", 5);
404     g_assert(opt == 10);
405 
406     qemu_opts_reset(list);
407 
408     /* should not find anything at this point */
409     opts = qemu_opts_find(list, NULL);
410     g_assert(opts == NULL);
411 }
412 
413 static int opts_count_iter(void *opaque, const char *name, const char *value,
414                            Error **errp)
415 {
416     (*(size_t *)opaque)++;
417     return 0;
418 }
419 
420 static size_t opts_count(QemuOpts *opts)
421 {
422     size_t n = 0;
423 
424     qemu_opt_foreach(opts, opts_count_iter, &n, NULL);
425     return n;
426 }
427 
428 static void test_opts_parse(void)
429 {
430     Error *err = NULL;
431     QemuOpts *opts;
432 
433     /* Nothing */
434     opts = qemu_opts_parse(&opts_list_03, "", false, &error_abort);
435     g_assert_cmpuint(opts_count(opts), ==, 0);
436 
437     /* Empty key */
438     opts = qemu_opts_parse(&opts_list_03, "=val", false, &error_abort);
439     g_assert_cmpuint(opts_count(opts), ==, 1);
440     g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "val");
441 
442     /* Multiple keys, last one wins */
443     opts = qemu_opts_parse(&opts_list_03, "a=1,b=2,,x,a=3",
444                            false, &error_abort);
445     g_assert_cmpuint(opts_count(opts), ==, 3);
446     g_assert_cmpstr(qemu_opt_get(opts, "a"), ==, "3");
447     g_assert_cmpstr(qemu_opt_get(opts, "b"), ==, "2,x");
448 
449     /* Except when it doesn't */
450     opts = qemu_opts_parse(&opts_list_03, "id=foo,id=bar",
451                            false, &error_abort);
452     g_assert_cmpuint(opts_count(opts), ==, 0);
453     g_assert_cmpstr(qemu_opts_id(opts), ==, "foo");
454 
455     /* TODO Cover low-level access to repeated keys */
456 
457     /* Trailing comma is ignored */
458     opts = qemu_opts_parse(&opts_list_03, "x=y,", false, &error_abort);
459     g_assert_cmpuint(opts_count(opts), ==, 1);
460     g_assert_cmpstr(qemu_opt_get(opts, "x"), ==, "y");
461 
462     /* Except when it isn't */
463     opts = qemu_opts_parse(&opts_list_03, ",", false, &error_abort);
464     g_assert_cmpuint(opts_count(opts), ==, 1);
465     g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "on");
466 
467     /* Duplicate ID */
468     opts = qemu_opts_parse(&opts_list_03, "x=y,id=foo", false, &err);
469     error_free_or_abort(&err);
470     g_assert(!opts);
471     /* TODO Cover .merge_lists = true */
472 
473     /* Buggy ID recognition (fixed) */
474     opts = qemu_opts_parse(&opts_list_03, "x=,,id=bar", false, &error_abort);
475     g_assert_cmpuint(opts_count(opts), ==, 1);
476     g_assert(!qemu_opts_id(opts));
477     g_assert_cmpstr(qemu_opt_get(opts, "x"), ==, ",id=bar");
478 
479     /* Anti-social ID */
480     opts = qemu_opts_parse(&opts_list_01, "id=666", false, &err);
481     error_free_or_abort(&err);
482     g_assert(!opts);
483 
484     /* Implied value (qemu_opts_parse warns but accepts it) */
485     opts = qemu_opts_parse(&opts_list_03, "an,noaus,noaus=",
486                            false, &error_abort);
487     g_assert_cmpuint(opts_count(opts), ==, 3);
488     g_assert_cmpstr(qemu_opt_get(opts, "an"), ==, "on");
489     g_assert_cmpstr(qemu_opt_get(opts, "aus"), ==, "off");
490     g_assert_cmpstr(qemu_opt_get(opts, "noaus"), ==, "");
491 
492     /* Implied value, negated empty key */
493     opts = qemu_opts_parse(&opts_list_03, "no", false, &error_abort);
494     g_assert_cmpuint(opts_count(opts), ==, 1);
495     g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "off");
496 
497     /* Implied key */
498     opts = qemu_opts_parse(&opts_list_03, "an,noaus,noaus=", true,
499                            &error_abort);
500     g_assert_cmpuint(opts_count(opts), ==, 3);
501     g_assert_cmpstr(qemu_opt_get(opts, "implied"), ==, "an");
502     g_assert_cmpstr(qemu_opt_get(opts, "aus"), ==, "off");
503     g_assert_cmpstr(qemu_opt_get(opts, "noaus"), ==, "");
504 
505     /* Implied key with empty value */
506     opts = qemu_opts_parse(&opts_list_03, ",", true, &error_abort);
507     g_assert_cmpuint(opts_count(opts), ==, 1);
508     g_assert_cmpstr(qemu_opt_get(opts, "implied"), ==, "");
509 
510     /* Implied key with comma value */
511     opts = qemu_opts_parse(&opts_list_03, ",,,a=1", true, &error_abort);
512     g_assert_cmpuint(opts_count(opts), ==, 2);
513     g_assert_cmpstr(qemu_opt_get(opts, "implied"), ==, ",");
514     g_assert_cmpstr(qemu_opt_get(opts, "a"), ==, "1");
515 
516     /* Empty key is not an implied key */
517     opts = qemu_opts_parse(&opts_list_03, "=val", true, &error_abort);
518     g_assert_cmpuint(opts_count(opts), ==, 1);
519     g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "val");
520 
521     /* Unknown key */
522     opts = qemu_opts_parse(&opts_list_01, "nonexistent=", false, &err);
523     error_free_or_abort(&err);
524     g_assert(!opts);
525 
526     qemu_opts_reset(&opts_list_01);
527     qemu_opts_reset(&opts_list_03);
528 }
529 
530 static void test_opts_parse_bool(void)
531 {
532     Error *err = NULL;
533     QemuOpts *opts;
534 
535     opts = qemu_opts_parse(&opts_list_02, "bool1=on,bool2=off",
536                            false, &error_abort);
537     g_assert_cmpuint(opts_count(opts), ==, 2);
538     g_assert(qemu_opt_get_bool(opts, "bool1", false));
539     g_assert(!qemu_opt_get_bool(opts, "bool2", true));
540 
541     opts = qemu_opts_parse(&opts_list_02, "bool1=offer", false, &err);
542     error_free_or_abort(&err);
543     g_assert(!opts);
544 
545     qemu_opts_reset(&opts_list_02);
546 }
547 
548 static void test_opts_parse_number(void)
549 {
550     Error *err = NULL;
551     QemuOpts *opts;
552 
553     /* Lower limit zero */
554     opts = qemu_opts_parse(&opts_list_01, "number1=0", false, &error_abort);
555     g_assert_cmpuint(opts_count(opts), ==, 1);
556     g_assert_cmpuint(qemu_opt_get_number(opts, "number1", 1), ==, 0);
557 
558     /* Upper limit 2^64-1 */
559     opts = qemu_opts_parse(&opts_list_01,
560                            "number1=18446744073709551615,number2=-1",
561                            false, &error_abort);
562     g_assert_cmpuint(opts_count(opts), ==, 2);
563     g_assert_cmphex(qemu_opt_get_number(opts, "number1", 1), ==, UINT64_MAX);
564     g_assert_cmphex(qemu_opt_get_number(opts, "number2", 0), ==, UINT64_MAX);
565 
566     /* Above upper limit */
567     opts = qemu_opts_parse(&opts_list_01, "number1=18446744073709551616",
568                            false, &err);
569     error_free_or_abort(&err);
570     g_assert(!opts);
571 
572     /* Below lower limit */
573     opts = qemu_opts_parse(&opts_list_01, "number1=-18446744073709551616",
574                            false, &err);
575     error_free_or_abort(&err);
576     g_assert(!opts);
577 
578     /* Hex and octal */
579     opts = qemu_opts_parse(&opts_list_01, "number1=0x2a,number2=052",
580                            false, &error_abort);
581     g_assert_cmpuint(opts_count(opts), ==, 2);
582     g_assert_cmpuint(qemu_opt_get_number(opts, "number1", 1), ==, 42);
583     g_assert_cmpuint(qemu_opt_get_number(opts, "number2", 0), ==, 42);
584 
585     /* Invalid */
586     opts = qemu_opts_parse(&opts_list_01, "number1=", false, &err);
587     error_free_or_abort(&err);
588     g_assert(!opts);
589     opts = qemu_opts_parse(&opts_list_01, "number1=eins", false, &err);
590     error_free_or_abort(&err);
591     g_assert(!opts);
592 
593     /* Leading whitespace */
594     opts = qemu_opts_parse(&opts_list_01, "number1= \t42",
595                            false, &error_abort);
596     g_assert_cmpuint(opts_count(opts), ==, 1);
597     g_assert_cmpuint(qemu_opt_get_number(opts, "number1", 1), ==, 42);
598 
599     /* Trailing crap */
600     opts = qemu_opts_parse(&opts_list_01, "number1=3.14", false, &err);
601     error_free_or_abort(&err);
602     g_assert(!opts);
603     opts = qemu_opts_parse(&opts_list_01, "number1=08", false, &err);
604     error_free_or_abort(&err);
605     g_assert(!opts);
606     opts = qemu_opts_parse(&opts_list_01, "number1=0 ", false, &err);
607     error_free_or_abort(&err);
608     g_assert(!opts);
609 
610     qemu_opts_reset(&opts_list_01);
611 }
612 
613 static void test_opts_parse_size(void)
614 {
615     Error *err = NULL;
616     QemuOpts *opts;
617 
618     /* Lower limit zero */
619     opts = qemu_opts_parse(&opts_list_02, "size1=0", false, &error_abort);
620     g_assert_cmpuint(opts_count(opts), ==, 1);
621     g_assert_cmpuint(qemu_opt_get_size(opts, "size1", 1), ==, 0);
622 
623     /* Note: full 64 bits of precision */
624 
625     /* Around double limit of precision: 2^53-1, 2^53, 2^53+1 */
626     opts = qemu_opts_parse(&opts_list_02,
627                            "size1=9007199254740991,"
628                            "size2=9007199254740992,"
629                            "size3=9007199254740993",
630                            false, &error_abort);
631     g_assert_cmpuint(opts_count(opts), ==, 3);
632     g_assert_cmphex(qemu_opt_get_size(opts, "size1", 1),
633                      ==, 0x1fffffffffffff);
634     g_assert_cmphex(qemu_opt_get_size(opts, "size2", 1),
635                      ==, 0x20000000000000);
636     g_assert_cmphex(qemu_opt_get_size(opts, "size3", 1),
637                      ==, 0x20000000000001);
638 
639     /* Close to signed int limit: 2^63-1, 2^63, 2^63+1 */
640     opts = qemu_opts_parse(&opts_list_02,
641                            "size1=9223372036854775807," /* 7fffffffffffffff */
642                            "size2=9223372036854775808," /* 8000000000000000 */
643                            "size3=9223372036854775809", /* 8000000000000001 */
644                            false, &error_abort);
645     g_assert_cmpuint(opts_count(opts), ==, 3);
646     g_assert_cmphex(qemu_opt_get_size(opts, "size1", 1),
647                      ==, 0x7fffffffffffffff);
648     g_assert_cmphex(qemu_opt_get_size(opts, "size2", 1),
649                      ==, 0x8000000000000000);
650     g_assert_cmphex(qemu_opt_get_size(opts, "size3", 1),
651                      ==, 0x8000000000000001);
652 
653     /* Close to actual upper limit 0xfffffffffffff800 (53 msbs set) */
654     opts = qemu_opts_parse(&opts_list_02,
655                            "size1=18446744073709549568," /* fffffffffffff800 */
656                            "size2=18446744073709550591", /* fffffffffffffbff */
657                            false, &error_abort);
658     g_assert_cmpuint(opts_count(opts), ==, 2);
659     g_assert_cmphex(qemu_opt_get_size(opts, "size1", 1),
660                      ==, 0xfffffffffffff800);
661     g_assert_cmphex(qemu_opt_get_size(opts, "size2", 1),
662                      ==, 0xfffffffffffffbff);
663 
664     /* Actual limit, 2^64-1 */
665     opts = qemu_opts_parse(&opts_list_02,
666                            "size1=18446744073709551615", /* ffffffffffffffff */
667                            false, &error_abort);
668     g_assert_cmpuint(opts_count(opts), ==, 1);
669     g_assert_cmphex(qemu_opt_get_size(opts, "size1", 1),
670                      ==, 0xffffffffffffffff);
671 
672     /* Beyond limits */
673     opts = qemu_opts_parse(&opts_list_02, "size1=-1", false, &err);
674     error_free_or_abort(&err);
675     g_assert(!opts);
676     opts = qemu_opts_parse(&opts_list_02,
677                            "size1=18446744073709551616", /* 2^64 */
678                            false, &err);
679     error_free_or_abort(&err);
680     g_assert(!opts);
681 
682     /* Suffixes */
683     opts = qemu_opts_parse(&opts_list_02, "size1=8b,size2=1.5k,size3=2M",
684                            false, &error_abort);
685     g_assert_cmpuint(opts_count(opts), ==, 3);
686     g_assert_cmphex(qemu_opt_get_size(opts, "size1", 0), ==, 8);
687     g_assert_cmphex(qemu_opt_get_size(opts, "size2", 0), ==, 1536);
688     g_assert_cmphex(qemu_opt_get_size(opts, "size3", 0), ==, 2 * MiB);
689     opts = qemu_opts_parse(&opts_list_02, "size1=0.1G,size2=16777215T",
690                            false, &error_abort);
691     g_assert_cmpuint(opts_count(opts), ==, 2);
692     g_assert_cmphex(qemu_opt_get_size(opts, "size1", 0), ==, GiB / 10);
693     g_assert_cmphex(qemu_opt_get_size(opts, "size2", 0), ==, 16777215ULL * TiB);
694 
695     /* Beyond limit with suffix */
696     opts = qemu_opts_parse(&opts_list_02, "size1=16777216T",
697                            false, &err);
698     error_free_or_abort(&err);
699     g_assert(!opts);
700 
701     /* Trailing crap */
702     opts = qemu_opts_parse(&opts_list_02, "size1=16E", false, &err);
703     error_free_or_abort(&err);
704     g_assert(!opts);
705     opts = qemu_opts_parse(&opts_list_02, "size1=16Gi", false, &err);
706     error_free_or_abort(&err);
707     g_assert(!opts);
708 
709     qemu_opts_reset(&opts_list_02);
710 }
711 
712 static void test_has_help_option(void)
713 {
714     static const struct {
715         const char *params;
716         /* expected value of qemu_opt_has_help_opt() with implied=false */
717         bool expect;
718         /* expected value of qemu_opt_has_help_opt() with implied=true */
719         bool expect_implied;
720     } test[] = {
721         { "help", true, false },
722         { "?", true, false },
723         { "helpme", false, false },
724         { "?me", false, false },
725         { "a,help", true, true },
726         { "a,?", true, true },
727         { "a=0,help,b", true, true },
728         { "a=0,?,b", true, true },
729         { "help,b=1", true, false },
730         { "?,b=1", true, false },
731         { "a,b,,help", true, true },
732         { "a,b,,?", true, true },
733     };
734     int i;
735     QemuOpts *opts;
736 
737     for (i = 0; i < ARRAY_SIZE(test); i++) {
738         g_assert_cmpint(has_help_option(test[i].params),
739                         ==, test[i].expect);
740         opts = qemu_opts_parse(&opts_list_03, test[i].params, false,
741                                &error_abort);
742         g_assert_cmpint(qemu_opt_has_help_opt(opts),
743                         ==, test[i].expect);
744         qemu_opts_del(opts);
745         opts = qemu_opts_parse(&opts_list_03, test[i].params, true,
746                                &error_abort);
747         g_assert_cmpint(qemu_opt_has_help_opt(opts),
748                         ==, test[i].expect_implied);
749         qemu_opts_del(opts);
750     }
751 }
752 
753 static void append_verify_list_01(QemuOptDesc *desc, bool with_overlapping)
754 {
755     int i = 0;
756 
757     if (with_overlapping) {
758         g_assert_cmpstr(desc[i].name, ==, "str1");
759         g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
760         g_assert_cmpstr(desc[i].help, ==,
761                         "Help texts are preserved in qemu_opts_append");
762         g_assert_cmpstr(desc[i].def_value_str, ==, "default");
763         i++;
764 
765         g_assert_cmpstr(desc[i].name, ==, "str2");
766         g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
767         g_assert_cmpstr(desc[i].help, ==, NULL);
768         g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
769         i++;
770     }
771 
772     g_assert_cmpstr(desc[i].name, ==, "str3");
773     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
774     g_assert_cmpstr(desc[i].help, ==, NULL);
775     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
776     i++;
777 
778     g_assert_cmpstr(desc[i].name, ==, "number1");
779     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_NUMBER);
780     g_assert_cmpstr(desc[i].help, ==,
781                     "Having help texts only for some options is okay");
782     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
783     i++;
784 
785     g_assert_cmpstr(desc[i].name, ==, "number2");
786     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_NUMBER);
787     g_assert_cmpstr(desc[i].help, ==, NULL);
788     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
789     i++;
790 
791     g_assert_cmpstr(desc[i].name, ==, NULL);
792 }
793 
794 static void append_verify_list_02(QemuOptDesc *desc)
795 {
796     int i = 0;
797 
798     g_assert_cmpstr(desc[i].name, ==, "str1");
799     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
800     g_assert_cmpstr(desc[i].help, ==, NULL);
801     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
802     i++;
803 
804     g_assert_cmpstr(desc[i].name, ==, "str2");
805     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
806     g_assert_cmpstr(desc[i].help, ==, NULL);
807     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
808     i++;
809 
810     g_assert_cmpstr(desc[i].name, ==, "bool1");
811     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_BOOL);
812     g_assert_cmpstr(desc[i].help, ==, NULL);
813     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
814     i++;
815 
816     g_assert_cmpstr(desc[i].name, ==, "bool2");
817     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_BOOL);
818     g_assert_cmpstr(desc[i].help, ==, NULL);
819     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
820     i++;
821 
822     g_assert_cmpstr(desc[i].name, ==, "size1");
823     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
824     g_assert_cmpstr(desc[i].help, ==, NULL);
825     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
826     i++;
827 
828     g_assert_cmpstr(desc[i].name, ==, "size2");
829     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
830     g_assert_cmpstr(desc[i].help, ==, NULL);
831     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
832     i++;
833 
834     g_assert_cmpstr(desc[i].name, ==, "size3");
835     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
836     g_assert_cmpstr(desc[i].help, ==, NULL);
837     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
838 }
839 
840 static void test_opts_append_to_null(void)
841 {
842     QemuOptsList *merged;
843 
844     merged = qemu_opts_append(NULL, &opts_list_01);
845     g_assert(merged != &opts_list_01);
846 
847     g_assert_cmpstr(merged->name, ==, NULL);
848     g_assert_cmpstr(merged->implied_opt_name, ==, NULL);
849     g_assert_false(merged->merge_lists);
850 
851     append_verify_list_01(merged->desc, true);
852 
853     qemu_opts_free(merged);
854 }
855 
856 static void test_opts_append(void)
857 {
858     QemuOptsList *first, *merged;
859 
860     first = qemu_opts_append(NULL, &opts_list_02);
861     merged = qemu_opts_append(first, &opts_list_01);
862     g_assert(first != &opts_list_02);
863     g_assert(merged != &opts_list_01);
864 
865     g_assert_cmpstr(merged->name, ==, NULL);
866     g_assert_cmpstr(merged->implied_opt_name, ==, NULL);
867     g_assert_false(merged->merge_lists);
868 
869     append_verify_list_02(&merged->desc[0]);
870     append_verify_list_01(&merged->desc[7], false);
871 
872     qemu_opts_free(merged);
873 }
874 
875 static void test_opts_to_qdict_basic(void)
876 {
877     QemuOpts *opts;
878     QDict *dict;
879 
880     opts = qemu_opts_parse(&opts_list_01, "str1=foo,str2=,str3=bar,number1=42",
881                            false, &error_abort);
882     g_assert(opts != NULL);
883 
884     dict = qemu_opts_to_qdict(opts, NULL);
885     g_assert(dict != NULL);
886 
887     g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
888     g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
889     g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
890     g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
891     g_assert_false(qdict_haskey(dict, "number2"));
892 
893     qobject_unref(dict);
894     qemu_opts_del(opts);
895 }
896 
897 static void test_opts_to_qdict_filtered(void)
898 {
899     QemuOptsList *first, *merged;
900     QemuOpts *opts;
901     QDict *dict;
902 
903     first = qemu_opts_append(NULL, &opts_list_02);
904     merged = qemu_opts_append(first, &opts_list_01);
905 
906     opts = qemu_opts_parse(merged,
907                            "str1=foo,str2=,str3=bar,bool1=off,number1=42",
908                            false, &error_abort);
909     g_assert(opts != NULL);
910 
911     /* Convert to QDict without deleting from opts */
912     dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, false);
913     g_assert(dict != NULL);
914     g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
915     g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
916     g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
917     g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
918     g_assert_false(qdict_haskey(dict, "number2"));
919     g_assert_false(qdict_haskey(dict, "bool1"));
920     qobject_unref(dict);
921 
922     dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, false);
923     g_assert(dict != NULL);
924     g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
925     g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
926     g_assert_cmpstr(qdict_get_str(dict, "bool1"), ==, "off");
927     g_assert_false(qdict_haskey(dict, "str3"));
928     g_assert_false(qdict_haskey(dict, "number1"));
929     g_assert_false(qdict_haskey(dict, "number2"));
930     qobject_unref(dict);
931 
932     /* Now delete converted options from opts */
933     dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, true);
934     g_assert(dict != NULL);
935     g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
936     g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
937     g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
938     g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
939     g_assert_false(qdict_haskey(dict, "number2"));
940     g_assert_false(qdict_haskey(dict, "bool1"));
941     qobject_unref(dict);
942 
943     dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, true);
944     g_assert(dict != NULL);
945     g_assert_cmpstr(qdict_get_str(dict, "bool1"), ==, "off");
946     g_assert_false(qdict_haskey(dict, "str1"));
947     g_assert_false(qdict_haskey(dict, "str2"));
948     g_assert_false(qdict_haskey(dict, "str3"));
949     g_assert_false(qdict_haskey(dict, "number1"));
950     g_assert_false(qdict_haskey(dict, "number2"));
951     qobject_unref(dict);
952 
953     g_assert_true(QTAILQ_EMPTY(&opts->head));
954 
955     qemu_opts_del(opts);
956     qemu_opts_free(merged);
957 }
958 
959 static void test_opts_to_qdict_duplicates(void)
960 {
961     QemuOpts *opts;
962     QemuOpt *opt;
963     QDict *dict;
964 
965     opts = qemu_opts_parse(&opts_list_03, "foo=a,foo=b", false, &error_abort);
966     g_assert(opts != NULL);
967 
968     /* Verify that opts has two options with the same name */
969     opt = QTAILQ_FIRST(&opts->head);
970     g_assert_cmpstr(opt->name, ==, "foo");
971     g_assert_cmpstr(opt->str , ==, "a");
972 
973     opt = QTAILQ_NEXT(opt, next);
974     g_assert_cmpstr(opt->name, ==, "foo");
975     g_assert_cmpstr(opt->str , ==, "b");
976 
977     opt = QTAILQ_NEXT(opt, next);
978     g_assert(opt == NULL);
979 
980     /* In the conversion to QDict, the last one wins */
981     dict = qemu_opts_to_qdict(opts, NULL);
982     g_assert(dict != NULL);
983     g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
984     qobject_unref(dict);
985 
986     /* The last one still wins if entries are deleted, and both are deleted */
987     dict = qemu_opts_to_qdict_filtered(opts, NULL, NULL, true);
988     g_assert(dict != NULL);
989     g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
990     qobject_unref(dict);
991 
992     g_assert_true(QTAILQ_EMPTY(&opts->head));
993 
994     qemu_opts_del(opts);
995 }
996 
997 int main(int argc, char *argv[])
998 {
999     register_opts();
1000     g_test_init(&argc, &argv, NULL);
1001     g_test_add_func("/qemu-opts/find_unknown_opts", test_find_unknown_opts);
1002     g_test_add_func("/qemu-opts/find_opts", test_qemu_find_opts);
1003     g_test_add_func("/qemu-opts/opts_create", test_qemu_opts_create);
1004     g_test_add_func("/qemu-opts/opt_get", test_qemu_opt_get);
1005     g_test_add_func("/qemu-opts/opt_get_bool", test_qemu_opt_get_bool);
1006     g_test_add_func("/qemu-opts/opt_get_number", test_qemu_opt_get_number);
1007     g_test_add_func("/qemu-opts/opt_get_size", test_qemu_opt_get_size);
1008     g_test_add_func("/qemu-opts/opt_unset", test_qemu_opt_unset);
1009     g_test_add_func("/qemu-opts/opts_reset", test_qemu_opts_reset);
1010     g_test_add_func("/qemu-opts/opts_parse/general", test_opts_parse);
1011     g_test_add_func("/qemu-opts/opts_parse/bool", test_opts_parse_bool);
1012     g_test_add_func("/qemu-opts/opts_parse/number", test_opts_parse_number);
1013     g_test_add_func("/qemu-opts/opts_parse/size", test_opts_parse_size);
1014     g_test_add_func("/qemu-opts/has_help_option", test_has_help_option);
1015     g_test_add_func("/qemu-opts/append_to_null", test_opts_append_to_null);
1016     g_test_add_func("/qemu-opts/append", test_opts_append);
1017     g_test_add_func("/qemu-opts/to_qdict/basic", test_opts_to_qdict_basic);
1018     g_test_add_func("/qemu-opts/to_qdict/filtered", test_opts_to_qdict_filtered);
1019     g_test_add_func("/qemu-opts/to_qdict/duplicates", test_opts_to_qdict_duplicates);
1020     g_test_run();
1021     return 0;
1022 }
1023