Debian Codegraph @

test/litest-selftest.c

raw
1 #include <config.h>
2
3 #include <signal.h>
4 #include <sys/resource.h>
5 #include <sys/time.h>
6 #include <valgrind/valgrind.h>
7
8 #include "litest.h"
9 /* This is a bit messy but until we've completely switched over
10 * to the litest runner it's easier like this */
11 #undef START_TEST
12 #undef END_TEST
13 #include <check.h>
14
15 START_TEST(litest_assert_trigger)
16 {
17 litest_assert(1 == 2);
18 }
19 END_TEST
20
21 START_TEST(litest_assert_notrigger)
22 {
23 litest_assert(1 == 1);
24 }
25 END_TEST
26
27 START_TEST(litest_assert_msg_trigger)
28 {
29 litest_assert_msg(1 == 2, "1 is not 2\n");
30 }
31 END_TEST
32
33 START_TEST(litest_assert_msg_NULL_trigger)
34 {
35 litest_assert_msg(1 == 2, NULL);
36 }
37 END_TEST
38
39 START_TEST(litest_assert_msg_notrigger)
40 {
41 litest_assert_msg(1 == 1, "1 is not 2\n");
42 litest_assert_msg(1 == 1, NULL);
43 }
44 END_TEST
45
46 START_TEST(litest_abort_msg_trigger)
47 {
48 litest_abort_msg("message\n");
49 }
50 END_TEST
51
52 START_TEST(litest_abort_msg_NULL_trigger)
53 {
54 litest_abort_msg(NULL);
55 }
56 END_TEST
57
58 START_TEST(litest_int_eq_trigger)
59 {
60 int a = 10;
61 int b = 20;
62 litest_assert_int_eq(a, b);
63 }
64 END_TEST
65
66 START_TEST(litest_int_eq_notrigger)
67 {
68 int a = 10;
69 int b = 10;
70 litest_assert_int_eq(a, b);
71 }
72 END_TEST
73
74 START_TEST(litest_int_ne_trigger)
75 {
76 int a = 10;
77 int b = 10;
78 litest_assert_int_ne(a, b);
79 }
80 END_TEST
81
82 START_TEST(litest_int_ne_notrigger)
83 {
84 int a = 10;
85 int b = 20;
86 litest_assert_int_ne(a, b);
87 }
88 END_TEST
89
90 START_TEST(litest_int_lt_trigger_eq)
91 {
92 int a = 10;
93 int b = 10;
94 litest_assert_int_lt(a, b);
95 }
96 END_TEST
97
98 START_TEST(litest_int_lt_trigger_gt)
99 {
100 int a = 11;
101 int b = 10;
102 litest_assert_int_lt(a, b);
103 }
104 END_TEST
105
106 START_TEST(litest_int_lt_notrigger)
107 {
108 int a = 10;
109 int b = 11;
110 litest_assert_int_lt(a, b);
111 }
112 END_TEST
113
114 START_TEST(litest_int_le_trigger)
115 {
116 int a = 11;
117 int b = 10;
118 litest_assert_int_le(a, b);
119 }
120 END_TEST
121
122 START_TEST(litest_int_le_notrigger)
123 {
124 int a = 10;
125 int b = 11;
126 int c = 10;
127 litest_assert_int_le(a, b);
128 litest_assert_int_le(a, c);
129 }
130 END_TEST
131
132 START_TEST(litest_int_gt_trigger_eq)
133 {
134 int a = 10;
135 int b = 10;
136 litest_assert_int_gt(a, b);
137 }
138 END_TEST
139
140 START_TEST(litest_int_gt_trigger_lt)
141 {
142 int a = 9;
143 int b = 10;
144 litest_assert_int_gt(a, b);
145 }
146 END_TEST
147
148 START_TEST(litest_int_gt_notrigger)
149 {
150 int a = 10;
151 int b = 9;
152 litest_assert_int_gt(a, b);
153 }
154 END_TEST
155
156 START_TEST(litest_int_ge_trigger)
157 {
158 int a = 9;
159 int b = 10;
160 litest_assert_int_ge(a, b);
161 }
162 END_TEST
163
164 START_TEST(litest_int_ge_notrigger)
165 {
166 int a = 10;
167 int b = 9;
168 int c = 10;
169 litest_assert_int_ge(a, b);
170 litest_assert_int_ge(a, c);
171 }
172 END_TEST
173
174 START_TEST(litest_ptr_eq_notrigger)
175 {
176 int v = 10;
177 int *a = &v;
178 int *b = &v;
179 int *c = NULL;
180 int *d = NULL;
181
182 litest_assert_ptr_eq(a, b);
183 litest_assert_ptr_eq(c, d);
184 }
185 END_TEST
186
187 START_TEST(litest_ptr_eq_trigger)
188 {
189 int v = 10;
190 int v2 = 11;
191 int *a = &v;
192 int *b = &v2;
193
194 litest_assert_ptr_eq(a, b);
195 }
196 END_TEST
197
198 START_TEST(litest_ptr_eq_trigger_NULL)
199 {
200 int v = 10;
201 int *a = &v;
202 int *b = NULL;
203
204 litest_assert_ptr_eq(a, b);
205 }
206 END_TEST
207
208 START_TEST(litest_ptr_eq_trigger_NULL2)
209 {
210 int v = 10;
211 int *a = &v;
212 int *b = NULL;
213
214 litest_assert_ptr_eq(b, a);
215 }
216 END_TEST
217
218 START_TEST(litest_ptr_ne_trigger)
219 {
220 int v = 10;
221 int *a = &v;
222 int *b = &v;
223
224 litest_assert_ptr_ne(a, b);
225 }
226 END_TEST
227
228 START_TEST(litest_ptr_ne_trigger_NULL)
229 {
230 int *a = NULL;
231
232 litest_assert_ptr_ne(a, NULL);
233 }
234 END_TEST
235
236 START_TEST(litest_ptr_ne_trigger_NULL2)
237 {
238 int *a = NULL;
239
240 litest_assert_ptr_ne(NULL, a);
241 }
242 END_TEST
243
244 START_TEST(litest_ptr_ne_notrigger)
245 {
246 int v1 = 10;
247 int v2 = 10;
248 int *a = &v1;
249 int *b = &v2;
250 int *c = NULL;
251
252 litest_assert_ptr_ne(a, b);
253 litest_assert_ptr_ne(a, c);
254 litest_assert_ptr_ne(c, b);
255 }
256 END_TEST
257
258 START_TEST(litest_ptr_null_notrigger)
259 {
260 int *a = NULL;
261
262 litest_assert_ptr_null(a);
263 litest_assert_ptr_null(NULL);
264 }
265 END_TEST
266
267 START_TEST(litest_ptr_null_trigger)
268 {
269 int v;
270 int *a = &v;
271
272 litest_assert_ptr_null(a);
273 }
274 END_TEST
275
276 START_TEST(litest_ptr_notnull_notrigger)
277 {
278 int v;
279 int *a = &v;
280
281 litest_assert_ptr_notnull(a);
282 }
283 END_TEST
284
285 START_TEST(litest_ptr_notnull_trigger)
286 {
287 int *a = NULL;
288
289 litest_assert_ptr_notnull(a);
290 }
291 END_TEST
292
293 START_TEST(litest_ptr_notnull_trigger_NULL)
294 {
295 litest_assert_ptr_notnull(NULL);
296 }
297 END_TEST
298
299 START_TEST(litest_double_eq_and_ne)
300 {
301 litest_assert_double_eq(0.4, 0.4);
302 litest_assert_double_eq(0.4, 0.4 + 1E-6);
303 litest_assert_double_ne(0.4, 0.4 + 1E-3);
304
305 litest_assert_double_eq_epsilon(0.4, 0.5, 0.1);
306 litest_assert_double_eq_epsilon(0.4, 0.5, 0.2);
307 litest_assert_double_ne_epsilon(0.4, 0.6, 0.1);
308 litest_assert_double_ne_epsilon(0.4, 0.41, 0.005);
309 }
310 END_TEST
311
312 START_TEST(litest_double_lt_gt)
313 {
314 litest_assert_double_lt(12.0, 13.0);
315 litest_assert_double_gt(15.4, 13.0);
316 litest_assert_double_le(12.0, 12.0);
317 litest_assert_double_le(12.0, 20.0);
318 litest_assert_double_ge(12.0, 12.0);
319 litest_assert_double_ge(20.0, 12.0);
320 }
321 END_TEST
322
323 START_TEST(litest_double_eq_fails)
324 {
325 litest_assert_double_eq(0.41, 0.4);
326 }
327 END_TEST
328
329 START_TEST(litest_double_eq_epsilon_fails)
330 {
331 litest_assert_double_eq_epsilon(0.4, 0.5, 0.05);
332 }
333 END_TEST
334
335 START_TEST(litest_double_ne_fails)
336 {
337 litest_assert_double_ne(0.4 + 1E-7, 0.4);
338 }
339 END_TEST
340
341 START_TEST(litest_double_ne_epsilon_fails)
342 {
343 litest_assert_double_ne_epsilon(0.4, 0.5, 0.2);
344 }
345 END_TEST
346
347 START_TEST(litest_double_lt_fails)
348 {
349 litest_assert_double_lt(6.0, 5.0);
350 }
351 END_TEST
352
353 START_TEST(litest_double_gt_fails)
354 {
355 litest_assert_double_gt(5.0, 6.0);
356 }
357 END_TEST
358
359 START_TEST(litest_double_le_fails)
360 {
361 litest_assert_double_le(6.0, 5.0);
362 }
363 END_TEST
364
365 START_TEST(litest_double_ge_fails)
366 {
367 litest_assert_double_ge(5.0, 6.0);
368 }
369 END_TEST
370
371 START_TEST(litest_string_eq_ne)
372 {
373 litest_assert_str_eq("foo", "foo");
374 litest_assert_str_ne("foo", "bar");
375 litest_assert_str_ne("foo", "foobar");
376 litest_assert_str_ne("foobar", "foo");
377
378 const char *a1 = "a";
379 const char *a2 = "a";
380 const char *b = "b";
381
382 litest_assert_str_eq(NULL, NULL);
383 litest_assert_str_eq(a1, a2);
384 litest_assert_str_ne(a1, b);
385 litest_assert_str_ne(a2, b);
386 litest_assert_str_ne(a2, b);
387 litest_assert_str_ne(b, NULL);
388 }
389 END_TEST
390
391 START_TEST(litest_string_eq_fails)
392 {
393 litest_assert_str_eq("foo", "bar");
394 }
395 END_TEST
396
397 START_TEST(litest_string_ne_fails)
398 {
399 litest_assert_str_ne("foo", "foo");
400 }
401 END_TEST
402
403 START_TEST(zalloc_overflow)
404 {
405 zalloc((size_t)-1);
406 }
407 END_TEST
408
409 START_TEST(zalloc_max_size)
410 {
411 /* Built-in alloc maximum */
412 free(zalloc(1536 * 1024));
413 }
414 END_TEST
415
416 START_TEST(zalloc_too_large)
417 {
418 zalloc(1536 * 1024 + 1);
419 }
420 END_TEST
421
422 struct permutation {
423 int32_t i;
424 const char *s;
425 bool b;
426
427 bool found;
428 };
429
430 static int
431 permutation_func(struct litest_parameters_permutation *permutation, void *userdata)
432 {
433 struct litest_parameters_permutation_value *value;
434
435 int32_t first;
436 const char *second;
437 bool third;
438
439 value = list_first_entry(&permutation->values, value, link);
440 multivalue_extract_typed(&value->value, 'i', &first);
441
442 value = list_first_entry(&value->link, value, link);
443 multivalue_extract_typed(&value->value, 's', &second);
444
445 value = list_first_entry(&value->link, value, link);
446 multivalue_extract_typed(&value->value, 'b', &third);
447
448 struct permutation *p = userdata;
449 while (p->s) {
450 if (p->i == first && streq(p->s, second) && p->b == third) {
451 p->found = true;
452 break;
453 }
454 p++;
455 }
456
457 return 0;
458 }
459
460 START_TEST(parameter_permutations)
461 {
462 struct permutation permutations[] = {
463 { 1, "a", true }, { 1, "a", false }, { 1, "ab", true },
464 { 1, "ab", false }, { 1, "abc", true }, { 1, "abc", false },
465 { 2, "a", true }, { 2, "a", false }, { 2, "ab", true },
466 { 2, "ab", false }, { 2, "abc", true }, { 2, "abc", false },
467 { 3, "a", true }, { 3, "a", false }, { 3, "ab", true },
468 { 3, "ab", false }, { 3, "abc", true }, { 3, "abc", false },
469 { 0, NULL, false, false },
470 };
471 /* clang-format off */
472 struct litest_parameters *params = litest_parameters_new("first", 'i', 3, 1, 2, 3,
473 "second", 's', 3, "a", "ab", "abc",
474 "third", 'b',
475 NULL);
476 /* clang-format on */
477
478 litest_parameters_permutations(params, permutation_func, permutations);
479
480 ARRAY_FOR_EACH(permutations, p) {
481 if (p->s == NULL)
482 break;
483 ck_assert_msg(p->found, "For %d/%s/%s", p->i, p->s, truefalse(p->b));
484 }
485 }
486 END_TEST
487
488 static Suite *
489 litest_assert_macros_suite(void)
490 {
491 TCase *tc;
492 Suite *s;
493
494 s = suite_create("litest:assert macros");
495 tc = tcase_create("assert");
496 tcase_add_test_raise_signal(tc, litest_assert_trigger, SIGABRT);
497 tcase_add_test(tc, litest_assert_notrigger);
498 tcase_add_test_raise_signal(tc, litest_assert_msg_trigger, SIGABRT);
499 tcase_add_test_raise_signal(tc, litest_assert_msg_NULL_trigger, SIGABRT);
500 tcase_add_test(tc, litest_assert_msg_notrigger);
501 suite_add_tcase(s, tc);
502
503 tc = tcase_create("abort");
504 tcase_add_test_raise_signal(tc, litest_abort_msg_trigger, SIGABRT);
505 tcase_add_test_raise_signal(tc, litest_abort_msg_NULL_trigger, SIGABRT);
506 suite_add_tcase(s, tc);
507
508 tc = tcase_create("int comparison ");
509 tcase_add_test_raise_signal(tc, litest_int_eq_trigger, SIGABRT);
510 tcase_add_test(tc, litest_int_eq_notrigger);
511 tcase_add_test_raise_signal(tc, litest_int_ne_trigger, SIGABRT);
512 tcase_add_test(tc, litest_int_ne_notrigger);
513 tcase_add_test_raise_signal(tc, litest_int_le_trigger, SIGABRT);
514 tcase_add_test(tc, litest_int_le_notrigger);
515 tcase_add_test_raise_signal(tc, litest_int_lt_trigger_gt, SIGABRT);
516 tcase_add_test_raise_signal(tc, litest_int_lt_trigger_eq, SIGABRT);
517 tcase_add_test(tc, litest_int_lt_notrigger);
518 tcase_add_test_raise_signal(tc, litest_int_ge_trigger, SIGABRT);
519 tcase_add_test(tc, litest_int_ge_notrigger);
520 tcase_add_test_raise_signal(tc, litest_int_gt_trigger_eq, SIGABRT);
521 tcase_add_test_raise_signal(tc, litest_int_gt_trigger_lt, SIGABRT);
522 tcase_add_test(tc, litest_int_gt_notrigger);
523 suite_add_tcase(s, tc);
524
525 tc = tcase_create("pointer comparison ");
526 tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger, SIGABRT);
527 tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL, SIGABRT);
528 tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL2, SIGABRT);
529 tcase_add_test(tc, litest_ptr_eq_notrigger);
530 tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger, SIGABRT);
531 tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL, SIGABRT);
532 tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL2, SIGABRT);
533 tcase_add_test(tc, litest_ptr_ne_notrigger);
534 tcase_add_test_raise_signal(tc, litest_ptr_null_trigger, SIGABRT);
535 tcase_add_test(tc, litest_ptr_null_notrigger);
536 tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger, SIGABRT);
537 tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger_NULL, SIGABRT);
538 tcase_add_test(tc, litest_ptr_notnull_notrigger);
539 suite_add_tcase(s, tc);
540
541 tc = tcase_create("double comparison ");
542 tcase_add_test(tc, litest_double_eq_and_ne);
543 tcase_add_test(tc, litest_double_lt_gt);
544 tcase_add_test_raise_signal(tc, litest_double_eq_fails, SIGABRT);
545 tcase_add_test_raise_signal(tc, litest_double_eq_epsilon_fails, SIGABRT);
546 tcase_add_test_raise_signal(tc, litest_double_ne_fails, SIGABRT);
547 tcase_add_test_raise_signal(tc, litest_double_ne_epsilon_fails, SIGABRT);
548 tcase_add_test_raise_signal(tc, litest_double_lt_fails, SIGABRT);
549 tcase_add_test_raise_signal(tc, litest_double_gt_fails, SIGABRT);
550 tcase_add_test_raise_signal(tc, litest_double_le_fails, SIGABRT);
551 tcase_add_test_raise_signal(tc, litest_double_ge_fails, SIGABRT);
552 suite_add_tcase(s, tc);
553
554 tc = tcase_create("string comparison ");
555 tcase_add_test(tc, litest_string_eq_ne);
556 tcase_add_test_raise_signal(tc, litest_string_eq_fails, SIGABRT);
557 tcase_add_test_raise_signal(tc, litest_string_ne_fails, SIGABRT);
558 suite_add_tcase(s, tc);
559
560 tc = tcase_create("zalloc ");
561 tcase_add_test(tc, zalloc_max_size);
562 tcase_add_test_raise_signal(tc, zalloc_overflow, SIGABRT);
563 tcase_add_test_raise_signal(tc, zalloc_too_large, SIGABRT);
564 suite_add_tcase(s, tc);
565
566 tc = tcase_create("parameters ");
567 tcase_add_test(tc, parameter_permutations);
568 suite_add_tcase(s, tc);
569
570 return s;
571 }
572
573 int
574 main(int argc, char **argv)
575 {
576 const struct rlimit corelimit = { 0, 0 };
577 int nfailed;
578 Suite *s;
579 SRunner *sr;
580
581 /* when running under valgrind we're using nofork mode, so a signal
582 * raised by a test will fail in valgrind. There's nothing to
583 * memcheck here anyway, so just skip the valgrind test */
584 if (RUNNING_ON_VALGRIND)
585 return 77;
586
587 if (setrlimit(RLIMIT_CORE, &corelimit) != 0)
588 perror("WARNING: Core dumps not disabled");
589
590 s = litest_assert_macros_suite();
591 sr = srunner_create(s);
592
593 srunner_run_all(sr, CK_ENV);
594 nfailed = srunner_ntests_failed(sr);
595 srunner_free(sr);
596
597 return (nfailed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
598 }