Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • tests/malloc.cfa

    r116a2ea r10d609a  
    1 #include <fstream.hfa>                                                                  // sout
     1#include <assert.h>
    22#include <malloc.h>                                                                             // malloc_usable_size
    33#include <stdint.h>                                                                             // uintptr_t
     4#include <stdlib.h>                                                                             // posix_memalign
     5#include <fstream.hfa>
    46#include <stdlib.hfa>                                                                   // access C malloc, realloc
    57#include <unistd.h>                                                                             // getpagesize
    … …  
    810int tests_failed;
    911size_t tAlign = 32;
    10 struct S1 { int data; } __attribute__(( aligned(32)));
     12struct S1 { int d1; } __attribute__((aligned(32)));
    1113typedef struct S1 T1;
    1214
    13 void test_base( void * ip, size_t size, size_t align ) {
     15void test_base( void * ip, size_t size, size_t align) {
    1416        tests_total += 1;
    15         bool passed = (malloc_size( ip ) == size) && (malloc_usable_size( ip ) >= size) && (malloc_alignment( ip ) == align) && ((uintptr_t)ip % align  == 0);
    16         if ( ! passed ) {
    17                 sout | "base failed test" | tests_total | "ip" | ip | "size" | size | "align" | align | "but got size" | malloc_size( ip ) | "usable" | malloc_usable_size( ip ) | "align" | malloc_alignment( ip );
     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));
    1820                tests_failed += 1;
    19         } // if
     21        }
    2022}
    2123
    22 void test_fill( void * ip_, size_t start, size_t end, char fill ) {
     24void test_fill( void * ip_, size_t start, size_t end, char fill) {
    2325        tests_total += 1;
    2426        bool passed = true;
    2527        char * ip = (char *) ip_;
    26         for ( i; start ~ end ) passed = passed && (ip[i] == fill);
    27         if ( ! passed ) {
    28                 sout | "fill1 failed test" | tests_total | "fill C";
     28        for (i; start ~ end) passed = passed && (ip[i] == fill);
     29        if (!passed) {
     30                printf("failed test %2d: fill\n", tests_total);
    2931                tests_failed += 1;
    30         } // if
     32        }
    3133}
    3234
    33 void test_use( void * ip_ ) {
     35void test_use( void * ip_) {
    3436        tests_total += 1;
    3537        bool passed = true;
    3638        int * ip = (int *) ip_;
    37         size_t size = malloc_size( ip );
    38         for ( i; 0 ~ size ~ sizeof(int)) ip[i/sizeof(int)] = 0xdeadbeef;
    39         for ( i; 0 ~ size ~ sizeof(int)) passed = passed && (ip[i / sizeof(int)] == 0xdeadbeef);
    40         size_t usize = malloc_usable_size( ip );
    41         for ( i; size ~ usize ~ sizeof(int)) ip[i / sizeof(int)] = -1;
    42         for ( i; size ~ usize ~ sizeof(int)) passed = passed &&  (ip[i / sizeof(int)] == -1);
    43         if ( ! passed ) {
    44                 sout | "failed test" | tests_total | "use";
     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);
    4547                tests_failed += 1;
    4648        }
    … …  
    4850
    4951int main( void ) {
    50         enum { dim = 8, align = 64, libAlign = libAlign() };
    5152        size_t elemSize = sizeof(int);
     53        size_t dim = 8;
    5254        size_t size = dim * elemSize;
     55        size_t align = 64;
     56        const size_t libAlign = libAlign();
    5357        char fill = '\xde';
    5458        int * ip;
    5559        T1 * tp;
    5660
    57         // testing C malloc
     61        // testing C   malloc
    5862
    5963        tests_total = 0;
    6064        tests_failed = 0;
    6165
    62         ip = (int *)malloc( size );
    63         test_base( ip, size, libAlign );
    64         test_use( ip );
    65         free( ip );
    66 
    67         ip = (int *)malloc( 0 );
    68         test_base( ip, 0, libAlign );
    69         test_use( ip );
    70         free( ip );
    71 
    72         ip = (int *)aalloc( dim, elemSize );
    73         test_base( ip, size, libAlign );
    74         test_use( ip );
    75         free( ip );
    76 
    77         ip = (int *)aalloc( 0, elemSize );
    78         test_base( ip, 0, libAlign );
    79         test_use( ip );
    80         free( ip );
    81 
    82         ip = (int *)aalloc( dim, 0 );
    83         test_base( ip, 0, libAlign );
    84         test_use( ip );
    85         free( ip );
    86 
    87         ip = (int *)aalloc( 0, 0 );
    88         test_base( ip, 0, libAlign );
    89         test_use( ip );
    90         free( ip );
    91 
    92         ip = (int *)calloc( dim, elemSize );
    93         test_base( ip, size, libAlign );
    94         test_fill( ip, 0, size, '\0' );
    95         test_use( ip );
    96         free( ip );
    97 
    98         ip = (int *)calloc( 0, elemSize );
    99         test_base( ip, 0, libAlign );
    100         test_fill( ip, 0, 0, '\0' );
    101         test_use( ip );
    102         free( ip );
    103 
    104         ip = (int *)calloc( dim, 0 );
    105         test_base( ip, 0, libAlign );
    106         test_fill( ip, 0, 0, '\0' );
    107         test_use( ip );
    108         free( ip );
    109 
    110         ip = (int *)malloc( size );
    111         ip = (int *)resize( ip, size / 4 );
    112         test_base( ip, size / 4, libAlign );
    113         test_use( ip );
    114         free( ip );
    115 
    116         ip = (int *)malloc( size );
    117         ip = (int *)resize( ip, size * 4 );
    118         test_base( ip, size * 4, libAlign );
    119         test_use( ip );
    120         free( ip );
    121 
    122         ip = (int *)malloc( size );
    123         ip = (int *)resize( ip, 0 );
    124         test_base( ip, 0, libAlign );
    125         test_use( ip );
    126         free( ip );
    127 
    128         ip = (int *)resize( NULL, size );
    129         test_base( ip, size, libAlign );
    130         test_use( ip );
    131         free( ip );
    132 
    133         ip = (int *)resize( 0p, size );
    134         test_base( ip, size, libAlign );
    135         test_use( ip );
    136         free( ip );
    137 
    138         ip = (int *)calloc( dim, elemSize );
    139         ip = (int *)realloc( ip, size / 4 );
    140         test_base( ip, size / 4, libAlign );
    141         test_fill( ip, 0, size / 4, '\0' );
    142         test_use( ip );
    143         free( ip );
    144 
    145         ip = (int *)calloc( dim, elemSize );
    146         ip = (int *)realloc( ip, size * 4 );
    147         test_base( ip, size * 4, libAlign );
    148         test_fill( ip, 0, size * 4, '\0' );
    149         test_use( ip );
    150         free( ip );
    151 
    152         ip = (int *)calloc( dim, elemSize );
    153         ip = (int *)realloc( ip, 0 );
    154         test_base( ip, 0, libAlign );
    155         test_use( ip );
    156         free( ip );
    157 
    158         ip = (int *)realloc( NULL, size  );
    159         test_base( ip, size , libAlign );
    160         test_use( ip );
    161         free( ip );
    162 
    163         ip = (int *)realloc( 0p, size );
    164         test_base( ip, size, libAlign );
    165         test_use( ip );
    166         free( ip );
    167 
    168         ip = (int *)memalign( align, size );
    169         test_base( ip, size, align );
    170         test_use( ip );
    171         free( ip );
    172 
    173         ip = (int *)memalign( align, 0 );
    174         test_base( ip, 0, libAlign );
    175         test_use( ip );
    176         free( ip );
    177 
    178         ip = (int *)amemalign( align, dim, elemSize );
    179         test_base( ip, size, align );
    180         test_use( ip );
    181         free( ip );
    182 
    183         ip = (int *)amemalign( align, 0, elemSize );
    184         test_base( ip, 0, libAlign );
    185         test_use( ip );
    186         free( ip );
    187 
    188         ip = (int *)amemalign( align, dim, 0 );
    189         test_base( ip, 0, libAlign );
    190         test_use( ip );
    191         free( ip );
    192 
    193         ip = (int *)cmemalign( align, dim, elemSize );
    194         test_base( ip, size, align );
    195         test_fill( ip, 0, size, '\0' );
    196         test_use( ip );
    197         free( ip );
    198 
    199         ip = (int *)cmemalign( align, 0, elemSize );
    200         test_base( ip, 0, libAlign );
    201         test_use( ip );
    202         free( ip );
    203 
    204         ip = (int *)cmemalign( align, dim, 0 );
    205         test_base( ip, 0, libAlign );
    206         test_use( ip );
    207         free( ip );
    208 
    209         ip = (int *)aligned_alloc( align, size );
    210         test_base( ip, size, align );
    211         test_use( ip );
    212         free( ip );
    213 
    214         ip = (int *)aligned_alloc( align, 0 );
    215         test_base( ip, 0, libAlign );
    216         test_use( ip );
    217         free( ip );
    218 
    219         posix_memalign( (void **) &ip, align, size );
    220         test_base( ip, size, align );
    221         test_use( ip );
    222         free( ip );
    223 
    224         posix_memalign( (void **) &ip, align, 0 );
    225         test_base( ip, 0, libAlign );
    226         test_use( ip );
    227         free( ip );
    228 
    229         ip = (int *)valloc( size );
    230         test_base( ip, size, getpagesize() );
    231         test_use( ip );
    232         free( ip );
    233 
    234         ip = (int *)valloc( 0 );
    235         test_base( ip, 0, libAlign );
    236         test_use( ip );
    237         free( ip );
    238 
    239         ip = (int *)pvalloc( getpagesize() * 3 / 2 );
    240         test_base( ip, getpagesize() * 2, getpagesize() );
    241         test_use( ip );
    242         free( ip );
    243 
    244         ip = (int *)pvalloc( 0 );
    245         test_base( ip, 0, libAlign );
    246         test_use( ip );
    247         free( ip );
    248 
    249         ip = (int *)malloc( size );
    250         ip = (int *)resize( ip, libAlign, size / 2 );
    251         test_base( ip, size / 2, libAlign );
    252         test_use( ip );
    253         free( ip );
    254 
    255         ip = (int *)aligned_alloc( align, size );
    256         ip = (int *)resize( ip, align, size / 2 );
    257         test_base( ip, size / 2, align );
    258         test_use( ip );
    259         free( ip );
    260 
    261         ip = (int *)malloc( size );
    262         ip = (int *)resize( ip, align, size / 4 );
    263         test_base( ip, size / 4, align );
    264         test_use( ip );
    265         free( ip );
    266 
    267         ip = (int *)malloc( size );
    268         ip = (int *)resize( ip, align, 0 );
    269         test_base( ip, 0, libAlign );
    270         test_use( ip );
    271         free( ip );
    272 
    273         ip = (int *)resize( NULL, align, size );
    274         test_base( ip, size, align );
    275         test_use( ip );
    276         free( ip );
    277 
    278         ip = (int *)resize( 0p, align, size );
    279         test_base( ip, size, align );
    280         test_use( ip );
    281         free( ip );
    282 
    283         ip = (int *)calloc( dim, elemSize );
    284         ip = (int *)realloc( ip, libAlign, size / 2 );
    285         test_base( ip, size / 2, libAlign );
    286         test_fill( ip, 0, size / 2, '\0' );
    287         test_use( ip );
    288         free( ip );
    289 
    290         ip = (int *)cmemalign( align, dim, elemSize );
    291         ip = (int *)realloc( ip, align, size / 2 );
    292         test_base( ip, size / 2, align );
    293         test_fill( ip, 0, size / 2, '\0' );
    294         test_use( ip );
    295         free( ip );
    296 
    297         ip = (int *)calloc( dim, elemSize );
    298         ip = (int *)realloc( ip, align, size / 4 );
    299         test_base( ip, size / 4, align );
    300         test_fill( ip, 0, size / 4, '\0' );
    301         test_use( ip );
    302         free( ip );
    303 
    304         ip = (int *)calloc( dim, elemSize );
    305         ip = (int *)realloc( ip, libAlign, size * 4 );
    306         test_base( ip, size * 4, libAlign );
    307         test_fill( ip, 0, size * 4, '\0' );
    308         test_use( ip );
    309         free( ip );
    310 
    311         ip = (int *)calloc( dim, elemSize );
    312         ip = (int *)realloc( ip, align, 0 );
    313         test_base( ip, 0, libAlign );
    314         test_use( ip );
    315         free( ip );
    316 
    317         free( 0p );                                                                                     // sanity check
    318         free( NULL );                                                                           // sanity check
    319 
    320         if (tests_failed == 0) sout | "PASSED C malloc tests" | nl | nl;
    321         else sout | "failed C malloc tests" | tests_failed | tests_total | nl | nl;
     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);
    322326
    323327        // testing CFA malloc
    … …  
    327331
    328332        ip = malloc();
    329         test_base( ip, elemSize, libAlign );
    330         test_use( ip );
    331         free( ip );
     333        test_base(ip, elemSize, libAlign);
     334        test_use(ip);
     335        free(ip);
    332336
    333337        ip = aalloc( dim );
    334         test_base( ip, size, libAlign );
    335         test_use( ip );
    336         free( ip );
     338        test_base(ip, size, libAlign);
     339        test_use(ip);
     340        free(ip);
    337341
    338342        ip = aalloc( 0 );
    339         test_base( ip, 0, libAlign );
    340         test_use( ip );
    341         free( ip );
     343        test_base(ip, 0, libAlign);
     344        test_use(ip);
     345        free(ip);
    342346
    343347        ip = calloc( dim );
    344         test_base( ip, size, libAlign );
    345         test_fill( ip, 0, size, '\0' );
    346         test_use( ip );
    347         free( ip );
     348        test_base(ip, size, libAlign);
     349        test_fill(ip, 0, size, '\0');
     350        test_use(ip);
     351        free(ip);
    348352
    349353        ip = calloc( 0 );
    350         test_base( ip, 0, libAlign );
    351         test_use( ip );
    352         free( ip );
     354        test_base(ip, 0, libAlign);
     355        test_use(ip);
     356        free(ip);
    353357
    354358        ip = aalloc( dim );
    355359        ip = resize( ip, size / 4 );
    356         test_base( ip, size / 4, libAlign );
    357         test_use( ip );
    358         free( ip );
     360        test_base(ip, size / 4, libAlign);
     361        test_use(ip);
     362        free(ip);
    359363
    360364        ip = aalloc( dim );
    361365        ip = resize( ip, size * 4 );
    362         test_base( ip, size * 4, libAlign );
    363         test_use( ip );
    364         free( ip );
     366        test_base(ip, size * 4, libAlign);
     367        test_use(ip);
     368        free(ip);
    365369
    366370        ip = aalloc( dim );
    367371        ip = resize( ip, 0 );
    368         test_base( ip, 0, libAlign );
    369         test_use( ip );
    370         free( ip );
    371 
    372         ip = resize( 0p, size );
    373         test_base( ip, size, libAlign );
    374         test_use( ip );
    375         free( ip );
    376 
    377         ip = resize( 0p, size );
    378         test_base( ip, size, libAlign );
    379         test_use( ip );
    380         free( ip );
     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);
    381385
    382386        ip = calloc( dim );
    383387        ip = realloc( ip, size / 4 );
    384         test_base( ip, size / 4, libAlign );
    385         test_fill( ip, 0, size / 4, '\0' );
    386         test_use( ip );
    387         free( ip );
     388        test_base(ip, size / 4, libAlign);
     389        test_fill(ip, 0, size / 4, '\0');
     390        test_use(ip);
     391        free(ip);
    388392
    389393        ip = calloc( dim );
    390394        ip = realloc( ip, size * 4 );
    391         test_base( ip, size * 4, libAlign );
    392         test_fill( ip, 0, size, '\0' );
    393         test_use( ip );
    394         free( ip );
     395        test_base(ip, size * 4, libAlign);
     396        test_fill(ip, 0, size, '\0');
     397        test_use(ip);
     398        free(ip);
    395399
    396400        ip = calloc( dim );
    397401        ip = realloc( ip, 0 );
    398         test_base( ip, 0, libAlign );
    399         test_use( ip );
    400         free( ip );
    401 
    402         ip = realloc( 0p, size );
    403         test_base( ip, size , libAlign );
    404         test_use( ip );
    405         free( ip );
    406 
    407         ip = realloc( 0p, size );
    408         test_base( ip, size, libAlign );
    409         test_use( ip );
    410         free( ip );
     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);
    411415
    412416        ip = memalign( align );
    413         test_base( ip, elemSize, align );
    414         test_use( ip );
    415         free( ip );
     417        test_base(ip, elemSize, align);
     418        test_use(ip);
     419        free(ip);
    416420
    417421        ip = amemalign( align, dim );
    418         test_base( ip, size, align );
    419         test_use( ip );
    420         free( ip );
     422        test_base(ip, size, align);
     423        test_use(ip);
     424        free(ip);
    421425
    422426        ip = amemalign( align, 0 );
    423         test_base( ip, 0, libAlign );
    424         test_use( ip );
    425         free( ip );
     427        test_base(ip, 0, libAlign);
     428        test_use(ip);
     429        free(ip);
    426430
    427431        ip = cmemalign( align, dim );
    428         test_base( ip, size, align );
    429         test_fill( ip, 0, size, '\0' );
    430         test_use( ip );
    431         free( ip );
     432        test_base(ip, size, align);
     433        test_fill(ip, 0, size, '\0');
     434        test_use(ip);
     435        free(ip);
    432436
    433437        ip = cmemalign( align, 0 );
    434         test_base( ip, 0, libAlign );
    435         test_use( ip );
    436         free( ip );
     438        test_base(ip, 0, libAlign);
     439        test_use(ip);
     440        free(ip);
    437441
    438442        ip = aligned_alloc( align );
    439         test_base( ip, elemSize, align );
    440         test_use( ip );
    441         free( ip );
    442 
    443         posix_memalign( (int **) &ip, align );
    444         test_base( ip, elemSize, align );
    445         test_use( ip );
    446         free( ip );
     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);
    447451
    448452        ip = valloc();
    449         test_base( ip, elemSize, getpagesize() );
    450         test_use( ip );
    451         free( ip );
     453        test_base(ip, elemSize, getpagesize());
     454        test_use(ip);
     455        free(ip);
    452456
    453457        ip = pvalloc();
    454         test_base( ip, getpagesize(), getpagesize() );
    455         test_use( ip );
    456         free( ip );
    457 
    458         if (tests_failed == 0) sout | "PASSED CFA malloc tests" | nl | nl;
    459         else sout | "failed CFA malloc tests" | tests_failed | tests_total | nl | nl;
     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);
    460464
    461465        // testing CFA malloc with aligned struct
    … …  
    467471
    468472        tp = malloc();
    469         test_base( tp, elemSize, tAlign );
    470         test_use( tp );
    471         free( tp );
     473        test_base(tp, elemSize, tAlign );
     474        test_use(tp);
     475        free(tp);
    472476
    473477        tp = aalloc( dim );
    474         test_base( tp, size, tAlign );
    475         test_use( tp );
    476         free( tp );
     478        test_base(tp, size, tAlign );
     479        test_use(tp);
     480        free(tp);
    477481
    478482        tp = aalloc( 0 );
    479         test_base( tp, 0, libAlign );
    480         test_use( tp );
    481         free( tp );
     483        test_base(tp, 0, libAlign);
     484        test_use(tp);
     485        free(tp);
    482486
    483487        tp = calloc( dim );
    484         test_base( tp, size, tAlign );
    485         test_fill( tp, 0, size, '\0' );
    486         test_use( tp );
    487         free( tp );
     488        test_base(tp, size, tAlign );
     489        test_fill(tp, 0, size, '\0');
     490        test_use(tp);
     491        free(tp);
    488492
    489493        tp = calloc( 0 );
    490         test_base( tp, 0, libAlign );
    491         test_use( tp );
    492         free( tp );
     494        test_base(tp, 0, libAlign);
     495        test_use(tp);
     496        free(tp);
    493497
    494498        tp = aalloc( dim );
    495499        tp = resize( tp, size / 4 );
    496         test_base( tp, size / 4, tAlign );
    497         test_use( tp );
    498         free( tp );
     500        test_base(tp, size / 4, tAlign );
     501        test_use(tp);
     502        free(tp);
    499503
    500504        tp = malloc();
    501505        tp = resize( tp, size * 4 );
    502         test_base( tp, size * 4, tAlign );
    503         test_use( tp );
    504         free( tp );
     506        test_base(tp, size * 4, tAlign );
     507        test_use(tp);
     508        free(tp);
    505509
    506510        tp = aalloc( dim );
    507511        tp = resize( tp, 0 );
    508         test_base( tp, 0, libAlign );
    509         test_use( tp );
    510         free( tp );
     512        test_base(tp, 0, libAlign);
     513        test_use(tp);
     514        free(tp);
    511515
    512516        tp = resize( (T1*)0p, size );
    513         test_base( tp, size, tAlign );
    514         test_use( tp );
    515         free( tp );
     517        test_base(tp, size, tAlign );
     518        test_use(tp);
     519        free(tp);
    516520
    517521        tp = resize( (T1*)0p, size );
    518         test_base( tp, size, tAlign );
    519         test_use( tp );
    520         free( tp );
     522        test_base(tp, size, tAlign );
     523        test_use(tp);
     524        free(tp);
    521525
    522526        tp = calloc( dim );
    523527        tp = realloc( tp, size / 4 );
    524         test_base( tp, size / 4, tAlign );
    525         test_fill( tp, 0, size / 4, '\0' );
    526         test_use( tp );
    527         free( tp );
     528        test_base(tp, size / 4, tAlign );
     529        test_fill(tp, 0, size / 4, '\0');
     530        test_use(tp);
     531        free(tp);
    528532
    529533        tp = calloc( dim );
    530534        tp = realloc( tp, size * 4 );
    531         test_base( tp, size * 4, tAlign );
    532         test_fill( tp, 0, size, '\0' );
    533         test_use( tp );
    534         free( tp );
     535        test_base(tp, size * 4, tAlign );
     536        test_fill(tp, 0, size, '\0');
     537        test_use(tp);
     538        free(tp);
    535539
    536540        tp = calloc( dim );
    537541        tp = realloc( tp, 0 );
    538         test_base( tp, 0, libAlign );
    539         test_use( tp );
    540         free( tp );
     542        test_base(tp, 0, libAlign);
     543        test_use(tp);
     544        free(tp);
    541545
    542546        tp = realloc( (T1*)0p, size  );
    543         test_base( tp, size , tAlign );
    544         test_use( tp );
    545         free( tp );
     547        test_base(tp, size , tAlign );
     548        test_use(tp);
     549        free(tp);
    546550
    547551        tp = realloc( (T1*)0p, size );
    548         test_base( tp, size, tAlign );
    549         test_use( tp );
    550         free( tp );
     552        test_base(tp, size, tAlign );
     553        test_use(tp);
     554        free(tp);
    551555
    552556        tp = memalign( align );
    553         test_base( tp, elemSize, align );
    554         test_use( tp );
    555         free( tp );
     557        test_base(tp, elemSize, align);
     558        test_use(tp);
     559        free(tp);
    556560
    557561        tp = amemalign( align, dim );
    558         test_base( tp, size, align );
    559         test_use( tp );
    560         free( tp );
     562        test_base(tp, size, align);
     563        test_use(tp);
     564        free(tp);
    561565
    562566        tp = amemalign( align, 0 );
    563         test_base( tp, 0, libAlign );
    564         test_use( tp );
    565         free( tp );
     567        test_base(tp, 0, libAlign);
     568        test_use(tp);
     569        free(tp);
    566570
    567571        tp = cmemalign( align, dim );
    568         test_base( tp, size, align );
    569         test_fill( tp, 0, size, '\0' );
    570         test_use( tp );
    571         free( tp );
     572        test_base(tp, size, align);
     573        test_fill(tp, 0, size, '\0');
     574        test_use(tp);
     575        free(tp);
    572576
    573577        tp = cmemalign( align, 0 );
    574         test_base( tp, 0, libAlign );
    575         test_use( tp );
    576         free( tp );
     578        test_base(tp, 0, libAlign);
     579        test_use(tp);
     580        free(tp);
    577581
    578582        tp = aligned_alloc( align );
    579         test_base( tp, elemSize, align );
    580         test_use( tp );
    581         free( tp );
    582 
    583         posix_memalign( (T1 **)&tp, align );
    584         test_base( tp, elemSize, align );
    585         test_use( tp );
    586         free( tp );
     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);
    587591
    588592        tp = valloc();
    589         test_base( tp, elemSize, getpagesize() );
    590         test_use( tp );
    591         free( tp );
     593        test_base(tp, elemSize, getpagesize());
     594        test_use(tp);
     595        free(tp);
    592596
    593597        tp = pvalloc();
    594         test_base( tp, getpagesize(), getpagesize() );
    595         test_use( tp );
    596         free( tp );
    597 
    598         if ( tests_failed == 0 ) sout | "PASSED CFA malloc tests (aligned struct)" | nl | nl;
    599         else sout | "failed CFA malloc tests (aligned struct)" | tests_failed | tests_total | nl | nl;
     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;
    600606}
    601607
Note: See TracChangeset for help on using the changeset viewer.