code_c/Maasha/src/test/test_filesys.c

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