Line data Source code
1 : /** @file suite_libdebug-memtrack.c
2 : * @brief Check Libdebug memtrack functions
3 : * @author François Cerbelle (Fanfan), francois@cerbelle.net
4 : *
5 : * @internal
6 : * Created: 24/06/2024
7 : * Revision: none
8 : * Last modified: 2024-12-19 19:51
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 : #define _XOPEN_SOURCE 500 /* snprintf */
22 : #include "libdebug/memtrack.h"
23 : #include "oom.h" /* oomfill_setup */
24 : #include <check.h>
25 : #include <unistd.h> /* pid_t getpid() */
26 : #include <sys/stat.h> /* mkdir(), chdir(), mode_t */
27 : #include <stdio.h> /* fprintf */
28 : #include <stdlib.h> /* abort() */
29 : #include "checktools.inc"
30 :
31 : #ifndef NDEBUG
32 : extern void memtrack_reset();
33 : #endif
34 :
35 : #ifndef NDEBUG
36 3 : START_TEST(getallocatedRAM_first) {
37 : unsigned int l_result;
38 :
39 : oomfill_fill(_i*sizeof(TMemBlock),2);
40 3 : l_result=memtrack_getallocatedRAM();
41 : oomfill_free();
42 : /* Always 0, except when initialized WithData */
43 : /* Uninitialized returns 0, Initialized returns 0, OOM uninitialized returns 0 */
44 3 : ck_assert(0==l_result);
45 3 : }
46 : END_TEST
47 : #endif /* NDEBUG */
48 :
49 : #ifndef NDEBUG
50 3 : START_TEST(getallocatedblocks_first) {
51 : unsigned int l_result;
52 : oomfill_fill(_i*sizeof(TMemBlock),2);
53 3 : l_result = memtrack_getallocatedblocks();
54 : oomfill_free();
55 : /* Always 0, except when initialized WithData */
56 : /* Uninitialized returns 0, Initialized returns 0, OOM uninitialized returns 0 */
57 3 : ck_assert(l_result==0);
58 3 : }
59 : END_TEST
60 : #endif /* NDEBUG */
61 :
62 : #ifndef NDEBUG
63 6 : START_TEST(getblocksize_first) {
64 : size_t l_result;
65 :
66 : oomfill_fill(_i*sizeof(TMemBlock),2);
67 6 : l_result = memtrack_getblocksize(NULL);
68 : oomfill_free();
69 : /* Always 0, because asking for "NULL" size */
70 6 : ck_assert(0==l_result);
71 6 : }
72 : END_TEST
73 : #endif /* NDEBUG */
74 :
75 : #ifndef NDEBUG
76 6 : START_TEST(getblocksize_null) {
77 : uint64_t l_NbBlocks;
78 : size_t l_BlockSize;
79 : size_t l_RAMSize;
80 :
81 : /* LibMemTrack consistency check preparation */
82 6 : l_NbBlocks=memtrack_getallocatedblocks();
83 6 : l_RAMSize=memtrack_getallocatedRAM();
84 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
85 :
86 : /* Run tests under constraint */
87 : /* Already initialized in previous lines, thus no need for allocation */
88 : oomfill_fill(_i,2);
89 6 : l_BlockSize=memtrack_getblocksize(NULL);
90 : oomfill_free();
91 :
92 : /* Check expected results */
93 6 : ck_assert_msg(0==l_BlockSize,"Blocksize of NULL pointer should be 0");
94 :
95 : /* Check no new block registered */
96 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
97 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
98 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
99 6 : }
100 : END_TEST
101 : #endif /* NDEBUG */
102 :
103 : #ifndef NDEBUG
104 6 : START_TEST(getblocksize_missing) {
105 : uint64_t l_NbBlocks;
106 : size_t l_BlockSize;
107 : size_t l_RAMSize;
108 :
109 : /* LibMemTrack consistency check preparation */
110 6 : l_NbBlocks=memtrack_getallocatedblocks();
111 6 : l_RAMSize=memtrack_getallocatedRAM();
112 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
113 :
114 : /* Already initialized in previous lines, thus no need for allocation */
115 : oomfill_fill(_i,2);
116 6 : l_BlockSize=memtrack_getblocksize((void*)999);
117 : oomfill_free();
118 :
119 : /* Check results */
120 6 : ck_assert_msg(0==l_BlockSize,"Blocksize of missing pointer should be 0");
121 :
122 : /* Check no new block registered */
123 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
124 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
125 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
126 6 : }
127 : END_TEST
128 : #endif /* NDEBUG */
129 :
130 : #ifndef NDEBUG
131 6 : START_TEST(addblock_null_first) {
132 : unsigned int l_result;
133 :
134 : /* First test to trigger autoinit */
135 : /* Try to create/update a new blocks with null values */
136 : /* Initialize memtrack and fail */
137 : oomfill_fill(_i*sizeof(TMemBlock),2);
138 6 : l_result = memtrack_addblock(
139 : NULL, /* Pointer */
140 : 10, /* Size */
141 : __FILE__, /* Source code filename */
142 : __LINE__, /* Source code line number */
143 : __DATE__, /* Compilation date */
144 : __TIME__, /* Compilation time */
145 : __func__ /* Source code function, GNU extension */
146 : );
147 : oomfill_free();
148 :
149 : /* Check results */
150 6 : ck_assert_msg(1==l_result,"Should not be able to register a NULL pointer");
151 6 : ck_assert_msg(0==memtrack_getblocksize(NULL),"Blocksize of NULL pointer should be 0");
152 : /* Can not check the block counters value, it depends on WithData */
153 6 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
154 6 : }
155 : END_TEST
156 : #endif
157 :
158 : #ifndef NDEBUG
159 6 : START_TEST(delblock_null_first) {
160 : unsigned int l_result;
161 :
162 : /* Initialize memtrack and fail */
163 : oomfill_fill(_i*sizeof(TMemBlock),2);
164 6 : l_result = memtrack_delblock(
165 : NULL, /* Pointer */
166 : __FILE__, /* Source code filename */
167 : __LINE__, /* Source code line number */
168 : __DATE__, /* Compilation date */
169 : __TIME__, /* Compilation time */
170 : __func__ /* Source code function, GNU extension */
171 : );
172 : oomfill_free();
173 :
174 : /* Check results */
175 6 : ck_assert_msg(1==l_result,"Should not be able to unregister a NULL pointer");
176 6 : ck_assert_msg(0==memtrack_getblocksize(NULL),"Blocksize of NULL pointer should be 0");
177 : /* Can not check the block counters value, it depends on WithData */
178 6 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
179 6 : }
180 : END_TEST
181 : #endif
182 :
183 : #ifndef NDEBUG
184 6 : START_TEST(addblock_null) {
185 : uint64_t l_NbBlocks;
186 : size_t l_RAMSize;
187 : unsigned int result;
188 :
189 : /* LibMemTrack consistency check preparation */
190 6 : l_NbBlocks=memtrack_getallocatedblocks();
191 6 : l_RAMSize=memtrack_getallocatedRAM();
192 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
193 :
194 : /* Already initialized in previous lines, thus no need for allocation */
195 : /* Try to create/update a new blocks with null values, fails, no need for RAM */
196 : oomfill_fill(_i,2);
197 6 : result=memtrack_addblock(
198 : NULL, /* Pointer */
199 : 10, /* Size */
200 : __FILE__, /* Source code filename */
201 : __LINE__, /* Source code line number */
202 : __DATE__, /* Compilation date */
203 : __TIME__, /* Compilation time */
204 : __func__ /* Source code function, GNU extension */
205 : );
206 : oomfill_free();
207 :
208 : /* Check results */
209 6 : ck_assert_msg(1==result,"Should not be able to register a NULL pointer");
210 6 : ck_assert_msg(0==memtrack_getblocksize(NULL),"Blocksize of NULL pointer should be 0");
211 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
212 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
213 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
214 6 : }
215 : END_TEST
216 : #endif
217 :
218 : #ifndef NDEBUG
219 6 : START_TEST(addblock_duplicate) {
220 : uint64_t l_NbBlocks;
221 : size_t l_RAMSize;
222 : unsigned int result;
223 :
224 : /* LibMemTrack consistency check preparation */
225 6 : l_NbBlocks=memtrack_getallocatedblocks();
226 6 : l_RAMSize=memtrack_getallocatedRAM();
227 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
228 :
229 : /* Already initialized in previous lines, thus no need for allocation */
230 : /* Try to create/update one new block */
231 : oomfill_fill(_i*sizeof(TMemBlock),2);
232 6 : result=memtrack_addblock(
233 : (void*)999, /* Pointer */
234 : 10, /* Size */
235 : __FILE__, /* Source code filename */
236 : __LINE__, /* Source code line number */
237 : __DATE__, /* Compilation date */
238 : __TIME__, /* Compilation time */
239 : __func__ /* Source code function, GNU extension */
240 : );
241 : oomfill_free();
242 6 : ck_assert((0==result)||(oomfill_enabled()));
243 6 : if (0!=result) {
244 : /* OOM occured, fix that */
245 0 : result=memtrack_addblock(
246 : (void*)999, /* Pointer */
247 : 10, /* Size */
248 : __FILE__, /* Source code filename */
249 : __LINE__, /* Source code line number */
250 : __DATE__, /* Compilation date */
251 : __TIME__, /* Compilation time */
252 : __func__ /* Source code function, GNU extension */
253 : );
254 : }
255 6 : l_NbBlocks+=1;
256 6 : l_RAMSize+=10;
257 :
258 : /* Check results */
259 6 : ck_assert_msg(0==result,"Should able to register a pointer");
260 6 : ck_assert_msg(10==memtrack_getblocksize((void*)999),"Blocksize of pointer should be 10");
261 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
262 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
263 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
264 :
265 : /* Add a duplicate, should fail */
266 : oomfill_fill(_i*sizeof(TMemBlock),2);
267 6 : result=memtrack_addblock(
268 : (void*)999, /* Pointer */
269 : 20, /* Size */
270 : __FILE__, /* Source code filename */
271 : __LINE__, /* Source code line number */
272 : __DATE__, /* Compilation date */
273 : __TIME__, /* Compilation time */
274 : __func__ /* Source code function, GNU extension */
275 : );
276 : oomfill_free();
277 :
278 : /* Check results */
279 6 : ck_assert_msg(1==result,"Should not be able to register a duplicate pointer");
280 6 : ck_assert_msg(10==memtrack_getblocksize((void*)999),"Duplicate pointer updated the size");
281 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
282 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
283 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
284 :
285 : /* Cleanup */
286 6 : result = memtrack_delblock(
287 : (void*)999, /* Pointer */
288 : __FILE__, /* Source code filename */
289 : __LINE__, /* Source code line number */
290 : __DATE__, /* Compilation date */
291 : __TIME__, /* Compilation time */
292 : __func__ /* Source code function, GNU extension */
293 : );
294 6 : ck_assert(0==result);
295 6 : }
296 : END_TEST
297 : #endif
298 :
299 : #ifndef NDEBUG
300 6 : START_TEST(addblock_empty) {
301 : uint64_t l_NbBlocks;
302 : size_t l_RAMSize;
303 : unsigned int result;
304 :
305 : /* LibMemTrack consistency check preparation */
306 6 : l_NbBlocks=memtrack_getallocatedblocks();
307 6 : l_RAMSize=memtrack_getallocatedRAM();
308 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
309 :
310 : /* Try to create/add a new block with empty values */
311 : /* Already initialized and empty val will fail, thus no need for RAM */
312 : oomfill_fill(_i,2);
313 6 : result=memtrack_addblock(
314 : (void*)999, /* Pointer */
315 : 0, /* Size */
316 : __FILE__, /* Source code filename */
317 : __LINE__, /* Source code line number */
318 : __DATE__, /* Compilation date */
319 : __TIME__, /* Compilation time */
320 : __func__ /* Source code function, GNU extension */
321 : );
322 : oomfill_free();
323 :
324 : /* Check results */
325 6 : ck_assert_msg(1==result,"Should not be able to register a 0 sized pointer");
326 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of missing block should be 0");
327 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
328 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
329 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
330 :
331 : /* Try to create/add a new block with empty values */
332 : oomfill_fill(_i,2);
333 6 : result=memtrack_addblock(
334 : (void*)999, /* Pointer */
335 : 1, /* Size */
336 : "", /* Source code filename */
337 : __LINE__, /* Source code line number */
338 : __DATE__, /* Compilation date */
339 : __TIME__, /* Compilation time */
340 : __func__ /* Source code function, GNU extension */
341 : );
342 : oomfill_free();
343 :
344 : /* Check results */
345 6 : ck_assert_msg(1==result,"Should not be able to register a pointer without filename");
346 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of missing block should be 0");
347 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
348 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
349 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
350 :
351 : /* Try to create/add a new block with empty values */
352 : oomfill_fill(_i,2);
353 6 : result=memtrack_addblock(
354 : (void*)999, /* Pointer */
355 : 1, /* Size */
356 : __FILE__, /* Source code filename */
357 : 0, /* Source code line number */
358 : __DATE__, /* Compilation date */
359 : __TIME__, /* Compilation time */
360 : __func__ /* Source code function, GNU extension */
361 : );
362 : oomfill_free();
363 :
364 : /* Check results */
365 6 : ck_assert_msg(1==result,"Should not be able to register a pointer à line number 0");
366 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of missing block should be 0");
367 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
368 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
369 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
370 :
371 : /* Try to create/add a new block with empty values */
372 : oomfill_fill(_i,2);
373 6 : result=memtrack_addblock(
374 : (void*)999, /* Pointer */
375 : 1, /* Size */
376 : __FILE__, /* Source code filename */
377 : __LINE__, /* Source code line number */
378 : "", /* Compilation date */
379 : __TIME__, /* Compilation time */
380 : __func__ /* Source code function, GNU extension */
381 : );
382 : oomfill_free();
383 :
384 : /* Check results */
385 6 : ck_assert_msg(1==result,"Should not be able to register a pointer without a compilation date");
386 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of missing block should be 0");
387 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
388 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
389 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
390 :
391 : /* Try to create/add a new block with empty values */
392 : oomfill_fill(_i,2);
393 6 : result=memtrack_addblock(
394 : (void*)999, /* Pointer */
395 : 1, /* Size */
396 : __FILE__, /* Source code filename */
397 : __LINE__, /* Source code line number */
398 : __DATE__, /* Compilation date */
399 : "", /* Compilation time */
400 : __func__ /* Source code function, GNU extension */
401 : );
402 : oomfill_free();
403 :
404 : /* Check results */
405 6 : ck_assert_msg(1==result,"Should not be able to register a pointer without a compilation time");
406 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of missing block should be 0");
407 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
408 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
409 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
410 :
411 : /* Try to create/add a new block with empty values */
412 : oomfill_fill(_i,2);
413 6 : result=memtrack_addblock(
414 : (void*)999, /* Pointer */
415 : 1, /* Size */
416 : __FILE__, /* Source code filename */
417 : __LINE__, /* Source code line number */
418 : __DATE__, /* Compilation date */
419 : __TIME__, /* Compilation time */
420 : "" /* Source code function, GNU extension */
421 : );
422 : oomfill_free();
423 :
424 : /* Check results */
425 6 : ck_assert_msg(1==result,"Should not be able to register a pointer without a function name");
426 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of missing block should be 0");
427 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
428 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
429 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
430 6 : }
431 : END_TEST
432 : #endif /* NDEBUG */
433 :
434 : #ifndef NDEBUG
435 6 : START_TEST(addblock_longstrings) {
436 : uint64_t l_NbBlocks;
437 : size_t l_BlockSize;
438 : size_t l_RAMSize;
439 : unsigned int result;
440 6 : char *szLongString =
441 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
442 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
443 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
444 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
445 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
446 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
447 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
448 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
449 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
450 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
451 : ;
452 :
453 : /* LibMemTrack consistency check preparation */
454 6 : l_NbBlocks=memtrack_getallocatedblocks();
455 6 : l_RAMSize=memtrack_getallocatedRAM();
456 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
457 :
458 : /* Try to create/add a new block with empty values */
459 : oomfill_fill(_i*(sizeof(TMemBlock)+sizeof(*szLongString)),2);
460 6 : result=memtrack_addblock(
461 : (void*)999, /* Pointer */
462 : 1, /* Size */
463 : szLongString,/* Source code filename */
464 : __LINE__, /* Source code line number */
465 : __DATE__, /* Compilation date */
466 : __TIME__, /* Compilation time */
467 : __func__ /* Source code function, GNU extension */
468 : );
469 : oomfill_free();
470 :
471 : /* Check results */
472 6 : ck_assert((0==result)||(oomfill_enabled()));
473 6 : if (0==result) {
474 6 : l_NbBlocks+=1;
475 6 : l_RAMSize+=1;
476 6 : l_BlockSize=1;
477 : } else {
478 : /* result is false while oom testing : OOM occured */
479 0 : l_BlockSize = 0;
480 : }
481 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
482 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
483 6 : ck_assert_msg(l_BlockSize==memtrack_getblocksize((void*)999),"Blocksize inconsistency");
484 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
485 :
486 : /* Try to create/add a new block with empty values */
487 : oomfill_fill(_i*(sizeof(TMemBlock)+sizeof(*szLongString)),2);
488 6 : result=memtrack_addblock(
489 : (void*)998, /* Pointer */
490 : 2, /* Size */
491 : __FILE__, /* Source code filename */
492 : 1, /* Source code line number */
493 : szLongString,/* Compilation date */
494 : __TIME__, /* Compilation time */
495 : __func__ /* Source code function, GNU extension */
496 : );
497 : oomfill_free();
498 :
499 : /* Check results */
500 6 : ck_assert((0==result)||(oomfill_enabled()));
501 6 : if (0==result) {
502 6 : l_NbBlocks+=1;
503 6 : l_RAMSize+=2;
504 6 : l_BlockSize=2;
505 : } else {
506 : /* result is false while oom testing : OOM occured */
507 0 : l_BlockSize = 0;
508 : }
509 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
510 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
511 6 : ck_assert_msg(l_BlockSize==memtrack_getblocksize((void*)998),"Blocksize inconsistency");
512 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
513 :
514 : /* Try to create/add a new block with empty values */
515 : oomfill_fill(_i*(sizeof(TMemBlock)+sizeof(*szLongString)),2);
516 6 : result=memtrack_addblock(
517 : (void*)997, /* Pointer */
518 : 3, /* Size */
519 : __FILE__, /* Source code filename */
520 : 1, /* Source code line number */
521 : __DATE__, /* Compilation date */
522 : szLongString,/* Compilation time */
523 : __func__ /* Source code function, GNU extension */
524 : );
525 : oomfill_free();
526 :
527 : /* Check results */
528 6 : ck_assert((0==result)||(oomfill_enabled()));
529 6 : if (0==result) {
530 6 : l_NbBlocks+=1;
531 6 : l_RAMSize+=3;
532 6 : l_BlockSize=3;
533 : } else {
534 : /* result is false while oom testing : OOM occured */
535 0 : l_BlockSize = 0;
536 : }
537 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
538 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
539 6 : ck_assert_msg(l_BlockSize==memtrack_getblocksize((void*)997),"Blocksize inconsistency");
540 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
541 :
542 : /* Try to create/add a new block with empty values */
543 : oomfill_fill(_i*(sizeof(TMemBlock)+sizeof(*szLongString)),2);
544 6 : result=memtrack_addblock(
545 : (void*)996, /* Pointer */
546 : 4, /* Size */
547 : __FILE__, /* Source code filename */
548 : 1, /* Source code line number */
549 : __DATE__, /* Compilation date */
550 : __TIME__, /* Compilation time */
551 : szLongString /* Source code function, GNU extension */
552 : );
553 : oomfill_free();
554 :
555 : /* Check results */
556 6 : ck_assert((0==result)||(oomfill_enabled()));
557 6 : if (0==result) {
558 6 : l_NbBlocks+=1;
559 6 : l_RAMSize+=4;
560 6 : l_BlockSize=4;
561 : } else {
562 : /* result is false while oom testing : OOM occured */
563 0 : l_BlockSize = 0;
564 : }
565 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
566 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
567 6 : ck_assert_msg(l_BlockSize==memtrack_getblocksize((void*)996),"Blocksize inconsistency");
568 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
569 6 : }
570 : END_TEST
571 : #endif /* NDEBUG */
572 :
573 : #ifndef NDEBUG
574 6 : START_TEST(delblock_null) {
575 : uint64_t l_NbBlocks;
576 : size_t l_RAMSize;
577 : unsigned int result;
578 :
579 : /* Functor autoinit already tested in a previous test, can surround with sanity checks */
580 6 : l_NbBlocks=memtrack_getallocatedblocks();
581 6 : l_RAMSize=memtrack_getallocatedRAM();
582 6 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks count differs");
583 :
584 : /* Run tests under constraint */
585 : oomfill_fill(_i,2);
586 6 : result=memtrack_delblock(
587 : NULL, /* Pointer */
588 : __FILE__, /* Source code filename */
589 : __LINE__, /* Source code line number */
590 : __DATE__, /* Compilation date */
591 : __TIME__, /* Compilation time */
592 : __func__ /* Source code function, GNU extension */
593 : );
594 : oomfill_free();
595 :
596 : /* Check results should always fail, oom or not */
597 6 : ck_assert_msg(1==result,"Should not be able to unregister a NULL pointer");
598 6 : ck_assert_msg(0==memtrack_getblocksize(NULL),"Blocksize of NULL pointer should be 0");
599 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
600 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
601 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
602 6 : }
603 : END_TEST
604 : #endif /* NDEBUG */
605 :
606 : #ifndef NDEBUG
607 6 : START_TEST(delblock_missing) {
608 : uint64_t l_NbBlocks;
609 : size_t l_RAMSize;
610 : unsigned int result;
611 :
612 : /* Functor autoinit already tested in a previous test, can surround with sanity checks */
613 6 : l_NbBlocks=memtrack_getallocatedblocks();
614 6 : l_RAMSize=memtrack_getallocatedRAM();
615 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
616 :
617 : /* Run tests under constraint */
618 : oomfill_fill(_i,2);
619 6 : result=memtrack_delblock(
620 : (void*)999, /* Pointer */
621 : __FILE__, /* Source code filename */
622 : __LINE__, /* Source code line number */
623 : __DATE__, /* Compilation date */
624 : __TIME__, /* Compilation time */
625 : __func__ /* Source code function, GNU extension */
626 : );
627 : oomfill_free();
628 :
629 : /* Check results should always fail, oom or not */
630 6 : ck_assert_msg(1==result,"Should not be able to unregister a missing pointer");
631 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of missing pointer should be 0");
632 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count changed");
633 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM changed");
634 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
635 6 : }
636 : END_TEST
637 : #endif /* NDEBUG */
638 :
639 : #ifndef NDEBUG
640 6 : START_TEST(addblock1_delblock1) {
641 : uint64_t l_NbBlocks;
642 : size_t l_RAMSize;
643 : unsigned int result;
644 :
645 : /* LibMemTrack consistency check preparation */
646 6 : l_NbBlocks=memtrack_getallocatedblocks();
647 6 : l_RAMSize=memtrack_getallocatedRAM();
648 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
649 :
650 : /* Ensure that block does not already exist */
651 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"The 999 block should not already exist");
652 :
653 : oomfill_fill(_i*sizeof(TMemBlock),2);
654 : /* Create a new block */
655 6 : result=memtrack_addblock(
656 : (void*)999, /* Pointer */
657 : 10, /* Size */
658 : __FILE__, /* Source code filename */
659 : __LINE__, /* Source code line number */
660 : __DATE__, /* Compilation date */
661 : __TIME__, /* Compilation time */
662 : __func__ /* Source code function, GNU extension */
663 : );
664 : oomfill_free();
665 :
666 : /* Intermediate check */
667 6 : ck_assert((0==result)||(oomfill_enabled()));
668 6 : if (0==result) {
669 : /* No OOM error, update the check counters */
670 6 : l_NbBlocks+=1;
671 6 : l_RAMSize+=10;
672 6 : ck_assert_msg(10==memtrack_getblocksize((void*)999),"Blocksize of 999 block should be 10");
673 : } else {
674 0 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of 999 missing block should be 0");
675 : }
676 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
677 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
678 :
679 : oomfill_fill(_i,2);
680 : /* Delete the created block */
681 6 : result = memtrack_delblock(
682 : (void*)999, /* Pointer */
683 : __FILE__, /* Source code filename */
684 : __LINE__, /* Source code line number */
685 : __DATE__, /* Compilation date */
686 : __TIME__, /* Compilation time */
687 : __func__ /* Source code function, GNU extension */
688 : );
689 : oomfill_free();
690 :
691 : /* Check results */
692 6 : ck_assert((0==result)||(oomfill_enabled()));
693 6 : if (0==result) {
694 : /* No OOM error, update the check counters */
695 6 : l_NbBlocks-=1;
696 6 : l_RAMSize-=10;
697 : }
698 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
699 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
700 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of deleted 999 block should be 0");
701 6 : }
702 : END_TEST
703 : #endif /* NDEBUG */
704 :
705 : #ifndef NDEBUG
706 6 : START_TEST(addblock12_delblock12) {
707 : uint64_t l_NbBlocks;
708 : size_t l_RAMSize;
709 : unsigned int result;
710 :
711 : /* LibMemTrack consistency check preparation */
712 6 : l_NbBlocks=memtrack_getallocatedblocks();
713 6 : l_RAMSize=memtrack_getallocatedRAM();
714 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
715 :
716 : /* Ensure that block does not already exist */
717 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"The 999 block should not already exist");
718 :
719 : oomfill_fill(_i*sizeof(TMemBlock),2);
720 : /* Create a new block */
721 6 : result=memtrack_addblock(
722 : (void*)999, /* Pointer */
723 : 10, /* Size */
724 : __FILE__, /* Source code filename */
725 : __LINE__, /* Source code line number */
726 : __DATE__, /* Compilation date */
727 : __TIME__, /* Compilation time */
728 : __func__ /* Source code function, GNU extension */
729 : );
730 : oomfill_free();
731 :
732 : /* Intermediate check */
733 6 : ck_assert((0==result)||(oomfill_enabled()));
734 6 : if (0==result) {
735 : /* No OOM error, update the check counters */
736 6 : l_NbBlocks+=1;
737 6 : l_RAMSize+=10;
738 6 : ck_assert_msg(10==memtrack_getblocksize((void*)999),"Blocksize of 999 block should be 10");
739 : } else {
740 0 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of 999 missing block should be 0");
741 : }
742 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
743 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
744 :
745 : /* Ensure that block does not already exist */
746 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"The 998 block should not already exist");
747 :
748 : oomfill_fill(_i*sizeof(TMemBlock),2);
749 : /* Create a new block */
750 6 : result=memtrack_addblock(
751 : (void*)998, /* Pointer */
752 : 20, /* Size */
753 : __FILE__, /* Source code filename */
754 : __LINE__, /* Source code line number */
755 : __DATE__, /* Compilation date */
756 : __TIME__, /* Compilation time */
757 : __func__ /* Source code function, GNU extension */
758 : );
759 : oomfill_free();
760 :
761 : /* Intermediate check */
762 6 : ck_assert((0==result)||(oomfill_enabled()));
763 6 : if (0==result) {
764 : /* No OOM error, update the check counters */
765 6 : l_NbBlocks+=1;
766 6 : l_RAMSize+=20;
767 6 : ck_assert_msg(20==memtrack_getblocksize((void*)998),"Blocksize of 998 block should be 10");
768 : } else {
769 0 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of 998 missing block should be 0");
770 : }
771 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
772 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
773 :
774 : oomfill_fill(_i,2);
775 : /* Delete the created block */
776 6 : result = memtrack_delblock(
777 : (void*)999, /* Pointer */
778 : __FILE__, /* Source code filename */
779 : __LINE__, /* Source code line number */
780 : __DATE__, /* Compilation date */
781 : __TIME__, /* Compilation time */
782 : __func__ /* Source code function, GNU extension */
783 : );
784 : oomfill_free();
785 :
786 : /* Check results */
787 6 : ck_assert((0==result)||(oomfill_enabled()));
788 6 : if (0==result) {
789 : /* No OOM error, update the check counters */
790 6 : l_NbBlocks-=1;
791 6 : l_RAMSize-=10;
792 : }
793 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
794 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
795 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of deleted 999 block should be 0");
796 :
797 : oomfill_fill(_i,2);
798 : /* Delete the created block */
799 6 : result = memtrack_delblock(
800 : (void*)998, /* Pointer */
801 : __FILE__, /* Source code filename */
802 : __LINE__, /* Source code line number */
803 : __DATE__, /* Compilation date */
804 : __TIME__, /* Compilation time */
805 : __func__ /* Source code function, GNU extension */
806 : );
807 : oomfill_free();
808 :
809 : /* Check results */
810 6 : ck_assert((0==result)||(oomfill_enabled()));
811 6 : if (0==result) {
812 : /* No OOM error, update the check counters */
813 6 : l_NbBlocks-=1;
814 6 : l_RAMSize-=20;
815 : }
816 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
817 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
818 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of deleted 998 block should be 0");
819 6 : }
820 : END_TEST
821 : #endif /* NDEBUG */
822 :
823 : #ifndef NDEBUG
824 6 : START_TEST(addblock12_delblock21) {
825 : uint64_t l_NbBlocks;
826 : size_t l_RAMSize;
827 : unsigned int result;
828 :
829 : /* LibMemTrack consistency check preparation */
830 6 : l_NbBlocks=memtrack_getallocatedblocks();
831 6 : l_RAMSize=memtrack_getallocatedRAM();
832 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
833 :
834 : /* Ensure that block does not already exist */
835 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"The 999 block should not already exist");
836 :
837 : oomfill_fill(_i*sizeof(TMemBlock),2);
838 : /* Create a new block */
839 6 : result=memtrack_addblock(
840 : (void*)999, /* Pointer */
841 : 10, /* Size */
842 : __FILE__, /* Source code filename */
843 : __LINE__, /* Source code line number */
844 : __DATE__, /* Compilation date */
845 : __TIME__, /* Compilation time */
846 : __func__ /* Source code function, GNU extension */
847 : );
848 : oomfill_free();
849 :
850 : /* Intermediate check */
851 6 : ck_assert((0==result)||(oomfill_enabled()));
852 6 : if (0==result) {
853 : /* No OOM error, update the check counters */
854 6 : l_NbBlocks+=1;
855 6 : l_RAMSize+=10;
856 6 : ck_assert_msg(10==memtrack_getblocksize((void*)999),"Blocksize of 999 block should be 10");
857 : } else {
858 0 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of 999 missing block should be 0");
859 : }
860 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
861 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
862 :
863 : /* Ensure that block does not already exist */
864 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"The 998 block should not already exist");
865 :
866 : oomfill_fill(_i*sizeof(TMemBlock),2);
867 : /* Create a new block */
868 6 : result=memtrack_addblock(
869 : (void*)998, /* Pointer */
870 : 20, /* Size */
871 : __FILE__, /* Source code filename */
872 : __LINE__, /* Source code line number */
873 : __DATE__, /* Compilation date */
874 : __TIME__, /* Compilation time */
875 : __func__ /* Source code function, GNU extension */
876 : );
877 : oomfill_free();
878 :
879 : /* Intermediate check */
880 6 : ck_assert((0==result)||(oomfill_enabled()));
881 6 : if (0==result) {
882 : /* No OOM error, update the check counters */
883 6 : l_NbBlocks+=1;
884 6 : l_RAMSize+=20;
885 6 : ck_assert_msg(20==memtrack_getblocksize((void*)998),"Blocksize of 998 block should be 10");
886 : } else {
887 0 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of 998 missing block should be 0");
888 : }
889 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
890 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
891 :
892 : oomfill_fill(_i,2);
893 : /* Delete the created block */
894 6 : result = memtrack_delblock(
895 : (void*)998, /* Pointer */
896 : __FILE__, /* Source code filename */
897 : __LINE__, /* Source code line number */
898 : __DATE__, /* Compilation date */
899 : __TIME__, /* Compilation time */
900 : __func__ /* Source code function, GNU extension */
901 : );
902 : oomfill_free();
903 :
904 : /* Check results */
905 6 : ck_assert((0==result)||(oomfill_enabled()));
906 6 : if (0==result) {
907 : /* No OOM error, update the check counters */
908 6 : l_NbBlocks-=1;
909 6 : l_RAMSize-=20;
910 : }
911 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
912 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
913 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of deleted 998 block should be 0");
914 :
915 : oomfill_fill(_i,2);
916 : /* Delete the created block */
917 6 : result = memtrack_delblock(
918 : (void*)999, /* Pointer */
919 : __FILE__, /* Source code filename */
920 : __LINE__, /* Source code line number */
921 : __DATE__, /* Compilation date */
922 : __TIME__, /* Compilation time */
923 : __func__ /* Source code function, GNU extension */
924 : );
925 : oomfill_free();
926 :
927 : /* Check results */
928 6 : ck_assert((0==result)||(oomfill_enabled()));
929 6 : if (0==result) {
930 : /* No OOM error, update the check counters */
931 6 : l_NbBlocks-=1;
932 6 : l_RAMSize-=10;
933 : }
934 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
935 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
936 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of deleted 999 block should be 0");
937 6 : }
938 : END_TEST
939 : #endif /* NDEBUG */
940 :
941 : #ifndef NDEBUG
942 6 : START_TEST(addblock123_delblock123) {
943 : uint64_t l_NbBlocks;
944 : size_t l_RAMSize;
945 : unsigned int result;
946 :
947 : /* LibMemTrack consistency check preparation */
948 6 : l_NbBlocks=memtrack_getallocatedblocks();
949 6 : l_RAMSize=memtrack_getallocatedRAM();
950 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
951 :
952 : /* Ensure that block does not already exist */
953 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"The 999 block should not already exist");
954 :
955 : oomfill_fill(_i*sizeof(TMemBlock),2);
956 : /* Create a new block */
957 6 : result=memtrack_addblock(
958 : (void*)999, /* Pointer */
959 : 10, /* Size */
960 : __FILE__, /* Source code filename */
961 : __LINE__, /* Source code line number */
962 : __DATE__, /* Compilation date */
963 : __TIME__, /* Compilation time */
964 : __func__ /* Source code function, GNU extension */
965 : );
966 : oomfill_free();
967 :
968 : /* Intermediate check */
969 6 : ck_assert((0==result)||(oomfill_enabled()));
970 6 : if (0==result) {
971 : /* No OOM error, update the check counters */
972 6 : l_NbBlocks+=1;
973 6 : l_RAMSize+=10;
974 6 : ck_assert_msg(10==memtrack_getblocksize((void*)999),"Blocksize of 999 block should be 10");
975 : } else {
976 0 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of 999 missing block should be 0");
977 : }
978 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
979 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
980 :
981 : /* Ensure that block does not already exist */
982 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"The 998 block should not already exist");
983 :
984 : oomfill_fill(_i*sizeof(TMemBlock),2);
985 : /* Create a new block */
986 6 : result=memtrack_addblock(
987 : (void*)998, /* Pointer */
988 : 20, /* Size */
989 : __FILE__, /* Source code filename */
990 : __LINE__, /* Source code line number */
991 : __DATE__, /* Compilation date */
992 : __TIME__, /* Compilation time */
993 : __func__ /* Source code function, GNU extension */
994 : );
995 : oomfill_free();
996 :
997 : /* Intermediate check */
998 6 : ck_assert((0==result)||(oomfill_enabled()));
999 6 : if (0==result) {
1000 : /* No OOM error, update the check counters */
1001 6 : l_NbBlocks+=1;
1002 6 : l_RAMSize+=20;
1003 6 : ck_assert_msg(20==memtrack_getblocksize((void*)998),"Blocksize of 998 block should be 10");
1004 : } else {
1005 0 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of 998 missing block should be 0");
1006 : }
1007 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1008 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1009 :
1010 : /* Ensure that block does not already exist */
1011 6 : ck_assert_msg(0==memtrack_getblocksize((void*)997),"The 997 block should not already exist");
1012 :
1013 : oomfill_fill(_i*sizeof(TMemBlock),2);
1014 : /* Create a new block */
1015 6 : result=memtrack_addblock(
1016 : (void*)997, /* Pointer */
1017 : 30, /* Size */
1018 : __FILE__, /* Source code filename */
1019 : __LINE__, /* Source code line number */
1020 : __DATE__, /* Compilation date */
1021 : __TIME__, /* Compilation time */
1022 : __func__ /* Source code function, GNU extension */
1023 : );
1024 : oomfill_free();
1025 :
1026 : /* Intermediate check */
1027 6 : ck_assert((0==result)||(oomfill_enabled()));
1028 6 : if (0==result) {
1029 : /* No OOM error, update the check counters */
1030 6 : l_NbBlocks+=1;
1031 6 : l_RAMSize+=30;
1032 6 : ck_assert_msg(30==memtrack_getblocksize((void*)997),"Blocksize of 997 block should be 10");
1033 : } else {
1034 0 : ck_assert_msg(0==memtrack_getblocksize((void*)997),"Blocksize of 997 missing block should be 0");
1035 : }
1036 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1037 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1038 :
1039 : oomfill_fill(_i,2);
1040 : /* Delete the created block */
1041 6 : result = memtrack_delblock(
1042 : (void*)999, /* Pointer */
1043 : __FILE__, /* Source code filename */
1044 : __LINE__, /* Source code line number */
1045 : __DATE__, /* Compilation date */
1046 : __TIME__, /* Compilation time */
1047 : __func__ /* Source code function, GNU extension */
1048 : );
1049 : oomfill_free();
1050 :
1051 : /* Check results */
1052 6 : ck_assert((0==result)||(oomfill_enabled()));
1053 6 : if (0==result) {
1054 : /* No OOM error, update the check counters */
1055 6 : l_NbBlocks-=1;
1056 6 : l_RAMSize-=10;
1057 : }
1058 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1059 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1060 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of deleted 999 block should be 0");
1061 :
1062 : oomfill_fill(_i,2);
1063 : /* Delete the created block */
1064 6 : result = memtrack_delblock(
1065 : (void*)998, /* Pointer */
1066 : __FILE__, /* Source code filename */
1067 : __LINE__, /* Source code line number */
1068 : __DATE__, /* Compilation date */
1069 : __TIME__, /* Compilation time */
1070 : __func__ /* Source code function, GNU extension */
1071 : );
1072 : oomfill_free();
1073 :
1074 : /* Check results */
1075 6 : ck_assert((0==result)||(oomfill_enabled()));
1076 6 : if (0==result) {
1077 : /* No OOM error, update the check counters */
1078 6 : l_NbBlocks-=1;
1079 6 : l_RAMSize-=20;
1080 : }
1081 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1082 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1083 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of deleted 998 block should be 0");
1084 :
1085 : oomfill_fill(_i,2);
1086 : /* Delete the created block */
1087 6 : result = memtrack_delblock(
1088 : (void*)997, /* Pointer */
1089 : __FILE__, /* Source code filename */
1090 : __LINE__, /* Source code line number */
1091 : __DATE__, /* Compilation date */
1092 : __TIME__, /* Compilation time */
1093 : __func__ /* Source code function, GNU extension */
1094 : );
1095 : oomfill_free();
1096 :
1097 : /* Check results */
1098 6 : ck_assert((0==result)||(oomfill_enabled()));
1099 6 : if (0==result) {
1100 : /* No OOM error, update the check counters */
1101 6 : l_NbBlocks-=1;
1102 6 : l_RAMSize-=30;
1103 : }
1104 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1105 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1106 6 : ck_assert_msg(0==memtrack_getblocksize((void*)997),"Blocksize of deleted 997 block should be 0");
1107 6 : }
1108 : END_TEST
1109 : #endif /* NDEBUG */
1110 :
1111 : #ifndef NDEBUG
1112 6 : START_TEST(addblock123_delblock2) {
1113 : uint64_t l_NbBlocks;
1114 : size_t l_RAMSize;
1115 : unsigned int result;
1116 :
1117 : /* LibMemTrack consistency check preparation */
1118 6 : l_NbBlocks=memtrack_getallocatedblocks();
1119 6 : l_RAMSize=memtrack_getallocatedRAM();
1120 6 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
1121 :
1122 : /* Ensure that block does not already exist */
1123 6 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"The 999 block should not already exist");
1124 :
1125 : oomfill_fill(_i*sizeof(TMemBlock),2);
1126 : /* Create a new block */
1127 6 : result=memtrack_addblock(
1128 : (void*)999, /* Pointer */
1129 : 10, /* Size */
1130 : __FILE__, /* Source code filename */
1131 : __LINE__, /* Source code line number */
1132 : __DATE__, /* Compilation date */
1133 : __TIME__, /* Compilation time */
1134 : __func__ /* Source code function, GNU extension */
1135 : );
1136 : oomfill_free();
1137 :
1138 : /* Intermediate check */
1139 6 : ck_assert((0==result)||(oomfill_enabled()));
1140 6 : if (0==result) {
1141 : /* No OOM error, update the check counters */
1142 6 : l_NbBlocks+=1;
1143 6 : l_RAMSize+=10;
1144 6 : ck_assert_msg(10==memtrack_getblocksize((void*)999),"Blocksize of 999 block should be 10");
1145 : } else {
1146 0 : ck_assert_msg(0==memtrack_getblocksize((void*)999),"Blocksize of 999 missing block should be 0");
1147 : }
1148 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1149 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1150 :
1151 : /* Ensure that block does not already exist */
1152 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"The 998 block should not already exist");
1153 :
1154 : oomfill_fill(_i*sizeof(TMemBlock),2);
1155 : /* Create a new block */
1156 6 : result=memtrack_addblock(
1157 : (void*)998, /* Pointer */
1158 : 20, /* Size */
1159 : __FILE__, /* Source code filename */
1160 : __LINE__, /* Source code line number */
1161 : __DATE__, /* Compilation date */
1162 : __TIME__, /* Compilation time */
1163 : __func__ /* Source code function, GNU extension */
1164 : );
1165 : oomfill_free();
1166 :
1167 : /* Intermediate check */
1168 6 : ck_assert((0==result)||(oomfill_enabled()));
1169 6 : if (0==result) {
1170 : /* No OOM error, update the check counters */
1171 6 : l_NbBlocks+=1;
1172 6 : l_RAMSize+=20;
1173 6 : ck_assert_msg(20==memtrack_getblocksize((void*)998),"Blocksize of 998 block should be 10");
1174 : } else {
1175 0 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of 998 missing block should be 0");
1176 : }
1177 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1178 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1179 :
1180 : /* Ensure that block does not already exist */
1181 6 : ck_assert_msg(0==memtrack_getblocksize((void*)997),"The 997 block should not already exist");
1182 :
1183 : oomfill_fill(_i*sizeof(TMemBlock),2);
1184 : /* Create a new block */
1185 6 : result=memtrack_addblock(
1186 : (void*)997, /* Pointer */
1187 : 30, /* Size */
1188 : __FILE__, /* Source code filename */
1189 : __LINE__, /* Source code line number */
1190 : __DATE__, /* Compilation date */
1191 : __TIME__, /* Compilation time */
1192 : __func__ /* Source code function, GNU extension */
1193 : );
1194 : oomfill_free();
1195 :
1196 : /* Intermediate check */
1197 6 : ck_assert((0==result)||(oomfill_enabled()));
1198 6 : if (0==result) {
1199 : /* No OOM error, update the check counters */
1200 6 : l_NbBlocks+=1;
1201 6 : l_RAMSize+=30;
1202 6 : ck_assert_msg(30==memtrack_getblocksize((void*)997),"Blocksize of 997 block should be 10");
1203 : } else {
1204 0 : ck_assert_msg(0==memtrack_getblocksize((void*)997),"Blocksize of 997 missing block should be 0");
1205 : }
1206 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1207 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1208 :
1209 : oomfill_fill(_i,2);
1210 : /* Delete the created block */
1211 6 : result = memtrack_delblock(
1212 : (void*)998, /* Pointer */
1213 : __FILE__, /* Source code filename */
1214 : __LINE__, /* Source code line number */
1215 : __DATE__, /* Compilation date */
1216 : __TIME__, /* Compilation time */
1217 : __func__ /* Source code function, GNU extension */
1218 : );
1219 : oomfill_free();
1220 :
1221 : /* Check results */
1222 6 : ck_assert((0==result)||(oomfill_enabled()));
1223 6 : if (0==result) {
1224 : /* No OOM error, update the check counters */
1225 6 : l_NbBlocks-=1;
1226 6 : l_RAMSize-=20;
1227 : }
1228 6 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1229 6 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1230 6 : ck_assert_msg(0==memtrack_getblocksize((void*)998),"Blocksize of deleted 998 block should be 0");
1231 6 : }
1232 : END_TEST
1233 : #endif /* NDEBUG */
1234 :
1235 : #ifndef NDEBUG
1236 : #ifdef HAVE_LIBOOM
1237 : START_TEST(adddelblock_oom) {
1238 : uint64_t l_NbBlocks;
1239 : size_t l_RAMSize;
1240 : long unsigned int i=0;
1241 : uint16_t oomtestvalues[65536] = {0};
1242 : char *szLongString =
1243 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1244 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1245 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1246 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1247 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1248 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1249 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1250 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1251 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1252 : "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1253 : ;
1254 :
1255 : /* LibMemTrack consistency check preparation */
1256 : l_NbBlocks=memtrack_getallocatedblocks();
1257 : l_RAMSize=memtrack_getallocatedRAM();
1258 : ck_assert_msg(l_NbBlocks==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks mismatch");
1259 :
1260 : /* Try to trigger OOM inside the tested feature */
1261 : i = 0;
1262 : oomfill_fill(_i*(sizeof(TMemBlock)+4*(26+10+26)*10),2);
1263 : do {
1264 : i++;
1265 : oomtestvalues[i] = memtrack_addblock(
1266 : (void*)(i+99),/* Pointer */
1267 : 10, /* Size */
1268 : szLongString, /* Source code filename */
1269 : __LINE__, /* Source code line number */
1270 : szLongString, /* Compilation date */
1271 : szLongString, /* Compilation time */
1272 : szLongString /* Source code function, GNU extension */
1273 : );
1274 : } while ((i<65535)&&(0==oomtestvalues[i]));
1275 : oomfill_free();
1276 :
1277 : /* Intermediate check */
1278 : l_NbBlocks+=i-1;
1279 : l_RAMSize+=(i-1)*10;
1280 : /* Should have returned NULL (OOM) before reaching 65535 */
1281 : ck_assert_msg(65535!=i,"Did not manage to trigger OOM");
1282 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1283 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1284 :
1285 : /* We will loose i value, precalculate values */
1286 : l_NbBlocks-=i-1;
1287 : l_RAMSize-=(i-1)*10;
1288 :
1289 : oomfill_fill(_i,2);
1290 : /* Free all the allocated memory */
1291 : i = 1;
1292 : while ((i<65535)&&(0==oomtestvalues[i])) {
1293 : if(0!=(oomtestvalues[i]=memtrack_delblock(
1294 : (void*)(i+99),/* Pointer */
1295 : __FILE__, /* Source code filename */
1296 : __LINE__, /* Source code line number */
1297 : __DATE__, /* Compilation date */
1298 : __TIME__, /* Compilation time */
1299 : __func__ /* Source code function, GNU extension */
1300 : )))
1301 : break;
1302 : i++;
1303 : }
1304 : oomfill_free();
1305 :
1306 : ck_assert_msg(65535!=i,"Did not manage to free all allocated RAM");
1307 : ck_assert(1==oomtestvalues[i]);
1308 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"Block count inconsistency");
1309 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"Allocated RAM inconsistency");
1310 : }
1311 : END_TEST
1312 : #endif /* HAVE_LIBOOM */
1313 : #endif /* NDEBUG */
1314 :
1315 : /************************************************************************/
1316 102 : void memtrack_checked_common_setup() {
1317 102 : signals_catch();
1318 102 : forktest_gprofdir();
1319 102 : }
1320 54 : void memtrack_checked_uninitialized_setup() {
1321 54 : memtrack_checked_common_setup();
1322 54 : }
1323 48 : void memtrack_checked_withdata_setup() {
1324 48 : memtrack_checked_common_setup();
1325 : #ifndef NDEBUG
1326 : uint64_t l_NbBlocks;
1327 : uint64_t l_RAMSize;
1328 :
1329 48 : l_NbBlocks=memtrack_getallocatedblocks();
1330 48 : l_RAMSize=memtrack_getallocatedRAM();
1331 48 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"getallocatedblocks does not match counter");
1332 48 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"getallocatedRAM does not match the counter");
1333 48 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks count differs");
1334 48 : ck_assert_msg(0==memtrack_addblock(
1335 : (void*)1, /* Pointer */
1336 : 10, /* Size */
1337 : __FILE__, /* Source code filename */
1338 : __LINE__, /* Source code line number */
1339 : __DATE__, /* Compilation date */
1340 : __TIME__, /* Compilation time */
1341 : "fonction" /* Source code function, GNU extension */
1342 : ),"Creating block (Normal values)");
1343 48 : ck_assert_msg(10==memtrack_getblocksize((void*)1),"Invalid getblocksize");
1344 48 : ck_assert_msg( 0==memtrack_getblocksize((void*)2),"Invalid getblocksize");
1345 48 : ck_assert_msg( 0==memtrack_getblocksize((void*)3),"Invalid getblocksize");
1346 48 : l_NbBlocks += 1;
1347 48 : l_RAMSize += 10;
1348 48 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"getallocatedblocks does not match counter");
1349 48 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"getallocatedRAM does not match the counter");
1350 48 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks count differs");
1351 48 : ck_assert_msg(0==memtrack_addblock(
1352 : (void*)2, /* Pointer */
1353 : 20, /* Size */
1354 : __FILE__, /* Source code filename */
1355 : __LINE__, /* Source code line number */
1356 : __DATE__, /* Compilation date */
1357 : __TIME__, /* Compilation time */
1358 : "fonction" /* Source code function, GNU extension */
1359 : ),"Creating block (Normal values)");
1360 48 : ck_assert_msg(10==memtrack_getblocksize((void*)1),"Invalid getblocksize");
1361 48 : ck_assert_msg(20==memtrack_getblocksize((void*)2),"Invalid getblocksize");
1362 48 : ck_assert_msg( 0==memtrack_getblocksize((void*)3),"Invalid getblocksize");
1363 48 : l_NbBlocks += 1;
1364 48 : l_RAMSize += 20;
1365 48 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"getallocatedblocks does not match counter");
1366 48 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"getallocatedRAM does not match the counter");
1367 48 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks count differs");
1368 48 : ck_assert_msg(0==memtrack_addblock(
1369 : (void*)3, /* Pointer */
1370 : 30, /* Size */
1371 : __FILE__, /* Source code filename */
1372 : __LINE__, /* Source code line number */
1373 : __DATE__, /* Compilation date */
1374 : __TIME__, /* Compilation time */
1375 : "fonction" /* Source code function, GNU extension */
1376 : ),"Creating block (Normal values)");
1377 48 : ck_assert_msg(10==memtrack_getblocksize((void*)1),"Invalid getblocksize");
1378 48 : ck_assert_msg(20==memtrack_getblocksize((void*)2),"Invalid getblocksize");
1379 48 : ck_assert_msg(30==memtrack_getblocksize((void*)3),"Invalid getblocksize");
1380 48 : l_NbBlocks += 1;
1381 48 : l_RAMSize += 30;
1382 48 : ck_assert_msg(l_NbBlocks==memtrack_getallocatedblocks(),"getallocatedblocks does not match counter");
1383 48 : ck_assert_msg(l_RAMSize==memtrack_getallocatedRAM(),"getallocatedRAM does not match the counter");
1384 48 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks count differs");
1385 : #endif /* NDEBUG */
1386 48 : }
1387 102 : void memtrack_checked_common_teardown() {
1388 102 : signals_release();
1389 : #ifndef NDEBUG
1390 : /** @todo make memtrack_reset compatible with oomfill_* */
1391 102 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks count differs");
1392 102 : memtrack_reset();
1393 102 : memtrack_reset(); /* Test the double run protection */
1394 102 : ck_assert_msg(0==memtrack_getallocatedblocks(),"getallocatedblocks does not match counter");
1395 102 : ck_assert_msg(0==memtrack_getallocatedRAM(),"getallocatedRAM does not match the counter");
1396 102 : ck_assert_msg(memtrack_getallocatedblocks()==memtrack_dumpblocks(),"Internal NbBlocks counter and dumpblocks count differs");
1397 : #endif /* NDEBUG */
1398 102 : }
1399 : /************************************************************************/
1400 686 : void memtrack_unchecked_common_setup() {
1401 686 : forktest_init();
1402 686 : }
1403 618 : void memtrack_unchecked_common_teardown() {
1404 618 : }
1405 : #ifdef HAVE_LIBOOM
1406 : void memtrack_unchecked_oom_setup() {
1407 : memtrack_unchecked_common_setup();
1408 : oomfill_enable(RAMLIMIT_SOFT);
1409 : }
1410 : void memtrack_unchecked_oom_teardown() {
1411 : oomfill_disable();
1412 : memtrack_unchecked_common_teardown();
1413 : }
1414 : #endif /* HAVE_LIBOOM */
1415 :
1416 : /************************************************************************/
1417 365 : Suite* libdebug_memtrack_suite() {
1418 : Suite *s;
1419 : TCase *tc;
1420 :
1421 365 : s = suite_create("LibDebug-MemTrack");
1422 365 : tc = tcase_create("Uninitialized");
1423 365 : tcase_add_checked_fixture(tc, memtrack_checked_uninitialized_setup, memtrack_checked_common_teardown);
1424 365 : tcase_add_unchecked_fixture(tc, memtrack_unchecked_common_setup, memtrack_unchecked_common_teardown);
1425 365 : suite_add_tcase(s, tc);
1426 : #ifndef NDEBUG
1427 365 : tcase_add_test(tc, getallocatedRAM_first);
1428 365 : tcase_add_test(tc, getallocatedblocks_first);
1429 365 : tcase_add_test(tc, getblocksize_first);
1430 365 : tcase_add_test(tc, getblocksize_null);
1431 365 : tcase_add_test(tc, getblocksize_missing);
1432 365 : tcase_add_test(tc, addblock_null_first);
1433 365 : tcase_add_test(tc, delblock_null_first);
1434 365 : tcase_add_test(tc, addblock_null);
1435 365 : tcase_add_test(tc, addblock_duplicate);
1436 365 : tcase_add_test(tc, addblock_empty);
1437 365 : tcase_add_test(tc, addblock_longstrings);
1438 365 : tcase_add_test(tc, delblock_null);
1439 365 : tcase_add_test(tc, delblock_missing);
1440 365 : tcase_add_test(tc, addblock1_delblock1);
1441 365 : tcase_add_test(tc, addblock12_delblock12);
1442 365 : tcase_add_test(tc, addblock12_delblock21);
1443 365 : tcase_add_test(tc, addblock123_delblock123);
1444 365 : tcase_add_test(tc, addblock123_delblock2);
1445 : /* tcase_add_test(tc, adddelblock_oom); */
1446 : #endif
1447 :
1448 365 : tc = tcase_create("WithData");
1449 365 : tcase_add_checked_fixture(tc, memtrack_checked_withdata_setup, memtrack_checked_common_teardown);
1450 365 : tcase_add_unchecked_fixture(tc, memtrack_unchecked_common_setup, memtrack_unchecked_common_teardown);
1451 365 : suite_add_tcase(s, tc);
1452 : #ifndef NDEBUG
1453 : /* tcase_add_test(tc, getallocatedRAM_first); */
1454 : /* tcase_add_test(tc, getallocatedblocks_first); */
1455 365 : tcase_add_test(tc, getblocksize_first);
1456 365 : tcase_add_test(tc, getblocksize_null);
1457 365 : tcase_add_test(tc, getblocksize_missing);
1458 365 : tcase_add_test(tc, addblock_null_first);
1459 365 : tcase_add_test(tc, delblock_null_first);
1460 365 : tcase_add_test(tc, addblock_null);
1461 365 : tcase_add_test(tc, addblock_duplicate);
1462 365 : tcase_add_test(tc, addblock_empty);
1463 365 : tcase_add_test(tc, addblock_longstrings);
1464 365 : tcase_add_test(tc, delblock_null);
1465 365 : tcase_add_test(tc, delblock_missing);
1466 365 : tcase_add_test(tc, addblock1_delblock1);
1467 365 : tcase_add_test(tc, addblock12_delblock12);
1468 365 : tcase_add_test(tc, addblock12_delblock21);
1469 365 : tcase_add_test(tc, addblock123_delblock123);
1470 365 : tcase_add_test(tc, addblock123_delblock2);
1471 : /* tcase_add_test(tc, adddelblock_oom); */
1472 : #endif
1473 :
1474 : #ifdef HAVE_LIBOOM
1475 : tc = tcase_create("Uninitialized-OOM");
1476 : tcase_set_tags(tc,"oom");
1477 : tcase_add_checked_fixture(tc, memtrack_checked_uninitialized_setup, memtrack_checked_common_teardown);
1478 : tcase_add_unchecked_fixture(tc, memtrack_unchecked_oom_setup, memtrack_unchecked_oom_teardown);
1479 : suite_add_tcase(s, tc);
1480 : #ifndef NDEBUG
1481 : tcase_add_loop_test(tc, getallocatedRAM_first, 0, 10);
1482 : tcase_add_loop_test(tc, getallocatedblocks_first, 0, 10);
1483 : tcase_add_loop_test(tc, getblocksize_first, 0, 10);
1484 : tcase_add_loop_test(tc, getblocksize_null, 0, 10);
1485 : tcase_add_loop_test(tc, getblocksize_missing, 0, 10);
1486 : tcase_add_loop_test(tc, addblock_null_first, 0, 10);
1487 : tcase_add_loop_test(tc, delblock_null_first, 0, 10);
1488 : tcase_add_loop_test(tc, addblock_null, 0, 10);
1489 : tcase_add_loop_test(tc, addblock_duplicate, 0, 10);
1490 : tcase_add_loop_test(tc, addblock_empty, 0, 10);
1491 : tcase_add_loop_test(tc, addblock_longstrings, 0, 10);
1492 : tcase_add_loop_test(tc, delblock_null, 0, 10);
1493 : tcase_add_loop_test(tc, delblock_missing, 0, 10);
1494 : tcase_add_loop_test(tc, addblock1_delblock1, 0, 10);
1495 : tcase_add_loop_test(tc, addblock12_delblock12, 0, 10);
1496 : tcase_add_loop_test(tc, addblock12_delblock21, 0, 10);
1497 : tcase_add_loop_test(tc, addblock123_delblock123, 0, 10);
1498 : tcase_add_loop_test(tc, addblock123_delblock2, 0, 10);
1499 : tcase_add_loop_test(tc, adddelblock_oom, 0, 10);
1500 : #endif
1501 :
1502 : tc = tcase_create("WithData-OOM");
1503 : tcase_set_tags(tc,"oom");
1504 : tcase_add_checked_fixture(tc, memtrack_checked_withdata_setup, memtrack_checked_common_teardown);
1505 : tcase_add_unchecked_fixture(tc, memtrack_unchecked_oom_setup, memtrack_unchecked_oom_teardown);
1506 : suite_add_tcase(s, tc);
1507 : #ifndef NDEBUG
1508 : /* tcase_add_loop_test(tc, getallocatedRAM_first, 0, 10); */
1509 : /* tcase_add_loop_test(tc, getallocatedblocks_first, 0, 10); */
1510 : tcase_add_loop_test(tc, getblocksize_first, 0, 10);
1511 : tcase_add_loop_test(tc, getblocksize_null, 0, 10);
1512 : tcase_add_loop_test(tc, getblocksize_missing, 0, 10);
1513 : tcase_add_loop_test(tc, addblock_null_first, 0, 10);
1514 : tcase_add_loop_test(tc, delblock_null_first, 0, 10);
1515 : tcase_add_loop_test(tc, addblock_null, 0, 10);
1516 : tcase_add_loop_test(tc, addblock_duplicate, 0, 10);
1517 : tcase_add_loop_test(tc, addblock_empty, 0, 10);
1518 : tcase_add_loop_test(tc, addblock_longstrings, 0, 10);
1519 : tcase_add_loop_test(tc, delblock_null, 0, 10);
1520 : tcase_add_loop_test(tc, delblock_missing, 0, 10);
1521 : tcase_add_loop_test(tc, addblock1_delblock1, 0, 10);
1522 : tcase_add_loop_test(tc, addblock12_delblock12, 0, 10);
1523 : tcase_add_loop_test(tc, addblock12_delblock21, 0, 10);
1524 : tcase_add_loop_test(tc, addblock123_delblock123, 0, 10);
1525 : tcase_add_loop_test(tc, addblock123_delblock2, 0, 10);
1526 : tcase_add_loop_test(tc, adddelblock_oom, 0, 10);
1527 : #endif
1528 : #endif /* HAVE_LIBOOM */
1529 :
1530 365 : return s;
1531 : }
1532 :
1533 : /* vim: set tw=80: */
|
