Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20210119-1' into...
[qemu.git] / tests / test-qemu-opts.c
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 void test_qemu_opts_set(void)
414 {
415 QemuOptsList *list;
416 QemuOpts *opts;
417 const char *opt;
418
419 list = qemu_find_opts("opts_list_04");
420 g_assert(list != NULL);
421 g_assert(QTAILQ_EMPTY(&list->head));
422 g_assert_cmpstr(list->name, ==, "opts_list_04");
423
424 /* should not find anything at this point */
425 opts = qemu_opts_find(list, NULL);
426 g_assert(opts == NULL);
427
428 /* implicitly create opts and set str3 value */
429 qemu_opts_set(list, "str3", "value", &error_abort);
430 g_assert(!QTAILQ_EMPTY(&list->head));
431
432 /* get the just created opts */
433 opts = qemu_opts_find(list, NULL);
434 g_assert(opts != NULL);
435
436 /* check the str3 value */
437 opt = qemu_opt_get(opts, "str3");
438 g_assert_cmpstr(opt, ==, "value");
439
440 qemu_opts_del(opts);
441
442 /* should not find anything at this point */
443 opts = qemu_opts_find(list, NULL);
444 g_assert(opts == NULL);
445 }
446
447 static int opts_count_iter(void *opaque, const char *name, const char *value,
448 Error **errp)
449 {
450 (*(size_t *)opaque)++;
451 return 0;
452 }
453
454 static size_t opts_count(QemuOpts *opts)
455 {
456 size_t n = 0;
457
458 qemu_opt_foreach(opts, opts_count_iter, &n, NULL);
459 return n;
460 }
461
462 static void test_opts_parse(void)
463 {
464 Error *err = NULL;
465 QemuOpts *opts;
466
467 /* Nothing */
468 opts = qemu_opts_parse(&opts_list_03, "", false, &error_abort);
469 g_assert_cmpuint(opts_count(opts), ==, 0);
470
471 /* Empty key */
472 opts = qemu_opts_parse(&opts_list_03, "=val", false, &error_abort);
473 g_assert_cmpuint(opts_count(opts), ==, 1);
474 g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "val");
475
476 /* Multiple keys, last one wins */
477 opts = qemu_opts_parse(&opts_list_03, "a=1,b=2,,x,a=3",
478 false, &error_abort);
479 g_assert_cmpuint(opts_count(opts), ==, 3);
480 g_assert_cmpstr(qemu_opt_get(opts, "a"), ==, "3");
481 g_assert_cmpstr(qemu_opt_get(opts, "b"), ==, "2,x");
482
483 /* Except when it doesn't */
484 opts = qemu_opts_parse(&opts_list_03, "id=foo,id=bar",
485 false, &error_abort);
486 g_assert_cmpuint(opts_count(opts), ==, 0);
487 g_assert_cmpstr(qemu_opts_id(opts), ==, "foo");
488
489 /* TODO Cover low-level access to repeated keys */
490
491 /* Trailing comma is ignored */
492 opts = qemu_opts_parse(&opts_list_03, "x=y,", false, &error_abort);
493 g_assert_cmpuint(opts_count(opts), ==, 1);
494 g_assert_cmpstr(qemu_opt_get(opts, "x"), ==, "y");
495
496 /* Except when it isn't */
497 opts = qemu_opts_parse(&opts_list_03, ",", false, &error_abort);
498 g_assert_cmpuint(opts_count(opts), ==, 1);
499 g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "on");
500
501 /* Duplicate ID */
502 opts = qemu_opts_parse(&opts_list_03, "x=y,id=foo", false, &err);
503 error_free_or_abort(&err);
504 g_assert(!opts);
505 /* TODO Cover .merge_lists = true */
506
507 /* Buggy ID recognition (fixed) */
508 opts = qemu_opts_parse(&opts_list_03, "x=,,id=bar", false, &error_abort);
509 g_assert_cmpuint(opts_count(opts), ==, 1);
510 g_assert(!qemu_opts_id(opts));
511 g_assert_cmpstr(qemu_opt_get(opts, "x"), ==, ",id=bar");
512
513 /* Anti-social ID */
514 opts = qemu_opts_parse(&opts_list_01, "id=666", false, &err);
515 error_free_or_abort(&err);
516 g_assert(!opts);
517
518 /* Implied value */
519 opts = qemu_opts_parse(&opts_list_03, "an,noaus,noaus=",
520 false, &error_abort);
521 g_assert_cmpuint(opts_count(opts), ==, 3);
522 g_assert_cmpstr(qemu_opt_get(opts, "an"), ==, "on");
523 g_assert_cmpstr(qemu_opt_get(opts, "aus"), ==, "off");
524 g_assert_cmpstr(qemu_opt_get(opts, "noaus"), ==, "");
525
526 /* Implied value, negated empty key */
527 opts = qemu_opts_parse(&opts_list_03, "no", false, &error_abort);
528 g_assert_cmpuint(opts_count(opts), ==, 1);
529 g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "off");
530
531 /* Implied key */
532 opts = qemu_opts_parse(&opts_list_03, "an,noaus,noaus=", true,
533 &error_abort);
534 g_assert_cmpuint(opts_count(opts), ==, 3);
535 g_assert_cmpstr(qemu_opt_get(opts, "implied"), ==, "an");
536 g_assert_cmpstr(qemu_opt_get(opts, "aus"), ==, "off");
537 g_assert_cmpstr(qemu_opt_get(opts, "noaus"), ==, "");
538
539 /* Implied key with empty value */
540 opts = qemu_opts_parse(&opts_list_03, ",", true, &error_abort);
541 g_assert_cmpuint(opts_count(opts), ==, 1);
542 g_assert_cmpstr(qemu_opt_get(opts, "implied"), ==, "");
543
544 /* Implied key with comma value */
545 opts = qemu_opts_parse(&opts_list_03, ",,,a=1", true, &error_abort);
546 g_assert_cmpuint(opts_count(opts), ==, 2);
547 g_assert_cmpstr(qemu_opt_get(opts, "implied"), ==, ",");
548 g_assert_cmpstr(qemu_opt_get(opts, "a"), ==, "1");
549
550 /* Empty key is not an implied key */
551 opts = qemu_opts_parse(&opts_list_03, "=val", true, &error_abort);
552 g_assert_cmpuint(opts_count(opts), ==, 1);
553 g_assert_cmpstr(qemu_opt_get(opts, ""), ==, "val");
554
555 /* Unknown key */
556 opts = qemu_opts_parse(&opts_list_01, "nonexistent=", false, &err);
557 error_free_or_abort(&err);
558 g_assert(!opts);
559
560 qemu_opts_reset(&opts_list_01);
561 qemu_opts_reset(&opts_list_03);
562 }
563
564 static void test_opts_parse_bool(void)
565 {
566 Error *err = NULL;
567 QemuOpts *opts;
568
569 opts = qemu_opts_parse(&opts_list_02, "bool1=on,bool2=off",
570 false, &error_abort);
571 g_assert_cmpuint(opts_count(opts), ==, 2);
572 g_assert(qemu_opt_get_bool(opts, "bool1", false));
573 g_assert(!qemu_opt_get_bool(opts, "bool2", true));
574
575 opts = qemu_opts_parse(&opts_list_02, "bool1=offer", false, &err);
576 error_free_or_abort(&err);
577 g_assert(!opts);
578
579 qemu_opts_reset(&opts_list_02);
580 }
581
582 static void test_opts_parse_number(void)
583 {
584 Error *err = NULL;
585 QemuOpts *opts;
586
587 /* Lower limit zero */
588 opts = qemu_opts_parse(&opts_list_01, "number1=0", false, &error_abort);
589 g_assert_cmpuint(opts_count(opts), ==, 1);
590 g_assert_cmpuint(qemu_opt_get_number(opts, "number1", 1), ==, 0);
591
592 /* Upper limit 2^64-1 */
593 opts = qemu_opts_parse(&opts_list_01,
594 "number1=18446744073709551615,number2=-1",
595 false, &error_abort);
596 g_assert_cmpuint(opts_count(opts), ==, 2);
597 g_assert_cmphex(qemu_opt_get_number(opts, "number1", 1), ==, UINT64_MAX);
598 g_assert_cmphex(qemu_opt_get_number(opts, "number2", 0), ==, UINT64_MAX);
599
600 /* Above upper limit */
601 opts = qemu_opts_parse(&opts_list_01, "number1=18446744073709551616",
602 false, &err);
603 error_free_or_abort(&err);
604 g_assert(!opts);
605
606 /* Below lower limit */
607 opts = qemu_opts_parse(&opts_list_01, "number1=-18446744073709551616",
608 false, &err);
609 error_free_or_abort(&err);
610 g_assert(!opts);
611
612 /* Hex and octal */
613 opts = qemu_opts_parse(&opts_list_01, "number1=0x2a,number2=052",
614 false, &error_abort);
615 g_assert_cmpuint(opts_count(opts), ==, 2);
616 g_assert_cmpuint(qemu_opt_get_number(opts, "number1", 1), ==, 42);
617 g_assert_cmpuint(qemu_opt_get_number(opts, "number2", 0), ==, 42);
618
619 /* Invalid */
620 opts = qemu_opts_parse(&opts_list_01, "number1=", false, &err);
621 error_free_or_abort(&err);
622 g_assert(!opts);
623 opts = qemu_opts_parse(&opts_list_01, "number1=eins", false, &err);
624 error_free_or_abort(&err);
625 g_assert(!opts);
626
627 /* Leading whitespace */
628 opts = qemu_opts_parse(&opts_list_01, "number1= \t42",
629 false, &error_abort);
630 g_assert_cmpuint(opts_count(opts), ==, 1);
631 g_assert_cmpuint(qemu_opt_get_number(opts, "number1", 1), ==, 42);
632
633 /* Trailing crap */
634 opts = qemu_opts_parse(&opts_list_01, "number1=3.14", false, &err);
635 error_free_or_abort(&err);
636 g_assert(!opts);
637 opts = qemu_opts_parse(&opts_list_01, "number1=08", false, &err);
638 error_free_or_abort(&err);
639 g_assert(!opts);
640 opts = qemu_opts_parse(&opts_list_01, "number1=0 ", false, &err);
641 error_free_or_abort(&err);
642 g_assert(!opts);
643
644 qemu_opts_reset(&opts_list_01);
645 }
646
647 static void test_opts_parse_size(void)
648 {
649 Error *err = NULL;
650 QemuOpts *opts;
651
652 /* Lower limit zero */
653 opts = qemu_opts_parse(&opts_list_02, "size1=0", false, &error_abort);
654 g_assert_cmpuint(opts_count(opts), ==, 1);
655 g_assert_cmpuint(qemu_opt_get_size(opts, "size1", 1), ==, 0);
656
657 /* Note: precision is 53 bits since we're parsing with strtod() */
658
659 /* Around limit of precision: 2^53-1, 2^53, 2^54 */
660 opts = qemu_opts_parse(&opts_list_02,
661 "size1=9007199254740991,"
662 "size2=9007199254740992,"
663 "size3=9007199254740993",
664 false, &error_abort);
665 g_assert_cmpuint(opts_count(opts), ==, 3);
666 g_assert_cmphex(qemu_opt_get_size(opts, "size1", 1),
667 ==, 0x1fffffffffffff);
668 g_assert_cmphex(qemu_opt_get_size(opts, "size2", 1),
669 ==, 0x20000000000000);
670 g_assert_cmphex(qemu_opt_get_size(opts, "size3", 1),
671 ==, 0x20000000000000);
672
673 /* Close to signed upper limit 0x7ffffffffffffc00 (53 msbs set) */
674 opts = qemu_opts_parse(&opts_list_02,
675 "size1=9223372036854774784," /* 7ffffffffffffc00 */
676 "size2=9223372036854775295", /* 7ffffffffffffdff */
677 false, &error_abort);
678 g_assert_cmpuint(opts_count(opts), ==, 2);
679 g_assert_cmphex(qemu_opt_get_size(opts, "size1", 1),
680 ==, 0x7ffffffffffffc00);
681 g_assert_cmphex(qemu_opt_get_size(opts, "size2", 1),
682 ==, 0x7ffffffffffffc00);
683
684 /* Close to actual upper limit 0xfffffffffffff800 (53 msbs set) */
685 opts = qemu_opts_parse(&opts_list_02,
686 "size1=18446744073709549568," /* fffffffffffff800 */
687 "size2=18446744073709550591", /* fffffffffffffbff */
688 false, &error_abort);
689 g_assert_cmpuint(opts_count(opts), ==, 2);
690 g_assert_cmphex(qemu_opt_get_size(opts, "size1", 1),
691 ==, 0xfffffffffffff800);
692 g_assert_cmphex(qemu_opt_get_size(opts, "size2", 1),
693 ==, 0xfffffffffffff800);
694
695 /* Beyond limits */
696 opts = qemu_opts_parse(&opts_list_02, "size1=-1", false, &err);
697 error_free_or_abort(&err);
698 g_assert(!opts);
699 opts = qemu_opts_parse(&opts_list_02,
700 "size1=18446744073709550592", /* fffffffffffffc00 */
701 false, &err);
702 error_free_or_abort(&err);
703 g_assert(!opts);
704
705 /* Suffixes */
706 opts = qemu_opts_parse(&opts_list_02, "size1=8b,size2=1.5k,size3=2M",
707 false, &error_abort);
708 g_assert_cmpuint(opts_count(opts), ==, 3);
709 g_assert_cmphex(qemu_opt_get_size(opts, "size1", 0), ==, 8);
710 g_assert_cmphex(qemu_opt_get_size(opts, "size2", 0), ==, 1536);
711 g_assert_cmphex(qemu_opt_get_size(opts, "size3", 0), ==, 2 * MiB);
712 opts = qemu_opts_parse(&opts_list_02, "size1=0.1G,size2=16777215T",
713 false, &error_abort);
714 g_assert_cmpuint(opts_count(opts), ==, 2);
715 g_assert_cmphex(qemu_opt_get_size(opts, "size1", 0), ==, GiB / 10);
716 g_assert_cmphex(qemu_opt_get_size(opts, "size2", 0), ==, 16777215ULL * TiB);
717
718 /* Beyond limit with suffix */
719 opts = qemu_opts_parse(&opts_list_02, "size1=16777216T",
720 false, &err);
721 error_free_or_abort(&err);
722 g_assert(!opts);
723
724 /* Trailing crap */
725 opts = qemu_opts_parse(&opts_list_02, "size1=16E", false, &err);
726 error_free_or_abort(&err);
727 g_assert(!opts);
728 opts = qemu_opts_parse(&opts_list_02, "size1=16Gi", false, &err);
729 error_free_or_abort(&err);
730 g_assert(!opts);
731
732 qemu_opts_reset(&opts_list_02);
733 }
734
735 static void test_has_help_option(void)
736 {
737 static const struct {
738 const char *params;
739 /* expected value of qemu_opt_has_help_opt() with implied=false */
740 bool expect;
741 /* expected value of qemu_opt_has_help_opt() with implied=true */
742 bool expect_implied;
743 } test[] = {
744 { "help", true, false },
745 { "?", true, false },
746 { "helpme", false, false },
747 { "?me", false, false },
748 { "a,help", true, true },
749 { "a,?", true, true },
750 { "a=0,help,b", true, true },
751 { "a=0,?,b", true, true },
752 { "help,b=1", true, false },
753 { "?,b=1", true, false },
754 { "a,b,,help", true, true },
755 { "a,b,,?", true, true },
756 };
757 int i;
758 QemuOpts *opts;
759
760 for (i = 0; i < ARRAY_SIZE(test); i++) {
761 g_assert_cmpint(has_help_option(test[i].params),
762 ==, test[i].expect);
763 opts = qemu_opts_parse(&opts_list_03, test[i].params, false,
764 &error_abort);
765 g_assert_cmpint(qemu_opt_has_help_opt(opts),
766 ==, test[i].expect);
767 qemu_opts_del(opts);
768 opts = qemu_opts_parse(&opts_list_03, test[i].params, true,
769 &error_abort);
770 g_assert_cmpint(qemu_opt_has_help_opt(opts),
771 ==, test[i].expect_implied);
772 qemu_opts_del(opts);
773 }
774 }
775
776 static void append_verify_list_01(QemuOptDesc *desc, bool with_overlapping)
777 {
778 int i = 0;
779
780 if (with_overlapping) {
781 g_assert_cmpstr(desc[i].name, ==, "str1");
782 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
783 g_assert_cmpstr(desc[i].help, ==,
784 "Help texts are preserved in qemu_opts_append");
785 g_assert_cmpstr(desc[i].def_value_str, ==, "default");
786 i++;
787
788 g_assert_cmpstr(desc[i].name, ==, "str2");
789 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
790 g_assert_cmpstr(desc[i].help, ==, NULL);
791 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
792 i++;
793 }
794
795 g_assert_cmpstr(desc[i].name, ==, "str3");
796 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
797 g_assert_cmpstr(desc[i].help, ==, NULL);
798 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
799 i++;
800
801 g_assert_cmpstr(desc[i].name, ==, "number1");
802 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_NUMBER);
803 g_assert_cmpstr(desc[i].help, ==,
804 "Having help texts only for some options is okay");
805 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
806 i++;
807
808 g_assert_cmpstr(desc[i].name, ==, "number2");
809 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_NUMBER);
810 g_assert_cmpstr(desc[i].help, ==, NULL);
811 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
812 i++;
813
814 g_assert_cmpstr(desc[i].name, ==, NULL);
815 }
816
817 static void append_verify_list_02(QemuOptDesc *desc)
818 {
819 int i = 0;
820
821 g_assert_cmpstr(desc[i].name, ==, "str1");
822 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
823 g_assert_cmpstr(desc[i].help, ==, NULL);
824 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
825 i++;
826
827 g_assert_cmpstr(desc[i].name, ==, "str2");
828 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
829 g_assert_cmpstr(desc[i].help, ==, NULL);
830 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
831 i++;
832
833 g_assert_cmpstr(desc[i].name, ==, "bool1");
834 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_BOOL);
835 g_assert_cmpstr(desc[i].help, ==, NULL);
836 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
837 i++;
838
839 g_assert_cmpstr(desc[i].name, ==, "bool2");
840 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_BOOL);
841 g_assert_cmpstr(desc[i].help, ==, NULL);
842 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
843 i++;
844
845 g_assert_cmpstr(desc[i].name, ==, "size1");
846 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
847 g_assert_cmpstr(desc[i].help, ==, NULL);
848 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
849 i++;
850
851 g_assert_cmpstr(desc[i].name, ==, "size2");
852 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
853 g_assert_cmpstr(desc[i].help, ==, NULL);
854 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
855 i++;
856
857 g_assert_cmpstr(desc[i].name, ==, "size3");
858 g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
859 g_assert_cmpstr(desc[i].help, ==, NULL);
860 g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
861 }
862
863 static void test_opts_append_to_null(void)
864 {
865 QemuOptsList *merged;
866
867 merged = qemu_opts_append(NULL, &opts_list_01);
868 g_assert(merged != &opts_list_01);
869
870 g_assert_cmpstr(merged->name, ==, NULL);
871 g_assert_cmpstr(merged->implied_opt_name, ==, NULL);
872 g_assert_false(merged->merge_lists);
873
874 append_verify_list_01(merged->desc, true);
875
876 qemu_opts_free(merged);
877 }
878
879 static void test_opts_append(void)
880 {
881 QemuOptsList *first, *merged;
882
883 first = qemu_opts_append(NULL, &opts_list_02);
884 merged = qemu_opts_append(first, &opts_list_01);
885 g_assert(first != &opts_list_02);
886 g_assert(merged != &opts_list_01);
887
888 g_assert_cmpstr(merged->name, ==, NULL);
889 g_assert_cmpstr(merged->implied_opt_name, ==, NULL);
890 g_assert_false(merged->merge_lists);
891
892 append_verify_list_02(&merged->desc[0]);
893 append_verify_list_01(&merged->desc[7], false);
894
895 qemu_opts_free(merged);
896 }
897
898 static void test_opts_to_qdict_basic(void)
899 {
900 QemuOpts *opts;
901 QDict *dict;
902
903 opts = qemu_opts_parse(&opts_list_01, "str1=foo,str2=,str3=bar,number1=42",
904 false, &error_abort);
905 g_assert(opts != NULL);
906
907 dict = qemu_opts_to_qdict(opts, NULL);
908 g_assert(dict != NULL);
909
910 g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
911 g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
912 g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
913 g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
914 g_assert_false(qdict_haskey(dict, "number2"));
915
916 qobject_unref(dict);
917 qemu_opts_del(opts);
918 }
919
920 static void test_opts_to_qdict_filtered(void)
921 {
922 QemuOptsList *first, *merged;
923 QemuOpts *opts;
924 QDict *dict;
925
926 first = qemu_opts_append(NULL, &opts_list_02);
927 merged = qemu_opts_append(first, &opts_list_01);
928
929 opts = qemu_opts_parse(merged,
930 "str1=foo,str2=,str3=bar,bool1=off,number1=42",
931 false, &error_abort);
932 g_assert(opts != NULL);
933
934 /* Convert to QDict without deleting from opts */
935 dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, false);
936 g_assert(dict != NULL);
937 g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
938 g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
939 g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
940 g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
941 g_assert_false(qdict_haskey(dict, "number2"));
942 g_assert_false(qdict_haskey(dict, "bool1"));
943 qobject_unref(dict);
944
945 dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, false);
946 g_assert(dict != NULL);
947 g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
948 g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
949 g_assert_cmpstr(qdict_get_str(dict, "bool1"), ==, "off");
950 g_assert_false(qdict_haskey(dict, "str3"));
951 g_assert_false(qdict_haskey(dict, "number1"));
952 g_assert_false(qdict_haskey(dict, "number2"));
953 qobject_unref(dict);
954
955 /* Now delete converted options from opts */
956 dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, true);
957 g_assert(dict != NULL);
958 g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
959 g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
960 g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
961 g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
962 g_assert_false(qdict_haskey(dict, "number2"));
963 g_assert_false(qdict_haskey(dict, "bool1"));
964 qobject_unref(dict);
965
966 dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, true);
967 g_assert(dict != NULL);
968 g_assert_cmpstr(qdict_get_str(dict, "bool1"), ==, "off");
969 g_assert_false(qdict_haskey(dict, "str1"));
970 g_assert_false(qdict_haskey(dict, "str2"));
971 g_assert_false(qdict_haskey(dict, "str3"));
972 g_assert_false(qdict_haskey(dict, "number1"));
973 g_assert_false(qdict_haskey(dict, "number2"));
974 qobject_unref(dict);
975
976 g_assert_true(QTAILQ_EMPTY(&opts->head));
977
978 qemu_opts_del(opts);
979 qemu_opts_free(merged);
980 }
981
982 static void test_opts_to_qdict_duplicates(void)
983 {
984 QemuOpts *opts;
985 QemuOpt *opt;
986 QDict *dict;
987
988 opts = qemu_opts_parse(&opts_list_03, "foo=a,foo=b", false, &error_abort);
989 g_assert(opts != NULL);
990
991 /* Verify that opts has two options with the same name */
992 opt = QTAILQ_FIRST(&opts->head);
993 g_assert_cmpstr(opt->name, ==, "foo");
994 g_assert_cmpstr(opt->str , ==, "a");
995
996 opt = QTAILQ_NEXT(opt, next);
997 g_assert_cmpstr(opt->name, ==, "foo");
998 g_assert_cmpstr(opt->str , ==, "b");
999
1000 opt = QTAILQ_NEXT(opt, next);
1001 g_assert(opt == NULL);
1002
1003 /* In the conversion to QDict, the last one wins */
1004 dict = qemu_opts_to_qdict(opts, NULL);
1005 g_assert(dict != NULL);
1006 g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
1007 qobject_unref(dict);
1008
1009 /* The last one still wins if entries are deleted, and both are deleted */
1010 dict = qemu_opts_to_qdict_filtered(opts, NULL, NULL, true);
1011 g_assert(dict != NULL);
1012 g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
1013 qobject_unref(dict);
1014
1015 g_assert_true(QTAILQ_EMPTY(&opts->head));
1016
1017 qemu_opts_del(opts);
1018 }
1019
1020 int main(int argc, char *argv[])
1021 {
1022 register_opts();
1023 g_test_init(&argc, &argv, NULL);
1024 g_test_add_func("/qemu-opts/find_unknown_opts", test_find_unknown_opts);
1025 g_test_add_func("/qemu-opts/find_opts", test_qemu_find_opts);
1026 g_test_add_func("/qemu-opts/opts_create", test_qemu_opts_create);
1027 g_test_add_func("/qemu-opts/opt_get", test_qemu_opt_get);
1028 g_test_add_func("/qemu-opts/opt_get_bool", test_qemu_opt_get_bool);
1029 g_test_add_func("/qemu-opts/opt_get_number", test_qemu_opt_get_number);
1030 g_test_add_func("/qemu-opts/opt_get_size", test_qemu_opt_get_size);
1031 g_test_add_func("/qemu-opts/opt_unset", test_qemu_opt_unset);
1032 g_test_add_func("/qemu-opts/opts_reset", test_qemu_opts_reset);
1033 g_test_add_func("/qemu-opts/opts_set", test_qemu_opts_set);
1034 g_test_add_func("/qemu-opts/opts_parse/general", test_opts_parse);
1035 g_test_add_func("/qemu-opts/opts_parse/bool", test_opts_parse_bool);
1036 g_test_add_func("/qemu-opts/opts_parse/number", test_opts_parse_number);
1037 g_test_add_func("/qemu-opts/opts_parse/size", test_opts_parse_size);
1038 g_test_add_func("/qemu-opts/has_help_option", test_has_help_option);
1039 g_test_add_func("/qemu-opts/append_to_null", test_opts_append_to_null);
1040 g_test_add_func("/qemu-opts/append", test_opts_append);
1041 g_test_add_func("/qemu-opts/to_qdict/basic", test_opts_to_qdict_basic);
1042 g_test_add_func("/qemu-opts/to_qdict/filtered", test_opts_to_qdict_filtered);
1043 g_test_add_func("/qemu-opts/to_qdict/duplicates", test_opts_to_qdict_duplicates);
1044 g_test_run();
1045 return 0;
1046 }