blob: a9296f0833c78e31ad5604b5e23627c2112bf215 [file] [log] [blame]
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -03001/*
2 * QDict unit-tests.
3 *
4 * Copyright (C) 2009 Red Hat Inc.
5 *
6 * Authors:
7 * Luiz Capitulino <lcapitulino@redhat.com>
Luiz Capitulino41836a92010-05-12 16:34:42 -03008 *
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.
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030011 */
Anthony Liguoriac531cb2012-01-10 13:10:44 -060012#include <glib.h>
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030013
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010014#include "qapi/qmp/qint.h"
15#include "qapi/qmp/qdict.h"
16#include "qapi/qmp/qstring.h"
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030017#include "qemu-common.h"
18
19/*
20 * Public Interface test-cases
21 *
22 * (with some violations to access 'private' data)
23 */
24
Anthony Liguoriac531cb2012-01-10 13:10:44 -060025static void qdict_new_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030026{
27 QDict *qdict;
28
29 qdict = qdict_new();
Anthony Liguoriac531cb2012-01-10 13:10:44 -060030 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);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030034
35 // destroy doesn't exit yet
Anthony Liguoriac531cb2012-01-10 13:10:44 -060036 g_free(qdict);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030037}
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030038
Anthony Liguoriac531cb2012-01-10 13:10:44 -060039static void qdict_put_obj_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030040{
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
Anthony Liguoriac531cb2012-01-10 13:10:44 -060051 g_assert(qdict_size(qdict) == 1);
Luiz Capitulinoc8bc3cd2010-06-07 15:45:22 -030052 ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030053 qi = qobject_to_qint(ent->value);
Anthony Liguoriac531cb2012-01-10 13:10:44 -060054 g_assert(qint_get_int(qi) == num);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030055
56 // destroy doesn't exit yet
57 QDECREF(qi);
Anthony Liguori7267c092011-08-20 22:09:37 -050058 g_free(ent->key);
59 g_free(ent);
60 g_free(qdict);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030061}
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030062
Anthony Liguoriac531cb2012-01-10 13:10:44 -060063static void qdict_destroy_simple_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030064{
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}
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030073
Anthony Liguoriac531cb2012-01-10 13:10:44 -060074static void qdict_get_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030075{
76 QInt *qi;
77 QObject *obj;
78 const int value = -42;
79 const char *key = "test";
Anthony Liguoriac531cb2012-01-10 13:10:44 -060080 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030081
82 qdict_put(tests_dict, key, qint_from_int(value));
83
84 obj = qdict_get(tests_dict, key);
Anthony Liguoriac531cb2012-01-10 13:10:44 -060085 g_assert(obj != NULL);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030086
87 qi = qobject_to_qint(obj);
Anthony Liguoriac531cb2012-01-10 13:10:44 -060088 g_assert(qint_get_int(qi) == value);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030089
Anthony Liguoriac531cb2012-01-10 13:10:44 -060090 QDECREF(tests_dict);
91}
92
93static void qdict_get_int_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030094{
95 int ret;
96 const int value = 100;
97 const char *key = "int";
Anthony Liguoriac531cb2012-01-10 13:10:44 -060098 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -030099
100 qdict_put(tests_dict, key, qint_from_int(value));
101
102 ret = qdict_get_int(tests_dict, key);
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600103 g_assert(ret == value);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300104
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600105 QDECREF(tests_dict);
106}
107
108static void qdict_get_try_int_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300109{
110 int ret;
111 const int value = 100;
112 const char *key = "int";
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600113 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300114
115 qdict_put(tests_dict, key, qint_from_int(value));
116
117 ret = qdict_get_try_int(tests_dict, key, 0);
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600118 g_assert(ret == value);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300119
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600120 QDECREF(tests_dict);
121}
122
123static void qdict_get_str_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300124{
125 const char *p;
126 const char *key = "key";
127 const char *str = "string";
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600128 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300129
130 qdict_put(tests_dict, key, qstring_from_str(str));
131
132 p = qdict_get_str(tests_dict, key);
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600133 g_assert(p != NULL);
134 g_assert(strcmp(p, str) == 0);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300135
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600136 QDECREF(tests_dict);
137}
138
139static void qdict_get_try_str_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300140{
141 const char *p;
142 const char *key = "key";
143 const char *str = "string";
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600144 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300145
146 qdict_put(tests_dict, key, qstring_from_str(str));
147
148 p = qdict_get_try_str(tests_dict, key);
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600149 g_assert(p != NULL);
150 g_assert(strcmp(p, str) == 0);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300151
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600152 QDECREF(tests_dict);
153}
154
155static void qdict_haskey_not_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300156{
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600157 QDict *tests_dict = qdict_new();
158 g_assert(qdict_haskey(tests_dict, "test") == 0);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300159
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600160 QDECREF(tests_dict);
161}
162
163static void qdict_haskey_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300164{
165 const char *key = "test";
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600166 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300167
168 qdict_put(tests_dict, key, qint_from_int(0));
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600169 g_assert(qdict_haskey(tests_dict, key) == 1);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300170
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600171 QDECREF(tests_dict);
172}
173
174static void qdict_del_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300175{
176 const char *key = "key test";
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600177 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300178
179 qdict_put(tests_dict, key, qstring_from_str("foo"));
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600180 g_assert(qdict_size(tests_dict) == 1);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300181
182 qdict_del(tests_dict, key);
183
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600184 g_assert(qdict_size(tests_dict) == 0);
185 g_assert(qdict_haskey(tests_dict, key) == 0);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300186
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600187 QDECREF(tests_dict);
188}
189
190static void qobject_to_qdict_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300191{
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600192 QDict *tests_dict = qdict_new();
193 g_assert(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300194
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600195 QDECREF(tests_dict);
196}
197
198static void qdict_iterapi_test(void)
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300199{
200 int count;
201 const QDictEntry *ent;
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600202 QDict *tests_dict = qdict_new();
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300203
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600204 g_assert(qdict_first(tests_dict) == NULL);
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300205
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)){
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600212 g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300213 count++;
214 }
215
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600216 g_assert(count == qdict_size(tests_dict));
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300217
218 /* Do it again to test restarting */
219 count = 0;
220 for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600221 g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300222 count++;
223 }
224
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600225 g_assert(count == qdict_size(tests_dict));
226
227 QDECREF(tests_dict);
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300228}
Luiz Capitulinod02c6bd2010-06-07 15:29:58 -0300229
Max Reitz3fb11772013-12-20 19:28:22 +0100230static 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
Max Reitzbe331342013-12-20 19:28:21 +0100305static void qdict_array_split_test(void)
306{
307 QDict *test_dict = qdict_new();
308 QDict *dict1, *dict2;
Max Reitz7841c762014-02-21 19:11:41 +0100309 QInt *int1;
Max Reitzbe331342013-12-20 19:28:21 +0100310 QList *test_list;
311
312 /*
313 * Test the split of
314 *
315 * {
316 * "1.x": 0,
Max Reitz7841c762014-02-21 19:11:41 +0100317 * "4.y": 1,
Max Reitzbe331342013-12-20 19:28:21 +0100318 * "0.a": 42,
319 * "o.o": 7,
Max Reitz7841c762014-02-21 19:11:41 +0100320 * "0.b": 23,
321 * "2": 66
Max Reitzbe331342013-12-20 19:28:21 +0100322 * }
323 *
324 * to
325 *
326 * [
327 * {
328 * "a": 42,
329 * "b": 23
330 * },
331 * {
332 * "x": 0
Max Reitz7841c762014-02-21 19:11:41 +0100333 * },
334 * 66
Max Reitzbe331342013-12-20 19:28:21 +0100335 * ]
336 *
337 * and
338 *
339 * {
Max Reitz7841c762014-02-21 19:11:41 +0100340 * "4.y": 1,
Max Reitzbe331342013-12-20 19:28:21 +0100341 * "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));
Max Reitz7841c762014-02-21 19:11:41 +0100350 qdict_put(test_dict, "4.y", qint_from_int(1));
Max Reitzbe331342013-12-20 19:28:21 +0100351 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));
Max Reitz7841c762014-02-21 19:11:41 +0100354 qdict_put(test_dict, "2", qint_from_int(66));
Max Reitzbe331342013-12-20 19:28:21 +0100355
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));
Max Reitz7841c762014-02-21 19:11:41 +0100360 int1 = qobject_to_qint(qlist_pop(test_list));
Max Reitzbe331342013-12-20 19:28:21 +0100361
362 g_assert(dict1);
363 g_assert(dict2);
Max Reitz7841c762014-02-21 19:11:41 +0100364 g_assert(int1);
Max Reitzbe331342013-12-20 19:28:21 +0100365 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
Max Reitz7841c762014-02-21 19:11:41 +0100382 g_assert(qint_get_int(int1) == 66);
383
384 QDECREF(int1);
385
386 g_assert(qdict_get_int(test_dict, "4.y") == 1);
Max Reitzbe331342013-12-20 19:28:21 +0100387 g_assert(qdict_get_int(test_dict, "o.o") == 7);
388
389 g_assert(qdict_size(test_dict) == 2);
390
391 QDECREF(test_dict);
Max Reitz64757582014-02-21 21:05:13 +0100392
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);
Max Reitzbe331342013-12-20 19:28:21 +0100445}
446
Max Reitz8a5eb362014-05-08 20:12:40 +0200447static 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
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300533/*
534 * Errors test-cases
535 */
536
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600537static void qdict_put_exists_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300538{
539 int value;
540 const char *key = "exists";
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600541 QDict *tests_dict = qdict_new();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300542
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);
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600547 g_assert(value == 2);
Luiz Capitulino29ec3152009-12-14 18:53:20 -0200548
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600549 g_assert(qdict_size(tests_dict) == 1);
550
551 QDECREF(tests_dict);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300552}
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300553
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600554static void qdict_get_not_exists_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300555{
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600556 QDict *tests_dict = qdict_new();
557 g_assert(qdict_get(tests_dict, "foo") == NULL);
558
559 QDECREF(tests_dict);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300560}
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300561
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
569static void remove_dots(char *string)
570{
571 char *p = strchr(string, ':');
572 if (p)
573 *p = '\0';
574}
575
576static QString *read_line(FILE *file, char *key)
577{
578 char value[128];
579
Stefan Weil7464f052011-01-21 22:50:30 +0100580 if (fscanf(file, "%127s%127s", key, value) == EOF) {
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300581 return NULL;
Stefan Weil7464f052011-01-21 22:50:30 +0100582 }
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300583 remove_dots(key);
584 return qstring_from_str(value);
585}
586
587#define reset_file(file) fseek(file, 0L, SEEK_SET)
588
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600589static void qdict_stress_test(void)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300590{
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");
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600599 g_assert(test_file != NULL);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300600
601 // Create the dict
602 qdict = qdict_new();
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600603 g_assert(qdict != NULL);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300604
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 }
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600613 g_assert(qdict_size(qdict) == lines);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300614
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);
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600627 g_assert(str2 != NULL);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300628
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600629 g_assert(strcmp(str1, str2) == 0);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300630
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
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600644 g_assert(qdict_haskey(qdict, key) == 0);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300645 }
646 fclose(test_file);
647
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600648 g_assert(qdict_size(qdict) == 0);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300649 QDECREF(qdict);
650}
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300651
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600652int main(int argc, char **argv)
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300653{
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600654 g_test_init(&argc, &argv, NULL);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300655
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600656 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);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300659
660 /* Continue, but now with fixtures */
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600661 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);
Max Reitz3fb11772013-12-20 19:28:22 +0100671 g_test_add_func("/public/flatten", qdict_flatten_test);
Max Reitzbe331342013-12-20 19:28:21 +0100672 g_test_add_func("/public/array_split", qdict_array_split_test);
Max Reitz8a5eb362014-05-08 20:12:40 +0200673 g_test_add_func("/public/join", qdict_join_test);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300674
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600675 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);
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300677
678 /* The Big one */
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600679 if (g_test_slow()) {
680 g_test_add_func("/stress/test", qdict_stress_test);
681 }
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300682
Anthony Liguoriac531cb2012-01-10 13:10:44 -0600683 return g_test_run();
Luiz Capitulino7b8c51a2009-08-28 15:27:32 -0300684}