source: tests/alloc2.cfa@ aaf92de

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since aaf92de was ea561c9, checked in by Peter A. Buhr <pabuhr@…>, 5 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.