test/clib/fseek_test.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <errno.h>
   9
  10 #define SHOW_PROGRESS 0
  11
  12 // Global variables
  13 int global_test_counter = 0;
  14 int global_test_step_counter = 0;
  15 int global_failure_indicator = 0;
  16
  17 FILE * testfilepointer = NULL;
  18 size_t buffersize = 1024;
  19 char writedata[1024] = {0};
  20 char * testfilename = "fseek_test_file";
  21
  22 void reset_global_test_counter()
  23 {
  24     global_test_counter = 0;
  25     global_test_step_counter = 0;
  26 }
  27
  28 void next_test()
  29 {
  30     global_test_counter++;
  31     global_test_step_counter = 0;
  32 }
  33
  34 void next_test_step()
  35 {
  36     global_test_step_counter++;
  37 }
  38
  39 // Reporting functions
  40 void report(const char * status, const char * message)
  41 {
  42     printf("REPORT : %s : %s \n", status, message);
  43 }
  44
  45 void report_progress(const char * message)
  46 {
  47     report("PROGRESS", message);
  48 }
  49
  50 void report_failure(const char * message)
  51 {
  52     report("FAILED", message);
  53 }
  54
  55 void report_failure_strerror()
  56 {
  57     report_failure((const char*)strerror(errno));
  58 }
  59
  60 void test_report(const char * status, const char * message)
  61 {
  62     printf("TEST %d-%d : %s : %s \n", global_test_counter , global_test_step_counter, status, message);
  63 }
  64
  65 void test_report_progress(const char * message)
  66 {
  67 #if SHOW_PROGRESS == 1
  68     test_report("PROGRESS", message);
  69 #endif
  70 }
  71
  72 void test_report_failure(const char * message)
  73 {
  74     test_report("FAILED", message);
  75 }
  76
  77 void test_report_success(const char * message)
  78 {
  79     test_report("OK", message);
  80 }
  81
  82 void test_report_description(const char * message)
  83 {
  84     test_report("TEST DESCRIPTION", message);
  85 }
  86
  87 void test_report_failure_strerror()
  88 {
  89     test_report_failure((const char*)strerror(errno));
  90 }
  91
  92 void erase_buffer(char * buffer, size_t size)
  93 {
  94     memset(buffer, 0, size);
  95 }
  96
  97 int compare_buffers(const char * buffer1, const char * buffer2, size_t bufferssize)
  98 {
  99     return memcmp(buffer1, buffer2, bufferssize);
 100 }
 101
 102 void close_test_file()
 103 {
 104     if (testfilepointer != NULL)
 105     {
 106         if (fclose(testfilepointer) != 0)
 107         {
 108             report_failure_strerror();
 109             report_failure("Failed to close the file.");
 110             return;
 111         }
 112         testfilepointer = NULL;
 113     }
 114 }
 115
 116 // Tests
 117 int test_fseek_ftell_preparation(const char * fopenflags)
 118 {
 119     size_t operationsize = 0;
 120
 121     report_progress("Starting test_fseek_ftell_preparation");
 122     report_progress(fopenflags);
 123
 124     if (testfilepointer != NULL)
 125     {
 126         report_failure("Pointer for test file not closed.");
 127         return -1;
 128     }
 129
 130     // zero buffer
 131     erase_buffer(writedata, buffersize);
 132
 133     // open file, write data
 134     testfilepointer = fopen(testfilename, fopenflags);
 135     if (testfilepointer == NULL)
 136     {
 137         report_failure_strerror();
 138         report_failure("Failed to open file for writting.");
 139         return -1;
 140     }
 141     operationsize = fwrite(writedata, 1, buffersize, testfilepointer);
 142     if (operationsize != buffersize)
 143     {
 144         report_failure_strerror();
 145         report_failure("Failed to write data.");
 146         return -1;
 147     }
 148
 149     // Seek to beginning
 150     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
 151     {
 152         report_failure_strerror();
 153         report_failure("Failed to seek to file beginning.");
 154         return -1;
 155     }
 156
 157     return 0;
 158
 159 }
 160
 161 int test_fseek_ftell()
 162 {
 163
 164     /* Expects that testfilepointer is opened in correct mode */
 165     int ftellposition = 0;
 166     char conv[16] = {0};
 167
 168     report_progress("Start test_fseek_ftell");
 169
 170     /*
 171      * TEST
 172      */
 173
 174     next_test_step();
 175
 176     test_report_description("seek to begin, tell location");
 177
 178     // seek to begin, tell location
 179     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
 180     {
 181         test_report_failure_strerror();
 182         test_report_failure("Failed to seek to beginning of file");
 183         return -1;
 184     }
 185     test_report_progress("Seek to beginning of file.");
 186     ftellposition = ftell(testfilepointer);
 187     if (ftellposition == -1)
 188     {
 189         test_report_failure_strerror();
 190         test_report_failure("Failed to tell position");
 191         return -1;
 192     }
 193     else
 194         if (ftellposition != 0)
 195         {
 196             test_report_failure("Wrong position in stream reported");
 197             sprintf(conv, "%d", ftellposition);
 198             test_report_failure(conv);
 199             return -1;
 200         }
 201     test_report_success("Correct position in stream reported");
 202     test_report_success("SUCCESS");
 203
 204     /*
 205      * TEST END
 206      */
 207
 208     /*
 209      * TEST
 210      */
 211
 212     next_test_step();
 213
 214     test_report_description("seek foreward, tell location");
 215
 216     // seek to begin, tell location
 217     if (fseek(testfilepointer, 153, SEEK_CUR) != 0)
 218     {
 219         test_report_failure_strerror();
 220         test_report_failure("Failed to seek foreward");
 221         return -1;
 222     }
 223     test_report_progress("Seek foreward made.");
 224     ftellposition = ftell(testfilepointer);
 225     if (ftellposition == -1)
 226     {
 227         test_report_failure_strerror();
 228         test_report_failure("Failed to tell position");
 229         return -1;
 230     }
 231     else
 232         if (ftellposition != 153)
 233         {
 234             test_report_failure("Wrong position in stream reported");
 235             sprintf(conv, "%d", ftellposition);
 236             test_report_failure(conv);
 237             return -1;
 238         }
 239     test_report_success("Correct position in stream reported");
 240     test_report_success("SUCCESS");
 241
 242     /*
 243      * TEST END
 244      */
 245
 246     /*
 247      * TEST
 248      */
 249
 250     next_test_step();
 251
 252     test_report_description("seek backwards, tell location");
 253
 254     // seek backwards, tell location
 255     if (fseek(testfilepointer, -80, SEEK_CUR) != 0)
 256     {
 257         test_report_failure_strerror();
 258         test_report_failure("Failed to seek backwards");
 259         return -1;
 260     }
 261     test_report_progress("Seek backwards made.");
 262     ftellposition = ftell(testfilepointer);
 263     if (ftellposition == -1)
 264     {
 265         test_report_failure_strerror();
 266         test_report_failure("Failed to tell position");
 267         return -1;
 268     }
 269     else
 270         if (ftellposition != (153-80))
 271         {
 272             test_report_failure("Wrong position in stream reported");
 273             sprintf(conv, "%d", ftellposition);
 274             test_report_failure(conv);
 275             return -1;
 276         }
 277     test_report_success("Correct position in stream reported");
 278     test_report_success("SUCCESS");
 279
 280     /*
 281      * TEST END
 282      */
 283
 284     /*
 285      * TEST
 286      */
 287
 288     next_test_step();
 289
 290     test_report_description("seek to the end, tell location");
 291
 292     // seek to begin, tell location
 293     if (fseek(testfilepointer, 0, SEEK_END) != 0)
 294     {
 295         test_report_failure_strerror();
 296         test_report_failure("Failed to seek to end of file");
 297         return -1;
 298     }
 299     test_report_progress("Seek to end of file made.");
 300     ftellposition = ftell(testfilepointer);
 301     if (ftellposition == -1)
 302     {
 303         test_report_failure_strerror();
 304         test_report_failure("Failed to tell position");
 305         return -1;
 306     }
 307     else
 308         if (ftellposition != buffersize)
 309         {
 310             test_report_failure("Wrong position in stream reported");
 311             sprintf(conv, "%d", ftellposition);
 312             test_report_failure(conv);
 313             return -1;
 314         }
 315     test_report_success("Correct position in stream reported");
 316     test_report_success("SUCCESS");
 317
 318     /*
 319      * TEST END
 320      */
 321
 322     /*
 323      * TEST
 324      */
 325
 326     next_test_step();
 327
 328     test_report_description("seek foreward(beyond file), tell location");
 329
 330     // seek foreward(beyond file), tell location
 331     if (fseek(testfilepointer, 120, SEEK_CUR) != 0)
 332     {
 333         test_report_failure_strerror();
 334         test_report_failure("Failed to seek beyond file end");
 335         return -1;
 336     }
 337     test_report_progress("Seek beyond file end made.");
 338     ftellposition = ftell(testfilepointer);
 339     if (ftellposition == -1)
 340     {
 341         test_report_failure_strerror();
 342         test_report_failure("Failed to tell position");
 343         return -1;
 344     }
 345     else
 346         if (ftellposition != buffersize + 120)
 347         {
 348             test_report_failure("Wrong position in stream reported");
 349             sprintf(conv, "%d", ftellposition);
 350             test_report_failure(conv);
 351             return -1;
 352         }
 353     test_report_success("Correct position in stream reported");
 354     test_report_success("SUCCESS");
 355
 356     /*
 357      * TEST END
 358      */
 359
 360     /*
 361      * TEST
 362      */
 363
 364     next_test_step();
 365
 366     test_report_description("seek backwards, tell location");
 367
 368     // seek backwards, tell location
 369     if (fseek(testfilepointer, -240, SEEK_CUR) != 0)
 370     {
 371         test_report_failure_strerror();
 372         test_report_failure("Failed to seek backwards");
 373         return -1;
 374     }
 375     test_report_progress("Seek backwards made.");
 376     ftellposition = ftell(testfilepointer);
 377     if (ftellposition == -1)
 378     {
 379         test_report_failure_strerror();
 380         test_report_failure("Failed to tell position");
 381         return -1;
 382     }
 383     else
 384         if (ftellposition != buffersize - 120)
 385         {
 386             test_report_failure("Wrong position in stream reported");
 387             sprintf(conv, "%d", ftellposition);
 388             test_report_failure(conv);
 389             return -1;
 390         }
 391     test_report_success("Correct position in stream reported");
 392     test_report_success("SUCCESS");
 393
 394     /*
 395      * TEST END
 396      */
 397
 398     /*
 399      * TEST
 400      */
 401
 402     next_test_step();
 403
 404     test_report_description("seek to end with positive offset, tell location");
 405
 406     // seek to end with positive offset, tell location
 407     if (fseek(testfilepointer, 120, SEEK_END) != 0)
 408     {
 409         test_report_failure_strerror();
 410         test_report_failure("Failed to seek to end with positive offset");
 411         return -1;
 412     }
 413     test_report_progress("Seek to end with positive offset made.");
 414     ftellposition = ftell(testfilepointer);
 415     if (ftellposition == -1)
 416     {
 417         test_report_failure_strerror();
 418         test_report_failure("Failed to tell position");
 419         return -1;
 420     }
 421     else
 422         if (ftellposition != buffersize + 120)
 423         {
 424             test_report_failure("Wrong position in stream reported");
 425             sprintf(conv, "%d", ftellposition);
 426             test_report_failure(conv);
 427             return -1;
 428         }
 429     test_report_success("Correct position in stream reported");
 430     test_report_success("SUCCESS");
 431
 432     /*
 433      * TEST END
 434      */
 435
 436     return 0;
 437 }
 438
 439 int test_fseek_ftell_wrapper(const char * fopenflags)
 440 {
 441     next_test();
 442
 443     int result = test_fseek_ftell_preparation(fopenflags);
 444     if (result != 0)
 445     {
 446         report_failure("Preparation failed");
 447     }
 448     else
 449         result = test_fseek_ftell();
 450
 451     close_test_file();
 452
 453     return result;
 454 }
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474 int test_fseek_and_fread_preparation(const char * fopenflags)
 475 {
 476     char readdatabuffer1[1024] = {0};
 477     int i = 0;
 478     size_t operationsize = 0;
 479
 480     report_progress("Starting test_fseek_and_fread_preparation");
 481     report_progress(fopenflags);
 482
 483     if (testfilepointer != NULL)
 484     {
 485         report_failure("Pointer for test file not closed.");
 486         return -1;
 487     }
 488
 489     // initialize with random data (always the same because of const seed)
 490     srand(1);
 491     for(i = 0; i < buffersize; i++)
 492         writedata[i] = (char)rand();
 493
 494     // open file, write data, close file
 495     testfilepointer = fopen(testfilename, "wb+");
 496     if (testfilepointer == NULL)
 497     {
 498         report_failure_strerror();
 499         report_failure("Failed to open file for writting.");
 500         return -1;
 501     }
 502     operationsize = fwrite(writedata, 1, buffersize, testfilepointer);
 503     if (operationsize != buffersize)
 504     {
 505         report_failure_strerror();
 506         report_failure("Failed to write data.");
 507         return -1;
 508     }
 509
 510     if ((strcmp(fopenflags, "w+b") == 0) ||
 511         (strcmp(fopenflags, "wb+") == 0))
 512     {
 513         // Seek to beginning
 514         if (fseek(testfilepointer, 0, SEEK_SET) != 0)
 515         {
 516             report_failure_strerror();
 517             report_failure("Failed to seek to file beginning (w+b).");
 518             return -1;
 519         }
 520     }
 521     else
 522     {
 523
 524         if (fclose(testfilepointer) != 0)
 525         {
 526             report_failure_strerror();
 527             report_failure("Failed to close file.");
 528             return -1;
 529         }
 530
 531         // open file
 532         testfilepointer = fopen(testfilename, "rb");
 533         if (testfilepointer == NULL)
 534         {
 535             report_failure_strerror();
 536             report_failure("Failed to open file for reading.");
 537             return -1;
 538         }
 539     }
 540
 541     //read data, compare data, close file
 542     erase_buffer(readdatabuffer1, buffersize);
 543     operationsize = fread(readdatabuffer1, 1, buffersize, testfilepointer);
 544     if (operationsize != buffersize)
 545     {
 546         report_failure_strerror();
 547         report_failure("Failed to read data.");
 548         return -1;
 549     }
 550     if (compare_buffers(readdatabuffer1, writedata, buffersize) != 0)
 551     {
 552         report_failure("Read data differs from written data");
 553         return -1;
 554     }
 555
 556     if ((strcmp(fopenflags, "w+b") == 0) ||
 557         (strcmp(fopenflags, "wb+") == 0))
 558     {
 559         // Seek to beginning
 560         if (fseek(testfilepointer, 0, SEEK_SET) != 0)
 561         {
 562             report_failure_strerror();
 563             report_failure("Failed to seek to file beginning (w+b).");
 564             return -1;
 565         }
 566     }
 567     else
 568     {
 569         // Close file and open it with new flags
 570         if (fclose(testfilepointer) != 0)
 571         {
 572             report_failure_strerror();
 573             report_failure("Failed to close file.");
 574             return -1;
 575         }
 576
 577         testfilepointer = fopen(testfilename, fopenflags);
 578         if (testfilepointer == NULL)
 579         {
 580             report_failure_strerror();
 581             report_failure("Failed to open file for seek testing.");
 582             return -1;
 583         }
 584     }
 585
 586     return 0;
 587
 588 }
 589
 590 int test_fseek_and_fread()
 591 {
 592
 593     /* Expects that testfilepointer is opened in correct mode */
 594     size_t chunksize = 128;
 595     char readdatabuffer1[1024] = {0};
 596     int i = 0;
 597     size_t operationsize = 0;
 598
 599     /*
 600      * TEST
 601      */
 602
 603     report_progress("Start test_fseek_and_fread");
 604
 605     next_test_step();
 606
 607     test_report_description("seek to begin, read some data , check data");
 608
 609     // seek to begin, read some data, check data
 610     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
 611     {
 612         test_report_failure_strerror();
 613         test_report_failure("Failed to seek to beginning of file");
 614         return -1;
 615     }
 616     test_report_progress("Seek to beginning of file.");
 617     erase_buffer(readdatabuffer1, buffersize);
 618     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 619     if (operationsize != chunksize)
 620     {
 621         test_report_failure_strerror();
 622         test_report_failure("Failed to read chunk of data.");
 623         return -1;
 624     }
 625     test_report_progress("Chunk read.");
 626     if (compare_buffers(readdatabuffer1, writedata, chunksize) != 0)
 627     {
 628         test_report_failure("Read data does not match written data");
 629         return -1;
 630     }
 631     test_report_success("Read data match written data.");
 632     test_report_success("SUCCESS");
 633
 634     /*
 635      * TEST END
 636      */
 637
 638
 639     /*
 640      * TEST
 641      */
 642
 643     next_test_step();
 644
 645     test_report_description("make absolute seek, read some data , check data");
 646
 647     // make absolute seek, read some data, check data
 648     if (fseek(testfilepointer, 350, SEEK_SET) != 0)
 649     {
 650         test_report_failure_strerror();
 651         test_report_failure("Failed to make absolute seek");
 652         return -1;
 653     }
 654     test_report_progress("Absolute seek made.");
 655     erase_buffer(readdatabuffer1, buffersize);
 656     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 657     if (operationsize != chunksize)
 658     {
 659         test_report_failure_strerror();
 660         test_report_failure("Failed to read chunk of data.");
 661         return -1;
 662     }
 663     test_report_progress("Chunk read.");
 664     if (compare_buffers(readdatabuffer1, writedata + 350, chunksize) != 0)
 665     {
 666         test_report_failure("Read data does not match written data");
 667         return -1;
 668     }
 669     test_report_success("Read data match written data.");
 670     test_report_success("SUCCESS");
 671
 672     /*
 673      * TEST END
 674      */
 675
 676
 677     /*
 678      * TEST
 679      */
 680
 681     next_test_step();
 682
 683     test_report_description("make relative seek backwards, read some data , check data");
 684     // make relative seek backwards, read some data, check data
 685     if (fseek(testfilepointer, - (120 + chunksize), SEEK_CUR) != 0)
 686     {
 687         test_report_failure_strerror();
 688         test_report_failure("Failed to make relative seek");
 689         return -1;
 690     }
 691     test_report_progress("Relative seek made.");
 692     erase_buffer(readdatabuffer1, buffersize);
 693     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 694     if (operationsize != chunksize)
 695     {
 696         test_report_failure_strerror();
 697         test_report_failure("Failed to read chunk of data.");
 698         return -1;
 699     }
 700     test_report_progress("Chunk read.");
 701     if (compare_buffers(readdatabuffer1, writedata + (350 - 120), chunksize) != 0)
 702     {
 703         test_report_failure("Read data does not match written data");
 704         return -1;
 705     }
 706     test_report_success("Read data match written data.");
 707     test_report_success("SUCCESS");
 708
 709     /*
 710      * TEST END
 711      */
 712
 713
 714     /*
 715      * TEST
 716      */
 717
 718     next_test_step();
 719
 720     test_report_description("make relative seek forewards, read some data , check data");
 721     // make relative seek forewards, read some data, check data
 722     if (fseek(testfilepointer, 138, SEEK_CUR) != 0)
 723     {
 724         test_report_failure_strerror();
 725         test_report_failure("Failed to make relative seek");
 726         return -1;
 727     }
 728     test_report_progress("Relative seek made.");
 729     erase_buffer(readdatabuffer1, buffersize);
 730     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 731     if (operationsize != chunksize)
 732     {
 733         test_report_failure_strerror();
 734         test_report_failure("Failed to read chunk of data.");
 735         return -1;
 736     }
 737     test_report_progress("Chunk read.");
 738     if (compare_buffers(readdatabuffer1, writedata + (350 - 120 + chunksize + 138), chunksize) != 0)
 739     {
 740         test_report_failure("Read data does not match written data");
 741         return -1;
 742     }
 743     test_report_success("Read data match written data.");
 744     test_report_success("SUCCESS");
 745
 746
 747     /*
 748      * TEST END
 749      */
 750
 751
 752     /*
 753      * TEST
 754      */
 755
 756     next_test_step();
 757
 758     test_report_description("seek to end, make relative seek backwards, read some data , check data");
 759     // seek to end, make relative seek backwards, read some data, check data
 760     if (fseek(testfilepointer, 0, SEEK_END) != 0)
 761     {
 762         test_report_failure_strerror();
 763         test_report_failure("Failed to seek to end");
 764         return -1;
 765     }
 766     test_report_progress("Seek to end made");
 767     if (fseek(testfilepointer, -210, SEEK_CUR) != 0)
 768     {
 769         test_report_failure_strerror();
 770         test_report_failure("Failed to make relative seek");
 771         return -1;
 772     }
 773     test_report_progress("Relative seek made.");
 774     erase_buffer(readdatabuffer1, buffersize);
 775     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 776     if (operationsize != chunksize)
 777     {
 778         test_report_failure_strerror();
 779         test_report_failure("Failed to read chunk of data.");
 780         return -1;
 781     }
 782     test_report_progress("Chunk read.");
 783     if (compare_buffers(readdatabuffer1, writedata + buffersize - 210, chunksize) != 0)
 784     {
 785         test_report_failure("Read data does not match written data");
 786         return -1;
 787     }
 788     test_report_success("Read data match written data.");
 789     test_report_success("SUCCESS");
 790
 791     /*
 792      * TEST END
 793      */
 794
 795
 796     /*
 797      * TEST
 798      */
 799
 800     next_test_step();
 801
 802     test_report_description("read some data (more than is in file) , check error code data");
 803     // read some data (more than is in file) , check error code data
 804     erase_buffer(readdatabuffer1, buffersize);
 805     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 806     if (operationsize != chunksize)
 807     {
 808         if (errno != 0/*rb*/ && errno != EINVAL/*a+b, w+b, r+b*/)
 809         {
 810             test_report_failure_strerror();
 811             test_report_failure("Error different than expected reported");
 812             return -1;
 813         }
 814     }
 815     else
 816     {
 817         test_report_failure("Number of read data should be different than requested data");
 818         return -1;
 819     }
 820     test_report_success("Error reported");
 821     test_report_success("SUCCESS");
 822
 823     /*
 824      * TEST END
 825      */
 826
 827
 828     /*
 829      * TEST
 830      */
 831
 832     next_test_step();
 833
 834     test_report_description("seek to beginning, seek forewards, seek backwards beyond file start, check error code");
 835     // seek to beginning, seek forewards, seek backwards beyond file start, check error code
 836     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
 837     {
 838         test_report_failure_strerror();
 839         test_report_failure("Failed to seek to beginning");
 840         return -1;
 841     }
 842     test_report_progress("Seek to beginning made.");
 843     if (fseek(testfilepointer, 99, SEEK_CUR) != 0)
 844     {
 845         test_report_failure_strerror();
 846         test_report_failure("Failed to make relative seek forewards");
 847         return -1;
 848     }
 849     test_report_progress("Relative seek forewards made.");
 850     if (fseek(testfilepointer, -150, SEEK_CUR) != 0)
 851     {
 852         if (errno != EINVAL)
 853         {
 854             test_report_failure_strerror();
 855             test_report_failure("Error different than expected reported");
 856             return -1;
 857         }
 858     }
 859     else
 860     {
 861         test_report_progress("Should not made relative seek backwards beyond file start.");
 862         return -1;
 863     }
 864     test_report_success("Error reported");
 865     test_report_success("SUCCESS");
 866
 867     /*
 868      * TEST END
 869      */
 870
 871
 872     /*
 873      * TEST
 874      */
 875
 876     next_test_step();
 877
 878     test_report_description("seek to end, seek forewards, read some data, check error code");
 879     // seek to end, seek forewards, read some data, check error code
 880     if (fseek(testfilepointer, 0, SEEK_END) != 0)
 881     {
 882         test_report_failure_strerror();
 883         test_report_failure("Failed to seek to end");
 884         return -1;
 885     }
 886     test_report_progress("Seek to end made.");
 887     if (fseek(testfilepointer, 99, SEEK_CUR) != 0)
 888     {
 889         test_report_failure_strerror();
 890         test_report_failure("Failed to make relative seek forewards");
 891         return -1;
 892     }
 893     test_report_progress("Relative seek forewards made.");
 894     erase_buffer(readdatabuffer1, buffersize);
 895     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 896     if (operationsize != chunksize)
 897     {
 898         if (errno != EINVAL)
 899         {
 900             test_report_failure_strerror();
 901             test_report_failure("Error different than expected reported");
 902             return -1;
 903         }
 904     }
 905     else
 906     {
 907         test_report_failure("Number of read data should be different than requested data");
 908         return -1;
 909     }
 910     test_report_success("Error reported");
 911     test_report_success("SUCCESS");
 912
 913    /*
 914      * TEST END
 915      */
 916
 917
 918     /*
 919      * TEST
 920      */
 921
 922     next_test_step();
 923
 924     test_report_description("seek to end with offset, read some data, check error code");
 925     // seek to end with offset, read some data, check error code
 926     if (fseek(testfilepointer, 100, SEEK_END) != 0)
 927     {
 928         test_report_failure_strerror();
 929         test_report_failure("Failed to seek to end with offset");
 930         return -1;
 931     }
 932     test_report_progress("Seek to end with offset made.");
 933     erase_buffer(readdatabuffer1, buffersize);
 934     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
 935     if (operationsize != chunksize)
 936     {
 937         if (errno != EINVAL)
 938         {
 939             test_report_failure_strerror();
 940             test_report_failure("Error different than expected reported");
 941             return -1;
 942         }
 943     }
 944     else
 945     {
 946         test_report_failure("Number of read data should be different than requested data");
 947         return -1;
 948     }
 949     test_report_success("Error reported");
 950     test_report_success("SUCCESS");
 951     return 0;
 952 }
 953
 954 int test_fseek_and_fread_wrapper(const char * fopenflags)
 955 {
 956     next_test();
 957
 958     int result = test_fseek_and_fread_preparation(fopenflags);
 959     if (result != 0)
 960     {
 961         report_failure("Preparation failed");
 962     }
 963     else
 964         result = test_fseek_and_fread();
 965
 966     close_test_file();
 967
 968     return result;
 969 }
 970
 971 int test_fseek_fwrite_fread_preparation()
 972 {
 973     char readdatabuffer1[1024] = {0};
 974     int i = 0;
 975     size_t operationsize = 0;
 976
 977     report_progress("Starting test_fseek_fwrite_fread_preparation");
 978
 979     if (testfilepointer != NULL)
 980     {
 981         report_failure("Pointer for test file not closed.");
 982         return -1;
 983     }
 984
 985     // Initilize random write buffer
 986     srand(1);
 987     for (i = 0; i < buffersize; i++)
 988         writedata[i] = (char)rand();
 989
 990     // open file, write data
 991     testfilepointer = fopen(testfilename, "wb+");
 992     if (testfilepointer == NULL)
 993     {
 994         report_failure_strerror();
 995         report_failure("Failed to open file for writting.");
 996         return -1;
 997     }
 998     operationsize = fwrite(writedata, 1, buffersize, testfilepointer);
 999     if (operationsize != buffersize)
1000     {
1001         report_failure_strerror();
1002         report_failure("Failed to write data.");
1003         return -1;
1004     }
1005
1006     // Seek to beginning
1007     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
1008     {
1009         report_failure_strerror();
1010         report_failure("Failed to seek to file beginning (w+b).");
1011         return -1;
1012     }
1013
1014     //read data, compare data
1015     erase_buffer(readdatabuffer1, buffersize);
1016     operationsize = fread(readdatabuffer1, 1, buffersize, testfilepointer);
1017     if (operationsize != buffersize)
1018     {
1019         report_failure_strerror();
1020         report_failure("Failed to read data.");
1021         return -1;
1022     }
1023     if (compare_buffers(readdatabuffer1, writedata, buffersize) != 0)
1024     {
1025         report_failure("Read data differs from written data");
1026         return -1;
1027     }
1028
1029     // Seek to beginning
1030     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
1031     {
1032         report_failure_strerror();
1033         report_failure("Failed to seek to file beginning (w+b).");
1034         return -1;
1035     }
1036
1037     return 0;
1038
1039 }
1040
1041 int test_fseek_fwrite_fread()
1042 {
1043     /* Expects that testfilepointer is opened in correct mode */
1044     char randomwritebuffer[1024] = {0};
1045     size_t chunksize = 128;
1046     char readdatabuffer1[1024] = {0};
1047     char zerobuffer[1024] = {0};
1048     int i = 0;
1049     size_t operationsize = 0;
1050
1051     // Initilize random write buffer
1052     // Don't initialize srand or randomwritebuffer == writedata
1053     for (i = 0; i < buffersize; i++)
1054         randomwritebuffer[i] = (char)rand();
1055
1056     /*
1057      * TEST
1058      */
1059
1060     report_progress("Start test_fseek_fwrite_fread");
1061
1062     next_test_step();
1063
1064     test_report_description("seek to begin, write some data , seek to begin, read 2x some data, check data");
1065
1066     // seek to begin, write some data , seek to begin, read 2x some data, check data
1067     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
1068     {
1069         test_report_failure_strerror();
1070         test_report_failure("Failed to seek to beginning of file");
1071         return -1;
1072     }
1073     test_report_progress("Seek to beginning of file.");
1074     operationsize = fwrite(randomwritebuffer, 1, chunksize, testfilepointer);
1075     if (operationsize != chunksize)
1076     {
1077         test_report_failure_strerror();
1078         test_report_failure("Failed to write chunk of data.");
1079         return -1;
1080     }
1081     test_report_progress("Chunk written.");
1082     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
1083     {
1084         test_report_failure_strerror();
1085         test_report_failure("Failed to seek to beginning of file");
1086         return -1;
1087     }
1088     test_report_progress("Seek to beginning of file.");
1089     erase_buffer(readdatabuffer1, buffersize);
1090     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1091     if (operationsize != 2 * chunksize)
1092     {
1093         test_report_failure_strerror();
1094         test_report_failure("Failed to read chunk of data.");
1095         return -1;
1096     }
1097     test_report_progress("Chunk read.");
1098     if (compare_buffers(readdatabuffer1, randomwritebuffer, chunksize) != 0)
1099     {
1100         test_report_failure("Read data does not match written data for first chunk");
1101         return -1;
1102     }
1103     test_report_success("Read data match written data for first chunk.");
1104     if (compare_buffers(readdatabuffer1 + chunksize, writedata + chunksize, chunksize) != 0)
1105     {
1106         test_report_failure("Read data does not match written data for second chunk");
1107         return -1;
1108     }
1109     test_report_success("Read data match written data for second chunk.");
1110     test_report_success("SUCCESS");
1111
1112     /*
1113      * TEST END
1114      */
1115
1116     /*
1117      * TEST
1118      */
1119
1120     next_test_step();
1121
1122     test_report_description("seek foreward, write some data , seek backward, read data, check data");
1123
1124     // seek foreward, write some data , seek backward, read data, check data
1125     if (fseek(testfilepointer, 3 * chunksize, SEEK_CUR) != 0)
1126     {
1127         test_report_failure_strerror();
1128         test_report_failure("Failed to seek foreward");
1129         return -1;
1130     }
1131     test_report_progress("Seek foreward made.");
1132     operationsize = fwrite(randomwritebuffer, 1, chunksize, testfilepointer);
1133     if (operationsize != chunksize)
1134     {
1135         test_report_failure_strerror();
1136         test_report_failure("Failed to write chunk of data.");
1137         return -1;
1138     }
1139     test_report_progress("Chunk written.");
1140     if (fseek(testfilepointer, - chunksize, SEEK_CUR) != 0)
1141     {
1142         test_report_failure_strerror();
1143         test_report_failure("Failed to seek backwards");
1144         return -1;
1145     }
1146     test_report_progress("Seek backwards made.");
1147     erase_buffer(readdatabuffer1, buffersize);
1148     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
1149     if (operationsize != chunksize)
1150     {
1151         test_report_failure_strerror();
1152         test_report_failure("Failed to read chunk of data.");
1153         return -1;
1154     }
1155     test_report_progress("Chunk read.");
1156     if (compare_buffers(readdatabuffer1, randomwritebuffer, chunksize) != 0)
1157     {
1158         test_report_failure("Read data does not match written");
1159         return -1;
1160     }
1161     test_report_success("Read data match written data.");
1162     test_report_success("SUCCESS");
1163
1164     /*
1165      * TEST END
1166      */
1167
1168     /*
1169      * TEST
1170      */
1171
1172     next_test_step();
1173
1174     test_report_description("seek backward, write some data , seek backward, read 2 x data, check data");
1175
1176     // seek backward, write some data , seek backward, read 2 x data, check data
1177     if (fseek(testfilepointer, -2 * chunksize, SEEK_CUR) != 0)
1178     {
1179         test_report_failure_strerror();
1180         test_report_failure("Failed to seek backwards");
1181         return -1;
1182     }
1183     test_report_progress("Seek backwards made.");
1184     operationsize = fwrite(randomwritebuffer + chunksize, 1, chunksize, testfilepointer);
1185     if (operationsize != chunksize)
1186     {
1187         test_report_failure_strerror();
1188         test_report_failure("Failed to write chunk of data.");
1189         return -1;
1190     }
1191     test_report_progress("Chunk written.");
1192     if (fseek(testfilepointer, -chunksize, SEEK_CUR) != 0)
1193     {
1194         test_report_failure_strerror();
1195         test_report_failure("Failed to seek backwards");
1196         return -1;
1197     }
1198     test_report_progress("Seek backwards made.");
1199     erase_buffer(readdatabuffer1, buffersize);
1200     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1201     if (operationsize != 2 * chunksize)
1202     {
1203         test_report_failure_strerror();
1204         test_report_failure("Failed to read chunk of data.");
1205         return -1;
1206     }
1207     test_report_progress("Chunk read.");
1208     if (compare_buffers(readdatabuffer1, randomwritebuffer + chunksize, chunksize) != 0)
1209     {
1210         test_report_failure("Read data does not match written for first chunk");
1211         return -1;
1212     }
1213     test_report_success("Read data match written data for first chunk.");
1214     if (compare_buffers(readdatabuffer1 + chunksize, randomwritebuffer, chunksize) != 0)
1215     {
1216         test_report_failure("Read data does not match written for second chunk");
1217         return -1;
1218     }
1219     test_report_success("Read data match written data for second chunk.");
1220     test_report_success("SUCCESS");
1221
1222     /*
1223      * TEST END
1224      */
1225
1226     /*
1227      * TEST
1228      */
1229
1230     next_test_step();
1231
1232     test_report_description("seek to end, write some data , seek backward, read data, check data");
1233
1234     // seek to end, write some data , seek backward, read data, check data
1235     if (fseek(testfilepointer, 0, SEEK_END) != 0)
1236     {
1237         test_report_failure_strerror();
1238         test_report_failure("Failed to seek to end");
1239         return -1;
1240     }
1241     test_report_progress("Seek to end of file made.");
1242     operationsize = fwrite(randomwritebuffer + 2 * chunksize, 1, chunksize, testfilepointer);
1243     if (operationsize != chunksize)
1244     {
1245         test_report_failure_strerror();
1246         test_report_failure("Failed to write chunk of data.");
1247         return -1;
1248     }
1249     test_report_progress("Chunk written.");
1250     if (fseek(testfilepointer, -chunksize, SEEK_CUR) != 0)
1251     {
1252         test_report_failure_strerror();
1253         test_report_failure("Failed to seek backwards");
1254         return -1;
1255     }
1256     test_report_progress("Seek backwards made.");
1257     erase_buffer(readdatabuffer1, buffersize);
1258     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
1259     if (operationsize != chunksize)
1260     {
1261         test_report_failure_strerror();
1262         test_report_failure("Failed to read chunk of data.");
1263         return -1;
1264     }
1265     test_report_progress("Chunk read.");
1266     if (compare_buffers(readdatabuffer1, randomwritebuffer + 2 * chunksize, chunksize) != 0)
1267     {
1268         test_report_failure("Read data does not match written data");
1269         return -1;
1270     }
1271     test_report_success("Read data match written data.");
1272     test_report_success("SUCCESS");
1273
1274     /*
1275      * TEST END
1276      */
1277
1278     /*
1279      * TEST
1280      */
1281
1282     next_test_step();
1283
1284     test_report_description("seek to end, seek foreward, write some data , seek backward, read 2 x data, check data");
1285
1286     // seek to end, seek foreward, write some data , seek backward, read 2 x data, check data
1287     if (fseek(testfilepointer, 0, SEEK_END) != 0)
1288     {
1289         test_report_failure_strerror();
1290         test_report_failure("Failed to seek to end");
1291         return -1;
1292     }
1293     test_report_progress("Seek to end of file made.");
1294     if (fseek(testfilepointer, chunksize, SEEK_CUR) != 0)
1295     {
1296         test_report_failure_strerror();
1297         test_report_failure("Failed to seek foreward");
1298         return -1;
1299     }
1300     test_report_progress("Seek foreward made.");
1301     operationsize = fwrite(randomwritebuffer, 1, chunksize, testfilepointer);
1302     if (operationsize != chunksize)
1303     {
1304         test_report_failure_strerror();
1305         test_report_failure("Failed to write chunk of data.");
1306         return -1;
1307     }
1308     test_report_progress("Chunk written.");
1309     if (fseek(testfilepointer, -2 * chunksize, SEEK_CUR) != 0)
1310     {
1311         test_report_failure_strerror();
1312         test_report_failure("Failed to seek backwards");
1313         return -1;
1314     }
1315     test_report_progress("Seek backwards made.");
1316     erase_buffer(readdatabuffer1, buffersize);
1317     erase_buffer(zerobuffer, buffersize);
1318     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1319     if (operationsize != 2 * chunksize)
1320     {
1321         test_report_failure_strerror();
1322         test_report_failure("Failed to read chunk of data.");
1323         return -1;
1324     }
1325     test_report_progress("Chunk read.");
1326     if (compare_buffers(readdatabuffer1, zerobuffer, chunksize) != 0)
1327     {
1328         test_report_failure("Read data does not match written data for first chunk");
1329         return -1;
1330     }
1331     test_report_success("Read data match written data for first chunk.");
1332     if (compare_buffers(readdatabuffer1 + chunksize, randomwritebuffer, chunksize) != 0)
1333     {
1334         test_report_failure("Read data does not match written data for second chunk");
1335         return -1;
1336     }
1337     test_report_success("Read data match written data for second chunk.");
1338     test_report_success("SUCCESS");
1339
1340     /*
1341      * TEST END
1342      */
1343
1344     /*
1345      * TEST
1346      */
1347
1348     next_test_step();
1349
1350     test_report_description("seek beoynd end, write some data , seek backward, read 2 x data, check data");
1351
1352     // seek beoynd end, write some data , seek backward, read 2 x data, check data
1353     if (fseek(testfilepointer, chunksize, SEEK_END) != 0)
1354     {
1355         test_report_failure_strerror();
1356         test_report_failure("Failed to seek beyond end of file");
1357         return -1;
1358     }
1359     test_report_progress("Seek beyond end of file made.");
1360     operationsize = fwrite(randomwritebuffer + chunksize, 1, chunksize, testfilepointer);
1361     if (operationsize != chunksize)
1362     {
1363         test_report_failure_strerror();
1364         test_report_failure("Failed to write chunk of data.");
1365         return -1;
1366     }
1367     test_report_progress("Chunk written.");
1368     if (fseek(testfilepointer, -2 * chunksize, SEEK_CUR) != 0)
1369     {
1370         test_report_failure_strerror();
1371         test_report_failure("Failed to seek backwards");
1372         return -1;
1373     }
1374     test_report_progress("Seek backwards made.");
1375     erase_buffer(readdatabuffer1, buffersize);
1376     erase_buffer(zerobuffer, buffersize);
1377     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1378     if (operationsize != 2 * chunksize)
1379     {
1380         test_report_failure_strerror();
1381         test_report_failure("Failed to read chunk of data.");
1382         return -1;
1383     }
1384     test_report_progress("Chunk read.");
1385     if (compare_buffers(readdatabuffer1, zerobuffer, chunksize) != 0)
1386     {
1387         test_report_failure("Read data does not match written data for first chunk");
1388         return -1;
1389     }
1390     test_report_success("Read data match written data for first chunk.");
1391     if (compare_buffers(readdatabuffer1 + chunksize, randomwritebuffer + chunksize, chunksize) != 0)
1392     {
1393         test_report_failure("Read data does not match written data for second chunk");
1394         return -1;
1395     }
1396     test_report_success("Read data match written data for second chunk.");
1397     test_report_success("SUCCESS");
1398
1399     /*
1400      * TEST END
1401      */
1402
1403     return 0;
1404 }
1405
1406 int test_fseek_fwrite_fread_wrapper()
1407 {
1408     next_test();
1409
1410     int result = test_fseek_fwrite_fread_preparation();
1411     if (result != 0)
1412     {
1413         report_failure("Preparation failed");
1414     }
1415     else
1416         result = test_fseek_fwrite_fread();
1417
1418     close_test_file();
1419
1420     return result;
1421 }
1422
1423 int test_fseek_fwrite_fread_append_preparation()
1424 {
1425     char readdatabuffer1[1024] = {0};
1426     int i = 0;
1427     size_t operationsize = 0;
1428
1429     report_progress("Starting test_fseek_fwrite_fread_append_preparation");
1430
1431     if (testfilepointer != NULL)
1432     {
1433         report_failure("Pointer for test file not closed.");
1434         return -1;
1435     }
1436
1437     // Initilize random write buffer
1438     srand(1);
1439     for (i = 0; i < buffersize; i++)
1440         writedata[i] = (char)rand();
1441
1442     // open file, write data
1443     testfilepointer = fopen(testfilename, "wb+");
1444     if (testfilepointer == NULL)
1445     {
1446         report_failure_strerror();
1447         report_failure("Failed to open file for writting.");
1448         return -1;
1449     }
1450     operationsize = fwrite(writedata, 1, buffersize, testfilepointer);
1451     if (operationsize != buffersize)
1452     {
1453         report_failure_strerror();
1454         report_failure("Failed to write data.");
1455         return -1;
1456     }
1457
1458     // Seek to beginning
1459     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
1460     {
1461         report_failure_strerror();
1462         report_failure("Failed to seek to file beginning (w+b).");
1463         return -1;
1464     }
1465
1466     //read data, compare data
1467     erase_buffer(readdatabuffer1, buffersize);
1468     operationsize = fread(readdatabuffer1, 1, buffersize, testfilepointer);
1469     if (operationsize != buffersize)
1470     {
1471         report_failure_strerror();
1472         report_failure("Failed to read data.");
1473         return -1;
1474     }
1475     if (compare_buffers(readdatabuffer1, writedata, buffersize) != 0)
1476     {
1477         report_failure("Read data differs from written data");
1478         return -1;
1479     }
1480
1481     // close
1482     if (fclose(testfilepointer) != 0)
1483     {
1484         report_failure_strerror();
1485         report_failure("Failed to close the file.");
1486         return;
1487     }
1488
1489     // open
1490     testfilepointer = fopen(testfilename, "ab+");
1491     if (testfilepointer == NULL)
1492     {
1493         report_failure_strerror();
1494         report_failure("Failed to open file for appending.");
1495         return -1;
1496     }
1497
1498     return 0;
1499
1500 }
1501
1502 int test_fseek_fwrite_fread_append()
1503 {
1504     /* Expects that testfilepointer is opened in correct mode */
1505     char randomwritebuffer[1024] = {0};
1506     size_t chunksize = 128;
1507     char readdatabuffer1[1024] = {0};
1508     char zerobuffer[1024] = {0};
1509     int i = 0;
1510     size_t operationsize = 0;
1511
1512     // Initilize random write buffer
1513     // Don't initialize srand or randomwritebuffer == writedata
1514     for (i = 0; i < buffersize; i++)
1515         randomwritebuffer[i] = (char)rand();
1516
1517     /*
1518      * TEST
1519      */
1520
1521     report_progress("Start test_fseek_fwrite_fread_append");
1522
1523     next_test_step();
1524
1525     test_report_description("seek to begin, write some data , seek to begin, read 2x some data, check data");
1526
1527     // seek to begin, write some data , seek to begin, read 2x some data, check data
1528     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
1529     {
1530         test_report_failure_strerror();
1531         test_report_failure("Failed to seek to beginning of file");
1532         return -1;
1533     }
1534     test_report_progress("Seek to beginning of file.");
1535     operationsize = fwrite(randomwritebuffer, 1, chunksize, testfilepointer);
1536     if (operationsize != chunksize)
1537     {
1538         test_report_failure_strerror();
1539         test_report_failure("Failed to write chunk of data.");
1540         return -1;
1541     }
1542     test_report_progress("Chunk written.");
1543     if (fseek(testfilepointer, 0, SEEK_SET) != 0)
1544     {
1545         test_report_failure_strerror();
1546         test_report_failure("Failed to seek to beginning of file");
1547         return -1;
1548     }
1549     test_report_progress("Seek to beginning of file.");
1550     erase_buffer(readdatabuffer1, buffersize);
1551     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1552     if (operationsize != 2 * chunksize)
1553     {
1554         test_report_failure_strerror();
1555         test_report_failure("Failed to read chunk of data.");
1556         return -1;
1557     }
1558     test_report_progress("Chunk read.");
1559     if (compare_buffers(readdatabuffer1, writedata, chunksize) != 0)
1560     {
1561         test_report_failure("Read data does not match written data for first chunk");
1562         return -1;
1563     }
1564     test_report_success("Read data match written data for first chunk.");
1565     if (compare_buffers(readdatabuffer1 + chunksize, writedata + chunksize, chunksize) != 0)
1566     {
1567         test_report_failure("Read data does not match written data for second chunk");
1568         return -1;
1569     }
1570     test_report_success("Read data match written data for second chunk.");
1571     test_report_success("SUCCESS");
1572
1573     /*
1574      * TEST END
1575      */
1576
1577     /*
1578      * TEST
1579      */
1580
1581     next_test_step();
1582
1583     test_report_description("seek foreward, write some data , seek backward, read data, check data");
1584
1585     // seek foreward, write some data , seek backward, read data, check data
1586     if (fseek(testfilepointer, 3 * chunksize, SEEK_CUR) != 0)
1587     {
1588         test_report_failure_strerror();
1589         test_report_failure("Failed to seek foreward");
1590         return -1;
1591     }
1592     test_report_progress("Seek foreward made.");
1593     operationsize = fwrite(randomwritebuffer, 1, chunksize, testfilepointer);
1594     if (operationsize != chunksize)
1595     {
1596         test_report_failure_strerror();
1597         test_report_failure("Failed to write chunk of data.");
1598         return -1;
1599     }
1600     test_report_progress("Chunk written.");
1601     if (fseek(testfilepointer, - chunksize, SEEK_CUR) != 0)
1602     {
1603         test_report_failure_strerror();
1604         test_report_failure("Failed to seek backwards");
1605         return -1;
1606     }
1607     test_report_progress("Seek backwards made.");
1608     erase_buffer(readdatabuffer1, buffersize);
1609     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
1610     if (operationsize != chunksize)
1611     {
1612         test_report_failure_strerror();
1613         test_report_failure("Failed to read chunk of data.");
1614         return -1;
1615     }
1616     test_report_progress("Chunk read.");
1617     if (compare_buffers(readdatabuffer1, randomwritebuffer, chunksize) != 0)
1618     {
1619         test_report_failure("Read data does not match written");
1620         return -1;
1621     }
1622     test_report_success("Read data match written data.");
1623     test_report_success("SUCCESS");
1624
1625     /*
1626      * TEST END
1627      */
1628
1629     /*
1630      * TEST
1631      */
1632
1633     next_test_step();
1634
1635     test_report_description("seek backward, write some data , seek backward, read 2 x data, check error");
1636
1637     // seek backward, write some data , seek backward, read 2 x data, check error
1638     if (fseek(testfilepointer, -2 * chunksize, SEEK_CUR) != 0)
1639     {
1640         test_report_failure_strerror();
1641         test_report_failure("Failed to seek backwards");
1642         return -1;
1643     }
1644     test_report_progress("Seek backwards made.");
1645     operationsize = fwrite(randomwritebuffer + chunksize, 1, chunksize, testfilepointer);
1646     if (operationsize != chunksize)
1647     {
1648         test_report_failure_strerror();
1649         test_report_failure("Failed to write chunk of data.");
1650         return -1;
1651     }
1652     test_report_progress("Chunk written.");
1653     if (fseek(testfilepointer, -chunksize, SEEK_CUR) != 0)
1654     {
1655         test_report_failure_strerror();
1656         test_report_failure("Failed to seek backwards");
1657         return -1;
1658     }
1659     test_report_progress("Seek backwards made.");
1660     erase_buffer(readdatabuffer1, buffersize);
1661     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1662     if (operationsize != 2 * chunksize)
1663     {
1664         if (errno != EINVAL)
1665         {
1666             test_report_failure_strerror();
1667             test_report_failure("Different than expected error reported.");
1668             return -1;
1669         }
1670     }
1671     else
1672     {
1673         test_report_failure("Expected error");
1674         return -1;
1675     }
1676     test_report_success("Error reported.");
1677     test_report_success("SUCCESS");
1678
1679     /*
1680      * TEST END
1681      */
1682
1683     /*
1684      * TEST
1685      */
1686
1687     next_test_step();
1688
1689     test_report_description("seek to end, write some data , seek backward, read data, check data");
1690
1691     // seek to end, write some data , seek backward, read data, check data
1692     if (fseek(testfilepointer, 0, SEEK_END) != 0)
1693     {
1694         test_report_failure_strerror();
1695         test_report_failure("Failed to seek to end");
1696         return -1;
1697     }
1698     test_report_progress("Seek to end of file made.");
1699     operationsize = fwrite(randomwritebuffer + 2 * chunksize, 1, chunksize, testfilepointer);
1700     if (operationsize != chunksize)
1701     {
1702         test_report_failure_strerror();
1703         test_report_failure("Failed to write chunk of data.");
1704         return -1;
1705     }
1706     test_report_progress("Chunk written.");
1707     if (fseek(testfilepointer, -chunksize, SEEK_CUR) != 0)
1708     {
1709         test_report_failure_strerror();
1710         test_report_failure("Failed to seek backwards");
1711         return -1;
1712     }
1713     test_report_progress("Seek backwards made.");
1714     erase_buffer(readdatabuffer1, buffersize);
1715     operationsize = fread(readdatabuffer1, 1, chunksize, testfilepointer);
1716     if (operationsize != chunksize)
1717     {
1718         test_report_failure_strerror();
1719         test_report_failure("Failed to read chunk of data.");
1720         return -1;
1721     }
1722     test_report_progress("Chunk read.");
1723     if (compare_buffers(readdatabuffer1, randomwritebuffer + 2 * chunksize, chunksize) != 0)
1724     {
1725         test_report_failure("Read data does not match written data");
1726         return -1;
1727     }
1728     test_report_success("Read data match written data.");
1729     test_report_success("SUCCESS");
1730
1731     /*
1732      * TEST END
1733      */
1734
1735     /*
1736      * TEST
1737      */
1738
1739     next_test_step();
1740
1741     test_report_description("seek to end, seek foreward, write some data , seek backward, read 2 x data, check data");
1742
1743     // seek to end, seek foreward, write some data , seek backward, read 2 x data, check data
1744     if (fseek(testfilepointer, 0, SEEK_END) != 0)
1745     {
1746         test_report_failure_strerror();
1747         test_report_failure("Failed to seek to end");
1748         return -1;
1749     }
1750     test_report_progress("Seek to end of file made.");
1751     if (fseek(testfilepointer, chunksize, SEEK_CUR) != 0)
1752     {
1753         test_report_failure_strerror();
1754         test_report_failure("Failed to seek foreward");
1755         return -1;
1756     }
1757     test_report_progress("Seek foreward made.");
1758     operationsize = fwrite(randomwritebuffer + 3 * chunksize, 1, chunksize, testfilepointer);
1759     if (operationsize != chunksize)
1760     {
1761         test_report_failure_strerror();
1762         test_report_failure("Failed to write chunk of data.");
1763         return -1;
1764     }
1765     test_report_progress("Chunk written.");
1766     if (fseek(testfilepointer, -2 * chunksize, SEEK_CUR) != 0)
1767     {
1768         test_report_failure_strerror();
1769         test_report_failure("Failed to seek backwards");
1770         return -1;
1771     }
1772     test_report_progress("Seek backwards made.");
1773     erase_buffer(readdatabuffer1, buffersize);
1774     erase_buffer(zerobuffer, buffersize);
1775     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1776     if (operationsize != 2 * chunksize)
1777     {
1778         test_report_failure_strerror();
1779         test_report_failure("Failed to read chunk of data.");
1780         return -1;
1781     }
1782     test_report_progress("Chunk read.");
1783     if (compare_buffers(readdatabuffer1, randomwritebuffer + 2 * chunksize, chunksize) != 0)
1784     {
1785         test_report_failure("Read data does not match written data for first chunk");
1786         return -1;
1787     }
1788     test_report_success("Read data match written data for first chunk.");
1789     if (compare_buffers(readdatabuffer1 + chunksize, randomwritebuffer + 3 * chunksize, chunksize) != 0)
1790     {
1791         test_report_failure("Read data does not match written data for second chunk");
1792         return -1;
1793     }
1794     test_report_success("Read data match written data for second chunk.");
1795     test_report_success("SUCCESS");
1796
1797     /*
1798      * TEST END
1799      */
1800
1801     /*
1802      * TEST
1803      */
1804
1805     next_test_step();
1806
1807     test_report_description("seek beyond end, write some data , seek backward, read 2 x data, check data");
1808
1809     // seek beoynd end, write some data , seek backward, read 2 x data, check data
1810     if (fseek(testfilepointer, chunksize, SEEK_END) != 0)
1811     {
1812         test_report_failure_strerror();
1813         test_report_failure("Failed to seek beyond end of file");
1814         return -1;
1815     }
1816     test_report_progress("Seek beyond end of file made.");
1817     operationsize = fwrite(randomwritebuffer + chunksize, 1, chunksize, testfilepointer);
1818     if (operationsize != chunksize)
1819     {
1820         test_report_failure_strerror();
1821         test_report_failure("Failed to write chunk of data.");
1822         return -1;
1823     }
1824     test_report_progress("Chunk written.");
1825     if (fseek(testfilepointer, -2 * chunksize, SEEK_CUR) != 0)
1826     {
1827         test_report_failure_strerror();
1828         test_report_failure("Failed to seek backwards");
1829         return -1;
1830     }
1831     test_report_progress("Seek backwards made.");
1832     erase_buffer(readdatabuffer1, buffersize);
1833     erase_buffer(zerobuffer, buffersize);
1834     operationsize = fread(readdatabuffer1, 1, 2 * chunksize, testfilepointer);
1835     if (operationsize != 2 * chunksize)
1836     {
1837         test_report_failure_strerror();
1838         test_report_failure("Failed to read chunk of data.");
1839         return -1;
1840     }
1841     test_report_progress("Chunk read.");
1842     if (compare_buffers(readdatabuffer1, randomwritebuffer + 3 * chunksize, chunksize) != 0)
1843     {
1844         test_report_failure("Read data does not match written data for first chunk");
1845         return -1;
1846     }
1847     test_report_success("Read data match written data for first chunk.");
1848     if (compare_buffers(readdatabuffer1 + chunksize, randomwritebuffer + chunksize, chunksize) != 0)
1849     {
1850         test_report_failure("Read data does not match written data for second chunk");
1851         return -1;
1852     }
1853     test_report_success("Read data match written data for second chunk.");
1854     test_report_success("SUCCESS");
1855
1856     /*
1857      * TEST END
1858      */
1859
1860     return 0;
1861 }
1862
1863 int test_fseek_fwrite_fread_append_wrapper()
1864 {
1865     next_test();
1866
1867     int result = test_fseek_fwrite_fread_append_preparation();
1868     if (result != 0)
1869     {
1870         report_failure("Preparation failed");
1871     }
1872     else
1873         result = test_fseek_fwrite_fread_append();
1874
1875     close_test_file();
1876
1877     return result;
1878 }
1879
1880 int main()
1881 {
1882     report_progress("Starting tests");
1883
1884     reset_global_test_counter();
1885
1886     // seek/tell
1887     if (test_fseek_ftell_wrapper("wb") != 0)
1888         global_failure_indicator = 1;
1889     if (test_fseek_ftell_wrapper("w+b") != 0)
1890         global_failure_indicator = 1;
1891
1892     // seek/read test
1893     // no tested:
1894     // wb - can only write
1895     // ab - can only append
1896     if (test_fseek_and_fread_wrapper("rb") != 0)
1897         global_failure_indicator = 1;
1898
1899     if (test_fseek_and_fread_wrapper("r+b") != 0)
1900         global_failure_indicator = 1;
1901
1902     if (test_fseek_and_fread_wrapper("a+b") != 0)
1903         global_failure_indicator = 1;
1904
1905     if (test_fseek_and_fread_wrapper("w+b") != 0)
1906         global_failure_indicator = 1;
1907
1908     // seek/write/read
1909     if (test_fseek_fwrite_fread_wrapper() != 0)
1910         global_failure_indicator = 1;
1911
1912     // seek/write/read (append)
1913     if (test_fseek_fwrite_fread_append_wrapper() != 0)
1914         global_failure_indicator = 1;
1915
1916     if (global_failure_indicator == 1)
1917         report_failure("One of the tests FAILED");
1918     else
1919         report_progress("All tests SUCCEEDED");
1920
1921     report_progress("Tests finished");
1922 }