Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 402 lines (317 sloc) 9.117 kb
68396ea @rmustacc Initial commit of d32e8d0b8d9e0ef7cf7ab2e74548982972789dfc from qemu-kvm
rmustacc authored
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 }
Something went wrong with that request. Please try again.