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