Line data Source code
1 : /** @file suite_libdebug-assert.c
2 : * @brief Check Libdebug assert functions
3 : * @author François Cerbelle (Fanfan), francois@cerbelle.net
4 : *
5 : * @internal
6 : * Created: 26/06/2024
7 : * Revision: none
8 : * Last modified: 2024-12-19 19:51
9 : * Compiler: gcc
10 : * Organization: Cerbelle.net
11 : * Copyright: Copyright (c) 2024, François Cerbelle
12 : *
13 : * This source code is released for free distribution under the terms of the
14 : * GNU General Public License as published by the Free Software Foundation.
15 : */
16 :
17 : #ifdef HAVE_CONFIG_H
18 : #include "config.h"
19 : #endif
20 :
21 : #define _XOPEN_SOURCE 500 /* snprintf */
22 : #include "libdebug/assert.h" /* libdebug's assertions */
23 : #include "oom.h" /* oomfill_setup */
24 : #include "libdebug/memtrack.h" /* memtrack_dumpblocks */
25 : #include <check.h>
26 : #include <unistd.h> /* pid_t getpid() */
27 : #include <sys/stat.h> /* mkdir(), chdir(), mode_t */
28 : #include <stdio.h> /* fprintf */
29 : #include <stdlib.h> /* abort() */
30 : #include "checktools.inc"
31 :
32 : #ifndef NDEBUG
33 : /** Test _trace with NULL or empty input strings */
34 3 : START_TEST(assert_trace_nullfile) {
35 : /* The function does not return anything or change any value, I can not
36 : * check if it worked. I can only expect it to work or to SIGSEV the process */
37 3 : forktest_only;
38 : #ifdef ENABLE_GCOV
39 : if(oomfill_enabled())
40 : __gcov_dump();
41 : #endif
42 : oomfill_fill(_i,2);
43 2 : _trace(NULL,__LINE__,__DATE__,__TIME__,__func__);
44 : }
45 : END_TEST
46 : #endif /* NDEBUG */
47 :
48 : #ifndef NDEBUG
49 : /** Test _trace with NULL or empty input strings */
50 3 : START_TEST(assert_trace_nullline) {
51 3 : forktest_only;
52 : #ifdef ENABLE_GCOV
53 : if(oomfill_enabled())
54 : __gcov_dump();
55 : #endif
56 : oomfill_fill(_i,2);
57 2 : _trace(__FILE__,0,__DATE__,__TIME__,__func__);
58 : }
59 : END_TEST
60 : #endif /* NDEBUG */
61 :
62 : #ifndef NDEBUG
63 : /** Test _trace with NULL or empty input strings */
64 3 : START_TEST(assert_trace_nulldate) {
65 3 : forktest_only;
66 : #ifdef ENABLE_GCOV
67 : if(oomfill_enabled())
68 : __gcov_dump();
69 : #endif
70 : oomfill_fill(_i,2);
71 2 : _trace(__FILE__,__LINE__,NULL,__TIME__,__func__);
72 : }
73 : END_TEST
74 : #endif /* NDEBUG */
75 :
76 : #ifndef NDEBUG
77 : /** Test _trace with NULL or empty input strings */
78 3 : START_TEST(assert_trace_nulltime) {
79 3 : forktest_only;
80 : #ifdef ENABLE_GCOV
81 : if(oomfill_enabled())
82 : __gcov_dump();
83 : #endif
84 : oomfill_fill(_i,2);
85 2 : _trace(__FILE__,__LINE__,__DATE__,NULL,__func__);
86 : }
87 : END_TEST
88 : #endif /* NDEBUG */
89 :
90 : #ifndef NDEBUG
91 : /** Test _trace with NULL or empty input strings */
92 3 : START_TEST(assert_trace_nullfunc) {
93 3 : forktest_only;
94 : #ifdef ENABLE_GCOV
95 : if(oomfill_enabled())
96 : __gcov_dump();
97 : #endif
98 : oomfill_fill(_i,2);
99 2 : _trace(__FILE__,__LINE__,__DATE__,__TIME__,NULL);
100 : }
101 : END_TEST
102 : #endif /* NDEBUG */
103 :
104 : #ifndef NDEBUG
105 : /** Test _trace with NULL or empty input strings */
106 3 : START_TEST(assert_trace_emptyfile) {
107 3 : forktest_only;
108 : #ifdef ENABLE_GCOV
109 : if(oomfill_enabled())
110 : __gcov_dump();
111 : #endif
112 : oomfill_fill(_i,2);
113 2 : _trace("",__LINE__,__DATE__,__TIME__,__func__);
114 : }
115 : END_TEST
116 : #endif /* NDEBUG */
117 :
118 : #ifndef NDEBUG
119 : /** Test _trace with NULL or empty input strings */
120 3 : START_TEST(assert_trace_emptydate) {
121 3 : forktest_only;
122 : #ifdef ENABLE_GCOV
123 : if(oomfill_enabled())
124 : __gcov_dump();
125 : #endif
126 : oomfill_fill(_i,2);
127 2 : _trace(__FILE__,__LINE__,"",__TIME__,__func__);
128 : }
129 : END_TEST
130 : #endif /* NDEBUG */
131 :
132 : #ifndef NDEBUG
133 : /** Test _trace with NULL or empty input strings */
134 3 : START_TEST(assert_trace_emptytime) {
135 3 : forktest_only;
136 : #ifdef ENABLE_GCOV
137 : if(oomfill_enabled())
138 : __gcov_dump();
139 : #endif
140 : oomfill_fill(_i,2);
141 2 : _trace(__FILE__,__LINE__,__DATE__,"",__func__);
142 : }
143 : END_TEST
144 : #endif /* NDEBUG */
145 :
146 : #ifndef NDEBUG
147 : /** Test _trace with NULL or empty input strings */
148 3 : START_TEST(assert_trace_emptyfunc) {
149 3 : forktest_only;
150 : #ifdef ENABLE_GCOV
151 : if(oomfill_enabled())
152 : __gcov_dump();
153 : #endif
154 : oomfill_fill(_i,2);
155 2 : _trace(__FILE__,__LINE__,__DATE__,__TIME__,"");
156 : }
157 : END_TEST
158 : #endif /* NDEBUG */
159 :
160 : #ifndef NDEBUG
161 3 : START_TEST(assert_trace_value) {
162 3 : char *szLongString =
163 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
164 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
165 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
166 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
167 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
168 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
169 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
170 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
171 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
172 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
173 : ;
174 : oomfill_fill(_i,2);
175 3 : _trace(szLongString,__LINE__,__DATE__,__TIME__,__func__);
176 : oomfill_free();
177 : oomfill_fill(_i,2);
178 3 : _trace(__FILE__,__LINE__,szLongString,__TIME__,__func__);
179 : oomfill_free();
180 : oomfill_fill(_i,2);
181 3 : _trace(__FILE__,__LINE__,__DATE__,szLongString,__func__);
182 : oomfill_free();
183 : oomfill_fill(_i,2);
184 3 : _trace(__FILE__,__LINE__,__DATE__,__TIME__,szLongString);
185 : oomfill_free();
186 3 : }
187 : END_TEST
188 : #endif /* NDEBUG */
189 :
190 :
191 :
192 : #ifndef NDEBUG
193 : /** Test _trace_msg with NULL or empty input strings */
194 3 : START_TEST(assert_tracemsg_nullfile) {
195 : /* The function does not return anything or change any value, I can not
196 : * check if it worked. I can only expect it to work or to SIGSEV the process */
197 3 : forktest_only;
198 : #ifdef ENABLE_GCOV
199 : if(oomfill_enabled())
200 : __gcov_dump();
201 : #endif
202 : oomfill_fill(_i,2);
203 2 : _trace_msg(NULL,__LINE__,__DATE__,__TIME__,__func__,"message");
204 : }
205 : END_TEST
206 : #endif /* NDEBUG */
207 :
208 : #ifndef NDEBUG
209 : /** Test _trace_msg with NULL or empty input strings */
210 3 : START_TEST(assert_tracemsg_nullline) {
211 3 : forktest_only;
212 : #ifdef ENABLE_GCOV
213 : if(oomfill_enabled())
214 : __gcov_dump();
215 : #endif
216 : oomfill_fill(_i,2);
217 2 : _trace_msg(__FILE__,0,__DATE__,__TIME__,__func__,"message");
218 : }
219 : END_TEST
220 : #endif /* NDEBUG */
221 :
222 : #ifndef NDEBUG
223 : /** Test _trace_msg with NULL or empty input strings */
224 3 : START_TEST(assert_tracemsg_nulldate) {
225 3 : forktest_only;
226 : #ifdef ENABLE_GCOV
227 : if(oomfill_enabled())
228 : __gcov_dump();
229 : #endif
230 : oomfill_fill(_i,2);
231 2 : _trace_msg(__FILE__,__LINE__,NULL,__TIME__,__func__,"message");
232 : }
233 : END_TEST
234 : #endif /* NDEBUG */
235 :
236 : #ifndef NDEBUG
237 : /** Test _trace_msg with NULL or empty input strings */
238 3 : START_TEST(assert_tracemsg_nulltime) {
239 3 : forktest_only;
240 : #ifdef ENABLE_GCOV
241 : if(oomfill_enabled())
242 : __gcov_dump();
243 : #endif
244 : oomfill_fill(_i,2);
245 2 : _trace_msg(__FILE__,__LINE__,__DATE__,NULL,__func__,"message");
246 : }
247 : END_TEST
248 : #endif /* NDEBUG */
249 :
250 : #ifndef NDEBUG
251 : /** Test _trace_msg with NULL or empty input strings */
252 3 : START_TEST(assert_tracemsg_nullfunc) {
253 3 : forktest_only;
254 : #ifdef ENABLE_GCOV
255 : if(oomfill_enabled())
256 : __gcov_dump();
257 : #endif
258 : oomfill_fill(_i,2);
259 2 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,NULL,"message");
260 : }
261 : END_TEST
262 : #endif /* NDEBUG */
263 :
264 : #ifndef NDEBUG
265 : /** Test _trace_msg with NULL or empty input strings */
266 3 : START_TEST(assert_tracemsg_nullmsg) {
267 3 : forktest_only;
268 : #ifdef ENABLE_GCOV
269 : if(oomfill_enabled())
270 : __gcov_dump();
271 : #endif
272 : oomfill_fill(_i,2);
273 2 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,NULL,NULL);
274 : }
275 : END_TEST
276 : #endif /* NDEBUG */
277 :
278 : #ifndef NDEBUG
279 : /** Test _trace_msg with NULL or empty input strings */
280 3 : START_TEST(assert_tracemsg_emptyfile) {
281 3 : forktest_only;
282 : #ifdef ENABLE_GCOV
283 : if(oomfill_enabled())
284 : __gcov_dump();
285 : #endif
286 : oomfill_fill(_i,2);
287 2 : _trace_msg("",__LINE__,__DATE__,__TIME__,__func__,"message");
288 : }
289 : END_TEST
290 : #endif /* NDEBUG */
291 :
292 : #ifndef NDEBUG
293 : /** Test _trace_msg with NULL or empty input strings */
294 3 : START_TEST(assert_tracemsg_emptydate) {
295 3 : forktest_only;
296 : #ifdef ENABLE_GCOV
297 : if(oomfill_enabled())
298 : __gcov_dump();
299 : #endif
300 : oomfill_fill(_i,2);
301 2 : _trace_msg(__FILE__,__LINE__,"",__TIME__,__func__,"message");
302 : }
303 : END_TEST
304 : #endif /* NDEBUG */
305 :
306 : #ifndef NDEBUG
307 : /** Test _trace_msg with NULL or empty input strings */
308 3 : START_TEST(assert_tracemsg_emptytime) {
309 3 : forktest_only;
310 : #ifdef ENABLE_GCOV
311 : if(oomfill_enabled())
312 : __gcov_dump();
313 : #endif
314 : oomfill_fill(_i,2);
315 2 : _trace_msg(__FILE__,__LINE__,__DATE__,"",__func__,"message");
316 : }
317 : END_TEST
318 : #endif /* NDEBUG */
319 :
320 : #ifndef NDEBUG
321 : /** Test _trace_msg with NULL or empty input strings */
322 3 : START_TEST(assert_tracemsg_emptyfunc) {
323 3 : forktest_only;
324 : #ifdef ENABLE_GCOV
325 : if(oomfill_enabled())
326 : __gcov_dump();
327 : #endif
328 : oomfill_fill(_i,2);
329 2 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,"","message");
330 : }
331 : END_TEST
332 : #endif /* NDEBUG */
333 :
334 : #ifndef NDEBUG
335 : /** Test _trace_msg with NULL or empty input strings */
336 3 : START_TEST(assert_tracemsg_emptymsg) {
337 : #ifdef ENABLE_GCOV
338 : if(oomfill_enabled())
339 : __gcov_dump();
340 : #endif
341 : oomfill_fill(_i,2);
342 3 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,"");
343 : oomfill_free();
344 3 : }
345 : END_TEST
346 : #endif /* NDEBUG */
347 :
348 : #ifndef NDEBUG
349 3 : START_TEST(assert_tracemsg_value) {
350 3 : char *szLongString =
351 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
352 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
353 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
354 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
355 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
356 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
357 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
358 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
359 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
360 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
361 : ;
362 : oomfill_fill(_i,2);
363 3 : _trace_msg(szLongString,__LINE__,__DATE__,__TIME__,__func__,"message");
364 : oomfill_free();
365 : oomfill_fill(_i,2);
366 3 : _trace_msg(__FILE__,__LINE__,szLongString,__TIME__,__func__,"message");
367 : oomfill_free();
368 : oomfill_fill(_i,2);
369 3 : _trace_msg(__FILE__,__LINE__,__DATE__,szLongString,__func__,"message");
370 : oomfill_free();
371 : oomfill_fill(_i,2);
372 3 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,szLongString,"message");
373 : oomfill_free();
374 : oomfill_fill(_i,2);
375 3 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString);
376 : oomfill_free();
377 3 : }
378 : END_TEST
379 : #endif /* NDEBUG */
380 :
381 :
382 :
383 : #ifndef NDEBUG
384 : /** Test _trace_dynmsg with NULL or empty input strings */
385 3 : START_TEST(assert_tracedynmsg_nullfile) {
386 : /* The function does not return anything or change any value, I can not
387 : * check if it worked. I can only expect it to work or to SIGSEV the process */
388 3 : forktest_only;
389 : #ifdef ENABLE_GCOV
390 : if(oomfill_enabled())
391 : __gcov_dump();
392 : #endif
393 : oomfill_fill(_i,2);
394 2 : _trace_dynmsg(NULL,__LINE__,__DATE__,__TIME__,__func__,"message");
395 : }
396 : END_TEST
397 : #endif /* NDEBUG */
398 :
399 : #ifndef NDEBUG
400 : /** Test _trace_dynmsg with NULL or empty input strings */
401 3 : START_TEST(assert_tracedynmsg_nullline) {
402 3 : forktest_only;
403 : #ifdef ENABLE_GCOV
404 : if(oomfill_enabled())
405 : __gcov_dump();
406 : #endif
407 : oomfill_fill(_i,2);
408 2 : _trace_dynmsg(__FILE__,0,__DATE__,__TIME__,__func__,"message");
409 : }
410 : END_TEST
411 : #endif /* NDEBUG */
412 :
413 : #ifndef NDEBUG
414 : /** Test _trace_dynmsg with NULL or empty input strings */
415 3 : START_TEST(assert_tracedynmsg_nulldate) {
416 3 : forktest_only;
417 : #ifdef ENABLE_GCOV
418 : if(oomfill_enabled())
419 : __gcov_dump();
420 : #endif
421 : oomfill_fill(_i,2);
422 2 : _trace_dynmsg(__FILE__,__LINE__,NULL,__TIME__,__func__,"message");
423 : }
424 : END_TEST
425 : #endif /* NDEBUG */
426 :
427 : #ifndef NDEBUG
428 : /** Test _trace_dynmsg with NULL or empty input strings */
429 3 : START_TEST(assert_tracedynmsg_nulltime) {
430 3 : forktest_only;
431 : #ifdef ENABLE_GCOV
432 : if(oomfill_enabled())
433 : __gcov_dump();
434 : #endif
435 : oomfill_fill(_i,2);
436 2 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,NULL,__func__,"message");
437 : }
438 : END_TEST
439 : #endif /* NDEBUG */
440 :
441 : #ifndef NDEBUG
442 : /** Test _trace_dynmsg with NULL or empty input strings */
443 3 : START_TEST(assert_tracedynmsg_nullfunc) {
444 3 : forktest_only;
445 : #ifdef ENABLE_GCOV
446 : if(oomfill_enabled())
447 : __gcov_dump();
448 : #endif
449 : oomfill_fill(_i,2);
450 2 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,NULL,"message");
451 : }
452 : END_TEST
453 : #endif /* NDEBUG */
454 :
455 : #ifndef NDEBUG
456 : /** Test _trace_dynmsg with NULL or empty input strings */
457 3 : START_TEST(assert_tracedynmsg_nullmsg) {
458 3 : forktest_only;
459 : #ifdef ENABLE_GCOV
460 : if(oomfill_enabled())
461 : __gcov_dump();
462 : #endif
463 : oomfill_fill(_i,2);
464 2 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,NULL,NULL);
465 : }
466 : END_TEST
467 : #endif /* NDEBUG */
468 :
469 : #ifndef NDEBUG
470 : /** Test _trace_dynmsg with NULL or empty input strings */
471 3 : START_TEST(assert_tracedynmsg_emptyfile) {
472 3 : forktest_only;
473 : #ifdef ENABLE_GCOV
474 : if(oomfill_enabled())
475 : __gcov_dump();
476 : #endif
477 : oomfill_fill(_i,2);
478 2 : _trace_dynmsg("",__LINE__,__DATE__,__TIME__,__func__,"message");
479 : }
480 : END_TEST
481 : #endif /* NDEBUG */
482 :
483 : #ifndef NDEBUG
484 : /** Test _trace_dynmsg with NULL or empty input strings */
485 3 : START_TEST(assert_tracedynmsg_emptydate) {
486 3 : forktest_only;
487 : #ifdef ENABLE_GCOV
488 : if(oomfill_enabled())
489 : __gcov_dump();
490 : #endif
491 : oomfill_fill(_i,2);
492 2 : _trace_dynmsg(__FILE__,__LINE__,"",__TIME__,__func__,"message");
493 : }
494 : END_TEST
495 : #endif /* NDEBUG */
496 :
497 : #ifndef NDEBUG
498 : /** Test _trace_dynmsg with NULL or empty input strings */
499 3 : START_TEST(assert_tracedynmsg_emptytime) {
500 3 : forktest_only;
501 : #ifdef ENABLE_GCOV
502 : if(oomfill_enabled())
503 : __gcov_dump();
504 : #endif
505 : oomfill_fill(_i,2);
506 2 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,"",__func__,"message");
507 : }
508 : END_TEST
509 : #endif /* NDEBUG */
510 :
511 : #ifndef NDEBUG
512 : /** Test _trace_dynmsg with NULL or empty input strings */
513 3 : START_TEST(assert_tracedynmsg_emptyfunc) {
514 3 : forktest_only;
515 : #ifdef ENABLE_GCOV
516 : if(oomfill_enabled())
517 : __gcov_dump();
518 : #endif
519 : oomfill_fill(_i,2);
520 2 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,"","message");
521 : }
522 : END_TEST
523 : #endif /* NDEBUG */
524 :
525 : #ifndef NDEBUG
526 : /** Test _trace_dynmsg with NULL or empty input strings */
527 3 : START_TEST(assert_tracedynmsg_emptymsg) {
528 3 : forktest_only;
529 : #ifdef ENABLE_GCOV
530 : if(oomfill_enabled())
531 : __gcov_dump();
532 : #endif
533 : oomfill_fill(_i,2);
534 2 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,"");
535 : oomfill_free();
536 : }
537 : END_TEST
538 : #endif /* NDEBUG */
539 :
540 : #ifndef NDEBUG
541 3 : START_TEST(assert_tracedynmsg_value) {
542 3 : char *szLongString =
543 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
544 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
545 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
546 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
547 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
548 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
549 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
550 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
551 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
552 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
553 : ;
554 3 : char *szParamLongString =
555 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
556 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
557 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
558 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
559 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
560 : "%d"
561 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
562 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
563 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
564 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
565 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
566 : ;
567 : oomfill_fill(_i,2);
568 3 : _trace_dynmsg(szLongString,__LINE__,__DATE__,__TIME__,__func__,"message");
569 : oomfill_free();
570 : oomfill_fill(_i,2);
571 3 : _trace_dynmsg(__FILE__,__LINE__,szLongString,__TIME__,__func__,"message");
572 : oomfill_free();
573 : oomfill_fill(_i,2);
574 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,szLongString,__func__,"message");
575 : oomfill_free();
576 : oomfill_fill(_i,2);
577 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,szLongString,"message");
578 : oomfill_free();
579 : oomfill_fill(_i,2);
580 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString);
581 : oomfill_free();
582 : oomfill_fill(_i,2);
583 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,NULL); /* cppcheck-suppress varFuncNullUB */
584 : oomfill_free();
585 : oomfill_fill(_i,2);
586 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,"");
587 : oomfill_free();
588 : oomfill_fill(_i,2);
589 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,"abc");
590 : oomfill_free();
591 : oomfill_fill(_i,2);
592 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,123);
593 : oomfill_free();
594 : oomfill_fill(_i,2);
595 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString);
596 : oomfill_free();
597 : oomfill_fill(_i,2);
598 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,NULL); /* cppcheck-suppress varFuncNullUB */
599 : oomfill_free();
600 : oomfill_fill(_i,2);
601 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,"");
602 : oomfill_free();
603 : oomfill_fill(_i,2);
604 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,"abc");
605 : oomfill_free();
606 : oomfill_fill(_i,2);
607 3 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,123);
608 : oomfill_free();
609 3 : }
610 : END_TEST
611 : #endif /* NDEBUG */
612 :
613 3 : START_TEST(assert_assert_true) {
614 : oomfill_fill(_i,2);
615 : ASSERT(1);
616 : oomfill_free();
617 3 : }
618 : END_TEST
619 :
620 3 : START_TEST(assert_assert_false) {
621 3 : forktest_only;
622 : #ifdef ENABLE_GCOV
623 : if(oomfill_enabled())
624 : __gcov_dump();
625 : #endif
626 : oomfill_fill(_i,2);
627 2 : ASSERT(0);
628 : oomfill_free();
629 : }
630 : END_TEST
631 :
632 3 : START_TEST(assert_dbgtrace) {
633 : oomfill_fill(_i,2);
634 3 : DBG_TRACE;
635 : oomfill_free();
636 3 : }
637 : END_TEST
638 :
639 3 : START_TEST(assert_dbgmsg_null) {
640 : oomfill_fill(_i,2);
641 3 : DBG_MSG(NULL);
642 : oomfill_free();
643 3 : }
644 : END_TEST
645 :
646 3 : START_TEST(assert_dbgmsg_empty) {
647 : oomfill_fill(_i,2);
648 3 : DBG_MSG("");
649 : oomfill_free();
650 3 : }
651 : END_TEST
652 :
653 3 : START_TEST(assert_dbgmsg_szlong) {
654 3 : char *szLongString =
655 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
656 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
657 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
658 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
659 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
660 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
661 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
662 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
663 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
664 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
665 : ;
666 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
667 : oomfill_fill(_i,2);
668 3 : DBG_MSG(szLongString);
669 : oomfill_free();
670 3 : }
671 : END_TEST
672 :
673 3 : START_TEST(assert_dbgitrace_inst) {
674 : unsigned int result;
675 3 : result=0;
676 : oomfill_fill(_i,2);
677 3 : DBG_ITRACE(result=1);
678 : oomfill_free();
679 3 : ck_assert(1==result);
680 3 : }
681 : END_TEST
682 :
683 3 : START_TEST(assert_dbgprintf_null_null) {
684 : oomfill_fill(_i,2);
685 3 : DBG_PRINTF(NULL,NULL); /* cppcheck-suppress varFuncNullUB */
686 : oomfill_free();
687 3 : }
688 : END_TEST
689 :
690 3 : START_TEST(assert_dbgprintf_null_empty) {
691 : oomfill_fill(_i,2);
692 3 : DBG_PRINTF(NULL,"");
693 : oomfill_free();
694 3 : }
695 : END_TEST
696 :
697 3 : START_TEST(assert_dbgprintf_null_szlong) {
698 3 : char *szLongString =
699 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
700 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
701 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
702 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
703 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
704 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
705 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
706 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
707 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
708 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
709 : ;
710 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
711 : oomfill_fill(_i,2);
712 3 : DBG_PRINTF(NULL,szLongString);
713 : oomfill_free();
714 3 : }
715 : END_TEST
716 :
717 3 : START_TEST(assert_dbgprintf_null_123) {
718 : oomfill_fill(_i,2);
719 3 : DBG_PRINTF(NULL,123);
720 : oomfill_free();
721 3 : }
722 : END_TEST
723 :
724 3 : START_TEST(assert_dbgprintf_empty_null) {
725 : oomfill_fill(_i,2);
726 3 : DBG_PRINTF("",NULL); /* cppcheck-suppress varFuncNullUB */
727 : oomfill_free();
728 3 : }
729 : END_TEST
730 :
731 3 : START_TEST(assert_dbgprintf_empty_empty) {
732 : oomfill_fill(_i,2);
733 3 : DBG_PRINTF("","");
734 : oomfill_free();
735 3 : }
736 : END_TEST
737 :
738 3 : START_TEST(assert_dbgprintf_empty_szlong) {
739 3 : char *szLongString =
740 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
741 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
742 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
743 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
744 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
745 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
746 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
747 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
748 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
749 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
750 : ;
751 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
752 : oomfill_fill(_i,2);
753 3 : DBG_PRINTF("",szLongString);
754 : oomfill_free();
755 3 : }
756 : END_TEST
757 :
758 3 : START_TEST(assert_dbgprintf_empty_123) {
759 : oomfill_fill(_i,2);
760 3 : DBG_PRINTF("",123);
761 : oomfill_free();
762 3 : }
763 : END_TEST
764 :
765 3 : START_TEST(assert_dbgprintf_szlong_null) {
766 3 : char *szLongString =
767 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
768 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
769 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
770 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
771 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
772 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
773 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
774 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
775 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
776 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
777 : ;
778 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
779 : oomfill_fill(_i,2);
780 3 : DBG_PRINTF(szLongString,NULL); /* cppcheck-suppress varFuncNullUB */
781 : oomfill_free();
782 3 : }
783 : END_TEST
784 :
785 3 : START_TEST(assert_dbgprintf_szlong_empty) {
786 3 : char *szLongString =
787 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
788 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
789 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
790 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
791 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
792 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
793 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
794 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
795 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
796 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
797 : ;
798 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
799 : oomfill_fill(_i,2);
800 3 : DBG_PRINTF(szLongString,"");
801 : oomfill_free();
802 3 : }
803 : END_TEST
804 :
805 3 : START_TEST(assert_dbgprintf_szlong_szlong) {
806 3 : char *szLongString =
807 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
808 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
809 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
810 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
811 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
812 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
813 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
814 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
815 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
816 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
817 : ;
818 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
819 : oomfill_fill(_i,2);
820 3 : DBG_PRINTF(szLongString,szLongString);
821 : oomfill_free();
822 3 : }
823 : END_TEST
824 :
825 3 : START_TEST(assert_dbgprintf_szlong_123) {
826 3 : char *szLongString =
827 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
828 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
829 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
830 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
831 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
832 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
833 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
834 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
835 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
836 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
837 : ;
838 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
839 : oomfill_fill(_i,2);
840 3 : DBG_PRINTF(szLongString,123);
841 : oomfill_free();
842 3 : }
843 : END_TEST
844 :
845 3 : START_TEST(assert_dbgprintf_szparamlong_null) {
846 3 : char *szParamLongString =
847 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
848 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
849 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
850 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
851 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
852 : "%d"
853 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
854 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
855 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
856 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
857 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
858 : ;
859 : (void)szParamLongString; /* Avoid error/warning when NDEBUG voids macro to test */
860 : oomfill_fill(_i,2);
861 3 : DBG_PRINTF(szParamLongString,NULL); /* cppcheck-suppress varFuncNullUB */
862 : oomfill_free();
863 3 : }
864 : END_TEST
865 :
866 3 : START_TEST(assert_dbgprintf_szparamlong_empty) {
867 3 : char *szParamLongString =
868 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
869 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
870 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
871 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
872 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
873 : "%d"
874 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
875 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
876 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
877 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
878 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
879 : ;
880 : (void)szParamLongString; /* Avoid error/warning when NDEBUG voids macro to test */
881 : oomfill_fill(_i,2);
882 3 : DBG_PRINTF(szParamLongString,"");
883 : oomfill_free();
884 3 : }
885 : END_TEST
886 :
887 3 : START_TEST(assert_dbgprintf_szparamlong_szlong) {
888 3 : char *szParamLongString =
889 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
890 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
891 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
892 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
893 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
894 : "%d"
895 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
896 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
897 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
898 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
899 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
900 : ;
901 3 : char *szLongString =
902 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
903 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
904 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
905 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
906 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
907 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
908 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
909 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
910 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
911 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
912 : ;
913 : (void)szParamLongString; /* Avoid error/warning when NDEBUG voids macro to test */
914 : (void)szLongString; /* Avoid error/warning when NDEBUG voids macro to test */
915 : oomfill_fill(_i,2);
916 3 : DBG_PRINTF(szParamLongString,szLongString);
917 : oomfill_free();
918 3 : }
919 : END_TEST
920 :
921 3 : START_TEST(assert_dbgprintf_szparamlong_123) {
922 3 : char *szParamLongString =
923 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
924 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
925 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
926 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
927 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
928 : "%d"
929 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
930 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
931 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
932 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
933 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
934 : ;
935 : (void)szParamLongString; /* Avoid error/warning when NDEBUG voids macro to test */
936 : oomfill_fill(_i,2);
937 3 : DBG_PRINTF(szParamLongString,123);
938 : oomfill_free();
939 3 : }
940 : END_TEST
941 :
942 : /************************************************************************/
943 171 : void assert_checked_uninitialized_setup() {
944 171 : signals_catch();
945 171 : forktest_gprofdir();
946 171 : }
947 111 : void assert_checked_common_teardown() {
948 111 : signals_release();
949 : #ifndef NDEBUG
950 111 : ck_assert(0==memtrack_getallocatedblocks());
951 : #endif /* NDEBUG */
952 111 : }
953 : /************************************************************************/
954 117 : void assert_unchecked_common_setup() {
955 117 : forktest_init();
956 117 : }
957 3 : void assert_unchecked_common_teardown() {
958 3 : }
959 : #ifdef HAVE_LIBOOM
960 : void assert_unchecked_oom_setup() {
961 : oomfill_enable(RAMLIMIT_SOFT);
962 : assert_unchecked_common_setup();
963 : }
964 : void assert_unchecked_oom_teardown() {
965 : oomfill_disable();
966 : assert_unchecked_common_teardown();
967 : }
968 : #endif /* HAVE_LIBOOM */
969 :
970 : /************************************************************************/
971 365 : Suite* libdebug_assert_suite() {
972 : Suite *s;
973 : TCase *tc;
974 :
975 365 : s = suite_create("LibDebug-Assert");
976 365 : tc = tcase_create("Uninitialized");
977 365 : tcase_add_checked_fixture(tc, assert_checked_uninitialized_setup, assert_checked_common_teardown);
978 365 : tcase_add_unchecked_fixture(tc, assert_unchecked_common_setup, assert_unchecked_common_teardown);
979 365 : suite_add_tcase(s, tc);
980 : #ifndef NDEBUG
981 365 : tcase_add_test_raise_signal(tc, assert_trace_nullfile,6);
982 365 : tcase_add_test_raise_signal(tc, assert_trace_nullline,6);
983 365 : tcase_add_test_raise_signal(tc, assert_trace_nulldate,6);
984 365 : tcase_add_test_raise_signal(tc, assert_trace_nulltime,6);
985 365 : tcase_add_test_raise_signal(tc, assert_trace_nullfunc,6);
986 365 : tcase_add_test_raise_signal(tc, assert_trace_emptyfile,6);
987 365 : tcase_add_test_raise_signal(tc, assert_trace_emptydate,6);
988 365 : tcase_add_test_raise_signal(tc, assert_trace_emptytime,6);
989 365 : tcase_add_test_raise_signal(tc, assert_trace_emptyfunc,6);
990 365 : tcase_add_test(tc, assert_trace_value);
991 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullfile,6);
992 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullline,6);
993 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_nulldate,6);
994 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_nulltime,6);
995 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullfunc,6);
996 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullmsg,6);
997 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptyfile,6);
998 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptydate,6);
999 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptytime,6);
1000 365 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptyfunc,6);
1001 365 : tcase_add_test(tc, assert_tracemsg_emptymsg);
1002 365 : tcase_add_test(tc, assert_tracemsg_value);
1003 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullfile,6);
1004 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullline,6);
1005 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nulldate,6);
1006 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nulltime,6);
1007 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullfunc,6);
1008 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullmsg,6);
1009 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptyfile,6);
1010 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptydate,6);
1011 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptytime,6);
1012 365 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptyfunc,6);
1013 365 : tcase_add_test(tc, assert_tracedynmsg_emptymsg);
1014 365 : tcase_add_test(tc, assert_tracedynmsg_value);
1015 365 : tcase_add_test_raise_signal(tc, assert_assert_false,6);
1016 : #else
1017 : tcase_add_test(tc, assert_assert_false);
1018 : #endif /* NDEBUG */
1019 365 : tcase_add_test(tc, assert_assert_true);
1020 365 : tcase_add_test(tc, assert_dbgtrace);
1021 365 : tcase_add_test(tc, assert_dbgmsg_null);
1022 365 : tcase_add_test(tc, assert_dbgmsg_empty);
1023 365 : tcase_add_test(tc, assert_dbgmsg_szlong);
1024 365 : tcase_add_test(tc, assert_dbgitrace_inst);
1025 365 : tcase_add_test(tc, assert_dbgprintf_null_null);
1026 365 : tcase_add_test(tc, assert_dbgprintf_null_empty);
1027 365 : tcase_add_test(tc, assert_dbgprintf_null_szlong);
1028 365 : tcase_add_test(tc, assert_dbgprintf_null_123);
1029 365 : tcase_add_test(tc, assert_dbgprintf_empty_null);
1030 365 : tcase_add_test(tc, assert_dbgprintf_empty_empty);
1031 365 : tcase_add_test(tc, assert_dbgprintf_empty_szlong);
1032 365 : tcase_add_test(tc, assert_dbgprintf_empty_123);
1033 365 : tcase_add_test(tc, assert_dbgprintf_szlong_null);
1034 365 : tcase_add_test(tc, assert_dbgprintf_szlong_empty);
1035 365 : tcase_add_test(tc, assert_dbgprintf_szlong_szlong);
1036 365 : tcase_add_test(tc, assert_dbgprintf_szlong_123);
1037 365 : tcase_add_test(tc, assert_dbgprintf_szparamlong_null);
1038 365 : tcase_add_test(tc, assert_dbgprintf_szparamlong_empty);
1039 365 : tcase_add_test(tc, assert_dbgprintf_szparamlong_szlong);
1040 365 : tcase_add_test(tc, assert_dbgprintf_szparamlong_123);
1041 :
1042 : #ifdef HAVE_LIBOOM
1043 : tc = tcase_create("Uninitialized-OOM");
1044 : tcase_set_tags(tc,"oom");
1045 : tcase_add_checked_fixture(tc, assert_checked_uninitialized_setup, assert_checked_common_teardown);
1046 : tcase_add_unchecked_fixture(tc, assert_unchecked_oom_setup, assert_unchecked_oom_teardown);
1047 : suite_add_tcase(s, tc);
1048 : #ifndef NDEBUG
1049 : tcase_add_loop_test_raise_signal(tc, assert_trace_nullfile,6, 0, 10);
1050 : tcase_add_loop_test_raise_signal(tc, assert_trace_nullline,6, 0, 10);
1051 : tcase_add_loop_test_raise_signal(tc, assert_trace_nulldate,6, 0, 10);
1052 : tcase_add_loop_test_raise_signal(tc, assert_trace_nulltime,6, 0, 10);
1053 : tcase_add_loop_test_raise_signal(tc, assert_trace_nullfunc,6, 0, 10);
1054 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptyfile,6, 0, 10);
1055 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptydate,6, 0, 10);
1056 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptytime,6, 0, 10);
1057 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptyfunc,6, 0, 10);
1058 : tcase_add_loop_test(tc, assert_trace_value, 0, 10);
1059 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullfile,6, 0, 10);
1060 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullline,6, 0, 10);
1061 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nulldate,6, 0, 10);
1062 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nulltime,6, 0, 10);
1063 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullfunc,6, 0, 10);
1064 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullmsg,6, 0, 10);
1065 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptyfile,6, 0, 10);
1066 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptydate,6, 0, 10);
1067 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptytime,6, 0, 10);
1068 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptyfunc,6, 0, 10);
1069 : tcase_add_loop_test(tc, assert_tracemsg_emptymsg, 0, 10);
1070 : tcase_add_loop_test(tc, assert_tracemsg_value, 0, 10);
1071 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullfile,6, 0, 10);
1072 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullline,6, 0, 10);
1073 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nulldate,6, 0, 10);
1074 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nulltime,6, 0, 10);
1075 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullfunc,6, 0, 10);
1076 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullmsg,6, 0, 10);
1077 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptyfile,6, 0, 10);
1078 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptydate,6, 0, 10);
1079 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptytime,6, 0, 10);
1080 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptyfunc,6, 0, 10);
1081 : tcase_add_loop_test(tc, assert_tracedynmsg_emptymsg, 0, 10);
1082 : tcase_add_loop_test(tc, assert_tracedynmsg_value, 0, 10);
1083 : tcase_add_loop_test_raise_signal(tc, assert_assert_false,6, 0, 10);
1084 : #else
1085 : tcase_add_loop_test(tc, assert_assert_false, 0, 10);
1086 : #endif /* NDEBUG */
1087 : tcase_add_loop_test(tc, assert_assert_true, 0, 10);
1088 : tcase_add_loop_test(tc, assert_dbgtrace, 0, 10);
1089 : tcase_add_loop_test(tc, assert_dbgmsg_null, 0, 10);
1090 : tcase_add_loop_test(tc, assert_dbgmsg_empty, 0, 10);
1091 : tcase_add_loop_test(tc, assert_dbgmsg_szlong, 0, 10);
1092 : tcase_add_loop_test(tc, assert_dbgitrace_inst, 0, 10);
1093 : tcase_add_loop_test(tc, assert_dbgprintf_null_null, 0, 10);
1094 : tcase_add_loop_test(tc, assert_dbgprintf_null_empty, 0, 10);
1095 : tcase_add_loop_test(tc, assert_dbgprintf_null_szlong, 0, 10);
1096 : tcase_add_loop_test(tc, assert_dbgprintf_null_123, 0, 10);
1097 : tcase_add_loop_test(tc, assert_dbgprintf_empty_null, 0, 10);
1098 : tcase_add_loop_test(tc, assert_dbgprintf_empty_empty, 0, 10);
1099 : tcase_add_loop_test(tc, assert_dbgprintf_empty_szlong, 0, 10);
1100 : tcase_add_loop_test(tc, assert_dbgprintf_empty_123, 0, 10);
1101 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_null, 0, 10);
1102 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_empty, 0, 10);
1103 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_szlong, 0, 10);
1104 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_123, 0, 10);
1105 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_null, 0, 10);
1106 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_empty, 0, 10);
1107 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_szlong, 0, 10);
1108 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_123, 0, 10);
1109 : #endif /* HAVE_LIBOOM */
1110 :
1111 365 : return s;
1112 : }
1113 :
1114 : /* vim: set tw=80: */
|
