Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • tests/configs/parsenums.cfa

    r9e042d8 r0b6089f  
    3232#endif
    3333
    34 int true_main(const char * exec);
    35 
    36 int main(int argc, char * argv[]) {
    37         check_main(argv[0]);
     34int true_main( const char * exec );
     35
     36int main( int argc, char * argv[]) {
     37        check_main( argv[0]);
    3838
    3939        int i = -3;
     
    5252
    5353        char **left;
    54         parse_args( options, "[OPTIONS]...\ntesting bool parameters", left);
     54        parse_args( options, "[OPTIONS]...\ntesting bool parameters", left );
    5555
    5656        sout | "int                :" | i;
     
    6161}
    6262
    63 int true_main(const char * path, char * env[]) {
    64         printf("no arg:\n");
    65         if(pid_t child = strict_fork(); child == 0) {
    66                 int ret = execle(path, "parsenums", (const char*)0p, env);
    67                 if(ret < 0) {
    68                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    69                         exit(1);
    70                 }
    71         }
    72         else {
    73                 int status = do_wait(child);
    74                 print_status(status);
    75         }
    76 
    77         printf("all 0 arg:\n");
    78         if(pid_t child = strict_fork(); child == 0) {
    79                 int ret = execle(path, "parsenums", "-i=0", "-u=0", "-l=0", "-L=0", "-d=0", (const char*)0p, env);
    80                 if(ret < 0) {
    81                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    82                         exit(1);
    83                 }
    84         }
    85         else {
    86                 int status = do_wait(child);
    87                 print_status(status);
    88         }
    89 
    90         printf("negative vals arg:\n");
    91         if(pid_t child = strict_fork(); child == 0) {
    92                 int ret = execle(path, "parsenums", "-i=-1", "-d=-1", (const char*)0p, env);
    93                 if(ret < 0) {
    94                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    95                         exit(1);
    96                 }
    97         }
    98         else {
    99                 int status = do_wait(child);
    100                 print_status(status);
    101         }
    102 
    103         printf("funky notation arg:\n");
    104         if(pid_t child = strict_fork(); child == 0) {
    105                 int ret = execle(path, "parsenums", "-i=0x10", "-u=0x20", "-l=0x300", "-L=0x4000", "-d=5e6", (const char*)0p, env);
    106                 if(ret < 0) {
    107                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    108                         exit(1);
    109                 }
    110         }
    111         else {
    112                 int status = do_wait(child);
    113                 print_status(status);
    114         }
    115 
    116         printf("big values arg:\n");
    117         if(pid_t child = strict_fork(); child == 0) {
    118                 int ret = execle(path, "parsenums", "-i=2147483647", "-u=4294967295", "-l=" BIG_UNSIGNED_LONG, "-L=18446744073709551615", "-d=5e6", (const char*)0p, env);
    119                 if(ret < 0) {
    120                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    121                         exit(1);
    122                 }
    123         }
    124         else {
    125                 int status = do_wait(child);
    126                 print_status(status);
    127         }
    128 
    129         printf("too big values arg:\n");
    130         if(pid_t child = strict_fork(); child == 0) {
    131                 int ret = execle(path, "parsenums", "-i=2147483648", (const char*)0p, env);
    132                 if(ret < 0) {
    133                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    134                         exit(1);
    135                 }
    136         }
    137         else {
    138                 int status = do_wait(child);
    139                 print_status(status);
    140         }
    141 
    142         if(pid_t child = strict_fork(); child == 0) {
    143                 int ret = execle(path, "parsenums", "-u=4294967296", (const char*)0p, env);
    144                 if(ret < 0) {
    145                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    146                         exit(1);
    147                 }
    148         }
    149         else {
    150                 int status = do_wait(child);
    151                 print_status(status);
    152         }
    153 
    154         if(pid_t child = strict_fork(); child == 0) {
    155                 int ret = execle(path, "parsenums", "-l=" TOO_BIG_UNSIGNED_LONG, (const char*)0p, env);
    156                 if(ret < 0) {
    157                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    158                         exit(1);
    159                 }
    160         }
    161         else {
    162                 int status = do_wait(child);
    163                 print_status(status);
    164         }
    165 
    166         if(pid_t child = strict_fork(); child == 0) {
    167                 int ret = execle(path, "parsenums", "-L=18446744073709551616", (const char*)0p, env);
    168                 if(ret < 0) {
    169                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    170                         exit(1);
    171                 }
    172         }
    173         else {
    174                 int status = do_wait(child);
    175                 print_status(status);
    176         }
    177 
    178         printf("negative errors arg:\n");
    179         if(pid_t child = strict_fork(); child == 0) {
    180                 int ret = execle(path, "parsenums", "-u=-1", (const char*)0p, env);
    181                 if(ret < 0) {
    182                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    183                         exit(1);
    184                 }
    185         }
    186         else {
    187                 int status = do_wait(child);
    188                 print_status(status);
    189         }
    190 
    191         if(pid_t child = strict_fork(); child == 0) {
    192                 int ret = execle(path, "parsenums", "-l=-1", (const char*)0p, env);
    193                 if(ret < 0) {
    194                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    195                         exit(1);
    196                 }
    197         }
    198         else {
    199                 int status = do_wait(child);
    200                 print_status(status);
    201         }
    202 
    203         if(pid_t child = strict_fork(); child == 0) {
    204                 int ret = execle(path, "parsenums", "-L=-1", (const char*)0p, env);
    205                 if(ret < 0) {
    206                         fprintf(stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror(errno));
    207                         exit(1);
    208                 }
    209         }
    210         else {
    211                 int status = do_wait(child);
    212                 print_status(status);
    213         }
    214 
    215         printf("All Done!\n");
     63int true_main( const char * path, char * env[] ) {
     64        printf( "no arg:\n" );
     65        if ( pid_t child = strict_fork(); child == 0 ) {
     66                int ret = execle( path, "parsenums", (const char*)0p, env );
     67                if ( ret < 0 ) {
     68                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     69                        exit( 1 );
     70                } // if
     71        } else {
     72                int status = do_wait( child );
     73                print_status( status );
     74        } // if
     75
     76        printf( "all 0 arg:\n" );
     77        if ( pid_t child = strict_fork(); child == 0 ) {
     78                int ret = execle( path, "parsenums", "-i=0", "-u=0", "-l=0", "-L=0", "-d=0", (const char*)0p, env );
     79                if ( ret < 0 ) {
     80                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     81                        exit( 1 );
     82                } // if
     83        } else {
     84                int status = do_wait( child );
     85                print_status( status );
     86        } // if
     87
     88        printf( "negative vals arg:\n" );
     89        if ( pid_t child = strict_fork(); child == 0 ) {
     90                int ret = execle( path, "parsenums", "-i=-1", "-d=-1", (const char*)0p, env );
     91                if ( ret < 0 ) {
     92                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     93                        exit( 1 );
     94                } // if
     95        } else {
     96                int status = do_wait( child );
     97                print_status( status );
     98        } // if
     99
     100        printf( "funky notation arg:\n" );
     101        if ( pid_t child = strict_fork(); child == 0 ) {
     102                int ret = execle( path, "parsenums", "-i=0x10", "-u=0x20", "-l=0x300", "-L=0x4000", "-d=5e6", (const char*)0p, env );
     103                if ( ret < 0 ) {
     104                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     105                        exit( 1 );
     106                } // if
     107        } else {
     108                int status = do_wait( child );
     109                print_status( status );
     110        } // if
     111
     112        printf( "big values arg:\n" );
     113        if ( pid_t child = strict_fork(); child == 0 ) {
     114                int ret = execle( path, "parsenums", "-i=2147483647", "-u=4294967295", "-l=" BIG_UNSIGNED_LONG, "-L=18446744073709551615", "-d=5e6", (const char*)0p, env );
     115                if ( ret < 0 ) {
     116                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     117                        exit( 1 );
     118                } // if
     119        } else {
     120                int status = do_wait( child );
     121                print_status( status );
     122        } // if
     123
     124        printf( "too big values arg:\n" );
     125        if ( pid_t child = strict_fork(); child == 0 ) {
     126                int ret = execle( path, "parsenums", "-i=2147483648", (const char*)0p, env );
     127                if ( ret < 0 ) {
     128                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     129                        exit( 1 );
     130                } // if
     131        } else {
     132                int status = do_wait( child );
     133                print_status( status );
     134        } // if
     135
     136        if ( pid_t child = strict_fork(); child == 0 ) {
     137                int ret = execle( path, "parsenums", "-u=4294967296", (const char*)0p, env );
     138                if ( ret < 0 ) {
     139                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     140                        exit( 1 );
     141                } // if
     142        } else {
     143                int status = do_wait( child );
     144                print_status( status );
     145        } // if
     146
     147        if ( pid_t child = strict_fork(); child == 0 ) {
     148                int ret = execle( path, "parsenums", "-l=" TOO_BIG_UNSIGNED_LONG, (const char*)0p, env );
     149                if ( ret < 0 ) {
     150                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     151                        exit( 1 );
     152                } // if
     153        } else {
     154                int status = do_wait( child );
     155                print_status( status );
     156        } // if
     157
     158        if ( pid_t child = strict_fork(); child == 0 ) {
     159                int ret = execle( path, "parsenums", "-L=18446744073709551616", (const char*)0p, env );
     160                if ( ret < 0 ) {
     161                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     162                        exit( 1 );
     163                } // if
     164        } else {
     165                int status = do_wait( child );
     166                print_status( status );
     167        } // if
     168
     169        printf( "negative errors arg:\n" );
     170        if ( pid_t child = strict_fork(); child == 0 ) {
     171                int ret = execle( path, "parsenums", "-u=-1", (const char*)0p, env );
     172                if ( ret < 0 ) {
     173                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     174                        exit( 1 );
     175                } // if
     176        } else {
     177                int status = do_wait( child );
     178                print_status( status );
     179        } // if
     180
     181        if ( pid_t child = strict_fork(); child == 0 ) {
     182                int ret = execle( path, "parsenums", "-l=-1", (const char*)0p, env );
     183                if ( ret < 0 ) {
     184                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     185                        exit( 1 );
     186                } // if
     187        } else {
     188                int status = do_wait( child );
     189                print_status( status );
     190        } // if
     191
     192        if ( pid_t child = strict_fork(); child == 0 ) {
     193                int ret = execle( path, "parsenums", "-L=-1", (const char*)0p, env );
     194                if ( ret < 0 ) {
     195                        fprintf( stderr, "Execl 2 returned with error: %d '%s'\n", errno, strerror( errno ) );
     196                        exit( 1 );
     197                } // if
     198        } else {
     199                int status = do_wait( child );
     200                print_status( status );
     201        } // if
     202
     203        printf( "All Done!\n" );
    216204
    217205        return 0;
Note: See TracChangeset for help on using the changeset viewer.