source: tests/alloc2.cfa @ b6f2e7ab

Last change on this file since b6f2e7ab was 116a2ea, checked in by Peter A. Buhr <pabuhr@…>, 2 years ago

new heap and associated tests updated
  • Property mode set to 100644
File size: 23.5 KB
Line 
1#include <fstream.hfa>                                                                  // sout
2#include <malloc.h>                                                                             // malloc_usable_size
3#include <stdint.h>                                                                             // uintptr_t
4#include <stdlib.hfa>                                                                   // access C malloc, realloc
5#include <string.h>                                                                             // memcmp
6
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        // sout | "DEBUG: starting test" | 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                sout | "base failed test" | tests_total | "ip" | ip | "size" | size | "align" | align | "but got size" | malloc_size( ip ) | "usable" | malloc_usable_size( ip ) | "align" | malloc_alignment( ip );
19                tests_failed += 1;
20        } // if
21        // sout | "DEBUG: done test" | tests_total;
22}
23
24void test_fill( void * ip_, size_t start, size_t end, char fill ) {
25        tests_total += 1;
26        // sout | "DEBUG: starting test" | 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                sout | "fill1 failed test" | tests_total | "fill C";
32                tests_failed += 1;
33        } // if
34        // sout | "DEBUG: done test" | tests_total;
35}
36
37void test_fill( void * ip_, size_t start, size_t end, int fill ) {
38        tests_total += 1;
39        // sout | "DEBUG: starting test" 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                sout | "fill2 failed test" | tests_total | "fill int";
45                tests_failed += 1;
46        } // if
47        // sout | "DEBUG: done test" | tests_total;
48}
49
50void test_fill( void * ip_, size_t start, size_t end, int * fill ) {
51        tests_total += 1;
52        // sout | "DEBUG: starting test" | tests_total;
53        bool passed = memcmp((void*)((uintptr_t )ip_ + start ), (void*)fill, end ) == 0;
54        if ( ! passed ) {
55                sout | "fill3 failed test" | tests_total | "fill int A";
56                tests_failed += 1;
57        } // if
58        // sout | "DEBUG: done test" | tests_total;
59}
60
61void test_fill( void * ip_, size_t start, size_t end, T1 fill ) {
62        tests_total += 1;
63        // sout | "DEBUG: starting test" | 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                sout | "fill4 failed test" | tests_total | "fill T1";
69                tests_failed += 1;
70        } // if
71        // sout | "DEBUG: done test" | tests_total;
72}
73
74void test_fill( void * ip_, size_t start, size_t end, T1 * fill ) {
75        tests_total += 1;
76        // sout | "DEBUG: starting test" | tests_total;
77        bool passed = memcmp( (void*)((uintptr_t )ip_ + start ), (void*)fill, end ) == 0;
78        if ( ! passed ) {
79                sout | "fill5 failed test" | tests_total | "fill T1 A";
80                tests_failed += 1;
81        } // if
82        // sout | "DEBUG: done test" | tests_total;
83}
84
85void test_use( int * ip, size_t dim ) {
86        tests_total += 1;
87        // sout | "DEBUG: starting test" | 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                sout | "use1 failed test" | tests_total | "use int";
93                tests_failed += 1;
94        } // if
95        // sout | "DEBUG: done test" | tests_total;
96}
97
98void test_use( T1 * ip, size_t dim ) {
99        tests_total += 1;
100        // sout | "DEBUG: starting test" | 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                sout | "use2 failed test" | tests_total | "use T1";
106                tests_failed += 1;
107        } // if
108        // sout | "DEBUG: done test" | 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
120        T1 FillT1 = { FillT };
121        T1 * FillT1A = (T1 *)(void *) malloc( (dim / 4) * sizeof(T1) );
122        for ( i; 0 ~ (dim / 4) ) FillT1A[i] = FillT1;
123
124        int * ip;
125        int * op;
126        double * dp;
127        T1 * t1p;
128        T1 * t1op;
129
130        // testing alloc
131
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( 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 ) sout | "PASSED alloc tests" | nl | nl;
498        else sout | "failed alloc tests :" | tests_failed | tests_total | nl | nl;
499
500        // testing alloc (aligned struct)
501
502        elemSize = sizeof(T1);
503        size = dim * elemSize;
504        tests_total = 0;
505        tests_failed = 0;
506
507        t1p = alloc();
508        test_base( t1p, elemSize, tAlign );
509        test_use( t1p, elemSize / elemSize );
510        free( t1p );
511
512        t1p = alloc( dim );
513        test_base( t1p, size, tAlign );
514        test_use( t1p, size / elemSize );
515        free( t1p );
516
517        t1p = alloc( 0 );
518        test_base( t1p, 0, libAlign );
519        free( t1p );
520
521        dp = alloc( dim );
522        t1p = alloc( dp`resize );
523        test_base( t1p, elemSize, tAlign );
524        test_use( t1p, elemSize / elemSize );
525        free( t1p );
526
527        t1p = alloc( 0p`resize );
528        test_base( t1p, elemSize, tAlign );
529        test_use( t1p, elemSize / elemSize );
530        free( t1p );
531
532        dp = alloc( dim );
533        t1p = alloc( dim, dp`resize );
534        test_base( t1p, size, tAlign );
535        test_use( t1p, size / elemSize );
536        free( t1p );
537
538        dp = alloc( dim );
539        t1p = alloc( 0, dp`resize );
540        test_base( t1p, 0, libAlign );
541        free( t1p );
542
543        t1p = alloc( dim, 0p`resize );
544        test_base( t1p, size, tAlign );
545        test_use( t1p, size / elemSize );
546        free( t1p );
547
548        t1p = alloc( 0, 0p`resize );
549        test_base( t1p, 0, libAlign );
550        free( t1p );
551
552        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
553        t1p = alloc( dim, t1op`realloc );
554        test_base( t1p, size, tAlign );
555        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
556        test_use( t1p, size / elemSize );
557        free( t1p );
558
559        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
560        t1p = alloc( 0, t1op`realloc );
561        test_base( t1p, 0, libAlign );
562        free( t1p );
563
564        t1p = alloc( dim, 0p`realloc );
565        test_base( t1p, size, tAlign );
566        test_use( t1p, size / elemSize );
567        free( t1p );
568
569        t1p = alloc( 0, 0p`realloc );
570        test_base( t1p, 0, libAlign );
571        free( t1p );
572
573        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
574        t1p = alloc( dim, t1op`resize );
575        test_base( t1p, size, tAlign );
576        test_use( t1p, size / elemSize );
577        free( t1p );
578
579        t1p = alloc( FillC`fill );
580        test_base( t1p, elemSize, tAlign );
581        test_fill( t1p, 0, elemSize, FillC );
582        test_use( t1p, elemSize / elemSize );
583        free( t1p );
584
585        t1p = alloc( FillT1`fill );
586        test_base( t1p, elemSize, tAlign );
587        test_fill( t1p, 0, 1, FillT1);
588        test_use( t1p, elemSize / elemSize );
589        free( t1p );
590
591        t1p = alloc( dim, FillC`fill );
592        test_base( t1p, size, tAlign );
593        test_fill( t1p, 0, size, FillC );
594        test_use( t1p, size / elemSize );
595        free( t1p );
596
597        t1p = alloc( 0, FillC`fill );
598        test_base( t1p, 0, libAlign );
599        free( t1p );
600
601        t1p = alloc( dim, FillT1`fill );
602        test_base( t1p, size, tAlign );
603        test_fill( t1p, 0, dim, FillT1);
604        test_use( t1p, size / elemSize );
605        free( t1p );
606
607        t1p = alloc( 0, FillT1`fill );
608        test_base( t1p, 0, libAlign );
609        free( t1p );
610
611        t1p = alloc( dim, [FillT1A, dim / 4]`fill );
612        test_base( t1p, size, tAlign );
613        test_fill( t1p, 0, size/4, FillT1A );
614        test_use( t1p, size / elemSize );
615        free( t1p );
616
617        t1p = alloc( 0, [FillT1A, dim / 4]`fill );
618        test_base( t1p, 0, libAlign );
619        free( t1p );
620
621        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
622        t1p = alloc( dim, t1op`realloc, FillC`fill );
623        test_base( t1p, size, tAlign );
624        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
625        test_use( t1p, size / elemSize );
626        free( t1p );
627
628        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
629        t1p = alloc( dim / 4, t1op`realloc, FillC`fill );
630        test_base( t1p, size / 4, tAlign );
631        test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
632        test_use( t1p, size / 4 / elemSize );
633        free( t1p );
634
635        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
636        t1p = alloc( dim * 4, t1op`realloc, FillC`fill );
637        test_base( t1p, size * 4, tAlign );
638        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
639        test_fill( t1p, size, size * 4, FillC );
640        test_use( t1p, size * 4 / elemSize );
641        free( t1p );
642
643        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
644        t1p = alloc( 0, t1op`realloc, FillC`fill );
645        test_base( t1p, 0, libAlign );
646        free( t1p );
647
648        t1p = alloc( dim, 0p`realloc, FillC`fill );
649        test_base( t1p, size, tAlign );
650        test_fill( t1p, 0, size, FillC );
651        test_use( t1p, size / elemSize );
652        free( t1p );
653
654        t1p = alloc( 0, 0p`realloc, FillC`fill );
655        test_base( t1p, 0, libAlign );
656        free( t1p );
657
658        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
659        t1p = alloc( dim, t1op`realloc, FillT1`fill );
660        test_base( t1p, size, tAlign );
661        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
662        test_use( t1p, size / elemSize );
663        free( t1p );
664
665        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
666        t1p = alloc( dim / 4, t1op`realloc, FillT1`fill );
667        test_base( t1p, size / 4, tAlign );
668        test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
669        test_use( t1p, size / 4 / elemSize );
670        free( t1p );
671
672        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
673        t1p = alloc( dim * 4, t1op`realloc, FillT1`fill );
674        test_base( t1p, size * 4, tAlign );
675        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
676        test_fill( t1p, dim, dim * 4, FillT1);
677        test_use( t1p, size * 4 / elemSize );
678        free( t1p );
679
680        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
681        t1p = alloc( 0, t1op`realloc, FillT1`fill );
682        test_base( t1p, 0, libAlign );
683        free( t1p );
684
685        t1p = alloc( dim, 0p`realloc, FillT1`fill );
686        test_base( t1p, size, tAlign );
687        test_fill( t1p, 0, dim, FillT1);
688        test_use( t1p, size / elemSize );
689        free( t1p );
690
691        t1p = alloc( 0, 0p`realloc, FillT1`fill );
692        test_base( t1p, 0, libAlign );
693        free( t1p );
694
695        t1p = alloc( align`align );
696        test_base( t1p, elemSize, align );
697        test_use( t1p, elemSize / elemSize );
698        free( t1p );
699
700        t1p = alloc( dim, align`align );
701        test_base( t1p, size, align );
702        test_use( t1p, size / elemSize );
703        free( t1p );
704
705        t1p = alloc( 0, align`align );
706        test_base( t1p, 0, libAlign );
707        free( t1p );
708
709        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
710        t1p = alloc( t1op`realloc, align`align );
711        test_base( t1p, elemSize, align );
712        test_fill( t1p, 0, 1, (T1){0xdeadbeef});
713        test_use( t1p, elemSize / elemSize );
714        free( t1p );
715
716        t1p = alloc( 0p`realloc, align`align );
717        test_base( t1p, elemSize, align );
718        test_use( t1p, elemSize / elemSize );
719        free( t1p );
720
721        dp = alloc( dim );
722        t1p = alloc( dp`resize, align`align );
723        test_base( t1p, elemSize, align );
724        test_use( t1p, elemSize / elemSize );
725        free( t1p );
726
727        t1p = alloc( 0p`resize, align`align );
728        test_base( t1p, elemSize, align );
729        test_use( t1p, elemSize / elemSize );
730        free( t1p );
731
732        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
733        t1p = alloc( dim, t1op`realloc, align`align );
734        test_base( t1p, size, align );
735        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
736        test_use( t1p, size / elemSize );
737        free( t1p );
738
739        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
740        t1p = alloc( 0, t1op`realloc, align`align );
741        test_base( t1p, 0, libAlign );
742        free( t1p );
743
744        t1p = alloc( dim, 0p`realloc, align`align );
745        test_base( t1p, size, align );
746        test_use( t1p, size / elemSize );
747        free( t1p );
748
749        t1p = alloc( 0, 0p`realloc, align`align );
750        test_base( t1p, 0, libAlign );
751        free( t1p );
752
753        t1p = alloc( align`align, FillC`fill );
754        test_base( t1p, elemSize, align );
755        test_fill( t1p, 0, elemSize, FillC );
756        test_use( t1p, elemSize / elemSize );
757        free( t1p );
758
759        t1p = alloc( align`align, FillT1`fill );
760        test_base( t1p, elemSize, align );
761        test_fill( t1p, 0, 1, FillT1);
762        test_use( t1p, elemSize / elemSize );
763        free( t1p );
764
765        t1p = alloc( dim, align`align, FillC`fill );
766        test_base( t1p, size, align );
767        test_fill( t1p, 0, size, FillC );
768        test_use( t1p, size / elemSize );
769        free( t1p );
770
771        t1p = alloc( 0, align`align, FillC`fill );
772        test_base( t1p, 0, libAlign );
773        free( t1p );
774
775        t1p = alloc( dim, align`align, FillT1`fill );
776        test_base( t1p, size, align );
777        test_fill( t1p, 0, dim, FillT1);
778        test_use( t1p, size / elemSize );
779        free( t1p );
780
781        t1p = alloc( 0, align`align, FillT1`fill );
782        test_base( t1p, 0, libAlign );
783        free( t1p );
784
785        t1p = alloc( dim, align`align, [FillT1A, dim / 4]`fill );
786        test_base( t1p, size, align );
787        test_fill( t1p, 0, size/4, FillT1A );
788        test_use( t1p, size / elemSize );
789        free( t1p );
790
791        t1p = alloc( 0, align`align, [FillT1A, dim / 4]`fill );
792        test_base( t1p, 0, libAlign );
793        free( t1p );
794
795        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
796        t1p = alloc( dim, t1op`realloc, align`align, FillC`fill );
797        test_base( t1p, size, align );
798        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
799        test_use( t1p, size / elemSize );
800        free( t1p );
801
802        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
803        t1p = alloc( dim / 4, t1op`realloc, align`align, FillC`fill );
804        test_base( t1p, size / 4, align );
805        test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
806        test_use( t1p, size / 4 / elemSize );
807        free( t1p );
808
809        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
810        t1p = alloc( dim * 4, t1op`realloc, align`align, FillC`fill );
811        test_base( t1p, size * 4, align );
812        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
813        test_fill( t1p, size, size * 4, FillC );
814        test_use( t1p, size * 4 / elemSize );
815        free( t1p );
816
817        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
818        t1p = alloc( 0, t1op`realloc, align`align, FillC`fill );
819        test_base( t1p, 0, libAlign );
820        free( t1p );
821
822        t1p = alloc( dim, 0p`realloc, align`align, FillC`fill );
823        test_base( t1p, size, align );
824        test_fill( t1p, 0, size, FillC );
825        test_use( t1p, size / elemSize );
826        free( t1p );
827
828        t1p = alloc( 0, 0p`realloc, align`align, FillC`fill );
829        test_base( t1p, 0, libAlign );
830        free( t1p );
831
832        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
833        t1p = alloc( dim, t1op`realloc, align`align, FillT1`fill );
834        test_base( t1p, size, align );
835        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
836        test_use( t1p, size / elemSize );
837        free( t1p );
838
839        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
840        t1p = alloc( dim / 4, t1op`realloc, align`align, FillT1`fill );
841        test_base( t1p, size / 4, align );
842        test_fill( t1p, 0, dim / 4, (T1){0xdeadbeef});
843        test_use( t1p, size / 4 / elemSize );
844        free( t1p );
845
846        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
847        t1p = alloc( dim * 4, t1op`realloc, align`align, FillT1`fill );
848        test_base( t1p, size * 4, align );
849        test_fill( t1p, 0, dim, (T1){0xdeadbeef});
850        test_fill( t1p, dim, dim * 4, FillT1);
851        test_use( t1p, size * 4 / elemSize );
852        free( t1p );
853
854        t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
855        t1p = alloc( 0, t1op`realloc, align`align, FillT1`fill );
856        test_base( t1p, 0, libAlign );
857        free( t1p );
858
859        t1p = alloc( dim, 0p`realloc, align`align, FillT1`fill );
860        test_base( t1p, size, align );
861        test_fill( t1p, 0, dim, FillT1);
862        test_use( t1p, size / elemSize );
863        free( t1p );
864
865        t1p = alloc( 0, 0p`realloc, align`align, FillT1`fill );
866        test_base( t1p, 0, libAlign );
867        free( t1p );
868
869        if ( tests_failed == 0) sout | "PASSED alloc tests (aligned struct)" | nl | nl;
870        else sout | "failed alloc tests ( aligned struct ) :" | tests_failed | tests_total | nl;
871
872        sout | "(if applicable) alignment error below indicates memory trashing caused by test_use." | nl | nl;
873        free( FillA );
874        free( FillT1A );
875} // main
Note: See TracBrowser for help on using the repository browser.