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 "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 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 33 : forktest_only;
38 : #ifdef GCOV
39 22 : if(oomtest_enabled())
40 20 : __gcov_dump();
41 : #endif
42 2 : oomtest_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 33 : START_TEST(assert_trace_nullline)
51 : {
52 33 : forktest_only;
53 : #ifdef GCOV
54 22 : if(oomtest_enabled())
55 20 : __gcov_dump();
56 : #endif
57 2 : oomtest_fill(_i,2);
58 2 : _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 33 : START_TEST(assert_trace_nulldate)
66 : {
67 33 : forktest_only;
68 : #ifdef GCOV
69 22 : if(oomtest_enabled())
70 20 : __gcov_dump();
71 : #endif
72 2 : oomtest_fill(_i,2);
73 2 : _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 33 : START_TEST(assert_trace_nulltime)
81 : {
82 33 : forktest_only;
83 : #ifdef GCOV
84 22 : if(oomtest_enabled())
85 20 : __gcov_dump();
86 : #endif
87 2 : oomtest_fill(_i,2);
88 2 : _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 33 : START_TEST(assert_trace_nullfunc)
96 : {
97 33 : forktest_only;
98 : #ifdef GCOV
99 22 : if(oomtest_enabled())
100 20 : __gcov_dump();
101 : #endif
102 2 : oomtest_fill(_i,2);
103 2 : _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 33 : START_TEST(assert_trace_emptyfile)
111 : {
112 33 : forktest_only;
113 : #ifdef GCOV
114 22 : if(oomtest_enabled())
115 20 : __gcov_dump();
116 : #endif
117 2 : oomtest_fill(_i,2);
118 2 : _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 33 : START_TEST(assert_trace_emptydate)
126 : {
127 33 : forktest_only;
128 : #ifdef GCOV
129 22 : if(oomtest_enabled())
130 20 : __gcov_dump();
131 : #endif
132 2 : oomtest_fill(_i,2);
133 2 : _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 33 : START_TEST(assert_trace_emptytime)
141 : {
142 33 : forktest_only;
143 : #ifdef GCOV
144 22 : if(oomtest_enabled())
145 20 : __gcov_dump();
146 : #endif
147 2 : oomtest_fill(_i,2);
148 2 : _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 33 : START_TEST(assert_trace_emptyfunc)
156 : {
157 33 : forktest_only;
158 : #ifdef GCOV
159 22 : if(oomtest_enabled())
160 20 : __gcov_dump();
161 : #endif
162 2 : oomtest_fill(_i,2);
163 2 : _trace(__FILE__,__LINE__,__DATE__,__TIME__,"");
164 : }
165 : END_TEST
166 : #endif /* NDEBUG */
167 :
168 : #ifndef NDEBUG
169 33 : START_TEST(assert_trace_value)
170 : {
171 33 : char *szLongString =
172 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
173 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
174 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
175 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
176 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
177 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
178 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
179 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
180 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
181 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
182 : ;
183 33 : oomtest_fill(_i,2);
184 33 : _trace(szLongString,__LINE__,__DATE__,__TIME__,__func__);
185 33 : oomtest_free();
186 33 : oomtest_fill(_i,2);
187 33 : _trace(__FILE__,__LINE__,szLongString,__TIME__,__func__);
188 33 : oomtest_free();
189 33 : oomtest_fill(_i,2);
190 33 : _trace(__FILE__,__LINE__,__DATE__,szLongString,__func__);
191 33 : oomtest_free();
192 33 : oomtest_fill(_i,2);
193 33 : _trace(__FILE__,__LINE__,__DATE__,__TIME__,szLongString);
194 33 : oomtest_free();
195 33 : }
196 : END_TEST
197 : #endif /* NDEBUG */
198 :
199 :
200 :
201 : #ifndef NDEBUG
202 : /** Test _trace_msg with NULL or empty input strings */
203 33 : 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 33 : forktest_only;
208 : #ifdef GCOV
209 22 : if(oomtest_enabled())
210 20 : __gcov_dump();
211 : #endif
212 2 : oomtest_fill(_i,2);
213 2 : _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 33 : START_TEST(assert_tracemsg_nullline)
221 : {
222 33 : forktest_only;
223 : #ifdef GCOV
224 22 : if(oomtest_enabled())
225 20 : __gcov_dump();
226 : #endif
227 2 : oomtest_fill(_i,2);
228 2 : _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 33 : START_TEST(assert_tracemsg_nulldate)
236 : {
237 33 : forktest_only;
238 : #ifdef GCOV
239 22 : if(oomtest_enabled())
240 20 : __gcov_dump();
241 : #endif
242 2 : oomtest_fill(_i,2);
243 2 : _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 33 : START_TEST(assert_tracemsg_nulltime)
251 : {
252 33 : forktest_only;
253 : #ifdef GCOV
254 22 : if(oomtest_enabled())
255 20 : __gcov_dump();
256 : #endif
257 2 : oomtest_fill(_i,2);
258 2 : _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 33 : START_TEST(assert_tracemsg_nullfunc)
266 : {
267 33 : forktest_only;
268 : #ifdef GCOV
269 22 : if(oomtest_enabled())
270 20 : __gcov_dump();
271 : #endif
272 2 : oomtest_fill(_i,2);
273 2 : _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 33 : START_TEST(assert_tracemsg_nullmsg)
281 : {
282 33 : forktest_only;
283 : #ifdef GCOV
284 22 : if(oomtest_enabled())
285 20 : __gcov_dump();
286 : #endif
287 2 : oomtest_fill(_i,2);
288 2 : _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 33 : START_TEST(assert_tracemsg_emptyfile)
296 : {
297 33 : forktest_only;
298 : #ifdef GCOV
299 22 : if(oomtest_enabled())
300 20 : __gcov_dump();
301 : #endif
302 2 : oomtest_fill(_i,2);
303 2 : _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 33 : START_TEST(assert_tracemsg_emptydate)
311 : {
312 33 : forktest_only;
313 : #ifdef GCOV
314 22 : if(oomtest_enabled())
315 20 : __gcov_dump();
316 : #endif
317 2 : oomtest_fill(_i,2);
318 2 : _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 33 : START_TEST(assert_tracemsg_emptytime)
326 : {
327 33 : forktest_only;
328 : #ifdef GCOV
329 22 : if(oomtest_enabled())
330 20 : __gcov_dump();
331 : #endif
332 2 : oomtest_fill(_i,2);
333 2 : _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 33 : START_TEST(assert_tracemsg_emptyfunc)
341 : {
342 33 : forktest_only;
343 : #ifdef GCOV
344 22 : if(oomtest_enabled())
345 20 : __gcov_dump();
346 : #endif
347 2 : oomtest_fill(_i,2);
348 2 : _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 24 : START_TEST(assert_tracemsg_emptymsg)
356 : {
357 : #ifdef GCOV
358 24 : if(oomtest_enabled())
359 21 : __gcov_dump();
360 : #endif
361 3 : oomtest_fill(_i,2);
362 3 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,"");
363 3 : oomtest_free();
364 3 : }
365 : END_TEST
366 : #endif /* NDEBUG */
367 :
368 : #ifndef NDEBUG
369 23 : START_TEST(assert_tracemsg_value)
370 : {
371 23 : char *szLongString =
372 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
373 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
374 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
375 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
376 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
377 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
378 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
379 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
380 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
381 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
382 : ;
383 23 : oomtest_fill(_i,2);
384 23 : _trace_msg(szLongString,__LINE__,__DATE__,__TIME__,__func__,"message");
385 23 : oomtest_free();
386 23 : oomtest_fill(_i,2);
387 23 : _trace_msg(__FILE__,__LINE__,szLongString,__TIME__,__func__,"message");
388 23 : oomtest_free();
389 23 : oomtest_fill(_i,2);
390 23 : _trace_msg(__FILE__,__LINE__,__DATE__,szLongString,__func__,"message");
391 23 : oomtest_free();
392 23 : oomtest_fill(_i,2);
393 23 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,szLongString,"message");
394 23 : oomtest_free();
395 23 : oomtest_fill(_i,2);
396 23 : _trace_msg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString);
397 23 : oomtest_free();
398 23 : }
399 : END_TEST
400 : #endif /* NDEBUG */
401 :
402 :
403 :
404 : #ifndef NDEBUG
405 : /** Test _trace_dynmsg with NULL or empty input strings */
406 23 : 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 23 : forktest_only;
411 : #ifdef GCOV
412 22 : if(oomtest_enabled())
413 20 : __gcov_dump();
414 : #endif
415 2 : oomtest_fill(_i,2);
416 2 : _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 23 : START_TEST(assert_tracedynmsg_nullline)
424 : {
425 23 : forktest_only;
426 : #ifdef GCOV
427 22 : if(oomtest_enabled())
428 20 : __gcov_dump();
429 : #endif
430 2 : oomtest_fill(_i,2);
431 2 : _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 23 : START_TEST(assert_tracedynmsg_nulldate)
439 : {
440 23 : forktest_only;
441 : #ifdef GCOV
442 22 : if(oomtest_enabled())
443 20 : __gcov_dump();
444 : #endif
445 2 : oomtest_fill(_i,2);
446 2 : _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 23 : START_TEST(assert_tracedynmsg_nulltime)
454 : {
455 23 : forktest_only;
456 : #ifdef GCOV
457 22 : if(oomtest_enabled())
458 20 : __gcov_dump();
459 : #endif
460 2 : oomtest_fill(_i,2);
461 2 : _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 23 : START_TEST(assert_tracedynmsg_nullfunc)
469 : {
470 23 : forktest_only;
471 : #ifdef GCOV
472 22 : if(oomtest_enabled())
473 20 : __gcov_dump();
474 : #endif
475 2 : oomtest_fill(_i,2);
476 2 : _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 23 : START_TEST(assert_tracedynmsg_nullmsg)
484 : {
485 23 : forktest_only;
486 : #ifdef GCOV
487 22 : if(oomtest_enabled())
488 20 : __gcov_dump();
489 : #endif
490 2 : oomtest_fill(_i,2);
491 2 : _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 23 : START_TEST(assert_tracedynmsg_emptyfile)
499 : {
500 23 : forktest_only;
501 : #ifdef GCOV
502 22 : if(oomtest_enabled())
503 20 : __gcov_dump();
504 : #endif
505 2 : oomtest_fill(_i,2);
506 2 : _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 23 : START_TEST(assert_tracedynmsg_emptydate)
514 : {
515 23 : forktest_only;
516 : #ifdef GCOV
517 22 : if(oomtest_enabled())
518 20 : __gcov_dump();
519 : #endif
520 2 : oomtest_fill(_i,2);
521 2 : _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 23 : START_TEST(assert_tracedynmsg_emptytime)
529 : {
530 23 : forktest_only;
531 : #ifdef GCOV
532 22 : if(oomtest_enabled())
533 20 : __gcov_dump();
534 : #endif
535 2 : oomtest_fill(_i,2);
536 2 : _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 23 : START_TEST(assert_tracedynmsg_emptyfunc)
544 : {
545 23 : forktest_only;
546 : #ifdef GCOV
547 22 : if(oomtest_enabled())
548 20 : __gcov_dump();
549 : #endif
550 2 : oomtest_fill(_i,2);
551 2 : _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 23 : START_TEST(assert_tracedynmsg_emptymsg)
559 : {
560 23 : forktest_only;
561 : #ifdef GCOV
562 22 : if(oomtest_enabled())
563 20 : __gcov_dump();
564 : #endif
565 2 : oomtest_fill(_i,2);
566 2 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,"");
567 2 : oomtest_free();
568 : }
569 : END_TEST
570 : #endif /* NDEBUG */
571 :
572 : #ifndef NDEBUG
573 23 : START_TEST(assert_tracedynmsg_value)
574 : {
575 23 : char *szLongString =
576 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
577 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
578 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
579 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
580 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
581 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
582 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
583 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
584 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
585 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
586 : ;
587 23 : 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 23 : oomtest_fill(_i,2);
601 23 : _trace_dynmsg(szLongString,__LINE__,__DATE__,__TIME__,__func__,"message");
602 23 : oomtest_free();
603 23 : oomtest_fill(_i,2);
604 23 : _trace_dynmsg(__FILE__,__LINE__,szLongString,__TIME__,__func__,"message");
605 23 : oomtest_free();
606 23 : oomtest_fill(_i,2);
607 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,szLongString,__func__,"message");
608 23 : oomtest_free();
609 23 : oomtest_fill(_i,2);
610 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,szLongString,"message");
611 23 : oomtest_free();
612 23 : oomtest_fill(_i,2);
613 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString);
614 23 : oomtest_free();
615 23 : oomtest_fill(_i,2);
616 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,NULL);
617 23 : oomtest_free();
618 23 : oomtest_fill(_i,2);
619 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,"");
620 23 : oomtest_free();
621 23 : oomtest_fill(_i,2);
622 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,"abc");
623 23 : oomtest_free();
624 23 : oomtest_fill(_i,2);
625 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szLongString,123);
626 23 : oomtest_free();
627 23 : oomtest_fill(_i,2);
628 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString);
629 23 : oomtest_free();
630 23 : oomtest_fill(_i,2);
631 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,NULL);
632 23 : oomtest_free();
633 23 : oomtest_fill(_i,2);
634 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,"");
635 23 : oomtest_free();
636 23 : oomtest_fill(_i,2);
637 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,"abc");
638 23 : oomtest_free();
639 23 : oomtest_fill(_i,2);
640 23 : _trace_dynmsg(__FILE__,__LINE__,__DATE__,__TIME__,__func__,szParamLongString,123);
641 23 : oomtest_free();
642 23 : }
643 : END_TEST
644 : #endif /* NDEBUG */
645 :
646 23 : START_TEST(assert_assert_true)
647 : {
648 23 : oomtest_fill(_i,2);
649 : ASSERT(1);
650 23 : oomtest_free();
651 23 : }
652 : END_TEST
653 :
654 23 : START_TEST(assert_assert_false)
655 : {
656 23 : forktest_only;
657 : #ifdef GCOV
658 22 : if(oomtest_enabled())
659 20 : __gcov_dump();
660 : #endif
661 2 : oomtest_fill(_i,2);
662 2 : ASSERT(0);
663 : oomtest_free();
664 : }
665 : END_TEST
666 :
667 23 : START_TEST(assert_dbgtrace)
668 : {
669 23 : oomtest_fill(_i,2);
670 23 : DBG_TRACE;
671 23 : oomtest_free();
672 23 : }
673 : END_TEST
674 :
675 23 : START_TEST(assert_dbgmsg_null)
676 : {
677 23 : oomtest_fill(_i,2);
678 23 : DBG_MSG(NULL);
679 23 : oomtest_free();
680 23 : }
681 : END_TEST
682 :
683 23 : START_TEST(assert_dbgmsg_empty)
684 : {
685 23 : oomtest_fill(_i,2);
686 23 : DBG_MSG("");
687 23 : oomtest_free();
688 23 : }
689 : END_TEST
690 :
691 23 : START_TEST(assert_dbgmsg_szlong)
692 : {
693 23 : 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 23 : oomtest_fill(_i,2);
707 23 : DBG_MSG(szLongString);
708 23 : oomtest_free();
709 23 : }
710 : END_TEST
711 :
712 23 : START_TEST(assert_dbgitrace_inst)
713 : {
714 : unsigned int result;
715 23 : result=0;
716 23 : oomtest_fill(_i,2);
717 23 : DBG_ITRACE(result=1);
718 23 : oomtest_free();
719 23 : ck_assert(1==result);
720 23 : }
721 : END_TEST
722 :
723 23 : START_TEST(assert_dbgprintf_null_null)
724 : {
725 23 : oomtest_fill(_i,2);
726 23 : DBG_PRINTF(NULL,NULL);
727 23 : oomtest_free();
728 23 : }
729 : END_TEST
730 :
731 23 : START_TEST(assert_dbgprintf_null_empty)
732 : {
733 23 : oomtest_fill(_i,2);
734 23 : DBG_PRINTF(NULL,"");
735 23 : oomtest_free();
736 23 : }
737 : END_TEST
738 :
739 23 : START_TEST(assert_dbgprintf_null_szlong)
740 : {
741 23 : 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 23 : oomtest_fill(_i,2);
755 23 : DBG_PRINTF(NULL,szLongString);
756 23 : oomtest_free();
757 23 : }
758 : END_TEST
759 :
760 23 : START_TEST(assert_dbgprintf_null_123)
761 : {
762 23 : oomtest_fill(_i,2);
763 23 : DBG_PRINTF(NULL,123);
764 23 : oomtest_free();
765 23 : }
766 : END_TEST
767 :
768 23 : START_TEST(assert_dbgprintf_empty_null)
769 : {
770 23 : oomtest_fill(_i,2);
771 23 : DBG_PRINTF("",NULL);
772 23 : oomtest_free();
773 23 : }
774 : END_TEST
775 :
776 23 : START_TEST(assert_dbgprintf_empty_empty)
777 : {
778 23 : oomtest_fill(_i,2);
779 23 : DBG_PRINTF("","");
780 23 : oomtest_free();
781 23 : }
782 : END_TEST
783 :
784 23 : START_TEST(assert_dbgprintf_empty_szlong)
785 : {
786 23 : 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 23 : oomtest_fill(_i,2);
800 23 : DBG_PRINTF("",szLongString);
801 23 : oomtest_free();
802 23 : }
803 : END_TEST
804 :
805 23 : START_TEST(assert_dbgprintf_empty_123)
806 : {
807 23 : oomtest_fill(_i,2);
808 23 : DBG_PRINTF("",123);
809 23 : oomtest_free();
810 23 : }
811 : END_TEST
812 :
813 23 : START_TEST(assert_dbgprintf_szlong_null)
814 : {
815 23 : 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 23 : oomtest_fill(_i,2);
829 23 : DBG_PRINTF(szLongString,NULL);
830 23 : oomtest_free();
831 23 : }
832 : END_TEST
833 :
834 23 : START_TEST(assert_dbgprintf_szlong_empty)
835 : {
836 23 : 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 23 : oomtest_fill(_i,2);
850 23 : DBG_PRINTF(szLongString,"");
851 23 : oomtest_free();
852 23 : }
853 : END_TEST
854 :
855 23 : START_TEST(assert_dbgprintf_szlong_szlong)
856 : {
857 23 : 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 23 : oomtest_fill(_i,2);
871 23 : DBG_PRINTF(szLongString,szLongString);
872 23 : oomtest_free();
873 23 : }
874 : END_TEST
875 :
876 23 : START_TEST(assert_dbgprintf_szlong_123)
877 : {
878 23 : 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 23 : oomtest_fill(_i,2);
892 23 : DBG_PRINTF(szLongString,123);
893 23 : oomtest_free();
894 23 : }
895 : END_TEST
896 :
897 23 : START_TEST(assert_dbgprintf_szparamlong_null)
898 : {
899 23 : 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 23 : oomtest_fill(_i,2);
914 23 : DBG_PRINTF(szParamLongString,NULL);
915 23 : oomtest_free();
916 23 : }
917 : END_TEST
918 :
919 23 : START_TEST(assert_dbgprintf_szparamlong_empty)
920 : {
921 23 : 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 23 : oomtest_fill(_i,2);
936 23 : DBG_PRINTF(szParamLongString,"");
937 23 : oomtest_free();
938 23 : }
939 : END_TEST
940 :
941 23 : START_TEST(assert_dbgprintf_szparamlong_szlong)
942 : {
943 23 : 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 23 : 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 23 : oomtest_fill(_i,2);
971 23 : DBG_PRINTF(szParamLongString,szLongString);
972 23 : oomtest_free();
973 23 : }
974 : END_TEST
975 :
976 23 : START_TEST(assert_dbgprintf_szparamlong_123)
977 : {
978 23 : 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 23 : oomtest_fill(_i,2);
993 23 : DBG_PRINTF(szParamLongString,123);
994 23 : oomtest_free();
995 23 : }
996 : END_TEST
997 :
998 : /************************************************************************/
999 1512 : void assert_checked_uninitialized_setup()
1000 : {
1001 1512 : signals_catch();
1002 1512 : forktest_gprofdir();
1003 1512 : }
1004 811 : void assert_checked_common_teardown()
1005 : {
1006 811 : signals_release();
1007 : #ifndef NDEBUG
1008 811 : ck_assert(0==memtrack_getallocatedblocks());
1009 : #endif /* NDEBUG */
1010 811 : }
1011 : /************************************************************************/
1012 2400 : void assert_unchecked_common_setup()
1013 : {
1014 2400 : forktest_init();
1015 2400 : }
1016 1145 : void assert_unchecked_common_teardown()
1017 : {
1018 1145 : }
1019 1143 : void assert_unchecked_oom_setup()
1020 : {
1021 1143 : oomtest_enable(RAMLIMIT_SOFT);
1022 1143 : assert_unchecked_common_setup();
1023 1143 : }
1024 2 : void assert_unchecked_oom_teardown()
1025 : {
1026 2 : oomtest_disable();
1027 2 : assert_unchecked_common_teardown();
1028 2 : }
1029 : /************************************************************************/
1030 3909 : Suite* libdebug_assert_suite()
1031 : {
1032 : Suite *s;
1033 : TCase *tc;
1034 :
1035 3909 : s = suite_create("LibDebug-Assert");
1036 3909 : tc = tcase_create("Uninitialized");
1037 3909 : tcase_add_checked_fixture(tc, assert_checked_uninitialized_setup, assert_checked_common_teardown);
1038 3909 : tcase_add_unchecked_fixture(tc, assert_unchecked_common_setup, assert_unchecked_common_teardown);
1039 3909 : suite_add_tcase(s, tc);
1040 : #ifndef NDEBUG
1041 3909 : tcase_add_test_raise_signal(tc, assert_trace_nullfile,6);
1042 3909 : tcase_add_test_raise_signal(tc, assert_trace_nullline,6);
1043 3909 : tcase_add_test_raise_signal(tc, assert_trace_nulldate,6);
1044 3909 : tcase_add_test_raise_signal(tc, assert_trace_nulltime,6);
1045 3909 : tcase_add_test_raise_signal(tc, assert_trace_nullfunc,6);
1046 3909 : tcase_add_test_raise_signal(tc, assert_trace_emptyfile,6);
1047 3909 : tcase_add_test_raise_signal(tc, assert_trace_emptydate,6);
1048 3909 : tcase_add_test_raise_signal(tc, assert_trace_emptytime,6);
1049 3909 : tcase_add_test_raise_signal(tc, assert_trace_emptyfunc,6);
1050 3909 : tcase_add_test(tc, assert_trace_value);
1051 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullfile,6);
1052 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullline,6);
1053 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_nulldate,6);
1054 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_nulltime,6);
1055 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullfunc,6);
1056 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_nullmsg,6);
1057 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptyfile,6);
1058 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptydate,6);
1059 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptytime,6);
1060 3909 : tcase_add_test_raise_signal(tc, assert_tracemsg_emptyfunc,6);
1061 3909 : tcase_add_test(tc, assert_tracemsg_emptymsg);
1062 3909 : tcase_add_test(tc, assert_tracemsg_value);
1063 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullfile,6);
1064 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullline,6);
1065 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nulldate,6);
1066 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nulltime,6);
1067 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullfunc,6);
1068 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_nullmsg,6);
1069 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptyfile,6);
1070 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptydate,6);
1071 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptytime,6);
1072 3909 : tcase_add_test_raise_signal(tc, assert_tracedynmsg_emptyfunc,6);
1073 3909 : tcase_add_test(tc, assert_tracedynmsg_emptymsg);
1074 3909 : tcase_add_test(tc, assert_tracedynmsg_value);
1075 3909 : tcase_add_test_raise_signal(tc, assert_assert_false,6);
1076 : #else
1077 : tcase_add_test(tc, assert_assert_false);
1078 : #endif /* NDEBUG */
1079 3909 : tcase_add_test(tc, assert_assert_true);
1080 3909 : tcase_add_test(tc, assert_dbgtrace);
1081 3909 : tcase_add_test(tc, assert_dbgmsg_null);
1082 3909 : tcase_add_test(tc, assert_dbgmsg_empty);
1083 3909 : tcase_add_test(tc, assert_dbgmsg_szlong);
1084 3909 : tcase_add_test(tc, assert_dbgitrace_inst);
1085 3909 : tcase_add_test(tc, assert_dbgprintf_null_null);
1086 3909 : tcase_add_test(tc, assert_dbgprintf_null_empty);
1087 3909 : tcase_add_test(tc, assert_dbgprintf_null_szlong);
1088 3909 : tcase_add_test(tc, assert_dbgprintf_null_123);
1089 3909 : tcase_add_test(tc, assert_dbgprintf_empty_null);
1090 3909 : tcase_add_test(tc, assert_dbgprintf_empty_empty);
1091 3909 : tcase_add_test(tc, assert_dbgprintf_empty_szlong);
1092 3909 : tcase_add_test(tc, assert_dbgprintf_empty_123);
1093 3909 : tcase_add_test(tc, assert_dbgprintf_szlong_null);
1094 3909 : tcase_add_test(tc, assert_dbgprintf_szlong_empty);
1095 3909 : tcase_add_test(tc, assert_dbgprintf_szlong_szlong);
1096 3909 : tcase_add_test(tc, assert_dbgprintf_szlong_123);
1097 3909 : tcase_add_test(tc, assert_dbgprintf_szparamlong_null);
1098 3909 : tcase_add_test(tc, assert_dbgprintf_szparamlong_empty);
1099 3909 : tcase_add_test(tc, assert_dbgprintf_szparamlong_szlong);
1100 3909 : tcase_add_test(tc, assert_dbgprintf_szparamlong_123);
1101 :
1102 3909 : tc = tcase_create("Uninitialized-OOM");
1103 3909 : tcase_set_tags(tc,"oom");
1104 3909 : tcase_add_checked_fixture(tc, assert_checked_uninitialized_setup, assert_checked_common_teardown);
1105 3909 : tcase_add_unchecked_fixture(tc, assert_unchecked_oom_setup, assert_unchecked_oom_teardown);
1106 3909 : suite_add_tcase(s, tc);
1107 : #ifndef NDEBUG
1108 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_nullfile,6, 0, 10);
1109 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_nullline,6, 0, 10);
1110 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_nulldate,6, 0, 10);
1111 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_nulltime,6, 0, 10);
1112 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_nullfunc,6, 0, 10);
1113 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptyfile,6, 0, 10);
1114 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptydate,6, 0, 10);
1115 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptytime,6, 0, 10);
1116 3909 : tcase_add_loop_test_raise_signal(tc, assert_trace_emptyfunc,6, 0, 10);
1117 3909 : tcase_add_loop_test(tc, assert_trace_value, 0, 10);
1118 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullfile,6, 0, 10);
1119 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullline,6, 0, 10);
1120 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nulldate,6, 0, 10);
1121 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nulltime,6, 0, 10);
1122 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullfunc,6, 0, 10);
1123 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_nullmsg,6, 0, 10);
1124 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptyfile,6, 0, 10);
1125 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptydate,6, 0, 10);
1126 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptytime,6, 0, 10);
1127 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracemsg_emptyfunc,6, 0, 10);
1128 3909 : tcase_add_loop_test(tc, assert_tracemsg_emptymsg, 0, 10);
1129 3909 : tcase_add_loop_test(tc, assert_tracemsg_value, 0, 10);
1130 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullfile,6, 0, 10);
1131 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullline,6, 0, 10);
1132 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nulldate,6, 0, 10);
1133 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nulltime,6, 0, 10);
1134 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullfunc,6, 0, 10);
1135 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_nullmsg,6, 0, 10);
1136 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptyfile,6, 0, 10);
1137 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptydate,6, 0, 10);
1138 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptytime,6, 0, 10);
1139 3909 : tcase_add_loop_test_raise_signal(tc, assert_tracedynmsg_emptyfunc,6, 0, 10);
1140 3909 : tcase_add_loop_test(tc, assert_tracedynmsg_emptymsg, 0, 10);
1141 3909 : tcase_add_loop_test(tc, assert_tracedynmsg_value, 0, 10);
1142 3909 : tcase_add_loop_test_raise_signal(tc, assert_assert_false,6, 0, 10);
1143 : #else
1144 : tcase_add_loop_test(tc, assert_assert_false, 0, 10);
1145 : #endif /* NDEBUG */
1146 3909 : tcase_add_loop_test(tc, assert_assert_true, 0, 10);
1147 3909 : tcase_add_loop_test(tc, assert_dbgtrace, 0, 10);
1148 3909 : tcase_add_loop_test(tc, assert_dbgmsg_null, 0, 10);
1149 3909 : tcase_add_loop_test(tc, assert_dbgmsg_empty, 0, 10);
1150 3909 : tcase_add_loop_test(tc, assert_dbgmsg_szlong, 0, 10);
1151 3909 : tcase_add_loop_test(tc, assert_dbgitrace_inst, 0, 10);
1152 3909 : tcase_add_loop_test(tc, assert_dbgprintf_null_null, 0, 10);
1153 3909 : tcase_add_loop_test(tc, assert_dbgprintf_null_empty, 0, 10);
1154 3909 : tcase_add_loop_test(tc, assert_dbgprintf_null_szlong, 0, 10);
1155 3909 : tcase_add_loop_test(tc, assert_dbgprintf_null_123, 0, 10);
1156 3909 : tcase_add_loop_test(tc, assert_dbgprintf_empty_null, 0, 10);
1157 3909 : tcase_add_loop_test(tc, assert_dbgprintf_empty_empty, 0, 10);
1158 3909 : tcase_add_loop_test(tc, assert_dbgprintf_empty_szlong, 0, 10);
1159 3909 : tcase_add_loop_test(tc, assert_dbgprintf_empty_123, 0, 10);
1160 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_null, 0, 10);
1161 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_empty, 0, 10);
1162 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_szlong, 0, 10);
1163 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szlong_123, 0, 10);
1164 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_null, 0, 10);
1165 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_empty, 0, 10);
1166 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_szlong, 0, 10);
1167 3909 : tcase_add_loop_test(tc, assert_dbgprintf_szparamlong_123, 0, 10);
1168 :
1169 3909 : return s;
1170 : }
1171 :
|
