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 <glib.h>
  13
  14 #include "qapi/qmp/qint.h"
  15 #include "qapi/qmp/qdict.h"
  16 #include "qapi/qmp/qstring.h"
  17 #include "qemu-common.h"
  18
  19 /*
  20  * Public Interface test-cases
  21  *
  22  * (with some violations to access 'private' data)
  23  */
  24
  25 static void qdict_new_test(void)
  26 {
  27     QDict *qdict;
  28
  29     qdict = qdict_new();
  30     g_assert(qdict != NULL);
  31     g_assert(qdict_size(qdict) == 0);
  32     g_assert(qdict->base.refcnt == 1);
  33     g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
  34
  35     // destroy doesn't exit yet
  36     g_free(qdict);
  37 }
  38
  39 static void qdict_put_obj_test(void)
  40 {
  41     QInt *qi;
  42     QDict *qdict;
  43     QDictEntry *ent;
  44     const int num = 42;
  45
  46     qdict = qdict_new();
  47
  48     // key "" will have tdb hash 12345
  49     qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num)));
  50
  51     g_assert(qdict_size(qdict) == 1);
  52     ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
  53     qi = qobject_to_qint(ent->value);
  54     g_assert(qint_get_int(qi) == num);
  55
  56     // destroy doesn't exit yet
  57     QDECREF(qi);
  58     g_free(ent->key);
  59     g_free(ent);
  60     g_free(qdict);
  61 }
  62
  63 static void qdict_destroy_simple_test(void)
  64 {
  65     QDict *qdict;
  66
  67     qdict = qdict_new();
  68     qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0)));
  69     qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo")));
  70
  71     QDECREF(qdict);
  72 }
  73
  74 static void qdict_get_test(void)
  75 {
  76     QInt *qi;
  77     QObject *obj;
  78     const int value = -42;
  79     const char *key = "test";
  80     QDict *tests_dict = qdict_new();
  81
  82     qdict_put(tests_dict, key, qint_from_int(value));
  83
  84     obj = qdict_get(tests_dict, key);
  85     g_assert(obj != NULL);
  86
  87     qi = qobject_to_qint(obj);
  88     g_assert(qint_get_int(qi) == value);
  89
  90     QDECREF(tests_dict);
  91 }
  92
  93 static void qdict_get_int_test(void)
  94 {
  95     int ret;
  96     const int value = 100;
  97     const char *key = "int";
  98     QDict *tests_dict = qdict_new();
  99
 100     qdict_put(tests_dict, key, qint_from_int(value));
 101
 102     ret = qdict_get_int(tests_dict, key);
 103     g_assert(ret == value);
 104
 105     QDECREF(tests_dict);
 106 }
 107
 108 static void qdict_get_try_int_test(void)
 109 {
 110     int ret;
 111     const int value = 100;
 112     const char *key = "int";
 113     QDict *tests_dict = qdict_new();
 114
 115     qdict_put(tests_dict, key, qint_from_int(value));
 116
 117     ret = qdict_get_try_int(tests_dict, key, 0);
 118     g_assert(ret == value);
 119
 120     QDECREF(tests_dict);
 121 }
 122
 123 static void qdict_get_str_test(void)
 124 {
 125     const char *p;
 126     const char *key = "key";
 127     const char *str = "string";
 128     QDict *tests_dict = qdict_new();
 129
 130     qdict_put(tests_dict, key, qstring_from_str(str));
 131
 132     p = qdict_get_str(tests_dict, key);
 133     g_assert(p != NULL);
 134     g_assert(strcmp(p, str) == 0);
 135
 136     QDECREF(tests_dict);
 137 }
 138
 139 static void qdict_get_try_str_test(void)
 140 {
 141     const char *p;
 142     const char *key = "key";
 143     const char *str = "string";
 144     QDict *tests_dict = qdict_new();
 145
 146     qdict_put(tests_dict, key, qstring_from_str(str));
 147
 148     p = qdict_get_try_str(tests_dict, key);
 149     g_assert(p != NULL);
 150     g_assert(strcmp(p, str) == 0);
 151
 152     QDECREF(tests_dict);
 153 }
 154
 155 static void qdict_haskey_not_test(void)
 156 {
 157     QDict *tests_dict = qdict_new();
 158     g_assert(qdict_haskey(tests_dict, "test") == 0);
 159
 160     QDECREF(tests_dict);
 161 }
 162
 163 static void qdict_haskey_test(void)
 164 {
 165     const char *key = "test";
 166     QDict *tests_dict = qdict_new();
 167
 168     qdict_put(tests_dict, key, qint_from_int(0));
 169     g_assert(qdict_haskey(tests_dict, key) == 1);
 170
 171     QDECREF(tests_dict);
 172 }
 173
 174 static void qdict_del_test(void)
 175 {
 176     const char *key = "key test";
 177     QDict *tests_dict = qdict_new();
 178
 179     qdict_put(tests_dict, key, qstring_from_str("foo"));
 180     g_assert(qdict_size(tests_dict) == 1);
 181
 182     qdict_del(tests_dict, key);
 183
 184     g_assert(qdict_size(tests_dict) == 0);
 185     g_assert(qdict_haskey(tests_dict, key) == 0);
 186
 187     QDECREF(tests_dict);
 188 }
 189
 190 static void qobject_to_qdict_test(void)
 191 {
 192     QDict *tests_dict = qdict_new();
 193     g_assert(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
 194
 195     QDECREF(tests_dict);
 196 }
 197
 198 static void qdict_iterapi_test(void)
 199 {
 200     int count;
 201     const QDictEntry *ent;
 202     QDict *tests_dict = qdict_new();
 203
 204     g_assert(qdict_first(tests_dict) == NULL);
 205
 206     qdict_put(tests_dict, "key1", qint_from_int(1));
 207     qdict_put(tests_dict, "key2", qint_from_int(2));
 208     qdict_put(tests_dict, "key3", qint_from_int(3));
 209
 210     count = 0;
 211     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
 212         g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
 213         count++;
 214     }
 215
 216     g_assert(count == qdict_size(tests_dict));
 217
 218     /* Do it again to test restarting */
 219     count = 0;
 220     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
 221         g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
 222         count++;
 223     }
 224
 225     g_assert(count == qdict_size(tests_dict));
 226
 227     QDECREF(tests_dict);
 228 }
 229
 230 static void qdict_flatten_test(void)
 231 {
 232     QList *list1 = qlist_new();
 233     QList *list2 = qlist_new();
 234     QDict *dict1 = qdict_new();
 235     QDict *dict2 = qdict_new();
 236     QDict *dict3 = qdict_new();
 237
 238     /*
 239      * Test the flattening of
 240      *
 241      * {
 242      *     "e": [
 243      *         42,
 244      *         [
 245      *             23,
 246      *             66,
 247      *             {
 248      *                 "a": 0,
 249      *                 "b": 1
 250      *             }
 251      *         ]
 252      *     ],
 253      *     "f": {
 254      *         "c": 2,
 255      *         "d": 3,
 256      *     },
 257      *     "g": 4
 258      * }
 259      *
 260      * to
 261      *
 262      * {
 263      *     "e.0": 42,
 264      *     "e.1.0": 23,
 265      *     "e.1.1": 66,
 266      *     "e.1.2.a": 0,
 267      *     "e.1.2.b": 1,
 268      *     "f.c": 2,
 269      *     "f.d": 3,
 270      *     "g": 4
 271      * }
 272      */
 273
 274     qdict_put(dict1, "a", qint_from_int(0));
 275     qdict_put(dict1, "b", qint_from_int(1));
 276
 277     qlist_append_obj(list1, QOBJECT(qint_from_int(23)));
 278     qlist_append_obj(list1, QOBJECT(qint_from_int(66)));
 279     qlist_append_obj(list1, QOBJECT(dict1));
 280     qlist_append_obj(list2, QOBJECT(qint_from_int(42)));
 281     qlist_append_obj(list2, QOBJECT(list1));
 282
 283     qdict_put(dict2, "c", qint_from_int(2));
 284     qdict_put(dict2, "d", qint_from_int(3));
 285     qdict_put_obj(dict3, "e", QOBJECT(list2));
 286     qdict_put_obj(dict3, "f", QOBJECT(dict2));
 287     qdict_put(dict3, "g", qint_from_int(4));
 288
 289     qdict_flatten(dict3);
 290
 291     g_assert(qdict_get_int(dict3, "e.0") == 42);
 292     g_assert(qdict_get_int(dict3, "e.1.0") == 23);
 293     g_assert(qdict_get_int(dict3, "e.1.1") == 66);
 294     g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
 295     g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
 296     g_assert(qdict_get_int(dict3, "f.c") == 2);
 297     g_assert(qdict_get_int(dict3, "f.d") == 3);
 298     g_assert(qdict_get_int(dict3, "g") == 4);
 299
 300     g_assert(qdict_size(dict3) == 8);
 301
 302     QDECREF(dict3);
 303 }
 304
 305 static void qdict_array_split_test(void)
 306 {
 307     QDict *test_dict = qdict_new();
 308     QDict *dict1, *dict2;
 309     QInt *int1;
 310     QList *test_list;
 311
 312     /*
 313      * Test the split of
 314      *
 315      * {
 316      *     "1.x": 0,
 317      *     "4.y": 1,
 318      *     "0.a": 42,
 319      *     "o.o": 7,
 320      *     "0.b": 23,
 321      *     "2": 66
 322      * }
 323      *
 324      * to
 325      *
 326      * [
 327      *     {
 328      *         "a": 42,
 329      *         "b": 23
 330      *     },
 331      *     {
 332      *         "x": 0
 333      *     },
 334      *     66
 335      * ]
 336      *
 337      * and
 338      *
 339      * {
 340      *     "4.y": 1,
 341      *     "o.o": 7
 342      * }
 343      *
 344      * (remaining in the old QDict)
 345      *
 346      * This example is given in the comment of qdict_array_split().
 347      */
 348
 349     qdict_put(test_dict, "1.x", qint_from_int(0));
 350     qdict_put(test_dict, "4.y", qint_from_int(1));
 351     qdict_put(test_dict, "0.a", qint_from_int(42));
 352     qdict_put(test_dict, "o.o", qint_from_int(7));
 353     qdict_put(test_dict, "0.b", qint_from_int(23));
 354     qdict_put(test_dict, "2", qint_from_int(66));
 355
 356     qdict_array_split(test_dict, &test_list);
 357
 358     dict1 = qobject_to_qdict(qlist_pop(test_list));
 359     dict2 = qobject_to_qdict(qlist_pop(test_list));
 360     int1 = qobject_to_qint(qlist_pop(test_list));
 361
 362     g_assert(dict1);
 363     g_assert(dict2);
 364     g_assert(int1);
 365     g_assert(qlist_empty(test_list));
 366
 367     QDECREF(test_list);
 368
 369     g_assert(qdict_get_int(dict1, "a") == 42);
 370     g_assert(qdict_get_int(dict1, "b") == 23);
 371
 372     g_assert(qdict_size(dict1) == 2);
 373
 374     QDECREF(dict1);
 375
 376     g_assert(qdict_get_int(dict2, "x") == 0);
 377
 378     g_assert(qdict_size(dict2) == 1);
 379
 380     QDECREF(dict2);
 381
 382     g_assert(qint_get_int(int1) == 66);
 383
 384     QDECREF(int1);
 385
 386     g_assert(qdict_get_int(test_dict, "4.y") == 1);
 387     g_assert(qdict_get_int(test_dict, "o.o") == 7);
 388
 389     g_assert(qdict_size(test_dict) == 2);
 390
 391     QDECREF(test_dict);
 392
 393
 394     /*
 395      * Test the split of
 396      *
 397      * {
 398      *     "0": 42,
 399      *     "1": 23,
 400      *     "1.x": 84
 401      * }
 402      *
 403      * to
 404      *
 405      * [
 406      *     42
 407      * ]
 408      *
 409      * and
 410      *
 411      * {
 412      *     "1": 23,
 413      *     "1.x": 84
 414      * }
 415      *
 416      * That is, test whether splitting stops if there is both an entry with key
 417      * of "%u" and other entries with keys prefixed "%u." for the same index.
 418      */
 419
 420     test_dict = qdict_new();
 421
 422     qdict_put(test_dict, "0", qint_from_int(42));
 423     qdict_put(test_dict, "1", qint_from_int(23));
 424     qdict_put(test_dict, "1.x", qint_from_int(84));
 425
 426     qdict_array_split(test_dict, &test_list);
 427
 428     int1 = qobject_to_qint(qlist_pop(test_list));
 429
 430     g_assert(int1);
 431     g_assert(qlist_empty(test_list));
 432
 433     QDECREF(test_list);
 434
 435     g_assert(qint_get_int(int1) == 42);
 436
 437     QDECREF(int1);
 438
 439     g_assert(qdict_get_int(test_dict, "1") == 23);
 440     g_assert(qdict_get_int(test_dict, "1.x") == 84);
 441
 442     g_assert(qdict_size(test_dict) == 2);
 443
 444     QDECREF(test_dict);
 445 }
 446
 447 static void qdict_join_test(void)
 448 {
 449     QDict *dict1, *dict2;
 450     bool overwrite = false;
 451     int i;
 452
 453     dict1 = qdict_new();
 454     dict2 = qdict_new();
 455
 456
 457     /* Test everything once without overwrite and once with */
 458     do
 459     {
 460         /* Test empty dicts */
 461         qdict_join(dict1, dict2, overwrite);
 462
 463         g_assert(qdict_size(dict1) == 0);
 464         g_assert(qdict_size(dict2) == 0);
 465
 466
 467         /* First iteration: Test movement */
 468         /* Second iteration: Test empty source and non-empty destination */
 469         qdict_put(dict2, "foo", qint_from_int(42));
 470
 471         for (i = 0; i < 2; i++) {
 472             qdict_join(dict1, dict2, overwrite);
 473
 474             g_assert(qdict_size(dict1) == 1);
 475             g_assert(qdict_size(dict2) == 0);
 476
 477             g_assert(qdict_get_int(dict1, "foo") == 42);
 478         }
 479
 480
 481         /* Test non-empty source and destination without conflict */
 482         qdict_put(dict2, "bar", qint_from_int(23));
 483
 484         qdict_join(dict1, dict2, overwrite);
 485
 486         g_assert(qdict_size(dict1) == 2);
 487         g_assert(qdict_size(dict2) == 0);
 488
 489         g_assert(qdict_get_int(dict1, "foo") == 42);
 490         g_assert(qdict_get_int(dict1, "bar") == 23);
 491
 492
 493         /* Test conflict */
 494         qdict_put(dict2, "foo", qint_from_int(84));
 495
 496         qdict_join(dict1, dict2, overwrite);
 497
 498         g_assert(qdict_size(dict1) == 2);
 499         g_assert(qdict_size(dict2) == !overwrite);
 500
 501         g_assert(qdict_get_int(dict1, "foo") == overwrite ? 84 : 42);
 502         g_assert(qdict_get_int(dict1, "bar") == 23);
 503
 504         if (!overwrite) {
 505             g_assert(qdict_get_int(dict2, "foo") == 84);
 506         }
 507
 508
 509         /* Check the references */
 510         g_assert(qdict_get(dict1, "foo")->refcnt == 1);
 511         g_assert(qdict_get(dict1, "bar")->refcnt == 1);
 512
 513         if (!overwrite) {
 514             g_assert(qdict_get(dict2, "foo")->refcnt == 1);
 515         }
 516
 517
 518         /* Clean up */
 519         qdict_del(dict1, "foo");
 520         qdict_del(dict1, "bar");
 521
 522         if (!overwrite) {
 523             qdict_del(dict2, "foo");
 524         }
 525     }
 526     while (overwrite ^= true);
 527
 528
 529     QDECREF(dict1);
 530     QDECREF(dict2);
 531 }
 532
 533 /*
 534  * Errors test-cases
 535  */
 536
 537 static void qdict_put_exists_test(void)
 538 {
 539     int value;
 540     const char *key = "exists";
 541     QDict *tests_dict = qdict_new();
 542
 543     qdict_put(tests_dict, key, qint_from_int(1));
 544     qdict_put(tests_dict, key, qint_from_int(2));
 545
 546     value = qdict_get_int(tests_dict, key);
 547     g_assert(value == 2);
 548
 549     g_assert(qdict_size(tests_dict) == 1);
 550
 551     QDECREF(tests_dict);
 552 }
 553
 554 static void qdict_get_not_exists_test(void)
 555 {
 556     QDict *tests_dict = qdict_new();
 557     g_assert(qdict_get(tests_dict, "foo") == NULL);
 558
 559     QDECREF(tests_dict);
 560 }
 561
 562 /*
 563  * Stress test-case
 564  *
 565  * This is a lot big for a unit-test, but there is no other place
 566  * to have it.
 567  */
 568
 569 static void remove_dots(char *string)
 570 {
 571     char *p = strchr(string, ':');
 572     if (p)
 573         *p = '\0';
 574 }
 575
 576 static QString *read_line(FILE *file, char *key)
 577 {
 578     char value[128];
 579
 580     if (fscanf(file, "%127s%127s", key, value) == EOF) {
 581         return NULL;
 582     }
 583     remove_dots(key);
 584     return qstring_from_str(value);
 585 }
 586
 587 #define reset_file(file)    fseek(file, 0L, SEEK_SET)
 588
 589 static void qdict_stress_test(void)
 590 {
 591     size_t lines;
 592     char key[128];
 593     FILE *test_file;
 594     QDict *qdict;
 595     QString *value;
 596     const char *test_file_path = "qdict-test-data.txt";
 597
 598     test_file = fopen(test_file_path, "r");
 599     g_assert(test_file != NULL);
 600
 601     // Create the dict
 602     qdict = qdict_new();
 603     g_assert(qdict != NULL);
 604
 605     // Add everything from the test file
 606     for (lines = 0;; lines++) {
 607         value = read_line(test_file, key);
 608         if (!value)
 609             break;
 610
 611         qdict_put(qdict, key, value);
 612     }
 613     g_assert(qdict_size(qdict) == lines);
 614
 615     // Check if everything is really in there
 616     reset_file(test_file);
 617     for (;;) {
 618         const char *str1, *str2;
 619
 620         value = read_line(test_file, key);
 621         if (!value)
 622             break;
 623
 624         str1 = qstring_get_str(value);
 625
 626         str2 = qdict_get_str(qdict, key);
 627         g_assert(str2 != NULL);
 628
 629         g_assert(strcmp(str1, str2) == 0);
 630
 631         QDECREF(value);
 632     }
 633
 634     // Delete everything
 635     reset_file(test_file);
 636     for (;;) {
 637         value = read_line(test_file, key);
 638         if (!value)
 639             break;
 640
 641         qdict_del(qdict, key);
 642         QDECREF(value);
 643
 644         g_assert(qdict_haskey(qdict, key) == 0);
 645     }
 646     fclose(test_file);
 647
 648     g_assert(qdict_size(qdict) == 0);
 649     QDECREF(qdict);
 650 }
 651
 652 int main(int argc, char **argv)
 653 {
 654     g_test_init(&argc, &argv, NULL);
 655
 656     g_test_add_func("/public/new", qdict_new_test);
 657     g_test_add_func("/public/put_obj", qdict_put_obj_test);
 658     g_test_add_func("/public/destroy_simple", qdict_destroy_simple_test);
 659
 660     /* Continue, but now with fixtures */
 661     g_test_add_func("/public/get", qdict_get_test);
 662     g_test_add_func("/public/get_int", qdict_get_int_test);
 663     g_test_add_func("/public/get_try_int", qdict_get_try_int_test);
 664     g_test_add_func("/public/get_str", qdict_get_str_test);
 665     g_test_add_func("/public/get_try_str", qdict_get_try_str_test);
 666     g_test_add_func("/public/haskey_not", qdict_haskey_not_test);
 667     g_test_add_func("/public/haskey", qdict_haskey_test);
 668     g_test_add_func("/public/del", qdict_del_test);
 669     g_test_add_func("/public/to_qdict", qobject_to_qdict_test);
 670     g_test_add_func("/public/iterapi", qdict_iterapi_test);
 671     g_test_add_func("/public/flatten", qdict_flatten_test);
 672     g_test_add_func("/public/array_split", qdict_array_split_test);
 673     g_test_add_func("/public/join", qdict_join_test);
 674
 675     g_test_add_func("/errors/put_exists", qdict_put_exists_test);
 676     g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test);
 677
 678     /* The Big one */
 679     if (g_test_slow()) {
 680         g_test_add_func("/stress/test", qdict_stress_test);
 681     }
 682
 683     return g_test_run();
 684 }