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