Line data Source code
1 : /** \file suite_libdebug-memory.c
2 : * \brief Check Libdebug memory 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 01: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/memtrack.h" /* memtrack_dumpblocks */
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> /* fprintf */
27 : #include <stdlib.h> /* abort() */
28 : #include "checktools.inc"
29 :
30 : #include "debug/memory.h" /* libdebug's memory macros */
31 :
32 66 : START_TEST(memory_malloc_0)
33 : {
34 : char* l_result;
35 : #ifndef NDEBUG
36 : size_t l_RAMSize;
37 : size_t l_NbBlocks;
38 66 : l_NbBlocks = memtrack_getallocatedblocks();
39 66 : l_RAMSize = memtrack_getallocatedRAM();
40 : #endif
41 :
42 66 : l_result=NULL;
43 66 : oomtest_fill(_i,2);
44 66 : l_result = malloc(0);
45 66 : oomtest_free();
46 : #ifndef NDEBUG
47 : /* Enforced by memtrack, but not glibc malloc */
48 66 : ck_assert(NULL==l_result);
49 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
50 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
51 66 : ck_assert(0==memtrack_getblocksize(l_result));
52 : #endif
53 66 : free(l_result);
54 66 : }
55 : END_TEST
56 :
57 66 : START_TEST(memory_malloc_100)
58 : {
59 : char* l_result;
60 : #ifndef NDEBUG
61 : size_t l_RAMSize;
62 : size_t l_NbBlocks;
63 66 : l_NbBlocks = memtrack_getallocatedblocks();
64 66 : l_RAMSize = memtrack_getallocatedRAM();
65 : #endif
66 :
67 66 : l_result=NULL;
68 66 : oomtest_fill(_i,2);
69 66 : l_result = malloc(100);
70 66 : oomtest_free();
71 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
72 66 : if (NULL!=l_result) {
73 : #ifndef NDEBUG
74 6 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
75 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
76 6 : ck_assert(100==memtrack_getblocksize(l_result));
77 : #endif
78 6 : free(l_result);
79 : }
80 66 : }
81 : END_TEST
82 :
83 66 : START_TEST(memory_malloc_oom)
84 : {
85 : char* l_result;
86 :
87 : #ifndef NDEBUG
88 : size_t l_RAMSize;
89 : size_t l_NbBlocks;
90 66 : l_NbBlocks = memtrack_getallocatedblocks();
91 66 : l_RAMSize = memtrack_getallocatedRAM();
92 : #endif
93 :
94 66 : l_result=NULL;
95 66 : oomtest_fill(_i,2);
96 66 : l_result = malloc(RAMLIMIT_SOFT/2);
97 66 : oomtest_free();
98 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
99 66 : if (NULL!=l_result) {
100 : #ifndef NDEBUG
101 6 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
102 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
103 : #endif
104 6 : free(l_result);
105 : }
106 : #ifndef NDEBUG
107 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
108 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
109 : #endif
110 66 : }
111 : END_TEST
112 :
113 66 : START_TEST(memory_realloc_null_0)
114 : {
115 : char* l_result;
116 : char* l_ptr;
117 :
118 : #ifndef NDEBUG
119 : size_t l_RAMSize;
120 : size_t l_NbBlocks;
121 66 : l_NbBlocks = memtrack_getallocatedblocks();
122 66 : l_RAMSize = memtrack_getallocatedRAM();
123 : #endif
124 :
125 66 : l_result=NULL;
126 66 : l_ptr=NULL;
127 66 : oomtest_fill(_i,2);
128 66 : l_result = realloc(l_ptr,0);
129 66 : oomtest_free();
130 66 : ck_assert(NULL==l_ptr);
131 : #ifndef NDEBUG
132 : /* Enforced by memtrack, but not glibc malloc */
133 66 : ck_assert(NULL==l_result);
134 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
135 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
136 : #endif
137 66 : if (NULL!=l_result)
138 0 : free(l_result);
139 66 : }
140 : END_TEST
141 :
142 66 : START_TEST(memory_realloc_null_100)
143 : {
144 : char* l_result;
145 : char* l_ptr;
146 :
147 : #ifndef NDEBUG
148 : size_t l_RAMSize;
149 : size_t l_NbBlocks;
150 66 : l_NbBlocks = memtrack_getallocatedblocks();
151 66 : l_RAMSize = memtrack_getallocatedRAM();
152 : #endif
153 :
154 66 : l_result=NULL;
155 66 : l_ptr=NULL;
156 66 : oomtest_fill(_i,2);
157 66 : l_result = realloc(l_ptr,100);
158 66 : oomtest_free();
159 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
160 66 : ck_assert(NULL==l_ptr);
161 66 : if (NULL!=l_result) {
162 : #ifndef NDEBUG
163 6 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
164 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
165 6 : ck_assert(100==memtrack_getblocksize(l_result));
166 : #endif
167 6 : free(l_result);
168 : }
169 66 : }
170 : END_TEST
171 :
172 66 : START_TEST(memory_realloc_null_oom)
173 : {
174 : char* l_result;
175 : char* l_ptr;
176 :
177 : #ifndef NDEBUG
178 : size_t l_RAMSize;
179 : size_t l_NbBlocks;
180 66 : l_NbBlocks = memtrack_getallocatedblocks();
181 66 : l_RAMSize = memtrack_getallocatedRAM();
182 : #endif
183 :
184 66 : l_result=NULL;
185 66 : l_ptr=NULL;
186 66 : oomtest_fill(_i,2);
187 66 : l_result = realloc(l_ptr,RAMLIMIT_SOFT/2);
188 66 : oomtest_free();
189 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
190 66 : if (NULL!=l_result) {
191 : #ifndef NDEBUG
192 6 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
193 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
194 : #endif
195 6 : free(l_result);
196 : }
197 66 : ck_assert(NULL==l_ptr);
198 : #ifndef NDEBUG
199 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
200 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
201 : #endif
202 66 : }
203 : END_TEST
204 :
205 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
206 66 : START_TEST(memory_realloc_invalid_0)
207 : {
208 : char* l_result;
209 : char* l_ptr;
210 :
211 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
212 : * whole testsuite if not caught or not in a child process */
213 66 : forktest_only;
214 :
215 44 : l_ptr=(void*)999;
216 : #ifdef GCOV
217 44 : if (oomtest_enabled())
218 40 : __gcov_dump();
219 : #endif
220 4 : oomtest_fill(_i,2);
221 4 : l_result=realloc(l_ptr,0);
222 : /* Never reached, dead code */
223 : (void)l_result;
224 : }
225 : END_TEST
226 : #endif
227 :
228 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
229 66 : START_TEST(memory_realloc_invalid_100)
230 : {
231 : char* l_result;
232 : char* l_ptr;
233 :
234 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
235 : * whole testsuite if not caught or not in a child process */
236 66 : forktest_only;
237 :
238 44 : l_ptr=(void*)999;
239 : #ifdef GCOV
240 44 : if (oomtest_enabled())
241 40 : __gcov_dump();
242 : #endif
243 4 : oomtest_fill(_i,2);
244 4 : l_result=realloc(l_ptr,100);
245 : /* Never reached, dead code */
246 : (void)l_result;
247 : }
248 : END_TEST
249 : #endif
250 :
251 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
252 66 : START_TEST(memory_realloc_invalid_oom)
253 : {
254 : void* l_result;
255 : char* l_ptr;
256 :
257 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
258 : * whole testsuite if not caught or not in a child process */
259 66 : forktest_only;
260 :
261 44 : l_ptr=(void*)999;
262 : #ifdef GCOV
263 44 : if (oomtest_enabled())
264 40 : __gcov_dump();
265 : #endif
266 4 : oomtest_fill(_i,2);
267 4 : l_result=realloc(l_ptr,RAMLIMIT_SOFT*2);
268 : /* Never reached, dead code */
269 : (void)l_result;
270 : }
271 : END_TEST
272 : #endif
273 :
274 66 : START_TEST(memory_realloc_valid_0)
275 : {
276 : void* l_result;
277 : char* l_ptr;
278 : #ifndef NDEBUG
279 : size_t l_RAMSize;
280 : size_t l_NbBlocks;
281 66 : l_NbBlocks = memtrack_getallocatedblocks();
282 66 : l_RAMSize = memtrack_getallocatedRAM();
283 : #endif
284 :
285 66 : l_ptr=malloc(100);
286 : #ifndef NDEBUG
287 66 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
288 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
289 : #endif
290 66 : oomtest_fill(_i,2);
291 66 : l_result=realloc(l_ptr,0);
292 66 : oomtest_free();
293 : (void)l_result;
294 : /* Behaves as free, result can be NULL or not, depending on implementations */
295 : #ifndef NDEBUG
296 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
297 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
298 : #endif
299 66 : }
300 : END_TEST
301 :
302 66 : START_TEST(memory_realloc_valid_updown)
303 : {
304 : char* l_result;
305 : char* l_ptr;
306 : #ifndef NDEBUG
307 : size_t l_RAMSize;
308 : size_t l_NbBlocks;
309 66 : l_NbBlocks = memtrack_getallocatedblocks();
310 66 : l_RAMSize = memtrack_getallocatedRAM();
311 : #endif
312 :
313 66 : l_result=NULL;
314 66 : l_ptr=malloc(100);
315 : #ifndef NDEBUG
316 66 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
317 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
318 : #endif
319 66 : oomtest_fill(_i,2);
320 66 : l_result=realloc(l_ptr,1000);
321 66 : oomtest_free();
322 66 : ck_assert((l_result!=NULL)||(oomtest_enabled()));
323 : /* Repair for next test outside of OOM context */
324 66 : if (NULL==l_result)
325 60 : l_result = realloc(l_ptr,1000);
326 : #ifndef NDEBUG
327 66 : ck_assert(l_RAMSize+1000==memtrack_getallocatedRAM());
328 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
329 66 : ck_assert(1000==memtrack_getblocksize(l_result));
330 : #endif
331 :
332 66 : l_ptr=l_result;
333 66 : oomtest_fill(_i,2);
334 66 : l_result=realloc(l_ptr,10);
335 66 : oomtest_free();
336 66 : ck_assert((l_result!=NULL)||(oomtest_enabled()));
337 : /* Repair for next test outside of OOM context */
338 66 : if (NULL==l_result)
339 60 : l_result = realloc(l_ptr,10);
340 : #ifndef NDEBUG
341 66 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
342 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
343 66 : ck_assert(10==memtrack_getblocksize(l_result));
344 : #endif
345 :
346 66 : free(l_result);
347 66 : }
348 : END_TEST
349 :
350 66 : START_TEST(memory_realloc_valid_oom)
351 : {
352 : char* l_result;
353 : char* l_ptr;
354 : #ifndef NDEBUG
355 : size_t l_RAMSize;
356 : size_t l_NbBlocks;
357 66 : l_NbBlocks = memtrack_getallocatedblocks();
358 66 : l_RAMSize = memtrack_getallocatedRAM();
359 : #endif
360 :
361 66 : l_result=NULL;
362 66 : l_ptr=malloc(100);
363 : #ifndef NDEBUG
364 66 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
365 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
366 : #endif
367 66 : oomtest_fill(_i,2);
368 66 : l_result = realloc(l_ptr,RAMLIMIT_SOFT/2);
369 66 : oomtest_free();
370 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
371 66 : if (NULL!=l_result) {
372 : #ifndef NDEBUG
373 6 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
374 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
375 6 : ck_assert(RAMLIMIT_SOFT/2==memtrack_getblocksize(l_result));
376 : #endif
377 6 : l_ptr=l_result;
378 : } else {
379 : #ifndef NDEBUG
380 60 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
381 60 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
382 60 : ck_assert(100==memtrack_getblocksize(l_ptr));
383 : #endif
384 : }
385 66 : ck_assert(NULL!=l_ptr);
386 :
387 : /* CppCheck detects a double free here for l_ptr, first freed at realloc.
388 : * But if realloc fails at runtime (this is wanted), l_ptr is left
389 : * untouched, thus not freed */
390 66 : free(l_ptr);
391 : /* CppCheck detects a memory leak here for l_result, allocated at realloc.
392 : * But if realloc fails at runtime (which is wanted here), l_result is NULL,
393 : * confirmed by the assertion, and do not need to be freed */
394 66 : }
395 : END_TEST
396 :
397 66 : START_TEST(memory_calloc_0_0)
398 : {
399 : char* l_result;
400 : #ifndef NDEBUG
401 : size_t l_RAMSize;
402 : size_t l_NbBlocks;
403 66 : l_NbBlocks = memtrack_getallocatedblocks();
404 66 : l_RAMSize = memtrack_getallocatedRAM();
405 : #endif
406 :
407 66 : l_result=NULL;
408 66 : oomtest_fill(_i,2);
409 66 : l_result = calloc(0,0);
410 66 : oomtest_free();
411 : #ifndef NDEBUG
412 : /* Enforced by memtrack, but not glibc malloc */
413 66 : ck_assert(NULL==l_result);
414 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
415 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
416 66 : ck_assert(0==memtrack_getblocksize(l_result));
417 : #endif
418 :
419 66 : free(l_result);
420 66 : }
421 : END_TEST
422 :
423 66 : START_TEST(memory_calloc_0_100)
424 : {
425 : char* l_result;
426 : #ifndef NDEBUG
427 : size_t l_RAMSize;
428 : size_t l_NbBlocks;
429 66 : l_NbBlocks = memtrack_getallocatedblocks();
430 66 : l_RAMSize = memtrack_getallocatedRAM();
431 : #endif
432 :
433 66 : l_result=NULL;
434 66 : oomtest_fill(_i,2);
435 66 : l_result = calloc(0,100);
436 66 : oomtest_free();
437 : #ifndef NDEBUG
438 : /* Enforced by memtrack, but not glibc malloc */
439 66 : ck_assert(NULL==l_result);
440 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
441 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
442 66 : ck_assert(0==memtrack_getblocksize(l_result));
443 : #endif
444 :
445 66 : free(l_result);
446 66 : }
447 : END_TEST
448 :
449 66 : START_TEST(memory_calloc_100_0)
450 : {
451 : char* l_result;
452 : #ifndef NDEBUG
453 : size_t l_RAMSize;
454 : size_t l_NbBlocks;
455 66 : l_NbBlocks = memtrack_getallocatedblocks();
456 66 : l_RAMSize = memtrack_getallocatedRAM();
457 : #endif
458 :
459 66 : l_result=NULL;
460 66 : oomtest_fill(_i,2);
461 66 : l_result = calloc(100,0);
462 66 : oomtest_free();
463 : #ifndef NDEBUG
464 : /* Enforced by memtrack, but not glibc malloc */
465 66 : ck_assert(NULL==l_result);
466 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
467 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
468 66 : ck_assert(0==memtrack_getblocksize(l_result));
469 : #endif
470 :
471 66 : free(l_result);
472 66 : }
473 : END_TEST
474 :
475 66 : START_TEST(memory_calloc_100_100)
476 : {
477 : char* l_result;
478 : #ifndef NDEBUG
479 : size_t l_RAMSize;
480 : size_t l_NbBlocks;
481 66 : l_NbBlocks = memtrack_getallocatedblocks();
482 66 : l_RAMSize = memtrack_getallocatedRAM();
483 : #endif
484 :
485 66 : l_result=NULL;
486 66 : oomtest_fill(_i,2);
487 66 : l_result = calloc(100,100);
488 66 : oomtest_free();
489 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
490 66 : if (NULL!=l_result) {
491 : #ifndef NDEBUG
492 6 : ck_assert(l_RAMSize+10000==memtrack_getallocatedRAM());
493 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
494 6 : ck_assert(10000==memtrack_getblocksize(l_result));
495 : #endif
496 :
497 6 : free(l_result);
498 : }
499 66 : }
500 : END_TEST
501 :
502 66 : START_TEST(memory_calloc_oom)
503 : {
504 : char* l_result;
505 : #ifndef NDEBUG
506 : size_t l_RAMSize;
507 : size_t l_NbBlocks;
508 66 : l_NbBlocks = memtrack_getallocatedblocks();
509 66 : l_RAMSize = memtrack_getallocatedRAM();
510 : #endif
511 :
512 66 : l_result=NULL;
513 66 : oomtest_fill(_i,2);
514 66 : l_result = calloc(RAMLIMIT_SOFT/2/1024,1024);
515 66 : oomtest_free();
516 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
517 66 : if (NULL!=l_result) {
518 : #ifndef NDEBUG
519 6 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
520 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
521 : #endif
522 6 : free(l_result);
523 : }
524 : #ifndef NDEBUG
525 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
526 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
527 : #endif
528 66 : }
529 : END_TEST
530 :
531 66 : START_TEST(memory_free_null)
532 : {
533 : char* l_ptr;
534 : #ifndef NDEBUG
535 : size_t l_RAMSize;
536 : size_t l_NbBlocks;
537 66 : l_NbBlocks = memtrack_getallocatedblocks();
538 66 : l_RAMSize = memtrack_getallocatedRAM();
539 : #endif
540 :
541 66 : l_ptr=NULL;
542 66 : oomtest_fill(_i,2);
543 66 : free(l_ptr);
544 66 : oomtest_free();
545 66 : ck_assert(NULL==l_ptr);
546 : #ifndef NDEBUG
547 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
548 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
549 : #endif
550 66 : }
551 : END_TEST
552 :
553 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
554 66 : START_TEST(memory_free_invalid)
555 : {
556 : char* l_ptr;
557 :
558 66 : l_ptr=(void*)999;
559 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
560 : * whole testsuite if not caught or not in a child process */
561 66 : forktest_only;
562 :
563 : #ifdef GCOV
564 44 : if (oomtest_enabled())
565 40 : __gcov_dump();
566 : #endif
567 4 : oomtest_fill(_i,2);
568 4 : free(l_ptr);
569 : }
570 : END_TEST
571 : #endif
572 :
573 66 : START_TEST(memory_free_valid)
574 : {
575 : char* l_ptr;
576 : #ifndef NDEBUG
577 : size_t l_RAMSize;
578 : size_t l_NbBlocks;
579 66 : l_NbBlocks = memtrack_getallocatedblocks();
580 66 : l_RAMSize = memtrack_getallocatedRAM();
581 : #endif
582 :
583 66 : l_ptr=malloc(100);
584 : #ifndef NDEBUG
585 66 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
586 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
587 : #endif
588 66 : oomtest_fill(_i,2);
589 66 : free(l_ptr);
590 66 : oomtest_free();
591 66 : ck_assert(NULL!=l_ptr);
592 : #ifndef NDEBUG
593 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
594 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
595 : #endif
596 66 : }
597 : END_TEST
598 :
599 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
600 26 : START_TEST(memory_strdup_null)
601 : {
602 : void* l_result;
603 : size_t l_RAMSize;
604 : size_t l_NbBlocks;
605 :
606 26 : l_NbBlocks = memtrack_getallocatedblocks();
607 26 : l_RAMSize = memtrack_getallocatedRAM();
608 :
609 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
610 : * whole testsuite if not caught or not in a child process */
611 26 : forktest_only;
612 :
613 4 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
614 4 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
615 4 : oomtest_fill(_i,2);
616 : /* CppCheck warns about null pointer dereference, normal for this test */
617 4 : l_result=strdup(NULL); /* cppcheck-suppress nullPointer */
618 : /* Never reached, dead code */
619 : (void)l_result;
620 : }
621 : END_TEST
622 : #endif
623 :
624 66 : START_TEST(memory_strdup_empty)
625 : {
626 : char* l_result;
627 : #ifndef NDEBUG
628 : size_t l_RAMSize;
629 : size_t l_NbBlocks;
630 66 : l_NbBlocks = memtrack_getallocatedblocks();
631 66 : l_RAMSize = memtrack_getallocatedRAM();
632 : #endif
633 :
634 66 : l_result=NULL;
635 : #ifndef NDEBUG
636 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
637 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
638 : #endif
639 66 : oomtest_fill(_i,2);
640 66 : l_result=strdup("");
641 66 : oomtest_free();
642 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
643 66 : if (NULL!=l_result) {
644 : #ifndef NDEBUG
645 6 : ck_assert(l_RAMSize+1==memtrack_getallocatedRAM());
646 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
647 : #endif
648 6 : free(l_result);
649 : } else {
650 : #ifndef NDEBUG
651 60 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
652 60 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
653 : #endif
654 : }
655 66 : }
656 : END_TEST
657 :
658 66 : START_TEST(memory_strdup_value)
659 : {
660 66 : char *szLongString =
661 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
662 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
663 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
664 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
665 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
666 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
667 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
668 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
669 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
670 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
671 : ;
672 : char* l_result;
673 : #ifndef NDEBUG
674 : size_t l_RAMSize;
675 : size_t l_NbBlocks;
676 66 : l_NbBlocks = memtrack_getallocatedblocks();
677 66 : l_RAMSize = memtrack_getallocatedRAM();
678 : #endif
679 :
680 66 : l_result=NULL;
681 : #ifndef NDEBUG
682 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
683 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
684 : #endif
685 66 : oomtest_fill(_i,2);
686 66 : l_result=strdup(szLongString);
687 66 : oomtest_free();
688 66 : ck_assert((NULL!=l_result)||(oomtest_enabled()));
689 66 : if (NULL!=l_result) {
690 : #ifndef NDEBUG
691 6 : ck_assert(l_RAMSize+strlen(szLongString)+1==memtrack_getallocatedRAM());
692 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
693 : #endif
694 6 : free(l_result);
695 : } else {
696 : #ifndef NDEBUG
697 60 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
698 60 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
699 : #endif
700 : }
701 66 : }
702 : END_TEST
703 :
704 26 : START_TEST(memory_strdup_invalid)
705 : {
706 : void* l_result;
707 : #ifndef NDEBUG
708 : size_t l_RAMSize;
709 : size_t l_NbBlocks;
710 26 : l_NbBlocks = memtrack_getallocatedblocks();
711 26 : l_RAMSize = memtrack_getallocatedRAM();
712 : #endif
713 :
714 : /* This test is supposed to trigger a SIGABRT(6) and will crash the
715 : * whole testsuite if not caught or not in a child process */
716 26 : forktest_only;
717 :
718 : #ifndef NDEBUG
719 4 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
720 4 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
721 : #endif
722 4 : oomtest_fill(_i,2);
723 4 : l_result=strdup((void*)999);
724 : /* Never reached, dead code */
725 : (void)l_result;
726 : }
727 : END_TEST
728 :
729 66 : START_TEST(memory_strdup_oom)
730 : {
731 : char *szLongString;
732 : size_t szSize;
733 : char* l_result;
734 : #ifndef NDEBUG
735 : size_t l_RAMSize;
736 : size_t l_NbBlocks;
737 66 : l_NbBlocks = memtrack_getallocatedblocks();
738 66 : l_RAMSize = memtrack_getallocatedRAM();
739 : #endif
740 :
741 66 : l_result=NULL;
742 66 : szSize=RAMLIMIT_HARD;
743 : /* Find szSize value such as malloc(szSize) works, malloc(2*szSize) fails */
744 258 : while ((szSize>0)&&(NULL==(szLongString=malloc(szSize))))
745 192 : szSize /= 2;
746 66 : szLongString = memset(szLongString,'A',szSize-1);
747 66 : szLongString[szSize-1]=0;
748 : #ifndef NDEBUG
749 66 : ck_assert(l_RAMSize+szSize==memtrack_getallocatedRAM());
750 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
751 : #endif
752 66 : oomtest_fill(_i,2);
753 66 : l_result=strdup(szLongString);
754 66 : oomtest_free();
755 66 : ck_assert(NULL==l_result);
756 : #ifndef NDEBUG
757 66 : ck_assert(l_RAMSize+szSize==memtrack_getallocatedRAM());
758 66 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
759 : #endif
760 66 : free(szLongString);
761 66 : }
762 : END_TEST
763 :
764 66 : START_TEST(memory_asprintf)
765 : {
766 : int l_result;
767 : char* l_ptr;
768 66 : char *szLongString =
769 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
770 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
771 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
772 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
773 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
774 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
775 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
776 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
777 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
778 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
779 : ;
780 : #ifndef NDEBUG
781 : size_t l_RAMSize;
782 : size_t l_NbBlocks;
783 66 : l_NbBlocks = memtrack_getallocatedblocks();
784 66 : l_RAMSize = memtrack_getallocatedRAM();
785 : #endif
786 :
787 : /* String empty */
788 66 : l_result=0;
789 66 : l_ptr = NULL;
790 : #ifndef NDEBUG
791 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
792 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
793 : #endif
794 :
795 66 : oomtest_fill(_i,2);
796 66 : l_result = asprintf(&l_ptr,"%s","");
797 66 : oomtest_free();
798 66 : ck_assert((0==l_result)||(oomtest_enabled()));
799 66 : if (0==l_result) {
800 6 : ck_assert(NULL!=l_ptr);
801 6 : ck_assert(0==strcmp("",l_ptr));
802 : #ifndef NDEBUG
803 6 : ck_assert(l_RAMSize+1==memtrack_getallocatedRAM());
804 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
805 6 : ck_assert(1==memtrack_getblocksize(l_ptr));
806 : #endif
807 6 : free(l_ptr);
808 : }
809 :
810 : /* String value */
811 66 : l_result=0;
812 66 : l_ptr = NULL;
813 : #ifndef NDEBUG
814 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
815 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
816 : #endif
817 :
818 66 : oomtest_fill(_i,2);
819 66 : l_result = asprintf(&l_ptr,"%s",szLongString);
820 66 : oomtest_free();
821 66 : ck_assert((strlen(szLongString)==(size_t)l_result)||(oomtest_enabled()));
822 66 : if (strlen(szLongString)==(size_t)l_result) {
823 6 : ck_assert(NULL!=l_ptr);
824 6 : ck_assert(0==strcmp(szLongString,l_ptr));
825 : #ifndef NDEBUG
826 6 : ck_assert(l_RAMSize+1+strlen(szLongString)==memtrack_getallocatedRAM());
827 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
828 6 : ck_assert(1+strlen(szLongString)==memtrack_getblocksize(l_ptr));
829 : #endif
830 6 : free(l_ptr);
831 : }
832 :
833 : /* Numeric value */
834 66 : l_result=0;
835 66 : l_ptr = NULL;
836 : #ifndef NDEBUG
837 66 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
838 66 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
839 : #endif
840 :
841 66 : oomtest_fill(_i,2);
842 66 : l_result = asprintf(&l_ptr,"%d",123);
843 66 : oomtest_free();
844 66 : ck_assert((3==l_result)||(oomtest_enabled()));
845 66 : if (3==l_result) {
846 6 : ck_assert(NULL!=l_ptr);
847 6 : ck_assert(0==strcmp("123",l_ptr));
848 : #ifndef NDEBUG
849 6 : ck_assert(l_RAMSize+4==memtrack_getallocatedRAM());
850 6 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
851 6 : ck_assert(4==memtrack_getblocksize(l_ptr));
852 : #endif
853 6 : free(l_ptr);
854 : }
855 66 : }
856 : END_TEST
857 :
858 66 : START_TEST(memory_memreport)
859 : {
860 66 : oomtest_fill(_i,2);
861 66 : memreport();
862 66 : oomtest_free();
863 66 : }
864 : END_TEST
865 :
866 : /************************************************************************/
867 851 : void memory_checked_uninitialized_setup()
868 : {
869 851 : signals_catch();
870 851 : forktest_gprofdir();
871 851 : }
872 759 : void memory_checked_uninitialized_teardown()
873 : {
874 759 : signals_release();
875 : #ifndef NDEBUG
876 759 : ck_assert(0==memtrack_getallocatedblocks());
877 : #endif /* NDEBUG */
878 759 : }
879 :
880 : #define DATASIZE 5
881 : #define DATACOUNT 5
882 : char* data[DATACOUNT];
883 851 : void memory_checked_withdata_setup()
884 : {
885 : unsigned int i;
886 851 : signals_catch();
887 851 : forktest_gprofdir();
888 5106 : for (i=0; i<DATACOUNT; i++)
889 4255 : data[i]=malloc(DATASIZE);
890 851 : }
891 759 : void memory_checked_withdata_teardown()
892 : {
893 : unsigned int i;
894 759 : signals_release();
895 4554 : for (i=0; i<DATACOUNT; i++)
896 3795 : free(data[i]);
897 759 : }
898 : /************************************************************************/
899 8690 : void memory_unchecked_common_setup()
900 : {
901 8690 : forktest_init();
902 8690 : }
903 7582 : void memory_unchecked_common_teardown()
904 : {
905 7582 : }
906 4014 : void memory_unchecked_oom_setup()
907 : {
908 4014 : oomtest_enable(RAMLIMIT_SOFT);
909 4014 : memory_unchecked_common_setup();
910 4014 : }
911 3014 : void memory_unchecked_oom_teardown()
912 : {
913 3014 : oomtest_disable();
914 3014 : memory_unchecked_common_teardown();
915 3014 : }
916 : /************************************************************************/
917 3909 : Suite* libdebug_memory_suite()
918 : {
919 : Suite *s;
920 : TCase *tc;
921 :
922 3909 : s = suite_create("LibDebug-Memory");
923 3909 : tc = tcase_create("Uninitialized");
924 3909 : tcase_add_checked_fixture(tc, memory_checked_uninitialized_setup, memory_checked_uninitialized_teardown);
925 3909 : tcase_add_unchecked_fixture(tc, memory_unchecked_common_setup, memory_unchecked_common_teardown);
926 3909 : suite_add_tcase(s, tc);
927 3909 : tcase_add_test(tc, memory_malloc_0);
928 3909 : tcase_add_test(tc, memory_malloc_100);
929 3909 : tcase_add_test(tc, memory_malloc_oom);
930 3909 : tcase_add_test(tc, memory_realloc_null_0);
931 3909 : tcase_add_test(tc, memory_realloc_null_100);
932 3909 : tcase_add_test(tc, memory_realloc_null_oom);
933 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
934 3909 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_0,6);
935 3909 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_100,6);
936 3909 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_oom,6);
937 : #endif
938 3909 : tcase_add_test(tc, memory_realloc_valid_0);
939 3909 : tcase_add_test(tc, memory_realloc_valid_updown);
940 3909 : tcase_add_test(tc, memory_realloc_valid_oom);
941 3909 : tcase_add_test(tc, memory_calloc_0_0);
942 3909 : tcase_add_test(tc, memory_calloc_0_100);
943 3909 : tcase_add_test(tc, memory_calloc_100_0);
944 3909 : tcase_add_test(tc, memory_calloc_100_100);
945 3909 : tcase_add_test(tc, memory_calloc_oom);
946 3909 : tcase_add_test(tc, memory_free_null);
947 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
948 3909 : tcase_add_test_raise_signal(tc, memory_free_invalid,6);
949 : #endif
950 3909 : tcase_add_test(tc, memory_free_valid);
951 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
952 3909 : tcase_add_test_raise_signal(tc, memory_strdup_null,11);
953 : #endif
954 3909 : tcase_add_test(tc, memory_strdup_empty);
955 3909 : tcase_add_test(tc, memory_strdup_value);
956 3909 : tcase_add_test_raise_signal(tc, memory_strdup_invalid,11);
957 3909 : tcase_add_test(tc, memory_strdup_oom);
958 3909 : tcase_add_test(tc, memory_asprintf);
959 3909 : tcase_add_test(tc, memory_memreport);
960 :
961 3909 : tc = tcase_create("WithData");
962 3909 : tcase_add_checked_fixture(tc, memory_checked_withdata_setup, memory_checked_withdata_teardown);
963 3909 : tcase_add_unchecked_fixture(tc, memory_unchecked_common_setup, memory_unchecked_common_teardown);
964 3909 : suite_add_tcase(s, tc);
965 3909 : tcase_add_test(tc, memory_malloc_0);
966 3909 : tcase_add_test(tc, memory_malloc_100);
967 3909 : tcase_add_test(tc, memory_malloc_oom);
968 3909 : tcase_add_test(tc, memory_realloc_null_0);
969 3909 : tcase_add_test(tc, memory_realloc_null_100);
970 3909 : tcase_add_test(tc, memory_realloc_null_oom);
971 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
972 3909 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_0,6);
973 3909 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_100,6);
974 3909 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_oom,6);
975 : #endif
976 3909 : tcase_add_test(tc, memory_realloc_valid_0);
977 3909 : tcase_add_test(tc, memory_realloc_valid_updown);
978 3909 : tcase_add_test(tc, memory_realloc_valid_oom);
979 3909 : tcase_add_test(tc, memory_calloc_0_0);
980 3909 : tcase_add_test(tc, memory_calloc_0_100);
981 3909 : tcase_add_test(tc, memory_calloc_100_0);
982 3909 : tcase_add_test(tc, memory_calloc_100_100);
983 3909 : tcase_add_test(tc, memory_calloc_oom);
984 3909 : tcase_add_test(tc, memory_free_null);
985 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
986 3909 : tcase_add_test_raise_signal(tc, memory_free_invalid,6);
987 : #endif
988 3909 : tcase_add_test(tc, memory_free_valid);
989 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
990 3909 : tcase_add_test_raise_signal(tc, memory_strdup_null,11);
991 : #endif
992 3909 : tcase_add_test(tc, memory_strdup_empty);
993 3909 : tcase_add_test(tc, memory_strdup_value);
994 3909 : tcase_add_test_raise_signal(tc, memory_strdup_invalid,11);
995 3909 : tcase_add_test(tc, memory_strdup_oom);
996 3909 : tcase_add_test(tc, memory_asprintf);
997 3909 : tcase_add_test(tc, memory_memreport);
998 :
999 3909 : tc = tcase_create("Uninitialized-OOM");
1000 3909 : tcase_set_tags(tc,"oom");
1001 3909 : tcase_add_checked_fixture(tc, memory_checked_uninitialized_setup, memory_checked_uninitialized_teardown);
1002 3909 : tcase_add_unchecked_fixture(tc, memory_unchecked_oom_setup, memory_unchecked_oom_teardown);
1003 3909 : suite_add_tcase(s, tc);
1004 3909 : tcase_add_loop_test(tc, memory_malloc_0, 0, 10);
1005 3909 : tcase_add_loop_test(tc, memory_malloc_100, 0, 10);
1006 3909 : tcase_add_loop_test(tc, memory_malloc_oom, 0, 10);
1007 3909 : tcase_add_loop_test(tc, memory_realloc_null_0, 0, 10);
1008 3909 : tcase_add_loop_test(tc, memory_realloc_null_100, 0, 10);
1009 3909 : tcase_add_loop_test(tc, memory_realloc_null_oom, 0, 10);
1010 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1011 3909 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_0,6, 0, 10);
1012 3909 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_100,6, 0, 10);
1013 3909 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_oom,6, 0, 10);
1014 : #endif
1015 3909 : tcase_add_loop_test(tc, memory_realloc_valid_0, 0, 10);
1016 3909 : tcase_add_loop_test(tc, memory_realloc_valid_updown, 0, 10);
1017 3909 : tcase_add_loop_test(tc, memory_realloc_valid_oom, 0, 10);
1018 3909 : tcase_add_loop_test(tc, memory_calloc_0_0, 0, 10);
1019 3909 : tcase_add_loop_test(tc, memory_calloc_0_100, 0, 10);
1020 3909 : tcase_add_loop_test(tc, memory_calloc_100_0, 0, 10);
1021 3909 : tcase_add_loop_test(tc, memory_calloc_100_100, 0, 10);
1022 3909 : tcase_add_loop_test(tc, memory_calloc_oom, 0, 10);
1023 3909 : tcase_add_loop_test(tc, memory_free_null, 0, 10);
1024 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1025 3909 : tcase_add_loop_test_raise_signal(tc, memory_free_invalid,6, 0, 10);
1026 : #endif
1027 3909 : tcase_add_loop_test(tc, memory_free_valid, 0, 10);
1028 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
1029 3909 : tcase_add_loop_test_raise_signal(tc, memory_strdup_null,11, 0, 10);
1030 : #endif
1031 3909 : tcase_add_loop_test(tc, memory_strdup_empty, 0, 10);
1032 3909 : tcase_add_loop_test(tc, memory_strdup_value, 0, 10);
1033 3909 : tcase_add_loop_test_raise_signal(tc, memory_strdup_invalid,11, 0, 10);
1034 3909 : tcase_add_loop_test(tc, memory_strdup_oom, 0, 10);
1035 3909 : tcase_add_loop_test(tc, memory_asprintf, 0, 10);
1036 3909 : tcase_add_loop_test(tc, memory_memreport, 0, 10);
1037 :
1038 3909 : tc = tcase_create("WithData-OOM");
1039 3909 : tcase_set_tags(tc,"oom");
1040 3909 : tcase_add_checked_fixture(tc, memory_checked_withdata_setup, memory_checked_withdata_teardown);
1041 3909 : tcase_add_unchecked_fixture(tc, memory_unchecked_oom_setup, memory_unchecked_oom_teardown);
1042 3909 : suite_add_tcase(s, tc);
1043 3909 : tcase_add_loop_test(tc, memory_malloc_0, 0, 10);
1044 3909 : tcase_add_loop_test(tc, memory_malloc_100, 0, 10);
1045 3909 : tcase_add_loop_test(tc, memory_malloc_oom, 0, 10);
1046 3909 : tcase_add_loop_test(tc, memory_realloc_null_0, 0, 10);
1047 3909 : tcase_add_loop_test(tc, memory_realloc_null_100, 0, 10);
1048 3909 : tcase_add_loop_test(tc, memory_realloc_null_oom, 0, 10);
1049 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1050 3909 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_0,6, 0, 10);
1051 3909 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_100,6, 0, 10);
1052 3909 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_oom,6, 0, 10);
1053 : #endif
1054 3909 : tcase_add_loop_test(tc, memory_realloc_valid_0, 0, 10);
1055 3909 : tcase_add_loop_test(tc, memory_realloc_valid_updown, 0, 10);
1056 3909 : tcase_add_loop_test(tc, memory_realloc_valid_oom, 0, 10);
1057 3909 : tcase_add_loop_test(tc, memory_calloc_0_0, 0, 10);
1058 3909 : tcase_add_loop_test(tc, memory_calloc_0_100, 0, 10);
1059 3909 : tcase_add_loop_test(tc, memory_calloc_100_0, 0, 10);
1060 3909 : tcase_add_loop_test(tc, memory_calloc_100_100, 0, 10);
1061 3909 : tcase_add_loop_test(tc, memory_calloc_oom, 0, 10);
1062 3909 : tcase_add_loop_test(tc, memory_free_null, 0, 10);
1063 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1064 3909 : tcase_add_loop_test_raise_signal(tc, memory_free_invalid,6, 0, 10);
1065 : #endif
1066 3909 : tcase_add_loop_test(tc, memory_free_valid, 0, 10);
1067 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
1068 3909 : tcase_add_loop_test_raise_signal(tc, memory_strdup_null,11, 0, 10);
1069 : #endif
1070 3909 : tcase_add_loop_test(tc, memory_strdup_empty, 0, 10);
1071 3909 : tcase_add_loop_test(tc, memory_strdup_value, 0, 10);
1072 3909 : tcase_add_loop_test_raise_signal(tc, memory_strdup_invalid,11, 0, 10);
1073 3909 : tcase_add_loop_test(tc, memory_strdup_oom, 0, 10);
1074 3909 : tcase_add_loop_test(tc, memory_asprintf, 0, 10);
1075 3909 : tcase_add_loop_test(tc, memory_memreport, 0, 10);
1076 :
1077 3909 : return s;
1078 : }
1079 :
|
