source: tests/alloc2.cfa @ a0dbf20

ADTast-experimentalpthread-emulation
Last change on this file since a0dbf20 was 1988572, checked in by Peter A. Buhr <pabuhr@…>, 2 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.