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 /*
 231  * Errors test-cases
 232  */
 233
 234 static void qdict_put_exists_test(void)
 235 {
 236     int value;
 237     const char *key = "exists";
 238     QDict *tests_dict = qdict_new();
 239
 240     qdict_put(tests_dict, key, qint_from_int(1));
 241     qdict_put(tests_dict, key, qint_from_int(2));
 242
 243     value = qdict_get_int(tests_dict, key);
 244     g_assert(value == 2);
 245
 246     g_assert(qdict_size(tests_dict) == 1);
 247
 248     QDECREF(tests_dict);
 249 }
 250
 251 static void qdict_get_not_exists_test(void)
 252 {
 253     QDict *tests_dict = qdict_new();
 254     g_assert(qdict_get(tests_dict, "foo") == NULL);
 255
 256     QDECREF(tests_dict);
 257 }
 258
 259 /*
 260  * Stress test-case
 261  *
 262  * This is a lot big for a unit-test, but there is no other place
 263  * to have it.
 264  */
 265
 266 static void remove_dots(char *string)
 267 {
 268     char *p = strchr(string, ':');
 269     if (p)
 270         *p = '\0';
 271 }
 272
 273 static QString *read_line(FILE *file, char *key)
 274 {
 275     char value[128];
 276
 277     if (fscanf(file, "%127s%127s", key, value) == EOF) {
 278         return NULL;
 279     }
 280     remove_dots(key);
 281     return qstring_from_str(value);
 282 }
 283
 284 #define reset_file(file)    fseek(file, 0L, SEEK_SET)
 285
 286 static void qdict_stress_test(void)
 287 {
 288     size_t lines;
 289     char key[128];
 290     FILE *test_file;
 291     QDict *qdict;
 292     QString *value;
 293     const char *test_file_path = "qdict-test-data.txt";
 294
 295     test_file = fopen(test_file_path, "r");
 296     g_assert(test_file != NULL);
 297
 298     // Create the dict
 299     qdict = qdict_new();
 300     g_assert(qdict != NULL);
 301
 302     // Add everything from the test file
 303     for (lines = 0;; lines++) {
 304         value = read_line(test_file, key);
 305         if (!value)
 306             break;
 307
 308         qdict_put(qdict, key, value);
 309     }
 310     g_assert(qdict_size(qdict) == lines);
 311
 312     // Check if everything is really in there
 313     reset_file(test_file);
 314     for (;;) {
 315         const char *str1, *str2;
 316
 317         value = read_line(test_file, key);
 318         if (!value)
 319             break;
 320
 321         str1 = qstring_get_str(value);
 322
 323         str2 = qdict_get_str(qdict, key);
 324         g_assert(str2 != NULL);
 325
 326         g_assert(strcmp(str1, str2) == 0);
 327
 328         QDECREF(value);
 329     }
 330
 331     // Delete everything
 332     reset_file(test_file);
 333     for (;;) {
 334         value = read_line(test_file, key);
 335         if (!value)
 336             break;
 337
 338         qdict_del(qdict, key);
 339         QDECREF(value);
 340
 341         g_assert(qdict_haskey(qdict, key) == 0);
 342     }
 343     fclose(test_file);
 344
 345     g_assert(qdict_size(qdict) == 0);
 346     QDECREF(qdict);
 347 }
 348
 349 int main(int argc, char **argv)
 350 {
 351     g_test_init(&argc, &argv, NULL);
 352
 353     g_test_add_func("/public/new", qdict_new_test);
 354     g_test_add_func("/public/put_obj", qdict_put_obj_test);
 355     g_test_add_func("/public/destroy_simple", qdict_destroy_simple_test);
 356
 357     /* Continue, but now with fixtures */
 358     g_test_add_func("/public/get", qdict_get_test);
 359     g_test_add_func("/public/get_int", qdict_get_int_test);
 360     g_test_add_func("/public/get_try_int", qdict_get_try_int_test);
 361     g_test_add_func("/public/get_str", qdict_get_str_test);
 362     g_test_add_func("/public/get_try_str", qdict_get_try_str_test);
 363     g_test_add_func("/public/haskey_not", qdict_haskey_not_test);
 364     g_test_add_func("/public/haskey", qdict_haskey_test);
 365     g_test_add_func("/public/del", qdict_del_test);
 366     g_test_add_func("/public/to_qdict", qobject_to_qdict_test);
 367     g_test_add_func("/public/iterapi", qdict_iterapi_test);
 368
 369     g_test_add_func("/errors/put_exists", qdict_put_exists_test);
 370     g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test);
 371
 372     /* The Big one */
 373     if (g_test_slow()) {
 374         g_test_add_func("/stress/test", qdict_stress_test);
 375     }
 376
 377     return g_test_run();
 378 }