tests/test-keyval.c

   1 /*
   2  * Unit tests for parsing of KEY=VALUE,... strings
   3  *
   4  * Copyright (C) 2017 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Markus Armbruster <armbru@redhat.com>,
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qemu/units.h"
  15 #include "qapi/error.h"
  16 #include "qapi/qmp/qdict.h"
  17 #include "qapi/qmp/qlist.h"
  18 #include "qapi/qmp/qstring.h"
  19 #include "qapi/qobject-input-visitor.h"
  20 #include "test-qapi-visit.h"
  21 #include "qemu/cutils.h"
  22 #include "qemu/option.h"
  23
  24 static void test_keyval_parse(void)
  25 {
  26     Error *err = NULL;
  27     QDict *qdict, *sub_qdict;
  28     char long_key[129];
  29     char *params;
  30
  31     /* Nothing */
  32     qdict = keyval_parse("", NULL, &error_abort);
  33     g_assert_cmpuint(qdict_size(qdict), ==, 0);
  34     qobject_unref(qdict);
  35
  36     /* Empty key (qemu_opts_parse() accepts this) */
  37     qdict = keyval_parse("=val", NULL, &err);
  38     error_free_or_abort(&err);
  39     g_assert(!qdict);
  40
  41     /* Empty key fragment */
  42     qdict = keyval_parse(".", NULL, &err);
  43     error_free_or_abort(&err);
  44     g_assert(!qdict);
  45     qdict = keyval_parse("key.", NULL, &err);
  46     error_free_or_abort(&err);
  47     g_assert(!qdict);
  48
  49     /* Invalid non-empty key (qemu_opts_parse() doesn't care) */
  50     qdict = keyval_parse("7up=val", NULL, &err);
  51     error_free_or_abort(&err);
  52     g_assert(!qdict);
  53
  54     /* Overlong key */
  55     memset(long_key, 'a', 127);
  56     long_key[127] = 'z';
  57     long_key[128] = 0;
  58     params = g_strdup_printf("k.%s=v", long_key);
  59     qdict = keyval_parse(params + 2, NULL, &err);
  60     error_free_or_abort(&err);
  61     g_assert(!qdict);
  62
  63     /* Overlong key fragment */
  64     qdict = keyval_parse(params, NULL, &err);
  65     error_free_or_abort(&err);
  66     g_assert(!qdict);
  67     g_free(params);
  68
  69     /* Long key (qemu_opts_parse() accepts and truncates silently) */
  70     params = g_strdup_printf("k.%s=v", long_key + 1);
  71     qdict = keyval_parse(params + 2, NULL, &error_abort);
  72     g_assert_cmpuint(qdict_size(qdict), ==, 1);
  73     g_assert_cmpstr(qdict_get_try_str(qdict, long_key + 1), ==, "v");
  74     qobject_unref(qdict);
  75
  76     /* Long key fragment */
  77     qdict = keyval_parse(params, NULL, &error_abort);
  78     g_assert_cmpuint(qdict_size(qdict), ==, 1);
  79     sub_qdict = qdict_get_qdict(qdict, "k");
  80     g_assert(sub_qdict);
  81     g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
  82     g_assert_cmpstr(qdict_get_try_str(sub_qdict, long_key + 1), ==, "v");
  83     qobject_unref(qdict);
  84     g_free(params);
  85
  86     /* Crap after valid key */
  87     qdict = keyval_parse("key[0]=val", NULL, &err);
  88     error_free_or_abort(&err);
  89     g_assert(!qdict);
  90
  91     /* Multiple keys, last one wins */
  92     qdict = keyval_parse("a=1,b=2,,x,a=3", NULL, &error_abort);
  93     g_assert_cmpuint(qdict_size(qdict), ==, 2);
  94     g_assert_cmpstr(qdict_get_try_str(qdict, "a"), ==, "3");
  95     g_assert_cmpstr(qdict_get_try_str(qdict, "b"), ==, "2,x");
  96     qobject_unref(qdict);
  97
  98     /* Even when it doesn't in qemu_opts_parse() */
  99     qdict = keyval_parse("id=foo,id=bar", NULL, &error_abort);
 100     g_assert_cmpuint(qdict_size(qdict), ==, 1);
 101     g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "bar");
 102     qobject_unref(qdict);
 103
 104     /* Dotted keys */
 105     qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
 106     g_assert_cmpuint(qdict_size(qdict), ==, 2);
 107     sub_qdict = qdict_get_qdict(qdict, "a");
 108     g_assert(sub_qdict);
 109     g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
 110     sub_qdict = qdict_get_qdict(sub_qdict, "b");
 111     g_assert(sub_qdict);
 112     g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
 113     g_assert_cmpstr(qdict_get_try_str(sub_qdict, "c"), ==, "2");
 114     g_assert_cmpstr(qdict_get_try_str(qdict, "d"), ==, "3");
 115     qobject_unref(qdict);
 116
 117     /* Inconsistent dotted keys */
 118     qdict = keyval_parse("a.b=1,a=2", NULL, &err);
 119     error_free_or_abort(&err);
 120     g_assert(!qdict);
 121     qdict = keyval_parse("a.b=1,a.b.c=2", NULL, &err);
 122     error_free_or_abort(&err);
 123     g_assert(!qdict);
 124
 125     /* Trailing comma is ignored */
 126     qdict = keyval_parse("x=y,", NULL, &error_abort);
 127     g_assert_cmpuint(qdict_size(qdict), ==, 1);
 128     g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, "y");
 129     qobject_unref(qdict);
 130
 131     /* Except when it isn't */
 132     qdict = keyval_parse(",", NULL, &err);
 133     error_free_or_abort(&err);
 134     g_assert(!qdict);
 135
 136     /* Value containing ,id= not misinterpreted as qemu_opts_parse() does */
 137     qdict = keyval_parse("x=,,id=bar", NULL, &error_abort);
 138     g_assert_cmpuint(qdict_size(qdict), ==, 1);
 139     g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, ",id=bar");
 140     qobject_unref(qdict);
 141
 142     /* Anti-social ID is left to caller (qemu_opts_parse() rejects it) */
 143     qdict = keyval_parse("id=666", NULL, &error_abort);
 144     g_assert_cmpuint(qdict_size(qdict), ==, 1);
 145     g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "666");
 146     qobject_unref(qdict);
 147
 148     /* Implied value not supported (unlike qemu_opts_parse()) */
 149     qdict = keyval_parse("an,noaus,noaus=", NULL, &err);
 150     error_free_or_abort(&err);
 151     g_assert(!qdict);
 152
 153     /* Implied value, key "no" (qemu_opts_parse(): negated empty key) */
 154     qdict = keyval_parse("no", NULL, &err);
 155     error_free_or_abort(&err);
 156     g_assert(!qdict);
 157
 158     /* Implied key */
 159     qdict = keyval_parse("an,aus=off,noaus=", "implied", &error_abort);
 160     g_assert_cmpuint(qdict_size(qdict), ==, 3);
 161     g_assert_cmpstr(qdict_get_try_str(qdict, "implied"), ==, "an");
 162     g_assert_cmpstr(qdict_get_try_str(qdict, "aus"), ==, "off");
 163     g_assert_cmpstr(qdict_get_try_str(qdict, "noaus"), ==, "");
 164     qobject_unref(qdict);
 165
 166     /* Implied dotted key */
 167     qdict = keyval_parse("val", "eins.zwei", &error_abort);
 168     g_assert_cmpuint(qdict_size(qdict), ==, 1);
 169     sub_qdict = qdict_get_qdict(qdict, "eins");
 170     g_assert(sub_qdict);
 171     g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
 172     g_assert_cmpstr(qdict_get_try_str(sub_qdict, "zwei"), ==, "val");
 173     qobject_unref(qdict);
 174
 175     /* Implied key with empty value (qemu_opts_parse() accepts this) */
 176     qdict = keyval_parse(",", "implied", &err);
 177     error_free_or_abort(&err);
 178     g_assert(!qdict);
 179
 180     /* Likewise (qemu_opts_parse(): implied key with comma value) */
 181     qdict = keyval_parse(",,,a=1", "implied", &err);
 182     error_free_or_abort(&err);
 183     g_assert(!qdict);
 184
 185     /* Implied key's value can't have comma (qemu_opts_parse(): it can) */
 186     /* BUG: it can */
 187     qdict = keyval_parse("val,,ue", "implied", &error_abort);
 188     g_assert_cmpuint(qdict_size(qdict), ==, 1);
 189     g_assert_cmpstr(qdict_get_try_str(qdict, "implied"), ==, "val,ue");
 190     qobject_unref(qdict);
 191
 192     /* Empty key is not an implied key */
 193     qdict = keyval_parse("=val", "implied", &err);
 194     error_free_or_abort(&err);
 195     g_assert(!qdict);
 196 }
 197
 198 static void check_list012(QList *qlist)
 199 {
 200     static const char *expected[] = { "null", "eins", "zwei" };
 201     int i;
 202     QString *qstr;
 203
 204     g_assert(qlist);
 205     for (i = 0; i < ARRAY_SIZE(expected); i++) {
 206         qstr = qobject_to(QString, qlist_pop(qlist));
 207         g_assert(qstr);
 208         g_assert_cmpstr(qstring_get_str(qstr), ==, expected[i]);
 209         qobject_unref(qstr);
 210     }
 211     g_assert(qlist_empty(qlist));
 212 }
 213
 214 static void test_keyval_parse_list(void)
 215 {
 216     Error *err = NULL;
 217     QDict *qdict, *sub_qdict;
 218
 219     /* Root can't be a list */
 220     qdict = keyval_parse("0=1", NULL, &err);
 221     error_free_or_abort(&err);
 222     g_assert(!qdict);
 223
 224     /* List elements need not be in order */
 225     qdict = keyval_parse("list.0=null,list.2=zwei,list.1=eins",
 226                          NULL, &error_abort);
 227     g_assert_cmpint(qdict_size(qdict), ==, 1);
 228     check_list012(qdict_get_qlist(qdict, "list"));
 229     qobject_unref(qdict);
 230
 231     /* Multiple indexes, last one wins */
 232     qdict = keyval_parse("list.1=goner,list.0=null,list.01=eins,list.2=zwei",
 233                          NULL, &error_abort);
 234     g_assert_cmpint(qdict_size(qdict), ==, 1);
 235     check_list012(qdict_get_qlist(qdict, "list"));
 236     qobject_unref(qdict);
 237
 238     /* List at deeper nesting */
 239     qdict = keyval_parse("a.list.1=eins,a.list.00=null,a.list.2=zwei",
 240                          NULL, &error_abort);
 241     g_assert_cmpint(qdict_size(qdict), ==, 1);
 242     sub_qdict = qdict_get_qdict(qdict, "a");
 243     g_assert_cmpint(qdict_size(sub_qdict), ==, 1);
 244     check_list012(qdict_get_qlist(sub_qdict, "list"));
 245     qobject_unref(qdict);
 246
 247     /* Inconsistent dotted keys: both list and dictionary */
 248     qdict = keyval_parse("a.b.c=1,a.b.0=2", NULL, &err);
 249     error_free_or_abort(&err);
 250     g_assert(!qdict);
 251     qdict = keyval_parse("a.0.c=1,a.b.c=2", NULL, &err);
 252     error_free_or_abort(&err);
 253     g_assert(!qdict);
 254
 255     /* Missing list indexes */
 256     qdict = keyval_parse("list.1=lonely", NULL, &err);
 257     error_free_or_abort(&err);
 258     g_assert(!qdict);
 259     qdict = keyval_parse("list.0=null,list.2=eins,list.02=zwei", NULL, &err);
 260     error_free_or_abort(&err);
 261     g_assert(!qdict);
 262 }
 263
 264 static void test_keyval_visit_bool(void)
 265 {
 266     Error *err = NULL;
 267     Visitor *v;
 268     QDict *qdict;
 269     bool b;
 270
 271     qdict = keyval_parse("bool1=on,bool2=off", NULL, &error_abort);
 272     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 273     qobject_unref(qdict);
 274     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 275     visit_type_bool(v, "bool1", &b, &error_abort);
 276     g_assert(b);
 277     visit_type_bool(v, "bool2", &b, &error_abort);
 278     g_assert(!b);
 279     visit_check_struct(v, &error_abort);
 280     visit_end_struct(v, NULL);
 281     visit_free(v);
 282
 283     qdict = keyval_parse("bool1=offer", NULL, &error_abort);
 284     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 285     qobject_unref(qdict);
 286     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 287     visit_type_bool(v, "bool1", &b, &err);
 288     error_free_or_abort(&err);
 289     visit_end_struct(v, NULL);
 290     visit_free(v);
 291 }
 292
 293 static void test_keyval_visit_number(void)
 294 {
 295     Error *err = NULL;
 296     Visitor *v;
 297     QDict *qdict;
 298     uint64_t u;
 299
 300     /* Lower limit zero */
 301     qdict = keyval_parse("number1=0", NULL, &error_abort);
 302     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 303     qobject_unref(qdict);
 304     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 305     visit_type_uint64(v, "number1", &u, &error_abort);
 306     g_assert_cmpuint(u, ==, 0);
 307     visit_check_struct(v, &error_abort);
 308     visit_end_struct(v, NULL);
 309     visit_free(v);
 310
 311     /* Upper limit 2^64-1 */
 312     qdict = keyval_parse("number1=18446744073709551615,number2=-1",
 313                          NULL, &error_abort);
 314     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 315     qobject_unref(qdict);
 316     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 317     visit_type_uint64(v, "number1", &u, &error_abort);
 318     g_assert_cmphex(u, ==, UINT64_MAX);
 319     visit_type_uint64(v, "number2", &u, &error_abort);
 320     g_assert_cmphex(u, ==, UINT64_MAX);
 321     visit_check_struct(v, &error_abort);
 322     visit_end_struct(v, NULL);
 323     visit_free(v);
 324
 325     /* Above upper limit */
 326     qdict = keyval_parse("number1=18446744073709551616",
 327                          NULL, &error_abort);
 328     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 329     qobject_unref(qdict);
 330     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 331     visit_type_uint64(v, "number1", &u, &err);
 332     error_free_or_abort(&err);
 333     visit_end_struct(v, NULL);
 334     visit_free(v);
 335
 336     /* Below lower limit */
 337     qdict = keyval_parse("number1=-18446744073709551616",
 338                          NULL, &error_abort);
 339     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 340     qobject_unref(qdict);
 341     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 342     visit_type_uint64(v, "number1", &u, &err);
 343     error_free_or_abort(&err);
 344     visit_end_struct(v, NULL);
 345     visit_free(v);
 346
 347     /* Hex and octal */
 348     qdict = keyval_parse("number1=0x2a,number2=052",
 349                          NULL, &error_abort);
 350     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 351     qobject_unref(qdict);
 352     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 353     visit_type_uint64(v, "number1", &u, &error_abort);
 354     g_assert_cmpuint(u, ==, 42);
 355     visit_type_uint64(v, "number2", &u, &error_abort);
 356     g_assert_cmpuint(u, ==, 42);
 357     visit_check_struct(v, &error_abort);
 358     visit_end_struct(v, NULL);
 359     visit_free(v);
 360
 361     /* Trailing crap */
 362     qdict = keyval_parse("number1=3.14,number2=08",
 363                          NULL, &error_abort);
 364     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 365     qobject_unref(qdict);
 366     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 367     visit_type_uint64(v, "number1", &u, &err);
 368     error_free_or_abort(&err);
 369     visit_type_uint64(v, "number2", &u, &err);
 370     error_free_or_abort(&err);
 371     visit_end_struct(v, NULL);
 372     visit_free(v);
 373 }
 374
 375 static void test_keyval_visit_size(void)
 376 {
 377     Error *err = NULL;
 378     Visitor *v;
 379     QDict *qdict;
 380     uint64_t sz;
 381
 382     /* Lower limit zero */
 383     qdict = keyval_parse("sz1=0", NULL, &error_abort);
 384     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 385     qobject_unref(qdict);
 386     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 387     visit_type_size(v, "sz1", &sz, &error_abort);
 388     g_assert_cmpuint(sz, ==, 0);
 389     visit_check_struct(v, &error_abort);
 390     visit_end_struct(v, NULL);
 391     visit_free(v);
 392
 393     /* Note: precision is 53 bits since we're parsing with strtod() */
 394
 395     /* Around limit of precision: 2^53-1, 2^53, 2^53+1 */
 396     qdict = keyval_parse("sz1=9007199254740991,"
 397                          "sz2=9007199254740992,"
 398                          "sz3=9007199254740993",
 399                          NULL, &error_abort);
 400     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 401     qobject_unref(qdict);
 402     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 403     visit_type_size(v, "sz1", &sz, &error_abort);
 404     g_assert_cmphex(sz, ==, 0x1fffffffffffff);
 405     visit_type_size(v, "sz2", &sz, &error_abort);
 406     g_assert_cmphex(sz, ==, 0x20000000000000);
 407     visit_type_size(v, "sz3", &sz, &error_abort);
 408     g_assert_cmphex(sz, ==, 0x20000000000000);
 409     visit_check_struct(v, &error_abort);
 410     visit_end_struct(v, NULL);
 411     visit_free(v);
 412
 413     /* Close to signed upper limit 0x7ffffffffffffc00 (53 msbs set) */
 414     qdict = keyval_parse("sz1=9223372036854774784," /* 7ffffffffffffc00 */
 415                          "sz2=9223372036854775295", /* 7ffffffffffffdff */
 416                          NULL, &error_abort);
 417     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 418     qobject_unref(qdict);
 419     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 420     visit_type_size(v, "sz1", &sz, &error_abort);
 421     g_assert_cmphex(sz, ==, 0x7ffffffffffffc00);
 422     visit_type_size(v, "sz2", &sz, &error_abort);
 423     g_assert_cmphex(sz, ==, 0x7ffffffffffffc00);
 424     visit_check_struct(v, &error_abort);
 425     visit_end_struct(v, NULL);
 426     visit_free(v);
 427
 428     /* Close to actual upper limit 0xfffffffffffff800 (53 msbs set) */
 429     qdict = keyval_parse("sz1=18446744073709549568," /* fffffffffffff800 */
 430                          "sz2=18446744073709550591", /* fffffffffffffbff */
 431                          NULL, &error_abort);
 432     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 433     qobject_unref(qdict);
 434     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 435     visit_type_size(v, "sz1", &sz, &error_abort);
 436     g_assert_cmphex(sz, ==, 0xfffffffffffff800);
 437     visit_type_size(v, "sz2", &sz, &error_abort);
 438     g_assert_cmphex(sz, ==, 0xfffffffffffff800);
 439     visit_check_struct(v, &error_abort);
 440     visit_end_struct(v, NULL);
 441     visit_free(v);
 442
 443     /* Beyond limits */
 444     qdict = keyval_parse("sz1=-1,"
 445                          "sz2=18446744073709550592", /* fffffffffffffc00 */
 446                          NULL, &error_abort);
 447     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 448     qobject_unref(qdict);
 449     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 450     visit_type_size(v, "sz1", &sz, &err);
 451     error_free_or_abort(&err);
 452     visit_type_size(v, "sz2", &sz, &err);
 453     error_free_or_abort(&err);
 454     visit_end_struct(v, NULL);
 455     visit_free(v);
 456
 457     /* Suffixes */
 458     qdict = keyval_parse("sz1=8b,sz2=1.5k,sz3=2M,sz4=0.1G,sz5=16777215T",
 459                          NULL, &error_abort);
 460     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 461     qobject_unref(qdict);
 462     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 463     visit_type_size(v, "sz1", &sz, &error_abort);
 464     g_assert_cmpuint(sz, ==, 8);
 465     visit_type_size(v, "sz2", &sz, &error_abort);
 466     g_assert_cmpuint(sz, ==, 1536);
 467     visit_type_size(v, "sz3", &sz, &error_abort);
 468     g_assert_cmphex(sz, ==, 2 * MiB);
 469     visit_type_size(v, "sz4", &sz, &error_abort);
 470     g_assert_cmphex(sz, ==, GiB / 10);
 471     visit_type_size(v, "sz5", &sz, &error_abort);
 472     g_assert_cmphex(sz, ==, 16777215ULL * TiB);
 473     visit_check_struct(v, &error_abort);
 474     visit_end_struct(v, NULL);
 475     visit_free(v);
 476
 477     /* Beyond limit with suffix */
 478     qdict = keyval_parse("sz1=16777216T", NULL, &error_abort);
 479     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 480     qobject_unref(qdict);
 481     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 482     visit_type_size(v, "sz1", &sz, &err);
 483     error_free_or_abort(&err);
 484     visit_end_struct(v, NULL);
 485     visit_free(v);
 486
 487     /* Trailing crap */
 488     qdict = keyval_parse("sz1=0Z,sz2=16Gi", NULL, &error_abort);
 489     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 490     qobject_unref(qdict);
 491     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 492     visit_type_size(v, "sz1", &sz, &err);
 493     error_free_or_abort(&err);
 494     visit_type_size(v, "sz2", &sz, &err);
 495     error_free_or_abort(&err);
 496     visit_end_struct(v, NULL);
 497     visit_free(v);
 498 }
 499
 500 static void test_keyval_visit_dict(void)
 501 {
 502     Error *err = NULL;
 503     Visitor *v;
 504     QDict *qdict;
 505     int64_t i;
 506
 507     qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
 508     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 509     qobject_unref(qdict);
 510     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 511     visit_start_struct(v, "a", NULL, 0, &error_abort);
 512     visit_start_struct(v, "b", NULL, 0, &error_abort);
 513     visit_type_int(v, "c", &i, &error_abort);
 514     g_assert_cmpint(i, ==, 2);
 515     visit_check_struct(v, &error_abort);
 516     visit_end_struct(v, NULL);
 517     visit_check_struct(v, &error_abort);
 518     visit_end_struct(v, NULL);
 519     visit_type_int(v, "d", &i, &error_abort);
 520     g_assert_cmpint(i, ==, 3);
 521     visit_check_struct(v, &error_abort);
 522     visit_end_struct(v, NULL);
 523     visit_free(v);
 524
 525     qdict = keyval_parse("a.b=", NULL, &error_abort);
 526     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 527     qobject_unref(qdict);
 528     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 529     visit_start_struct(v, "a", NULL, 0, &error_abort);
 530     visit_type_int(v, "c", &i, &err);   /* a.c missing */
 531     error_free_or_abort(&err);
 532     visit_check_struct(v, &err);
 533     error_free_or_abort(&err);          /* a.b unexpected */
 534     visit_end_struct(v, NULL);
 535     visit_check_struct(v, &error_abort);
 536     visit_end_struct(v, NULL);
 537     visit_free(v);
 538 }
 539
 540 static void test_keyval_visit_list(void)
 541 {
 542     Error *err = NULL;
 543     Visitor *v;
 544     QDict *qdict;
 545     char *s;
 546
 547     qdict = keyval_parse("a.0=,a.1=I,a.2.0=II", NULL, &error_abort);
 548     /* TODO empty list */
 549     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 550     qobject_unref(qdict);
 551     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 552     visit_start_list(v, "a", NULL, 0, &error_abort);
 553     visit_type_str(v, NULL, &s, &error_abort);
 554     g_assert_cmpstr(s, ==, "");
 555     g_free(s);
 556     visit_type_str(v, NULL, &s, &error_abort);
 557     g_assert_cmpstr(s, ==, "I");
 558     g_free(s);
 559     visit_start_list(v, NULL, NULL, 0, &error_abort);
 560     visit_type_str(v, NULL, &s, &error_abort);
 561     g_assert_cmpstr(s, ==, "II");
 562     g_free(s);
 563     visit_check_list(v, &error_abort);
 564     visit_end_list(v, NULL);
 565     visit_check_list(v, &error_abort);
 566     visit_end_list(v, NULL);
 567     visit_check_struct(v, &error_abort);
 568     visit_end_struct(v, NULL);
 569     visit_free(v);
 570
 571     qdict = keyval_parse("a.0=,b.0.0=head", NULL, &error_abort);
 572     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 573     qobject_unref(qdict);
 574     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 575     visit_start_list(v, "a", NULL, 0, &error_abort);
 576     visit_check_list(v, &err);  /* a[0] unexpected */
 577     error_free_or_abort(&err);
 578     visit_end_list(v, NULL);
 579     visit_start_list(v, "b", NULL, 0, &error_abort);
 580     visit_start_list(v, NULL, NULL, 0, &error_abort);
 581     visit_type_str(v, NULL, &s, &error_abort);
 582     g_assert_cmpstr(s, ==, "head");
 583     g_free(s);
 584     visit_type_str(v, NULL, &s, &err); /* b[0][1] missing */
 585     error_free_or_abort(&err);
 586     visit_end_list(v, NULL);
 587     visit_end_list(v, NULL);
 588     visit_check_struct(v, &error_abort);
 589     visit_end_struct(v, NULL);
 590     visit_free(v);
 591 }
 592
 593 static void test_keyval_visit_optional(void)
 594 {
 595     Visitor *v;
 596     QDict *qdict;
 597     bool present;
 598     int64_t i;
 599
 600     qdict = keyval_parse("a.b=1", NULL, &error_abort);
 601     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 602     qobject_unref(qdict);
 603     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 604     visit_optional(v, "b", &present);
 605     g_assert(!present);         /* b missing */
 606     visit_optional(v, "a", &present);
 607     g_assert(present);          /* a present */
 608     visit_start_struct(v, "a", NULL, 0, &error_abort);
 609     visit_optional(v, "b", &present);
 610     g_assert(present);          /* a.b present */
 611     visit_type_int(v, "b", &i, &error_abort);
 612     g_assert_cmpint(i, ==, 1);
 613     visit_optional(v, "a", &present);
 614     g_assert(!present);         /* a.a missing */
 615     visit_check_struct(v, &error_abort);
 616     visit_end_struct(v, NULL);
 617     visit_check_struct(v, &error_abort);
 618     visit_end_struct(v, NULL);
 619     visit_free(v);
 620 }
 621
 622 static void test_keyval_visit_alternate(void)
 623 {
 624     Error *err = NULL;
 625     Visitor *v;
 626     QDict *qdict;
 627     AltStrObj *aso;
 628     AltNumEnum *ane;
 629     AltEnumBool *aeb;
 630
 631     /*
 632      * Can't do scalar alternate variants other than string.  You get
 633      * the string variant if there is one, else an error.
 634      * TODO make it work for unambiguous cases like AltEnumBool below
 635      */
 636     qdict = keyval_parse("a=1,b=2,c=on", NULL, &error_abort);
 637     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 638     qobject_unref(qdict);
 639     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 640     visit_type_AltStrObj(v, "a", &aso, &error_abort);
 641     g_assert_cmpint(aso->type, ==, QTYPE_QSTRING);
 642     g_assert_cmpstr(aso->u.s, ==, "1");
 643     qapi_free_AltStrObj(aso);
 644     visit_type_AltNumEnum(v, "b", &ane, &err);
 645     error_free_or_abort(&err);
 646     visit_type_AltEnumBool(v, "c", &aeb, &err);
 647     error_free_or_abort(&err);
 648     visit_end_struct(v, NULL);
 649     visit_free(v);
 650 }
 651
 652 static void test_keyval_visit_any(void)
 653 {
 654     Visitor *v;
 655     QDict *qdict;
 656     QObject *any;
 657     QList *qlist;
 658     QString *qstr;
 659
 660     qdict = keyval_parse("a.0=null,a.1=1", NULL, &error_abort);
 661     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 662     qobject_unref(qdict);
 663     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 664     visit_type_any(v, "a", &any, &error_abort);
 665     qlist = qobject_to(QList, any);
 666     g_assert(qlist);
 667     qstr = qobject_to(QString, qlist_pop(qlist));
 668     g_assert_cmpstr(qstring_get_str(qstr), ==, "null");
 669     qobject_unref(qstr);
 670     qstr = qobject_to(QString, qlist_pop(qlist));
 671     g_assert_cmpstr(qstring_get_str(qstr), ==, "1");
 672     g_assert(qlist_empty(qlist));
 673     qobject_unref(qstr);
 674     qobject_unref(any);
 675     visit_check_struct(v, &error_abort);
 676     visit_end_struct(v, NULL);
 677     visit_free(v);
 678 }
 679
 680 int main(int argc, char *argv[])
 681 {
 682     g_test_init(&argc, &argv, NULL);
 683     g_test_add_func("/keyval/keyval_parse", test_keyval_parse);
 684     g_test_add_func("/keyval/keyval_parse/list", test_keyval_parse_list);
 685     g_test_add_func("/keyval/visit/bool", test_keyval_visit_bool);
 686     g_test_add_func("/keyval/visit/number", test_keyval_visit_number);
 687     g_test_add_func("/keyval/visit/size", test_keyval_visit_size);
 688     g_test_add_func("/keyval/visit/dict", test_keyval_visit_dict);
 689     g_test_add_func("/keyval/visit/list", test_keyval_visit_list);
 690     g_test_add_func("/keyval/visit/optional", test_keyval_visit_optional);
 691     g_test_add_func("/keyval/visit/alternate", test_keyval_visit_alternate);
 692     g_test_add_func("/keyval/visit/any", test_keyval_visit_any);
 693     g_test_run();
 694     return 0;
 695 }