Line data Source code
1 : /** \file suite_libdebug-memdbg.c
2 : * \brief Check Libdebug memdbg 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-26 14:45
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/memdbg.h"
22 : #include "debug/oom.h" /* OOM simulation */
23 : #include <check.h>
24 : #include <unistd.h> /* pid_t getpid() */
25 : #include <sys/stat.h> /* mkdir(), chdir(), mode_t */
26 : #include <stdio.h> /* printf() */
27 : #include <stdlib.h> /* abort() */
28 : #include "checktools.inc"
29 :
30 : #ifndef NDEBUG
31 : START_TEST(memdbg_malloc_0)
32 : {
33 : uint64_t l_NbBlocks;
34 : size_t l_RAMSize;
35 : void* result;
36 :
37 : /* LibMemTrack consistency check preparation */
38 : l_NbBlocks=memtrack_getallocatedblocks();
39 : l_RAMSize=memtrack_getallocatedRAM();
40 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
41 :
42 : oomtest_fill(_i,2);
43 : /* Malloc has a non portable behavior, see man page, for 0 sized blocks */
44 : /* We should not support it */
45 : result=dbg_malloc(
46 : 0,
47 : __FILE__, __LINE__,
48 : __DATE__, __TIME__,__func__
49 : );
50 : oomtest_free();
51 : ck_assert(NULL==result);
52 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
53 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
54 : }
55 : END_TEST
56 : #endif
57 :
58 : #ifndef NDEBUG
59 : START_TEST(memdbg_malloc_null)
60 : {
61 : uint64_t l_NbBlocks;
62 : size_t l_RAMSize;
63 : void* result;
64 :
65 : /* LibMemTrack consistency check preparation */
66 : l_NbBlocks=memtrack_getallocatedblocks();
67 : l_RAMSize=memtrack_getallocatedRAM();
68 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
69 :
70 : oomtest_fill(_i,2);
71 : result=dbg_malloc(
72 : 1,
73 : __FILE__,0,
74 : __DATE__, __TIME__,__func__
75 : );
76 : oomtest_free();
77 : ck_assert(NULL==result);
78 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
79 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
80 :
81 : oomtest_fill(_i,2);
82 : result=dbg_malloc(
83 : 1,
84 : "", __LINE__,
85 : __DATE__, __TIME__,__func__
86 : );
87 : oomtest_free();
88 : ck_assert(NULL==result);
89 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
90 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
91 :
92 : oomtest_fill(_i,2);
93 : result=dbg_malloc(
94 : 1,
95 : __FILE__, __LINE__,
96 : "", __TIME__,__func__
97 : );
98 : oomtest_free();
99 : ck_assert(NULL==result);
100 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
101 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
102 :
103 : oomtest_fill(_i,2);
104 : result=dbg_malloc(
105 : 1,
106 : __FILE__, __LINE__,
107 : __DATE__, "",__func__
108 : );
109 : oomtest_free();
110 : ck_assert(NULL==result);
111 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
112 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
113 :
114 : oomtest_fill(_i,2);
115 : result=dbg_malloc(
116 : 1,
117 : __FILE__, __LINE__,
118 : __DATE__, __TIME__,""
119 : );
120 : oomtest_free();
121 : ck_assert(NULL==result);
122 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
123 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
124 : }
125 : END_TEST
126 : #endif
127 :
128 : #ifndef NDEBUG
129 : START_TEST(memdbg_free_null)
130 : {
131 : uint64_t l_NbBlocks;
132 : size_t l_RAMSize;
133 : void* result=NULL;
134 :
135 : /* LibMemTrack consistency check preparation */
136 : l_NbBlocks=memtrack_getallocatedblocks();
137 : l_RAMSize=memtrack_getallocatedRAM();
138 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
139 :
140 : /* should work */
141 : oomtest_fill(_i,2);
142 : dbg_free(NULL,
143 : __FILE__, __LINE__,
144 : __DATE__, __TIME__,__func__
145 : );
146 : oomtest_free();
147 : ck_assert(NULL==result);
148 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
149 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
150 : }
151 : END_TEST
152 : #endif
153 :
154 : #ifndef NDEBUG
155 : START_TEST(memdbg_free_invalid)
156 : {
157 : uint64_t l_NbBlocks;
158 :
159 : /* LibMemTrack consistency check preparation */
160 : l_NbBlocks=memtrack_getallocatedblocks();
161 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
162 :
163 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
164 : * whole testsuite if not caught or not in a child process */
165 : forktest_only;
166 : #ifdef GCOV
167 : if (oomtest_enabled())
168 : __gcov_dump();
169 : #endif
170 : oomtest_fill(_i,2);
171 : dbg_free((void*)123,
172 : __FILE__, __LINE__,
173 : __DATE__, __TIME__,__func__
174 : );
175 : /* Never reached, dead code */
176 : }
177 : END_TEST
178 : #endif
179 :
180 :
181 : #ifndef NDEBUG
182 : START_TEST(memdbg_mallocfree)
183 : {
184 : uint64_t l_NbBlocks;
185 : size_t l_RAMSize;
186 : void* result;
187 :
188 : /* LibMemTrack consistency check preparation */
189 : l_NbBlocks=memtrack_getallocatedblocks();
190 : l_RAMSize=memtrack_getallocatedRAM();
191 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
192 :
193 : /* Allocate */
194 : oomtest_fill(_i,2);
195 : result=dbg_malloc(
196 : 10000,
197 : __FILE__, __LINE__,
198 : __DATE__, __TIME__,__func__
199 : );
200 : oomtest_free();
201 : ck_assert((NULL!=result)||(oomtest_enabled()));
202 : if (NULL!=result) {
203 : /* Function returned the expected result */
204 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
205 : ck_assert(l_RAMSize+10000==memtrack_getallocatedRAM());
206 : } else {
207 : /* Function failed to return expected result while in OOM mode */
208 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
209 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
210 : }
211 :
212 : /* Deallocate */
213 : oomtest_fill(_i,2);
214 : dbg_free(result,
215 : __FILE__, __LINE__,
216 : __DATE__, __TIME__,__func__
217 : );
218 : oomtest_free();
219 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
220 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
221 : }
222 : END_TEST
223 : #endif
224 :
225 : #ifndef NDEBUG
226 : START_TEST(memdbg_calloc_0)
227 : {
228 : uint64_t l_NbBlocks;
229 : size_t l_RAMSize;
230 : void* result;
231 :
232 : /* LibMemTrack consistency check preparation */
233 : l_NbBlocks=memtrack_getallocatedblocks();
234 : l_RAMSize=memtrack_getallocatedRAM();
235 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
236 :
237 : oomtest_fill(_i,2);
238 : /* As well as malloc, calloc returns a pointer for a zero sized block allocation */
239 : /* We do not want to support this */
240 : result=dbg_calloc(
241 : 0, 0,
242 : __FILE__, __LINE__,
243 : __DATE__, __TIME__,__func__
244 : );
245 : oomtest_free();
246 : ck_assert(NULL==result);
247 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
248 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
249 :
250 : oomtest_fill(_i,2);
251 : result=dbg_calloc(
252 : 1, 0,
253 : __FILE__, __LINE__,
254 : __DATE__, __TIME__,__func__
255 : );
256 : oomtest_free();
257 : ck_assert(NULL==result);
258 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
259 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
260 :
261 : oomtest_fill(_i,2);
262 : result=dbg_calloc(
263 : 0, 1,
264 : __FILE__, __LINE__,
265 : __DATE__, __TIME__,__func__
266 : );
267 : oomtest_free();
268 : ck_assert(NULL==result);
269 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
270 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
271 : }
272 : END_TEST
273 : #endif
274 :
275 : #ifndef NDEBUG
276 : START_TEST(memdbg_calloc_null)
277 : {
278 : uint64_t l_NbBlocks;
279 : size_t l_RAMSize;
280 : void* result;
281 :
282 : /* LibMemTrack consistency check preparation */
283 : l_NbBlocks=memtrack_getallocatedblocks();
284 : l_RAMSize=memtrack_getallocatedRAM();
285 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
286 :
287 : oomtest_fill(_i,2);
288 : result=dbg_calloc(
289 : 1,1,
290 : __FILE__,0,
291 : __DATE__, __TIME__,__func__
292 : );
293 : oomtest_free();
294 : ck_assert(NULL==result);
295 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
296 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
297 :
298 : oomtest_fill(_i,2);
299 : result=dbg_calloc(
300 : 1,1,
301 : "", __LINE__,
302 : __DATE__, __TIME__,__func__
303 : );
304 : oomtest_free();
305 : ck_assert(NULL==result);
306 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
307 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
308 :
309 : oomtest_fill(_i,2);
310 : result=dbg_calloc(
311 : 1,1,
312 : __FILE__, __LINE__,
313 : "", __TIME__,__func__
314 : );
315 : oomtest_free();
316 : ck_assert(NULL==result);
317 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
318 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
319 :
320 : oomtest_fill(_i,2);
321 : result=dbg_calloc(
322 : 1,1,
323 : __FILE__, __LINE__,
324 : __DATE__, "",__func__
325 : );
326 : oomtest_free();
327 : ck_assert(NULL==result);
328 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
329 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
330 :
331 : oomtest_fill(_i,2);
332 : result=dbg_calloc(
333 : 1,1,
334 : __FILE__, __LINE__,
335 : __DATE__, __TIME__,""
336 : );
337 : oomtest_free();
338 : ck_assert(NULL==result);
339 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
340 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
341 : }
342 : END_TEST
343 : #endif
344 :
345 : #ifndef NDEBUG
346 : START_TEST(memdbg_callocfree)
347 : {
348 : uint64_t l_NbBlocks;
349 : size_t l_RAMSize;
350 : void* result;
351 :
352 : /* LibMemTrack consistency check preparation */
353 : l_NbBlocks=memtrack_getallocatedblocks();
354 : l_RAMSize=memtrack_getallocatedRAM();
355 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
356 :
357 : /* Allocate */
358 : oomtest_fill(_i,2);
359 : result=dbg_calloc(
360 : 100,100,
361 : __FILE__, __LINE__,
362 : __DATE__, __TIME__,__func__
363 : );
364 : oomtest_free();
365 : ck_assert((NULL!=result)||(oomtest_enabled()));
366 : if (NULL!=result) {
367 : /* Function returned the expected result */
368 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
369 : ck_assert(l_RAMSize+10000==memtrack_getallocatedRAM());
370 : } else {
371 : /* Function failed to return expected result while in OOM mode */
372 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
373 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
374 : }
375 :
376 : /* Deallocate */
377 : oomtest_fill(_i,2);
378 : dbg_free(result,
379 : __FILE__, __LINE__,
380 : __DATE__, __TIME__,__func__
381 : );
382 : oomtest_free();
383 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
384 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
385 : }
386 : END_TEST
387 : #endif
388 :
389 : /* WIP */
390 : #ifndef NDEBUG
391 : START_TEST(memdbg_realloc_null0)
392 : {
393 : uint64_t l_NbBlocks;
394 : size_t l_RAMSize;
395 : void* l_Ptr;
396 : void* result;
397 :
398 : /* LibMemTrack consistency check preparation */
399 : l_NbBlocks=memtrack_getallocatedblocks();
400 : l_RAMSize=memtrack_getallocatedRAM();
401 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
402 :
403 : /* Null test */
404 : /* Should behave as malloc in this case and allocate a valid initial block */
405 : l_Ptr=NULL;
406 : oomtest_fill(_i,2);
407 : result=dbg_realloc(
408 : l_Ptr,
409 : 10,
410 : __FILE__,__LINE__,
411 : __DATE__, __TIME__,__func__
412 : );
413 : oomtest_free();
414 : ck_assert((NULL!=result)||(oomtest_enabled()));
415 : if (NULL!=result) {
416 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
417 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
418 : ck_assert_msg(l_NbBlocks+1==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
419 : } else {
420 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
421 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
422 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
423 : /* Repair for next test */
424 : result=dbg_realloc(
425 : l_Ptr,
426 : 10,
427 : __FILE__,__LINE__,
428 : __DATE__, __TIME__,__func__
429 : );
430 : }
431 :
432 : /* Non portable behavior which behaves as free */
433 : l_Ptr=result;
434 : oomtest_fill(_i,2);
435 : result=dbg_realloc(
436 : l_Ptr,
437 : 0,
438 : __FILE__, __LINE__,
439 : __DATE__, __TIME__,__func__
440 : );
441 : oomtest_free();
442 : ck_assert(l_Ptr==result);
443 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
444 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
445 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
446 : }
447 : END_TEST
448 : #endif
449 :
450 : #ifndef NDEBUG
451 : START_TEST(memdbg_realloc_empty)
452 : {
453 : uint64_t l_NbBlocks;
454 : size_t l_RAMSize;
455 : void* l_Ptr;
456 : void* result;
457 :
458 : /* LibMemTrack consistency check preparation */
459 : l_NbBlocks=memtrack_getallocatedblocks();
460 : l_RAMSize=memtrack_getallocatedRAM();
461 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
462 :
463 : /* Create an initial valid block */
464 : l_Ptr=NULL;
465 : oomtest_fill(_i,2);
466 : result=dbg_realloc(
467 : l_Ptr,
468 : 10,
469 : __FILE__,__LINE__,
470 : __DATE__, __TIME__,__func__
471 : );
472 : oomtest_free();
473 : ck_assert((NULL!=result)||(oomtest_enabled()));
474 : if (NULL!=result) {
475 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
476 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
477 : } else {
478 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
479 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
480 : /* Repair for next test */
481 : result=dbg_realloc(
482 : l_Ptr,
483 : 10,
484 : __FILE__,__LINE__,
485 : __DATE__, __TIME__,__func__
486 : );
487 : }
488 :
489 : /* Line number 0 */
490 : l_Ptr=result;
491 : oomtest_fill(_i,2);
492 : result=dbg_realloc(
493 : l_Ptr,
494 : 1,
495 : __FILE__,0,
496 : __DATE__, __TIME__,__func__
497 : );
498 : oomtest_free();
499 : ck_assert(NULL==result);
500 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
501 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
502 :
503 : /* Empty filename */
504 : oomtest_fill(_i,2);
505 : result=dbg_realloc(
506 : l_Ptr,
507 : 1,
508 : "", __LINE__,
509 : __DATE__, __TIME__,__func__
510 : );
511 : oomtest_free();
512 : ck_assert(NULL==result);
513 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
514 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
515 :
516 : /* Empty Compilation date */
517 : oomtest_fill(_i,2);
518 : result=dbg_realloc(
519 : l_Ptr,
520 : 1,
521 : __FILE__, __LINE__,
522 : "", __TIME__,__func__
523 : );
524 : oomtest_free();
525 : ck_assert(NULL==result);
526 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
527 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
528 :
529 : /* Empty Compilation time */
530 : oomtest_fill(_i,2);
531 : result=dbg_realloc(
532 : l_Ptr,
533 : 1,
534 : __FILE__, __LINE__,
535 : __DATE__, "",__func__
536 : );
537 : oomtest_free();
538 : ck_assert(NULL==result);
539 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
540 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
541 :
542 : /* Empty function name */
543 : oomtest_fill(_i,2);
544 : result=dbg_realloc(
545 : l_Ptr,
546 : 1,
547 : __FILE__, __LINE__,
548 : __DATE__, __TIME__,""
549 : );
550 : oomtest_free();
551 : ck_assert(NULL==result);
552 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
553 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
554 :
555 : dbg_free(
556 : l_Ptr,
557 : __FILE__, __LINE__,
558 : __DATE__, __TIME__,__func__
559 : );
560 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
561 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
562 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
563 : }
564 : END_TEST
565 : #endif
566 :
567 : #ifndef NDEBUG
568 : START_TEST(memdbg_realloc_invalid)
569 : {
570 : uint64_t l_NbBlocks;
571 :
572 : /* LibMemTrack consistency check preparation */
573 : l_NbBlocks=memtrack_getallocatedblocks();
574 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
575 :
576 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
577 : * whole testsuite if not caught or not in a child process */
578 : forktest_only;
579 :
580 : #ifdef GCOV
581 : if (oomtest_enabled())
582 : __gcov_dump();
583 : #endif
584 : oomtest_fill(_i,2);
585 : /* Try to realloc a non null, not tracked block */
586 : /* Abort/SIG6 expected */
587 : dbg_realloc(
588 : (void*)999,
589 : 10,
590 : __FILE__, __LINE__, __DATE__, __TIME__, __func__
591 : );
592 : /* Never reached, dead code */
593 : }
594 : END_TEST
595 : #endif
596 :
597 : #ifndef NDEBUG
598 : START_TEST(memdbg_reallocfree)
599 : {
600 : uint64_t l_NbBlocks;
601 : size_t l_RAMSize;
602 : void* l_Ptr;
603 : void* result;
604 :
605 : /* LibMemTrack consistency check preparation */
606 : l_NbBlocks=memtrack_getallocatedblocks();
607 : l_RAMSize=memtrack_getallocatedRAM();
608 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
609 :
610 : /* Create an initial valid block */
611 : l_Ptr=NULL;
612 : result=dbg_malloc(
613 : 10,
614 : __FILE__,__LINE__,
615 : __DATE__, __TIME__,__func__
616 : );
617 : ck_assert(NULL!=result);
618 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
619 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
620 :
621 : /* Standard realloc to increase the block size */
622 : l_Ptr=result;
623 : oomtest_fill(_i,2);
624 : result = dbg_realloc(
625 : l_Ptr,
626 : 10000,
627 : __FILE__, __LINE__, __DATE__, __TIME__, __func__
628 : );
629 : oomtest_free();
630 : ck_assert((NULL!=result)||(oomtest_enabled()));
631 : if (NULL!=result) {
632 : /* Function returned the expected result */
633 : } else {
634 : /* Function failed to return expected result while in OOM mode */
635 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
636 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
637 : /* Repair for next test */
638 : result = dbg_realloc(
639 : l_Ptr,
640 : 10000,
641 : __FILE__, __LINE__, __DATE__, __TIME__, __func__
642 : );
643 : ck_assert(NULL!=result);
644 : }
645 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
646 : ck_assert(l_RAMSize+10000==memtrack_getallocatedRAM());
647 :
648 : l_Ptr=result;
649 : /* Standard realloc to reduce the block size */
650 : oomtest_fill(_i,2);
651 : result = dbg_realloc(
652 : l_Ptr,
653 : 1000,
654 : __FILE__, __LINE__, __DATE__, __TIME__, __func__
655 : );
656 : oomtest_free();
657 : ck_assert((NULL!=result)||(oomtest_enabled()));
658 : if (NULL!=result) {
659 : /* Function returned the expected result */
660 : } else {
661 : /* Function failed to return expected result while in OOM mode */
662 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
663 : ck_assert(l_RAMSize+10000==memtrack_getallocatedRAM());
664 : /* Repair for next test */
665 : result = dbg_realloc(
666 : l_Ptr,
667 : 1000,
668 : __FILE__, __LINE__, __DATE__, __TIME__, __func__
669 : );
670 : }
671 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
672 : ck_assert(l_RAMSize+1000==memtrack_getallocatedRAM());
673 :
674 : /* OOM expected, no realloc */
675 : l_Ptr=result;
676 : if (oomtest_enabled()) {
677 : oomtest_fill(_i,2);
678 : result= dbg_realloc(
679 : l_Ptr,
680 : (RAMLIMIT_SOFT+1),
681 : __FILE__, __LINE__, __DATE__, __TIME__, __func__
682 : );
683 : oomtest_free();
684 :
685 : ck_assert(NULL==result);
686 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
687 : ck_assert(l_RAMSize+1000==memtrack_getallocatedRAM());
688 : }
689 : /* Optional cleanup when forked, but cleaner and dbg_free already tested */
690 : dbg_free(
691 : l_Ptr,
692 : __FILE__, __LINE__,
693 : __DATE__, __TIME__,__func__
694 : );
695 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
696 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
697 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
698 : }
699 : END_TEST
700 : #endif
701 :
702 : #ifndef NDEBUG
703 : START_TEST(memdbg_strdup_invalid)
704 : {
705 : /* This test is supposed to trigger a SIGSEV(11) and will crash the
706 : * whole testsuite if not caught or not in a child process */
707 : forktest_only;
708 :
709 : oomtest_fill(_i,2);
710 : /* SIGSEV expected */
711 : dbg_strdup(
712 : NULL,
713 : __FILE__, __LINE__,
714 : __DATE__, __TIME__,__func__
715 : );
716 : /* Never reached, dead code */
717 : }
718 : END_TEST
719 : #endif
720 :
721 : #ifndef NDEBUG
722 : START_TEST(memdbg_strdup_nullempty)
723 : {
724 : char* result;
725 :
726 : result = NULL;
727 : oomtest_fill(_i,2);
728 : result=dbg_strdup(
729 : "",
730 : __FILE__, __LINE__,
731 : __DATE__, __TIME__,__func__
732 : );
733 : oomtest_free();
734 : ck_assert((NULL!=result)||(oomtest_enabled()));
735 : dbg_free(result,
736 : __FILE__, __LINE__,
737 : __DATE__, __TIME__,__func__
738 : );
739 :
740 : result = NULL;
741 : oomtest_fill(_i,2);
742 : result=dbg_strdup(
743 : "abc",
744 : NULL, __LINE__,
745 : __DATE__, __TIME__,__func__
746 : );
747 : oomtest_free();
748 : ck_assert((NULL==result)||(oomtest_enabled()));
749 :
750 : result = NULL;
751 : oomtest_fill(_i,2);
752 : result=dbg_strdup(
753 : "abc",
754 : __FILE__, 0,
755 : __DATE__, __TIME__,__func__
756 : );
757 : oomtest_free();
758 : ck_assert((NULL==result)||(oomtest_enabled()));
759 :
760 : result = NULL;
761 : oomtest_fill(_i,2);
762 : result=dbg_strdup(
763 : "abc",
764 : __FILE__, __LINE__,
765 : NULL, __TIME__,__func__
766 : );
767 : oomtest_free();
768 : ck_assert((NULL==result)||(oomtest_enabled()));
769 :
770 : result = NULL;
771 : oomtest_fill(_i,2);
772 : result=dbg_strdup(
773 : "abc",
774 : __FILE__, __LINE__,
775 : __DATE__, NULL,__func__
776 : );
777 : oomtest_free();
778 : ck_assert((NULL==result)||(oomtest_enabled()));
779 :
780 : result = NULL;
781 : oomtest_fill(_i,2);
782 : result=dbg_strdup(
783 : "abc",
784 : __FILE__, __LINE__,
785 : __DATE__, __TIME__,NULL
786 : );
787 : oomtest_free();
788 : ck_assert((NULL==result)||(oomtest_enabled()));
789 :
790 : result = NULL;
791 : oomtest_fill(_i,2);
792 : result=dbg_strdup(
793 : "abc",
794 : "", __LINE__,
795 : __DATE__, __TIME__,__func__
796 : );
797 : oomtest_free();
798 : ck_assert((NULL==result)||(oomtest_enabled()));
799 :
800 : result = NULL;
801 : oomtest_fill(_i,2);
802 : result=dbg_strdup(
803 : "abc",
804 : __FILE__, __LINE__,
805 : "", __TIME__,__func__
806 : );
807 : oomtest_free();
808 : ck_assert((NULL==result)||(oomtest_enabled()));
809 :
810 : result = NULL;
811 : oomtest_fill(_i,2);
812 : result=dbg_strdup(
813 : "abc",
814 : __FILE__, __LINE__,
815 : __DATE__, "",__func__
816 : );
817 : oomtest_free();
818 : ck_assert((NULL==result)||(oomtest_enabled()));
819 :
820 : result = NULL;
821 : oomtest_fill(_i,2);
822 : result=dbg_strdup(
823 : "abc",
824 : __FILE__, __LINE__,
825 : __DATE__, __TIME__,""
826 : );
827 : oomtest_free();
828 : ck_assert((NULL==result)||(oomtest_enabled()));
829 : }
830 : END_TEST
831 : #endif
832 :
833 : #ifndef NDEBUG
834 : START_TEST(memdbg_strdup_value)
835 : {
836 : char* result;
837 : char *szLongString =
838 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
839 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
840 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
841 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
842 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
843 : "%d"
844 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
845 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
846 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
847 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
848 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
849 : ;
850 : oomtest_fill(_i,2);
851 : result=dbg_strdup(
852 : szLongString,
853 : __FILE__, __LINE__,
854 : __DATE__, __TIME__,__func__
855 : );
856 : oomtest_free();
857 : ck_assert((NULL!=result)||(oomtest_enabled()));
858 : if (NULL!=result) {
859 : ck_assert(0==strcmp(szLongString,result));
860 : dbg_free(result,
861 : __FILE__, __LINE__,
862 : __DATE__, __TIME__,__func__
863 : );
864 : }
865 : }
866 : END_TEST
867 : #endif
868 :
869 : #ifndef NDEBUG
870 : START_TEST(memdbg_asprintf_invalid)
871 : {
872 : forktest_only;
873 : #ifdef GCOV
874 : if (oomtest_enabled())
875 : __gcov_dump();
876 : #endif
877 : oomtest_fill(_i,2);
878 : /* SIGABRT6 expected */
879 : dbg_asprintf(NULL,
880 : "abc%ddef",
881 : __FILE__, __LINE__,
882 : __DATE__, __TIME__,__func__,
883 : 123
884 : );
885 : }
886 : END_TEST
887 : #endif
888 :
889 : #ifndef NDEBUG
890 : START_TEST(memdbg_asprintf_nullempty)
891 : {
892 : int result;
893 : char* l_Ptr;
894 :
895 : oomtest_fill(_i,2);
896 : result=dbg_asprintf(&l_Ptr,
897 : NULL,
898 : __FILE__, __LINE__,
899 : __DATE__, __TIME__,__func__
900 : );
901 : oomtest_free();
902 : ck_assert((-1==result)||((oomtest_enabled())&&(-2==result)));
903 :
904 : oomtest_fill(_i,2);
905 : result=dbg_asprintf(&l_Ptr,
906 : "abcdef",
907 : NULL, __LINE__,
908 : __DATE__, __TIME__,__func__
909 : );
910 : oomtest_free();
911 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
912 :
913 : oomtest_fill(_i,2);
914 : result=dbg_asprintf(&l_Ptr,
915 : "abcdef",
916 : __FILE__, 0,
917 : __DATE__, __TIME__,__func__
918 : );
919 : oomtest_free();
920 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
921 :
922 : oomtest_fill(_i,2);
923 : result=dbg_asprintf(&l_Ptr,
924 : "abcdef",
925 : __FILE__, __LINE__,
926 : NULL, __TIME__,__func__
927 : );
928 : oomtest_free();
929 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
930 :
931 : oomtest_fill(_i,2);
932 : result=dbg_asprintf(&l_Ptr,
933 : "abcdef",
934 : __FILE__, __LINE__,
935 : __DATE__, NULL,__func__
936 : );
937 : oomtest_free();
938 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
939 :
940 : oomtest_fill(_i,2);
941 : result=dbg_asprintf(&l_Ptr,
942 : "abcdef",
943 : __FILE__, __LINE__,
944 : __DATE__, __TIME__,NULL
945 : );
946 : oomtest_free();
947 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
948 :
949 : oomtest_fill(_i,2);
950 : result=dbg_asprintf(&l_Ptr,
951 : "",
952 : __FILE__, __LINE__,
953 : __DATE__, __TIME__,__func__
954 : );
955 : oomtest_free();
956 : ck_assert((0==result)||(oomtest_enabled()));
957 : if (0==result) {
958 : ck_assert(NULL!=l_Ptr);
959 : dbg_free(l_Ptr,
960 : __FILE__, __LINE__,
961 : __DATE__, __TIME__,__func__
962 : );
963 : }
964 :
965 : oomtest_fill(_i,2);
966 : result=dbg_asprintf(&l_Ptr,
967 : "abcdef",
968 : "", __LINE__,
969 : __DATE__, __TIME__,__func__
970 : );
971 : oomtest_free();
972 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
973 :
974 : oomtest_fill(_i,2);
975 : result=dbg_asprintf(&l_Ptr,
976 : "abcdef",
977 : __FILE__, 0,
978 : __DATE__, __TIME__,__func__
979 : );
980 : oomtest_free();
981 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
982 :
983 : oomtest_fill(_i,2);
984 : result=dbg_asprintf(&l_Ptr,
985 : "abcdef",
986 : __FILE__, __LINE__,
987 : "", __TIME__,__func__
988 : );
989 : oomtest_free();
990 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
991 :
992 : oomtest_fill(_i,2);
993 : result=dbg_asprintf(&l_Ptr,
994 : "abcdef",
995 : __FILE__, __LINE__,
996 : __DATE__, "",__func__
997 : );
998 : oomtest_free();
999 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
1000 :
1001 : oomtest_fill(_i,2);
1002 : result=dbg_asprintf(&l_Ptr,
1003 : "abcdef",
1004 : __FILE__, __LINE__,
1005 : __DATE__, __TIME__,""
1006 : );
1007 : oomtest_free();
1008 : ck_assert((-2==result)||((oomtest_enabled())&&(-1==result)));
1009 : }
1010 : END_TEST
1011 : #endif
1012 :
1013 : #ifndef NDEBUG
1014 : START_TEST(memdbg_asprintf_value)
1015 : {
1016 : /* Only test with parameter, not without or with parameter type error */
1017 : int result;
1018 : char* l_Ptr;
1019 : char *szLongString =
1020 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1021 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1022 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1023 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1024 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1025 : "%d"
1026 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1027 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1028 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1029 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1030 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1031 : ;
1032 : oomtest_fill(_i,2);
1033 : result=dbg_asprintf(&l_Ptr,
1034 : szLongString,
1035 : __FILE__, __LINE__,
1036 : __DATE__, __TIME__,__func__,
1037 : 123
1038 : );
1039 : oomtest_free();
1040 : ck_assert((-1!=result)||(oomtest_enabled()));
1041 : if (-1!=result) {
1042 : char *szExpected =
1043 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1044 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1045 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1046 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1047 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1048 : "123"
1049 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1050 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1051 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1052 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1053 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1054 : ;
1055 : /* Test succeeded */
1056 : ck_assert((size_t)result==strlen(szExpected));
1057 : ck_assert((NULL!=l_Ptr)&&(0==strcmp(szExpected,l_Ptr)));
1058 : dbg_free(l_Ptr,
1059 : __FILE__, __LINE__,
1060 : __DATE__, __TIME__,__func__
1061 : );
1062 : }
1063 : }
1064 : END_TEST
1065 : #endif
1066 :
1067 : /************************************************************************/
1068 0 : void memdbg_checked_uninitialized_setup()
1069 : {
1070 0 : signals_catch();
1071 0 : forktest_gprofdir();
1072 0 : }
1073 0 : void memdbg_checked_withdata_setup()
1074 : {
1075 0 : signals_catch();
1076 0 : forktest_gprofdir();
1077 0 : }
1078 0 : void memdbg_checked_common_teardown()
1079 : {
1080 0 : signals_release();
1081 : #ifndef NDEBUG
1082 : ck_assert(0==memtrack_getallocatedblocks());
1083 : #endif /* NDEBUG */
1084 0 : }
1085 : /************************************************************************/
1086 5748 : void memdbg_unchecked_common_setup()
1087 : {
1088 5748 : forktest_init();
1089 5748 : }
1090 5748 : void memdbg_unchecked_common_teardown()
1091 : {
1092 5748 : }
1093 2874 : void memdbg_unchecked_oom_setup()
1094 : {
1095 2874 : oomtest_enable(RAMLIMIT_SOFT);
1096 2874 : memdbg_unchecked_common_setup();
1097 2874 : }
1098 2874 : void memdbg_unchecked_oom_teardown()
1099 : {
1100 2874 : oomtest_disable();
1101 2874 : memdbg_unchecked_common_teardown();
1102 2874 : }
1103 : /************************************************************************/
1104 1441 : Suite* libdebug_memdbg_suite()
1105 : {
1106 : Suite *s;
1107 : TCase *tc;
1108 :
1109 1441 : s = suite_create("LibDebug-MemDbg");
1110 1441 : tc = tcase_create("Uninitialized");
1111 1441 : tcase_add_checked_fixture(tc, memdbg_checked_uninitialized_setup, memdbg_checked_common_teardown);
1112 1441 : tcase_add_unchecked_fixture(tc, memdbg_unchecked_common_setup, memdbg_unchecked_common_teardown);
1113 1441 : suite_add_tcase(s, tc);
1114 : #ifndef NDEBUG
1115 : tcase_add_test(tc, memdbg_malloc_0);
1116 : tcase_add_test(tc, memdbg_malloc_null);
1117 : tcase_add_test(tc, memdbg_free_null);
1118 : tcase_add_test_raise_signal(tc, memdbg_free_invalid, 6);
1119 : tcase_add_test(tc, memdbg_mallocfree);
1120 : tcase_add_test(tc, memdbg_calloc_0);
1121 : tcase_add_test(tc, memdbg_calloc_null);
1122 : tcase_add_test(tc, memdbg_callocfree);
1123 : tcase_add_test(tc, memdbg_realloc_null0);
1124 : tcase_add_test(tc, memdbg_realloc_empty);
1125 : tcase_add_test_raise_signal(tc, memdbg_realloc_invalid, 6);
1126 : tcase_add_test(tc, memdbg_reallocfree);
1127 : tcase_add_test_raise_signal(tc, memdbg_strdup_invalid, 11);
1128 : tcase_add_test(tc, memdbg_strdup_nullempty);
1129 : tcase_add_test(tc, memdbg_strdup_value);
1130 : tcase_add_test_raise_signal(tc, memdbg_asprintf_invalid, 6);
1131 : tcase_add_test(tc, memdbg_asprintf_nullempty);
1132 : tcase_add_test(tc, memdbg_asprintf_value);
1133 : #endif
1134 :
1135 1441 : tc = tcase_create("WithData");
1136 1441 : tcase_add_checked_fixture(tc, memdbg_checked_withdata_setup, memdbg_checked_common_teardown);
1137 1441 : tcase_add_unchecked_fixture(tc, memdbg_unchecked_common_setup, memdbg_unchecked_common_teardown);
1138 1441 : suite_add_tcase(s, tc);
1139 : #ifndef NDEBUG
1140 : tcase_add_test(tc, memdbg_malloc_0);
1141 : tcase_add_test(tc, memdbg_malloc_null);
1142 : tcase_add_test(tc, memdbg_free_null);
1143 : tcase_add_test_raise_signal(tc, memdbg_free_invalid, 6);
1144 : tcase_add_test(tc, memdbg_mallocfree);
1145 : tcase_add_test(tc, memdbg_calloc_0);
1146 : tcase_add_test(tc, memdbg_calloc_null);
1147 : tcase_add_test(tc, memdbg_callocfree);
1148 : tcase_add_test(tc, memdbg_realloc_null0);
1149 : tcase_add_test(tc, memdbg_realloc_empty);
1150 : tcase_add_test_raise_signal(tc, memdbg_realloc_invalid, 6);
1151 : tcase_add_test(tc, memdbg_reallocfree);
1152 : tcase_add_test_raise_signal(tc, memdbg_strdup_invalid, 11);
1153 : tcase_add_test(tc, memdbg_strdup_nullempty);
1154 : tcase_add_test(tc, memdbg_strdup_value);
1155 : tcase_add_test_raise_signal(tc, memdbg_asprintf_invalid, 6);
1156 : tcase_add_test(tc, memdbg_asprintf_nullempty);
1157 : tcase_add_test(tc, memdbg_asprintf_value);
1158 : #endif
1159 :
1160 1441 : tc = tcase_create("Uninitialized-OOM");
1161 1441 : tcase_set_tags(tc,"oom");
1162 1441 : tcase_add_checked_fixture(tc, memdbg_checked_uninitialized_setup, memdbg_checked_common_teardown);
1163 1441 : tcase_add_unchecked_fixture(tc, memdbg_unchecked_oom_setup, memdbg_unchecked_oom_teardown);
1164 1441 : suite_add_tcase(s, tc);
1165 : #ifndef NDEBUG
1166 : tcase_add_loop_test(tc, memdbg_malloc_0, 0, 10);
1167 : tcase_add_loop_test(tc, memdbg_malloc_null, 0, 10);
1168 : tcase_add_loop_test(tc, memdbg_free_null, 0, 10);
1169 : tcase_add_loop_test_raise_signal(tc, memdbg_free_invalid, 6, 0, 10);
1170 : tcase_add_loop_test(tc, memdbg_mallocfree, 0, 10);
1171 : tcase_add_loop_test(tc, memdbg_calloc_0, 0, 10);
1172 : tcase_add_loop_test(tc, memdbg_calloc_null, 0, 10);
1173 : tcase_add_loop_test(tc, memdbg_callocfree, 0, 10);
1174 : tcase_add_loop_test(tc, memdbg_realloc_null0, 0, 10);
1175 : tcase_add_loop_test(tc, memdbg_realloc_empty, 0, 10);
1176 : tcase_add_loop_test_raise_signal(tc, memdbg_realloc_invalid, 6, 0, 10);
1177 : tcase_add_loop_test(tc, memdbg_reallocfree, 0, 10);
1178 : tcase_add_loop_test_raise_signal(tc, memdbg_strdup_invalid, 11, 0, 10);
1179 : tcase_add_loop_test(tc, memdbg_strdup_nullempty, 0, 10);
1180 : tcase_add_loop_test(tc, memdbg_strdup_value, 0, 10);
1181 : tcase_add_loop_test_raise_signal(tc, memdbg_asprintf_invalid, 6, 0, 10);
1182 : tcase_add_loop_test(tc, memdbg_asprintf_nullempty, 0, 10);
1183 : tcase_add_loop_test(tc, memdbg_asprintf_value, 0, 10);
1184 : #endif
1185 :
1186 1441 : tc = tcase_create("WithData-OOM");
1187 1441 : tcase_set_tags(tc,"oom");
1188 1441 : tcase_add_checked_fixture(tc, memdbg_checked_withdata_setup, memdbg_checked_common_teardown);
1189 1441 : tcase_add_unchecked_fixture(tc, memdbg_unchecked_oom_setup, memdbg_unchecked_oom_teardown);
1190 1441 : suite_add_tcase(s, tc);
1191 : #ifndef NDEBUG
1192 : tcase_add_loop_test(tc, memdbg_malloc_0, 0, 10);
1193 : tcase_add_loop_test(tc, memdbg_malloc_null, 0, 10);
1194 : tcase_add_loop_test(tc, memdbg_free_null, 0, 10);
1195 : tcase_add_loop_test_raise_signal(tc, memdbg_free_invalid, 6, 0, 10);
1196 : tcase_add_loop_test(tc, memdbg_mallocfree, 0, 10);
1197 : tcase_add_loop_test(tc, memdbg_calloc_0, 0, 10);
1198 : tcase_add_loop_test(tc, memdbg_calloc_null, 0, 10);
1199 : tcase_add_loop_test(tc, memdbg_callocfree, 0, 10);
1200 : tcase_add_loop_test(tc, memdbg_realloc_null0, 0, 10);
1201 : tcase_add_loop_test(tc, memdbg_realloc_empty, 0, 10);
1202 : tcase_add_loop_test_raise_signal(tc, memdbg_realloc_invalid, 6, 0, 10);
1203 : tcase_add_loop_test(tc, memdbg_reallocfree, 0, 10);
1204 : tcase_add_loop_test_raise_signal(tc, memdbg_strdup_invalid, 11, 0, 10);
1205 : tcase_add_loop_test(tc, memdbg_strdup_nullempty, 0, 10);
1206 : tcase_add_loop_test(tc, memdbg_strdup_value, 0, 10);
1207 : tcase_add_loop_test_raise_signal(tc, memdbg_asprintf_invalid, 6, 0, 10);
1208 : tcase_add_loop_test(tc, memdbg_asprintf_nullempty, 0, 10);
1209 : tcase_add_loop_test(tc, memdbg_asprintf_value, 0, 10);
1210 : #endif
1211 :
1212 1441 : return s;
1213 : }
1214 :
|
