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