source: tests/malloc.cfa @ f76ff0b

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since f76ff0b was f76ff0b, checked in by m3zulfiq <m3zulfiq@…>, 15 months ago

alloc2.txt: added expected output file for test alloc2.cfa. heap.cfa: removed alignment bugs from realloc and resize with alignment. stdlib.hfa: removed debug prints from alloc interface. alloc2.cfa, malloc.cfa: uncommented tests that were previously commented because of a bug in realloc and resize.

  • Property mode set to 100644
File size: 13.1 KB
Line 
1#include <assert.h>
2#include <malloc.h>                                                                             // malloc_usable_size
3#include <stdint.h>                                                                             // uintptr_t
4#include <stdlib.h>                                                                             // posix_memalign
5#include <fstream.hfa>
6#include <stdlib.hfa>                                                                   // access C malloc, realloc
7#include <unistd.h>                                                                             // getpagesize
8
9int tests_total;
10int tests_failed;
11size_t tAlign = 32;
12struct S1 { int d1; } __attribute__((aligned(32)));
13typedef struct S1 T1;
14
15void test_base( void * ip, size_t size, size_t align) {
16        tests_total += 1;
17        bool passed = (malloc_size(ip) == size) && (malloc_usable_size(ip) >= size) && (malloc_alignment(ip) == align) && ((uintptr_t)ip % align  == 0);
18        if (!passed) {
19                printf("failed test %2d: %4lu %4lu but got %4lu ( %3lu ) %4lu\n", tests_total, size, align, malloc_size(ip), malloc_usable_size(ip), malloc_alignment(ip));
20                tests_failed += 1;
21        }
22}
23
24void test_fill( void * ip_, size_t start, size_t end, char fill) {
25        tests_total += 1;
26        bool passed = true;
27        char * ip = (char *) ip_;
28        for (i; start ~ end) passed = passed && (ip[i] == fill);
29        if (!passed) {
30                printf("failed test %2d: fill\n", tests_total);
31                tests_failed += 1;
32        }
33}
34
35void test_use( void * ip_) {
36        tests_total += 1;
37        bool passed = true;
38        int * ip = (int *) ip_;
39        size_t size = malloc_size(ip);
40        for (i; 0 ~ size ~ sizeof(int)) ip[i/sizeof(int)] = 0xdeadbeef;
41        for (i; 0 ~ size ~ sizeof(int)) passed = passed &&  (ip[i/sizeof(int)] == 0xdeadbeef);
42        size_t usize = malloc_usable_size(ip);
43        for (i; size ~ usize ~ sizeof(int)) ip[i/sizeof(int)] = -1;
44        for (i; size ~ usize ~ sizeof(int)) passed = passed &&  (ip[i/sizeof(int)] == -1);
45        if (!passed) {
46                printf("failed test %2d: use\n", tests_total);
47                tests_failed += 1;
48        }
49}
50
51int main( void ) {
52        size_t elemSize = sizeof(int);
53        size_t dim = 8;
54        size_t size = dim * elemSize;
55        size_t align = 64;
56        const size_t libAlign = libAlign();
57        char fill = '\xde';
58        int * ip;
59        T1 * tp;
60
61        // testing C   malloc
62
63        tests_total = 0;
64        tests_failed = 0;
65
66        ip = (int *) (void *) malloc( size );
67        test_base(ip, size, libAlign);
68        test_use(ip);
69        free(ip);
70
71        ip = (int *) (void *) malloc( 0 );
72        test_base(ip, 0, libAlign);
73        test_use(ip);
74        free(ip);
75
76        ip = (int *) (void *) aalloc( dim, elemSize );
77        test_base(ip, size, libAlign);
78        test_use(ip);
79        free(ip);
80
81        ip = (int *) (void *) aalloc( 0, elemSize );
82        test_base(ip, 0, libAlign);
83        test_use(ip);
84        free(ip);
85
86        ip = (int *) (void *) aalloc( dim, 0 );
87        test_base(ip, 0, libAlign);
88        test_use(ip);
89        free(ip);
90
91        ip = (int *) (void *) aalloc( 0, 0 );
92        test_base(ip, 0, libAlign);
93        test_use(ip);
94        free(ip);
95
96        ip = (int *) (void *) calloc( dim, elemSize );
97        test_base(ip, size, libAlign);
98        test_fill(ip, 0, size, '\0');
99        test_use(ip);
100        free(ip);
101
102        ip = (int *) (void *) calloc( 0, elemSize );
103        test_base(ip, 0, libAlign);
104        test_fill(ip, 0, 0, '\0');
105        test_use(ip);
106        free(ip);
107
108        ip = (int *) (void *) calloc( dim, 0 );
109        test_base(ip, 0, libAlign);
110        test_fill(ip, 0, 0, '\0');
111        test_use(ip);
112        free(ip);
113
114        ip = (int *) (void *) malloc( size );
115        ip = (int *) (void *) resize( (void *) ip, size / 4 );
116        test_base(ip, size / 4, libAlign);
117        test_use(ip);
118        free(ip);
119
120        ip = (int *) (void *) malloc( size );
121        ip = (int *) (void *) resize( (void *) ip, size * 4 );
122        test_base(ip, size * 4, libAlign);
123        test_use(ip);
124        free(ip);
125
126        ip = (int *) (void *) malloc( size );
127        ip = (int *) (void *) resize( (void *) ip, 0 );
128        test_base(ip, 0, libAlign);
129        test_use(ip);
130        free(ip);
131
132        ip = (int *) (void *) resize( NULL, size );
133        test_base(ip, size, libAlign);
134        test_use(ip);
135        free(ip);
136
137        ip = (int *) (void *) resize( 0p, size );
138        test_base(ip, size, libAlign);
139        test_use(ip);
140        free(ip);
141
142        ip = (int *) (void *) calloc( dim, elemSize );
143        ip = (int *) (void *) realloc( (void *) ip, size / 4 );
144        test_base(ip, size / 4, libAlign);
145        test_fill(ip, 0, size / 4, '\0');
146        test_use(ip);
147        free(ip);
148
149        ip = (int *) (void *) calloc( dim, elemSize );
150        ip = (int *) (void *) realloc( (void *) ip, size * 4 );
151        test_base(ip, size * 4, libAlign);
152        test_fill(ip, 0, size * 4, '\0');
153        test_use(ip);
154        free(ip);
155
156        ip = (int *) (void *) calloc( dim, elemSize );
157        ip = (int *) (void *) realloc( (void *) ip, 0 );
158        test_base(ip, 0, libAlign);
159        test_use(ip);
160        free(ip);
161
162        ip = (int *) (void *) realloc( NULL, size  );
163        test_base(ip, size , libAlign);
164        test_use(ip);
165        free(ip);
166
167        ip = (int *) (void *) realloc( 0p, size );
168        test_base(ip, size, libAlign);
169        test_use(ip);
170        free(ip);
171
172        ip = (int *) (void *) memalign( align, size );
173        test_base(ip, size, align);
174        test_use(ip);
175        free(ip);
176
177        ip = (int *) (void *) memalign( align, 0 );
178        test_base(ip, 0, libAlign);
179        test_use(ip);
180        free(ip);
181
182        ip = (int *) (void *) amemalign( align, dim, elemSize );
183        test_base(ip, size, align);
184        test_use(ip);
185        free(ip);
186
187        ip = (int *) (void *) amemalign( align, 0, elemSize );
188        test_base(ip, 0, libAlign);
189        test_use(ip);
190        free(ip);
191
192        ip = (int *) (void *) amemalign( align, dim, 0 );
193        test_base(ip, 0, libAlign);
194        test_use(ip);
195        free(ip);
196
197        ip = (int *) (void *) cmemalign( align, dim, elemSize );
198        test_base(ip, size, align);
199        test_fill(ip, 0, size, '\0');
200        test_use(ip);
201        free(ip);
202
203        ip = (int *) (void *) cmemalign( align, 0, elemSize );
204        test_base(ip, 0, libAlign);
205        test_use(ip);
206        free(ip);
207
208        ip = (int *) (void *) cmemalign( align, dim, 0 );
209        test_base(ip, 0, libAlign);
210        test_use(ip);
211        free(ip);
212
213        ip = (int *) (void *) aligned_alloc( align, size );
214        test_base(ip, size, align);
215        test_use(ip);
216        free(ip);
217
218        ip = (int *) (void *) aligned_alloc( align, 0 );
219        test_base(ip, 0, libAlign);
220        test_use(ip);
221        free(ip);
222
223        (int) posix_memalign( (void **) &ip, align, size );
224        test_base(ip, size, align);
225        test_use(ip);
226        free(ip);
227
228        (int) posix_memalign( (void **) &ip, align, 0 );
229        test_base(ip, 0, libAlign);
230        test_use(ip);
231        free(ip);
232
233        ip = (int *) (void *) valloc( size );
234        test_base(ip, size, getpagesize());
235        test_use(ip);
236        free(ip);
237
238        ip = (int *) (void *) valloc( 0 );
239        test_base(ip, 0, libAlign);
240        test_use(ip);
241        free(ip);
242
243        ip = (int *) (void *) pvalloc( getpagesize() * 3 / 2 );
244        test_base(ip, getpagesize() * 2, getpagesize());
245        test_use(ip);
246        free(ip);
247
248        ip = (int *) (void *) pvalloc( 0 );
249        test_base(ip, 0, libAlign);
250        test_use(ip);
251        free(ip);
252
253        ip = (int *) (void *) malloc( size );
254        ip = (int *) (void *) resize( (void *) ip, libAlign, size / 2 );
255        test_base(ip, size / 2, libAlign);
256        test_use(ip);
257        free(ip);
258
259        ip = (int *) (void *) aligned_alloc( align, size );
260        ip = (int *) (void *) resize( (void *) ip, align, size / 2 );
261        test_base(ip, size / 2, align);
262        test_use(ip);
263        free(ip);
264
265        ip = (int *) (void *) malloc( size );
266        ip = (int *) (void *) resize( (void *) ip, align, size / 4 );
267        test_base(ip, size / 4, align);
268        test_use(ip);
269        free(ip);
270
271        ip = (int *) (void *) malloc( size );
272        ip = (int *) (void *) resize( (void *) ip, align, 0 );
273        test_base(ip, 0, libAlign);
274        test_use(ip);
275        free(ip);
276
277        ip = (int *) (void *) resize( NULL, align, size );
278        test_base(ip, size, align);
279        test_use(ip);
280        free(ip);
281
282        ip = (int *) (void *) resize( 0p, align, size );
283        test_base(ip, size, align);
284        test_use(ip);
285        free(ip);
286
287        ip = (int *) (void *) calloc( dim, elemSize );
288        ip = (int *) (void *) realloc( (void *) ip, libAlign, size / 2 );
289        test_base(ip, size / 2, libAlign);
290        test_fill(ip, 0, size / 2, '\0');
291        test_use(ip);
292        free(ip);
293
294        ip = (int *) (void *) cmemalign( align, dim, elemSize );
295        ip = (int *) (void *) realloc( (void *) ip, align, size / 2 );
296        test_base(ip, size / 2, align);
297        test_fill(ip, 0, size / 2, '\0');
298        test_use(ip);
299        free(ip);
300
301        ip = (int *) (void *) calloc( dim, elemSize );
302        ip = (int *) (void *) realloc( (void *) ip, align, size / 4 );
303        test_base(ip, size / 4, align);
304        test_fill(ip, 0, size / 4, '\0');
305        test_use(ip);
306        free(ip);
307
308        ip = (int *) (void *) calloc( dim, elemSize );
309        ip = (int *) (void *) realloc( (void *) ip, 0, size * 4 );
310        test_base(ip, size * 4, libAlign);
311        test_fill(ip, 0, size * 4, '\0');
312        test_use(ip);
313        free(ip);
314
315        ip = (int *) (void *) calloc( dim, elemSize );
316        ip = (int *) (void *) realloc( (void *) ip, align, 0 );
317        test_base(ip, 0, libAlign);
318        test_use(ip);
319        free(ip);
320
321        free( 0p ); // sanity check
322        free( NULL ); // sanity check
323
324        if (tests_failed == 0) printf("PASSED C malloc tests\n\n");
325        else printf("failed C malloc tests : %d/%d\n\n", tests_failed, tests_total);
326
327        // testing CFA malloc
328
329        tests_total = 0;
330        tests_failed = 0;
331
332        ip = malloc();
333        test_base(ip, elemSize, libAlign);
334        test_use(ip);
335        free(ip);
336
337        ip = aalloc( dim );
338        test_base(ip, size, libAlign);
339        test_use(ip);
340        free(ip);
341
342        ip = aalloc( 0 );
343        test_base(ip, 0, libAlign);
344        test_use(ip);
345        free(ip);
346
347        ip = calloc( dim );
348        test_base(ip, size, libAlign);
349        test_fill(ip, 0, size, '\0');
350        test_use(ip);
351        free(ip);
352
353        ip = calloc( 0 );
354        test_base(ip, 0, libAlign);
355        test_use(ip);
356        free(ip);
357
358        ip = aalloc( dim );
359        ip = resize( ip, size / 4 );
360        test_base(ip, size / 4, libAlign);
361        test_use(ip);
362        free(ip);
363
364        ip = aalloc( dim );
365        ip = resize( ip, size * 4 );
366        test_base(ip, size * 4, libAlign);
367        test_use(ip);
368        free(ip);
369
370        ip = aalloc( dim );
371        ip = resize( ip, 0 );
372        test_base(ip, 0, libAlign);
373        test_use(ip);
374        free(ip);
375
376        ip = resize( (int*)0p, size );
377        test_base(ip, size, libAlign);
378        test_use(ip);
379        free(ip);
380
381        ip = resize( (int*)0p, size );
382        test_base(ip, size, libAlign);
383        test_use(ip);
384        free(ip);
385
386        ip = calloc( dim );
387        ip = realloc( ip, size / 4 );
388        test_base(ip, size / 4, libAlign);
389        test_fill(ip, 0, size / 4, '\0');
390        test_use(ip);
391        free(ip);
392
393        ip = calloc( dim );
394        ip = realloc( ip, size * 4 );
395        test_base(ip, size * 4, libAlign);
396        test_fill(ip, 0, size, '\0');
397        test_use(ip);
398        free(ip);
399
400        ip = calloc( dim );
401        ip = realloc( ip, 0 );
402        test_base(ip, 0, libAlign);
403        test_use(ip);
404        free(ip);
405
406        ip = realloc( (int*)0p, size );
407        test_base(ip, size , libAlign);
408        test_use(ip);
409        free(ip);
410
411        ip = realloc( (int*)0p, size );
412        test_base(ip, size, libAlign);
413        test_use(ip);
414        free(ip);
415
416        ip = memalign( align );
417        test_base(ip, elemSize, align);
418        test_use(ip);
419        free(ip);
420
421        ip = amemalign( align, dim );
422        test_base(ip, size, align);
423        test_use(ip);
424        free(ip);
425
426        ip = amemalign( align, 0 );
427        test_base(ip, 0, libAlign);
428        test_use(ip);
429        free(ip);
430
431        ip = cmemalign( align, dim );
432        test_base(ip, size, align);
433        test_fill(ip, 0, size, '\0');
434        test_use(ip);
435        free(ip);
436
437        ip = cmemalign( align, 0 );
438        test_base(ip, 0, libAlign);
439        test_use(ip);
440        free(ip);
441
442        ip = aligned_alloc( align );
443        test_base(ip, elemSize, align);
444        test_use(ip);
445        free(ip);
446
447        (int) posix_memalign( (int **) &ip, align );
448        test_base(ip, elemSize, align);
449        test_use(ip);
450        free(ip);
451
452        ip = valloc();
453        test_base(ip, elemSize, getpagesize());
454        test_use(ip);
455        free(ip);
456
457        ip = pvalloc();
458        test_base(ip, getpagesize(), getpagesize());
459        test_use(ip);
460        free(ip);
461
462        if (tests_failed == 0) printf("PASSED CFA malloc tests\n\n");
463        else printf("failed CFA malloc tests : %d/%d\n\n", tests_failed, tests_total);
464
465        // testing CFA malloc with aligned struct
466
467        elemSize = sizeof(T1);
468        size = dim * elemSize;
469        tests_total = 0;
470        tests_failed = 0;
471
472        tp = malloc();
473        test_base(tp, elemSize, tAlign );
474        test_use(tp);
475        free(tp);
476
477        tp = aalloc( dim );
478        test_base(tp, size, tAlign );
479        test_use(tp);
480        free(tp);
481
482        tp = aalloc( 0 );
483        test_base(tp, 0, libAlign);
484        test_use(tp);
485        free(tp);
486
487        tp = calloc( dim );
488        test_base(tp, size, tAlign );
489        test_fill(tp, 0, size, '\0');
490        test_use(tp);
491        free(tp);
492
493        tp = calloc( 0 );
494        test_base(tp, 0, libAlign);
495        test_use(tp);
496        free(tp);
497
498        tp = aalloc( dim );
499        tp = resize( tp, size / 4 );
500        test_base(tp, size / 4, tAlign );
501        test_use(tp);
502        free(tp);
503
504        tp = malloc();
505        tp = resize( tp, size * 4 );
506        test_base(tp, size * 4, tAlign );
507        test_use(tp);
508        free(tp);
509
510        tp = aalloc( dim );
511        tp = resize( tp, 0 );
512        test_base(tp, 0, libAlign);
513        test_use(tp);
514        free(tp);
515
516        tp = resize( (T1*)0p, size );
517        test_base(tp, size, tAlign );
518        test_use(tp);
519        free(tp);
520
521        tp = resize( (T1*)0p, size );
522        test_base(tp, size, tAlign );
523        test_use(tp);
524        free(tp);
525
526        tp = calloc( dim );
527        tp = realloc( tp, size / 4 );
528        test_base(tp, size / 4, tAlign );
529        test_fill(tp, 0, size / 4, '\0');
530        test_use(tp);
531        free(tp);
532
533        tp = calloc( dim );
534        tp = realloc( tp, size * 4 );
535        test_base(tp, size * 4, tAlign );
536        test_fill(tp, 0, size, '\0');
537        test_use(tp);
538        free(tp);
539
540        tp = calloc( dim );
541        tp = realloc( tp, 0 );
542        test_base(tp, 0, libAlign);
543        test_use(tp);
544        free(tp);
545
546        tp = realloc( (T1*)0p, size  );
547        test_base(tp, size , tAlign );
548        test_use(tp);
549        free(tp);
550
551        tp = realloc( (T1*)0p, size );
552        test_base(tp, size, tAlign );
553        test_use(tp);
554        free(tp);
555
556        tp = memalign( align );
557        test_base(tp, elemSize, align);
558        test_use(tp);
559        free(tp);
560
561        tp = amemalign( align, dim );
562        test_base(tp, size, align);
563        test_use(tp);
564        free(tp);
565
566        tp = amemalign( align, 0 );
567        test_base(tp, 0, libAlign);
568        test_use(tp);
569        free(tp);
570
571        tp = cmemalign( align, dim );
572        test_base(tp, size, align);
573        test_fill(tp, 0, size, '\0');
574        test_use(tp);
575        free(tp);
576
577        tp = cmemalign( align, 0 );
578        test_base(tp, 0, libAlign);
579        test_use(tp);
580        free(tp);
581
582        tp = aligned_alloc( align );
583        test_base(tp, elemSize, align);
584        test_use(tp);
585        free(tp);
586
587        (int) posix_memalign( (T1 **) &tp, align );
588        test_base(tp, elemSize, align);
589        test_use(tp);
590        free(tp);
591
592        tp = valloc();
593        test_base(tp, elemSize, getpagesize());
594        test_use(tp);
595        free(tp);
596
597        tp = pvalloc();
598        test_base(tp, getpagesize(), getpagesize());
599        test_use(tp);
600        free(tp);
601
602        if (tests_failed == 0) printf("PASSED CFA malloc tests (aligned struct)\n\n");
603        else printf("failed CFA malloc tests (aligned struct) : %d/%d\n\n", tests_failed, tests_total);
604
605        return 0;
606}
Note: See TracBrowser for help on using the repository browser.