4 * Copyright (C) 2014 Leandro Dorileo <l@dorileo.org>
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.
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"
20 static QemuOptsList opts_list_01
= {
21 .name
= "opts_list_01",
22 .head
= QTAILQ_HEAD_INITIALIZER(opts_list_01
.head
),
26 .type
= QEMU_OPT_STRING
,
27 .help
= "Help texts are preserved in qemu_opts_append",
28 .def_value_str
= "default",
31 .type
= QEMU_OPT_STRING
,
34 .type
= QEMU_OPT_STRING
,
37 .type
= QEMU_OPT_NUMBER
,
38 .help
= "Having help texts only for some options is okay",
41 .type
= QEMU_OPT_NUMBER
,
47 static QemuOptsList opts_list_02
= {
48 .name
= "opts_list_02",
49 .head
= QTAILQ_HEAD_INITIALIZER(opts_list_02
.head
),
53 .type
= QEMU_OPT_STRING
,
56 .type
= QEMU_OPT_STRING
,
59 .type
= QEMU_OPT_BOOL
,
62 .type
= QEMU_OPT_BOOL
,
65 .type
= QEMU_OPT_SIZE
,
68 .type
= QEMU_OPT_SIZE
,
71 .type
= QEMU_OPT_SIZE
,
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
),
82 /* no elements => accept any params */
87 static void register_opts(void)
89 qemu_add_opts(&opts_list_01
);
90 qemu_add_opts(&opts_list_02
);
91 qemu_add_opts(&opts_list_03
);
94 static void test_find_unknown_opts(void)
99 /* should not return anything, we don't have an "unknown" option */
100 list
= qemu_find_opts_err("unknown", &err
);
101 g_assert(list
== NULL
);
102 error_free_or_abort(&err
);
105 static void test_qemu_find_opts(void)
109 /* we have an "opts_list_01" option, should return it */
110 list
= qemu_find_opts("opts_list_01");
111 g_assert(list
!= NULL
);
112 g_assert_cmpstr(list
->name
, ==, "opts_list_01");
115 static void test_qemu_opts_create(void)
120 list
= qemu_find_opts("opts_list_01");
121 g_assert(list
!= NULL
);
122 g_assert(QTAILQ_EMPTY(&list
->head
));
123 g_assert_cmpstr(list
->name
, ==, "opts_list_01");
125 /* should not find anything at this point */
126 opts
= qemu_opts_find(list
, NULL
);
127 g_assert(opts
== NULL
);
129 /* create the opts */
130 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
131 g_assert(opts
!= NULL
);
132 g_assert(!QTAILQ_EMPTY(&list
->head
));
134 /* now we've create the opts, must find it */
135 opts
= qemu_opts_find(list
, NULL
);
136 g_assert(opts
!= NULL
);
140 /* should not find anything at this point */
141 opts
= qemu_opts_find(list
, NULL
);
142 g_assert(opts
== NULL
);
145 static void test_qemu_opt_get(void)
149 const char *opt
= NULL
;
151 list
= qemu_find_opts("opts_list_01");
152 g_assert(list
!= NULL
);
153 g_assert(QTAILQ_EMPTY(&list
->head
));
154 g_assert_cmpstr(list
->name
, ==, "opts_list_01");
156 /* should not find anything at this point */
157 opts
= qemu_opts_find(list
, NULL
);
158 g_assert(opts
== NULL
);
160 /* create the opts */
161 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
162 g_assert(opts
!= NULL
);
163 g_assert(!QTAILQ_EMPTY(&list
->head
));
165 /* haven't set anything to str2 yet */
166 opt
= qemu_opt_get(opts
, "str2");
167 g_assert(opt
== NULL
);
169 qemu_opt_set(opts
, "str2", "value", &error_abort
);
171 /* now we have set str2, should know about it */
172 opt
= qemu_opt_get(opts
, "str2");
173 g_assert_cmpstr(opt
, ==, "value");
175 qemu_opt_set(opts
, "str2", "value2", &error_abort
);
177 /* having reset the value, the returned should be the reset one */
178 opt
= qemu_opt_get(opts
, "str2");
179 g_assert_cmpstr(opt
, ==, "value2");
183 /* should not find anything at this point */
184 opts
= qemu_opts_find(list
, NULL
);
185 g_assert(opts
== NULL
);
188 static void test_qemu_opt_get_bool(void)
195 list
= qemu_find_opts("opts_list_02");
196 g_assert(list
!= NULL
);
197 g_assert(QTAILQ_EMPTY(&list
->head
));
198 g_assert_cmpstr(list
->name
, ==, "opts_list_02");
200 /* should not find anything at this point */
201 opts
= qemu_opts_find(list
, NULL
);
202 g_assert(opts
== NULL
);
204 /* create the opts */
205 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
206 g_assert(opts
!= NULL
);
207 g_assert(!QTAILQ_EMPTY(&list
->head
));
209 /* haven't set anything to bool1 yet, so defval should be returned */
210 opt
= qemu_opt_get_bool(opts
, "bool1", false);
211 g_assert(opt
== false);
213 qemu_opt_set_bool(opts
, "bool1", true, &err
);
216 /* now we have set bool1, should know about it */
217 opt
= qemu_opt_get_bool(opts
, "bool1", false);
218 g_assert(opt
== true);
220 /* having reset the value, opt should be the reset one not defval */
221 qemu_opt_set_bool(opts
, "bool1", false, &err
);
224 opt
= qemu_opt_get_bool(opts
, "bool1", true);
225 g_assert(opt
== false);
229 /* should not find anything at this point */
230 opts
= qemu_opts_find(list
, NULL
);
231 g_assert(opts
== NULL
);
234 static void test_qemu_opt_get_number(void)
241 list
= qemu_find_opts("opts_list_01");
242 g_assert(list
!= NULL
);
243 g_assert(QTAILQ_EMPTY(&list
->head
));
244 g_assert_cmpstr(list
->name
, ==, "opts_list_01");
246 /* should not find anything at this point */
247 opts
= qemu_opts_find(list
, NULL
);
248 g_assert(opts
== NULL
);
250 /* create the opts */
251 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
252 g_assert(opts
!= NULL
);
253 g_assert(!QTAILQ_EMPTY(&list
->head
));
255 /* haven't set anything to number1 yet, so defval should be returned */
256 opt
= qemu_opt_get_number(opts
, "number1", 5);
259 qemu_opt_set_number(opts
, "number1", 10, &err
);
262 /* now we have set number1, should know about it */
263 opt
= qemu_opt_get_number(opts
, "number1", 5);
266 /* having reset it, the returned should be the reset one not defval */
267 qemu_opt_set_number(opts
, "number1", 15, &err
);
270 opt
= qemu_opt_get_number(opts
, "number1", 5);
275 /* should not find anything at this point */
276 opts
= qemu_opts_find(list
, NULL
);
277 g_assert(opts
== NULL
);
280 static void test_qemu_opt_get_size(void)
287 list
= qemu_find_opts("opts_list_02");
288 g_assert(list
!= NULL
);
289 g_assert(QTAILQ_EMPTY(&list
->head
));
290 g_assert_cmpstr(list
->name
, ==, "opts_list_02");
292 /* should not find anything at this point */
293 opts
= qemu_opts_find(list
, NULL
);
294 g_assert(opts
== NULL
);
296 /* create the opts */
297 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
298 g_assert(opts
!= NULL
);
299 g_assert(!QTAILQ_EMPTY(&list
->head
));
301 /* haven't set anything to size1 yet, so defval should be returned */
302 opt
= qemu_opt_get_size(opts
, "size1", 5);
306 g_assert(dict
!= NULL
);
308 qdict_put_str(dict
, "size1", "10");
310 qemu_opts_absorb_qdict(opts
, dict
, &error_abort
);
311 g_assert(error_abort
== NULL
);
313 /* now we have set size1, should know about it */
314 opt
= qemu_opt_get_size(opts
, "size1", 5);
318 qdict_put_str(dict
, "size1", "15");
320 qemu_opts_absorb_qdict(opts
, dict
, &error_abort
);
321 g_assert(error_abort
== NULL
);
323 /* test the reset value */
324 opt
= qemu_opt_get_size(opts
, "size1", 5);
327 qdict_del(dict
, "size1");
332 /* should not find anything at this point */
333 opts
= qemu_opts_find(list
, NULL
);
334 g_assert(opts
== NULL
);
337 static void test_qemu_opt_unset(void)
343 /* dynamically initialized (parsed) opts */
344 opts
= qemu_opts_parse(&opts_list_03
, "key=value", false, NULL
);
345 g_assert(opts
!= NULL
);
347 /* check default/parsed value */
348 value
= qemu_opt_get(opts
, "key");
349 g_assert_cmpstr(value
, ==, "value");
351 /* reset it to value2 */
352 qemu_opt_set(opts
, "key", "value2", &error_abort
);
354 value
= qemu_opt_get(opts
, "key");
355 g_assert_cmpstr(value
, ==, "value2");
357 /* unset, valid only for "accept any" */
358 ret
= qemu_opt_unset(opts
, "key");
361 /* after reset the value should be the parsed/default one */
362 value
= qemu_opt_get(opts
, "key");
363 g_assert_cmpstr(value
, ==, "value");
368 static void test_qemu_opts_reset(void)
375 list
= qemu_find_opts("opts_list_01");
376 g_assert(list
!= NULL
);
377 g_assert(QTAILQ_EMPTY(&list
->head
));
378 g_assert_cmpstr(list
->name
, ==, "opts_list_01");
380 /* should not find anything at this point */
381 opts
= qemu_opts_find(list
, NULL
);
382 g_assert(opts
== NULL
);
384 /* create the opts */
385 opts
= qemu_opts_create(list
, NULL
, 0, &error_abort
);
386 g_assert(opts
!= NULL
);
387 g_assert(!QTAILQ_EMPTY(&list
->head
));
389 /* haven't set anything to number1 yet, so defval should be returned */
390 opt
= qemu_opt_get_number(opts
, "number1", 5);
393 qemu_opt_set_number(opts
, "number1", 10, &err
);
396 /* now we have set number1, should know about it */
397 opt
= qemu_opt_get_number(opts
, "number1", 5);
400 qemu_opts_reset(list
);
402 /* should not find anything at this point */
403 opts
= qemu_opts_find(list
, NULL
);
404 g_assert(opts
== NULL
);
407 static void test_qemu_opts_set(void)
414 list
= qemu_find_opts("opts_list_01");
415 g_assert(list
!= NULL
);
416 g_assert(QTAILQ_EMPTY(&list
->head
));
417 g_assert_cmpstr(list
->name
, ==, "opts_list_01");
419 /* should not find anything at this point */
420 opts
= qemu_opts_find(list
, NULL
);
421 g_assert(opts
== NULL
);
423 /* implicitly create opts and set str3 value */
424 qemu_opts_set(list
, NULL
, "str3", "value", &err
);
426 g_assert(!QTAILQ_EMPTY(&list
->head
));
428 /* get the just created opts */
429 opts
= qemu_opts_find(list
, NULL
);
430 g_assert(opts
!= NULL
);
432 /* check the str3 value */
433 opt
= qemu_opt_get(opts
, "str3");
434 g_assert_cmpstr(opt
, ==, "value");
438 /* should not find anything at this point */
439 opts
= qemu_opts_find(list
, NULL
);
440 g_assert(opts
== NULL
);
443 static int opts_count_iter(void *opaque
, const char *name
, const char *value
,
446 (*(size_t *)opaque
)++;
450 static size_t opts_count(QemuOpts
*opts
)
454 qemu_opt_foreach(opts
, opts_count_iter
, &n
, NULL
);
458 static void test_opts_parse(void)
464 opts
= qemu_opts_parse(&opts_list_03
, "", false, &error_abort
);
465 g_assert_cmpuint(opts_count(opts
), ==, 0);
468 opts
= qemu_opts_parse(&opts_list_03
, "=val", false, &error_abort
);
469 g_assert_cmpuint(opts_count(opts
), ==, 1);
470 g_assert_cmpstr(qemu_opt_get(opts
, ""), ==, "val");
472 /* Multiple keys, last one wins */
473 opts
= qemu_opts_parse(&opts_list_03
, "a=1,b=2,,x,a=3",
474 false, &error_abort
);
475 g_assert_cmpuint(opts_count(opts
), ==, 3);
476 g_assert_cmpstr(qemu_opt_get(opts
, "a"), ==, "3");
477 g_assert_cmpstr(qemu_opt_get(opts
, "b"), ==, "2,x");
479 /* Except when it doesn't */
480 opts
= qemu_opts_parse(&opts_list_03
, "id=foo,id=bar",
481 false, &error_abort
);
482 g_assert_cmpuint(opts_count(opts
), ==, 0);
483 g_assert_cmpstr(qemu_opts_id(opts
), ==, "foo");
485 /* TODO Cover low-level access to repeated keys */
487 /* Trailing comma is ignored */
488 opts
= qemu_opts_parse(&opts_list_03
, "x=y,", false, &error_abort
);
489 g_assert_cmpuint(opts_count(opts
), ==, 1);
490 g_assert_cmpstr(qemu_opt_get(opts
, "x"), ==, "y");
492 /* Except when it isn't */
493 opts
= qemu_opts_parse(&opts_list_03
, ",", false, &error_abort
);
494 g_assert_cmpuint(opts_count(opts
), ==, 1);
495 g_assert_cmpstr(qemu_opt_get(opts
, ""), ==, "on");
498 opts
= qemu_opts_parse(&opts_list_03
, "x=y,id=foo", false, &err
);
499 error_free_or_abort(&err
);
501 /* TODO Cover .merge_lists = true */
503 /* Buggy ID recognition */
504 opts
= qemu_opts_parse(&opts_list_03
, "x=,,id=bar", false, &error_abort
);
505 g_assert_cmpuint(opts_count(opts
), ==, 1);
506 g_assert_cmpstr(qemu_opts_id(opts
), ==, "bar"); /* BUG */
507 g_assert_cmpstr(qemu_opt_get(opts
, "x"), ==, ",id=bar");
510 opts
= qemu_opts_parse(&opts_list_01
, "id=666", false, &err
);
511 error_free_or_abort(&err
);
515 opts
= qemu_opts_parse(&opts_list_03
, "an,noaus,noaus=",
516 false, &error_abort
);
517 g_assert_cmpuint(opts_count(opts
), ==, 3);
518 g_assert_cmpstr(qemu_opt_get(opts
, "an"), ==, "on");
519 g_assert_cmpstr(qemu_opt_get(opts
, "aus"), ==, "off");
520 g_assert_cmpstr(qemu_opt_get(opts
, "noaus"), ==, "");
522 /* Implied value, negated empty key */
523 opts
= qemu_opts_parse(&opts_list_03
, "no", false, &error_abort
);
524 g_assert_cmpuint(opts_count(opts
), ==, 1);
525 g_assert_cmpstr(qemu_opt_get(opts
, ""), ==, "off");
528 opts
= qemu_opts_parse(&opts_list_03
, "an,noaus,noaus=", true,
530 g_assert_cmpuint(opts_count(opts
), ==, 3);
531 g_assert_cmpstr(qemu_opt_get(opts
, "implied"), ==, "an");
532 g_assert_cmpstr(qemu_opt_get(opts
, "aus"), ==, "off");
533 g_assert_cmpstr(qemu_opt_get(opts
, "noaus"), ==, "");
535 /* Implied key with empty value */
536 opts
= qemu_opts_parse(&opts_list_03
, ",", true, &error_abort
);
537 g_assert_cmpuint(opts_count(opts
), ==, 1);
538 g_assert_cmpstr(qemu_opt_get(opts
, "implied"), ==, "");
540 /* Implied key with comma value */
541 opts
= qemu_opts_parse(&opts_list_03
, ",,,a=1", true, &error_abort
);
542 g_assert_cmpuint(opts_count(opts
), ==, 2);
543 g_assert_cmpstr(qemu_opt_get(opts
, "implied"), ==, ",");
544 g_assert_cmpstr(qemu_opt_get(opts
, "a"), ==, "1");
546 /* Empty key is not an implied key */
547 opts
= qemu_opts_parse(&opts_list_03
, "=val", true, &error_abort
);
548 g_assert_cmpuint(opts_count(opts
), ==, 1);
549 g_assert_cmpstr(qemu_opt_get(opts
, ""), ==, "val");
552 opts
= qemu_opts_parse(&opts_list_01
, "nonexistent=", false, &err
);
553 error_free_or_abort(&err
);
556 qemu_opts_reset(&opts_list_01
);
557 qemu_opts_reset(&opts_list_03
);
560 static void test_opts_parse_bool(void)
565 opts
= qemu_opts_parse(&opts_list_02
, "bool1=on,bool2=off",
566 false, &error_abort
);
567 g_assert_cmpuint(opts_count(opts
), ==, 2);
568 g_assert(qemu_opt_get_bool(opts
, "bool1", false));
569 g_assert(!qemu_opt_get_bool(opts
, "bool2", true));
571 opts
= qemu_opts_parse(&opts_list_02
, "bool1=offer", false, &err
);
572 error_free_or_abort(&err
);
575 qemu_opts_reset(&opts_list_02
);
578 static void test_opts_parse_number(void)
583 /* Lower limit zero */
584 opts
= qemu_opts_parse(&opts_list_01
, "number1=0", false, &error_abort
);
585 g_assert_cmpuint(opts_count(opts
), ==, 1);
586 g_assert_cmpuint(qemu_opt_get_number(opts
, "number1", 1), ==, 0);
588 /* Upper limit 2^64-1 */
589 opts
= qemu_opts_parse(&opts_list_01
,
590 "number1=18446744073709551615,number2=-1",
591 false, &error_abort
);
592 g_assert_cmpuint(opts_count(opts
), ==, 2);
593 g_assert_cmphex(qemu_opt_get_number(opts
, "number1", 1), ==, UINT64_MAX
);
594 g_assert_cmphex(qemu_opt_get_number(opts
, "number2", 0), ==, UINT64_MAX
);
596 /* Above upper limit */
597 opts
= qemu_opts_parse(&opts_list_01
, "number1=18446744073709551616",
599 error_free_or_abort(&err
);
602 /* Below lower limit */
603 opts
= qemu_opts_parse(&opts_list_01
, "number1=-18446744073709551616",
605 error_free_or_abort(&err
);
609 opts
= qemu_opts_parse(&opts_list_01
, "number1=0x2a,number2=052",
610 false, &error_abort
);
611 g_assert_cmpuint(opts_count(opts
), ==, 2);
612 g_assert_cmpuint(qemu_opt_get_number(opts
, "number1", 1), ==, 42);
613 g_assert_cmpuint(qemu_opt_get_number(opts
, "number2", 0), ==, 42);
616 opts
= qemu_opts_parse(&opts_list_01
, "number1=", false, &err
);
617 error_free_or_abort(&err
);
619 opts
= qemu_opts_parse(&opts_list_01
, "number1=eins", false, &err
);
620 error_free_or_abort(&err
);
623 /* Leading whitespace */
624 opts
= qemu_opts_parse(&opts_list_01
, "number1= \t42",
625 false, &error_abort
);
626 g_assert_cmpuint(opts_count(opts
), ==, 1);
627 g_assert_cmpuint(qemu_opt_get_number(opts
, "number1", 1), ==, 42);
630 opts
= qemu_opts_parse(&opts_list_01
, "number1=3.14", false, &err
);
631 error_free_or_abort(&err
);
633 opts
= qemu_opts_parse(&opts_list_01
, "number1=08", false, &err
);
634 error_free_or_abort(&err
);
636 opts
= qemu_opts_parse(&opts_list_01
, "number1=0 ", false, &err
);
637 error_free_or_abort(&err
);
640 qemu_opts_reset(&opts_list_01
);
643 static void test_opts_parse_size(void)
648 /* Lower limit zero */
649 opts
= qemu_opts_parse(&opts_list_02
, "size1=0", false, &error_abort
);
650 g_assert_cmpuint(opts_count(opts
), ==, 1);
651 g_assert_cmpuint(qemu_opt_get_size(opts
, "size1", 1), ==, 0);
653 /* Note: precision is 53 bits since we're parsing with strtod() */
655 /* Around limit of precision: 2^53-1, 2^53, 2^54 */
656 opts
= qemu_opts_parse(&opts_list_02
,
657 "size1=9007199254740991,"
658 "size2=9007199254740992,"
659 "size3=9007199254740993",
660 false, &error_abort
);
661 g_assert_cmpuint(opts_count(opts
), ==, 3);
662 g_assert_cmphex(qemu_opt_get_size(opts
, "size1", 1),
663 ==, 0x1fffffffffffff);
664 g_assert_cmphex(qemu_opt_get_size(opts
, "size2", 1),
665 ==, 0x20000000000000);
666 g_assert_cmphex(qemu_opt_get_size(opts
, "size3", 1),
667 ==, 0x20000000000000);
669 /* Close to signed upper limit 0x7ffffffffffffc00 (53 msbs set) */
670 opts
= qemu_opts_parse(&opts_list_02
,
671 "size1=9223372036854774784," /* 7ffffffffffffc00 */
672 "size2=9223372036854775295", /* 7ffffffffffffdff */
673 false, &error_abort
);
674 g_assert_cmpuint(opts_count(opts
), ==, 2);
675 g_assert_cmphex(qemu_opt_get_size(opts
, "size1", 1),
676 ==, 0x7ffffffffffffc00);
677 g_assert_cmphex(qemu_opt_get_size(opts
, "size2", 1),
678 ==, 0x7ffffffffffffc00);
680 /* Close to actual upper limit 0xfffffffffffff800 (53 msbs set) */
681 opts
= qemu_opts_parse(&opts_list_02
,
682 "size1=18446744073709549568," /* fffffffffffff800 */
683 "size2=18446744073709550591", /* fffffffffffffbff */
684 false, &error_abort
);
685 g_assert_cmpuint(opts_count(opts
), ==, 2);
686 g_assert_cmphex(qemu_opt_get_size(opts
, "size1", 1),
687 ==, 0xfffffffffffff800);
688 g_assert_cmphex(qemu_opt_get_size(opts
, "size2", 1),
689 ==, 0xfffffffffffff800);
692 opts
= qemu_opts_parse(&opts_list_02
, "size1=-1", false, &err
);
693 error_free_or_abort(&err
);
695 opts
= qemu_opts_parse(&opts_list_02
,
696 "size1=18446744073709550592", /* fffffffffffffc00 */
698 error_free_or_abort(&err
);
702 opts
= qemu_opts_parse(&opts_list_02
, "size1=8b,size2=1.5k,size3=2M",
703 false, &error_abort
);
704 g_assert_cmpuint(opts_count(opts
), ==, 3);
705 g_assert_cmphex(qemu_opt_get_size(opts
, "size1", 0), ==, 8);
706 g_assert_cmphex(qemu_opt_get_size(opts
, "size2", 0), ==, 1536);
707 g_assert_cmphex(qemu_opt_get_size(opts
, "size3", 0), ==, 2 * MiB
);
708 opts
= qemu_opts_parse(&opts_list_02
, "size1=0.1G,size2=16777215T",
709 false, &error_abort
);
710 g_assert_cmpuint(opts_count(opts
), ==, 2);
711 g_assert_cmphex(qemu_opt_get_size(opts
, "size1", 0), ==, GiB
/ 10);
712 g_assert_cmphex(qemu_opt_get_size(opts
, "size2", 0), ==, 16777215ULL * TiB
);
714 /* Beyond limit with suffix */
715 opts
= qemu_opts_parse(&opts_list_02
, "size1=16777216T",
717 error_free_or_abort(&err
);
721 opts
= qemu_opts_parse(&opts_list_02
, "size1=16E", false, &err
);
722 error_free_or_abort(&err
);
724 opts
= qemu_opts_parse(&opts_list_02
, "size1=16Gi", false, &err
);
725 error_free_or_abort(&err
);
728 qemu_opts_reset(&opts_list_02
);
731 static void append_verify_list_01(QemuOptDesc
*desc
, bool with_overlapping
)
735 if (with_overlapping
) {
736 g_assert_cmpstr(desc
[i
].name
, ==, "str1");
737 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_STRING
);
738 g_assert_cmpstr(desc
[i
].help
, ==,
739 "Help texts are preserved in qemu_opts_append");
740 g_assert_cmpstr(desc
[i
].def_value_str
, ==, "default");
743 g_assert_cmpstr(desc
[i
].name
, ==, "str2");
744 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_STRING
);
745 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
746 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
750 g_assert_cmpstr(desc
[i
].name
, ==, "str3");
751 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_STRING
);
752 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
753 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
756 g_assert_cmpstr(desc
[i
].name
, ==, "number1");
757 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_NUMBER
);
758 g_assert_cmpstr(desc
[i
].help
, ==,
759 "Having help texts only for some options is okay");
760 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
763 g_assert_cmpstr(desc
[i
].name
, ==, "number2");
764 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_NUMBER
);
765 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
766 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
769 g_assert_cmpstr(desc
[i
].name
, ==, NULL
);
772 static void append_verify_list_02(QemuOptDesc
*desc
)
776 g_assert_cmpstr(desc
[i
].name
, ==, "str1");
777 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_STRING
);
778 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
779 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
782 g_assert_cmpstr(desc
[i
].name
, ==, "str2");
783 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_STRING
);
784 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
785 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
788 g_assert_cmpstr(desc
[i
].name
, ==, "bool1");
789 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_BOOL
);
790 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
791 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
794 g_assert_cmpstr(desc
[i
].name
, ==, "bool2");
795 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_BOOL
);
796 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
797 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
800 g_assert_cmpstr(desc
[i
].name
, ==, "size1");
801 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_SIZE
);
802 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
803 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
806 g_assert_cmpstr(desc
[i
].name
, ==, "size2");
807 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_SIZE
);
808 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
809 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
812 g_assert_cmpstr(desc
[i
].name
, ==, "size3");
813 g_assert_cmpint(desc
[i
].type
, ==, QEMU_OPT_SIZE
);
814 g_assert_cmpstr(desc
[i
].help
, ==, NULL
);
815 g_assert_cmpstr(desc
[i
].def_value_str
, ==, NULL
);
818 static void test_opts_append_to_null(void)
820 QemuOptsList
*merged
;
822 merged
= qemu_opts_append(NULL
, &opts_list_01
);
823 g_assert(merged
!= &opts_list_01
);
825 g_assert_cmpstr(merged
->name
, ==, NULL
);
826 g_assert_cmpstr(merged
->implied_opt_name
, ==, NULL
);
827 g_assert_false(merged
->merge_lists
);
829 append_verify_list_01(merged
->desc
, true);
831 qemu_opts_free(merged
);
834 static void test_opts_append(void)
836 QemuOptsList
*first
, *merged
;
838 first
= qemu_opts_append(NULL
, &opts_list_02
);
839 merged
= qemu_opts_append(first
, &opts_list_01
);
840 g_assert(first
!= &opts_list_02
);
841 g_assert(merged
!= &opts_list_01
);
843 g_assert_cmpstr(merged
->name
, ==, NULL
);
844 g_assert_cmpstr(merged
->implied_opt_name
, ==, NULL
);
845 g_assert_false(merged
->merge_lists
);
847 append_verify_list_02(&merged
->desc
[0]);
848 append_verify_list_01(&merged
->desc
[7], false);
850 qemu_opts_free(merged
);
853 static void test_opts_to_qdict_basic(void)
858 opts
= qemu_opts_parse(&opts_list_01
, "str1=foo,str2=,str3=bar,number1=42",
859 false, &error_abort
);
860 g_assert(opts
!= NULL
);
862 dict
= qemu_opts_to_qdict(opts
, NULL
);
863 g_assert(dict
!= NULL
);
865 g_assert_cmpstr(qdict_get_str(dict
, "str1"), ==, "foo");
866 g_assert_cmpstr(qdict_get_str(dict
, "str2"), ==, "");
867 g_assert_cmpstr(qdict_get_str(dict
, "str3"), ==, "bar");
868 g_assert_cmpstr(qdict_get_str(dict
, "number1"), ==, "42");
869 g_assert_false(qdict_haskey(dict
, "number2"));
875 static void test_opts_to_qdict_filtered(void)
877 QemuOptsList
*first
, *merged
;
881 first
= qemu_opts_append(NULL
, &opts_list_02
);
882 merged
= qemu_opts_append(first
, &opts_list_01
);
884 opts
= qemu_opts_parse(merged
,
885 "str1=foo,str2=,str3=bar,bool1=off,number1=42",
886 false, &error_abort
);
887 g_assert(opts
!= NULL
);
889 /* Convert to QDict without deleting from opts */
890 dict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &opts_list_01
, false);
891 g_assert(dict
!= NULL
);
892 g_assert_cmpstr(qdict_get_str(dict
, "str1"), ==, "foo");
893 g_assert_cmpstr(qdict_get_str(dict
, "str2"), ==, "");
894 g_assert_cmpstr(qdict_get_str(dict
, "str3"), ==, "bar");
895 g_assert_cmpstr(qdict_get_str(dict
, "number1"), ==, "42");
896 g_assert_false(qdict_haskey(dict
, "number2"));
897 g_assert_false(qdict_haskey(dict
, "bool1"));
900 dict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &opts_list_02
, false);
901 g_assert(dict
!= NULL
);
902 g_assert_cmpstr(qdict_get_str(dict
, "str1"), ==, "foo");
903 g_assert_cmpstr(qdict_get_str(dict
, "str2"), ==, "");
904 g_assert_cmpstr(qdict_get_str(dict
, "bool1"), ==, "off");
905 g_assert_false(qdict_haskey(dict
, "str3"));
906 g_assert_false(qdict_haskey(dict
, "number1"));
907 g_assert_false(qdict_haskey(dict
, "number2"));
910 /* Now delete converted options from opts */
911 dict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &opts_list_01
, true);
912 g_assert(dict
!= NULL
);
913 g_assert_cmpstr(qdict_get_str(dict
, "str1"), ==, "foo");
914 g_assert_cmpstr(qdict_get_str(dict
, "str2"), ==, "");
915 g_assert_cmpstr(qdict_get_str(dict
, "str3"), ==, "bar");
916 g_assert_cmpstr(qdict_get_str(dict
, "number1"), ==, "42");
917 g_assert_false(qdict_haskey(dict
, "number2"));
918 g_assert_false(qdict_haskey(dict
, "bool1"));
921 dict
= qemu_opts_to_qdict_filtered(opts
, NULL
, &opts_list_02
, true);
922 g_assert(dict
!= NULL
);
923 g_assert_cmpstr(qdict_get_str(dict
, "bool1"), ==, "off");
924 g_assert_false(qdict_haskey(dict
, "str1"));
925 g_assert_false(qdict_haskey(dict
, "str2"));
926 g_assert_false(qdict_haskey(dict
, "str3"));
927 g_assert_false(qdict_haskey(dict
, "number1"));
928 g_assert_false(qdict_haskey(dict
, "number2"));
931 g_assert_true(QTAILQ_EMPTY(&opts
->head
));
934 qemu_opts_free(merged
);
937 static void test_opts_to_qdict_duplicates(void)
943 opts
= qemu_opts_parse(&opts_list_03
, "foo=a,foo=b", false, &error_abort
);
944 g_assert(opts
!= NULL
);
946 /* Verify that opts has two options with the same name */
947 opt
= QTAILQ_FIRST(&opts
->head
);
948 g_assert_cmpstr(opt
->name
, ==, "foo");
949 g_assert_cmpstr(opt
->str
, ==, "a");
951 opt
= QTAILQ_NEXT(opt
, next
);
952 g_assert_cmpstr(opt
->name
, ==, "foo");
953 g_assert_cmpstr(opt
->str
, ==, "b");
955 opt
= QTAILQ_NEXT(opt
, next
);
956 g_assert(opt
== NULL
);
958 /* In the conversion to QDict, the last one wins */
959 dict
= qemu_opts_to_qdict(opts
, NULL
);
960 g_assert(dict
!= NULL
);
961 g_assert_cmpstr(qdict_get_str(dict
, "foo"), ==, "b");
964 /* The last one still wins if entries are deleted, and both are deleted */
965 dict
= qemu_opts_to_qdict_filtered(opts
, NULL
, NULL
, true);
966 g_assert(dict
!= NULL
);
967 g_assert_cmpstr(qdict_get_str(dict
, "foo"), ==, "b");
970 g_assert_true(QTAILQ_EMPTY(&opts
->head
));
975 int main(int argc
, char *argv
[])
978 g_test_init(&argc
, &argv
, NULL
);
979 g_test_add_func("/qemu-opts/find_unknown_opts", test_find_unknown_opts
);
980 g_test_add_func("/qemu-opts/find_opts", test_qemu_find_opts
);
981 g_test_add_func("/qemu-opts/opts_create", test_qemu_opts_create
);
982 g_test_add_func("/qemu-opts/opt_get", test_qemu_opt_get
);
983 g_test_add_func("/qemu-opts/opt_get_bool", test_qemu_opt_get_bool
);
984 g_test_add_func("/qemu-opts/opt_get_number", test_qemu_opt_get_number
);
985 g_test_add_func("/qemu-opts/opt_get_size", test_qemu_opt_get_size
);
986 g_test_add_func("/qemu-opts/opt_unset", test_qemu_opt_unset
);
987 g_test_add_func("/qemu-opts/opts_reset", test_qemu_opts_reset
);
988 g_test_add_func("/qemu-opts/opts_set", test_qemu_opts_set
);
989 g_test_add_func("/qemu-opts/opts_parse/general", test_opts_parse
);
990 g_test_add_func("/qemu-opts/opts_parse/bool", test_opts_parse_bool
);
991 g_test_add_func("/qemu-opts/opts_parse/number", test_opts_parse_number
);
992 g_test_add_func("/qemu-opts/opts_parse/size", test_opts_parse_size
);
993 g_test_add_func("/qemu-opts/append_to_null", test_opts_append_to_null
);
994 g_test_add_func("/qemu-opts/append", test_opts_append
);
995 g_test_add_func("/qemu-opts/to_qdict/basic", test_opts_to_qdict_basic
);
996 g_test_add_func("/qemu-opts/to_qdict/filtered", test_opts_to_qdict_filtered
);
997 g_test_add_func("/qemu-opts/to_qdict/duplicates", test_opts_to_qdict_duplicates
);