source: tests/alloc2.cfa@ dcac8bf1

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 dcac8bf1 was 191a190, checked in by m3zulfiq <m3zulfiq@…>, 5 years ago

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