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 : l_NbBlocks = memtrack_getallocatedblocks();
39 : 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 : ck_assert(NULL==l_result);
49 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
50 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
51 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
64 : 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 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
75 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
76 : ck_assert(100==memtrack_getblocksize(l_result));
77 : #endif
78 54 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
91 : 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 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
102 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
103 : #endif
104 6 : free(l_result);
105 : }
106 : #ifndef NDEBUG
107 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
108 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
122 : 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 : ck_assert(NULL==l_result);
134 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
135 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
136 : #endif
137 66 : if (NULL!=l_result)
138 60 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
151 : 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 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
164 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
165 : ck_assert(100==memtrack_getblocksize(l_result));
166 : #endif
167 46 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
181 : 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 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
193 : 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 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
200 : 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 : 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 : forktest_only;
214 :
215 : l_ptr=(void*)999;
216 : #ifdef GCOV
217 : if (oomtest_enabled())
218 : __gcov_dump();
219 : #endif
220 : oomtest_fill(_i,2);
221 : 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 : 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 : forktest_only;
237 :
238 : l_ptr=(void*)999;
239 : #ifdef GCOV
240 : if (oomtest_enabled())
241 : __gcov_dump();
242 : #endif
243 : oomtest_fill(_i,2);
244 : 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 : 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 : forktest_only;
260 :
261 : l_ptr=(void*)999;
262 : #ifdef GCOV
263 : if (oomtest_enabled())
264 : __gcov_dump();
265 : #endif
266 : oomtest_fill(_i,2);
267 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
282 : l_RAMSize = memtrack_getallocatedRAM();
283 : #endif
284 :
285 66 : l_ptr=malloc(100);
286 : #ifndef NDEBUG
287 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
288 : 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 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
297 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
310 : l_RAMSize = memtrack_getallocatedRAM();
311 : #endif
312 :
313 66 : l_result=NULL;
314 66 : l_ptr=malloc(100);
315 : #ifndef NDEBUG
316 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
317 : 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 : ck_assert(l_RAMSize+1000==memtrack_getallocatedRAM());
328 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
329 : 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 0 : l_result = realloc(l_ptr,10);
340 : #ifndef NDEBUG
341 : ck_assert(l_RAMSize+10==memtrack_getallocatedRAM());
342 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
343 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
358 : l_RAMSize = memtrack_getallocatedRAM();
359 : #endif
360 :
361 66 : l_result=NULL;
362 66 : l_ptr=malloc(100);
363 : #ifndef NDEBUG
364 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
365 : 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 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
374 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
375 : ck_assert(RAMLIMIT_SOFT/2==memtrack_getblocksize(l_result));
376 : #endif
377 6 : l_ptr=l_result;
378 : } else {
379 : #ifndef NDEBUG
380 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
381 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
382 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
404 : 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 : ck_assert(NULL==l_result);
414 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
415 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
416 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
430 : 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 : ck_assert(NULL==l_result);
440 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
441 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
442 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
456 : 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 : ck_assert(NULL==l_result);
466 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
467 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
468 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
482 : 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 : ck_assert(l_RAMSize+10000==memtrack_getallocatedRAM());
493 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
494 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
509 : 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 : ck_assert(l_RAMSize+RAMLIMIT_SOFT/2==memtrack_getallocatedRAM());
520 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
521 : #endif
522 6 : free(l_result);
523 : }
524 : #ifndef NDEBUG
525 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
526 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
538 : 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 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
548 : 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 : START_TEST(memory_free_invalid)
555 : {
556 : char* l_ptr;
557 :
558 : 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 : forktest_only;
562 :
563 : #ifdef GCOV
564 : if (oomtest_enabled())
565 : __gcov_dump();
566 : #endif
567 : oomtest_fill(_i,2);
568 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
580 : l_RAMSize = memtrack_getallocatedRAM();
581 : #endif
582 :
583 66 : l_ptr=malloc(100);
584 : #ifndef NDEBUG
585 : ck_assert(l_RAMSize+100==memtrack_getallocatedRAM());
586 : 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 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
594 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
595 : #endif
596 66 : }
597 : END_TEST
598 :
599 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
600 : START_TEST(memory_strdup_null)
601 : {
602 : void* l_result;
603 : size_t l_RAMSize;
604 : size_t l_NbBlocks;
605 :
606 : l_NbBlocks = memtrack_getallocatedblocks();
607 : 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 : forktest_only;
612 :
613 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
614 : ck_assert(l_NbBlocks==memtrack_getallocatedblocks());
615 : oomtest_fill(_i,2);
616 : /* CppCheck warns about null pointer dereference, normal for this test */
617 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
631 : l_RAMSize = memtrack_getallocatedRAM();
632 : #endif
633 :
634 66 : l_result=NULL;
635 : #ifndef NDEBUG
636 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
637 : 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 : ck_assert(l_RAMSize+1==memtrack_getallocatedRAM());
646 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
647 : #endif
648 60 : free(l_result);
649 : } else {
650 : #ifndef NDEBUG
651 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
652 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
677 : l_RAMSize = memtrack_getallocatedRAM();
678 : #endif
679 :
680 66 : l_result=NULL;
681 : #ifndef NDEBUG
682 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
683 : 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 : ck_assert(l_RAMSize+strlen(szLongString)+1==memtrack_getallocatedRAM());
692 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
693 : #endif
694 26 : free(l_result);
695 : } else {
696 : #ifndef NDEBUG
697 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
698 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
711 : 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 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
720 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
738 : 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 252 : while ((szSize>0)&&(NULL==(szLongString=malloc(szSize))))
745 186 : szSize /= 2;
746 66 : szLongString = memset(szLongString,'A',szSize-1);
747 66 : szLongString[szSize-1]=0;
748 : #ifndef NDEBUG
749 : ck_assert(l_RAMSize+szSize==memtrack_getallocatedRAM());
750 : 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 : ck_assert(l_RAMSize+szSize==memtrack_getallocatedRAM());
758 : 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 : l_NbBlocks = memtrack_getallocatedblocks();
784 : l_RAMSize = memtrack_getallocatedRAM();
785 : #endif
786 :
787 : /* String empty */
788 66 : l_result=0;
789 66 : l_ptr = NULL;
790 : #ifndef NDEBUG
791 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
792 : 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 46 : ck_assert(NULL!=l_ptr);
801 46 : ck_assert(0==strcmp("",l_ptr));
802 : #ifndef NDEBUG
803 : ck_assert(l_RAMSize+1==memtrack_getallocatedRAM());
804 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
805 : ck_assert(1==memtrack_getblocksize(l_ptr));
806 : #endif
807 46 : free(l_ptr);
808 : }
809 :
810 : /* String value */
811 66 : l_result=0;
812 66 : l_ptr = NULL;
813 : #ifndef NDEBUG
814 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
815 : 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 : ck_assert(l_RAMSize+1+strlen(szLongString)==memtrack_getallocatedRAM());
827 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
828 : 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 : ck_assert(l_RAMSize==memtrack_getallocatedRAM());
838 : 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 42 : ck_assert(NULL!=l_ptr);
847 42 : ck_assert(0==strcmp("123",l_ptr));
848 : #ifndef NDEBUG
849 : ck_assert(l_RAMSize+4==memtrack_getallocatedRAM());
850 : ck_assert(l_NbBlocks+1==memtrack_getallocatedblocks());
851 : ck_assert(4==memtrack_getblocksize(l_ptr));
852 : #endif
853 42 : free(l_ptr);
854 : }
855 66 : }
856 : END_TEST
857 :
858 66 : START_TEST(memory_memreport)
859 : {
860 66 : oomtest_fill(_i,2);
861 : memreport();
862 66 : oomtest_free();
863 66 : }
864 : END_TEST
865 :
866 : /************************************************************************/
867 706 : void memory_checked_uninitialized_setup()
868 : {
869 706 : signals_catch();
870 706 : forktest_gprofdir();
871 706 : }
872 704 : void memory_checked_uninitialized_teardown()
873 : {
874 704 : signals_release();
875 : #ifndef NDEBUG
876 : ck_assert(0==memtrack_getallocatedblocks());
877 : #endif /* NDEBUG */
878 704 : }
879 :
880 : #define DATASIZE 5
881 : #define DATACOUNT 5
882 : char* data[DATACOUNT];
883 706 : void memory_checked_withdata_setup()
884 : {
885 : unsigned int i;
886 706 : signals_catch();
887 706 : forktest_gprofdir();
888 4236 : for (i=0; i<DATACOUNT; i++)
889 3530 : data[i]=malloc(DATASIZE);
890 706 : }
891 704 : void memory_checked_withdata_teardown()
892 : {
893 : unsigned int i;
894 704 : signals_release();
895 4224 : for (i=0; i<DATACOUNT; i++)
896 3520 : free(data[i]);
897 704 : }
898 : /************************************************************************/
899 5108 : void memory_unchecked_common_setup()
900 : {
901 5108 : forktest_init();
902 5108 : }
903 4180 : void memory_unchecked_common_teardown()
904 : {
905 4180 : }
906 2278 : void memory_unchecked_oom_setup()
907 : {
908 2278 : oomtest_enable(RAMLIMIT_SOFT);
909 2278 : memory_unchecked_common_setup();
910 2278 : }
911 1438 : void memory_unchecked_oom_teardown()
912 : {
913 1438 : oomtest_disable();
914 1438 : memory_unchecked_common_teardown();
915 1438 : }
916 : /************************************************************************/
917 1441 : Suite* libdebug_memory_suite()
918 : {
919 : Suite *s;
920 : TCase *tc;
921 :
922 1441 : s = suite_create("LibDebug-Memory");
923 1441 : tc = tcase_create("Uninitialized");
924 1441 : tcase_add_checked_fixture(tc, memory_checked_uninitialized_setup, memory_checked_uninitialized_teardown);
925 1441 : tcase_add_unchecked_fixture(tc, memory_unchecked_common_setup, memory_unchecked_common_teardown);
926 1441 : suite_add_tcase(s, tc);
927 1441 : tcase_add_test(tc, memory_malloc_0);
928 1441 : tcase_add_test(tc, memory_malloc_100);
929 1441 : tcase_add_test(tc, memory_malloc_oom);
930 1441 : tcase_add_test(tc, memory_realloc_null_0);
931 1441 : tcase_add_test(tc, memory_realloc_null_100);
932 1441 : tcase_add_test(tc, memory_realloc_null_oom);
933 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
934 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_0,6);
935 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_100,6);
936 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_oom,6);
937 : #endif
938 1441 : tcase_add_test(tc, memory_realloc_valid_0);
939 1441 : tcase_add_test(tc, memory_realloc_valid_updown);
940 1441 : tcase_add_test(tc, memory_realloc_valid_oom);
941 1441 : tcase_add_test(tc, memory_calloc_0_0);
942 1441 : tcase_add_test(tc, memory_calloc_0_100);
943 1441 : tcase_add_test(tc, memory_calloc_100_0);
944 1441 : tcase_add_test(tc, memory_calloc_100_100);
945 1441 : tcase_add_test(tc, memory_calloc_oom);
946 1441 : tcase_add_test(tc, memory_free_null);
947 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
948 : tcase_add_test_raise_signal(tc, memory_free_invalid,6);
949 : #endif
950 1441 : tcase_add_test(tc, memory_free_valid);
951 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
952 : tcase_add_test_raise_signal(tc, memory_strdup_null,11);
953 : #endif
954 1441 : tcase_add_test(tc, memory_strdup_empty);
955 1441 : tcase_add_test(tc, memory_strdup_value);
956 1441 : tcase_add_test_raise_signal(tc, memory_strdup_invalid,11);
957 1441 : tcase_add_test(tc, memory_strdup_oom);
958 1441 : tcase_add_test(tc, memory_asprintf);
959 1441 : tcase_add_test(tc, memory_memreport);
960 :
961 1441 : tc = tcase_create("WithData");
962 1441 : tcase_add_checked_fixture(tc, memory_checked_withdata_setup, memory_checked_withdata_teardown);
963 1441 : tcase_add_unchecked_fixture(tc, memory_unchecked_common_setup, memory_unchecked_common_teardown);
964 1441 : suite_add_tcase(s, tc);
965 1441 : tcase_add_test(tc, memory_malloc_0);
966 1441 : tcase_add_test(tc, memory_malloc_100);
967 1441 : tcase_add_test(tc, memory_malloc_oom);
968 1441 : tcase_add_test(tc, memory_realloc_null_0);
969 1441 : tcase_add_test(tc, memory_realloc_null_100);
970 1441 : tcase_add_test(tc, memory_realloc_null_oom);
971 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
972 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_0,6);
973 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_100,6);
974 : tcase_add_test_raise_signal(tc, memory_realloc_invalid_oom,6);
975 : #endif
976 1441 : tcase_add_test(tc, memory_realloc_valid_0);
977 1441 : tcase_add_test(tc, memory_realloc_valid_updown);
978 1441 : tcase_add_test(tc, memory_realloc_valid_oom);
979 1441 : tcase_add_test(tc, memory_calloc_0_0);
980 1441 : tcase_add_test(tc, memory_calloc_0_100);
981 1441 : tcase_add_test(tc, memory_calloc_100_0);
982 1441 : tcase_add_test(tc, memory_calloc_100_100);
983 1441 : tcase_add_test(tc, memory_calloc_oom);
984 1441 : tcase_add_test(tc, memory_free_null);
985 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
986 : tcase_add_test_raise_signal(tc, memory_free_invalid,6);
987 : #endif
988 1441 : tcase_add_test(tc, memory_free_valid);
989 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
990 : tcase_add_test_raise_signal(tc, memory_strdup_null,11);
991 : #endif
992 1441 : tcase_add_test(tc, memory_strdup_empty);
993 1441 : tcase_add_test(tc, memory_strdup_value);
994 1441 : tcase_add_test_raise_signal(tc, memory_strdup_invalid,11);
995 1441 : tcase_add_test(tc, memory_strdup_oom);
996 1441 : tcase_add_test(tc, memory_asprintf);
997 1441 : tcase_add_test(tc, memory_memreport);
998 :
999 1441 : tc = tcase_create("Uninitialized-OOM");
1000 1441 : tcase_set_tags(tc,"oom");
1001 1441 : tcase_add_checked_fixture(tc, memory_checked_uninitialized_setup, memory_checked_uninitialized_teardown);
1002 1441 : tcase_add_unchecked_fixture(tc, memory_unchecked_oom_setup, memory_unchecked_oom_teardown);
1003 1441 : suite_add_tcase(s, tc);
1004 1441 : tcase_add_loop_test(tc, memory_malloc_0, 0, 10);
1005 1441 : tcase_add_loop_test(tc, memory_malloc_100, 0, 10);
1006 1441 : tcase_add_loop_test(tc, memory_malloc_oom, 0, 10);
1007 1441 : tcase_add_loop_test(tc, memory_realloc_null_0, 0, 10);
1008 1441 : tcase_add_loop_test(tc, memory_realloc_null_100, 0, 10);
1009 1441 : tcase_add_loop_test(tc, memory_realloc_null_oom, 0, 10);
1010 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1011 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_0,6, 0, 10);
1012 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_100,6, 0, 10);
1013 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_oom,6, 0, 10);
1014 : #endif
1015 1441 : tcase_add_loop_test(tc, memory_realloc_valid_0, 0, 10);
1016 1441 : tcase_add_loop_test(tc, memory_realloc_valid_updown, 0, 10);
1017 1441 : tcase_add_loop_test(tc, memory_realloc_valid_oom, 0, 10);
1018 1441 : tcase_add_loop_test(tc, memory_calloc_0_0, 0, 10);
1019 1441 : tcase_add_loop_test(tc, memory_calloc_0_100, 0, 10);
1020 1441 : tcase_add_loop_test(tc, memory_calloc_100_0, 0, 10);
1021 1441 : tcase_add_loop_test(tc, memory_calloc_100_100, 0, 10);
1022 1441 : tcase_add_loop_test(tc, memory_calloc_oom, 0, 10);
1023 1441 : tcase_add_loop_test(tc, memory_free_null, 0, 10);
1024 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1025 : tcase_add_loop_test_raise_signal(tc, memory_free_invalid,6, 0, 10);
1026 : #endif
1027 1441 : tcase_add_loop_test(tc, memory_free_valid, 0, 10);
1028 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
1029 : tcase_add_loop_test_raise_signal(tc, memory_strdup_null,11, 0, 10);
1030 : #endif
1031 1441 : tcase_add_loop_test(tc, memory_strdup_empty, 0, 10);
1032 1441 : tcase_add_loop_test(tc, memory_strdup_value, 0, 10);
1033 1441 : tcase_add_loop_test_raise_signal(tc, memory_strdup_invalid,11, 0, 10);
1034 1441 : tcase_add_loop_test(tc, memory_strdup_oom, 0, 10);
1035 1441 : tcase_add_loop_test(tc, memory_asprintf, 0, 10);
1036 1441 : tcase_add_loop_test(tc, memory_memreport, 0, 10);
1037 :
1038 1441 : tc = tcase_create("WithData-OOM");
1039 1441 : tcase_set_tags(tc,"oom");
1040 1441 : tcase_add_checked_fixture(tc, memory_checked_withdata_setup, memory_checked_withdata_teardown);
1041 1441 : tcase_add_unchecked_fixture(tc, memory_unchecked_oom_setup, memory_unchecked_oom_teardown);
1042 1441 : suite_add_tcase(s, tc);
1043 1441 : tcase_add_loop_test(tc, memory_malloc_0, 0, 10);
1044 1441 : tcase_add_loop_test(tc, memory_malloc_100, 0, 10);
1045 1441 : tcase_add_loop_test(tc, memory_malloc_oom, 0, 10);
1046 1441 : tcase_add_loop_test(tc, memory_realloc_null_0, 0, 10);
1047 1441 : tcase_add_loop_test(tc, memory_realloc_null_100, 0, 10);
1048 1441 : tcase_add_loop_test(tc, memory_realloc_null_oom, 0, 10);
1049 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1050 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_0,6, 0, 10);
1051 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_100,6, 0, 10);
1052 : tcase_add_loop_test_raise_signal(tc, memory_realloc_invalid_oom,6, 0, 10);
1053 : #endif
1054 1441 : tcase_add_loop_test(tc, memory_realloc_valid_0, 0, 10);
1055 1441 : tcase_add_loop_test(tc, memory_realloc_valid_updown, 0, 10);
1056 1441 : tcase_add_loop_test(tc, memory_realloc_valid_oom, 0, 10);
1057 1441 : tcase_add_loop_test(tc, memory_calloc_0_0, 0, 10);
1058 1441 : tcase_add_loop_test(tc, memory_calloc_0_100, 0, 10);
1059 1441 : tcase_add_loop_test(tc, memory_calloc_100_0, 0, 10);
1060 1441 : tcase_add_loop_test(tc, memory_calloc_100_100, 0, 10);
1061 1441 : tcase_add_loop_test(tc, memory_calloc_oom, 0, 10);
1062 1441 : tcase_add_loop_test(tc, memory_free_null, 0, 10);
1063 : #ifndef NDEBUG /* Free non-heap pointer caught by gcc */
1064 : tcase_add_loop_test_raise_signal(tc, memory_free_invalid,6, 0, 10);
1065 : #endif
1066 1441 : tcase_add_loop_test(tc, memory_free_valid, 0, 10);
1067 : #ifndef NDEBUG /* strdup(NULL) caught by gcc */
1068 : tcase_add_loop_test_raise_signal(tc, memory_strdup_null,11, 0, 10);
1069 : #endif
1070 1441 : tcase_add_loop_test(tc, memory_strdup_empty, 0, 10);
1071 1441 : tcase_add_loop_test(tc, memory_strdup_value, 0, 10);
1072 1441 : tcase_add_loop_test_raise_signal(tc, memory_strdup_invalid,11, 0, 10);
1073 1441 : tcase_add_loop_test(tc, memory_strdup_oom, 0, 10);
1074 1441 : tcase_add_loop_test(tc, memory_asprintf, 0, 10);
1075 1441 : tcase_add_loop_test(tc, memory_memreport, 0, 10);
1076 :
1077 1441 : return s;
1078 : }
1079 :
|
