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 <check.h>
  13
  14 #include "qint.h"
  15 #include "qdict.h"
  16 #include "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 START_TEST(qdict_new_test)
  26 {
  27     QDict *qdict;
  28
  29     qdict = qdict_new();
  30     fail_unless(qdict != NULL);
  31     fail_unless(qdict_size(qdict) == 0);
  32     fail_unless(qdict->base.refcnt == 1);
  33     fail_unless(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
  34
  35     // destroy doesn't exit yet
  36     free(qdict);
  37 }
  38 END_TEST
  39
  40 START_TEST(qdict_put_obj_test)
  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_obj(qdict, "", QOBJECT(qint_from_int(num)));
  51
  52     fail_unless(qdict_size(qdict) == 1);
  53     ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
  54     qi = qobject_to_qint(ent->value);
  55     fail_unless(qint_get_int(qi) == num);
  56
  57     // destroy doesn't exit yet
  58     QDECREF(qi);
  59     qemu_free(ent->key);
  60     qemu_free(ent);
  61     qemu_free(qdict);
  62 }
  63 END_TEST
  64
  65 START_TEST(qdict_destroy_simple_test)
  66 {
  67     QDict *qdict;
  68
  69     qdict = qdict_new();
  70     qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0)));
  71     qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo")));
  72
  73     QDECREF(qdict);
  74 }
  75 END_TEST
  76
  77 static QDict *tests_dict = NULL;
  78
  79 static void qdict_setup(void)
  80 {
  81     tests_dict = qdict_new();
  82     fail_unless(tests_dict != NULL);
  83 }
  84
  85 static void qdict_teardown(void)
  86 {
  87     QDECREF(tests_dict);
  88     tests_dict = NULL;
  89 }
  90
  91 START_TEST(qdict_get_test)
  92 {
  93     QInt *qi;
  94     QObject *obj;
  95     const int value = -42;
  96     const char *key = "test";
  97
  98     qdict_put(tests_dict, key, qint_from_int(value));
  99
 100     obj = qdict_get(tests_dict, key);
 101     fail_unless(obj != NULL);
 102
 103     qi = qobject_to_qint(obj);
 104     fail_unless(qint_get_int(qi) == value);
 105 }
 106 END_TEST
 107
 108 START_TEST(qdict_get_int_test)
 109 {
 110     int ret;
 111     const int value = 100;
 112     const char *key = "int";
 113
 114     qdict_put(tests_dict, key, qint_from_int(value));
 115
 116     ret = qdict_get_int(tests_dict, key);
 117     fail_unless(ret == value);
 118 }
 119 END_TEST
 120
 121 START_TEST(qdict_get_try_int_test)
 122 {
 123     int ret;
 124     const int value = 100;
 125     const char *key = "int";
 126
 127     qdict_put(tests_dict, key, qint_from_int(value));
 128
 129     ret = qdict_get_try_int(tests_dict, key, 0);
 130     fail_unless(ret == value);
 131 }
 132 END_TEST
 133
 134 START_TEST(qdict_get_str_test)
 135 {
 136     const char *p;
 137     const char *key = "key";
 138     const char *str = "string";
 139
 140     qdict_put(tests_dict, key, qstring_from_str(str));
 141
 142     p = qdict_get_str(tests_dict, key);
 143     fail_unless(p != NULL);
 144     fail_unless(strcmp(p, str) == 0);
 145 }
 146 END_TEST
 147
 148 START_TEST(qdict_get_try_str_test)
 149 {
 150     const char *p;
 151     const char *key = "key";
 152     const char *str = "string";
 153
 154     qdict_put(tests_dict, key, qstring_from_str(str));
 155
 156     p = qdict_get_try_str(tests_dict, key);
 157     fail_unless(p != NULL);
 158     fail_unless(strcmp(p, str) == 0);
 159 }
 160 END_TEST
 161
 162 START_TEST(qdict_haskey_not_test)
 163 {
 164     fail_unless(qdict_haskey(tests_dict, "test") == 0);
 165 }
 166 END_TEST
 167
 168 START_TEST(qdict_haskey_test)
 169 {
 170     const char *key = "test";
 171
 172     qdict_put(tests_dict, key, qint_from_int(0));
 173     fail_unless(qdict_haskey(tests_dict, key) == 1);
 174 }
 175 END_TEST
 176
 177 START_TEST(qdict_del_test)
 178 {
 179     const char *key = "key test";
 180
 181     qdict_put(tests_dict, key, qstring_from_str("foo"));
 182     fail_unless(qdict_size(tests_dict) == 1);
 183
 184     qdict_del(tests_dict, key);
 185
 186     fail_unless(qdict_size(tests_dict) == 0);
 187     fail_unless(qdict_haskey(tests_dict, key) == 0);
 188 }
 189 END_TEST
 190
 191 START_TEST(qobject_to_qdict_test)
 192 {
 193     fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
 194 }
 195 END_TEST
 196
 197 START_TEST(qdict_iterapi_test)
 198 {
 199     int count;
 200     const QDictEntry *ent;
 201
 202     fail_unless(qdict_first(tests_dict) == NULL);
 203
 204     qdict_put(tests_dict, "key1", qint_from_int(1));
 205     qdict_put(tests_dict, "key2", qint_from_int(2));
 206     qdict_put(tests_dict, "key3", qint_from_int(3));
 207
 208     count = 0;
 209     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
 210         fail_unless(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
 211         count++;
 212     }
 213
 214     fail_unless(count == qdict_size(tests_dict));
 215
 216     /* Do it again to test restarting */
 217     count = 0;
 218     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
 219         fail_unless(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
 220         count++;
 221     }
 222
 223     fail_unless(count == qdict_size(tests_dict));
 224 }
 225 END_TEST
 226
 227 /*
 228  * Errors test-cases
 229  */
 230
 231 START_TEST(qdict_put_exists_test)
 232 {
 233     int value;
 234     const char *key = "exists";
 235
 236     qdict_put(tests_dict, key, qint_from_int(1));
 237     qdict_put(tests_dict, key, qint_from_int(2));
 238
 239     value = qdict_get_int(tests_dict, key);
 240     fail_unless(value == 2);
 241
 242     fail_unless(qdict_size(tests_dict) == 1);
 243 }
 244 END_TEST
 245
 246 START_TEST(qdict_get_not_exists_test)
 247 {
 248     fail_unless(qdict_get(tests_dict, "foo") == NULL);
 249 }
 250 END_TEST
 251
 252 /*
 253  * Stress test-case
 254  *
 255  * This is a lot big for a unit-test, but there is no other place
 256  * to have it.
 257  */
 258
 259 static void remove_dots(char *string)
 260 {
 261     char *p = strchr(string, ':');
 262     if (p)
 263         *p = '\0';
 264 }
 265
 266 static QString *read_line(FILE *file, char *key)
 267 {
 268     char value[128];
 269
 270     if (fscanf(file, "%s%s", key, value) == EOF)
 271         return NULL;
 272     remove_dots(key);
 273     return qstring_from_str(value);
 274 }
 275
 276 #define reset_file(file)    fseek(file, 0L, SEEK_SET)
 277
 278 START_TEST(qdict_stress_test)
 279 {
 280     size_t lines;
 281     char key[128];
 282     FILE *test_file;
 283     QDict *qdict;
 284     QString *value;
 285     const char *test_file_path = "qdict-test-data.txt";
 286
 287     test_file = fopen(test_file_path, "r");
 288     fail_unless(test_file != NULL);
 289
 290     // Create the dict
 291     qdict = qdict_new();
 292     fail_unless(qdict != NULL);
 293
 294     // Add everything from the test file
 295     for (lines = 0;; lines++) {
 296         value = read_line(test_file, key);
 297         if (!value)
 298             break;
 299
 300         qdict_put(qdict, key, value);
 301     }
 302     fail_unless(qdict_size(qdict) == lines);
 303
 304     // Check if everything is really in there
 305     reset_file(test_file);
 306     for (;;) {
 307         const char *str1, *str2;
 308
 309         value = read_line(test_file, key);
 310         if (!value)
 311             break;
 312
 313         str1 = qstring_get_str(value);
 314
 315         str2 = qdict_get_str(qdict, key);
 316         fail_unless(str2 != NULL);
 317
 318         fail_unless(strcmp(str1, str2) == 0);
 319
 320         QDECREF(value);
 321     }
 322
 323     // Delete everything
 324     reset_file(test_file);
 325     for (;;) {
 326         value = read_line(test_file, key);
 327         if (!value)
 328             break;
 329
 330         qdict_del(qdict, key);
 331         QDECREF(value);
 332
 333         fail_unless(qdict_haskey(qdict, key) == 0);
 334     }
 335     fclose(test_file);
 336
 337     fail_unless(qdict_size(qdict) == 0);
 338     QDECREF(qdict);
 339 }
 340 END_TEST
 341
 342 static Suite *qdict_suite(void)
 343 {
 344     Suite *s;
 345     TCase *qdict_public_tcase;
 346     TCase *qdict_public2_tcase;
 347     TCase *qdict_stress_tcase;
 348     TCase *qdict_errors_tcase;
 349
 350     s = suite_create("QDict test-suite");
 351
 352     qdict_public_tcase = tcase_create("Public Interface");
 353     suite_add_tcase(s, qdict_public_tcase);
 354     tcase_add_test(qdict_public_tcase, qdict_new_test);
 355     tcase_add_test(qdict_public_tcase, qdict_put_obj_test);
 356     tcase_add_test(qdict_public_tcase, qdict_destroy_simple_test);
 357
 358     /* Continue, but now with fixtures */
 359     qdict_public2_tcase = tcase_create("Public Interface (2)");
 360     suite_add_tcase(s, qdict_public2_tcase);
 361     tcase_add_checked_fixture(qdict_public2_tcase, qdict_setup, qdict_teardown);
 362     tcase_add_test(qdict_public2_tcase, qdict_get_test);
 363     tcase_add_test(qdict_public2_tcase, qdict_get_int_test);
 364     tcase_add_test(qdict_public2_tcase, qdict_get_try_int_test);
 365     tcase_add_test(qdict_public2_tcase, qdict_get_str_test);
 366     tcase_add_test(qdict_public2_tcase, qdict_get_try_str_test);
 367     tcase_add_test(qdict_public2_tcase, qdict_haskey_not_test);
 368     tcase_add_test(qdict_public2_tcase, qdict_haskey_test);
 369     tcase_add_test(qdict_public2_tcase, qdict_del_test);
 370     tcase_add_test(qdict_public2_tcase, qobject_to_qdict_test);
 371     tcase_add_test(qdict_public2_tcase, qdict_iterapi_test);
 372
 373     qdict_errors_tcase = tcase_create("Errors");
 374     suite_add_tcase(s, qdict_errors_tcase);
 375     tcase_add_checked_fixture(qdict_errors_tcase, qdict_setup, qdict_teardown);
 376     tcase_add_test(qdict_errors_tcase, qdict_put_exists_test);
 377     tcase_add_test(qdict_errors_tcase, qdict_get_not_exists_test);
 378
 379     /* The Big one */
 380     qdict_stress_tcase = tcase_create("Stress Test");
 381     suite_add_tcase(s, qdict_stress_tcase);
 382     tcase_add_test(qdict_stress_tcase, qdict_stress_test);
 383
 384     return s;
 385 }
 386
 387 int main(void)
 388 {
 389         int nf;
 390         Suite *s;
 391         SRunner *sr;
 392
 393         s = qdict_suite();
 394         sr = srunner_create(s);
 395
 396         srunner_run_all(sr, CK_NORMAL);
 397         nf = srunner_ntests_failed(sr);
 398         srunner_free(sr);
 399
 400         return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 401 }