code_c/Maasha/src/test/test_filesys.c

   1 #include "common.h"
   2 #include "filesys.h"
   3
   4 //#define TEST_FILE "/Users/m.hansen/DATA/genomes/hg18/hg18.fna"
   5 #define TEST_FILE "test/test_files/test.fna"
   6 #define TEST_SIZE 1
   7
   8 static void test_read_open();
   9 static void test_write_open();
  10 static void test_append_open();
  11 static void test_close_stream();
  12 static void test_file_read();
  13 static void test_file_unlink();
  14 static void test_file_rename();
  15 static void test_buffer_new();
  16 static void test_buffer_read();
  17 static void test_buffer_getc();
  18 static void test_buffer_ungetc();
  19 static void test_buffer_gets();
  20 static void test_buffer_ungets();
  21 static void test_buffer_new_size();
  22 static void test_buffer_resize();
  23 static void test_buffer_move();
  24 static void test_buffer_destroy();
  25 static void test_buffer_print();
  26
  27
  28 int main()
  29 {
  30     fprintf( stderr, "Running all tests for filesys.c\n" );
  31
  32     test_read_open();
  33     test_write_open();
  34     test_append_open();
  35     test_close_stream();
  36     test_file_read();
  37     test_file_unlink();
  38     test_file_rename();
  39     test_buffer_new();
  40     test_buffer_read();
  41     test_buffer_getc();
  42     test_buffer_ungetc();
  43     test_buffer_gets();
  44     test_buffer_ungets();
  45     test_buffer_new_size();
  46     test_buffer_resize();
  47     test_buffer_move();
  48     test_buffer_destroy();
  49     test_buffer_print();
  50
  51     fprintf( stderr, "Done\n\n" );
  52
  53     return EXIT_SUCCESS;
  54 }
  55
  56
  57 void test_read_open()
  58 {
  59     fprintf( stderr, "   Testing read_open ... " );
  60
  61     FILE *fp;
  62
  63     // fp = read_open( "/tmp/asdf" );
  64     // fp = read_open( "/private/etc/ssh_host_rsa_key" );
  65     fp = read_open( "/dev/null" );
  66
  67     close_stream( fp );
  68
  69     fprintf( stderr, "OK\n" );
  70 }
  71
  72
  73 void test_write_open()
  74 {
  75     fprintf( stderr, "   Testing write_open ... " );
  76
  77     FILE *fp;
  78
  79     // fp = write_open( "/tmp/asdf" );
  80     // fp = write_open( "/private/etc/ssh_host_rsa_key" );
  81     fp = write_open( "/dev/null" );
  82
  83     close_stream( fp );
  84
  85     fprintf( stderr, "OK\n" );
  86 }
  87
  88
  89 void test_append_open()
  90 {
  91     fprintf( stderr, "   Testing append_open ... " );
  92
  93     FILE *fp;
  94
  95     //fp = append_open( "/tmp/asdf" );
  96     //fp = append_open( "/private/etc/ssh_host_rsa_key" );
  97     fp = append_open( "/dev/null" );
  98
  99     close_stream( fp );
 100
 101     fprintf( stderr, "OK\n" );
 102 }
 103
 104
 105 void test_close_stream()
 106 {
 107     fprintf( stderr, "   Testing close_stream ... " );
 108
 109     FILE *fp;
 110
 111     fp = read_open( "/dev/null" );
 112
 113     close_stream( fp );
 114
 115     fprintf( stderr, "OK\n" );
 116 }
 117
 118
 119 void test_file_read()
 120 {
 121     fprintf( stderr, "   Testing file_read ... " );
 122
 123     char *file   = "/tmp/test_file_read";
 124     char *str1   = "MARTIN";
 125     char *str2   = NULL;
 126     FILE *fp1    = NULL;
 127     FILE *fp2    = NULL;
 128     size_t len   = strlen( str1 );
 129     size_t num   = 0;
 130
 131     fp1 = write_open( file );
 132     fprintf( fp1, str1 );
 133     close_stream( fp1 );
 134
 135     fp2 = read_open( file );
 136
 137     num = file_read( fp2, &str2, len );
 138
 139     close_stream( fp2 );
 140
 141     assert( num == len );
 142     assert( strcmp( str1, str2 ) == 0 );
 143
 144     fprintf( stderr, "OK\n" );
 145 }
 146
 147
 148 void test_file_unlink()
 149 {
 150     fprintf( stderr, "   Testing file_unlink ... " );
 151
 152     char *test_file = "/tmp/test";
 153     FILE *fp;
 154
 155     fp = write_open( test_file );
 156
 157     close_stream( fp );
 158
 159     //file_unlink( "" );
 160     //file_unlink( "/dev/null" );
 161     //file_unlink( "/tmp/" );
 162     //file_unlink( "/private/etc/ssh_host_rsa_key" );
 163     file_unlink( test_file );
 164
 165     fprintf( stderr, "OK\n" );
 166 }
 167
 168
 169 void test_file_rename()
 170 {
 171     fprintf( stderr, "   Testing file_rename ... " );
 172
 173     char *file_before = "/tmp/before";
 174     char *file_after  = "/tmp/after";
 175
 176     FILE *fp;
 177
 178     fp = write_open( file_before );
 179
 180     close_stream( fp );
 181
 182     //file_rename( file_after, file_after );
 183     file_rename( file_before, file_before );
 184     file_rename( file_before, file_after );
 185
 186     //file_unlink( file_before );
 187     file_unlink( file_after );
 188
 189     fprintf( stderr, "OK\n" );
 190 }
 191
 192
 193 void test_buffer_new()
 194 {
 195     fprintf( stderr, "   Testing buffer_new ... " );
 196
 197     char        *file   = "/tmp/test_buffer_new";
 198     char        *str    = "MARTIN";
 199     FILE        *fp     = NULL;
 200     size_t       size   = 10;
 201     size_t       num    = 0;
 202     file_buffer *buffer = NULL;
 203
 204     fp = write_open( file );
 205     fprintf( fp, str );
 206     close_stream( fp );
 207
 208     num = buffer_new( file, &buffer, size );
 209
 210     assert( num == strlen( str ) );
 211     assert( buffer->token_pos   == 0 );
 212     assert( buffer->buffer_pos  == 0 );
 213     assert( buffer->buffer_end  == 6 );
 214     assert( buffer->buffer_size == size );
 215     assert( buffer->eof         == TRUE );
 216     assert( strcmp( str, buffer->str ) == 0 );
 217
 218     buffer_destroy( &buffer );
 219
 220     buffer = NULL;
 221
 222     file_unlink( file );
 223
 224     fprintf( stderr, "OK\n" );
 225 }
 226
 227
 228 void test_buffer_read()
 229 {
 230     fprintf( stderr, "   Testing buffer_read ... " );
 231
 232     char        *file   = "/tmp/test_buffer_read";
 233     char        *str    = "MARTIN";
 234     FILE        *fp     = NULL;
 235     size_t       size   = 2;
 236     size_t       num    = 0;
 237     file_buffer *buffer = NULL;
 238
 239     fp = write_open( file );
 240     fprintf( fp, str );
 241     close_stream( fp );
 242
 243     num = buffer_new( file, &buffer, size );
 244
 245     assert( num == 2 );
 246     assert( buffer->token_pos   == 0 );
 247     assert( buffer->buffer_pos  == 0 );
 248     assert( buffer->buffer_end  == 2 );
 249     assert( buffer->buffer_size == size );
 250     assert( buffer->eof         == FALSE );
 251     assert( strcmp( buffer->str, "MA" ) == 0 );
 252
 253     buffer->buffer_pos += 2;
 254
 255     num = buffer_read( &buffer );
 256
 257     assert( num == 2 );
 258     assert( buffer->token_pos   == 0 );
 259     assert( buffer->buffer_pos  == 2 );
 260     assert( buffer->buffer_end  == 4 );
 261     assert( buffer->buffer_size == size );
 262     assert( buffer->eof         == FALSE );
 263     assert( strcmp( buffer->str, "MART" ) == 0 );
 264
 265     buffer->buffer_pos += 2;
 266
 267     num = buffer_read( &buffer );
 268
 269     assert( num == 2 );
 270     assert( buffer->token_pos   == 0 );
 271     assert( buffer->buffer_pos  == 4 );
 272     assert( buffer->buffer_end  == 6 );
 273     assert( buffer->buffer_size == size );
 274     assert( buffer->eof         == FALSE );
 275     assert( strcmp( buffer->str, "MARTIN" ) == 0 );
 276
 277     buffer->buffer_pos += 2;
 278
 279     num = buffer_read( &buffer );
 280
 281     assert( num == 0 );
 282     assert( buffer->token_pos   == 0 );
 283     assert( buffer->buffer_pos  == 6 );
 284     assert( buffer->buffer_end  == 6 );
 285     assert( buffer->buffer_size == size );
 286     assert( buffer->eof         == TRUE );
 287     assert( strcmp( buffer->str, "MARTIN" ) == 0 );
 288
 289     buffer_destroy( &buffer );
 290
 291     buffer = NULL;
 292
 293     file_unlink( file );
 294     fprintf( stderr, "OK\n" );
 295 }
 296
 297
 298 void test_buffer_getc()
 299 {
 300     fprintf( stderr, "   Testing buffer_getc ... " );
 301
 302     char        *file   = "/tmp/test_buffer_getc";
 303     char        *str    = "MARTIN";
 304     FILE        *fp     = NULL;
 305     size_t       size   = strlen( str );
 306     size_t       i      = 0;
 307     char         c      = 0;
 308     file_buffer *buffer = NULL;
 309
 310     fp = write_open( file );
 311     fprintf( fp, str );
 312     close_stream( fp );
 313
 314     buffer_new( file, &buffer, size );
 315
 316     for ( i = 0; str[ i ]; i++ )
 317     {
 318         c = buffer_getc( buffer );
 319
 320         assert( str[ i ] == c );
 321     }
 322
 323     buffer_destroy( &buffer );
 324
 325     buffer = NULL;
 326
 327     file_unlink( file );
 328
 329     fprintf( stderr, "OK\n" );
 330 }
 331
 332
 333 void test_buffer_ungetc()
 334 {
 335     fprintf( stderr, "   Testing buffer_ungetc ... " );
 336
 337     char        *file   = "/tmp/test_buffer_ungetc";
 338     char        *str    = "MARTIN";
 339     FILE        *fp     = NULL;
 340     char         c      = '\0';
 341     size_t       i      = 0;
 342     file_buffer *buffer = NULL;
 343
 344     fp = write_open( file );
 345
 346     fprintf( fp, str );
 347
 348     close_stream( fp );
 349
 350     buffer_new( file, &buffer, TEST_SIZE );
 351
 352     c = buffer_getc( buffer );
 353
 354     assert( c == 'M' );
 355
 356     buffer_ungetc( buffer );
 357
 358     i = 0;
 359
 360     while ( ( c = buffer_getc( buffer ) ) != EOF )
 361     {
 362         assert( c == str[ i ] );
 363
 364         i++;
 365     }
 366
 367     assert( c == EOF );
 368
 369     buffer_ungetc( buffer );
 370
 371     c = buffer_getc( buffer );
 372
 373     assert( c == 'N' );
 374
 375     buffer_destroy( &buffer );
 376
 377     buffer = NULL;
 378
 379     file_unlink( file );
 380
 381     fprintf( stderr, "OK\n" );
 382 }
 383
 384
 385 void test_buffer_gets()
 386 {
 387     fprintf( stderr, "   Testing buffer_gets ... " );
 388
 389     char        *file   = "/tmp/test_buffer_gets";
 390     char        *out    = "MARTIN\nASSER\nHANSEN\n";
 391     FILE        *fp     = NULL;
 392     char        *str    = NULL;
 393     size_t       size   = 1;
 394     size_t          i   = 0;
 395     file_buffer *buffer = NULL;
 396
 397     fp = write_open( file );
 398     fprintf( fp, out );
 399     close_stream( fp );
 400
 401     buffer_new( file, &buffer, size );
 402
 403     i = 0;
 404
 405     while( ( str = buffer_gets( buffer ) ) != NULL )
 406     {
 407         if ( i == 0 ) {
 408             assert( strcmp( str, "MARTIN\n" ) == 0 );
 409         } else if ( i == 1 ) {
 410             assert( strcmp( str, "ASSER\n" ) == 0 );
 411         } else if ( i == 2 ) {
 412             assert( strcmp( str, "HANSEN\n" ) == 0 );
 413         }
 414
 415         i++;
 416     }
 417
 418     buffer_destroy( &buffer );
 419
 420     buffer = NULL;
 421
 422     file_unlink( file );
 423
 424     fprintf( stderr, "OK\n" );
 425 }
 426
 427
 428 void test_buffer_ungets()
 429 {
 430     fprintf( stderr, "   Testing buffer_ungets ... " );
 431
 432     char        *file   = "/tmp/test_buffer_ungets";
 433     char        *out    = "MARTIN\nASSER\nHANSEN\n";
 434     FILE        *fp     = NULL;
 435     size_t       size   = 1;
 436     char        *str1   = NULL;
 437     char        *str2   = NULL;
 438     file_buffer *buffer = NULL;
 439
 440     fp = write_open( file );
 441
 442     fprintf( fp, out );
 443
 444     close_stream( fp );
 445
 446     buffer_new( file, &buffer, size );
 447
 448     str1 = buffer_gets( buffer );
 449
 450     buffer_ungets( buffer );
 451
 452     str2 = buffer_gets( buffer );
 453
 454     assert( strcmp( str1, str2 ) == 0 );
 455
 456     while ( ( str1 = buffer_gets( buffer ) ) != NULL )
 457     {
 458     }
 459
 460     buffer_ungets( buffer );
 461
 462     str1 = buffer_gets( buffer );
 463
 464     assert( ( strcmp( str1, "HANSEN\n" ) ) == 0 );
 465
 466     buffer_destroy( &buffer );
 467
 468     buffer = NULL;
 469
 470     file_unlink( file );
 471
 472     fprintf( stderr, "OK\n" );
 473 }
 474
 475
 476 void test_buffer_new_size()
 477 {
 478     fprintf( stderr, "   Testing buffer_new_size ... " );
 479
 480     char        *file     = "/tmp/test_buffer_new_size";
 481     char        *str      = "X";
 482     size_t       size     = 1;
 483     FILE        *fp       = NULL;
 484     file_buffer *buffer   = NULL;
 485
 486     fp = write_open( file );
 487     fprintf( fp, str );
 488     close_stream( fp );
 489
 490     buffer_new( file, &buffer, size );
 491
 492     buffer_new_size( buffer, 201048577 );
 493
 494     assert( buffer->buffer_size == 268435456 );
 495
 496     buffer_destroy( &buffer );
 497
 498     buffer = NULL;
 499
 500     file_unlink( file );
 501
 502     fprintf( stderr, "OK\n" );
 503 }
 504
 505
 506 void test_buffer_resize()
 507 {
 508     fprintf( stderr, "   Testing buffer_resize ... " );
 509
 510     char        *file   = "/tmp/test_buffer_resize";
 511     char        *str    = "ABC";
 512     FILE        *fp     = NULL;
 513     size_t       size   = 1;
 514     size_t       i      = 0;
 515     char         c      = 0;
 516     file_buffer *buffer = NULL;
 517
 518     fp = write_open( file );
 519     fprintf( fp, str );
 520     close_stream( fp );
 521
 522     buffer_new( file, &buffer, size );
 523
 524     i = 0;
 525
 526     while ( ( c = buffer_getc( buffer ) ) != EOF )
 527     {
 528         assert( c == str[ i ] );
 529         i++;
 530     }
 531
 532     buffer_destroy( &buffer );
 533
 534     buffer = NULL;
 535
 536     file_unlink( file );
 537
 538     fprintf( stderr, "OK\n" );
 539 }
 540
 541
 542 void test_buffer_move()
 543 {
 544     fprintf( stderr, "   Testing buffer_move ... " );
 545
 546     char        *file     = "/tmp/test_buffer_move";
 547     char        *str      = "ABCDEFG";
 548     size_t       size     = strlen( str );
 549     size_t       new_size = 0;
 550     size_t       move     = 3;
 551     FILE        *fp       = NULL;
 552     file_buffer *buffer   = NULL;
 553
 554     fp = write_open( file );
 555
 556     fprintf( fp, str );
 557
 558     close_stream( fp );
 559
 560     buffer_new( file, &buffer, size );
 561
 562     new_size = buffer_move( buffer, size, move );
 563
 564     assert( new_size == strlen( buffer->str ) );
 565     assert( strcmp( buffer->str, "DEFG" ) == 0 );
 566
 567     new_size = buffer_move( buffer, new_size, move );
 568
 569     assert( new_size == strlen( buffer->str ) );
 570     assert( strcmp( buffer->str, "G" ) == 0 );
 571
 572     buffer_destroy( &buffer );
 573
 574     buffer = NULL;
 575
 576     file_unlink( file );
 577
 578     fprintf( stderr, "OK\n" );
 579 }
 580
 581
 582 void test_buffer_destroy()
 583 {
 584     fprintf( stderr, "   Testing buffer_destroy ... " );
 585
 586     char        *file   = "/tmp/test_buffer_destroy";
 587     char        *str    = "X";
 588     FILE        *fp     = NULL;
 589     file_buffer *buffer = NULL;
 590
 591     fp = write_open( file );
 592
 593     fprintf( fp, str );
 594
 595     close_stream( fp );
 596
 597     buffer_new( file, &buffer, TEST_SIZE );
 598
 599     buffer_destroy( &buffer );
 600
 601     file_unlink( file );
 602
 603     fprintf( stderr, "OK\n" );
 604 }
 605
 606
 607 void test_buffer_print()
 608 {
 609     fprintf( stderr, "   Testing buffer_print ... " );
 610
 611     file_buffer *buffer = NULL;
 612
 613     buffer_new( TEST_FILE, &buffer, TEST_SIZE );
 614
 615 //    buffer_print( buffer );
 616
 617     buffer_destroy( &buffer );
 618
 619     buffer = NULL;
 620
 621     fprintf( stderr, "OK\n" );
 622 }
 623