@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 1,022 lines 32.6 KB
Raw
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 "qobject/qdict.h"
16 #include "qobject/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 }