www.aleph1.co.uk Git - yaffs-website/blob - vendor/mikey179/vfsStream/src/test/php/org/bovigo/vfs/vfsStreamAbstractContentTestCase.php

   1 <?php
   2 /**
   3  * This file is part of vfsStream.
   4  *
   5  * For the full copyright and license information, please view the LICENSE
   6  * file that was distributed with this source code.
   7  *
   8  * @package  org\bovigo\vfs
   9  */
  10 namespace org\bovigo\vfs;
  11 /**
  12  * Helper class for the test.
  13  */
  14 class TestvfsStreamAbstractContent extends vfsStreamAbstractContent
  15 {
  16     /**
  17      * returns default permissions for concrete implementation
  18      *
  19      * @return  int
  20      * @since   0.8.0
  21      */
  22     protected function getDefaultPermissions()
  23     {
  24         return 0777;
  25     }
  26
  27     /**
  28      * returns size of content
  29      *
  30      * @return  int
  31      */
  32     public function size()
  33     {
  34         return 0;
  35     }
  36 }
  37 /**
  38  * Test for org\bovigo\vfs\vfsStreamAbstractContent.
  39  */
  40 class vfsStreamAbstractContentTestCase extends \PHPUnit_Framework_TestCase
  41 {
  42     /**
  43      * @test
  44      * @group  permissions
  45      * @group  bug_15
  46      */
  47     public function noPermissionsForEveryone()
  48     {
  49         $abstractContent = new TestvfsStreamAbstractContent('foo', 0000);
  50         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
  51                                                         vfsStream::getCurrentGroup()
  52                                              )
  53                );
  54         $this->assertFalse($abstractContent->isReadable(-1,
  55                                                         vfsStream::getCurrentGroup()
  56                                              )
  57                );
  58         $this->assertFalse($abstractContent->isReadable(-1,
  59                                                         -1
  60                                              )
  61                );
  62         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
  63                                                         vfsStream::getCurrentGroup()
  64                                              )
  65                );
  66         $this->assertFalse($abstractContent->isWritable(-1,
  67                                                         vfsStream::getCurrentGroup()
  68                                              )
  69                );
  70         $this->assertFalse($abstractContent->isWritable(-1,
  71                                                         -1
  72                                              )
  73                );
  74         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
  75                                                         vfsStream::getCurrentGroup()
  76                                              )
  77                );
  78         $this->assertFalse($abstractContent->isExecutable(-1,
  79                                                           vfsStream::getCurrentGroup()
  80                                              )
  81                );
  82         $this->assertFalse($abstractContent->isExecutable(-1,
  83                                                           -1
  84                                              )
  85                );
  86     }
  87
  88     /**
  89      * @test
  90      * @group  permissions
  91      * @group  bug_15
  92      */
  93     public function executePermissionsForUser()
  94     {
  95         $abstractContent = new TestvfsStreamAbstractContent('foo', 0100);
  96         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
  97                                                         vfsStream::getCurrentGroup()
  98                                              )
  99                );
 100         $this->assertFalse($abstractContent->isReadable(-1,
 101                                                         vfsStream::getCurrentGroup()
 102                                              )
 103                );
 104         $this->assertFalse($abstractContent->isReadable(-1,
 105                                                         -1
 106                                              )
 107                );
 108         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 109                                                         vfsStream::getCurrentGroup()
 110                                              )
 111                );
 112         $this->assertFalse($abstractContent->isWritable(-1,
 113                                                         vfsStream::getCurrentGroup()
 114                                              )
 115                );
 116         $this->assertFalse($abstractContent->isWritable(-1,
 117                                                         -1
 118                                              )
 119                );
 120         $this->assertTrue($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 121                                                          vfsStream::getCurrentGroup()
 122                                             )
 123                );
 124         $this->assertFalse($abstractContent->isExecutable(-1,
 125                                                           vfsStream::getCurrentGroup()
 126                                              )
 127                );
 128         $this->assertFalse($abstractContent->isExecutable(-1,
 129                                                           -1
 130                                              )
 131                );
 132     }
 133
 134     /**
 135      * @test
 136      * @group  permissions
 137      * @group  bug_15
 138      */
 139     public function executePermissionsForGroup()
 140     {
 141         $abstractContent = new TestvfsStreamAbstractContent('foo', 0010);
 142         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 143                                                         vfsStream::getCurrentGroup()
 144                                              )
 145                );
 146         $this->assertFalse($abstractContent->isReadable(-1,
 147                                                         vfsStream::getCurrentGroup()
 148                                              )
 149                );
 150         $this->assertFalse($abstractContent->isReadable(-1,
 151                                                         -1
 152                                              )
 153                );
 154         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 155                                                         vfsStream::getCurrentGroup()
 156                                              )
 157                );
 158         $this->assertFalse($abstractContent->isWritable(-1,
 159                                                         vfsStream::getCurrentGroup()
 160                                              )
 161                );
 162         $this->assertFalse($abstractContent->isWritable(-1,
 163                                                         -1
 164                                              )
 165                );
 166         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 167                                                           vfsStream::getCurrentGroup()
 168                                              )
 169                );
 170         $this->assertTrue($abstractContent->isExecutable(-1,
 171                                                          vfsStream::getCurrentGroup()
 172                                             )
 173                );
 174         $this->assertFalse($abstractContent->isExecutable(-1,
 175                                                           -1
 176                                              )
 177                );
 178     }
 179
 180     /**
 181      * @test
 182      * @group  permissions
 183      * @group  bug_15
 184      */
 185     public function executePermissionsForOther()
 186     {
 187         $abstractContent = new TestvfsStreamAbstractContent('foo', 0001);
 188         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 189                                                         vfsStream::getCurrentGroup()
 190                                              )
 191                );
 192         $this->assertFalse($abstractContent->isReadable(-1,
 193                                                         vfsStream::getCurrentGroup()
 194                                              )
 195                );
 196         $this->assertFalse($abstractContent->isReadable(-1,
 197                                                         -1
 198                                              )
 199                );
 200         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 201                                                         vfsStream::getCurrentGroup()
 202                                              )
 203                );
 204         $this->assertFalse($abstractContent->isWritable(-1,
 205                                                         vfsStream::getCurrentGroup()
 206                                              )
 207                );
 208         $this->assertFalse($abstractContent->isWritable(-1,
 209                                                         -1
 210                                              )
 211                );
 212         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 213                                                           vfsStream::getCurrentGroup()
 214                                              )
 215                );
 216         $this->assertFalse($abstractContent->isExecutable(-1,
 217                                                           vfsStream::getCurrentGroup()
 218                                              )
 219                );
 220         $this->assertTrue($abstractContent->isExecutable(-1,
 221                                                          -1
 222                                             )
 223                );
 224     }
 225
 226     /**
 227      * @test
 228      * @group  permissions
 229      * @group  bug_15
 230      */
 231     public function writePermissionsForUser()
 232     {
 233         $abstractContent = new TestvfsStreamAbstractContent('foo', 0200);
 234         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 235                                                         vfsStream::getCurrentGroup()
 236                                              )
 237                );
 238         $this->assertFalse($abstractContent->isReadable(-1,
 239                                                         vfsStream::getCurrentGroup()
 240                                              )
 241                );
 242         $this->assertFalse($abstractContent->isReadable(-1,
 243                                                         -1
 244                                              )
 245                );
 246         $this->assertTrue($abstractContent->isWritable(vfsStream::getCurrentUser(),
 247                                                        vfsStream::getCurrentGroup()
 248                                             )
 249                );
 250         $this->assertFalse($abstractContent->isWritable(-1,
 251                                                         vfsStream::getCurrentGroup()
 252                                              )
 253                );
 254         $this->assertFalse($abstractContent->isWritable(-1,
 255                                                         -1
 256                                              )
 257                );
 258         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 259                                                           vfsStream::getCurrentGroup()
 260                                              )
 261                );
 262         $this->assertFalse($abstractContent->isExecutable(-1,
 263                                                           vfsStream::getCurrentGroup()
 264                                              )
 265                );
 266         $this->assertFalse($abstractContent->isExecutable(-1,
 267                                                           -1
 268                                              )
 269                );
 270     }
 271
 272     /**
 273      * @test
 274      * @group  permissions
 275      * @group  bug_15
 276      */
 277     public function writePermissionsForGroup()
 278     {
 279         $abstractContent = new TestvfsStreamAbstractContent('foo', 0020);
 280         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 281                                                         vfsStream::getCurrentGroup()
 282                                              )
 283                );
 284         $this->assertFalse($abstractContent->isReadable(-1,
 285                                                         vfsStream::getCurrentGroup()
 286                                              )
 287                );
 288         $this->assertFalse($abstractContent->isReadable(-1,
 289                                                         -1
 290                                              )
 291                );
 292         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 293                                                         vfsStream::getCurrentGroup()
 294                                              )
 295                );
 296         $this->assertTrue($abstractContent->isWritable(-1,
 297                                                        vfsStream::getCurrentGroup()
 298                                             )
 299                );
 300         $this->assertFalse($abstractContent->isWritable(-1,
 301                                                         -1
 302                                              )
 303                );
 304         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 305                                                           vfsStream::getCurrentGroup()
 306                                              )
 307                );
 308         $this->assertFalse($abstractContent->isExecutable(-1,
 309                                                           vfsStream::getCurrentGroup()
 310                                              )
 311                );
 312         $this->assertFalse($abstractContent->isExecutable(-1,
 313                                                           -1
 314                                              )
 315                );
 316     }
 317
 318     /**
 319      * @test
 320      * @group  permissions
 321      * @group  bug_15
 322      */
 323     public function writePermissionsForOther()
 324     {
 325         $abstractContent = new TestvfsStreamAbstractContent('foo', 0002);
 326         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 327                                                         vfsStream::getCurrentGroup()
 328                                              )
 329                );
 330         $this->assertFalse($abstractContent->isReadable(-1,
 331                                                         vfsStream::getCurrentGroup()
 332                                              )
 333                );
 334         $this->assertFalse($abstractContent->isReadable(-1,
 335                                                         -1
 336                                              )
 337                );
 338         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 339                                                         vfsStream::getCurrentGroup()
 340                                              )
 341                );
 342         $this->assertFalse($abstractContent->isWritable(-1,
 343                                                         vfsStream::getCurrentGroup()
 344                                              )
 345                );
 346         $this->assertTrue($abstractContent->isWritable(-1,
 347                                                        -1
 348                                             )
 349                );
 350         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 351                                                           vfsStream::getCurrentGroup()
 352                                              )
 353                );
 354         $this->assertFalse($abstractContent->isExecutable(-1,
 355                                                           vfsStream::getCurrentGroup()
 356                                              )
 357                );
 358         $this->assertFalse($abstractContent->isExecutable(-1,
 359                                                           -1
 360                                              )
 361                );
 362     }
 363
 364     /**
 365      * @test
 366      * @group  permissions
 367      * @group  bug_15
 368      */
 369     public function executeAndWritePermissionsForUser()
 370     {
 371         $abstractContent = new TestvfsStreamAbstractContent('foo', 0300);
 372         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 373                                                         vfsStream::getCurrentGroup()
 374                                              )
 375                );
 376         $this->assertFalse($abstractContent->isReadable(-1,
 377                                                         vfsStream::getCurrentGroup()
 378                                              )
 379                );
 380         $this->assertFalse($abstractContent->isReadable(-1,
 381                                                         -1
 382                                              )
 383                );
 384         $this->assertTrue($abstractContent->isWritable(vfsStream::getCurrentUser(),
 385                                                        vfsStream::getCurrentGroup()
 386                                             )
 387                );
 388         $this->assertFalse($abstractContent->isWritable(-1,
 389                                                         vfsStream::getCurrentGroup()
 390                                              )
 391                );
 392         $this->assertFalse($abstractContent->isWritable(-1,
 393                                                         -1
 394                                              )
 395                );
 396         $this->assertTrue($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 397                                                          vfsStream::getCurrentGroup()
 398                                             )
 399                );
 400         $this->assertFalse($abstractContent->isExecutable(-1,
 401                                                           vfsStream::getCurrentGroup()
 402                                              )
 403                );
 404         $this->assertFalse($abstractContent->isExecutable(-1,
 405                                                           -1
 406                                              )
 407                );
 408     }
 409
 410     /**
 411      * @test
 412      * @group  permissions
 413      * @group  bug_15
 414      */
 415     public function executeAndWritePermissionsForGroup()
 416     {
 417         $abstractContent = new TestvfsStreamAbstractContent('foo', 0030);
 418         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 419                                                         vfsStream::getCurrentGroup()
 420                                              )
 421                );
 422         $this->assertFalse($abstractContent->isReadable(-1,
 423                                                         vfsStream::getCurrentGroup()
 424                                              )
 425                );
 426         $this->assertFalse($abstractContent->isReadable(-1,
 427                                                         -1
 428                                              )
 429                );
 430         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 431                                                         vfsStream::getCurrentGroup()
 432                                              )
 433                );
 434         $this->assertTrue($abstractContent->isWritable(-1,
 435                                                        vfsStream::getCurrentGroup()
 436                                             )
 437                );
 438         $this->assertFalse($abstractContent->isWritable(-1,
 439                                                         -1
 440                                              )
 441                );
 442         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 443                                                           vfsStream::getCurrentGroup()
 444                                              )
 445                );
 446         $this->assertTrue($abstractContent->isExecutable(-1,
 447                                                          vfsStream::getCurrentGroup()
 448                                             )
 449                );
 450         $this->assertFalse($abstractContent->isExecutable(-1,
 451                                                           -1
 452                                              )
 453                );
 454     }
 455
 456     /**
 457      * @test
 458      * @group  permissions
 459      * @group  bug_15
 460      */
 461     public function executeAndWritePermissionsForOther()
 462     {
 463         $abstractContent = new TestvfsStreamAbstractContent('foo', 0003);
 464         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 465                                                         vfsStream::getCurrentGroup()
 466                                              )
 467                );
 468         $this->assertFalse($abstractContent->isReadable(-1,
 469                                                         vfsStream::getCurrentGroup()
 470                                              )
 471                );
 472         $this->assertFalse($abstractContent->isReadable(-1,
 473                                                         -1
 474                                              )
 475                );
 476         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 477                                                         vfsStream::getCurrentGroup()
 478                                              )
 479                );
 480         $this->assertFalse($abstractContent->isWritable(-1,
 481                                                         vfsStream::getCurrentGroup()
 482                                              )
 483                );
 484         $this->assertTrue($abstractContent->isWritable(-1,
 485                                                        -1
 486                                             )
 487                );
 488         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 489                                                           vfsStream::getCurrentGroup()
 490                                              )
 491                );
 492         $this->assertFalse($abstractContent->isExecutable(-1,
 493                                                           vfsStream::getCurrentGroup()
 494                                              )
 495                );
 496         $this->assertTrue($abstractContent->isExecutable(-1,
 497                                                          -1
 498                                             )
 499                );
 500     }
 501
 502     /**
 503      * @test
 504      * @group  permissions
 505      * @group  bug_15
 506      */
 507     public function readPermissionsForUser()
 508     {
 509         $abstractContent = new TestvfsStreamAbstractContent('foo', 0400);
 510         $this->assertTrue($abstractContent->isReadable(vfsStream::getCurrentUser(),
 511                                                        vfsStream::getCurrentGroup()
 512                                             )
 513                );
 514         $this->assertFalse($abstractContent->isReadable(-1,
 515                                                         vfsStream::getCurrentGroup()
 516                                              )
 517                );
 518         $this->assertFalse($abstractContent->isReadable(-1,
 519                                                         -1
 520                                              )
 521                );
 522         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 523                                                         vfsStream::getCurrentGroup()
 524                                              )
 525                );
 526         $this->assertFalse($abstractContent->isWritable(-1,
 527                                                         vfsStream::getCurrentGroup()
 528                                              )
 529                );
 530         $this->assertFalse($abstractContent->isWritable(-1,
 531                                                         -1
 532                                              )
 533                );
 534         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 535                                                           vfsStream::getCurrentGroup()
 536                                              )
 537                );
 538         $this->assertFalse($abstractContent->isExecutable(-1,
 539                                                           vfsStream::getCurrentGroup()
 540                                              )
 541                );
 542         $this->assertFalse($abstractContent->isExecutable(-1,
 543                                                           -1
 544                                              )
 545                );
 546     }
 547
 548     /**
 549      * @test
 550      * @group  permissions
 551      * @group  bug_15
 552      */
 553     public function readPermissionsForGroup()
 554     {
 555         $abstractContent = new TestvfsStreamAbstractContent('foo', 0040);
 556         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 557                                                         vfsStream::getCurrentGroup()
 558                                              )
 559                );
 560         $this->assertTrue($abstractContent->isReadable(-1,
 561                                                         vfsStream::getCurrentGroup()
 562                                              )
 563                );
 564         $this->assertFalse($abstractContent->isReadable(-1,
 565                                                         -1
 566                                              )
 567                );
 568         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 569                                                         vfsStream::getCurrentGroup()
 570                                              )
 571                );
 572         $this->assertFalse($abstractContent->isWritable(-1,
 573                                                         vfsStream::getCurrentGroup()
 574                                              )
 575                );
 576         $this->assertFalse($abstractContent->isWritable(-1,
 577                                                         -1
 578                                              )
 579                );
 580         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 581                                                           vfsStream::getCurrentGroup()
 582                                              )
 583                );
 584         $this->assertFalse($abstractContent->isExecutable(-1,
 585                                                           vfsStream::getCurrentGroup()
 586                                              )
 587                );
 588         $this->assertFalse($abstractContent->isExecutable(-1,
 589                                                           -1
 590                                              )
 591                );
 592     }
 593
 594     /**
 595      * @test
 596      * @group  permissions
 597      * @group  bug_15
 598      */
 599     public function readPermissionsForOther()
 600     {
 601         $abstractContent = new TestvfsStreamAbstractContent('foo', 0004);
 602         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 603                                                         vfsStream::getCurrentGroup()
 604                                              )
 605                );
 606         $this->assertFalse($abstractContent->isReadable(-1,
 607                                                         vfsStream::getCurrentGroup()
 608                                              )
 609                );
 610         $this->assertTrue($abstractContent->isReadable(-1,
 611                                                        -1
 612                                             )
 613                );
 614         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 615                                                         vfsStream::getCurrentGroup()
 616                                              )
 617                );
 618         $this->assertFalse($abstractContent->isWritable(-1,
 619                                                         vfsStream::getCurrentGroup()
 620                                              )
 621                );
 622         $this->assertFalse($abstractContent->isWritable(-1,
 623                                                         -1
 624                                              )
 625                );
 626         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 627                                                           vfsStream::getCurrentGroup()
 628                                              )
 629                );
 630         $this->assertFalse($abstractContent->isExecutable(-1,
 631                                                           vfsStream::getCurrentGroup()
 632                                              )
 633                );
 634         $this->assertFalse($abstractContent->isExecutable(-1,
 635                                                           -1
 636                                              )
 637                );
 638     }
 639
 640     /**
 641      * @test
 642      * @group  permissions
 643      * @group  bug_15
 644      */
 645     public function readAndExecutePermissionsForUser()
 646     {
 647         $abstractContent = new TestvfsStreamAbstractContent('foo', 0500);
 648         $this->assertTrue($abstractContent->isReadable(vfsStream::getCurrentUser(),
 649                                                        vfsStream::getCurrentGroup()
 650                                             )
 651                );
 652         $this->assertFalse($abstractContent->isReadable(-1,
 653                                                         vfsStream::getCurrentGroup()
 654                                              )
 655                );
 656         $this->assertFalse($abstractContent->isReadable(-1,
 657                                                         -1
 658                                              )
 659                );
 660         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 661                                                         vfsStream::getCurrentGroup()
 662                                              )
 663                );
 664         $this->assertFalse($abstractContent->isWritable(-1,
 665                                                         vfsStream::getCurrentGroup()
 666                                              )
 667                );
 668         $this->assertFalse($abstractContent->isWritable(-1,
 669                                                         -1
 670                                              )
 671                );
 672         $this->assertTrue($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 673                                                          vfsStream::getCurrentGroup()
 674                                             )
 675                );
 676         $this->assertFalse($abstractContent->isExecutable(-1,
 677                                                           vfsStream::getCurrentGroup()
 678                                              )
 679                );
 680         $this->assertFalse($abstractContent->isExecutable(-1,
 681                                                           -1
 682                                              )
 683                );
 684     }
 685
 686     /**
 687      * @test
 688      * @group  permissions
 689      * @group  bug_15
 690      */
 691     public function readAndExecutePermissionsForGroup()
 692     {
 693         $abstractContent = new TestvfsStreamAbstractContent('foo', 0050);
 694         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 695                                                         vfsStream::getCurrentGroup()
 696                                              )
 697                );
 698         $this->assertTrue($abstractContent->isReadable(-1,
 699                                                         vfsStream::getCurrentGroup()
 700                                              )
 701                );
 702         $this->assertFalse($abstractContent->isReadable(-1,
 703                                                         -1
 704                                              )
 705                );
 706         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 707                                                         vfsStream::getCurrentGroup()
 708                                              )
 709                );
 710         $this->assertFalse($abstractContent->isWritable(-1,
 711                                                         vfsStream::getCurrentGroup()
 712                                              )
 713                );
 714         $this->assertFalse($abstractContent->isWritable(-1,
 715                                                         -1
 716                                              )
 717                );
 718         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 719                                                           vfsStream::getCurrentGroup()
 720                                              )
 721                );
 722         $this->assertTrue($abstractContent->isExecutable(-1,
 723                                                          vfsStream::getCurrentGroup()
 724                                             )
 725                );
 726         $this->assertFalse($abstractContent->isExecutable(-1,
 727                                                           -1
 728                                              )
 729                );
 730     }
 731
 732     /**
 733      * @test
 734      * @group  permissions
 735      * @group  bug_15
 736      */
 737     public function readAndExecutePermissionsForOther()
 738     {
 739         $abstractContent = new TestvfsStreamAbstractContent('foo', 0005);
 740         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 741                                                         vfsStream::getCurrentGroup()
 742                                              )
 743                );
 744         $this->assertFalse($abstractContent->isReadable(-1,
 745                                                         vfsStream::getCurrentGroup()
 746                                              )
 747                );
 748         $this->assertTrue($abstractContent->isReadable(-1,
 749                                                        -1
 750                                             )
 751                );
 752         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 753                                                         vfsStream::getCurrentGroup()
 754                                              )
 755                );
 756         $this->assertFalse($abstractContent->isWritable(-1,
 757                                                         vfsStream::getCurrentGroup()
 758                                              )
 759                );
 760         $this->assertFalse($abstractContent->isWritable(-1,
 761                                                         -1
 762                                              )
 763                );
 764         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 765                                                           vfsStream::getCurrentGroup()
 766                                              )
 767                );
 768         $this->assertFalse($abstractContent->isExecutable(-1,
 769                                                           vfsStream::getCurrentGroup()
 770                                              )
 771                );
 772         $this->assertTrue($abstractContent->isExecutable(-1,
 773                                                          -1
 774                                             )
 775                );
 776     }
 777
 778     /**
 779      * @test
 780      * @group  permissions
 781      * @group  bug_15
 782      */
 783     public function readAndWritePermissionsForUser()
 784     {
 785         $abstractContent = new TestvfsStreamAbstractContent('foo', 0600);
 786         $this->assertTrue($abstractContent->isReadable(vfsStream::getCurrentUser(),
 787                                                        vfsStream::getCurrentGroup()
 788                                             )
 789                );
 790         $this->assertFalse($abstractContent->isReadable(-1,
 791                                                         vfsStream::getCurrentGroup()
 792                                              )
 793                );
 794         $this->assertFalse($abstractContent->isReadable(-1,
 795                                                         -1
 796                                              )
 797                );
 798         $this->assertTrue($abstractContent->isWritable(vfsStream::getCurrentUser(),
 799                                                        vfsStream::getCurrentGroup()
 800                                             )
 801                );
 802         $this->assertFalse($abstractContent->isWritable(-1,
 803                                                         vfsStream::getCurrentGroup()
 804                                              )
 805                );
 806         $this->assertFalse($abstractContent->isWritable(-1,
 807                                                         -1
 808                                              )
 809                );
 810         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 811                                                           vfsStream::getCurrentGroup()
 812                                              )
 813                );
 814         $this->assertFalse($abstractContent->isExecutable(-1,
 815                                                           vfsStream::getCurrentGroup()
 816                                              )
 817                );
 818         $this->assertFalse($abstractContent->isExecutable(-1,
 819                                                           -1
 820                                              )
 821                );
 822     }
 823
 824     /**
 825      * @test
 826      * @group  permissions
 827      * @group  bug_15
 828      */
 829     public function readAndWritePermissionsForGroup()
 830     {
 831         $abstractContent = new TestvfsStreamAbstractContent('foo', 0060);
 832         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 833                                                         vfsStream::getCurrentGroup()
 834                                              )
 835                );
 836         $this->assertTrue($abstractContent->isReadable(-1,
 837                                                         vfsStream::getCurrentGroup()
 838                                              )
 839                );
 840         $this->assertFalse($abstractContent->isReadable(-1,
 841                                                         -1
 842                                              )
 843                );
 844         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 845                                                         vfsStream::getCurrentGroup()
 846                                              )
 847                );
 848         $this->assertTrue($abstractContent->isWritable(-1,
 849                                                        vfsStream::getCurrentGroup()
 850                                             )
 851                );
 852         $this->assertFalse($abstractContent->isWritable(-1,
 853                                                         -1
 854                                              )
 855                );
 856         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 857                                                           vfsStream::getCurrentGroup()
 858                                              )
 859                );
 860         $this->assertFalse($abstractContent->isExecutable(-1,
 861                                                           vfsStream::getCurrentGroup()
 862                                              )
 863                );
 864         $this->assertFalse($abstractContent->isExecutable(-1,
 865                                                           -1
 866                                              )
 867                );
 868     }
 869
 870     /**
 871      * @test
 872      * @group  permissions
 873      * @group  bug_15
 874      */
 875     public function readAndWritePermissionsForOther()
 876     {
 877         $abstractContent = new TestvfsStreamAbstractContent('foo', 0006);
 878         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 879                                                         vfsStream::getCurrentGroup()
 880                                              )
 881                );
 882         $this->assertFalse($abstractContent->isReadable(-1,
 883                                                         vfsStream::getCurrentGroup()
 884                                              )
 885                );
 886         $this->assertTrue($abstractContent->isReadable(-1,
 887                                                        -1
 888                                             )
 889                );
 890         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 891                                                         vfsStream::getCurrentGroup()
 892                                              )
 893                );
 894         $this->assertFalse($abstractContent->isWritable(-1,
 895                                                         vfsStream::getCurrentGroup()
 896                                              )
 897                );
 898         $this->assertTrue($abstractContent->isWritable(-1,
 899                                                        -1
 900                                             )
 901                );
 902         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 903                                                           vfsStream::getCurrentGroup()
 904                                              )
 905                );
 906         $this->assertFalse($abstractContent->isExecutable(-1,
 907                                                           vfsStream::getCurrentGroup()
 908                                              )
 909                );
 910         $this->assertFalse($abstractContent->isExecutable(-1,
 911                                                           -1
 912                                              )
 913                );
 914     }
 915
 916     /**
 917      * @test
 918      * @group  permissions
 919      * @group  bug_15
 920      */
 921     public function allPermissionsForUser()
 922     {
 923         $abstractContent = new TestvfsStreamAbstractContent('foo', 0700);
 924         $this->assertTrue($abstractContent->isReadable(vfsStream::getCurrentUser(),
 925                                                        vfsStream::getCurrentGroup()
 926                                             )
 927                );
 928         $this->assertFalse($abstractContent->isReadable(-1,
 929                                                         vfsStream::getCurrentGroup()
 930                                              )
 931                );
 932         $this->assertFalse($abstractContent->isReadable(-1,
 933                                                         -1
 934                                              )
 935                );
 936         $this->assertTrue($abstractContent->isWritable(vfsStream::getCurrentUser(),
 937                                                        vfsStream::getCurrentGroup()
 938                                             )
 939                );
 940         $this->assertFalse($abstractContent->isWritable(-1,
 941                                                         vfsStream::getCurrentGroup()
 942                                              )
 943                );
 944         $this->assertFalse($abstractContent->isWritable(-1,
 945                                                         -1
 946                                              )
 947                );
 948         $this->assertTrue($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 949                                                          vfsStream::getCurrentGroup()
 950                                             )
 951                );
 952         $this->assertFalse($abstractContent->isExecutable(-1,
 953                                                           vfsStream::getCurrentGroup()
 954                                              )
 955                );
 956         $this->assertFalse($abstractContent->isExecutable(-1,
 957                                                           -1
 958                                              )
 959                );
 960     }
 961
 962     /**
 963      * @test
 964      * @group  permissions
 965      * @group  bug_15
 966      */
 967     public function allPermissionsForGroup()
 968     {
 969         $abstractContent = new TestvfsStreamAbstractContent('foo', 0070);
 970         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
 971                                                         vfsStream::getCurrentGroup()
 972                                              )
 973                );
 974         $this->assertTrue($abstractContent->isReadable(-1,
 975                                                         vfsStream::getCurrentGroup()
 976                                              )
 977                );
 978         $this->assertFalse($abstractContent->isReadable(-1,
 979                                                         -1
 980                                              )
 981                );
 982         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
 983                                                         vfsStream::getCurrentGroup()
 984                                              )
 985                );
 986         $this->assertTrue($abstractContent->isWritable(-1,
 987                                                        vfsStream::getCurrentGroup()
 988                                             )
 989                );
 990         $this->assertFalse($abstractContent->isWritable(-1,
 991                                                         -1
 992                                              )
 993                );
 994         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
 995                                                           vfsStream::getCurrentGroup()
 996                                              )
 997                );
 998         $this->assertTrue($abstractContent->isExecutable(-1,
 999                                                          vfsStream::getCurrentGroup()
1000                                             )
1001                );
1002         $this->assertFalse($abstractContent->isExecutable(-1,
1003                                                           -1
1004                                              )
1005                );
1006     }
1007
1008     /**
1009      * @test
1010      * @group  permissions
1011      * @group  bug_15
1012      */
1013     public function allPermissionsForOther()
1014     {
1015         $abstractContent = new TestvfsStreamAbstractContent('foo', 0007);
1016         $this->assertFalse($abstractContent->isReadable(vfsStream::getCurrentUser(),
1017                                                         vfsStream::getCurrentGroup()
1018                                              )
1019                );
1020         $this->assertFalse($abstractContent->isReadable(-1,
1021                                                         vfsStream::getCurrentGroup()
1022                                              )
1023                );
1024         $this->assertTrue($abstractContent->isReadable(-1,
1025                                                        -1
1026                                             )
1027                );
1028         $this->assertFalse($abstractContent->isWritable(vfsStream::getCurrentUser(),
1029                                                         vfsStream::getCurrentGroup()
1030                                              )
1031                );
1032         $this->assertFalse($abstractContent->isWritable(-1,
1033                                                         vfsStream::getCurrentGroup()
1034                                              )
1035                );
1036         $this->assertTrue($abstractContent->isWritable(-1,
1037                                                        -1
1038                                             )
1039                );
1040         $this->assertFalse($abstractContent->isExecutable(vfsStream::getCurrentUser(),
1041                                                           vfsStream::getCurrentGroup()
1042                                              )
1043                );
1044         $this->assertFalse($abstractContent->isExecutable(-1,
1045                                                           vfsStream::getCurrentGroup()
1046                                              )
1047                );
1048         $this->assertTrue($abstractContent->isExecutable(-1,
1049                                                          -1
1050                                             )
1051                );
1052     }
1053 }