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/cutils.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 void register_opts(void)
  88 {
  89     qemu_add_opts(&opts_list_01);
  90     qemu_add_opts(&opts_list_02);
  91     qemu_add_opts(&opts_list_03);
  92 }
  93
  94 static void test_find_unknown_opts(void)
  95 {
  96     QemuOptsList *list;
  97     Error *err = NULL;
  98
  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);
 103 }
 104
 105 static void test_qemu_find_opts(void)
 106 {
 107     QemuOptsList *list;
 108
 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");
 113 }
 114
 115 static void test_qemu_opts_create(void)
 116 {
 117     QemuOptsList *list;
 118     QemuOpts *opts;
 119
 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");
 124
 125     /* should not find anything at this point */
 126     opts = qemu_opts_find(list, NULL);
 127     g_assert(opts == NULL);
 128
 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));
 133
 134     /* now we've create the opts, must find it */
 135     opts = qemu_opts_find(list, NULL);
 136     g_assert(opts != NULL);
 137
 138     qemu_opts_del(opts);
 139
 140     /* should not find anything at this point */
 141     opts = qemu_opts_find(list, NULL);
 142     g_assert(opts == NULL);
 143 }
 144
 145 static void test_qemu_opt_get(void)
 146 {
 147     QemuOptsList *list;
 148     QemuOpts *opts;
 149     const char *opt = NULL;
 150
 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");
 155
 156     /* should not find anything at this point */
 157     opts = qemu_opts_find(list, NULL);
 158     g_assert(opts == NULL);
 159
 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));
 164
 165     /* haven't set anything to str2 yet */
 166     opt = qemu_opt_get(opts, "str2");
 167     g_assert(opt == NULL);
 168
 169     qemu_opt_set(opts, "str2", "value", &error_abort);
 170
 171     /* now we have set str2, should know about it */
 172     opt = qemu_opt_get(opts, "str2");
 173     g_assert_cmpstr(opt, ==, "value");
 174
 175     qemu_opt_set(opts, "str2", "value2", &error_abort);
 176
 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");
 180
 181     qemu_opts_del(opts);
 182
 183     /* should not find anything at this point */
 184     opts = qemu_opts_find(list, NULL);
 185     g_assert(opts == NULL);
 186 }
 187
 188 static void test_qemu_opt_get_bool(void)
 189 {
 190     Error *err = NULL;
 191     QemuOptsList *list;
 192     QemuOpts *opts;
 193     bool opt;
 194
 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");
 199
 200     /* should not find anything at this point */
 201     opts = qemu_opts_find(list, NULL);
 202     g_assert(opts == NULL);
 203
 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));
 208
 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);
 212
 213     qemu_opt_set_bool(opts, "bool1", true, &err);
 214     g_assert(!err);
 215
 216     /* now we have set bool1, should know about it */
 217     opt = qemu_opt_get_bool(opts, "bool1", false);
 218     g_assert(opt == true);
 219
 220     /* having reset the value, opt should be the reset one not defval */
 221     qemu_opt_set_bool(opts, "bool1", false, &err);
 222     g_assert(!err);
 223
 224     opt = qemu_opt_get_bool(opts, "bool1", true);
 225     g_assert(opt == false);
 226
 227     qemu_opts_del(opts);
 228
 229     /* should not find anything at this point */
 230     opts = qemu_opts_find(list, NULL);
 231     g_assert(opts == NULL);
 232 }
 233
 234 static void test_qemu_opt_get_number(void)
 235 {
 236     Error *err = NULL;
 237     QemuOptsList *list;
 238     QemuOpts *opts;
 239     uint64_t opt;
 240
 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");
 245
 246     /* should not find anything at this point */
 247     opts = qemu_opts_find(list, NULL);
 248     g_assert(opts == NULL);
 249
 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));
 254
 255     /* haven't set anything to number1 yet, so defval should be returned */
 256     opt = qemu_opt_get_number(opts, "number1", 5);
 257     g_assert(opt == 5);
 258
 259     qemu_opt_set_number(opts, "number1", 10, &err);
 260     g_assert(!err);
 261
 262     /* now we have set number1, should know about it */
 263     opt = qemu_opt_get_number(opts, "number1", 5);
 264     g_assert(opt == 10);
 265
 266     /* having reset it, the returned should be the reset one not defval */
 267     qemu_opt_set_number(opts, "number1", 15, &err);
 268     g_assert(!err);
 269
 270     opt = qemu_opt_get_number(opts, "number1", 5);
 271     g_assert(opt == 15);
 272
 273     qemu_opts_del(opts);
 274
 275     /* should not find anything at this point */
 276     opts = qemu_opts_find(list, NULL);
 277     g_assert(opts == NULL);
 278 }
 279
 280 static void test_qemu_opt_get_size(void)
 281 {
 282     QemuOptsList *list;
 283     QemuOpts *opts;
 284     uint64_t opt;
 285     QDict *dict;
 286
 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");
 291
 292     /* should not find anything at this point */
 293     opts = qemu_opts_find(list, NULL);
 294     g_assert(opts == NULL);
 295
 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));
 300
 301     /* haven't set anything to size1 yet, so defval should be returned */
 302     opt = qemu_opt_get_size(opts, "size1", 5);
 303     g_assert(opt == 5);
 304
 305     dict = qdict_new();
 306     g_assert(dict != NULL);
 307
 308     qdict_put_str(dict, "size1", "10");
 309
 310     qemu_opts_absorb_qdict(opts, dict, &error_abort);
 311     g_assert(error_abort == NULL);
 312
 313     /* now we have set size1, should know about it */
 314     opt = qemu_opt_get_size(opts, "size1", 5);
 315     g_assert(opt == 10);
 316
 317     /* reset value */
 318     qdict_put_str(dict, "size1", "15");
 319
 320     qemu_opts_absorb_qdict(opts, dict, &error_abort);
 321     g_assert(error_abort == NULL);
 322
 323     /* test the reset value */
 324     opt = qemu_opt_get_size(opts, "size1", 5);
 325     g_assert(opt == 15);
 326
 327     qdict_del(dict, "size1");
 328     g_free(dict);
 329
 330     qemu_opts_del(opts);
 331
 332     /* should not find anything at this point */
 333     opts = qemu_opts_find(list, NULL);
 334     g_assert(opts == NULL);
 335 }
 336
 337 static void test_qemu_opt_unset(void)
 338 {
 339     QemuOpts *opts;
 340     const char *value;
 341     int ret;
 342
 343     /* dynamically initialized (parsed) opts */
 344     opts = qemu_opts_parse(&opts_list_03, "key=value", false, NULL);
 345     g_assert(opts != NULL);
 346
 347     /* check default/parsed value */
 348     value = qemu_opt_get(opts, "key");
 349     g_assert_cmpstr(value, ==, "value");
 350
 351     /* reset it to value2 */
 352     qemu_opt_set(opts, "key", "value2", &error_abort);
 353
 354     value = qemu_opt_get(opts, "key");
 355     g_assert_cmpstr(value, ==, "value2");
 356
 357     /* unset, valid only for "accept any" */
 358     ret = qemu_opt_unset(opts, "key");
 359     g_assert(ret == 0);
 360
 361     /* after reset the value should be the parsed/default one */
 362     value = qemu_opt_get(opts, "key");
 363     g_assert_cmpstr(value, ==, "value");
 364
 365     qemu_opts_del(opts);
 366 }
 367
 368 static void test_qemu_opts_reset(void)
 369 {
 370     Error *err = NULL;
 371     QemuOptsList *list;
 372     QemuOpts *opts;
 373     uint64_t opt;
 374
 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");
 379
 380     /* should not find anything at this point */
 381     opts = qemu_opts_find(list, NULL);
 382     g_assert(opts == NULL);
 383
 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));
 388
 389     /* haven't set anything to number1 yet, so defval should be returned */
 390     opt = qemu_opt_get_number(opts, "number1", 5);
 391     g_assert(opt == 5);
 392
 393     qemu_opt_set_number(opts, "number1", 10, &err);
 394     g_assert(!err);
 395
 396     /* now we have set number1, should know about it */
 397     opt = qemu_opt_get_number(opts, "number1", 5);
 398     g_assert(opt == 10);
 399
 400     qemu_opts_reset(list);
 401
 402     /* should not find anything at this point */
 403     opts = qemu_opts_find(list, NULL);
 404     g_assert(opts == NULL);
 405 }
 406
 407 static void test_qemu_opts_set(void)
 408 {
 409     Error *err = NULL;
 410     QemuOptsList *list;
 411     QemuOpts *opts;
 412     const char *opt;
 413
 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");
 418
 419     /* should not find anything at this point */
 420     opts = qemu_opts_find(list, NULL);
 421     g_assert(opts == NULL);
 422
 423     /* implicitly create opts and set str3 value */
 424     qemu_opts_set(list, NULL, "str3", "value", &err);
 425     g_assert(!err);
 426     g_assert(!QTAILQ_EMPTY(&list->head));
 427
 428     /* get the just created opts */
 429     opts = qemu_opts_find(list, NULL);
 430     g_assert(opts != NULL);
 431
 432     /* check the str3 value */
 433     opt = qemu_opt_get(opts, "str3");
 434     g_assert_cmpstr(opt, ==, "value");
 435
 436     qemu_opts_del(opts);
 437
 438     /* should not find anything at this point */
 439     opts = qemu_opts_find(list, NULL);
 440     g_assert(opts == NULL);
 441 }
 442
 443 static int opts_count_iter(void *opaque, const char *name, const char *value,
 444                            Error **errp)
 445 {
 446     (*(size_t *)opaque)++;
 447     return 0;
 448 }
 449
 450 static size_t opts_count(QemuOpts *opts)
 451 {
 452     size_t n = 0;
 453
 454     qemu_opt_foreach(opts, opts_count_iter, &n, NULL);
 455     return n;
 456 }
 457
 458 static void test_opts_parse(void)
 459 {
 460     Error *err = NULL;
 461     QemuOpts *opts;
 462
 463     /* Nothing */
 464     opts = qemu_opts_parse(&opts_list_03, "", false, &error_abort);
 465     g_assert_cmpuint(opts_count(opts), ==, 0);
 466
 467     /* Empty key */
 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");
 471
 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");
 478
 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");
 484
 485     /* TODO Cover low-level access to repeated keys */
 486
 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");
 491
 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");
 496
 497     /* Duplicate ID */
 498     opts = qemu_opts_parse(&opts_list_03, "x=y,id=foo", false, &err);
 499     error_free_or_abort(&err);
 500     g_assert(!opts);
 501     /* TODO Cover .merge_lists = true */
 502
 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");
 508
 509     /* Anti-social ID */
 510     opts = qemu_opts_parse(&opts_list_01, "id=666", false, &err);
 511     error_free_or_abort(&err);
 512     g_assert(!opts);
 513
 514     /* Implied value */
 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"), ==, "");
 521
 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");
 526
 527     /* Implied key */
 528     opts = qemu_opts_parse(&opts_list_03, "an,noaus,noaus=", true,
 529                            &error_abort);
 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"), ==, "");
 534
 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"), ==, "");
 539
 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");
 545
 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");
 550
 551     /* Unknown key */
 552     opts = qemu_opts_parse(&opts_list_01, "nonexistent=", false, &err);
 553     error_free_or_abort(&err);
 554     g_assert(!opts);
 555
 556     qemu_opts_reset(&opts_list_01);
 557     qemu_opts_reset(&opts_list_03);
 558 }
 559
 560 static void test_opts_parse_bool(void)
 561 {
 562     Error *err = NULL;
 563     QemuOpts *opts;
 564
 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));
 570
 571     opts = qemu_opts_parse(&opts_list_02, "bool1=offer", false, &err);
 572     error_free_or_abort(&err);
 573     g_assert(!opts);
 574
 575     qemu_opts_reset(&opts_list_02);
 576 }
 577
 578 static void test_opts_parse_number(void)
 579 {
 580     Error *err = NULL;
 581     QemuOpts *opts;
 582
 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);
 587
 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);
 595
 596     /* Above upper limit */
 597     opts = qemu_opts_parse(&opts_list_01, "number1=18446744073709551616",
 598                            false, &err);
 599     error_free_or_abort(&err);
 600     g_assert(!opts);
 601
 602     /* Below lower limit */
 603     opts = qemu_opts_parse(&opts_list_01, "number1=-18446744073709551616",
 604                            false, &err);
 605     error_free_or_abort(&err);
 606     g_assert(!opts);
 607
 608     /* Hex and octal */
 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);
 614
 615     /* Invalid */
 616     opts = qemu_opts_parse(&opts_list_01, "number1=", false, &err);
 617     error_free_or_abort(&err);
 618     g_assert(!opts);
 619     opts = qemu_opts_parse(&opts_list_01, "number1=eins", false, &err);
 620     error_free_or_abort(&err);
 621     g_assert(!opts);
 622
 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);
 628
 629     /* Trailing crap */
 630     opts = qemu_opts_parse(&opts_list_01, "number1=3.14", false, &err);
 631     error_free_or_abort(&err);
 632     g_assert(!opts);
 633     opts = qemu_opts_parse(&opts_list_01, "number1=08", false, &err);
 634     error_free_or_abort(&err);
 635     g_assert(!opts);
 636     opts = qemu_opts_parse(&opts_list_01, "number1=0 ", false, &err);
 637     error_free_or_abort(&err);
 638     g_assert(!opts);
 639
 640     qemu_opts_reset(&opts_list_01);
 641 }
 642
 643 static void test_opts_parse_size(void)
 644 {
 645     Error *err = NULL;
 646     QemuOpts *opts;
 647
 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);
 652
 653     /* Note: precision is 53 bits since we're parsing with strtod() */
 654
 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);
 668
 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);
 679
 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);
 690
 691     /* Beyond limits */
 692     opts = qemu_opts_parse(&opts_list_02, "size1=-1", false, &err);
 693     error_free_or_abort(&err);
 694     g_assert(!opts);
 695     opts = qemu_opts_parse(&opts_list_02,
 696                            "size1=18446744073709550592", /* fffffffffffffc00 */
 697                            false, &err);
 698     error_free_or_abort(&err);
 699     g_assert(!opts);
 700
 701     /* Suffixes */
 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 * M_BYTE);
 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), ==, G_BYTE / 10);
 712     g_assert_cmphex(qemu_opt_get_size(opts, "size2", 0),
 713                      ==, 16777215 * T_BYTE);
 714
 715     /* Beyond limit with suffix */
 716     opts = qemu_opts_parse(&opts_list_02, "size1=16777216T",
 717                            false, &err);
 718     error_free_or_abort(&err);
 719     g_assert(!opts);
 720
 721     /* Trailing crap */
 722     opts = qemu_opts_parse(&opts_list_02, "size1=16E", false, &err);
 723     error_free_or_abort(&err);
 724     g_assert(!opts);
 725     opts = qemu_opts_parse(&opts_list_02, "size1=16Gi", false, &err);
 726     error_free_or_abort(&err);
 727     g_assert(!opts);
 728
 729     qemu_opts_reset(&opts_list_02);
 730 }
 731
 732 static void append_verify_list_01(QemuOptDesc *desc, bool with_overlapping)
 733 {
 734     int i = 0;
 735
 736     if (with_overlapping) {
 737         g_assert_cmpstr(desc[i].name, ==, "str1");
 738         g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
 739         g_assert_cmpstr(desc[i].help, ==,
 740                         "Help texts are preserved in qemu_opts_append");
 741         g_assert_cmpstr(desc[i].def_value_str, ==, "default");
 742         i++;
 743
 744         g_assert_cmpstr(desc[i].name, ==, "str2");
 745         g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
 746         g_assert_cmpstr(desc[i].help, ==, NULL);
 747         g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 748         i++;
 749     }
 750
 751     g_assert_cmpstr(desc[i].name, ==, "str3");
 752     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
 753     g_assert_cmpstr(desc[i].help, ==, NULL);
 754     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 755     i++;
 756
 757     g_assert_cmpstr(desc[i].name, ==, "number1");
 758     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_NUMBER);
 759     g_assert_cmpstr(desc[i].help, ==,
 760                     "Having help texts only for some options is okay");
 761     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 762     i++;
 763
 764     g_assert_cmpstr(desc[i].name, ==, "number2");
 765     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_NUMBER);
 766     g_assert_cmpstr(desc[i].help, ==, NULL);
 767     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 768     i++;
 769
 770     g_assert_cmpstr(desc[i].name, ==, NULL);
 771 }
 772
 773 static void append_verify_list_02(QemuOptDesc *desc)
 774 {
 775     int i = 0;
 776
 777     g_assert_cmpstr(desc[i].name, ==, "str1");
 778     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
 779     g_assert_cmpstr(desc[i].help, ==, NULL);
 780     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 781     i++;
 782
 783     g_assert_cmpstr(desc[i].name, ==, "str2");
 784     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_STRING);
 785     g_assert_cmpstr(desc[i].help, ==, NULL);
 786     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 787     i++;
 788
 789     g_assert_cmpstr(desc[i].name, ==, "bool1");
 790     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_BOOL);
 791     g_assert_cmpstr(desc[i].help, ==, NULL);
 792     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 793     i++;
 794
 795     g_assert_cmpstr(desc[i].name, ==, "bool2");
 796     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_BOOL);
 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, ==, "size1");
 802     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
 803     g_assert_cmpstr(desc[i].help, ==, NULL);
 804     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 805     i++;
 806
 807     g_assert_cmpstr(desc[i].name, ==, "size2");
 808     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
 809     g_assert_cmpstr(desc[i].help, ==, NULL);
 810     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 811     i++;
 812
 813     g_assert_cmpstr(desc[i].name, ==, "size3");
 814     g_assert_cmpint(desc[i].type, ==, QEMU_OPT_SIZE);
 815     g_assert_cmpstr(desc[i].help, ==, NULL);
 816     g_assert_cmpstr(desc[i].def_value_str, ==, NULL);
 817 }
 818
 819 static void test_opts_append_to_null(void)
 820 {
 821     QemuOptsList *merged;
 822
 823     merged = qemu_opts_append(NULL, &opts_list_01);
 824     g_assert(merged != &opts_list_01);
 825
 826     g_assert_cmpstr(merged->name, ==, NULL);
 827     g_assert_cmpstr(merged->implied_opt_name, ==, NULL);
 828     g_assert_false(merged->merge_lists);
 829
 830     append_verify_list_01(merged->desc, true);
 831
 832     qemu_opts_free(merged);
 833 }
 834
 835 static void test_opts_append(void)
 836 {
 837     QemuOptsList *first, *merged;
 838
 839     first = qemu_opts_append(NULL, &opts_list_02);
 840     merged = qemu_opts_append(first, &opts_list_01);
 841     g_assert(first != &opts_list_02);
 842     g_assert(merged != &opts_list_01);
 843
 844     g_assert_cmpstr(merged->name, ==, NULL);
 845     g_assert_cmpstr(merged->implied_opt_name, ==, NULL);
 846     g_assert_false(merged->merge_lists);
 847
 848     append_verify_list_02(&merged->desc[0]);
 849     append_verify_list_01(&merged->desc[7], false);
 850
 851     qemu_opts_free(merged);
 852 }
 853
 854 static void test_opts_to_qdict_basic(void)
 855 {
 856     QemuOpts *opts;
 857     QDict *dict;
 858
 859     opts = qemu_opts_parse(&opts_list_01, "str1=foo,str2=,str3=bar,number1=42",
 860                            false, &error_abort);
 861     g_assert(opts != NULL);
 862
 863     dict = qemu_opts_to_qdict(opts, NULL);
 864     g_assert(dict != NULL);
 865
 866     g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
 867     g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
 868     g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
 869     g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
 870     g_assert_false(qdict_haskey(dict, "number2"));
 871
 872     qobject_unref(dict);
 873     qemu_opts_del(opts);
 874 }
 875
 876 static void test_opts_to_qdict_filtered(void)
 877 {
 878     QemuOptsList *first, *merged;
 879     QemuOpts *opts;
 880     QDict *dict;
 881
 882     first = qemu_opts_append(NULL, &opts_list_02);
 883     merged = qemu_opts_append(first, &opts_list_01);
 884
 885     opts = qemu_opts_parse(merged,
 886                            "str1=foo,str2=,str3=bar,bool1=off,number1=42",
 887                            false, &error_abort);
 888     g_assert(opts != NULL);
 889
 890     /* Convert to QDict without deleting from opts */
 891     dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, false);
 892     g_assert(dict != NULL);
 893     g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
 894     g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
 895     g_assert_cmpstr(qdict_get_str(dict, "str3"), ==, "bar");
 896     g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
 897     g_assert_false(qdict_haskey(dict, "number2"));
 898     g_assert_false(qdict_haskey(dict, "bool1"));
 899     qobject_unref(dict);
 900
 901     dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, false);
 902     g_assert(dict != NULL);
 903     g_assert_cmpstr(qdict_get_str(dict, "str1"), ==, "foo");
 904     g_assert_cmpstr(qdict_get_str(dict, "str2"), ==, "");
 905     g_assert_cmpstr(qdict_get_str(dict, "bool1"), ==, "off");
 906     g_assert_false(qdict_haskey(dict, "str3"));
 907     g_assert_false(qdict_haskey(dict, "number1"));
 908     g_assert_false(qdict_haskey(dict, "number2"));
 909     qobject_unref(dict);
 910
 911     /* Now delete converted options from opts */
 912     dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, true);
 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, true);
 923     g_assert(dict != NULL);
 924     g_assert_cmpstr(qdict_get_str(dict, "bool1"), ==, "off");
 925     g_assert_false(qdict_haskey(dict, "str1"));
 926     g_assert_false(qdict_haskey(dict, "str2"));
 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     g_assert_true(QTAILQ_EMPTY(&opts->head));
 933
 934     qemu_opts_del(opts);
 935     qemu_opts_free(merged);
 936 }
 937
 938 static void test_opts_to_qdict_duplicates(void)
 939 {
 940     QemuOpts *opts;
 941     QemuOpt *opt;
 942     QDict *dict;
 943
 944     opts = qemu_opts_parse(&opts_list_03, "foo=a,foo=b", false, &error_abort);
 945     g_assert(opts != NULL);
 946
 947     /* Verify that opts has two options with the same name */
 948     opt = QTAILQ_FIRST(&opts->head);
 949     g_assert_cmpstr(opt->name, ==, "foo");
 950     g_assert_cmpstr(opt->str , ==, "a");
 951
 952     opt = QTAILQ_NEXT(opt, next);
 953     g_assert_cmpstr(opt->name, ==, "foo");
 954     g_assert_cmpstr(opt->str , ==, "b");
 955
 956     opt = QTAILQ_NEXT(opt, next);
 957     g_assert(opt == NULL);
 958
 959     /* In the conversion to QDict, the last one wins */
 960     dict = qemu_opts_to_qdict(opts, NULL);
 961     g_assert(dict != NULL);
 962     g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
 963     qobject_unref(dict);
 964
 965     /* The last one still wins if entries are deleted, and both are deleted */
 966     dict = qemu_opts_to_qdict_filtered(opts, NULL, NULL, true);
 967     g_assert(dict != NULL);
 968     g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
 969     qobject_unref(dict);
 970
 971     g_assert_true(QTAILQ_EMPTY(&opts->head));
 972
 973     qemu_opts_del(opts);
 974 }
 975
 976 int main(int argc, char *argv[])
 977 {
 978     register_opts();
 979     g_test_init(&argc, &argv, NULL);
 980     g_test_add_func("/qemu-opts/find_unknown_opts", test_find_unknown_opts);
 981     g_test_add_func("/qemu-opts/find_opts", test_qemu_find_opts);
 982     g_test_add_func("/qemu-opts/opts_create", test_qemu_opts_create);
 983     g_test_add_func("/qemu-opts/opt_get", test_qemu_opt_get);
 984     g_test_add_func("/qemu-opts/opt_get_bool", test_qemu_opt_get_bool);
 985     g_test_add_func("/qemu-opts/opt_get_number", test_qemu_opt_get_number);
 986     g_test_add_func("/qemu-opts/opt_get_size", test_qemu_opt_get_size);
 987     g_test_add_func("/qemu-opts/opt_unset", test_qemu_opt_unset);
 988     g_test_add_func("/qemu-opts/opts_reset", test_qemu_opts_reset);
 989     g_test_add_func("/qemu-opts/opts_set", test_qemu_opts_set);
 990     g_test_add_func("/qemu-opts/opts_parse/general", test_opts_parse);
 991     g_test_add_func("/qemu-opts/opts_parse/bool", test_opts_parse_bool);
 992     g_test_add_func("/qemu-opts/opts_parse/number", test_opts_parse_number);
 993     g_test_add_func("/qemu-opts/opts_parse/size", test_opts_parse_size);
 994     g_test_add_func("/qemu-opts/append_to_null", test_opts_append_to_null);
 995     g_test_add_func("/qemu-opts/append", test_opts_append);
 996     g_test_add_func("/qemu-opts/to_qdict/basic", test_opts_to_qdict_basic);
 997     g_test_add_func("/qemu-opts/to_qdict/filtered", test_opts_to_qdict_filtered);
 998     g_test_add_func("/qemu-opts/to_qdict/duplicates", test_opts_to_qdict_duplicates);
 999     g_test_run();
1000     return 0;
1001 }