source: tests/alloc2.cfa @ 8f2f185

ADTast-experimentalenumpthread-emulationqualifiedEnum
Last change on this file since 8f2f185 was ea561c9, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago

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