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