test/clib/access_test.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <errno.h>
   4 #include <unistd.h>
   5
   6 #define SHOW_PROGRESS 0
   7
   8 // Global variables
   9 int global_test_counter = 0;
  10 int global_test_step_counter = 0;
  11 int global_failure_indicator = 0;
  12
  13 /* 2008-03-22 - All test pass (if manual configuration is done correclty) */
  14
  15 /* COMPILE WITH '-nix' for unix2amiga path conversion */
  16
  17 /* These values are arbitrary and influence test results! */
  18 /* Existing objects should have RWED permitions (even the volume!) */
  19
  20 #if defined __AROS__
  21 const char * existing_volume = "/Work/";
  22 const char * existing_directory = "/SYS/Classes";
  23 const char * existing_file = "/SYS/Classes/Datatypes/bmp.datatype";
  24 const char * non_existing_volume = "/sw243";
  25 const char * non_existing_directory = "/SYS/sdgfer";
  26 const char * non_existing_file = "/SYS/Classes/ggg.txt";
  27 #else
  28 const char * existing_volume = "/usr";
  29 const char * existing_directory = "/usr/bin";
  30 const char * existing_file = "/usr/bin/gcc";
  31 const char * non_existing_volume = "/sw243";
  32 const char * non_existing_directory = "/usr/sdgfer";
  33 const char * non_existing_file = "/usr/lib/ggg.txt";
  34 #endif
  35
  36 /* These files need to be prepared in application directory with appriopriate access rights! */
  37 const char * read_only_file = "read_only_file";
  38 const char * write_only_file = "write_only_file";
  39 const char * execute_only_file = "execute_only_file";
  40 const char * all_access_file = "all_access_file";
  41
  42 void reset_global_test_counter()
  43 {
  44     global_test_counter = 0;
  45     global_test_step_counter = 0;
  46 }
  47
  48 void next_test()
  49 {
  50     global_test_counter++;
  51     global_test_step_counter = 0;
  52 }
  53
  54 void next_test_step()
  55 {
  56     global_test_step_counter++;
  57 }
  58
  59 // Reporting functions
  60 void report(const char * status, const char * message)
  61 {
  62     printf("REPORT : %s : %s \n", status, message);
  63 }
  64
  65 void report_progress(const char * message)
  66 {
  67     report("PROGRESS", message);
  68 }
  69
  70 void report_failure(const char * message)
  71 {
  72     report("FAILED", message);
  73 }
  74
  75 void report_failure_strerror()
  76 {
  77     report_failure((const char*)strerror(errno));
  78 }
  79
  80 void test_report(const char * status, const char * message)
  81 {
  82     printf("TEST %d-%d : %s : %s \n", global_test_counter , global_test_step_counter, status, message);
  83 }
  84
  85 void test_report_progress(const char * message)
  86 {
  87 #if SHOW_PROGRESS == 1
  88     test_report("PROGRESS", message);
  89 #endif
  90 }
  91
  92 void test_report_failure(const char * message)
  93 {
  94     test_report("FAILED", message);
  95 }
  96
  97 void test_report_success(const char * message)
  98 {
  99     test_report("OK", message);
 100 }
 101
 102 void test_report_description(const char * message)
 103 {
 104     test_report("TEST DESCRIPTION", message);
 105 }
 106
 107 void test_report_failure_strerror()
 108 {
 109     test_report_failure((const char*)strerror(errno));
 110 }
 111
 112 // Test
 113 int test_access_preparation()
 114 {
 115 }
 116
 117 int test_access(int mode)
 118 {
 119     report_progress("Start test_access");
 120     if (mode & R_OK)
 121         report_progress("R_OK");
 122     if (mode & W_OK)
 123         report_progress("W_OK");
 124     if (mode & X_OK)
 125         report_progress("X_OK");
 126     if (mode == 0)
 127         report_progress("F_OK");
 128
 129
 130    /*
 131      * TEST
 132      */
 133
 134     next_test_step();
 135
 136     test_report_description("access existing volume");
 137
 138     // access existing volume
 139     if (access(existing_volume, mode) != 0)
 140     {
 141         test_report_failure_strerror();
 142         test_report_failure("Failed accessing existing volume");
 143         return -1;
 144     }
 145     test_report_success("Accessed existing volume");
 146     test_report_success("SUCCESS");
 147
 148     /*
 149      * TEST END
 150      */
 151
 152    /*
 153      * TEST
 154      */
 155
 156     next_test_step();
 157
 158     test_report_description("access existing directory");
 159
 160     // access existing directory
 161     if (access(existing_directory, mode) != 0)
 162     {
 163         test_report_failure_strerror();
 164         test_report_failure("Failed accessing existing directory");
 165         return -1;
 166     }
 167     test_report_success("Accessed existing directory");
 168     test_report_success("SUCCESS");
 169
 170     /*
 171      * TEST END
 172      */
 173
 174    /*
 175      * TEST
 176      */
 177
 178     next_test_step();
 179
 180     test_report_description("access existing file");
 181
 182     // access existing file
 183     if (access(existing_file, mode) != 0)
 184     {
 185         test_report_failure_strerror();
 186         test_report_failure("Failed accessing existing file");
 187         return -1;
 188     }
 189     test_report_success("Accessed existing file");
 190     test_report_success("SUCCESS");
 191
 192     /*
 193      * TEST END
 194      */
 195
 196    /*
 197      * TEST
 198      */
 199
 200     next_test_step();
 201
 202     test_report_description("access non existing volume");
 203
 204     // access non existing volume
 205     if (access(non_existing_volume, mode) == 0)
 206     {
 207         test_report_failure("This call should fail");
 208         return -1;
 209     }
 210     else
 211     {
 212         if (errno != ENOENT)
 213         {
 214             test_report_failure_strerror();
 215             test_report_failure("Different error expected");
 216             return -1;
 217         }
 218     }
 219     test_report_success("Correct error reported");
 220     test_report_success("SUCCESS");
 221
 222     /*
 223      * TEST END
 224      */
 225
 226    /*
 227      * TEST
 228      */
 229
 230     next_test_step();
 231
 232     test_report_description("access non existing directory");
 233
 234     // access non existing directory
 235     if (access(non_existing_directory, mode) == 0)
 236     {
 237         test_report_failure("This call should fail");
 238         return -1;
 239     }
 240     else
 241     {
 242         if (errno != ENOENT)
 243         {
 244             test_report_failure_strerror();
 245             test_report_failure("Different error expected");
 246             return -1;
 247         }
 248     }
 249     test_report_success("Correct error reported");
 250     test_report_success("SUCCESS");
 251
 252     /*
 253      * TEST END
 254      */
 255
 256    /*
 257      * TEST
 258      */
 259
 260     next_test_step();
 261
 262     test_report_description("access non existing file");
 263
 264     // access non existing file
 265     if (access(non_existing_file, mode) == 0)
 266     {
 267         test_report_failure("This call should fail");
 268         return -1;
 269     }
 270     else
 271     {
 272         if (errno != ENOENT)
 273         {
 274             test_report_failure_strerror();
 275             test_report_failure("Different error expected");
 276             return -1;
 277         }
 278     }
 279     test_report_success("Correct error reported");
 280     test_report_success("SUCCESS");
 281
 282     /*
 283      * TEST END
 284      */
 285
 286     return 0;
 287 }
 288
 289 int test_access_wrapper(int mode)
 290 {
 291     next_test();
 292     return test_access(mode);
 293 }
 294
 295 int test_single_file_access_modes()
 296 {
 297     next_test();
 298
 299     /* Manual action required for test. See top of file */
 300
 301     report_progress("Start test_file_access_modes");
 302
 303    /*
 304      * TEST
 305      */
 306
 307     next_test_step();
 308
 309     test_report_description("access F_OK for read_only_file");
 310
 311     // access F_OK for read_only_file
 312     if (access(read_only_file, F_OK) != 0)
 313     {
 314         test_report_failure_strerror();
 315         test_report_failure("Failed accessing file");
 316         return -1;
 317     }
 318     test_report_success("File accessed");
 319     test_report_success("SUCCESS");
 320
 321     /*
 322      * TEST END
 323      */
 324
 325    /*
 326      * TEST
 327      */
 328
 329     next_test_step();
 330
 331     test_report_description("access F_OK for write_only_file");
 332
 333     // access F_OK for write_only_file
 334     if (access(write_only_file, F_OK) != 0)
 335     {
 336         test_report_failure_strerror();
 337         test_report_failure("Failed accessing file");
 338         return -1;
 339     }
 340     test_report_success("File accessed");
 341     test_report_success("SUCCESS");
 342
 343     /*
 344      * TEST END
 345      */
 346
 347    /*
 348      * TEST
 349      */
 350
 351     next_test_step();
 352
 353     test_report_description("access F_OK for execute_only_file");
 354
 355     // access F_OK for execute_only_file
 356     if (access(execute_only_file, F_OK) != 0)
 357     {
 358         test_report_failure_strerror();
 359         test_report_failure("Failed accessing file");
 360         return -1;
 361     }
 362     test_report_success("File accessed");
 363     test_report_success("SUCCESS");
 364
 365     /*
 366      * TEST END
 367      */
 368
 369    /*
 370      * TEST
 371      */
 372
 373     next_test_step();
 374
 375     test_report_description("access R_OK for read_only_file");
 376
 377     // access R_OK for read_only_file
 378     if (access(read_only_file, R_OK) != 0)
 379     {
 380         test_report_failure_strerror();
 381         test_report_failure("Failed accessing file");
 382         return -1;
 383     }
 384     test_report_success("File accessed");
 385     test_report_success("SUCCESS");
 386
 387     /*
 388      * TEST END
 389      */
 390
 391    /*
 392      * TEST
 393      */
 394
 395     next_test_step();
 396
 397     test_report_description("access R_OK | W_OK for read_only_file");
 398
 399     // access R_OK | W_OK for read_only_file
 400     if (access(read_only_file, R_OK | W_OK) != 0)
 401     {
 402         if (errno != EACCES)
 403         {
 404             test_report_failure_strerror();
 405             test_report_failure("Different error expected");
 406             return -1;
 407         }
 408     }
 409     else
 410     {
 411         test_report_failure("This operation should fail");
 412         return -1;
 413     }
 414     test_report_success("Correct error reported");
 415     test_report_success("SUCCESS");
 416
 417     /*
 418      * TEST END
 419      */
 420
 421    /*
 422      * TEST
 423      */
 424
 425     next_test_step();
 426
 427     test_report_description("access R_OK | X_OK for read_only_file");
 428
 429     // access R_OK | X_OK for read_only_file
 430     if (access(read_only_file, R_OK | X_OK) != 0)
 431     {
 432         if (errno != EACCES)
 433         {
 434             test_report_failure_strerror();
 435             test_report_failure("Different error expected");
 436             return -1;
 437         }
 438     }
 439     else
 440     {
 441         test_report_failure("This operation should fail");
 442         return -1;
 443     }
 444     test_report_success("Correct error reported");
 445     test_report_success("SUCCESS");
 446
 447     /*
 448      * TEST END
 449      */
 450
 451    /*
 452      * TEST
 453      */
 454
 455     next_test_step();
 456
 457     test_report_description("access W_OK for write_only_file");
 458
 459     // access W_OK for write_only_file
 460     if (access(write_only_file, W_OK) != 0)
 461     {
 462         test_report_failure_strerror();
 463         test_report_failure("Failed accessing file");
 464         return -1;
 465     }
 466     test_report_success("File accessed");
 467     test_report_success("SUCCESS");
 468
 469     /*
 470      * TEST END
 471      */
 472
 473    /*
 474      * TEST
 475      */
 476
 477     next_test_step();
 478
 479     test_report_description("access W_OK | R_OK for write_only_file");
 480
 481     // access W_OK | R_OK for write_only_file
 482     if (access(write_only_file, W_OK | R_OK) != 0)
 483     {
 484         if (errno != EACCES)
 485         {
 486             test_report_failure_strerror();
 487             test_report_failure("Different error expected");
 488             return -1;
 489         }
 490     }
 491     else
 492     {
 493         test_report_failure("This operation should fail");
 494         return -1;
 495     }
 496     test_report_success("Correct error reported");
 497     test_report_success("SUCCESS");
 498
 499     /*
 500      * TEST END
 501      */
 502
 503    /*
 504      * TEST
 505      */
 506
 507     next_test_step();
 508
 509     test_report_description("access W_OK | X_OK for write_only_file");
 510
 511     // access W_OK | X_OK for write_only_file
 512     if (access(write_only_file, W_OK | X_OK) != 0)
 513     {
 514         if (errno != EACCES)
 515         {
 516             test_report_failure_strerror();
 517             test_report_failure("Different error expected");
 518             return -1;
 519         }
 520     }
 521     else
 522     {
 523         test_report_failure("This operation should fail");
 524         return -1;
 525     }
 526     test_report_success("Correct error reported");
 527     test_report_success("SUCCESS");
 528
 529     /*
 530      * TEST END
 531      */
 532
 533
 534    /*
 535      * TEST
 536      */
 537
 538     next_test_step();
 539
 540     test_report_description("access X_OK for execute_only_file");
 541
 542     // access X_OK for execute_only_file
 543     if (access(execute_only_file, X_OK) != 0)
 544     {
 545         test_report_failure_strerror();
 546         test_report_failure("Failed accessing file");
 547         return -1;
 548     }
 549     test_report_success("File accessed");
 550     test_report_success("SUCCESS");
 551
 552     /*
 553      * TEST END
 554      */
 555
 556    /*
 557      * TEST
 558      */
 559
 560     next_test_step();
 561
 562     test_report_description("access X_OK | R_OK for execute_only_file");
 563
 564     // access X_OK | R_OK for execute_only_file
 565     if (access(execute_only_file, X_OK | R_OK) != 0)
 566     {
 567         if (errno != EACCES)
 568         {
 569             test_report_failure_strerror();
 570             test_report_failure("Different error expected");
 571             return -1;
 572         }
 573     }
 574     else
 575     {
 576         test_report_failure("This operation should fail");
 577         return -1;
 578     }
 579     test_report_success("Correct error reported");
 580     test_report_success("SUCCESS");
 581
 582     /*
 583      * TEST END
 584      */
 585
 586    /*
 587      * TEST
 588      */
 589
 590     next_test_step();
 591
 592     test_report_description("access X_OK | W_OK for execute_only_file");
 593
 594     // access X_OK | W_OK for execute_only_file
 595     if (access(execute_only_file, X_OK | W_OK) != 0)
 596     {
 597         if (errno != EACCES)
 598         {
 599             test_report_failure_strerror();
 600             test_report_failure("Different error expected");
 601             return -1;
 602         }
 603     }
 604     else
 605     {
 606         test_report_failure("This operation should fail");
 607         return -1;
 608     }
 609     test_report_success("Correct error reported");
 610     test_report_success("SUCCESS");
 611
 612     /*
 613      * TEST END
 614      */
 615
 616     return 0;
 617 }
 618
 619 int test_combined_file_access_modes()
 620 {
 621     next_test();
 622
 623     /* Manual action required for test. See top of file */
 624
 625     report_progress("Start test_combined_file_access_modes");
 626
 627
 628    /*
 629      * TEST
 630      */
 631
 632     next_test_step();
 633
 634     test_report_description("access R_OK | W_OK for all_access_file");
 635
 636     // access R_OK | W_OK for all_access_file
 637     if (access(all_access_file, R_OK | W_OK) != 0)
 638     {
 639         test_report_failure_strerror();
 640         test_report_failure("Failed accessing file");
 641         return -1;
 642     }
 643     test_report_success("File accessed");
 644     test_report_success("SUCCESS");
 645
 646     /*
 647      * TEST END
 648      */
 649
 650    /*
 651      * TEST
 652      */
 653
 654     next_test_step();
 655
 656     test_report_description("access R_OK | X_OK for all_access_file");
 657
 658     // access R_OK | X_OK for all_access_file
 659     if (access(all_access_file, R_OK | X_OK) != 0)
 660     {
 661         test_report_failure_strerror();
 662         test_report_failure("Failed accessing file");
 663         return -1;
 664     }
 665     test_report_success("File accessed");
 666     test_report_success("SUCCESS");
 667
 668     /*
 669      * TEST END
 670      */
 671
 672    /*
 673      * TEST
 674      */
 675
 676     next_test_step();
 677
 678     test_report_description("access W_OK | X_OK for all_access_file");
 679
 680     // access W_OK | X_OK for all_access_file
 681     if (access(all_access_file, W_OK | X_OK) != 0)
 682     {
 683         test_report_failure_strerror();
 684         test_report_failure("Failed accessing file");
 685         return -1;
 686     }
 687     test_report_success("File accessed");
 688     test_report_success("SUCCESS");
 689
 690     /*
 691      * TEST END
 692      */
 693
 694    /*
 695      * TEST
 696      */
 697
 698     next_test_step();
 699
 700     test_report_description("access R_OK | W_OK | X_OK for all_access_file");
 701
 702     // access R_OK | W_OK | X_OK for all_access_file
 703     if (access(all_access_file, R_OK | W_OK | X_OK) != 0)
 704     {
 705         test_report_failure_strerror();
 706         test_report_failure("Failed accessing file");
 707         return -1;
 708     }
 709     test_report_success("File accessed");
 710     test_report_success("SUCCESS");
 711
 712     /*
 713      * TEST END
 714      */
 715
 716    /*
 717      * TEST
 718      */
 719
 720     next_test_step();
 721
 722     test_report_description("access R_OK | W_OK | X_OK | F_OK for all_access_file");
 723
 724     // access R_OK | W_OK | X_OK | F_OK for all_access_file
 725     if (access(all_access_file, R_OK | W_OK | X_OK | F_OK) != 0)
 726     {
 727         test_report_failure_strerror();
 728         test_report_failure("Failed accessing file");
 729         return -1;
 730     }
 731     test_report_success("File accessed");
 732     test_report_success("SUCCESS");
 733
 734     /*
 735      * TEST END
 736      */
 737
 738     return 0;
 739 }
 740 int main()
 741 {
 742     report_progress("Starting tests");
 743
 744     reset_global_test_counter();
 745
 746     // access test
 747     if (test_access_wrapper(F_OK) != 0)
 748         global_failure_indicator = 1;
 749
 750     if (test_access_wrapper(R_OK) != 0)
 751         global_failure_indicator = 1;
 752
 753     if (test_access_wrapper(W_OK) != 0)
 754         global_failure_indicator = 1;
 755
 756     if (test_access_wrapper(X_OK) != 0)
 757         global_failure_indicator = 1;
 758
 759     if (test_access_wrapper(R_OK | W_OK | X_OK) != 0)
 760         global_failure_indicator = 1;
 761
 762     if (test_single_file_access_modes() != 0)
 763         global_failure_indicator = 1;
 764
 765     if (test_combined_file_access_modes() != 0)
 766         global_failure_indicator = 1;
 767
 768     if (global_failure_indicator == 1)
 769         report_failure("One of the tests FAILED");
 770     else
 771         report_progress("All tests SUCCEEDED");
 772
 773     report_progress("Tests finished");
 774 }