1 #include <config.h>
2
3 #include <sys/resource.h>
4 #include <sys/time.h>
5 #include <check.h>
6 #include <signal.h>
7
8 #include <valgrind/valgrind.h>
9
10 #include "litest.h"
11
START_TEST(litest_assert_trigger)12 START_TEST(litest_assert_trigger)
13 {
14 litest_assert(1 == 2);
15 }
16 END_TEST
17
START_TEST(litest_assert_notrigger)18 START_TEST(litest_assert_notrigger)
19 {
20 litest_assert(1 == 1);
21 }
22 END_TEST
23
START_TEST(litest_assert_msg_trigger)24 START_TEST(litest_assert_msg_trigger)
25 {
26 litest_assert_msg(1 == 2, "1 is not 2\n");
27 }
28 END_TEST
29
START_TEST(litest_assert_msg_NULL_trigger)30 START_TEST(litest_assert_msg_NULL_trigger)
31 {
32 litest_assert_msg(1 == 2, NULL);
33 }
34 END_TEST
35
START_TEST(litest_assert_msg_notrigger)36 START_TEST(litest_assert_msg_notrigger)
37 {
38 litest_assert_msg(1 == 1, "1 is not 2\n");
39 litest_assert_msg(1 == 1, NULL);
40 }
41 END_TEST
42
START_TEST(litest_abort_msg_trigger)43 START_TEST(litest_abort_msg_trigger)
44 {
45 litest_abort_msg("message\n");
46 }
47 END_TEST
48
START_TEST(litest_abort_msg_NULL_trigger)49 START_TEST(litest_abort_msg_NULL_trigger)
50 {
51 litest_abort_msg(NULL);
52 }
53 END_TEST
54
START_TEST(litest_int_eq_trigger)55 START_TEST(litest_int_eq_trigger)
56 {
57 int a = 10;
58 int b = 20;
59 litest_assert_int_eq(a, b);
60 }
61 END_TEST
62
START_TEST(litest_int_eq_notrigger)63 START_TEST(litest_int_eq_notrigger)
64 {
65 int a = 10;
66 int b = 10;
67 litest_assert_int_eq(a, b);
68 }
69 END_TEST
70
START_TEST(litest_int_ne_trigger)71 START_TEST(litest_int_ne_trigger)
72 {
73 int a = 10;
74 int b = 10;
75 litest_assert_int_ne(a, b);
76 }
77 END_TEST
78
START_TEST(litest_int_ne_notrigger)79 START_TEST(litest_int_ne_notrigger)
80 {
81 int a = 10;
82 int b = 20;
83 litest_assert_int_ne(a, b);
84 }
85 END_TEST
86
START_TEST(litest_int_lt_trigger_eq)87 START_TEST(litest_int_lt_trigger_eq)
88 {
89 int a = 10;
90 int b = 10;
91 litest_assert_int_lt(a, b);
92 }
93 END_TEST
94
START_TEST(litest_int_lt_trigger_gt)95 START_TEST(litest_int_lt_trigger_gt)
96 {
97 int a = 11;
98 int b = 10;
99 litest_assert_int_lt(a, b);
100 }
101 END_TEST
102
START_TEST(litest_int_lt_notrigger)103 START_TEST(litest_int_lt_notrigger)
104 {
105 int a = 10;
106 int b = 11;
107 litest_assert_int_lt(a, b);
108 }
109 END_TEST
110
START_TEST(litest_int_le_trigger)111 START_TEST(litest_int_le_trigger)
112 {
113 int a = 11;
114 int b = 10;
115 litest_assert_int_le(a, b);
116 }
117 END_TEST
118
START_TEST(litest_int_le_notrigger)119 START_TEST(litest_int_le_notrigger)
120 {
121 int a = 10;
122 int b = 11;
123 int c = 10;
124 litest_assert_int_le(a, b);
125 litest_assert_int_le(a, c);
126 }
127 END_TEST
128
START_TEST(litest_int_gt_trigger_eq)129 START_TEST(litest_int_gt_trigger_eq)
130 {
131 int a = 10;
132 int b = 10;
133 litest_assert_int_gt(a, b);
134 }
135 END_TEST
136
START_TEST(litest_int_gt_trigger_lt)137 START_TEST(litest_int_gt_trigger_lt)
138 {
139 int a = 9;
140 int b = 10;
141 litest_assert_int_gt(a, b);
142 }
143 END_TEST
144
START_TEST(litest_int_gt_notrigger)145 START_TEST(litest_int_gt_notrigger)
146 {
147 int a = 10;
148 int b = 9;
149 litest_assert_int_gt(a, b);
150 }
151 END_TEST
152
START_TEST(litest_int_ge_trigger)153 START_TEST(litest_int_ge_trigger)
154 {
155 int a = 9;
156 int b = 10;
157 litest_assert_int_ge(a, b);
158 }
159 END_TEST
160
START_TEST(litest_int_ge_notrigger)161 START_TEST(litest_int_ge_notrigger)
162 {
163 int a = 10;
164 int b = 9;
165 int c = 10;
166 litest_assert_int_ge(a, b);
167 litest_assert_int_ge(a, c);
168 }
169 END_TEST
170
START_TEST(litest_ptr_eq_notrigger)171 START_TEST(litest_ptr_eq_notrigger)
172 {
173 int v = 10;
174 int *a = &v;
175 int *b = &v;
176 int *c = NULL;
177 int *d = NULL;
178
179 litest_assert_ptr_eq(a, b);
180 litest_assert_ptr_eq(c, d);
181 }
182 END_TEST
183
START_TEST(litest_ptr_eq_trigger)184 START_TEST(litest_ptr_eq_trigger)
185 {
186 int v = 10;
187 int v2 = 11;
188 int *a = &v;
189 int *b = &v2;
190
191 litest_assert_ptr_eq(a, b);
192 }
193 END_TEST
194
START_TEST(litest_ptr_eq_trigger_NULL)195 START_TEST(litest_ptr_eq_trigger_NULL)
196 {
197 int v = 10;
198 int *a = &v;
199 int *b = NULL;
200
201 litest_assert_ptr_eq(a, b);
202 }
203 END_TEST
204
START_TEST(litest_ptr_eq_trigger_NULL2)205 START_TEST(litest_ptr_eq_trigger_NULL2)
206 {
207 int v = 10;
208 int *a = &v;
209 int *b = NULL;
210
211 litest_assert_ptr_eq(b, a);
212 }
213 END_TEST
214
START_TEST(litest_ptr_ne_trigger)215 START_TEST(litest_ptr_ne_trigger)
216 {
217 int v = 10;
218 int *a = &v;
219 int *b = &v;
220
221 litest_assert_ptr_ne(a, b);
222 }
223 END_TEST
224
START_TEST(litest_ptr_ne_trigger_NULL)225 START_TEST(litest_ptr_ne_trigger_NULL)
226 {
227 int *a = NULL;
228
229 litest_assert_ptr_ne(a, NULL);
230 }
231 END_TEST
232
START_TEST(litest_ptr_ne_trigger_NULL2)233 START_TEST(litest_ptr_ne_trigger_NULL2)
234 {
235 int *a = NULL;
236
237 litest_assert_ptr_ne(NULL, a);
238 }
239 END_TEST
240
START_TEST(litest_ptr_ne_notrigger)241 START_TEST(litest_ptr_ne_notrigger)
242 {
243 int v1 = 10;
244 int v2 = 10;
245 int *a = &v1;
246 int *b = &v2;
247 int *c = NULL;
248
249 litest_assert_ptr_ne(a, b);
250 litest_assert_ptr_ne(a, c);
251 litest_assert_ptr_ne(c, b);
252 }
253 END_TEST
254
START_TEST(litest_ptr_null_notrigger)255 START_TEST(litest_ptr_null_notrigger)
256 {
257 int *a = NULL;
258
259 litest_assert_ptr_null(a);
260 litest_assert_ptr_null(NULL);
261 }
262 END_TEST
263
START_TEST(litest_ptr_null_trigger)264 START_TEST(litest_ptr_null_trigger)
265 {
266 int v;
267 int *a = &v;
268
269 litest_assert_ptr_null(a);
270 }
271 END_TEST
272
START_TEST(litest_ptr_notnull_notrigger)273 START_TEST(litest_ptr_notnull_notrigger)
274 {
275 int v;
276 int *a = &v;
277
278 litest_assert_ptr_notnull(a);
279 }
280 END_TEST
281
START_TEST(litest_ptr_notnull_trigger)282 START_TEST(litest_ptr_notnull_trigger)
283 {
284 int *a = NULL;
285
286 litest_assert_ptr_notnull(a);
287 }
288 END_TEST
289
START_TEST(litest_ptr_notnull_trigger_NULL)290 START_TEST(litest_ptr_notnull_trigger_NULL)
291 {
292 litest_assert_ptr_notnull(NULL);
293 }
294 END_TEST
295
START_TEST(ck_double_eq_and_ne)296 START_TEST(ck_double_eq_and_ne)
297 {
298 ck_assert_double_eq(0.4,0.4);
299 ck_assert_double_eq(0.4,0.4 + 1E-6);
300 ck_assert_double_ne(0.4,0.4 + 1E-3);
301 }
302 END_TEST
303
START_TEST(ck_double_lt_gt)304 START_TEST(ck_double_lt_gt)
305 {
306 ck_assert_double_lt(12.0,13.0);
307 ck_assert_double_gt(15.4,13.0);
308 ck_assert_double_le(12.0,12.0);
309 ck_assert_double_le(12.0,20.0);
310 ck_assert_double_ge(12.0,12.0);
311 ck_assert_double_ge(20.0,12.0);
312 }
313 END_TEST
314
START_TEST(ck_double_eq_fails)315 START_TEST(ck_double_eq_fails)
316 {
317 ck_assert_double_eq(0.41,0.4);
318 }
319 END_TEST
320
START_TEST(ck_double_ne_fails)321 START_TEST(ck_double_ne_fails)
322 {
323 ck_assert_double_ne(0.4 + 1E-7,0.4);
324 }
325 END_TEST
326
START_TEST(ck_double_lt_fails)327 START_TEST(ck_double_lt_fails)
328 {
329 ck_assert_double_lt(6,5);
330 }
331 END_TEST
332
START_TEST(ck_double_gt_fails)333 START_TEST(ck_double_gt_fails)
334 {
335 ck_assert_double_gt(5,6);
336 }
337 END_TEST
338
START_TEST(ck_double_le_fails)339 START_TEST(ck_double_le_fails)
340 {
341 ck_assert_double_le(6,5);
342 }
343 END_TEST
344
START_TEST(ck_double_ge_fails)345 START_TEST(ck_double_ge_fails)
346 {
347 ck_assert_double_ge(5,6);
348 }
349 END_TEST
350
START_TEST(zalloc_overflow)351 START_TEST(zalloc_overflow)
352 {
353 zalloc((size_t)-1);
354 }
355 END_TEST
356
START_TEST(zalloc_max_size)357 START_TEST(zalloc_max_size)
358 {
359 /* Built-in alloc maximum */
360 free(zalloc(1536 * 1024));
361 }
362 END_TEST
363
START_TEST(zalloc_too_large)364 START_TEST(zalloc_too_large)
365 {
366 zalloc(1536 * 1024 + 1);
367 }
368 END_TEST
369
370 static Suite *
litest_assert_macros_suite(void)371 litest_assert_macros_suite(void)
372 {
373 TCase *tc;
374 Suite *s;
375
376 s = suite_create("litest:assert macros");
377 tc = tcase_create("assert");
378 tcase_add_test_raise_signal(tc, litest_assert_trigger, SIGABRT);
379 tcase_add_test(tc, litest_assert_notrigger);
380 tcase_add_test_raise_signal(tc, litest_assert_msg_trigger, SIGABRT);
381 tcase_add_test_raise_signal(tc, litest_assert_msg_NULL_trigger, SIGABRT);
382 tcase_add_test(tc, litest_assert_msg_notrigger);
383 suite_add_tcase(s, tc);
384
385 tc = tcase_create("abort");
386 tcase_add_test_raise_signal(tc, litest_abort_msg_trigger, SIGABRT);
387 tcase_add_test_raise_signal(tc, litest_abort_msg_NULL_trigger, SIGABRT);
388 suite_add_tcase(s, tc);
389
390 tc = tcase_create("int comparison ");
391 tcase_add_test_raise_signal(tc, litest_int_eq_trigger, SIGABRT);
392 tcase_add_test(tc, litest_int_eq_notrigger);
393 tcase_add_test_raise_signal(tc, litest_int_ne_trigger, SIGABRT);
394 tcase_add_test(tc, litest_int_ne_notrigger);
395 tcase_add_test_raise_signal(tc, litest_int_le_trigger, SIGABRT);
396 tcase_add_test(tc, litest_int_le_notrigger);
397 tcase_add_test_raise_signal(tc, litest_int_lt_trigger_gt, SIGABRT);
398 tcase_add_test_raise_signal(tc, litest_int_lt_trigger_eq, SIGABRT);
399 tcase_add_test(tc, litest_int_lt_notrigger);
400 tcase_add_test_raise_signal(tc, litest_int_ge_trigger, SIGABRT);
401 tcase_add_test(tc, litest_int_ge_notrigger);
402 tcase_add_test_raise_signal(tc, litest_int_gt_trigger_eq, SIGABRT);
403 tcase_add_test_raise_signal(tc, litest_int_gt_trigger_lt, SIGABRT);
404 tcase_add_test(tc, litest_int_gt_notrigger);
405 suite_add_tcase(s, tc);
406
407 tc = tcase_create("pointer comparison ");
408 tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger, SIGABRT);
409 tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL, SIGABRT);
410 tcase_add_test_raise_signal(tc, litest_ptr_eq_trigger_NULL2, SIGABRT);
411 tcase_add_test(tc, litest_ptr_eq_notrigger);
412 tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger, SIGABRT);
413 tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL, SIGABRT);
414 tcase_add_test_raise_signal(tc, litest_ptr_ne_trigger_NULL2, SIGABRT);
415 tcase_add_test(tc, litest_ptr_ne_notrigger);
416 tcase_add_test_raise_signal(tc, litest_ptr_null_trigger, SIGABRT);
417 tcase_add_test(tc, litest_ptr_null_notrigger);
418 tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger, SIGABRT);
419 tcase_add_test_raise_signal(tc, litest_ptr_notnull_trigger_NULL, SIGABRT);
420 tcase_add_test(tc, litest_ptr_notnull_notrigger);
421 suite_add_tcase(s, tc);
422
423 tc = tcase_create("double comparison ");
424 tcase_add_test(tc, ck_double_eq_and_ne);
425 tcase_add_test(tc, ck_double_lt_gt);
426 tcase_add_exit_test(tc, ck_double_eq_fails, 1);
427 tcase_add_exit_test(tc, ck_double_ne_fails, 1);
428 tcase_add_exit_test(tc, ck_double_lt_fails, 1);
429 tcase_add_exit_test(tc, ck_double_gt_fails, 1);
430 tcase_add_exit_test(tc, ck_double_le_fails, 1);
431 tcase_add_exit_test(tc, ck_double_ge_fails, 1);
432 suite_add_tcase(s, tc);
433
434 tc = tcase_create("zalloc ");
435 tcase_add_test(tc, zalloc_max_size);
436 tcase_add_test_raise_signal(tc, zalloc_overflow, SIGABRT);
437 tcase_add_test_raise_signal(tc, zalloc_too_large, SIGABRT);
438 suite_add_tcase(s, tc);
439
440 return s;
441 }
442
443 int
main(int argc,char ** argv)444 main (int argc, char **argv)
445 {
446 const struct rlimit corelimit = { 0, 0 };
447 int nfailed;
448 Suite *s;
449 SRunner *sr;
450
451 /* when running under valgrind we're using nofork mode, so a signal
452 * raised by a test will fail in valgrind. There's nothing to
453 * memcheck here anyway, so just skip the valgrind test */
454 if (RUNNING_ON_VALGRIND)
455 return 77;
456
457 if (setrlimit(RLIMIT_CORE, &corelimit) != 0)
458 perror("WARNING: Core dumps not disabled");
459
460 s = litest_assert_macros_suite();
461 sr = srunner_create(s);
462
463 srunner_run_all(sr, CK_ENV);
464 nfailed = srunner_ntests_failed(sr);
465 srunner_free(sr);
466
467 return (nfailed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
468 }
469