tests/check-qdict.c

   1 /*
   2  * QDict unit-tests.
   3  *
   4  * Copyright (C) 2009 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Luiz Capitulino <lcapitulino@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  10  * See the COPYING.LIB file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "block/qdict.h"
  15 #include "qapi/qmp/qdict.h"
  16 #include "qapi/qmp/qlist.h"
  17 #include "qapi/qmp/qnum.h"
  18 #include "qapi/qmp/qstring.h"
  19 #include "qapi/error.h"
  20 #include "qemu-common.h"
  21
  22 /*
  23  * Public Interface test-cases
  24  *
  25  * (with some violations to access 'private' data)
  26  */
  27
  28 static void qdict_new_test(void)
  29 {
  30     QDict *qdict;
  31
  32     qdict = qdict_new();
  33     g_assert(qdict != NULL);
  34     g_assert(qdict_size(qdict) == 0);
  35     g_assert(qdict->base.refcnt == 1);
  36     g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
  37
  38     qobject_unref(qdict);
  39 }
  40
  41 static void qdict_put_obj_test(void)
  42 {
  43     QNum *qn;
  44     QDict *qdict;
  45     QDictEntry *ent;
  46     const int num = 42;
  47
  48     qdict = qdict_new();
  49
  50     // key "" will have tdb hash 12345
  51     qdict_put_int(qdict, "", num);
  52
  53     g_assert(qdict_size(qdict) == 1);
  54     ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
  55     qn = qobject_to(QNum, ent->value);
  56     g_assert_cmpint(qnum_get_int(qn), ==, num);
  57
  58     qobject_unref(qdict);
  59 }
  60
  61 static void qdict_destroy_simple_test(void)
  62 {
  63     QDict *qdict;
  64
  65     qdict = qdict_new();
  66     qdict_put_int(qdict, "num", 0);
  67     qdict_put_str(qdict, "str", "foo");
  68
  69     qobject_unref(qdict);
  70 }
  71
  72 static void qdict_get_test(void)
  73 {
  74     QNum *qn;
  75     QObject *obj;
  76     const int value = -42;
  77     const char *key = "test";
  78     QDict *tests_dict = qdict_new();
  79
  80     qdict_put_int(tests_dict, key, value);
  81
  82     obj = qdict_get(tests_dict, key);
  83     g_assert(obj != NULL);
  84
  85     qn = qobject_to(QNum, obj);
  86     g_assert_cmpint(qnum_get_int(qn), ==, value);
  87
  88     qobject_unref(tests_dict);
  89 }
  90
  91 static void qdict_get_int_test(void)
  92 {
  93     int ret;
  94     const int value = 100;
  95     const char *key = "int";
  96     QDict *tests_dict = qdict_new();
  97
  98     qdict_put_int(tests_dict, key, value);
  99
 100     ret = qdict_get_int(tests_dict, key);
 101     g_assert(ret == value);
 102
 103     qobject_unref(tests_dict);
 104 }
 105
 106 static void qdict_get_try_int_test(void)
 107 {
 108     int ret;
 109     const int value = 100;
 110     const char *key = "int";
 111     QDict *tests_dict = qdict_new();
 112
 113     qdict_put_int(tests_dict, key, value);
 114     qdict_put_str(tests_dict, "string", "test");
 115
 116     ret = qdict_get_try_int(tests_dict, key, 0);
 117     g_assert(ret == value);
 118
 119     ret = qdict_get_try_int(tests_dict, "missing", -42);
 120     g_assert_cmpuint(ret, ==, -42);
 121
 122     ret = qdict_get_try_int(tests_dict, "string", -42);
 123     g_assert_cmpuint(ret, ==, -42);
 124
 125     qobject_unref(tests_dict);
 126 }
 127
 128 static void qdict_get_str_test(void)
 129 {
 130     const char *p;
 131     const char *key = "key";
 132     const char *str = "string";
 133     QDict *tests_dict = qdict_new();
 134
 135     qdict_put_str(tests_dict, key, str);
 136
 137     p = qdict_get_str(tests_dict, key);
 138     g_assert(p != NULL);
 139     g_assert(strcmp(p, str) == 0);
 140
 141     qobject_unref(tests_dict);
 142 }
 143
 144 static void qdict_get_try_str_test(void)
 145 {
 146     const char *p;
 147     const char *key = "key";
 148     const char *str = "string";
 149     QDict *tests_dict = qdict_new();
 150
 151     qdict_put_str(tests_dict, key, str);
 152
 153     p = qdict_get_try_str(tests_dict, key);
 154     g_assert(p != NULL);
 155     g_assert(strcmp(p, str) == 0);
 156
 157     qobject_unref(tests_dict);
 158 }
 159
 160 static void qdict_defaults_test(void)
 161 {
 162     QDict *dict, *copy;
 163
 164     dict = qdict_new();
 165     copy = qdict_new();
 166
 167     qdict_set_default_str(dict, "foo", "abc");
 168     qdict_set_default_str(dict, "foo", "def");
 169     g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "abc");
 170     qdict_set_default_str(dict, "bar", "ghi");
 171
 172     qdict_copy_default(copy, dict, "foo");
 173     g_assert_cmpstr(qdict_get_str(copy, "foo"), ==, "abc");
 174     qdict_set_default_str(copy, "bar", "xyz");
 175     qdict_copy_default(copy, dict, "bar");
 176     g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
 177
 178     qobject_unref(copy);
 179     qobject_unref(dict);
 180 }
 181
 182 static void qdict_haskey_not_test(void)
 183 {
 184     QDict *tests_dict = qdict_new();
 185     g_assert(qdict_haskey(tests_dict, "test") == 0);
 186
 187     qobject_unref(tests_dict);
 188 }
 189
 190 static void qdict_haskey_test(void)
 191 {
 192     const char *key = "test";
 193     QDict *tests_dict = qdict_new();
 194
 195     qdict_put_int(tests_dict, key, 0);
 196     g_assert(qdict_haskey(tests_dict, key) == 1);
 197
 198     qobject_unref(tests_dict);
 199 }
 200
 201 static void qdict_del_test(void)
 202 {
 203     const char *key = "key test";
 204     QDict *tests_dict = qdict_new();
 205
 206     qdict_put_str(tests_dict, key, "foo");
 207     g_assert(qdict_size(tests_dict) == 1);
 208
 209     qdict_del(tests_dict, key);
 210
 211     g_assert(qdict_size(tests_dict) == 0);
 212     g_assert(qdict_haskey(tests_dict, key) == 0);
 213
 214     qobject_unref(tests_dict);
 215 }
 216
 217 static void qobject_to_qdict_test(void)
 218 {
 219     QDict *tests_dict = qdict_new();
 220     g_assert(qobject_to(QDict, QOBJECT(tests_dict)) == tests_dict);
 221
 222     qobject_unref(tests_dict);
 223 }
 224
 225 static void qdict_iterapi_test(void)
 226 {
 227     int count;
 228     const QDictEntry *ent;
 229     QDict *tests_dict = qdict_new();
 230
 231     g_assert(qdict_first(tests_dict) == NULL);
 232
 233     qdict_put_int(tests_dict, "key1", 1);
 234     qdict_put_int(tests_dict, "key2", 2);
 235     qdict_put_int(tests_dict, "key3", 3);
 236
 237     count = 0;
 238     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
 239         g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
 240         count++;
 241     }
 242
 243     g_assert(count == qdict_size(tests_dict));
 244
 245     /* Do it again to test restarting */
 246     count = 0;
 247     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
 248         g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
 249         count++;
 250     }
 251
 252     g_assert(count == qdict_size(tests_dict));
 253
 254     qobject_unref(tests_dict);
 255 }
 256
 257 static void qdict_flatten_test(void)
 258 {
 259     QList *list1 = qlist_new();
 260     QList *list2 = qlist_new();
 261     QDict *dict1 = qdict_new();
 262     QDict *dict2 = qdict_new();
 263     QDict *dict3 = qdict_new();
 264
 265     /*
 266      * Test the flattening of
 267      *
 268      * {
 269      *     "e": [
 270      *         42,
 271      *         [
 272      *             23,
 273      *             66,
 274      *             {
 275      *                 "a": 0,
 276      *                 "b": 1
 277      *             }
 278      *         ]
 279      *     ],
 280      *     "f": {
 281      *         "c": 2,
 282      *         "d": 3,
 283      *     },
 284      *     "g": 4
 285      * }
 286      *
 287      * to
 288      *
 289      * {
 290      *     "e.0": 42,
 291      *     "e.1.0": 23,
 292      *     "e.1.1": 66,
 293      *     "e.1.2.a": 0,
 294      *     "e.1.2.b": 1,
 295      *     "f.c": 2,
 296      *     "f.d": 3,
 297      *     "g": 4
 298      * }
 299      */
 300
 301     qdict_put_int(dict1, "a", 0);
 302     qdict_put_int(dict1, "b", 1);
 303
 304     qlist_append_int(list1, 23);
 305     qlist_append_int(list1, 66);
 306     qlist_append(list1, dict1);
 307     qlist_append_int(list2, 42);
 308     qlist_append(list2, list1);
 309
 310     qdict_put_int(dict2, "c", 2);
 311     qdict_put_int(dict2, "d", 3);
 312     qdict_put(dict3, "e", list2);
 313     qdict_put(dict3, "f", dict2);
 314     qdict_put_int(dict3, "g", 4);
 315
 316     qdict_flatten(dict3);
 317
 318     g_assert(qdict_get_int(dict3, "e.0") == 42);
 319     g_assert(qdict_get_int(dict3, "e.1.0") == 23);
 320     g_assert(qdict_get_int(dict3, "e.1.1") == 66);
 321     g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
 322     g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
 323     g_assert(qdict_get_int(dict3, "f.c") == 2);
 324     g_assert(qdict_get_int(dict3, "f.d") == 3);
 325     g_assert(qdict_get_int(dict3, "g") == 4);
 326
 327     g_assert(qdict_size(dict3) == 8);
 328
 329     qobject_unref(dict3);
 330 }
 331
 332 static void qdict_array_split_test(void)
 333 {
 334     QDict *test_dict = qdict_new();
 335     QDict *dict1, *dict2;
 336     QNum *int1;
 337     QList *test_list;
 338
 339     /*
 340      * Test the split of
 341      *
 342      * {
 343      *     "1.x": 0,
 344      *     "4.y": 1,
 345      *     "0.a": 42,
 346      *     "o.o": 7,
 347      *     "0.b": 23,
 348      *     "2": 66
 349      * }
 350      *
 351      * to
 352      *
 353      * [
 354      *     {
 355      *         "a": 42,
 356      *         "b": 23
 357      *     },
 358      *     {
 359      *         "x": 0
 360      *     },
 361      *     66
 362      * ]
 363      *
 364      * and
 365      *
 366      * {
 367      *     "4.y": 1,
 368      *     "o.o": 7
 369      * }
 370      *
 371      * (remaining in the old QDict)
 372      *
 373      * This example is given in the comment of qdict_array_split().
 374      */
 375
 376     qdict_put_int(test_dict, "1.x", 0);
 377     qdict_put_int(test_dict, "4.y", 1);
 378     qdict_put_int(test_dict, "0.a", 42);
 379     qdict_put_int(test_dict, "o.o", 7);
 380     qdict_put_int(test_dict, "0.b", 23);
 381     qdict_put_int(test_dict, "2", 66);
 382
 383     qdict_array_split(test_dict, &test_list);
 384
 385     dict1 = qobject_to(QDict, qlist_pop(test_list));
 386     dict2 = qobject_to(QDict, qlist_pop(test_list));
 387     int1 = qobject_to(QNum, qlist_pop(test_list));
 388
 389     g_assert(dict1);
 390     g_assert(dict2);
 391     g_assert(int1);
 392     g_assert(qlist_empty(test_list));
 393
 394     qobject_unref(test_list);
 395
 396     g_assert(qdict_get_int(dict1, "a") == 42);
 397     g_assert(qdict_get_int(dict1, "b") == 23);
 398
 399     g_assert(qdict_size(dict1) == 2);
 400
 401     qobject_unref(dict1);
 402
 403     g_assert(qdict_get_int(dict2, "x") == 0);
 404
 405     g_assert(qdict_size(dict2) == 1);
 406
 407     qobject_unref(dict2);
 408
 409     g_assert_cmpint(qnum_get_int(int1), ==, 66);
 410
 411     qobject_unref(int1);
 412
 413     g_assert(qdict_get_int(test_dict, "4.y") == 1);
 414     g_assert(qdict_get_int(test_dict, "o.o") == 7);
 415
 416     g_assert(qdict_size(test_dict) == 2);
 417
 418     qobject_unref(test_dict);
 419
 420     /*
 421      * Test the split of
 422      *
 423      * {
 424      *     "0": 42,
 425      *     "1": 23,
 426      *     "1.x": 84
 427      * }
 428      *
 429      * to
 430      *
 431      * [
 432      *     42
 433      * ]
 434      *
 435      * and
 436      *
 437      * {
 438      *     "1": 23,
 439      *     "1.x": 84
 440      * }
 441      *
 442      * That is, test whether splitting stops if there is both an entry with key
 443      * of "%u" and other entries with keys prefixed "%u." for the same index.
 444      */
 445
 446     test_dict = qdict_new();
 447
 448     qdict_put_int(test_dict, "0", 42);
 449     qdict_put_int(test_dict, "1", 23);
 450     qdict_put_int(test_dict, "1.x", 84);
 451
 452     qdict_array_split(test_dict, &test_list);
 453
 454     int1 = qobject_to(QNum, qlist_pop(test_list));
 455
 456     g_assert(int1);
 457     g_assert(qlist_empty(test_list));
 458
 459     qobject_unref(test_list);
 460
 461     g_assert_cmpint(qnum_get_int(int1), ==, 42);
 462
 463     qobject_unref(int1);
 464
 465     g_assert(qdict_get_int(test_dict, "1") == 23);
 466     g_assert(qdict_get_int(test_dict, "1.x") == 84);
 467
 468     g_assert(qdict_size(test_dict) == 2);
 469
 470     qobject_unref(test_dict);
 471 }
 472
 473 static void qdict_array_entries_test(void)
 474 {
 475     QDict *dict = qdict_new();
 476
 477     g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
 478
 479     qdict_put_int(dict, "bar", 0);
 480     qdict_put_int(dict, "baz.0", 0);
 481     g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
 482
 483     qdict_put_int(dict, "foo.1", 0);
 484     g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
 485     qdict_put_int(dict, "foo.0", 0);
 486     g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2);
 487     qdict_put_int(dict, "foo.bar", 0);
 488     g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
 489     qdict_del(dict, "foo.bar");
 490
 491     qdict_put_int(dict, "foo.2.a", 0);
 492     qdict_put_int(dict, "foo.2.b", 0);
 493     qdict_put_int(dict, "foo.2.c", 0);
 494     g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
 495     g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 496
 497     qobject_unref(dict);
 498
 499     dict = qdict_new();
 500     qdict_put_int(dict, "1", 0);
 501     g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 502     qdict_put_int(dict, "0", 0);
 503     g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2);
 504     qdict_put_int(dict, "bar", 0);
 505     g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 506     qdict_del(dict, "bar");
 507
 508     qdict_put_int(dict, "2.a", 0);
 509     qdict_put_int(dict, "2.b", 0);
 510     qdict_put_int(dict, "2.c", 0);
 511     g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
 512
 513     qobject_unref(dict);
 514 }
 515
 516 static void qdict_join_test(void)
 517 {
 518     QDict *dict1, *dict2;
 519     bool overwrite = false;
 520     int i;
 521
 522     dict1 = qdict_new();
 523     dict2 = qdict_new();
 524
 525     /* Test everything once without overwrite and once with */
 526     do
 527     {
 528         /* Test empty dicts */
 529         qdict_join(dict1, dict2, overwrite);
 530
 531         g_assert(qdict_size(dict1) == 0);
 532         g_assert(qdict_size(dict2) == 0);
 533
 534         /* First iteration: Test movement */
 535         /* Second iteration: Test empty source and non-empty destination */
 536         qdict_put_int(dict2, "foo", 42);
 537
 538         for (i = 0; i < 2; i++) {
 539             qdict_join(dict1, dict2, overwrite);
 540
 541             g_assert(qdict_size(dict1) == 1);
 542             g_assert(qdict_size(dict2) == 0);
 543
 544             g_assert(qdict_get_int(dict1, "foo") == 42);
 545         }
 546
 547         /* Test non-empty source and destination without conflict */
 548         qdict_put_int(dict2, "bar", 23);
 549
 550         qdict_join(dict1, dict2, overwrite);
 551
 552         g_assert(qdict_size(dict1) == 2);
 553         g_assert(qdict_size(dict2) == 0);
 554
 555         g_assert(qdict_get_int(dict1, "foo") == 42);
 556         g_assert(qdict_get_int(dict1, "bar") == 23);
 557
 558         /* Test conflict */
 559         qdict_put_int(dict2, "foo", 84);
 560
 561         qdict_join(dict1, dict2, overwrite);
 562
 563         g_assert(qdict_size(dict1) == 2);
 564         g_assert(qdict_size(dict2) == !overwrite);
 565
 566         g_assert(qdict_get_int(dict1, "foo") == (overwrite ? 84 : 42));
 567         g_assert(qdict_get_int(dict1, "bar") == 23);
 568
 569         if (!overwrite) {
 570             g_assert(qdict_get_int(dict2, "foo") == 84);
 571         }
 572
 573         /* Check the references */
 574         g_assert(qdict_get(dict1, "foo")->base.refcnt == 1);
 575         g_assert(qdict_get(dict1, "bar")->base.refcnt == 1);
 576
 577         if (!overwrite) {
 578             g_assert(qdict_get(dict2, "foo")->base.refcnt == 1);
 579         }
 580
 581         /* Clean up */
 582         qdict_del(dict1, "foo");
 583         qdict_del(dict1, "bar");
 584
 585         if (!overwrite) {
 586             qdict_del(dict2, "foo");
 587         }
 588     }
 589     while (overwrite ^= true);
 590
 591     qobject_unref(dict1);
 592     qobject_unref(dict2);
 593 }
 594
 595 static void qdict_crumple_test_recursive(void)
 596 {
 597     QDict *src, *dst, *rule, *vnc, *acl, *listen;
 598     QList *rules;
 599
 600     src = qdict_new();
 601     qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
 602     qdict_put_str(src, "vnc.listen.port", "5901");
 603     qdict_put_str(src, "vnc.acl.rules.0.match", "fred");
 604     qdict_put_str(src, "vnc.acl.rules.0.policy", "allow");
 605     qdict_put_str(src, "vnc.acl.rules.1.match", "bob");
 606     qdict_put_str(src, "vnc.acl.rules.1.policy", "deny");
 607     qdict_put_str(src, "vnc.acl.default", "deny");
 608     qdict_put_str(src, "vnc.acl..name", "acl0");
 609     qdict_put_str(src, "vnc.acl.rule..name", "acl0");
 610
 611     dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
 612     g_assert(dst);
 613     g_assert_cmpint(qdict_size(dst), ==, 1);
 614
 615     vnc = qdict_get_qdict(dst, "vnc");
 616     g_assert(vnc);
 617     g_assert_cmpint(qdict_size(vnc), ==, 3);
 618
 619     listen = qdict_get_qdict(vnc, "listen");
 620     g_assert(listen);
 621     g_assert_cmpint(qdict_size(listen), ==, 2);
 622     g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr"));
 623     g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port"));
 624
 625     acl = qdict_get_qdict(vnc, "acl");
 626     g_assert(acl);
 627     g_assert_cmpint(qdict_size(acl), ==, 3);
 628
 629     rules = qdict_get_qlist(acl, "rules");
 630     g_assert(rules);
 631     g_assert_cmpint(qlist_size(rules), ==, 2);
 632
 633     rule = qobject_to(QDict, qlist_pop(rules));
 634     g_assert(rule);
 635     g_assert_cmpint(qdict_size(rule), ==, 2);
 636     g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
 637     g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
 638     qobject_unref(rule);
 639
 640     rule = qobject_to(QDict, qlist_pop(rules));
 641     g_assert(rule);
 642     g_assert_cmpint(qdict_size(rule), ==, 2);
 643     g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
 644     g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
 645     qobject_unref(rule);
 646
 647     /* With recursive crumpling, we should see all names unescaped */
 648     g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
 649     g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
 650
 651     qobject_unref(src);
 652     qobject_unref(dst);
 653 }
 654
 655 static void qdict_crumple_test_empty(void)
 656 {
 657     QDict *src, *dst;
 658
 659     src = qdict_new();
 660
 661     dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
 662
 663     g_assert_cmpint(qdict_size(dst), ==, 0);
 664
 665     qobject_unref(src);
 666     qobject_unref(dst);
 667 }
 668
 669 static int qdict_count_entries(QDict *dict)
 670 {
 671     const QDictEntry *e;
 672     int count = 0;
 673
 674     for (e = qdict_first(dict); e; e = qdict_next(dict, e)) {
 675         count++;
 676     }
 677
 678     return count;
 679 }
 680
 681 static void qdict_rename_keys_test(void)
 682 {
 683     QDict *dict = qdict_new();
 684     QDict *copy;
 685     QDictRenames *renames;
 686     Error *local_err = NULL;
 687
 688     qdict_put_str(dict, "abc", "foo");
 689     qdict_put_str(dict, "abcdef", "bar");
 690     qdict_put_int(dict, "number", 42);
 691     qdict_put_bool(dict, "flag", true);
 692     qdict_put_null(dict, "nothing");
 693
 694     /* Empty rename list */
 695     renames = (QDictRenames[]) {
 696         { NULL, "this can be anything" }
 697     };
 698     copy = qdict_clone_shallow(dict);
 699     qdict_rename_keys(copy, renames, &error_abort);
 700
 701     g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
 702     g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
 703     g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
 704     g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
 705     g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
 706     g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 707
 708     qobject_unref(copy);
 709
 710     /* Simple rename of all entries */
 711     renames = (QDictRenames[]) {
 712         { "abc",        "str1" },
 713         { "abcdef",     "str2" },
 714         { "number",     "int" },
 715         { "flag",       "bool" },
 716         { "nothing",    "null" },
 717         { NULL , NULL }
 718     };
 719     copy = qdict_clone_shallow(dict);
 720     qdict_rename_keys(copy, renames, &error_abort);
 721
 722     g_assert(!qdict_haskey(copy, "abc"));
 723     g_assert(!qdict_haskey(copy, "abcdef"));
 724     g_assert(!qdict_haskey(copy, "number"));
 725     g_assert(!qdict_haskey(copy, "flag"));
 726     g_assert(!qdict_haskey(copy, "nothing"));
 727
 728     g_assert_cmpstr(qdict_get_str(copy, "str1"), ==, "foo");
 729     g_assert_cmpstr(qdict_get_str(copy, "str2"), ==, "bar");
 730     g_assert_cmpint(qdict_get_int(copy, "int"), ==, 42);
 731     g_assert_cmpint(qdict_get_bool(copy, "bool"), ==, true);
 732     g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL);
 733     g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 734
 735     qobject_unref(copy);
 736
 737     /* Renames are processed top to bottom */
 738     renames = (QDictRenames[]) {
 739         { "abc",        "tmp" },
 740         { "abcdef",     "abc" },
 741         { "number",     "abcdef" },
 742         { "flag",       "number" },
 743         { "nothing",    "flag" },
 744         { "tmp",        "nothing" },
 745         { NULL , NULL }
 746     };
 747     copy = qdict_clone_shallow(dict);
 748     qdict_rename_keys(copy, renames, &error_abort);
 749
 750     g_assert_cmpstr(qdict_get_str(copy, "nothing"), ==, "foo");
 751     g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "bar");
 752     g_assert_cmpint(qdict_get_int(copy, "abcdef"), ==, 42);
 753     g_assert_cmpint(qdict_get_bool(copy, "number"), ==, true);
 754     g_assert(qobject_type(qdict_get(copy, "flag")) == QTYPE_QNULL);
 755     g_assert(!qdict_haskey(copy, "tmp"));
 756     g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 757
 758     qobject_unref(copy);
 759
 760     /* Conflicting rename */
 761     renames = (QDictRenames[]) {
 762         { "abcdef",     "abc" },
 763         { NULL , NULL }
 764     };
 765     copy = qdict_clone_shallow(dict);
 766     qdict_rename_keys(copy, renames, &local_err);
 767
 768     g_assert(local_err != NULL);
 769     error_free(local_err);
 770     local_err = NULL;
 771
 772     g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
 773     g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
 774     g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
 775     g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
 776     g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
 777     g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 778
 779     qobject_unref(copy);
 780
 781     /* Renames in an empty dict */
 782     renames = (QDictRenames[]) {
 783         { "abcdef",     "abc" },
 784         { NULL , NULL }
 785     };
 786
 787     qobject_unref(dict);
 788     dict = qdict_new();
 789
 790     qdict_rename_keys(dict, renames, &error_abort);
 791     g_assert(qdict_first(dict) == NULL);
 792
 793     qobject_unref(dict);
 794 }
 795
 796 static void qdict_crumple_test_bad_inputs(void)
 797 {
 798     QDict *src;
 799     Error *error = NULL;
 800
 801     src = qdict_new();
 802     /* rule.0 can't be both a string and a dict */
 803     qdict_put_str(src, "rule.0", "fred");
 804     qdict_put_str(src, "rule.0.policy", "allow");
 805
 806     g_assert(qdict_crumple(src, &error) == NULL);
 807     g_assert(error != NULL);
 808     error_free(error);
 809     error = NULL;
 810     qobject_unref(src);
 811
 812     src = qdict_new();
 813     /* rule can't be both a list and a dict */
 814     qdict_put_str(src, "rule.0", "fred");
 815     qdict_put_str(src, "rule.a", "allow");
 816
 817     g_assert(qdict_crumple(src, &error) == NULL);
 818     g_assert(error != NULL);
 819     error_free(error);
 820     error = NULL;
 821     qobject_unref(src);
 822
 823     src = qdict_new();
 824     /* The input should be flat, ie no dicts or lists */
 825     qdict_put(src, "rule.a", qdict_new());
 826     qdict_put_str(src, "rule.b", "allow");
 827
 828     g_assert(qdict_crumple(src, &error) == NULL);
 829     g_assert(error != NULL);
 830     error_free(error);
 831     error = NULL;
 832     qobject_unref(src);
 833
 834     src = qdict_new();
 835     /* List indexes must not have gaps */
 836     qdict_put_str(src, "rule.0", "deny");
 837     qdict_put_str(src, "rule.3", "allow");
 838
 839     g_assert(qdict_crumple(src, &error) == NULL);
 840     g_assert(error != NULL);
 841     error_free(error);
 842     error = NULL;
 843     qobject_unref(src);
 844
 845     src = qdict_new();
 846     /* List indexes must be in %zu format */
 847     qdict_put_str(src, "rule.0", "deny");
 848     qdict_put_str(src, "rule.+1", "allow");
 849
 850     g_assert(qdict_crumple(src, &error) == NULL);
 851     g_assert(error != NULL);
 852     error_free(error);
 853     error = NULL;
 854     qobject_unref(src);
 855 }
 856
 857 /*
 858  * Errors test-cases
 859  */
 860
 861 static void qdict_put_exists_test(void)
 862 {
 863     int value;
 864     const char *key = "exists";
 865     QDict *tests_dict = qdict_new();
 866
 867     qdict_put_int(tests_dict, key, 1);
 868     qdict_put_int(tests_dict, key, 2);
 869
 870     value = qdict_get_int(tests_dict, key);
 871     g_assert(value == 2);
 872
 873     g_assert(qdict_size(tests_dict) == 1);
 874
 875     qobject_unref(tests_dict);
 876 }
 877
 878 static void qdict_get_not_exists_test(void)
 879 {
 880     QDict *tests_dict = qdict_new();
 881     g_assert(qdict_get(tests_dict, "foo") == NULL);
 882
 883     qobject_unref(tests_dict);
 884 }
 885
 886 /*
 887  * Stress test-case
 888  *
 889  * This is a lot big for a unit-test, but there is no other place
 890  * to have it.
 891  */
 892
 893 static void remove_dots(char *string)
 894 {
 895     char *p = strchr(string, ':');
 896     if (p)
 897         *p = '\0';
 898 }
 899
 900 static QString *read_line(FILE *file, char *key)
 901 {
 902     char value[128];
 903
 904     if (fscanf(file, "%127s%127s", key, value) == EOF) {
 905         return NULL;
 906     }
 907     remove_dots(key);
 908     return qstring_from_str(value);
 909 }
 910
 911 #define reset_file(file)    fseek(file, 0L, SEEK_SET)
 912
 913 static void qdict_stress_test(void)
 914 {
 915     size_t lines;
 916     char key[128];
 917     FILE *test_file;
 918     QDict *qdict;
 919     QString *value;
 920     const char *test_file_path = "qdict-test-data.txt";
 921
 922     test_file = fopen(test_file_path, "r");
 923     g_assert(test_file != NULL);
 924
 925     // Create the dict
 926     qdict = qdict_new();
 927     g_assert(qdict != NULL);
 928
 929     // Add everything from the test file
 930     for (lines = 0;; lines++) {
 931         value = read_line(test_file, key);
 932         if (!value)
 933             break;
 934
 935         qdict_put(qdict, key, value);
 936     }
 937     g_assert(qdict_size(qdict) == lines);
 938
 939     // Check if everything is really in there
 940     reset_file(test_file);
 941     for (;;) {
 942         const char *str1, *str2;
 943
 944         value = read_line(test_file, key);
 945         if (!value)
 946             break;
 947
 948         str1 = qstring_get_str(value);
 949
 950         str2 = qdict_get_str(qdict, key);
 951         g_assert(str2 != NULL);
 952
 953         g_assert(strcmp(str1, str2) == 0);
 954
 955         qobject_unref(value);
 956     }
 957
 958     // Delete everything
 959     reset_file(test_file);
 960     for (;;) {
 961         value = read_line(test_file, key);
 962         if (!value)
 963             break;
 964
 965         qdict_del(qdict, key);
 966         qobject_unref(value);
 967
 968         g_assert(qdict_haskey(qdict, key) == 0);
 969     }
 970     fclose(test_file);
 971
 972     g_assert(qdict_size(qdict) == 0);
 973     qobject_unref(qdict);
 974 }
 975
 976 int main(int argc, char **argv)
 977 {
 978     g_test_init(&argc, &argv, NULL);
 979
 980     g_test_add_func("/public/new", qdict_new_test);
 981     g_test_add_func("/public/put_obj", qdict_put_obj_test);
 982     g_test_add_func("/public/destroy_simple", qdict_destroy_simple_test);
 983
 984     /* Continue, but now with fixtures */
 985     g_test_add_func("/public/get", qdict_get_test);
 986     g_test_add_func("/public/get_int", qdict_get_int_test);
 987     g_test_add_func("/public/get_try_int", qdict_get_try_int_test);
 988     g_test_add_func("/public/get_str", qdict_get_str_test);
 989     g_test_add_func("/public/get_try_str", qdict_get_try_str_test);
 990     g_test_add_func("/public/defaults", qdict_defaults_test);
 991     g_test_add_func("/public/haskey_not", qdict_haskey_not_test);
 992     g_test_add_func("/public/haskey", qdict_haskey_test);
 993     g_test_add_func("/public/del", qdict_del_test);
 994     g_test_add_func("/public/to_qdict", qobject_to_qdict_test);
 995     g_test_add_func("/public/iterapi", qdict_iterapi_test);
 996     g_test_add_func("/public/flatten", qdict_flatten_test);
 997     g_test_add_func("/public/array_split", qdict_array_split_test);
 998     g_test_add_func("/public/array_entries", qdict_array_entries_test);
 999     g_test_add_func("/public/join", qdict_join_test);
1000
1001     g_test_add_func("/errors/put_exists", qdict_put_exists_test);
1002     g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test);
1003
1004     g_test_add_func("/public/crumple/recursive",
1005                     qdict_crumple_test_recursive);
1006     g_test_add_func("/public/crumple/empty",
1007                     qdict_crumple_test_empty);
1008     g_test_add_func("/public/crumple/bad_inputs",
1009                     qdict_crumple_test_bad_inputs);
1010
1011     g_test_add_func("/public/rename_keys", qdict_rename_keys_test);
1012
1013     /* The Big one */
1014     if (g_test_slow()) {
1015         g_test_add_func("/stress/test", qdict_stress_test);
1016     }
1017
1018     return g_test_run();
1019 }