source: tests/alloc2.cfa@ 428adbc

ADT ast-experimental pthread-emulation
Last change on this file since 428adbc was 1988572, checked in by Peter A. Buhr <pabuhr@…>, 3 years ago

formatting, removed unnecessary casts
  • Property mode set to 100644
File size: 23.6 KB
Line 
1#include <malloc.h> // malloc_usable_size
2#include <stdint.h> // uintptr_t
3#include <stdlib.hfa> // access C malloc, realloc
4#include <string.h> // memcmp
5
6int last_failed;
7int tests_total;
8int tests_failed;
9size_t tAlign = 32;
10struct S1 { int data; } __attribute__((aligned(32)));
11typedef struct S1 T1;
12
13void test_base( void * ip, size_t size, size_t align ) {
14 tests_total += 1;
15// printf( "DEBUG: starting test %d\n", tests_total);
16 bool passed = (malloc_size( ip ) == size) && (malloc_usable_size( ip ) >= size) && (malloc_alignment( ip ) == align) && ((uintptr_t)ip % align == 0);
17 if ( ! passed ) {
18 printf( "failed test %3d: %4zu %4zu but got %4zu ( %3zu ) %4zu\n", tests_total, size, align, malloc_size( ip ), malloc_usable_size( ip ), malloc_alignment( ip ) );
19 tests_failed += 1;
20 } // if
21// printf( "DEBUG: done test %d\n", tests_total);
22}
23
24void test_fill( void * ip_, size_t start, size_t end, char fill ) {
25 tests_total += 1;
26// printf( "DEBUG: starting test %d\n", tests_total );
27 bool passed = true;
28 char * ip = (char *) ip_;
29 for ( i; start ~ end ) passed = passed && (ip[i] == fill);
30 if ( ! passed ) {
31 printf( "failed test %3d: fill C\n", tests_total );
32 tests_failed += 1;
33 } // if
34// printf( "DEBUG: done test %d\n", tests_total );
35}
36
37void test_fill( void * ip_, size_t start, size_t end, int fill ) {
38 tests_total += 1;
39// printf( "DEBUG: starting test %d\n", tests_total );
40 bool passed = true;
41 int * ip = (int *)ip_;
42 for (i; start ~ end ) passed = passed && (ip[i] == fill);
43 if ( ! passed ) {
44 printf( "failed test %3d: fill int\n", tests_total );
45 tests_failed += 1;
46 } // if
47// printf( "DEBUG: done test %d\n", tests_total );
48}
49
50void test_fill( void * ip_, size_t start, size_t end, int * fill ) {
51 tests_total += 1;
52// printf( "DEBUG: starting test %d\n", tests_total );
53 bool passed = memcmp((void*)((uintptr_t )ip_ + start ), (void*)fill, end ) == 0;
54 if ( ! passed ) {
55 printf( "failed test %3d: fill int A\n", tests_total );
56 tests_failed += 1;
57 } // if
58// printf( "DEBUG: done test %d\n", tests_total );
59}
60
61void test_fill( void * ip_, size_t start, size_t end, T1 fill ) {
62 tests_total += 1;
63// printf( "DEBUG: starting test %d\n", tests_total );
64 bool passed = true;
65 T1 * ip = (T1 *) ip_;
66 for ( i; start ~ end ) passed = passed && (ip[i].data == fill.data );
67 if ( ! passed ) {
68 printf( "failed test %3d: fill T1\n", tests_total );
69 tests_failed += 1;
70 } // if
71// printf( "DEBUG: done test %d\n", tests_total );
72}
73
74void test_fill( void * ip_, size_t start, size_t end, T1 * fill ) {
75 tests_total += 1;
76// printf( "DEBUG: starting test %d\n", tests_total );
77 bool passed = memcmp( (void*)((uintptr_t )ip_ + start ), (void*)fill, end ) == 0;
78 if ( ! passed ) {
79 printf( "failed test %3d: fill T1 A\n", tests_total );
80 tests_failed += 1;
81 } // if
82// printf( "DEBUG: done test %d\n", tests_total );
83}
84
85void test_use( int * ip, size_t dim ) {
86 tests_total += 1;
87// printf( "DEBUG: starting test %d\n", tests_total );
88 bool passed = true;
89 for ( i; 0 ~ dim ) ip[i] = 0xdeadbeef;
90 for ( i; 0 ~ dim ) passed = passed && (ip[i] == 0xdeadbeef);
91 if ( ! passed ) {
92 printf( "failed test %3d: use int\n", tests_total );
93 tests_failed += 1;
94 } // if
95// printf( "DEBUG: done test %d\n", tests_total );
96}
97
98void test_use( T1 * ip, size_t dim ) {
99 tests_total += 1;
100// printf( "DEBUG: starting test %d\n", tests_total );
101 bool passed = true;
102 for ( i; 0 ~ dim ) ip[i].data = 0xdeadbeef;
103 for ( i; 0 ~ dim ) passed = passed && (ip[i].data == 0xdeadbeef);
104 if ( ! passed ) {
105 printf( "failed test %3d: use T1\n", tests_total );
106 tests_failed += 1;
107 } // if
108// printf( "DEBUG: done test %d\n", tests_total );
109}
110
111int main( void ) {
112 enum { dim = 8, align = 64, libAlign = libAlign() };
113 size_t elemSize = sizeof(int);
114 size_t size = dim * elemSize;
115
116 int FillT = 9;
117 char FillC = 'a';
118 int * FillA = calloc( dim / 4 );
119 T1 FillT1 = { FillT };
120 T1 * FillT1A = (T1 *)(void *) malloc( (dim / 4) * sizeof(T1) );
121 for ( i; 0 ~ (dim / 4) ) FillT1A[i] = FillT1;
122
123 int * ip;
124 int * op;
125 double * dp;
126 T1 * t1p;
127 T1 * t1op;
128
129 // testing alloc
130
131 last_failed = -1;
132 tests_total = 0;
133 tests_failed = 0;
134
135 ip = alloc();
136 test_base( ip, elemSize, libAlign );
137 test_use( ip, elemSize / elemSize );
138 free( ip );
139
140 ip = alloc( dim );
141 test_base( ip, size, libAlign );
142 test_use( ip, size / elemSize );
143 free( ip );
144
145 ip = alloc( 0 );
146 test_base( ip, 0, libAlign );
147 free( ip );
148
149 dp = alloc( dim );
150 ip = alloc( dp`resize );
151 test_base( ip, elemSize, libAlign );
152 test_use( ip, elemSize / elemSize );
153 free( ip );
154
155 ip = alloc( ((double *)0p)`resize );
156 test_base( ip, elemSize, libAlign );
157 test_use( ip, elemSize / elemSize );
158 free( ip );
159
160 dp = alloc( dim );
161 ip = alloc( dim, dp`resize );
162 test_base( ip, size, libAlign );
163 test_use( ip, size / elemSize );
164 free( ip );
165
166 dp = alloc( dim );
167 ip = alloc( 0, dp`resize );
168 test_base( ip, 0, libAlign );
169 free( ip );
170
171 ip = alloc( dim, 0p`resize );
172 test_base( ip, size, libAlign );
173 test_use( ip, size / elemSize );
174 free( ip );
175
176 ip = alloc( 0, 0p`resize );
177 test_base( ip, 0, libAlign );
178 free( ip );
179
180 op = alloc( dim, 0xdeadbeefN`fill );
181 ip = alloc( dim, op`realloc );
182 test_base( ip, size, libAlign );
183 test_fill( ip, 0, dim, 0xdeadbeefN );
184 test_use( ip, size / elemSize );
185 free( ip );
186
187 op = alloc( dim, 0xdeadbeefN`fill );
188 ip = alloc( 0, op`realloc );
189 test_base( ip, 0, libAlign );
190 free( ip );
191
192 ip = alloc( dim, 0p`realloc );
193 test_base( ip, size, libAlign );
194 test_use( ip, size / elemSize );
195 free( ip );
196
197 ip = alloc( 0, 0p`realloc );
198 test_base( ip, 0, libAlign );
199 free( ip );
200
201 op = alloc( dim, 0xdeadbeefN`fill );
202 ip = alloc( dim, op`resize );
203 test_base( ip, size, libAlign );
204 test_use( ip, size / elemSize );
205 free( ip );
206
207 ip = alloc( FillC`fill );
208 test_base( ip, elemSize, libAlign );
209 test_fill( ip, 0, elemSize, FillC );
210 test_use( ip, elemSize / elemSize );
211 free( ip );
212
213 ip = alloc( FillT`fill );
214 test_base( ip, elemSize, libAlign );
215 test_fill( ip, 0, 1, FillT );
216 test_use( ip, elemSize / elemSize );
217 free( ip );
218
219 ip = alloc( dim, FillC`fill );
220 test_base( ip, size, libAlign );
221 test_fill( ip, 0, size, FillC );
222 test_use( ip, size / elemSize );
223 free( ip );
224
225 ip = alloc( 0, FillC`fill );
226 test_base( ip, 0, libAlign );
227 free( ip );
228
229 ip = alloc( dim, FillT`fill );
230 test_base( ip, size, libAlign );
231 test_fill( ip, 0, dim, FillT );
232 test_use( ip, size / elemSize );
233 free( ip );
234
235 ip = alloc( 0, FillT`fill );
236 test_base( ip, 0, libAlign );
237 free( ip );
238
239 ip = alloc( dim, [FillA, dim/4]`fill );
240 test_base( ip, size, libAlign );
241 test_fill( ip, 0, size/4, FillA );
242 test_use( ip, size / elemSize );
243 free( ip );
244
245 ip = alloc( 0, [FillA, dim/4]`fill );
246 test_base( ip, 0, libAlign );
247 free( ip );
248
249 op = alloc( dim, 0xdeadbeefN`fill );
250 ip = alloc( dim, op`realloc, FillC`fill );
251 test_base( ip, size, libAlign );
252 test_fill( ip, 0, dim, 0xdeadbeefN );
253 test_use( ip, size / elemSize );
254 free( ip );
255
256 op = alloc( dim, 0xdeadbeefN`fill );
257 ip = alloc( dim / 4, op`realloc, FillC`fill );
258 test_base( ip, size / 4, libAlign );
259 test_fill( ip, 0, dim / 4, 0xdeadbeefN );
260 test_use( ip, size / 4 / elemSize );
261 free( ip );
262
263 op = alloc( dim, 0xdeadbeefN`fill );
264 ip = alloc( dim * 4, op`realloc, FillC`fill );
265 test_base( ip, size * 4, libAlign );
266 test_fill( ip, 0, dim, 0xdeadbeefN );
267 test_fill( ip, size, size * 4, FillC );
268 test_use( ip, size * 4 / elemSize );
269 free( ip );
270
271 op = alloc( dim, 0xdeadbeefN`fill );
272 ip = alloc( 0, op`realloc, FillC`fill );
273 test_base( ip, 0, libAlign );
274 free( ip );
275
276 ip = alloc( dim, 0p`realloc, FillC`fill );
277 test_base( ip, size, libAlign );
278 test_fill( ip, 0, size, FillC );
279 test_use( ip, size / elemSize );
280 free( ip );
281
282 ip = alloc( 0, 0p`realloc, FillC`fill );
283 test_base( ip, 0, libAlign );
284 free( ip );
285
286 op = alloc( dim, 0xdeadbeefN`fill );
287 ip = alloc( dim, op`realloc, FillT`fill );
288 test_base( ip, size, libAlign );
289 test_fill( ip, 0, dim, 0xdeadbeefN );
290 test_use( ip, size / elemSize );
291 free( ip );
292
293 op = alloc( dim, 0xdeadbeefN`fill );
294 ip = alloc( dim / 4, op`realloc, FillT`fill );
295 test_base( ip, size / 4, libAlign );
296 test_fill( ip, 0, dim / 4, 0xdeadbeefN );
297 test_use( ip, size / 4 / elemSize );
298 free( ip );
299
300 op = alloc( dim, 0xdeadbeefN`fill );
301 ip = alloc( dim * 4, op`realloc, FillT`fill );
302 test_base( ip, size * 4, libAlign );
303 test_fill( ip, 0, dim, 0xdeadbeefN );
304 test_fill( ip, dim, dim * 4, FillT );
305 test_use( ip, size * 4 / elemSize );
306 free( ip );
307
308 op = alloc( dim, 0xdeadbeefN`fill );
309 ip = alloc( 0, op`realloc, FillT`fill );
310 test_base( ip, 0, libAlign );
311 free( ip );
312
313 ip = alloc( dim, 0p`realloc, FillT`fill );
314 test_base( ip, size, libAlign );
315 test_fill( ip, 0, dim, FillT );
316 test_use( ip, size / elemSize );
317 free( ip );
318
319 ip = alloc( 0, 0p`realloc, FillT`fill );
320 test_base( ip, 0, libAlign );
321 free( ip );
322
323 ip = alloc( align`align );
324 test_base( ip, elemSize, align );
325 test_use( ip, elemSize / elemSize );
326 free( ip );
327
328 ip = alloc( dim, align`align );
329 test_base( ip, size, align );
330 test_use( ip, size / elemSize );
331 free( ip );
332
333 ip = alloc( 0, align`align );
334 test_base( ip, 0, libAlign );
335 free( ip );
336
337 op = alloc( dim, 0xdeadbeefN`fill );
338 ip = alloc( op`realloc, align`align );
339 test_base( ip, elemSize, align );
340 test_fill( ip, 0, 1, 0xdeadbeefN );
341 test_use( ip, elemSize / elemSize );
342 free( ip );
343
344 ip = alloc( 0p`realloc, align`align );
345 test_base( ip, elemSize, align );
346 test_use( ip, elemSize / elemSize );
347 free( ip );
348
349 dp = alloc( dim );
350 ip = alloc( dp`resize, align`align );
351 test_base( ip, elemSize, align );
352 test_use( ip, elemSize / elemSize );
353 free( ip );
354
355 ip = alloc( 0p`resize, align`align );
356 test_base( ip, elemSize, align );
357 test_use( ip, elemSize / elemSize );
358 free( ip );
359
360 op = alloc( dim, 0xdeadbeefN`fill );
361 ip = alloc( dim, op`realloc, align`align );
362 test_base( ip, size, align );
363 test_fill( ip, 0, dim, 0xdeadbeefN );
364 test_use( ip, size / elemSize );
365 free( ip );
366
367 op = alloc( dim, 0xdeadbeefN`fill );
368 ip = alloc( 0, op`realloc, align`align );
369 test_base( ip, 0, libAlign );
370 free( ip );
371
372 ip = alloc( dim, 0p`realloc, align`align );
373 test_base( ip, size, align );
374 test_use( ip, size / elemSize );
375 free( ip );
376
377 ip = alloc( 0, 0p`realloc, align`align );
378 test_base( ip, 0, libAlign );
379 free( ip );
380
381 ip = alloc( align`align, FillC`fill );
382 test_base( ip, elemSize, align );
383 test_fill( ip, 0, elemSize, FillC );
384 test_use( ip, elemSize / elemSize );
385 free( ip );
386
387 ip = alloc( align`align, FillT`fill );
388 test_base( ip, elemSize, align );
389 test_fill( ip, 0, 1, FillT );
390 test_use( ip, elemSize / elemSize );
391 free( ip );
392
393 ip = alloc( dim, align`align, FillC`fill );
394 test_base( ip, size, align );
395 test_fill( ip, 0, size, FillC );
396 test_use( ip, size / elemSize );
397 free( ip );
398
399 ip = alloc( 0, align`align, FillC`fill );
400 test_base( ip, 0, libAlign );
401 free( ip );
402
403 ip = alloc( dim, align`align, FillT`fill );
404 test_base( ip, size, align );
405 test_fill( ip, 0, dim, FillT );
406 test_use( ip, size / elemSize );
407 free( ip );
408
409 ip = alloc( 0, align`align, FillT`fill );
410 test_base( ip, 0, libAlign );
411 free( ip );
412
413 ip = alloc( dim, align`align, [FillA, dim/4]`fill );
414 test_base( ip, size, align );
415 test_fill( ip, 0, size/4, FillA );
416 test_use( ip, size / elemSize );
417 free( ip );
418
419 ip = alloc( 0, align`align, [FillA, dim/4]`fill );
420 test_base( ip, 0, libAlign );
421 free( ip );
422
423 op = alloc( dim, 0xdeadbeefN`fill );
424 ip = alloc( dim, op`realloc, align`align, FillC`fill );
425 test_base( ip, size, align );
426 test_fill( ip, 0, dim, 0xdeadbeefN );
427 test_use( ip, size / elemSize );
428 free( ip );
429
430 op = alloc( dim, 0xdeadbeefN`fill );
431 ip = alloc( dim / 4, op`realloc, align`align, FillC`fill );
432 test_base( ip, size / 4, align );
433 test_fill( ip, 0, dim / 4, 0xdeadbeefN );
434 test_use( ip, size / 4 / elemSize );
435 free( ip );
436
437 op = alloc( dim, 0xdeadbeefN`fill );
438 ip = alloc( dim * 4, op`realloc, align`align, FillC`fill );
439 test_base( ip, size * 4, align );
440 test_fill( ip, 0, dim, 0xdeadbeefN );
441 test_fill( ip, size, size * 4, FillC );
442 test_use( ip, size * 4 / elemSize );
443 free( ip );
444
445 op = alloc( dim, 0xdeadbeefN`fill );
446 ip = alloc( 0, op`realloc, align`align, FillC`fill );
447 test_base( ip, 0, libAlign );
448 free( ip );
449
450 ip = alloc( dim, 0p`realloc, align`align, FillC`fill );
451 test_base( ip, size, align );
452 test_fill( ip, 0, size, FillC );
453 test_use( ip, size / elemSize );
454 free( ip );
455
456 ip = alloc( 0, 0p`realloc, align`align, FillC`fill );
457 test_base( ip, 0, libAlign );
458 free( ip );
459
460 op = alloc( dim, 0xdeadbeefN`fill );
461 ip = alloc( dim, op`realloc, align`align, FillT`fill );
462 test_base( ip, size, align );
463 test_fill( ip, 0, dim, 0xdeadbeefN );
464 test_use( ip, size / elemSize );
465 free( ip );
466
467 op = alloc( dim, 0xdeadbeefN`fill );
468 ip = alloc( dim / 4, op`realloc, align`align, FillT`fill );
469 test_base( ip, size / 4, align );
470 test_fill( ip, 0, dim / 4, 0xdeadbeefN );
471 test_use( ip, size / 4 / elemSize );
472 free( ip );
473
474 op = alloc( dim, 0xdeadbeefN`fill );
475 ip = alloc( dim * 4, op`realloc, align`align, FillT`fill );
476 test_base( ip, size * 4, align );
477 test_fill( ip, 0, dim, 0xdeadbeefN );
478 test_fill( ip, dim, dim * 4, FillT );
479 test_use( ip, size * 4 / elemSize );
480 free( ip );
481
482 op = alloc( dim, 0xdeadbeefN`fill );
483 ip = alloc( 0, op`realloc, align`align, FillT`fill );
484 test_base( ip, 0, libAlign );
485 free( ip );
486
487 ip = alloc( dim, 0p`realloc, align`align, FillT`fill );
488 test_base( ip, size, align );
489 test_fill( ip, 0, dim, FillT );
490 test_use( ip, size / elemSize );
491 free( ip );
492
493 ip = alloc( 0, 0p`realloc, align`align, FillT`fill );
494 test_base( ip, 0, libAlign );
495 free( ip );
496
497 if ( tests_failed == 0 ) printf( "PASSED alloc tests\n\n" );
498 else printf( "failed alloc tests : %d/%d\n\n", tests_failed, tests_total );
499
500 // testing alloc ( aligned struct )
501
502 elemSize = sizeof(T1);
503 size = dim * elemSize;
504 last_failed = -1;
505 tests_total = 0;
506 tests_failed = 0;
507
508 t1p = alloc();
509 test_base( t1p, elemSize, tAlign );
510 test_use( t1p, elemSize / elemSize );
511 free( t1p );
512
513 t1p = alloc( dim );
514 test_base( t1p, size, tAlign );
515 test_use( t1p, size / elemSize );
516 free( t1p );
517
518 t1p = alloc( 0 );
519 test_base( t1p, 0, libAlign );
520 free( t1p );
521
522 dp = alloc( dim );
523 t1p = alloc( dp`resize );
524 test_base( t1p, elemSize, tAlign );
525 test_use( t1p, elemSize / elemSize );
526 free( t1p );
527
528 t1p = alloc( 0p`resize );
529 test_base( t1p, elemSize, tAlign );
530 test_use( t1p, elemSize / elemSize );
531 free( t1p );
532
533 dp = alloc( dim );
534 t1p = alloc( dim, dp`resize );
535 test_base( t1p, size, tAlign );
536 test_use( t1p, size / elemSize );
537 free( t1p );
538
539 dp = alloc( dim );
540 t1p = alloc( 0, dp`resize );
541 test_base( t1p, 0, libAlign );
542 free( t1p );
543
544 t1p = alloc( dim, 0p`resize );
545 test_base( t1p, size, tAlign );
546 test_use( t1p, size / elemSize );
547 free( t1p );
548
549 t1p = alloc( 0, 0p`resize );
550 test_base( t1p, 0, libAlign );
551 free( t1p );
552
553 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
554 t1p = alloc( dim, t1op`realloc );
555 test_base( t1p, size, tAlign );
556 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
557 test_use( t1p, size / elemSize );
558 free( t1p );
559
560 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
561 t1p = alloc( 0, t1op`realloc );
562 test_base( t1p, 0, libAlign );
563 free( t1p );
564
565 t1p = alloc( dim, 0p`realloc );
566 test_base( t1p, size, tAlign );
567 test_use( t1p, size / elemSize );
568 free( t1p );
569
570 t1p = alloc( 0, 0p`realloc );
571 test_base( t1p, 0, libAlign );
572 free( t1p );
573
574 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
575 t1p = alloc( dim, t1op`resize );
576 test_base( t1p, size, tAlign );
577 test_use( t1p, size / elemSize );
578 free( t1p );
579
580 t1p = alloc( FillC`fill );
581 test_base( t1p, elemSize, tAlign );
582 test_fill( t1p, 0, elemSize, FillC );
583 test_use( t1p, elemSize / elemSize );
584 free( t1p );
585
586 t1p = alloc( FillT1`fill );
587 test_base( t1p, elemSize, tAlign );
588 test_fill( t1p, 0, 1, FillT1);
589 test_use( t1p, elemSize / elemSize );
590 free( t1p );
591
592 t1p = alloc( dim, FillC`fill );
593 test_base( t1p, size, tAlign );
594 test_fill( t1p, 0, size, FillC );
595 test_use( t1p, size / elemSize );
596 free( t1p );
597
598 t1p = alloc( 0, FillC`fill );
599 test_base( t1p, 0, libAlign );
600 free( t1p );
601
602 t1p = alloc( dim, FillT1`fill );
603 test_base( t1p, size, tAlign );
604 test_fill( t1p, 0, dim, FillT1);
605 test_use( t1p, size / elemSize );
606 free( t1p );
607
608 t1p = alloc( 0, FillT1`fill );
609 test_base( t1p, 0, libAlign );
610 free( t1p );
611
612 t1p = alloc( dim, [FillT1A, dim / 4]`fill );
613 test_base( t1p, size, tAlign );
614 test_fill( t1p, 0, size/4, FillT1A );
615 test_use( t1p, size / elemSize );
616 free( t1p );
617
618 t1p = alloc( 0, [FillT1A, dim / 4]`fill );
619 test_base( t1p, 0, libAlign );
620 free( t1p );
621
622 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
623 t1p = alloc( dim, t1op`realloc, FillC`fill );
624 test_base( t1p, size, tAlign );
625 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
626 test_use( t1p, size / elemSize );
627 free( t1p );
628
629 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
630 t1p = alloc( dim / 4, t1op`realloc, FillC`fill );
631 test_base( t1p, size / 4, tAlign );
632 test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
633 test_use( t1p, size / 4 / elemSize );
634 free( t1p );
635
636 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
637 t1p = alloc( dim * 4, t1op`realloc, FillC`fill );
638 test_base( t1p, size * 4, tAlign );
639 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
640 test_fill( t1p, size, size * 4, FillC );
641 test_use( t1p, size * 4 / elemSize );
642 free( t1p );
643
644 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
645 t1p = alloc( 0, t1op`realloc, FillC`fill );
646 test_base( t1p, 0, libAlign );
647 free( t1p );
648
649 t1p = alloc( dim, 0p`realloc, FillC`fill );
650 test_base( t1p, size, tAlign );
651 test_fill( t1p, 0, size, FillC );
652 test_use( t1p, size / elemSize );
653 free( t1p );
654
655 t1p = alloc( 0, 0p`realloc, FillC`fill );
656 test_base( t1p, 0, libAlign );
657 free( t1p );
658
659 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
660 t1p = alloc( dim, t1op`realloc, FillT1`fill );
661 test_base( t1p, size, tAlign );
662 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
663 test_use( t1p, size / elemSize );
664 free( t1p );
665
666 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
667 t1p = alloc( dim / 4, t1op`realloc, FillT1`fill );
668 test_base( t1p, size / 4, tAlign );
669 test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
670 test_use( t1p, size / 4 / elemSize );
671 free( t1p );
672
673 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
674 t1p = alloc( dim * 4, t1op`realloc, FillT1`fill );
675 test_base( t1p, size * 4, tAlign );
676 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
677 test_fill( t1p, dim, dim * 4, FillT1);
678 test_use( t1p, size * 4 / elemSize );
679 free( t1p );
680
681 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
682 t1p = alloc( 0, t1op`realloc, FillT1`fill );
683 test_base( t1p, 0, libAlign );
684 free( t1p );
685
686 t1p = alloc( dim, 0p`realloc, FillT1`fill );
687 test_base( t1p, size, tAlign );
688 test_fill( t1p, 0, dim, FillT1);
689 test_use( t1p, size / elemSize );
690 free( t1p );
691
692 t1p = alloc( 0, 0p`realloc, FillT1`fill );
693 test_base( t1p, 0, libAlign );
694 free( t1p );
695
696 t1p = alloc( align`align );
697 test_base( t1p, elemSize, align );
698 test_use( t1p, elemSize / elemSize );
699 free( t1p );
700
701 t1p = alloc( dim, align`align );
702 test_base( t1p, size, align );
703 test_use( t1p, size / elemSize );
704 free( t1p );
705
706 t1p = alloc( 0, align`align );
707 test_base( t1p, 0, libAlign );
708 free( t1p );
709
710 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
711 t1p = alloc( t1op`realloc, align`align );
712 test_base( t1p, elemSize, align );
713 test_fill( t1p, 0, 1, (T1){0xdeadbeef});
714 test_use( t1p, elemSize / elemSize );
715 free( t1p );
716
717 t1p = alloc( 0p`realloc, align`align );
718 test_base( t1p, elemSize, align );
719 test_use( t1p, elemSize / elemSize );
720 free( t1p );
721
722 dp = alloc( dim );
723 t1p = alloc( dp`resize, align`align );
724 test_base( t1p, elemSize, align );
725 test_use( t1p, elemSize / elemSize );
726 free( t1p );
727
728 t1p = alloc( 0p`resize, align`align );
729 test_base( t1p, elemSize, align );
730 test_use( t1p, elemSize / elemSize );
731 free( t1p );
732
733 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
734 t1p = alloc( dim, t1op`realloc, align`align );
735 test_base( t1p, size, align );
736 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
737 test_use( t1p, size / elemSize );
738 free( t1p );
739
740 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
741 t1p = alloc( 0, t1op`realloc, align`align );
742 test_base( t1p, 0, libAlign );
743 free( t1p );
744
745 t1p = alloc( dim, 0p`realloc, align`align );
746 test_base( t1p, size, align );
747 test_use( t1p, size / elemSize );
748 free( t1p );
749
750 t1p = alloc( 0, 0p`realloc, align`align );
751 test_base( t1p, 0, libAlign );
752 free( t1p );
753
754 t1p = alloc( align`align, FillC`fill );
755 test_base( t1p, elemSize, align );
756 test_fill( t1p, 0, elemSize, FillC );
757 test_use( t1p, elemSize / elemSize );
758 free( t1p );
759
760 t1p = alloc( align`align, FillT1`fill );
761 test_base( t1p, elemSize, align );
762 test_fill( t1p, 0, 1, FillT1);
763 test_use( t1p, elemSize / elemSize );
764 free( t1p );
765
766 t1p = alloc( dim, align`align, FillC`fill );
767 test_base( t1p, size, align );
768 test_fill( t1p, 0, size, FillC );
769 test_use( t1p, size / elemSize );
770 free( t1p );
771
772 t1p = alloc( 0, align`align, FillC`fill );
773 test_base( t1p, 0, libAlign );
774 free( t1p );
775
776 t1p = alloc( dim, align`align, FillT1`fill );
777 test_base( t1p, size, align );
778 test_fill( t1p, 0, dim, FillT1);
779 test_use( t1p, size / elemSize );
780 free( t1p );
781
782 t1p = alloc( 0, align`align, FillT1`fill );
783 test_base( t1p, 0, libAlign );
784 free( t1p );
785
786 t1p = alloc( dim, align`align, [FillT1A, dim / 4]`fill );
787 test_base( t1p, size, align );
788 test_fill( t1p, 0, size/4, FillT1A );
789 test_use( t1p, size / elemSize );
790 free( t1p );
791
792 t1p = alloc( 0, align`align, [FillT1A, dim / 4]`fill );
793 test_base( t1p, 0, libAlign );
794 free( t1p );
795
796 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
797 t1p = alloc( dim, t1op`realloc, align`align, FillC`fill );
798 test_base( t1p, size, align );
799 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
800 test_use( t1p, size / elemSize );
801 free( t1p );
802
803 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
804 t1p = alloc( dim / 4, t1op`realloc, align`align, FillC`fill );
805 test_base( t1p, size / 4, align );
806 test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
807 test_use( t1p, size / 4 / elemSize );
808 free( t1p );
809
810 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
811 t1p = alloc( dim * 4, t1op`realloc, align`align, FillC`fill );
812 test_base( t1p, size * 4, align );
813 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
814 test_fill( t1p, size, size * 4, FillC );
815 test_use( t1p, size * 4 / elemSize );
816 free( t1p );
817
818 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
819 t1p = alloc( 0, t1op`realloc, align`align, FillC`fill );
820 test_base( t1p, 0, libAlign );
821 free( t1p );
822
823 t1p = alloc( dim, 0p`realloc, align`align, FillC`fill );
824 test_base( t1p, size, align );
825 test_fill( t1p, 0, size, FillC );
826 test_use( t1p, size / elemSize );
827 free( t1p );
828
829 t1p = alloc( 0, 0p`realloc, align`align, FillC`fill );
830 test_base( t1p, 0, libAlign );
831 free( t1p );
832
833 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
834 t1p = alloc( dim, t1op`realloc, align`align, FillT1`fill );
835 test_base( t1p, size, align );
836 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
837 test_use( t1p, size / elemSize );
838 free( t1p );
839
840 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
841 t1p = alloc( dim / 4, t1op`realloc, align`align, FillT1`fill );
842 test_base( t1p, size / 4, align );
843 test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
844 test_use( t1p, size / 4 / elemSize );
845 free( t1p );
846
847 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
848 t1p = alloc( dim * 4, t1op`realloc, align`align, FillT1`fill );
849 test_base( t1p, size * 4, align );
850 test_fill( t1p, 0, dim, (T1){0xdeadbeef});
851 test_fill( t1p, dim, dim * 4, FillT1);
852 test_use( t1p, size * 4 / elemSize );
853 free( t1p );
854
855 t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
856 t1p = alloc( 0, t1op`realloc, align`align, FillT1`fill );
857 test_base( t1p, 0, libAlign );
858 free( t1p );
859
860 t1p = alloc( dim, 0p`realloc, align`align, FillT1`fill );
861 test_base( t1p, size, align );
862 test_fill( t1p, 0, dim, FillT1);
863 test_use( t1p, size / elemSize );
864 free( t1p );
865
866 t1p = alloc( 0, 0p`realloc, align`align, FillT1`fill );
867 test_base( t1p, 0, libAlign );
868 free( t1p );
869
870 if ( tests_failed == 0) printf( "PASSED alloc tests (aligned struct)\n\n");
871 else printf( "failed alloc tests ( aligned struct ) : %d/%d\n\n", tests_failed, tests_total );
872
873 printf( "(if applicable) alignment error below indicates memory trashing caused by test_use.\n\n");
874 free( FillA );
875 free( FillT1A );
876} // main
Note: See TracBrowser for help on using the repository browser.