Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • tests/alloc.cfa

    r6a25b8f rfe23950  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Nov 22 15:34:19 2019
    13 // Update Count     : 404
     12// Last Modified On : Thu Nov 12 10:02:18 2020
     13// Update Count     : 432
    1414//
    1515
    … …  
    2828        size_t dim = 10;
    2929        char fill = '\xde';
    30         int * p, * p1;
     30        int * ip, * ip1;
    3131
    3232        // allocation, non-array types
    3333
    34         p = (int *)malloc( sizeof(*p) );                                        // C malloc, type unsafe
    35         *p = 0xdeadbeef;
    36         printf( "C   malloc %#x\n", *p );
    37         free( p );
    38 
    39         p = malloc();                                       // CFA malloc, type safe
    40         *p = 0xdeadbeef;
    41         printf( "CFA malloc %#x\n", *p );
    42         free( p );
    43 
    44         p = alloc();                                        // CFA alloc, type safe
    45         *p = 0xdeadbeef;
    46         printf( "CFA alloc %#x\n", *p );
    47         free( p );
    48 
    49         p = alloc_set( fill );                                                          // CFA alloc, fill
     34        ip = (int *)malloc( sizeof(*ip) );                                      // C malloc, type unsafe
     35        *ip = 0xdeadbeef;
     36        printf( "C   malloc %#x\n", *ip );
     37        free( ip );
     38
     39        ip = malloc();                                                                          // CFA malloc, type safe
     40        *ip = 0xdeadbeef;
     41        printf( "CFA malloc %#x\n", *ip );
     42        free( ip );
     43
     44        ip = alloc();                                                                           // CFA alloc, type safe
     45        *ip = 0xdeadbeef;
     46        printf( "CFA alloc %#x\n", *ip );
     47        free( ip );
     48
     49        ip = alloc( fill`fill );                                                                // CFA alloc, fill
     50        printf( "CFA alloc, fill %08x\n", *ip );
     51        free( ip );
     52
     53        ip = alloc( 3`fill );                                                           // CFA alloc, fill
     54        printf( "CFA alloc, fill %d\n", *ip );
     55        free( ip );
     56
     57
     58        // allocation, array types
     59        printf( "\n" );
     60
     61        ip = (int *)calloc( dim, sizeof( *ip ) );                       // C array calloc, type unsafe
     62        printf( "C   array calloc, fill 0\n" );
     63        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     64        printf( "\n" );
     65        free( ip );
     66
     67        ip = calloc( dim );                                                                     // CFA array calloc, type safe
     68        printf( "CFA array calloc, fill 0\n" );
     69        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     70        printf( "\n" );
     71        free( ip );
     72
     73        ip = alloc( dim );                                                                      // CFA array alloc, type safe
     74        for ( i; dim ) { ip[i] = 0xdeadbeef; }
     75        printf( "CFA array alloc, no fill\n" );
     76        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     77        printf( "\n" );
     78        free( ip );
     79
     80        ip = alloc( 2 * dim, fill`fill );                                       // CFA array alloc, fill
    5081        printf( "CFA array alloc, fill %#hhx\n", fill );
    51         printf( "CFA alloc, fill %08x\n", *p );
    52         free( p );
    53 
    54         p = alloc_set( 3 );                                                                     // CFA alloc, fill
    55         printf( "CFA alloc, fill %d\n", *p );
    56         free( p );
    57 
    58 
    59         // allocation, array types
    60         printf( "\n" );
    61 
    62         p = (int *)calloc( dim, sizeof( *p ) );                         // C array calloc, type unsafe
    63         printf( "C   array calloc, fill 0\n" );
    64         for ( i; dim ) { printf( "%#x ", p[i] ); }
    65         printf( "\n" );
    66         free( p );
    67 
    68         p = calloc( dim );                                  // CFA array calloc, type safe
    69         printf( "CFA array calloc, fill 0\n" );
    70         for ( i; dim ) { printf( "%#x ", p[i] ); }
    71         printf( "\n" );
    72         free( p );
    73 
    74         p = alloc( dim );                                   // CFA array alloc, type safe
    75         for ( i; dim ) { p[i] = 0xdeadbeef; }
    76         printf( "CFA array alloc, no fill\n" );
    77         for ( i; dim ) { printf( "%#x ", p[i] ); }
    78         printf( "\n" );
    79         free( p );
    80 
    81         p = alloc_set( 2 * dim, fill );                                         // CFA array alloc, fill
    82         printf( "CFA array alloc, fill %#hhx\n", fill );
    83         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    84         printf( "\n" );
    85         free( p );
    86 
    87         p = alloc_set( 2 * dim, 0xdeadbeef );                           // CFA array alloc, fill
     82        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     83        printf( "\n" );
     84        free( ip );
     85
     86        ip = alloc( 2 * dim, ((int)0xdeadbeef)`fill );                          // CFA array alloc, fill
    8887        printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
    89         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    90         printf( "\n" );
    91         // do not free
    92 
    93         p1 = alloc_set( 2 * dim, p );                                           // CFA array alloc, fill
     88        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     89        printf( "\n" );
     90        // do not free
     91
     92        ip1 = alloc( 2 * dim, [ip, 2 * dim]`fill );                             // CFA array alloc, fill
    9493        printf( "CFA array alloc, fill from array\n" );
    95         for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
    96         free( p1 );
    97         printf( "\n" );
    98 
     94        for ( i; 2 * dim ) { printf( "%#x %#x, ", ip[i], ip1[i] ); }
     95        free( ip1 );
     96        printf( "\n" );
     97
     98
     99        // realloc, non-array types
     100        printf( "\n" );
     101
     102        ip = (int *)realloc( ip, dim * sizeof(*ip) );           // C realloc
     103        printf( "C realloc\n" );
     104        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     105        printf( "\n" );
     106        // do not free
     107
     108        ip = realloc( ip, 2 * dim * sizeof(*ip) );                      // CFA realloc
     109        for ( i; dim ~ 2 * dim ) { ip[i] = 0x1010101; }
     110        printf( "CFA realloc\n" );
     111        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     112        printf( "\n" );
     113        // do not free
     114
     115
     116        // realloc, array types
     117        printf( "\n" );
     118
     119        ip = alloc( dim, ip`realloc );                                                          // CFA realloc array alloc
     120        for ( i; dim ) { ip[i] = 0xdeadbeef; }
     121        printf( "CFA realloc array alloc\n" );
     122        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     123        printf( "\n" );
     124        // do not free
     125
     126        ip = alloc( 2 * dim, ip`realloc );                                                      // CFA realloc array alloc
     127        for ( i; dim ~ 2 * dim ) { ip[i] = 0x1010101; }         // fill upper part
     128        printf( "CFA realloc array alloc\n" );
     129        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     130        printf( "\n" );
     131        // do not free
     132
     133        ip = alloc( dim, ip`realloc );                                                          // CFA realloc array alloc
     134        printf( "CFA realloc array alloc\n" );
     135        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     136        printf( "\n" );
     137        // do not free
     138
     139        ip = alloc( 3 * dim, ip`realloc, fill`fill );                           // CFA realloc array alloc, fill
     140        printf( "CFA realloc array alloc, fill\n" );
     141        for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
     142        printf( "\n" );
     143        // do not free
     144
     145        ip = alloc( dim, ip`realloc, fill`fill );                                       // CFA realloc array alloc, fill
     146        printf( "CFA realloc array alloc, fill\n" );
     147        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     148        printf( "\n" );
     149        // do not free
     150
     151        ip = alloc( 3 * dim, ip`realloc, fill`fill );                           // CFA realloc array alloc, fill
     152        printf( "CFA realloc array alloc, fill\n" );
     153        for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
     154        printf( "\n" );
     155        // do not free
     156#if 0 // FIX ME
     157        ip = alloc( 5 * dim, ip`realloc, 5`fill );                                      // CFA realloc array alloc, 5
     158        printf( "CFA realloc array alloc, 5\n" );
     159        for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); }
     160        printf( "\n" );
     161        // do not free
     162
     163        ip = alloc( dim, ip`realloc, 5`fill );                                          // CFA realloc array alloc, 5
     164        printf( "CFA realloc array alloc, 5\n" );
     165        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     166        printf( "\n" );
     167        // do not free
     168
     169        ip = alloc( 5 * dim, ip`realloc, 5`fill );                                      // CFA realloc array alloc, 5
     170        printf( "CFA realloc array alloc, 5\n" );
     171        for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); }
     172        printf( "\n" );
     173#endif // 0
     174        free( ip );
    99175
    100176        // resize, non-array types
    101         printf( "\n" );
    102 
    103         p = (int *)realloc( p, dim * sizeof(*p) );                      // C realloc
    104         printf( "C realloc\n" );
    105         for ( i; dim ) { printf( "%#x ", p[i] ); }
    106         printf( "\n" );
    107         // do not free
    108 
    109         p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
    110         for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
    111         printf( "CFA realloc\n" );
    112         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    113         printf( "\n" );
    114         // do not free
     177
     178        struct S {
     179                int a[5];
     180        };
     181
     182    ip = alloc();
     183        *ip = 5;
     184    double * dp = alloc( ip`resize );
     185        *dp = 5.5;
     186    S * sp = alloc( dp`resize );
     187        *sp = (S){ {0, 1, 2, 3, 4} };
     188    ip = alloc( sp`resize );
     189        *ip = 3;
     190    free( ip );
    115191
    116192
    117193        // resize, array types
    118         printf( "\n" );
    119 
    120         p = alloc( p, dim );                                // CFA resize array alloc
    121         for ( i; dim ) { p[i] = 0xdeadbeef; }
    122         printf( "CFA resize array alloc\n" );
    123         for ( i; dim ) { printf( "%#x ", p[i] ); }
    124         printf( "\n" );
    125         // do not free
    126 
    127         p = alloc( p, 2 * dim );                            // CFA resize array alloc
    128         for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }          // fill upper part
    129         printf( "CFA resize array alloc\n" );
    130         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    131         printf( "\n" );
    132         // do not free
    133 
    134         p = alloc( p, dim );                                // CFA resize array alloc
    135         printf( "CFA resize array alloc\n" );
    136         for ( i; dim ) { printf( "%#x ", p[i] ); }
    137         printf( "\n" );
    138         // do not free
    139 
    140         p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
    141         printf( "CFA resize array alloc\n" );
    142         for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
    143         printf( "\n" );
    144         // do not free
    145 
    146         p = alloc_set( p, dim, fill );                                          // CFA resize array alloc, fill
    147         printf( "CFA resize array alloc\n" );
    148         for ( i; dim ) { printf( "%#x ", p[i] ); }
    149         printf( "\n" );
    150         // do not free
    151 
    152         p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
    153         printf( "CFA resize array alloc, fill\n" );
    154         for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
    155         printf( "\n" );
    156         free( p );
    157 
    158 
     194
     195    ip = alloc( 5 );
     196        for ( i; 5 ) { ip[i] = 5; }
     197    dp = alloc( 5, ip`resize );
     198        for ( i; 5 ) { dp[i] = 5.5; }
     199    sp = alloc( 5, dp`resize );
     200        for ( i; 5 ) { sp[i] = (S){ {0, 1, 2, 3, 4} }; }
     201    ip = alloc( 3, sp`resize );
     202        for ( i; 3 ) { ip[i] = 3; }
     203    ip = alloc( 7, ip`realloc );
     204        for ( i; 7 ) { ip[i] = 7; }
     205    ip = alloc( 7, ip`resize );
     206        for ( i; 7 ) { ip[i] = 7; }
     207    free( ip );
     208
     209
     210        int const_count, dest_count;
    159211        struct Struct { int x; double y; };
     212        void  ?{}( Struct & a ) {                                       // construct
     213                a.[ x, y ] = [ -1, -1.0 ];
     214        }
     215        void  ?{}( Struct & a, int x, double y ) {      // initialize
     216                a.[ x, y ] = [ x, y ];
     217                const_count++;
     218        }
     219        void ^?{}( Struct & a ) {  dest_count++; }      // destruct
    160220        Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
    161221
    … …  
    169229        free( stp );
    170230
    171         stp = &(*memalign( Alignment )){ 42, 42.5 };          // CFA memalign
     231        stp = &(*memalign( Alignment )){ 42, 42.5 };            // CFA memalign
    172232        assert( (uintptr_t)stp % Alignment == 0 );
    173233        printf( "CFA memalign %d %g\n", stp->x, stp->y );
    … …  
    186246        free( stp );
    187247
    188         stp = &(*alloc_align( Alignment)){ 42, 42.5 };          // CFA alloc_align
     248        stp = &(*alloc( Alignment`align)){ 42, 42.5 };          // CFA alloc_align
    189249        assert( (uintptr_t)stp % Alignment == 0 );
    190250        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    191251        free( stp );
    192252
    193         stp = &(*alloc_align( Alignment )){ 42, 42.5 };         // CFA alloc_align
     253        stp = &(*alloc( Alignment`align )){ 42, 42.5 };         // CFA alloc_align
    194254        assert( (uintptr_t)stp % Alignment == 0 );
    195255        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    196256        free( stp );
    197257
    198         stp = alloc_align_set( Alignment, fill );                       // CFA memalign, fill
     258        stp = alloc( Alignment`align, fill`fill );                      // CFA memalign, fill
    199259        assert( (uintptr_t)stp % Alignment == 0 );
    200260        printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
    201261        free( stp );
    202262
    203         stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
     263        stp = alloc( Alignment`align, (Struct){ 42, 42.5 }`fill ); // CFA memalign, fill
    204264        assert( (uintptr_t)stp % Alignment == 0 );
    205265        printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
    206266        // do not free
    207267
    208         stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 };         // CFA realign
     268        stp = &(*alloc( stp`realloc, 4096`align )){ 42, 42.5 };         // CFA realign
    209269        assert( (uintptr_t)stp % 4096 == 0 );
    210270        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    … …  
    215275        printf( "\n" );
    216276
    217         stp = alloc_align( Alignment, dim );                // CFA array memalign
     277        stp = alloc( dim, Alignment`align );                // CFA array memalign
    218278        assert( (uintptr_t)stp % Alignment == 0 );
    219279        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
    … …  
    223283        free( stp );
    224284
    225         stp = alloc_align_set( Alignment, dim, fill );          // CFA array memalign, fill
     285        stp = alloc( dim, Alignment`align, fill`fill );         // CFA array memalign, fill
    226286        assert( (uintptr_t)stp % Alignment == 0 );
    227287        printf( "CFA array alloc_align, fill\n" );
    … …  
    230290        free( stp );
    231291
    232         stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
     292        stp = alloc( dim, Alignment`align, ((Struct){ 42, 42.5 })`fill ); // CFA array memalign, fill
    233293        assert( (uintptr_t)stp % Alignment == 0 );
    234294        printf( "CFA array alloc_align, fill\n" );
    … …  
    237297        // do not free
    238298
    239         stp1 = alloc_align_set( Alignment, dim, stp );          // CFA array memalign, fill
     299        stp1 = alloc( dim, Alignment`align, [stp, dim]`fill );  // CFA array memalign, fill
    240300        assert( (uintptr_t)stp % Alignment == 0 );
    241301        printf( "CFA array alloc_align, fill array\n" );
    … …  
    244304        free( stp1 );
    245305
    246         stp = alloc_align( stp, 4096, dim );                            // CFA aligned realloc array
     306        stp = alloc( dim, stp`realloc, 4096`align );                            // CFA aligned realloc array
    247307        assert( (uintptr_t)stp % 4096 == 0 );
    248308        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
    … …  
    275335        printf( "\n" );
    276336
    277 
    278337        // new, non-array types
    279338        printf( "\n" );
    280339
     340        const_count = dest_count = 0;
    281341        stp = new( 42, 42.5 );
     342        assert( const_count == 1 && dest_count == 0 );                                          // assertion for testing
    282343        stp1 = new( 42, 42.5 );
     344        assert( const_count == 2 && dest_count == 0 );                                          // assertion for testing
     345
    283346        printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
    284347        delete( stp, stp1 );
     348        assert( const_count == 2 && dest_count == 2 );                                          // assertion for testing
    285349
    286350        // new, array types
    287351        stp = anew( dim, 42, 42.5 );
     352        assert( const_count == 2 + dim && dest_count == 2 );                            // assertion for testing
    288353        printf( "CFA array new initialize\n" );
    289354        for ( i; dim ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
    290355        printf( "\n" );
     356
    291357        stp1 = anew( dim, 42, 42.5 );
     358        assert( const_count == 2 + 2 * dim && dest_count == 2 );                        // assertion for testing
    292359        for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
    293360        printf( "\n" );
    294         adelete( dim, stp, dim, stp1 );
     361        adelete( stp, stp1 );
     362        assert( const_count == 2 + 2 * dim && dest_count == 2 + 2 * dim);       // assertion for testing
    295363
    296364        // extras
    … …  
    301369        free( fp - 1 );
    302370
    303         p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
    304         *p = 0xdeadbeef;
    305         printf( "CFA deep malloc %#x\n", *p );
    306         free( p );
     371        ip = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
     372        *ip = 0xdeadbeef;
     373        printf( "CFA deep malloc %#x\n", *ip );
     374
     375        dp = alloc(5.0`fill); // just for testing multiple free
     376        assert(*dp == 5.0);
     377        free( ip, dp, 0p );
    307378
    308379#ifdef ERR1
    309380        stp = malloc();
    310381        printf( "\nSHOULD FAIL\n" );
    311         p = realloc( stp, dim * sizeof( *stp ) );
    312         p = alloc( stp, dim * sizeof( *stp ) );
    313         p = memset( stp, 10 );
    314         p = memcpy( &st1, &st );
    315 #endif
     382        ip = realloc( stp, dim * sizeof( *stp ) );
     383        ip = memset( stp, 10 );
     384        ip = memcpy( &st1, &st );
     385#endif // ERR1
    316386} // main
    317387
Note: See TracChangeset for help on using the changeset viewer.