www.aleph1.co.uk Git - yaffs-website/blob - vendor/phpunit/phpunit/tests/Framework/AssertTest.php

   1 <?php
   2 /*
   3  * This file is part of PHPUnit.
   4  *
   5  * (c) Sebastian Bergmann <sebastian@phpunit.de>
   6  *
   7  * For the full copyright and license information, please view the LICENSE
   8  * file that was distributed with this source code.
   9  */
  10
  11 /**
  12  * @since      Class available since Release 2.0.0
  13  */
  14 class Framework_AssertTest extends PHPUnit_Framework_TestCase
  15 {
  16     /**
  17      * @var string
  18      */
  19     private $filesDirectory;
  20
  21     protected function setUp()
  22     {
  23         $this->filesDirectory = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR;
  24     }
  25
  26     /**
  27      * @covers PHPUnit_Framework_Assert::fail
  28      */
  29     public function testFail()
  30     {
  31         try {
  32             $this->fail();
  33         } catch (PHPUnit_Framework_AssertionFailedError $e) {
  34             return;
  35         }
  36
  37         throw new PHPUnit_Framework_AssertionFailedError('Fail did not throw fail exception');
  38     }
  39
  40     /**
  41      * @covers PHPUnit_Framework_Assert::assertContains
  42      */
  43     public function testAssertSplObjectStorageContainsObject()
  44     {
  45         $a = new stdClass;
  46         $b = new stdClass;
  47         $c = new SplObjectStorage;
  48         $c->attach($a);
  49
  50         $this->assertContains($a, $c);
  51
  52         try {
  53             $this->assertContains($b, $c);
  54         } catch (PHPUnit_Framework_AssertionFailedError $e) {
  55             return;
  56         }
  57
  58         $this->fail();
  59     }
  60
  61     /**
  62      * @covers PHPUnit_Framework_Assert::assertContains
  63      */
  64     public function testAssertArrayContainsObject()
  65     {
  66         $a = new stdClass;
  67         $b = new stdClass;
  68
  69         $this->assertContains($a, array($a));
  70
  71         try {
  72             $this->assertContains($a, array($b));
  73         } catch (PHPUnit_Framework_AssertionFailedError $e) {
  74             return;
  75         }
  76
  77         $this->fail();
  78     }
  79
  80     /**
  81      * @covers PHPUnit_Framework_Assert::assertContains
  82      */
  83     public function testAssertArrayContainsString()
  84     {
  85         $this->assertContains('foo', array('foo'));
  86
  87         try {
  88             $this->assertContains('foo', array('bar'));
  89         } catch (PHPUnit_Framework_AssertionFailedError $e) {
  90             return;
  91         }
  92
  93         $this->fail();
  94     }
  95
  96     /**
  97      * @covers PHPUnit_Framework_Assert::assertContains
  98      */
  99     public function testAssertArrayContainsNonObject()
 100     {
 101         $this->assertContains('foo', array(true));
 102
 103         try {
 104             $this->assertContains('foo', array(true), '', false, true, true);
 105         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 106             return;
 107         }
 108
 109         $this->fail();
 110     }
 111
 112     /**
 113      * @covers PHPUnit_Framework_Assert::assertContainsOnlyInstancesOf
 114      */
 115     public function testAssertContainsOnlyInstancesOf()
 116     {
 117         $test = array(
 118             new Book(),
 119             new Book
 120         );
 121         $this->assertContainsOnlyInstancesOf('Book', $test);
 122         $this->assertContainsOnlyInstancesOf('stdClass', array(new stdClass()));
 123
 124         $test2 = array(
 125             new Author('Test')
 126         );
 127         try {
 128             $this->assertContainsOnlyInstancesOf('Book', $test2);
 129         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 130             return;
 131         }
 132         $this->fail();
 133     }
 134
 135     /**
 136      * @covers            PHPUnit_Framework_Assert::assertArrayHasKey
 137      * @expectedException PHPUnit_Framework_Exception
 138      */
 139     public function testAssertArrayHasKeyThrowsExceptionForInvalidFirstArgument()
 140     {
 141         $this->assertArrayHasKey(null, array());
 142     }
 143
 144     /**
 145      * @covers            PHPUnit_Framework_Assert::assertArrayHasKey
 146      * @expectedException PHPUnit_Framework_Exception
 147      */
 148     public function testAssertArrayHasKeyThrowsExceptionForInvalidSecondArgument()
 149     {
 150         $this->assertArrayHasKey(0, null);
 151     }
 152
 153     /**
 154      * @covers PHPUnit_Framework_Assert::assertArrayHasKey
 155      */
 156     public function testAssertArrayHasIntegerKey()
 157     {
 158         $this->assertArrayHasKey(0, array('foo'));
 159
 160         try {
 161             $this->assertArrayHasKey(1, array('foo'));
 162         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 163             return;
 164         }
 165
 166         $this->fail();
 167     }
 168
 169     /**
 170      * @covers PHPUnit_Framework_Assert::assertArraySubset
 171      * @covers PHPUnit_Framework_Constraint_ArraySubset
 172      */
 173     public function testAssertArraySubset()
 174     {
 175         $array = array(
 176             'a' => 'item a',
 177             'b' => 'item b',
 178             'c' => array('a2' => 'item a2', 'b2' => 'item b2'),
 179             'd' => array('a2' => array('a3' => 'item a3', 'b3' => 'item b3'))
 180         );
 181
 182         $this->assertArraySubset(array('a' => 'item a', 'c' => array('a2' => 'item a2')), $array);
 183         $this->assertArraySubset(array('a' => 'item a', 'd' => array('a2' => array('b3' => 'item b3'))), $array);
 184
 185         $arrayAccessData = new ArrayObject($array);
 186
 187         $this->assertArraySubset(array('a' => 'item a', 'c' => array('a2' => 'item a2')), $arrayAccessData);
 188         $this->assertArraySubset(array('a' => 'item a', 'd' => array('a2' => array('b3' => 'item b3'))), $arrayAccessData);
 189
 190         try {
 191             $this->assertArraySubset(array('a' => 'bad value'), $array);
 192         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 193         }
 194
 195         try {
 196             $this->assertArraySubset(array('d' => array('a2' => array('bad index' => 'item b3'))), $array);
 197         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 198             return;
 199         }
 200
 201         $this->fail();
 202     }
 203
 204     /**
 205      * @covers PHPUnit_Framework_Assert::assertArraySubset
 206      * @covers PHPUnit_Framework_Constraint_ArraySubset
 207      */
 208     public function testAssertArraySubsetWithDeepNestedArrays()
 209     {
 210         $array = array(
 211             'path' => array(
 212                 'to' => array(
 213                     'the' => array(
 214                         'cake' => 'is a lie'
 215                     )
 216                 )
 217             )
 218         );
 219
 220         $this->assertArraySubset(array('path' => array()), $array);
 221         $this->assertArraySubset(array('path' => array('to' => array())), $array);
 222         $this->assertArraySubset(array('path' => array('to' => array('the' => array()))), $array);
 223         $this->assertArraySubset(array('path' => array('to' => array('the' => array('cake' => 'is a lie')))), $array);
 224
 225         try {
 226             $this->assertArraySubset(array('path' => array('to' => array('the' => array('cake' => 'is not a lie')))), $array);
 227         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 228             return;
 229         }
 230
 231         $this->fail();
 232     }
 233
 234     /**
 235      * @covers PHPUnit_Framework_Assert::assertArraySubset
 236      * @covers PHPUnit_Framework_Constraint_ArraySubset
 237      */
 238     public function testAssertArraySubsetWithNoStrictCheckAndObjects()
 239     {
 240         $obj       = new \stdClass;
 241         $reference = &$obj;
 242         $array     = array('a' => $obj);
 243
 244         $this->assertArraySubset(array('a' => $reference), $array);
 245         $this->assertArraySubset(array('a' => new \stdClass), $array);
 246     }
 247
 248     /**
 249      * @covers PHPUnit_Framework_Assert::assertArraySubset
 250      * @covers PHPUnit_Framework_Constraint_ArraySubset
 251      */
 252     public function testAssertArraySubsetWithStrictCheckAndObjects()
 253     {
 254         $obj       = new \stdClass;
 255         $reference = &$obj;
 256         $array     = array('a' => $obj);
 257
 258         $this->assertArraySubset(array('a' => $reference), $array, true);
 259
 260         try {
 261             $this->assertArraySubset(array('a' => new \stdClass), $array, true);
 262         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 263             return;
 264         }
 265
 266         $this->fail('Strict recursive array check fail.');
 267     }
 268
 269     /**
 270      * @covers PHPUnit_Framework_Assert::assertArraySubset
 271      * @covers PHPUnit_Framework_Constraint_ArraySubset
 272      * @expectedException PHPUnit_Framework_Exception
 273      * @expectedExceptionMessage array or ArrayAccess
 274      * @dataProvider assertArraySubsetInvalidArgumentProvider
 275      */
 276     public function testAssertArraySubsetRaisesExceptionForInvalidArguments($partial, $subject)
 277     {
 278         $this->assertArraySubset($partial, $subject);
 279     }
 280
 281     /**
 282      * @return array
 283      */
 284     public function assertArraySubsetInvalidArgumentProvider()
 285     {
 286         return array(
 287             array(false, array()),
 288             array(array(), false),
 289         );
 290     }
 291
 292     /**
 293      * @covers            PHPUnit_Framework_Assert::assertArrayNotHasKey
 294      * @expectedException PHPUnit_Framework_Exception
 295      */
 296     public function testAssertArrayNotHasKeyThrowsExceptionForInvalidFirstArgument()
 297     {
 298         $this->assertArrayNotHasKey(null, array());
 299     }
 300
 301     /**
 302      * @covers            PHPUnit_Framework_Assert::assertArrayNotHasKey
 303      * @expectedException PHPUnit_Framework_Exception
 304      */
 305     public function testAssertArrayNotHasKeyThrowsExceptionForInvalidSecondArgument()
 306     {
 307         $this->assertArrayNotHasKey(0, null);
 308     }
 309
 310     /**
 311      * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
 312      */
 313     public function testAssertArrayNotHasIntegerKey()
 314     {
 315         $this->assertArrayNotHasKey(1, array('foo'));
 316
 317         try {
 318             $this->assertArrayNotHasKey(0, array('foo'));
 319         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 320             return;
 321         }
 322
 323         $this->fail();
 324     }
 325
 326     /**
 327      * @covers PHPUnit_Framework_Assert::assertArrayHasKey
 328      */
 329     public function testAssertArrayHasStringKey()
 330     {
 331         $this->assertArrayHasKey('foo', array('foo' => 'bar'));
 332
 333         try {
 334             $this->assertArrayHasKey('bar', array('foo' => 'bar'));
 335         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 336             return;
 337         }
 338
 339         $this->fail();
 340     }
 341
 342     /**
 343      * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
 344      */
 345     public function testAssertArrayNotHasStringKey()
 346     {
 347         $this->assertArrayNotHasKey('bar', array('foo' => 'bar'));
 348
 349         try {
 350             $this->assertArrayNotHasKey('foo', array('foo' => 'bar'));
 351         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 352             return;
 353         }
 354
 355         $this->fail();
 356     }
 357
 358     /**
 359      * @covers PHPUnit_Framework_Assert::assertArrayHasKey
 360      */
 361     public function testAssertArrayHasKeyAcceptsArrayObjectValue()
 362     {
 363         $array        = new ArrayObject();
 364         $array['foo'] = 'bar';
 365         $this->assertArrayHasKey('foo', $array);
 366     }
 367
 368     /**
 369      * @covers PHPUnit_Framework_Assert::assertArrayHasKey
 370      * @expectedException PHPUnit_Framework_AssertionFailedError
 371      */
 372     public function testAssertArrayHasKeyProperlyFailsWithArrayObjectValue()
 373     {
 374         $array        = new ArrayObject();
 375         $array['bar'] = 'bar';
 376         $this->assertArrayHasKey('foo', $array);
 377     }
 378
 379     /**
 380      * @covers PHPUnit_Framework_Assert::assertArrayHasKey
 381      */
 382     public function testAssertArrayHasKeyAcceptsArrayAccessValue()
 383     {
 384         $array        = new SampleArrayAccess();
 385         $array['foo'] = 'bar';
 386         $this->assertArrayHasKey('foo', $array);
 387     }
 388
 389     /**
 390      * @covers PHPUnit_Framework_Assert::assertArrayHasKey
 391      * @expectedException PHPUnit_Framework_AssertionFailedError
 392      */
 393     public function testAssertArrayHasKeyProperlyFailsWithArrayAccessValue()
 394     {
 395         $array        = new SampleArrayAccess();
 396         $array['bar'] = 'bar';
 397         $this->assertArrayHasKey('foo', $array);
 398     }
 399
 400     /**
 401      * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
 402      */
 403     public function testAssertArrayNotHasKeyAcceptsArrayAccessValue()
 404     {
 405         $array        = new ArrayObject();
 406         $array['foo'] = 'bar';
 407         $this->assertArrayNotHasKey('bar', $array);
 408     }
 409
 410     /**
 411      * @covers PHPUnit_Framework_Assert::assertArrayNotHasKey
 412      * @expectedException PHPUnit_Framework_AssertionFailedError
 413      */
 414     public function testAssertArrayNotHasKeyPropertlyFailsWithArrayAccessValue()
 415     {
 416         $array        = new ArrayObject();
 417         $array['bar'] = 'bar';
 418         $this->assertArrayNotHasKey('bar', $array);
 419     }
 420
 421     /**
 422      * @covers            PHPUnit_Framework_Assert::assertContains
 423      * @expectedException PHPUnit_Framework_Exception
 424      */
 425     public function testAssertContainsThrowsException()
 426     {
 427         $this->assertContains(null, null);
 428     }
 429
 430     /**
 431      * @covers PHPUnit_Framework_Assert::assertContains
 432      */
 433     public function testAssertIteratorContainsObject()
 434     {
 435         $foo = new stdClass;
 436
 437         $this->assertContains($foo, new TestIterator(array($foo)));
 438
 439         try {
 440             $this->assertContains($foo, new TestIterator(array(new stdClass)));
 441         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 442             return;
 443         }
 444
 445         $this->fail();
 446     }
 447
 448     /**
 449      * @covers PHPUnit_Framework_Assert::assertContains
 450      */
 451     public function testAssertIteratorContainsString()
 452     {
 453         $this->assertContains('foo', new TestIterator(array('foo')));
 454
 455         try {
 456             $this->assertContains('foo', new TestIterator(array('bar')));
 457         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 458             return;
 459         }
 460
 461         $this->fail();
 462     }
 463
 464     /**
 465      * @covers PHPUnit_Framework_Assert::assertContains
 466      */
 467     public function testAssertStringContainsString()
 468     {
 469         $this->assertContains('foo', 'foobar');
 470
 471         try {
 472             $this->assertContains('foo', 'bar');
 473         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 474             return;
 475         }
 476
 477         $this->fail();
 478     }
 479
 480     /**
 481      * @covers            PHPUnit_Framework_Assert::assertNotContains
 482      * @expectedException PHPUnit_Framework_Exception
 483      */
 484     public function testAssertNotContainsThrowsException()
 485     {
 486         $this->assertNotContains(null, null);
 487     }
 488
 489     /**
 490      * @covers PHPUnit_Framework_Assert::assertNotContains
 491      */
 492     public function testAssertSplObjectStorageNotContainsObject()
 493     {
 494         $a = new stdClass;
 495         $b = new stdClass;
 496         $c = new SplObjectStorage;
 497         $c->attach($a);
 498
 499         $this->assertNotContains($b, $c);
 500
 501         try {
 502             $this->assertNotContains($a, $c);
 503         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 504             return;
 505         }
 506
 507         $this->fail();
 508     }
 509
 510     /**
 511      * @covers PHPUnit_Framework_Assert::assertNotContains
 512      */
 513     public function testAssertArrayNotContainsObject()
 514     {
 515         $a = new stdClass;
 516         $b = new stdClass;
 517
 518         $this->assertNotContains($a, array($b));
 519
 520         try {
 521             $this->assertNotContains($a, array($a));
 522         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 523             return;
 524         }
 525
 526         $this->fail();
 527     }
 528
 529     /**
 530      * @covers PHPUnit_Framework_Assert::assertNotContains
 531      */
 532     public function testAssertArrayNotContainsString()
 533     {
 534         $this->assertNotContains('foo', array('bar'));
 535
 536         try {
 537             $this->assertNotContains('foo', array('foo'));
 538         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 539             return;
 540         }
 541
 542         $this->fail();
 543     }
 544
 545     /**
 546      * @covers PHPUnit_Framework_Assert::assertNotContains
 547      */
 548     public function testAssertArrayNotContainsNonObject()
 549     {
 550         $this->assertNotContains('foo', array(true), '', false, true, true);
 551
 552         try {
 553             $this->assertNotContains('foo', array(true));
 554         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 555             return;
 556         }
 557
 558         $this->fail();
 559     }
 560
 561     /**
 562      * @covers PHPUnit_Framework_Assert::assertNotContains
 563      */
 564     public function testAssertStringNotContainsString()
 565     {
 566         $this->assertNotContains('foo', 'bar');
 567
 568         try {
 569             $this->assertNotContains('foo', 'foo');
 570         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 571             return;
 572         }
 573
 574         $this->fail();
 575     }
 576
 577     /**
 578      * @covers            PHPUnit_Framework_Assert::assertContainsOnly
 579      * @expectedException PHPUnit_Framework_Exception
 580      */
 581     public function testAssertContainsOnlyThrowsException()
 582     {
 583         $this->assertContainsOnly(null, null);
 584     }
 585
 586     /**
 587      * @covers            PHPUnit_Framework_Assert::assertNotContainsOnly
 588      * @expectedException PHPUnit_Framework_Exception
 589      */
 590     public function testAssertNotContainsOnlyThrowsException()
 591     {
 592         $this->assertNotContainsOnly(null, null);
 593     }
 594
 595     /**
 596      * @covers            PHPUnit_Framework_Assert::assertContainsOnlyInstancesOf
 597      * @expectedException PHPUnit_Framework_Exception
 598      */
 599     public function testAssertContainsOnlyInstancesOfThrowsException()
 600     {
 601         $this->assertContainsOnlyInstancesOf(null, null);
 602     }
 603
 604     /**
 605      * @covers PHPUnit_Framework_Assert::assertContainsOnly
 606      */
 607     public function testAssertArrayContainsOnlyIntegers()
 608     {
 609         $this->assertContainsOnly('integer', array(1, 2, 3));
 610
 611         try {
 612             $this->assertContainsOnly('integer', array('1', 2, 3));
 613         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 614             return;
 615         }
 616
 617         $this->fail();
 618     }
 619
 620     /**
 621      * @covers PHPUnit_Framework_Assert::assertNotContainsOnly
 622      */
 623     public function testAssertArrayNotContainsOnlyIntegers()
 624     {
 625         $this->assertNotContainsOnly('integer', array('1', 2, 3));
 626
 627         try {
 628             $this->assertNotContainsOnly('integer', array(1, 2, 3));
 629         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 630             return;
 631         }
 632
 633         $this->fail();
 634     }
 635
 636     /**
 637      * @covers PHPUnit_Framework_Assert::assertContainsOnly
 638      */
 639     public function testAssertArrayContainsOnlyStdClass()
 640     {
 641         $this->assertContainsOnly('StdClass', array(new stdClass));
 642
 643         try {
 644             $this->assertContainsOnly('StdClass', array('StdClass'));
 645         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 646             return;
 647         }
 648
 649         $this->fail();
 650     }
 651
 652     /**
 653      * @covers PHPUnit_Framework_Assert::assertNotContainsOnly
 654      */
 655     public function testAssertArrayNotContainsOnlyStdClass()
 656     {
 657         $this->assertNotContainsOnly('StdClass', array('StdClass'));
 658
 659         try {
 660             $this->assertNotContainsOnly('StdClass', array(new stdClass));
 661         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 662             return;
 663         }
 664
 665         $this->fail();
 666     }
 667
 668     protected function sameValues()
 669     {
 670         $object = new SampleClass(4, 8, 15);
 671         // cannot use $filesDirectory, because neither setUp() nor
 672         // setUpBeforeClass() are executed before the data providers
 673         $file     = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml';
 674         $resource = fopen($file, 'r');
 675
 676         return array(
 677             // null
 678             array(null, null),
 679             // strings
 680             array('a', 'a'),
 681             // integers
 682             array(0, 0),
 683             // floats
 684             array(2.3, 2.3),
 685             array(1/3, 1 - 2/3),
 686             array(log(0), log(0)),
 687             // arrays
 688             array(array(), array()),
 689             array(array(0 => 1), array(0 => 1)),
 690             array(array(0 => null), array(0 => null)),
 691             array(array('a', 'b' => array(1, 2)), array('a', 'b' => array(1, 2))),
 692             // objects
 693             array($object, $object),
 694             // resources
 695             array($resource, $resource),
 696         );
 697     }
 698
 699     protected function notEqualValues()
 700     {
 701         // cyclic dependencies
 702         $book1                  = new Book;
 703         $book1->author          = new Author('Terry Pratchett');
 704         $book1->author->books[] = $book1;
 705         $book2                  = new Book;
 706         $book2->author          = new Author('Terry Pratch');
 707         $book2->author->books[] = $book2;
 708
 709         $book3         = new Book;
 710         $book3->author = 'Terry Pratchett';
 711         $book4         = new stdClass;
 712         $book4->author = 'Terry Pratchett';
 713
 714         $object1  = new SampleClass(4, 8, 15);
 715         $object2  = new SampleClass(16, 23, 42);
 716         $object3  = new SampleClass(4, 8, 15);
 717         $storage1 = new SplObjectStorage;
 718         $storage1->attach($object1);
 719         $storage2 = new SplObjectStorage;
 720         $storage2->attach($object3); // same content, different object
 721
 722         // cannot use $filesDirectory, because neither setUp() nor
 723         // setUpBeforeClass() are executed before the data providers
 724         $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml';
 725
 726         return array(
 727             // strings
 728             array('a', 'b'),
 729             array('a', 'A'),
 730             // https://github.com/sebastianbergmann/phpunit/issues/1023
 731             array('9E6666666','9E7777777'),
 732             // integers
 733             array(1, 2),
 734             array(2, 1),
 735             // floats
 736             array(2.3, 4.2),
 737             array(2.3, 4.2, 0.5),
 738             array(array(2.3), array(4.2), 0.5),
 739             array(array(array(2.3)), array(array(4.2)), 0.5),
 740             array(new Struct(2.3), new Struct(4.2), 0.5),
 741             array(array(new Struct(2.3)), array(new Struct(4.2)), 0.5),
 742             // NAN
 743             array(NAN, NAN),
 744             // arrays
 745             array(array(), array(0 => 1)),
 746             array(array(0          => 1), array()),
 747             array(array(0          => null), array()),
 748             array(array(0          => 1, 1 => 2), array(0          => 1, 1 => 3)),
 749             array(array('a', 'b' => array(1, 2)), array('a', 'b' => array(2, 1))),
 750             // objects
 751             array(new SampleClass(4, 8, 15), new SampleClass(16, 23, 42)),
 752             array($object1, $object2),
 753             array($book1, $book2),
 754             array($book3, $book4), // same content, different class
 755             // resources
 756             array(fopen($file, 'r'), fopen($file, 'r')),
 757             // SplObjectStorage
 758             array($storage1, $storage2),
 759             // DOMDocument
 760             array(
 761                 PHPUnit_Util_XML::load('<root></root>'),
 762                 PHPUnit_Util_XML::load('<bar/>'),
 763             ),
 764             array(
 765                 PHPUnit_Util_XML::load('<foo attr1="bar"/>'),
 766                 PHPUnit_Util_XML::load('<foo attr1="foobar"/>'),
 767             ),
 768             array(
 769                 PHPUnit_Util_XML::load('<foo> bar </foo>'),
 770                 PHPUnit_Util_XML::load('<foo />'),
 771             ),
 772             array(
 773                 PHPUnit_Util_XML::load('<foo xmlns="urn:myns:bar"/>'),
 774                 PHPUnit_Util_XML::load('<foo xmlns="urn:notmyns:bar"/>'),
 775             ),
 776             array(
 777                 PHPUnit_Util_XML::load('<foo> bar </foo>'),
 778                 PHPUnit_Util_XML::load('<foo> bir </foo>'),
 779             ),
 780             array(
 781                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 782                 new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')),
 783             ),
 784             array(
 785                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 786                 new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/New_York')),
 787                 3500
 788             ),
 789             array(
 790                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 791                 new DateTime('2013-03-29 05:13:35', new DateTimeZone('America/New_York')),
 792                 3500
 793             ),
 794             array(
 795                 new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
 796                 new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
 797             ),
 798             array(
 799                 new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
 800                 new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
 801                 43200
 802             ),
 803             array(
 804                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 805                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')),
 806             ),
 807             array(
 808                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 809                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')),
 810                 3500
 811             ),
 812             array(
 813                 new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
 814                 new DateTime('2013-03-30', new DateTimeZone('America/Chicago')),
 815             ),
 816             array(
 817                 new DateTime('2013-03-29T05:13:35-0600'),
 818                 new DateTime('2013-03-29T04:13:35-0600'),
 819             ),
 820             array(
 821                 new DateTime('2013-03-29T05:13:35-0600'),
 822                 new DateTime('2013-03-29T05:13:35-0500'),
 823             ),
 824             // Exception
 825             //array(new Exception('Exception 1'), new Exception('Exception 2')),
 826             // different types
 827             array(new SampleClass(4, 8, 15), false),
 828             array(false, new SampleClass(4, 8, 15)),
 829             array(array(0        => 1, 1 => 2), false),
 830             array(false, array(0 => 1, 1 => 2)),
 831             array(array(), new stdClass),
 832             array(new stdClass, array()),
 833             // PHP: 0 == 'Foobar' => true!
 834             // We want these values to differ
 835             array(0, 'Foobar'),
 836             array('Foobar', 0),
 837             array(3, acos(8)),
 838             array(acos(8), 3)
 839         );
 840     }
 841
 842     protected function equalValues()
 843     {
 844         // cyclic dependencies
 845         $book1                  = new Book;
 846         $book1->author          = new Author('Terry Pratchett');
 847         $book1->author->books[] = $book1;
 848         $book2                  = new Book;
 849         $book2->author          = new Author('Terry Pratchett');
 850         $book2->author->books[] = $book2;
 851
 852         $object1  = new SampleClass(4, 8, 15);
 853         $object2  = new SampleClass(4, 8, 15);
 854         $storage1 = new SplObjectStorage;
 855         $storage1->attach($object1);
 856         $storage2 = new SplObjectStorage;
 857         $storage2->attach($object1);
 858
 859         return array(
 860             // strings
 861             array('a', 'A', 0, false, true), // ignore case
 862             // arrays
 863             array(array('a' => 1, 'b' => 2), array('b' => 2, 'a' => 1)),
 864             array(array(1), array('1')),
 865             array(array(3, 2, 1), array(2, 3, 1), 0, true), // canonicalized comparison
 866             // floats
 867             array(2.3, 2.5, 0.5),
 868             array(array(2.3), array(2.5), 0.5),
 869             array(array(array(2.3)), array(array(2.5)), 0.5),
 870             array(new Struct(2.3), new Struct(2.5), 0.5),
 871             array(array(new Struct(2.3)), array(new Struct(2.5)), 0.5),
 872             // numeric with delta
 873             array(1, 2, 1),
 874             // objects
 875             array($object1, $object2),
 876             array($book1, $book2),
 877             // SplObjectStorage
 878             array($storage1, $storage2),
 879             // DOMDocument
 880             array(
 881                 PHPUnit_Util_XML::load('<root></root>'),
 882                 PHPUnit_Util_XML::load('<root/>'),
 883             ),
 884             array(
 885                 PHPUnit_Util_XML::load('<root attr="bar"></root>'),
 886                 PHPUnit_Util_XML::load('<root attr="bar"/>'),
 887             ),
 888             array(
 889                 PHPUnit_Util_XML::load('<root><foo attr="bar"></foo></root>'),
 890                 PHPUnit_Util_XML::load('<root><foo attr="bar"/></root>'),
 891             ),
 892             array(
 893                 PHPUnit_Util_XML::load("<root>\n  <child/>\n</root>"),
 894                 PHPUnit_Util_XML::load('<root><child/></root>'),
 895             ),
 896             array(
 897                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 898                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 899             ),
 900             array(
 901                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 902                 new DateTime('2013-03-29 04:13:25', new DateTimeZone('America/New_York')),
 903                 10
 904             ),
 905             array(
 906                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 907                 new DateTime('2013-03-29 04:14:40', new DateTimeZone('America/New_York')),
 908                 65
 909             ),
 910             array(
 911                 new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
 912                 new DateTime('2013-03-29', new DateTimeZone('America/New_York')),
 913             ),
 914             array(
 915                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 916                 new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/Chicago')),
 917             ),
 918             array(
 919                 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')),
 920                 new DateTime('2013-03-29 03:13:49', new DateTimeZone('America/Chicago')),
 921                 15
 922             ),
 923             array(
 924                 new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
 925                 new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')),
 926             ),
 927             array(
 928                 new DateTime('2013-03-30', new DateTimeZone('America/New_York')),
 929                 new DateTime('2013-03-29 23:01:30', new DateTimeZone('America/Chicago')),
 930                 100
 931             ),
 932             array(
 933                 new DateTime('@1364616000'),
 934                 new DateTime('2013-03-29 23:00:00', new DateTimeZone('America/Chicago')),
 935             ),
 936             array(
 937                 new DateTime('2013-03-29T05:13:35-0500'),
 938                 new DateTime('2013-03-29T04:13:35-0600'),
 939             ),
 940             // Exception
 941             //array(new Exception('Exception 1'), new Exception('Exception 1')),
 942             // mixed types
 943             array(0, '0'),
 944             array('0', 0),
 945             array(2.3, '2.3'),
 946             array('2.3', 2.3),
 947             array((string) (1/3), 1 - 2/3),
 948             array(1/3, (string) (1 - 2/3)),
 949             array('string representation', new ClassWithToString),
 950             array(new ClassWithToString, 'string representation'),
 951         );
 952     }
 953
 954     public function equalProvider()
 955     {
 956         // same |= equal
 957         return array_merge($this->equalValues(), $this->sameValues());
 958     }
 959
 960     public function notEqualProvider()
 961     {
 962         return $this->notEqualValues();
 963     }
 964
 965     public function sameProvider()
 966     {
 967         return $this->sameValues();
 968     }
 969
 970     public function notSameProvider()
 971     {
 972         // not equal |= not same
 973         // equal, ¬same |= not same
 974         return array_merge($this->notEqualValues(), $this->equalValues());
 975     }
 976
 977     /**
 978      * @covers PHPUnit_Framework_Assert::assertEquals
 979      * @dataProvider equalProvider
 980      */
 981     public function testAssertEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
 982     {
 983         $this->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
 984     }
 985
 986     /**
 987      * @covers PHPUnit_Framework_Assert::assertEquals
 988      * @dataProvider notEqualProvider
 989      */
 990     public function testAssertEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
 991     {
 992         try {
 993             $this->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
 994         } catch (PHPUnit_Framework_AssertionFailedError $e) {
 995             return;
 996         }
 997
 998         $this->fail();
 999     }
1000
1001     /**
1002      * @covers PHPUnit_Framework_Assert::assertNotEquals
1003      * @dataProvider notEqualProvider
1004      */
1005     public function testAssertNotEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
1006     {
1007         $this->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
1008     }
1009
1010     /**
1011      * @covers PHPUnit_Framework_Assert::assertNotEquals
1012      * @dataProvider equalProvider
1013      */
1014     public function testAssertNotEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false)
1015     {
1016         try {
1017             $this->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);
1018         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1019             return;
1020         }
1021
1022         $this->fail();
1023     }
1024
1025     /**
1026      * @covers PHPUnit_Framework_Assert::assertSame
1027      * @dataProvider sameProvider
1028      */
1029     public function testAssertSameSucceeds($a, $b)
1030     {
1031         $this->assertSame($a, $b);
1032     }
1033
1034     /**
1035      * @covers PHPUnit_Framework_Assert::assertSame
1036      * @dataProvider notSameProvider
1037      */
1038     public function testAssertSameFails($a, $b)
1039     {
1040         try {
1041             $this->assertSame($a, $b);
1042         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1043             return;
1044         }
1045
1046         $this->fail();
1047     }
1048
1049     /**
1050      * @covers PHPUnit_Framework_Assert::assertNotSame
1051      * @dataProvider notSameProvider
1052      */
1053     public function testAssertNotSameSucceeds($a, $b)
1054     {
1055         $this->assertNotSame($a, $b);
1056     }
1057
1058     /**
1059      * @covers PHPUnit_Framework_Assert::assertNotSame
1060      * @dataProvider sameProvider
1061      */
1062     public function testAssertNotSameFails($a, $b)
1063     {
1064         try {
1065             $this->assertNotSame($a, $b);
1066         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1067             return;
1068         }
1069
1070         $this->fail();
1071     }
1072
1073     /**
1074      * @covers PHPUnit_Framework_Assert::assertXmlFileEqualsXmlFile
1075      */
1076     public function testAssertXmlFileEqualsXmlFile()
1077     {
1078         $this->assertXmlFileEqualsXmlFile(
1079             $this->filesDirectory . 'foo.xml',
1080             $this->filesDirectory . 'foo.xml'
1081         );
1082
1083         try {
1084             $this->assertXmlFileEqualsXmlFile(
1085                 $this->filesDirectory . 'foo.xml',
1086                 $this->filesDirectory . 'bar.xml'
1087             );
1088         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1089             return;
1090         }
1091
1092         $this->fail();
1093     }
1094
1095     /**
1096      * @covers PHPUnit_Framework_Assert::assertXmlFileNotEqualsXmlFile
1097      */
1098     public function testAssertXmlFileNotEqualsXmlFile()
1099     {
1100         $this->assertXmlFileNotEqualsXmlFile(
1101             $this->filesDirectory . 'foo.xml',
1102             $this->filesDirectory . 'bar.xml'
1103         );
1104
1105         try {
1106             $this->assertXmlFileNotEqualsXmlFile(
1107                 $this->filesDirectory . 'foo.xml',
1108                 $this->filesDirectory . 'foo.xml'
1109             );
1110         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1111             return;
1112         }
1113
1114         $this->fail();
1115     }
1116
1117     /**
1118      * @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlFile
1119      */
1120     public function testAssertXmlStringEqualsXmlFile()
1121     {
1122         $this->assertXmlStringEqualsXmlFile(
1123             $this->filesDirectory . 'foo.xml',
1124             file_get_contents($this->filesDirectory . 'foo.xml')
1125         );
1126
1127         try {
1128             $this->assertXmlStringEqualsXmlFile(
1129                 $this->filesDirectory . 'foo.xml',
1130                 file_get_contents($this->filesDirectory . 'bar.xml')
1131             );
1132         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1133             return;
1134         }
1135
1136         $this->fail();
1137     }
1138
1139     /**
1140      * @covers PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlFile
1141      */
1142     public function testXmlStringNotEqualsXmlFile()
1143     {
1144         $this->assertXmlStringNotEqualsXmlFile(
1145             $this->filesDirectory . 'foo.xml',
1146             file_get_contents($this->filesDirectory . 'bar.xml')
1147         );
1148
1149         try {
1150             $this->assertXmlStringNotEqualsXmlFile(
1151                 $this->filesDirectory . 'foo.xml',
1152                 file_get_contents($this->filesDirectory . 'foo.xml')
1153             );
1154         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1155             return;
1156         }
1157
1158         $this->fail();
1159     }
1160
1161     /**
1162      * @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString
1163      */
1164     public function testAssertXmlStringEqualsXmlString()
1165     {
1166         $this->assertXmlStringEqualsXmlString('<root/>', '<root/>');
1167
1168         try {
1169             $this->assertXmlStringEqualsXmlString('<foo/>', '<bar/>');
1170         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1171             return;
1172         }
1173
1174         $this->fail();
1175     }
1176
1177     /**
1178      * @expectedException PHPUnit_Framework_Exception
1179      * @covers            PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString
1180      * @ticket            1860
1181      */
1182     public function testAssertXmlStringEqualsXmlString2()
1183     {
1184         $this->assertXmlStringEqualsXmlString('<a></b>', '<c></d>');
1185     }
1186
1187     /**
1188      * @covers PHPUnit_Framework_Assert::assertXmlStringEqualsXmlString
1189      * @ticket 1860
1190      */
1191     public function testAssertXmlStringEqualsXmlString3()
1192     {
1193         $expected = <<<XML
1194 <?xml version="1.0"?>
1195 <root>
1196     <node />
1197 </root>
1198 XML;
1199
1200         $actual = <<<XML
1201 <?xml version="1.0"?>
1202 <root>
1203 <node />
1204 </root>
1205 XML;
1206
1207         $this->assertXmlStringEqualsXmlString($expected, $actual);
1208     }
1209
1210     /**
1211      * @covers PHPUnit_Framework_Assert::assertXmlStringNotEqualsXmlString
1212      */
1213     public function testAssertXmlStringNotEqualsXmlString()
1214     {
1215         $this->assertXmlStringNotEqualsXmlString('<foo/>', '<bar/>');
1216
1217         try {
1218             $this->assertXmlStringNotEqualsXmlString('<root/>', '<root/>');
1219         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1220             return;
1221         }
1222
1223         $this->fail();
1224     }
1225
1226     /**
1227      * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
1228      */
1229     public function testXMLStructureIsSame()
1230     {
1231         $expected = new DOMDocument;
1232         $expected->load($this->filesDirectory . 'structureExpected.xml');
1233
1234         $actual = new DOMDocument;
1235         $actual->load($this->filesDirectory . 'structureExpected.xml');
1236
1237         $this->assertEqualXMLStructure(
1238             $expected->firstChild, $actual->firstChild, true
1239         );
1240     }
1241
1242     /**
1243      * @covers            PHPUnit_Framework_Assert::assertEqualXMLStructure
1244      * @expectedException PHPUnit_Framework_ExpectationFailedException
1245      */
1246     public function testXMLStructureWrongNumberOfAttributes()
1247     {
1248         $expected = new DOMDocument;
1249         $expected->load($this->filesDirectory . 'structureExpected.xml');
1250
1251         $actual = new DOMDocument;
1252         $actual->load($this->filesDirectory . 'structureWrongNumberOfAttributes.xml');
1253
1254         $this->assertEqualXMLStructure(
1255             $expected->firstChild, $actual->firstChild, true
1256         );
1257     }
1258
1259     /**
1260      * @covers            PHPUnit_Framework_Assert::assertEqualXMLStructure
1261      * @expectedException PHPUnit_Framework_ExpectationFailedException
1262      */
1263     public function testXMLStructureWrongNumberOfNodes()
1264     {
1265         $expected = new DOMDocument;
1266         $expected->load($this->filesDirectory . 'structureExpected.xml');
1267
1268         $actual = new DOMDocument;
1269         $actual->load($this->filesDirectory . 'structureWrongNumberOfNodes.xml');
1270
1271         $this->assertEqualXMLStructure(
1272             $expected->firstChild, $actual->firstChild, true
1273         );
1274     }
1275
1276     /**
1277      * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
1278      */
1279     public function testXMLStructureIsSameButDataIsNot()
1280     {
1281         $expected = new DOMDocument;
1282         $expected->load($this->filesDirectory . 'structureExpected.xml');
1283
1284         $actual = new DOMDocument;
1285         $actual->load($this->filesDirectory . 'structureIsSameButDataIsNot.xml');
1286
1287         $this->assertEqualXMLStructure(
1288             $expected->firstChild, $actual->firstChild, true
1289         );
1290     }
1291
1292     /**
1293      * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
1294      */
1295     public function testXMLStructureAttributesAreSameButValuesAreNot()
1296     {
1297         $expected = new DOMDocument;
1298         $expected->load($this->filesDirectory . 'structureExpected.xml');
1299
1300         $actual = new DOMDocument;
1301         $actual->load($this->filesDirectory . 'structureAttributesAreSameButValuesAreNot.xml');
1302
1303         $this->assertEqualXMLStructure(
1304             $expected->firstChild, $actual->firstChild, true
1305         );
1306     }
1307
1308     /**
1309      * @covers PHPUnit_Framework_Assert::assertEqualXMLStructure
1310      */
1311     public function testXMLStructureIgnoreTextNodes()
1312     {
1313         $expected = new DOMDocument;
1314         $expected->load($this->filesDirectory . 'structureExpected.xml');
1315
1316         $actual = new DOMDocument;
1317         $actual->load($this->filesDirectory . 'structureIgnoreTextNodes.xml');
1318
1319         $this->assertEqualXMLStructure(
1320             $expected->firstChild, $actual->firstChild, true
1321         );
1322     }
1323
1324     /**
1325      * @covers PHPUnit_Framework_Assert::assertEquals
1326      */
1327     public function testAssertStringEqualsNumeric()
1328     {
1329         $this->assertEquals('0', 0);
1330
1331         try {
1332             $this->assertEquals('0', 1);
1333         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1334             return;
1335         }
1336
1337         $this->fail();
1338     }
1339
1340     /**
1341      * @covers PHPUnit_Framework_Assert::assertNotEquals
1342      */
1343     public function testAssertStringEqualsNumeric2()
1344     {
1345         $this->assertNotEquals('A', 0);
1346     }
1347
1348     /**
1349      * @covers            PHPUnit_Framework_Assert::assertFileExists
1350      * @expectedException PHPUnit_Framework_Exception
1351      */
1352     public function testAssertFileExistsThrowsException()
1353     {
1354         $this->assertFileExists(null);
1355     }
1356
1357     /**
1358      * @covers PHPUnit_Framework_Assert::assertFileExists
1359      */
1360     public function testAssertFileExists()
1361     {
1362         $this->assertFileExists(__FILE__);
1363
1364         try {
1365             $this->assertFileExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1366         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1367             return;
1368         }
1369
1370         $this->fail();
1371     }
1372
1373     /**
1374      * @covers            PHPUnit_Framework_Assert::assertFileNotExists
1375      * @expectedException PHPUnit_Framework_Exception
1376      */
1377     public function testAssertFileNotExistsThrowsException()
1378     {
1379         $this->assertFileNotExists(null);
1380     }
1381
1382     /**
1383      * @covers PHPUnit_Framework_Assert::assertFileNotExists
1384      */
1385     public function testAssertFileNotExists()
1386     {
1387         $this->assertFileNotExists(__DIR__ . DIRECTORY_SEPARATOR . 'NotExisting');
1388
1389         try {
1390             $this->assertFileNotExists(__FILE__);
1391         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1392             return;
1393         }
1394
1395         $this->fail();
1396     }
1397
1398     /**
1399      * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
1400      */
1401     public function testAssertObjectHasAttribute()
1402     {
1403         $o = new Author('Terry Pratchett');
1404
1405         $this->assertObjectHasAttribute('name', $o);
1406
1407         try {
1408             $this->assertObjectHasAttribute('foo', $o);
1409         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1410             return;
1411         }
1412
1413         $this->fail();
1414     }
1415
1416     /**
1417      * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
1418      */
1419     public function testAssertObjectNotHasAttribute()
1420     {
1421         $o = new Author('Terry Pratchett');
1422
1423         $this->assertObjectNotHasAttribute('foo', $o);
1424
1425         try {
1426             $this->assertObjectNotHasAttribute('name', $o);
1427         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1428             return;
1429         }
1430
1431         $this->fail();
1432     }
1433
1434     /**
1435      * @covers PHPUnit_Framework_Assert::assertNull
1436      */
1437     public function testAssertNull()
1438     {
1439         $this->assertNull(null);
1440
1441         try {
1442             $this->assertNull(new stdClass);
1443         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1444             return;
1445         }
1446
1447         $this->fail();
1448     }
1449
1450     /**
1451      * @covers PHPUnit_Framework_Assert::assertNotNull
1452      */
1453     public function testAssertNotNull()
1454     {
1455         $this->assertNotNull(new stdClass);
1456
1457         try {
1458             $this->assertNotNull(null);
1459         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1460             return;
1461         }
1462
1463         $this->fail();
1464     }
1465
1466     /**
1467      * @covers PHPUnit_Framework_Assert::assertTrue
1468      */
1469     public function testAssertTrue()
1470     {
1471         $this->assertTrue(true);
1472
1473         try {
1474             $this->assertTrue(false);
1475         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1476             return;
1477         }
1478
1479         $this->fail();
1480     }
1481
1482     /**
1483      * @covers PHPUnit_Framework_Assert::assertNotTrue
1484      */
1485     public function testAssertNotTrue()
1486     {
1487         $this->assertNotTrue(false);
1488         $this->assertNotTrue(1);
1489         $this->assertNotTrue('true');
1490
1491         try {
1492             $this->assertNotTrue(true);
1493         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1494             return;
1495         }
1496
1497         $this->fail();
1498     }
1499
1500     /**
1501      * @covers PHPUnit_Framework_Assert::assertFalse
1502      */
1503     public function testAssertFalse()
1504     {
1505         $this->assertFalse(false);
1506
1507         try {
1508             $this->assertFalse(true);
1509         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1510             return;
1511         }
1512
1513         $this->fail();
1514     }
1515
1516     /**
1517      * @covers PHPUnit_Framework_Assert::assertNotFalse
1518      */
1519     public function testAssertNotFalse()
1520     {
1521         $this->assertNotFalse(true);
1522         $this->assertNotFalse(0);
1523         $this->assertNotFalse('');
1524
1525         try {
1526             $this->assertNotFalse(false);
1527         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1528             return;
1529         }
1530
1531         $this->fail();
1532     }
1533
1534     /**
1535      * @covers            PHPUnit_Framework_Assert::assertRegExp
1536      * @expectedException PHPUnit_Framework_Exception
1537      */
1538     public function testAssertRegExpThrowsException()
1539     {
1540         $this->assertRegExp(null, null);
1541     }
1542
1543     /**
1544      * @covers            PHPUnit_Framework_Assert::assertRegExp
1545      * @expectedException PHPUnit_Framework_Exception
1546      */
1547     public function testAssertRegExpThrowsException2()
1548     {
1549         $this->assertRegExp('', null);
1550     }
1551
1552     /**
1553      * @covers            PHPUnit_Framework_Assert::assertNotRegExp
1554      * @expectedException PHPUnit_Framework_Exception
1555      */
1556     public function testAssertNotRegExpThrowsException()
1557     {
1558         $this->assertNotRegExp(null, null);
1559     }
1560
1561     /**
1562      * @covers            PHPUnit_Framework_Assert::assertNotRegExp
1563      * @expectedException PHPUnit_Framework_Exception
1564      */
1565     public function testAssertNotRegExpThrowsException2()
1566     {
1567         $this->assertNotRegExp('', null);
1568     }
1569
1570     /**
1571      * @covers PHPUnit_Framework_Assert::assertRegExp
1572      */
1573     public function testAssertRegExp()
1574     {
1575         $this->assertRegExp('/foo/', 'foobar');
1576
1577         try {
1578             $this->assertRegExp('/foo/', 'bar');
1579         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1580             return;
1581         }
1582
1583         $this->fail();
1584     }
1585
1586     /**
1587      * @covers PHPUnit_Framework_Assert::assertNotRegExp
1588      */
1589     public function testAssertNotRegExp()
1590     {
1591         $this->assertNotRegExp('/foo/', 'bar');
1592
1593         try {
1594             $this->assertNotRegExp('/foo/', 'foobar');
1595         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1596             return;
1597         }
1598
1599         $this->fail();
1600     }
1601
1602     /**
1603      * @covers PHPUnit_Framework_Assert::assertSame
1604      */
1605     public function testAssertSame()
1606     {
1607         $o = new stdClass;
1608
1609         $this->assertSame($o, $o);
1610
1611         try {
1612             $this->assertSame(
1613                 new stdClass,
1614                 new stdClass
1615             );
1616         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1617             return;
1618         }
1619
1620         $this->fail();
1621     }
1622
1623     /**
1624      * @covers PHPUnit_Framework_Assert::assertSame
1625      */
1626     public function testAssertSame2()
1627     {
1628         $this->assertSame(true, true);
1629         $this->assertSame(false, false);
1630
1631         try {
1632             $this->assertSame(true, false);
1633         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1634             return;
1635         }
1636
1637         $this->fail();
1638     }
1639
1640     /**
1641      * @covers PHPUnit_Framework_Assert::assertNotSame
1642      */
1643     public function testAssertNotSame()
1644     {
1645         $this->assertNotSame(
1646             new stdClass,
1647             null
1648         );
1649
1650         $this->assertNotSame(
1651             null,
1652             new stdClass
1653         );
1654
1655         $this->assertNotSame(
1656             new stdClass,
1657             new stdClass
1658         );
1659
1660         $o = new stdClass;
1661
1662         try {
1663             $this->assertNotSame($o, $o);
1664         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1665             return;
1666         }
1667
1668         $this->fail();
1669     }
1670
1671     /**
1672      * @covers PHPUnit_Framework_Assert::assertNotSame
1673      */
1674     public function testAssertNotSame2()
1675     {
1676         $this->assertNotSame(true, false);
1677         $this->assertNotSame(false, true);
1678
1679         try {
1680             $this->assertNotSame(true, true);
1681         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1682             return;
1683         }
1684
1685         $this->fail();
1686     }
1687
1688     /**
1689      * @covers PHPUnit_Framework_Assert::assertNotSame
1690      */
1691     public function testAssertNotSameFailsNull()
1692     {
1693         try {
1694             $this->assertNotSame(null, null);
1695         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1696             return;
1697         }
1698
1699         $this->fail();
1700     }
1701
1702     /**
1703      * @covers PHPUnit_Framework_Assert::assertGreaterThan
1704      */
1705     public function testGreaterThan()
1706     {
1707         $this->assertGreaterThan(1, 2);
1708
1709         try {
1710             $this->assertGreaterThan(2, 1);
1711         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1712             return;
1713         }
1714
1715         $this->fail();
1716     }
1717
1718     /**
1719      * @covers PHPUnit_Framework_Assert::assertAttributeGreaterThan
1720      */
1721     public function testAttributeGreaterThan()
1722     {
1723         $this->assertAttributeGreaterThan(
1724             1, 'bar', new ClassWithNonPublicAttributes
1725         );
1726
1727         try {
1728             $this->assertAttributeGreaterThan(
1729                 1, 'foo', new ClassWithNonPublicAttributes
1730             );
1731         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1732             return;
1733         }
1734
1735         $this->fail();
1736     }
1737
1738     /**
1739      * @covers PHPUnit_Framework_Assert::assertGreaterThanOrEqual
1740      */
1741     public function testGreaterThanOrEqual()
1742     {
1743         $this->assertGreaterThanOrEqual(1, 2);
1744
1745         try {
1746             $this->assertGreaterThanOrEqual(2, 1);
1747         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1748             return;
1749         }
1750
1751         $this->fail();
1752     }
1753
1754     /**
1755      * @covers PHPUnit_Framework_Assert::assertAttributeGreaterThanOrEqual
1756      */
1757     public function testAttributeGreaterThanOrEqual()
1758     {
1759         $this->assertAttributeGreaterThanOrEqual(
1760             1, 'bar', new ClassWithNonPublicAttributes
1761         );
1762
1763         try {
1764             $this->assertAttributeGreaterThanOrEqual(
1765                 2, 'foo', new ClassWithNonPublicAttributes
1766             );
1767         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1768             return;
1769         }
1770
1771         $this->fail();
1772     }
1773
1774     /**
1775      * @covers PHPUnit_Framework_Assert::assertLessThan
1776      */
1777     public function testLessThan()
1778     {
1779         $this->assertLessThan(2, 1);
1780
1781         try {
1782             $this->assertLessThan(1, 2);
1783         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1784             return;
1785         }
1786
1787         $this->fail();
1788     }
1789
1790     /**
1791      * @covers PHPUnit_Framework_Assert::assertAttributeLessThan
1792      */
1793     public function testAttributeLessThan()
1794     {
1795         $this->assertAttributeLessThan(
1796             2, 'foo', new ClassWithNonPublicAttributes
1797         );
1798
1799         try {
1800             $this->assertAttributeLessThan(
1801                 1, 'bar', new ClassWithNonPublicAttributes
1802             );
1803         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1804             return;
1805         }
1806
1807         $this->fail();
1808     }
1809
1810     /**
1811      * @covers PHPUnit_Framework_Assert::assertLessThanOrEqual
1812      */
1813     public function testLessThanOrEqual()
1814     {
1815         $this->assertLessThanOrEqual(2, 1);
1816
1817         try {
1818             $this->assertLessThanOrEqual(1, 2);
1819         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1820             return;
1821         }
1822
1823         $this->fail();
1824     }
1825
1826     /**
1827      * @covers PHPUnit_Framework_Assert::assertAttributeLessThanOrEqual
1828      */
1829     public function testAttributeLessThanOrEqual()
1830     {
1831         $this->assertAttributeLessThanOrEqual(
1832             2, 'foo', new ClassWithNonPublicAttributes
1833         );
1834
1835         try {
1836             $this->assertAttributeLessThanOrEqual(
1837                 1, 'bar', new ClassWithNonPublicAttributes
1838             );
1839         } catch (PHPUnit_Framework_AssertionFailedError $e) {
1840             return;
1841         }
1842
1843         $this->fail();
1844     }
1845
1846     /**
1847      * @covers PHPUnit_Framework_Assert::readAttribute
1848      * @covers PHPUnit_Framework_Assert::getStaticAttribute
1849      * @covers PHPUnit_Framework_Assert::getObjectAttribute
1850      */
1851     public function testReadAttribute()
1852     {
1853         $obj = new ClassWithNonPublicAttributes;
1854
1855         $this->assertEquals('foo', $this->readAttribute($obj, 'publicAttribute'));
1856         $this->assertEquals('bar', $this->readAttribute($obj, 'protectedAttribute'));
1857         $this->assertEquals('baz', $this->readAttribute($obj, 'privateAttribute'));
1858         $this->assertEquals('bar', $this->readAttribute($obj, 'protectedParentAttribute'));
1859         //$this->assertEquals('bar', $this->readAttribute($obj, 'privateParentAttribute'));
1860     }
1861
1862     /**
1863      * @covers PHPUnit_Framework_Assert::readAttribute
1864      * @covers PHPUnit_Framework_Assert::getStaticAttribute
1865      * @covers PHPUnit_Framework_Assert::getObjectAttribute
1866      */
1867     public function testReadAttribute2()
1868     {
1869         $this->assertEquals('foo', $this->readAttribute('ClassWithNonPublicAttributes', 'publicStaticAttribute'));
1870         $this->assertEquals('bar', $this->readAttribute('ClassWithNonPublicAttributes', 'protectedStaticAttribute'));
1871         $this->assertEquals('baz', $this->readAttribute('ClassWithNonPublicAttributes', 'privateStaticAttribute'));
1872         $this->assertEquals('foo', $this->readAttribute('ClassWithNonPublicAttributes', 'protectedStaticParentAttribute'));
1873         $this->assertEquals('foo', $this->readAttribute('ClassWithNonPublicAttributes', 'privateStaticParentAttribute'));
1874     }
1875
1876     /**
1877      * @covers            PHPUnit_Framework_Assert::readAttribute
1878      * @covers            PHPUnit_Framework_Assert::getStaticAttribute
1879      * @covers            PHPUnit_Framework_Assert::getObjectAttribute
1880      * @expectedException PHPUnit_Framework_Exception
1881      */
1882     public function testReadAttribute3()
1883     {
1884         $this->readAttribute('StdClass', null);
1885     }
1886
1887     /**
1888      * @covers            PHPUnit_Framework_Assert::readAttribute
1889      * @covers            PHPUnit_Framework_Assert::getStaticAttribute
1890      * @covers            PHPUnit_Framework_Assert::getObjectAttribute
1891      * @expectedException PHPUnit_Framework_Exception
1892      */
1893     public function testReadAttribute4()
1894     {
1895         $this->readAttribute('NotExistingClass', 'foo');
1896     }
1897
1898     /**
1899      * @covers            PHPUnit_Framework_Assert::readAttribute
1900      * @covers            PHPUnit_Framework_Assert::getStaticAttribute
1901      * @covers            PHPUnit_Framework_Assert::getObjectAttribute
1902      * @expectedException PHPUnit_Framework_Exception
1903      */
1904     public function testReadAttribute5()
1905     {
1906         $this->readAttribute(null, 'foo');
1907     }
1908
1909     /**
1910      * @covers            PHPUnit_Framework_Assert::readAttribute
1911      * @covers            PHPUnit_Framework_Assert::getStaticAttribute
1912      * @covers            PHPUnit_Framework_Assert::getObjectAttribute
1913      * @expectedException PHPUnit_Framework_Exception
1914      */
1915     public function testReadAttributeIfAttributeNameIsNotValid()
1916     {
1917         $this->readAttribute('StdClass', '2');
1918     }
1919
1920     /**
1921      * @covers PHPUnit_Framework_Assert::getStaticAttribute
1922      * @expectedException PHPUnit_Framework_Exception
1923      */
1924     public function testGetStaticAttributeRaisesExceptionForInvalidFirstArgument()
1925     {
1926         $this->getStaticAttribute(null, 'foo');
1927     }
1928
1929     /**
1930      * @covers PHPUnit_Framework_Assert::getStaticAttribute
1931      * @expectedException PHPUnit_Framework_Exception
1932      */
1933     public function testGetStaticAttributeRaisesExceptionForInvalidFirstArgument2()
1934     {
1935         $this->getStaticAttribute('NotExistingClass', 'foo');
1936     }
1937
1938     /**
1939      * @covers PHPUnit_Framework_Assert::getStaticAttribute
1940      * @expectedException PHPUnit_Framework_Exception
1941      */
1942     public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument()
1943     {
1944         $this->getStaticAttribute('stdClass', null);
1945     }
1946
1947     /**
1948      * @covers PHPUnit_Framework_Assert::getStaticAttribute
1949      * @expectedException PHPUnit_Framework_Exception
1950      */
1951     public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument2()
1952     {
1953         $this->getStaticAttribute('stdClass', '0');
1954     }
1955
1956     /**
1957      * @covers PHPUnit_Framework_Assert::getStaticAttribute
1958      * @expectedException PHPUnit_Framework_Exception
1959      */
1960     public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument3()
1961     {
1962         $this->getStaticAttribute('stdClass', 'foo');
1963     }
1964
1965     /**
1966      * @covers PHPUnit_Framework_Assert::getObjectAttribute
1967      * @expectedException PHPUnit_Framework_Exception
1968      */
1969     public function testGetObjectAttributeRaisesExceptionForInvalidFirstArgument()
1970     {
1971         $this->getObjectAttribute(null, 'foo');
1972     }
1973
1974     /**
1975      * @covers PHPUnit_Framework_Assert::getObjectAttribute
1976      * @expectedException PHPUnit_Framework_Exception
1977      */
1978     public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument()
1979     {
1980         $this->getObjectAttribute(new stdClass, null);
1981     }
1982
1983     /**
1984      * @covers PHPUnit_Framework_Assert::getObjectAttribute
1985      * @expectedException PHPUnit_Framework_Exception
1986      */
1987     public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument2()
1988     {
1989         $this->getObjectAttribute(new stdClass, '0');
1990     }
1991
1992     /**
1993      * @covers PHPUnit_Framework_Assert::getObjectAttribute
1994      * @expectedException PHPUnit_Framework_Exception
1995      */
1996     public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument3()
1997     {
1998         $this->getObjectAttribute(new stdClass, 'foo');
1999     }
2000
2001     /**
2002      * @covers PHPUnit_Framework_Assert::getObjectAttribute
2003      */
2004     public function testGetObjectAttributeWorksForInheritedAttributes()
2005     {
2006         $this->assertEquals(
2007             'bar',
2008             $this->getObjectAttribute(new ClassWithNonPublicAttributes, 'privateParentAttribute')
2009         );
2010     }
2011
2012     /**
2013      * @covers PHPUnit_Framework_Assert::assertAttributeContains
2014      */
2015     public function testAssertPublicAttributeContains()
2016     {
2017         $obj = new ClassWithNonPublicAttributes;
2018
2019         $this->assertAttributeContains('foo', 'publicArray', $obj);
2020
2021         try {
2022             $this->assertAttributeContains('bar', 'publicArray', $obj);
2023         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2024             return;
2025         }
2026
2027         $this->fail();
2028     }
2029
2030     /**
2031      * @covers PHPUnit_Framework_Assert::assertAttributeContainsOnly
2032      */
2033     public function testAssertPublicAttributeContainsOnly()
2034     {
2035         $obj = new ClassWithNonPublicAttributes;
2036
2037         $this->assertAttributeContainsOnly('string', 'publicArray', $obj);
2038
2039         try {
2040             $this->assertAttributeContainsOnly('integer', 'publicArray', $obj);
2041         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2042             return;
2043         }
2044
2045         $this->fail();
2046     }
2047
2048     /**
2049      * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
2050      */
2051     public function testAssertPublicAttributeNotContains()
2052     {
2053         $obj = new ClassWithNonPublicAttributes;
2054
2055         $this->assertAttributeNotContains('bar', 'publicArray', $obj);
2056
2057         try {
2058             $this->assertAttributeNotContains('foo', 'publicArray', $obj);
2059         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2060             return;
2061         }
2062
2063         $this->fail();
2064     }
2065
2066     /**
2067      * @covers PHPUnit_Framework_Assert::assertAttributeNotContainsOnly
2068      */
2069     public function testAssertPublicAttributeNotContainsOnly()
2070     {
2071         $obj = new ClassWithNonPublicAttributes;
2072
2073         $this->assertAttributeNotContainsOnly('integer', 'publicArray', $obj);
2074
2075         try {
2076             $this->assertAttributeNotContainsOnly('string', 'publicArray', $obj);
2077         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2078             return;
2079         }
2080
2081         $this->fail();
2082     }
2083
2084     /**
2085      * @covers PHPUnit_Framework_Assert::assertAttributeContains
2086      */
2087     public function testAssertProtectedAttributeContains()
2088     {
2089         $obj = new ClassWithNonPublicAttributes;
2090
2091         $this->assertAttributeContains('bar', 'protectedArray', $obj);
2092
2093         try {
2094             $this->assertAttributeContains('foo', 'protectedArray', $obj);
2095         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2096             return;
2097         }
2098
2099         $this->fail();
2100     }
2101
2102     /**
2103      * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
2104      */
2105     public function testAssertProtectedAttributeNotContains()
2106     {
2107         $obj = new ClassWithNonPublicAttributes;
2108
2109         $this->assertAttributeNotContains('foo', 'protectedArray', $obj);
2110
2111         try {
2112             $this->assertAttributeNotContains('bar', 'protectedArray', $obj);
2113         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2114             return;
2115         }
2116
2117         $this->fail();
2118     }
2119
2120     /**
2121      * @covers PHPUnit_Framework_Assert::assertAttributeContains
2122      */
2123     public function testAssertPrivateAttributeContains()
2124     {
2125         $obj = new ClassWithNonPublicAttributes;
2126
2127         $this->assertAttributeContains('baz', 'privateArray', $obj);
2128
2129         try {
2130             $this->assertAttributeContains('foo', 'privateArray', $obj);
2131         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2132             return;
2133         }
2134
2135         $this->fail();
2136     }
2137
2138     /**
2139      * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
2140      */
2141     public function testAssertPrivateAttributeNotContains()
2142     {
2143         $obj = new ClassWithNonPublicAttributes;
2144
2145         $this->assertAttributeNotContains('foo', 'privateArray', $obj);
2146
2147         try {
2148             $this->assertAttributeNotContains('baz', 'privateArray', $obj);
2149         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2150             return;
2151         }
2152
2153         $this->fail();
2154     }
2155
2156     /**
2157      * @covers PHPUnit_Framework_Assert::assertAttributeContains
2158      */
2159     public function testAssertAttributeContainsNonObject()
2160     {
2161         $obj = new ClassWithNonPublicAttributes;
2162
2163         $this->assertAttributeContains(true, 'privateArray', $obj);
2164
2165         try {
2166             $this->assertAttributeContains(true, 'privateArray', $obj, '', false, true, true);
2167         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2168             return;
2169         }
2170
2171         $this->fail();
2172     }
2173
2174     /**
2175      * @covers PHPUnit_Framework_Assert::assertAttributeNotContains
2176      */
2177     public function testAssertAttributeNotContainsNonObject()
2178     {
2179         $obj = new ClassWithNonPublicAttributes;
2180
2181         $this->assertAttributeNotContains(true, 'privateArray', $obj, '', false, true, true);
2182
2183         try {
2184             $this->assertAttributeNotContains(true, 'privateArray', $obj);
2185         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2186             return;
2187         }
2188
2189         $this->fail();
2190     }
2191
2192     /**
2193      * @covers PHPUnit_Framework_Assert::assertAttributeEquals
2194      */
2195     public function testAssertPublicAttributeEquals()
2196     {
2197         $obj = new ClassWithNonPublicAttributes;
2198
2199         $this->assertAttributeEquals('foo', 'publicAttribute', $obj);
2200
2201         try {
2202             $this->assertAttributeEquals('bar', 'publicAttribute', $obj);
2203         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2204             return;
2205         }
2206
2207         $this->fail();
2208     }
2209
2210     /**
2211      * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
2212      */
2213     public function testAssertPublicAttributeNotEquals()
2214     {
2215         $obj = new ClassWithNonPublicAttributes;
2216
2217         $this->assertAttributeNotEquals('bar', 'publicAttribute', $obj);
2218
2219         try {
2220             $this->assertAttributeNotEquals('foo', 'publicAttribute', $obj);
2221         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2222             return;
2223         }
2224
2225         $this->fail();
2226     }
2227
2228     /**
2229      * @covers PHPUnit_Framework_Assert::assertAttributeSame
2230      */
2231     public function testAssertPublicAttributeSame()
2232     {
2233         $obj = new ClassWithNonPublicAttributes;
2234
2235         $this->assertAttributeSame('foo', 'publicAttribute', $obj);
2236
2237         try {
2238             $this->assertAttributeSame('bar', 'publicAttribute', $obj);
2239         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2240             return;
2241         }
2242
2243         $this->fail();
2244     }
2245
2246     /**
2247      * @covers PHPUnit_Framework_Assert::assertAttributeNotSame
2248      */
2249     public function testAssertPublicAttributeNotSame()
2250     {
2251         $obj = new ClassWithNonPublicAttributes;
2252
2253         $this->assertAttributeNotSame('bar', 'publicAttribute', $obj);
2254
2255         try {
2256             $this->assertAttributeNotSame('foo', 'publicAttribute', $obj);
2257         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2258             return;
2259         }
2260
2261         $this->fail();
2262     }
2263
2264     /**
2265      * @covers PHPUnit_Framework_Assert::assertAttributeEquals
2266      */
2267     public function testAssertProtectedAttributeEquals()
2268     {
2269         $obj = new ClassWithNonPublicAttributes;
2270
2271         $this->assertAttributeEquals('bar', 'protectedAttribute', $obj);
2272
2273         try {
2274             $this->assertAttributeEquals('foo', 'protectedAttribute', $obj);
2275         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2276             return;
2277         }
2278
2279         $this->fail();
2280     }
2281
2282     /**
2283      * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
2284      */
2285     public function testAssertProtectedAttributeNotEquals()
2286     {
2287         $obj = new ClassWithNonPublicAttributes;
2288
2289         $this->assertAttributeNotEquals('foo', 'protectedAttribute', $obj);
2290
2291         try {
2292             $this->assertAttributeNotEquals('bar', 'protectedAttribute', $obj);
2293         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2294             return;
2295         }
2296
2297         $this->fail();
2298     }
2299
2300     /**
2301      * @covers PHPUnit_Framework_Assert::assertAttributeEquals
2302      */
2303     public function testAssertPrivateAttributeEquals()
2304     {
2305         $obj = new ClassWithNonPublicAttributes;
2306
2307         $this->assertAttributeEquals('baz', 'privateAttribute', $obj);
2308
2309         try {
2310             $this->assertAttributeEquals('foo', 'privateAttribute', $obj);
2311         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2312             return;
2313         }
2314
2315         $this->fail();
2316     }
2317
2318     /**
2319      * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
2320      */
2321     public function testAssertPrivateAttributeNotEquals()
2322     {
2323         $obj = new ClassWithNonPublicAttributes;
2324
2325         $this->assertAttributeNotEquals('foo', 'privateAttribute', $obj);
2326
2327         try {
2328             $this->assertAttributeNotEquals('baz', 'privateAttribute', $obj);
2329         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2330             return;
2331         }
2332
2333         $this->fail();
2334     }
2335
2336     /**
2337      * @covers PHPUnit_Framework_Assert::assertAttributeEquals
2338      */
2339     public function testAssertPublicStaticAttributeEquals()
2340     {
2341         $this->assertAttributeEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2342
2343         try {
2344             $this->assertAttributeEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2345         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2346             return;
2347         }
2348
2349         $this->fail();
2350     }
2351
2352     /**
2353      * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
2354      */
2355     public function testAssertPublicStaticAttributeNotEquals()
2356     {
2357         $this->assertAttributeNotEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2358
2359         try {
2360             $this->assertAttributeNotEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
2361         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2362             return;
2363         }
2364
2365         $this->fail();
2366     }
2367
2368     /**
2369      * @covers PHPUnit_Framework_Assert::assertAttributeEquals
2370      */
2371     public function testAssertProtectedStaticAttributeEquals()
2372     {
2373         $this->assertAttributeEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2374
2375         try {
2376             $this->assertAttributeEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2377         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2378             return;
2379         }
2380
2381         $this->fail();
2382     }
2383
2384     /**
2385      * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
2386      */
2387     public function testAssertProtectedStaticAttributeNotEquals()
2388     {
2389         $this->assertAttributeNotEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2390
2391         try {
2392             $this->assertAttributeNotEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
2393         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2394             return;
2395         }
2396
2397         $this->fail();
2398     }
2399
2400     /**
2401      * @covers PHPUnit_Framework_Assert::assertAttributeEquals
2402      */
2403     public function testAssertPrivateStaticAttributeEquals()
2404     {
2405         $this->assertAttributeEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2406
2407         try {
2408             $this->assertAttributeEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2409         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2410             return;
2411         }
2412
2413         $this->fail();
2414     }
2415
2416     /**
2417      * @covers PHPUnit_Framework_Assert::assertAttributeNotEquals
2418      */
2419     public function testAssertPrivateStaticAttributeNotEquals()
2420     {
2421         $this->assertAttributeNotEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2422
2423         try {
2424             $this->assertAttributeNotEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
2425         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2426             return;
2427         }
2428
2429         $this->fail();
2430     }
2431
2432     /**
2433      * @covers            PHPUnit_Framework_Assert::assertClassHasAttribute
2434      * @expectedException PHPUnit_Framework_Exception
2435      */
2436     public function testAssertClassHasAttributeThrowsException()
2437     {
2438         $this->assertClassHasAttribute(null, null);
2439     }
2440
2441     /**
2442      * @covers            PHPUnit_Framework_Assert::assertClassHasAttribute
2443      * @expectedException PHPUnit_Framework_Exception
2444      */
2445     public function testAssertClassHasAttributeThrowsException2()
2446     {
2447         $this->assertClassHasAttribute('foo', null);
2448     }
2449
2450     /**
2451      * @covers            PHPUnit_Framework_Assert::assertClassHasAttribute
2452      * @expectedException PHPUnit_Framework_Exception
2453      */
2454     public function testAssertClassHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2455     {
2456         $this->assertClassHasAttribute('1', 'ClassWithNonPublicAttributes');
2457     }
2458
2459     /**
2460      * @covers            PHPUnit_Framework_Assert::assertClassNotHasAttribute
2461      * @expectedException PHPUnit_Framework_Exception
2462      */
2463     public function testAssertClassNotHasAttributeThrowsException()
2464     {
2465         $this->assertClassNotHasAttribute(null, null);
2466     }
2467
2468     /**
2469      * @covers            PHPUnit_Framework_Assert::assertClassNotHasAttribute
2470      * @expectedException PHPUnit_Framework_Exception
2471      */
2472     public function testAssertClassNotHasAttributeThrowsException2()
2473     {
2474         $this->assertClassNotHasAttribute('foo', null);
2475     }
2476
2477     /**
2478      * @covers            PHPUnit_Framework_Assert::assertClassNotHasAttribute
2479      * @expectedException PHPUnit_Framework_Exception
2480      */
2481     public function testAssertClassNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2482     {
2483         $this->assertClassNotHasAttribute('1', 'ClassWithNonPublicAttributes');
2484     }
2485
2486     /**
2487      * @covers            PHPUnit_Framework_Assert::assertClassHasStaticAttribute
2488      * @expectedException PHPUnit_Framework_Exception
2489      */
2490     public function testAssertClassHasStaticAttributeThrowsException()
2491     {
2492         $this->assertClassHasStaticAttribute(null, null);
2493     }
2494
2495     /**
2496      * @covers            PHPUnit_Framework_Assert::assertClassHasStaticAttribute
2497      * @expectedException PHPUnit_Framework_Exception
2498      */
2499     public function testAssertClassHasStaticAttributeThrowsException2()
2500     {
2501         $this->assertClassHasStaticAttribute('foo', null);
2502     }
2503
2504     /**
2505      * @covers            PHPUnit_Framework_Assert::assertClassHasStaticAttribute
2506      * @expectedException PHPUnit_Framework_Exception
2507      */
2508     public function testAssertClassHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid()
2509     {
2510         $this->assertClassHasStaticAttribute('1', 'ClassWithNonPublicAttributes');
2511     }
2512
2513     /**
2514      * @covers            PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
2515      * @expectedException PHPUnit_Framework_Exception
2516      */
2517     public function testAssertClassNotHasStaticAttributeThrowsException()
2518     {
2519         $this->assertClassNotHasStaticAttribute(null, null);
2520     }
2521
2522     /**
2523      * @covers            PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
2524      * @expectedException PHPUnit_Framework_Exception
2525      */
2526     public function testAssertClassNotHasStaticAttributeThrowsException2()
2527     {
2528         $this->assertClassNotHasStaticAttribute('foo', null);
2529     }
2530
2531     /**
2532      * @covers            PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
2533      * @expectedException PHPUnit_Framework_Exception
2534      */
2535     public function testAssertClassNotHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid()
2536     {
2537         $this->assertClassNotHasStaticAttribute('1', 'ClassWithNonPublicAttributes');
2538     }
2539
2540     /**
2541      * @covers            PHPUnit_Framework_Assert::assertObjectHasAttribute
2542      * @expectedException PHPUnit_Framework_Exception
2543      */
2544     public function testAssertObjectHasAttributeThrowsException()
2545     {
2546         $this->assertObjectHasAttribute(null, null);
2547     }
2548
2549     /**
2550      * @covers            PHPUnit_Framework_Assert::assertObjectHasAttribute
2551      * @expectedException PHPUnit_Framework_Exception
2552      */
2553     public function testAssertObjectHasAttributeThrowsException2()
2554     {
2555         $this->assertObjectHasAttribute('foo', null);
2556     }
2557
2558     /**
2559      * @covers            PHPUnit_Framework_Assert::assertObjectHasAttribute
2560      * @expectedException PHPUnit_Framework_Exception
2561      */
2562     public function testAssertObjectHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2563     {
2564         $this->assertObjectHasAttribute('1', 'ClassWithNonPublicAttributes');
2565     }
2566
2567     /**
2568      * @covers            PHPUnit_Framework_Assert::assertObjectNotHasAttribute
2569      * @expectedException PHPUnit_Framework_Exception
2570      */
2571     public function testAssertObjectNotHasAttributeThrowsException()
2572     {
2573         $this->assertObjectNotHasAttribute(null, null);
2574     }
2575
2576     /**
2577      * @covers            PHPUnit_Framework_Assert::assertObjectNotHasAttribute
2578      * @expectedException PHPUnit_Framework_Exception
2579      */
2580     public function testAssertObjectNotHasAttributeThrowsException2()
2581     {
2582         $this->assertObjectNotHasAttribute('foo', null);
2583     }
2584
2585     /**
2586      * @covers            PHPUnit_Framework_Assert::assertObjectNotHasAttribute
2587      * @expectedException PHPUnit_Framework_Exception
2588      */
2589     public function testAssertObjectNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid()
2590     {
2591         $this->assertObjectNotHasAttribute('1', 'ClassWithNonPublicAttributes');
2592     }
2593
2594     /**
2595      * @covers PHPUnit_Framework_Assert::assertClassHasAttribute
2596      */
2597     public function testClassHasPublicAttribute()
2598     {
2599         $this->assertClassHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
2600
2601         try {
2602             $this->assertClassHasAttribute('attribute', 'ClassWithNonPublicAttributes');
2603         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2604             return;
2605         }
2606
2607         $this->fail();
2608     }
2609
2610     /**
2611      * @covers PHPUnit_Framework_Assert::assertClassNotHasAttribute
2612      */
2613     public function testClassNotHasPublicAttribute()
2614     {
2615         $this->assertClassNotHasAttribute('attribute', 'ClassWithNonPublicAttributes');
2616
2617         try {
2618             $this->assertClassNotHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
2619         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2620             return;
2621         }
2622
2623         $this->fail();
2624     }
2625
2626     /**
2627      * @covers PHPUnit_Framework_Assert::assertClassHasStaticAttribute
2628      */
2629     public function testClassHasPublicStaticAttribute()
2630     {
2631         $this->assertClassHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
2632
2633         try {
2634             $this->assertClassHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
2635         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2636             return;
2637         }
2638
2639         $this->fail();
2640     }
2641
2642     /**
2643      * @covers PHPUnit_Framework_Assert::assertClassNotHasStaticAttribute
2644      */
2645     public function testClassNotHasPublicStaticAttribute()
2646     {
2647         $this->assertClassNotHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
2648
2649         try {
2650             $this->assertClassNotHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
2651         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2652             return;
2653         }
2654
2655         $this->fail();
2656     }
2657
2658     /**
2659      * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
2660      */
2661     public function testObjectHasPublicAttribute()
2662     {
2663         $obj = new ClassWithNonPublicAttributes;
2664
2665         $this->assertObjectHasAttribute('publicAttribute', $obj);
2666
2667         try {
2668             $this->assertObjectHasAttribute('attribute', $obj);
2669         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2670             return;
2671         }
2672
2673         $this->fail();
2674     }
2675
2676     /**
2677      * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
2678      */
2679     public function testObjectNotHasPublicAttribute()
2680     {
2681         $obj = new ClassWithNonPublicAttributes;
2682
2683         $this->assertObjectNotHasAttribute('attribute', $obj);
2684
2685         try {
2686             $this->assertObjectNotHasAttribute('publicAttribute', $obj);
2687         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2688             return;
2689         }
2690
2691         $this->fail();
2692     }
2693
2694     /**
2695      * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
2696      */
2697     public function testObjectHasOnTheFlyAttribute()
2698     {
2699         $obj      = new stdClass;
2700         $obj->foo = 'bar';
2701
2702         $this->assertObjectHasAttribute('foo', $obj);
2703
2704         try {
2705             $this->assertObjectHasAttribute('bar', $obj);
2706         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2707             return;
2708         }
2709
2710         $this->fail();
2711     }
2712
2713     /**
2714      * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
2715      */
2716     public function testObjectNotHasOnTheFlyAttribute()
2717     {
2718         $obj      = new stdClass;
2719         $obj->foo = 'bar';
2720
2721         $this->assertObjectNotHasAttribute('bar', $obj);
2722
2723         try {
2724             $this->assertObjectNotHasAttribute('foo', $obj);
2725         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2726             return;
2727         }
2728
2729         $this->fail();
2730     }
2731
2732     /**
2733      * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
2734      */
2735     public function testObjectHasProtectedAttribute()
2736     {
2737         $obj = new ClassWithNonPublicAttributes;
2738
2739         $this->assertObjectHasAttribute('protectedAttribute', $obj);
2740
2741         try {
2742             $this->assertObjectHasAttribute('attribute', $obj);
2743         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2744             return;
2745         }
2746
2747         $this->fail();
2748     }
2749
2750     /**
2751      * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
2752      */
2753     public function testObjectNotHasProtectedAttribute()
2754     {
2755         $obj = new ClassWithNonPublicAttributes;
2756
2757         $this->assertObjectNotHasAttribute('attribute', $obj);
2758
2759         try {
2760             $this->assertObjectNotHasAttribute('protectedAttribute', $obj);
2761         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2762             return;
2763         }
2764
2765         $this->fail();
2766     }
2767
2768     /**
2769      * @covers PHPUnit_Framework_Assert::assertObjectHasAttribute
2770      */
2771     public function testObjectHasPrivateAttribute()
2772     {
2773         $obj = new ClassWithNonPublicAttributes;
2774
2775         $this->assertObjectHasAttribute('privateAttribute', $obj);
2776
2777         try {
2778             $this->assertObjectHasAttribute('attribute', $obj);
2779         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2780             return;
2781         }
2782
2783         $this->fail();
2784     }
2785
2786     /**
2787      * @covers PHPUnit_Framework_Assert::assertObjectNotHasAttribute
2788      */
2789     public function testObjectNotHasPrivateAttribute()
2790     {
2791         $obj = new ClassWithNonPublicAttributes;
2792
2793         $this->assertObjectNotHasAttribute('attribute', $obj);
2794
2795         try {
2796             $this->assertObjectNotHasAttribute('privateAttribute', $obj);
2797         } catch (PHPUnit_Framework_AssertionFailedError $e) {
2798             return;
2799         }
2800
2801         $this->fail();
2802     }
2803
2804     /**
2805      * @covers PHPUnit_Framework_Assert::assertThat
2806      * @covers PHPUnit_Framework_Assert::attribute
2807      * @covers PHPUnit_Framework_Assert::equalTo
2808      */
2809     public function testAssertThatAttributeEquals()
2810     {
2811         $this->assertThat(
2812             new ClassWithNonPublicAttributes,
2813             $this->attribute(
2814                 $this->equalTo('foo'),
2815                 'publicAttribute'
2816             )
2817         );
2818     }
2819
2820     /**
2821      * @covers            PHPUnit_Framework_Assert::assertThat
2822      * @covers            PHPUnit_Framework_Assert::attribute
2823      * @covers            PHPUnit_Framework_Assert::equalTo
2824      * @expectedException PHPUnit_Framework_AssertionFailedError
2825      */
2826     public function testAssertThatAttributeEquals2()
2827     {
2828         $this->assertThat(
2829             new ClassWithNonPublicAttributes,
2830             $this->attribute(
2831                 $this->equalTo('bar'),
2832                 'publicAttribute'
2833             )
2834         );
2835     }
2836
2837     /**
2838      * @covers PHPUnit_Framework_Assert::assertThat
2839      * @covers PHPUnit_Framework_Assert::attribute
2840      * @covers PHPUnit_Framework_Assert::equalTo
2841      */
2842     public function testAssertThatAttributeEqualTo()
2843     {
2844         $this->assertThat(
2845             new ClassWithNonPublicAttributes,
2846             $this->attributeEqualTo('publicAttribute', 'foo')
2847         );
2848     }
2849
2850     /**
2851      * @covers PHPUnit_Framework_Assert::assertThat
2852      * @covers PHPUnit_Framework_Assert::anything
2853      */
2854     public function testAssertThatAnything()
2855     {
2856         $this->assertThat('anything', $this->anything());
2857     }
2858
2859     /**
2860      * @covers PHPUnit_Framework_Assert::assertThat
2861      * @covers PHPUnit_Framework_Assert::isTrue
2862      */
2863     public function testAssertThatIsTrue()
2864     {
2865         $this->assertThat(true, $this->isTrue());
2866     }
2867
2868     /**
2869      * @covers PHPUnit_Framework_Assert::assertThat
2870      * @covers PHPUnit_Framework_Assert::isFalse
2871      */
2872     public function testAssertThatIsFalse()
2873     {
2874         $this->assertThat(false, $this->isFalse());
2875     }
2876
2877     /**
2878      * @covers PHPUnit_Framework_Assert::assertThat
2879      * @covers PHPUnit_Framework_Assert::isJson
2880      */
2881     public function testAssertThatIsJson()
2882     {
2883         $this->assertThat('{}', $this->isJson());
2884     }
2885
2886     /**
2887      * @covers PHPUnit_Framework_Assert::assertThat
2888      * @covers PHPUnit_Framework_Assert::anything
2889      * @covers PHPUnit_Framework_Assert::logicalAnd
2890      */
2891     public function testAssertThatAnythingAndAnything()
2892     {
2893         $this->assertThat(
2894             'anything',
2895             $this->logicalAnd(
2896                 $this->anything(), $this->anything()
2897             )
2898         );
2899     }
2900
2901     /**
2902      * @covers PHPUnit_Framework_Assert::assertThat
2903      * @covers PHPUnit_Framework_Assert::anything
2904      * @covers PHPUnit_Framework_Assert::logicalOr
2905      */
2906     public function testAssertThatAnythingOrAnything()
2907     {
2908         $this->assertThat(
2909             'anything',
2910             $this->logicalOr(
2911                 $this->anything(), $this->anything()
2912             )
2913         );
2914     }
2915
2916     /**
2917      * @covers PHPUnit_Framework_Assert::assertThat
2918      * @covers PHPUnit_Framework_Assert::anything
2919      * @covers PHPUnit_Framework_Assert::logicalNot
2920      * @covers PHPUnit_Framework_Assert::logicalXor
2921      */
2922     public function testAssertThatAnythingXorNotAnything()
2923     {
2924         $this->assertThat(
2925             'anything',
2926             $this->logicalXor(
2927                 $this->anything(),
2928                 $this->logicalNot($this->anything())
2929             )
2930         );
2931     }
2932
2933     /**
2934      * @covers PHPUnit_Framework_Assert::assertThat
2935      * @covers PHPUnit_Framework_Assert::contains
2936      */
2937     public function testAssertThatContains()
2938     {
2939         $this->assertThat(array('foo'), $this->contains('foo'));
2940     }
2941
2942     /**
2943      * @covers PHPUnit_Framework_Assert::assertThat
2944      * @covers PHPUnit_Framework_Assert::stringContains
2945      */
2946     public function testAssertThatStringContains()
2947     {
2948         $this->assertThat('barfoobar', $this->stringContains('foo'));
2949     }
2950
2951     /**
2952      * @covers PHPUnit_Framework_Assert::assertThat
2953      * @covers PHPUnit_Framework_Assert::containsOnly
2954      */
2955     public function testAssertThatContainsOnly()
2956     {
2957         $this->assertThat(array('foo'), $this->containsOnly('string'));
2958     }
2959     /**
2960      * @covers PHPUnit_Framework_Assert::assertThat
2961      * @covers PHPUnit_Framework_Assert::containsOnlyInstancesOf
2962      */
2963     public function testAssertThatContainsOnlyInstancesOf()
2964     {
2965         $this->assertThat(array(new Book), $this->containsOnlyInstancesOf('Book'));
2966     }
2967
2968     /**
2969      * @covers PHPUnit_Framework_Assert::assertThat
2970      * @covers PHPUnit_Framework_Assert::arrayHasKey
2971      */
2972     public function testAssertThatArrayHasKey()
2973     {
2974         $this->assertThat(array('foo' => 'bar'), $this->arrayHasKey('foo'));
2975     }
2976
2977     /**
2978      * @covers PHPUnit_Framework_Assert::assertThat
2979      * @covers PHPUnit_Framework_Assert::classHasAttribute
2980      */
2981     public function testAssertThatClassHasAttribute()
2982     {
2983         $this->assertThat(
2984             new ClassWithNonPublicAttributes,
2985             $this->classHasAttribute('publicAttribute')
2986         );
2987     }
2988
2989     /**
2990      * @covers PHPUnit_Framework_Assert::assertThat
2991      * @covers PHPUnit_Framework_Assert::classHasStaticAttribute
2992      */
2993     public function testAssertThatClassHasStaticAttribute()
2994     {
2995         $this->assertThat(
2996             new ClassWithNonPublicAttributes,
2997             $this->classHasStaticAttribute('publicStaticAttribute')
2998         );
2999     }
3000
3001     /**
3002      * @covers PHPUnit_Framework_Assert::assertThat
3003      * @covers PHPUnit_Framework_Assert::objectHasAttribute
3004      */
3005     public function testAssertThatObjectHasAttribute()
3006     {
3007         $this->assertThat(
3008             new ClassWithNonPublicAttributes,
3009             $this->objectHasAttribute('publicAttribute')
3010         );
3011     }
3012
3013     /**
3014      * @covers PHPUnit_Framework_Assert::assertThat
3015      * @covers PHPUnit_Framework_Assert::equalTo
3016      */
3017     public function testAssertThatEqualTo()
3018     {
3019         $this->assertThat('foo', $this->equalTo('foo'));
3020     }
3021
3022     /**
3023      * @covers PHPUnit_Framework_Assert::assertThat
3024      * @covers PHPUnit_Framework_Assert::identicalTo
3025      */
3026     public function testAssertThatIdenticalTo()
3027     {
3028         $value      = new stdClass;
3029         $constraint = $this->identicalTo($value);
3030
3031         $this->assertThat($value, $constraint);
3032     }
3033
3034     /**
3035      * @covers PHPUnit_Framework_Assert::assertThat
3036      * @covers PHPUnit_Framework_Assert::isInstanceOf
3037      */
3038     public function testAssertThatIsInstanceOf()
3039     {
3040         $this->assertThat(new stdClass, $this->isInstanceOf('StdClass'));
3041     }
3042
3043     /**
3044      * @covers PHPUnit_Framework_Assert::assertThat
3045      * @covers PHPUnit_Framework_Assert::isType
3046      */
3047     public function testAssertThatIsType()
3048     {
3049         $this->assertThat('string', $this->isType('string'));
3050     }
3051
3052     /**
3053      * @covers PHPUnit_Framework_Assert::assertThat
3054      * @covers PHPUnit_Framework_Assert::isEmpty
3055      */
3056     public function testAssertThatIsEmpty()
3057     {
3058         $this->assertThat(array(), $this->isEmpty());
3059     }
3060
3061     /**
3062      * @covers PHPUnit_Framework_Assert::assertThat
3063      * @covers PHPUnit_Framework_Assert::fileExists
3064      */
3065     public function testAssertThatFileExists()
3066     {
3067         $this->assertThat(__FILE__, $this->fileExists());
3068     }
3069
3070     /**
3071      * @covers PHPUnit_Framework_Assert::assertThat
3072      * @covers PHPUnit_Framework_Assert::greaterThan
3073      */
3074     public function testAssertThatGreaterThan()
3075     {
3076         $this->assertThat(2, $this->greaterThan(1));
3077     }
3078
3079     /**
3080      * @covers PHPUnit_Framework_Assert::assertThat
3081      * @covers PHPUnit_Framework_Assert::greaterThanOrEqual
3082      */
3083     public function testAssertThatGreaterThanOrEqual()
3084     {
3085         $this->assertThat(2, $this->greaterThanOrEqual(1));
3086     }
3087
3088     /**
3089      * @covers PHPUnit_Framework_Assert::assertThat
3090      * @covers PHPUnit_Framework_Assert::lessThan
3091      */
3092     public function testAssertThatLessThan()
3093     {
3094         $this->assertThat(1, $this->lessThan(2));
3095     }
3096
3097     /**
3098      * @covers PHPUnit_Framework_Assert::assertThat
3099      * @covers PHPUnit_Framework_Assert::lessThanOrEqual
3100      */
3101     public function testAssertThatLessThanOrEqual()
3102     {
3103         $this->assertThat(1, $this->lessThanOrEqual(2));
3104     }
3105
3106     /**
3107      * @covers PHPUnit_Framework_Assert::assertThat
3108      * @covers PHPUnit_Framework_Assert::matchesRegularExpression
3109      */
3110     public function testAssertThatMatchesRegularExpression()
3111     {
3112         $this->assertThat('foobar', $this->matchesRegularExpression('/foo/'));
3113     }
3114
3115     /**
3116      * @covers PHPUnit_Framework_Assert::assertThat
3117      * @covers PHPUnit_Framework_Assert::callback
3118      */
3119     public function testAssertThatCallback()
3120     {
3121         $this->assertThat(
3122             null,
3123             $this->callback(function ($other) { return true; })
3124         );
3125     }
3126
3127     /**
3128      * @covers PHPUnit_Framework_Assert::assertThat
3129      * @covers PHPUnit_Framework_Assert::countOf
3130      */
3131     public function testAssertThatCountOf()
3132     {
3133         $this->assertThat(array(1), $this->countOf(1));
3134     }
3135
3136     /**
3137      * @covers PHPUnit_Framework_Assert::assertFileEquals
3138      */
3139     public function testAssertFileEquals()
3140     {
3141         $this->assertFileEquals(
3142             $this->filesDirectory . 'foo.xml',
3143             $this->filesDirectory . 'foo.xml'
3144         );
3145
3146         try {
3147             $this->assertFileEquals(
3148                 $this->filesDirectory . 'foo.xml',
3149                 $this->filesDirectory . 'bar.xml'
3150             );
3151         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3152             return;
3153         }
3154
3155         $this->fail();
3156     }
3157
3158     /**
3159      * @covers PHPUnit_Framework_Assert::assertFileNotEquals
3160      */
3161     public function testAssertFileNotEquals()
3162     {
3163         $this->assertFileNotEquals(
3164             $this->filesDirectory . 'foo.xml',
3165             $this->filesDirectory . 'bar.xml'
3166         );
3167
3168         try {
3169             $this->assertFileNotEquals(
3170                 $this->filesDirectory . 'foo.xml',
3171                 $this->filesDirectory . 'foo.xml'
3172             );
3173         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3174             return;
3175         }
3176
3177         $this->fail();
3178     }
3179
3180     /**
3181      * @covers PHPUnit_Framework_Assert::assertStringEqualsFile
3182      */
3183     public function testAssertStringEqualsFile()
3184     {
3185         $this->assertStringEqualsFile(
3186             $this->filesDirectory . 'foo.xml',
3187             file_get_contents($this->filesDirectory . 'foo.xml')
3188         );
3189
3190         try {
3191             $this->assertStringEqualsFile(
3192                 $this->filesDirectory . 'foo.xml',
3193                 file_get_contents($this->filesDirectory . 'bar.xml')
3194             );
3195         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3196             return;
3197         }
3198
3199         $this->fail();
3200     }
3201
3202     /**
3203      * @covers PHPUnit_Framework_Assert::assertStringNotEqualsFile
3204      */
3205     public function testAssertStringNotEqualsFile()
3206     {
3207         $this->assertStringNotEqualsFile(
3208             $this->filesDirectory . 'foo.xml',
3209             file_get_contents($this->filesDirectory . 'bar.xml')
3210         );
3211
3212         try {
3213             $this->assertStringNotEqualsFile(
3214                 $this->filesDirectory . 'foo.xml',
3215                 file_get_contents($this->filesDirectory . 'foo.xml')
3216             );
3217         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3218             return;
3219         }
3220
3221         $this->fail();
3222     }
3223
3224     /**
3225      * @covers            PHPUnit_Framework_Assert::assertStringStartsWith
3226      * @expectedException PHPUnit_Framework_Exception
3227      */
3228     public function testAssertStringStartsWithThrowsException()
3229     {
3230         $this->assertStringStartsWith(null, null);
3231     }
3232
3233     /**
3234      * @covers            PHPUnit_Framework_Assert::assertStringStartsWith
3235      * @expectedException PHPUnit_Framework_Exception
3236      */
3237     public function testAssertStringStartsWithThrowsException2()
3238     {
3239         $this->assertStringStartsWith('', null);
3240     }
3241
3242     /**
3243      * @covers            PHPUnit_Framework_Assert::assertStringStartsNotWith
3244      * @expectedException PHPUnit_Framework_Exception
3245      */
3246     public function testAssertStringStartsNotWithThrowsException()
3247     {
3248         $this->assertStringStartsNotWith(null, null);
3249     }
3250
3251     /**
3252      * @covers            PHPUnit_Framework_Assert::assertStringStartsNotWith
3253      * @expectedException PHPUnit_Framework_Exception
3254      */
3255     public function testAssertStringStartsNotWithThrowsException2()
3256     {
3257         $this->assertStringStartsNotWith('', null);
3258     }
3259
3260     /**
3261      * @covers            PHPUnit_Framework_Assert::assertStringEndsWith
3262      * @expectedException PHPUnit_Framework_Exception
3263      */
3264     public function testAssertStringEndsWithThrowsException()
3265     {
3266         $this->assertStringEndsWith(null, null);
3267     }
3268
3269     /**
3270      * @covers            PHPUnit_Framework_Assert::assertStringEndsWith
3271      * @expectedException PHPUnit_Framework_Exception
3272      */
3273     public function testAssertStringEndsWithThrowsException2()
3274     {
3275         $this->assertStringEndsWith('', null);
3276     }
3277
3278     /**
3279      * @covers            PHPUnit_Framework_Assert::assertStringEndsNotWith
3280      * @expectedException PHPUnit_Framework_Exception
3281      */
3282     public function testAssertStringEndsNotWithThrowsException()
3283     {
3284         $this->assertStringEndsNotWith(null, null);
3285     }
3286
3287     /**
3288      * @covers            PHPUnit_Framework_Assert::assertStringEndsNotWith
3289      * @expectedException PHPUnit_Framework_Exception
3290      */
3291     public function testAssertStringEndsNotWithThrowsException2()
3292     {
3293         $this->assertStringEndsNotWith('', null);
3294     }
3295
3296     /**
3297      * @covers PHPUnit_Framework_Assert::assertStringStartsWith
3298      */
3299     public function testAssertStringStartsWith()
3300     {
3301         $this->assertStringStartsWith('prefix', 'prefixfoo');
3302
3303         try {
3304             $this->assertStringStartsWith('prefix', 'foo');
3305         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3306             return;
3307         }
3308
3309         $this->fail();
3310     }
3311
3312     /**
3313      * @covers PHPUnit_Framework_Assert::assertStringStartsNotWith
3314      */
3315     public function testAssertStringStartsNotWith()
3316     {
3317         $this->assertStringStartsNotWith('prefix', 'foo');
3318
3319         try {
3320             $this->assertStringStartsNotWith('prefix', 'prefixfoo');
3321         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3322             return;
3323         }
3324
3325         $this->fail();
3326     }
3327
3328     /**
3329      * @covers PHPUnit_Framework_Assert::assertStringEndsWith
3330      */
3331     public function testAssertStringEndsWith()
3332     {
3333         $this->assertStringEndsWith('suffix', 'foosuffix');
3334
3335         try {
3336             $this->assertStringEndsWith('suffix', 'foo');
3337         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3338             return;
3339         }
3340
3341         $this->fail();
3342     }
3343
3344     /**
3345      * @covers PHPUnit_Framework_Assert::assertStringEndsNotWith
3346      */
3347     public function testAssertStringEndsNotWith()
3348     {
3349         $this->assertStringEndsNotWith('suffix', 'foo');
3350
3351         try {
3352             $this->assertStringEndsNotWith('suffix', 'foosuffix');
3353         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3354             return;
3355         }
3356
3357         $this->fail();
3358     }
3359
3360     /**
3361      * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
3362      * @expectedException PHPUnit_Framework_Exception
3363      */
3364     public function testAssertStringMatchesFormatRaisesExceptionForInvalidFirstArgument()
3365     {
3366         $this->assertStringMatchesFormat(null, '');
3367     }
3368
3369     /**
3370      * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
3371      * @expectedException PHPUnit_Framework_Exception
3372      */
3373     public function testAssertStringMatchesFormatRaisesExceptionForInvalidSecondArgument()
3374     {
3375         $this->assertStringMatchesFormat('', null);
3376     }
3377
3378     /**
3379      * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
3380      */
3381     public function testAssertStringMatchesFormat()
3382     {
3383         $this->assertStringMatchesFormat('*%s*', '***');
3384     }
3385
3386     /**
3387      * @covers PHPUnit_Framework_Assert::assertStringMatchesFormat
3388      * @expectedException PHPUnit_Framework_AssertionFailedError
3389      */
3390     public function testAssertStringMatchesFormatFailure()
3391     {
3392         $this->assertStringMatchesFormat('*%s*', '**');
3393     }
3394
3395     /**
3396      * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat
3397      * @expectedException PHPUnit_Framework_Exception
3398      */
3399     public function testAssertStringNotMatchesFormatRaisesExceptionForInvalidFirstArgument()
3400     {
3401         $this->assertStringNotMatchesFormat(null, '');
3402     }
3403
3404     /**
3405      * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat
3406      * @expectedException PHPUnit_Framework_Exception
3407      */
3408     public function testAssertStringNotMatchesFormatRaisesExceptionForInvalidSecondArgument()
3409     {
3410         $this->assertStringNotMatchesFormat('', null);
3411     }
3412
3413     /**
3414      * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormat
3415      */
3416     public function testAssertStringNotMatchesFormat()
3417     {
3418         $this->assertStringNotMatchesFormat('*%s*', '**');
3419
3420         try {
3421             $this->assertStringMatchesFormat('*%s*', '**');
3422         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3423             return;
3424         }
3425
3426         $this->fail();
3427     }
3428
3429     /**
3430      * @covers PHPUnit_Framework_Assert::assertEmpty
3431      */
3432     public function testAssertEmpty()
3433     {
3434         $this->assertEmpty(array());
3435
3436         try {
3437             $this->assertEmpty(array('foo'));
3438         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3439             return;
3440         }
3441
3442         $this->fail();
3443     }
3444
3445     /**
3446      * @covers PHPUnit_Framework_Assert::assertNotEmpty
3447      */
3448     public function testAssertNotEmpty()
3449     {
3450         $this->assertNotEmpty(array('foo'));
3451
3452         try {
3453             $this->assertNotEmpty(array());
3454         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3455             return;
3456         }
3457
3458         $this->fail();
3459     }
3460
3461     /**
3462      * @covers PHPUnit_Framework_Assert::assertAttributeEmpty
3463      */
3464     public function testAssertAttributeEmpty()
3465     {
3466         $o    = new stdClass;
3467         $o->a = array();
3468
3469         $this->assertAttributeEmpty('a', $o);
3470
3471         try {
3472             $o->a = array('b');
3473             $this->assertAttributeEmpty('a', $o);
3474         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3475             return;
3476         }
3477
3478         $this->fail();
3479     }
3480
3481     /**
3482      * @covers PHPUnit_Framework_Assert::assertAttributeNotEmpty
3483      */
3484     public function testAssertAttributeNotEmpty()
3485     {
3486         $o    = new stdClass;
3487         $o->a = array('b');
3488
3489         $this->assertAttributeNotEmpty('a', $o);
3490
3491         try {
3492             $o->a = array();
3493             $this->assertAttributeNotEmpty('a', $o);
3494         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3495             return;
3496         }
3497
3498         $this->fail();
3499     }
3500
3501     /**
3502      * @covers PHPUnit_Framework_Assert::markTestIncomplete
3503      */
3504     public function testMarkTestIncomplete()
3505     {
3506         try {
3507             $this->markTestIncomplete('incomplete');
3508         } catch (PHPUnit_Framework_IncompleteTestError $e) {
3509             $this->assertEquals('incomplete', $e->getMessage());
3510
3511             return;
3512         }
3513
3514         $this->fail();
3515     }
3516
3517     /**
3518      * @covers PHPUnit_Framework_Assert::markTestSkipped
3519      */
3520     public function testMarkTestSkipped()
3521     {
3522         try {
3523             $this->markTestSkipped('skipped');
3524         } catch (PHPUnit_Framework_SkippedTestError $e) {
3525             $this->assertEquals('skipped', $e->getMessage());
3526
3527             return;
3528         }
3529
3530         $this->fail();
3531     }
3532
3533     /**
3534      * @covers PHPUnit_Framework_Assert::assertCount
3535      */
3536     public function testAssertCount()
3537     {
3538         $this->assertCount(2, array(1, 2));
3539
3540         try {
3541             $this->assertCount(2, array(1, 2, 3));
3542         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3543             return;
3544         }
3545
3546         $this->fail();
3547     }
3548
3549     /**
3550      * @covers PHPUnit_Framework_Assert::assertCount
3551      */
3552     public function testAssertCountTraversable()
3553     {
3554         $this->assertCount(2, new ArrayIterator(array(1, 2)));
3555
3556         try {
3557             $this->assertCount(2, new ArrayIterator(array(1, 2, 3)));
3558         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3559             return;
3560         }
3561
3562         $this->fail();
3563     }
3564
3565     /**
3566      * @covers PHPUnit_Framework_Assert::assertCount
3567      */
3568     public function testAssertCountThrowsExceptionIfExpectedCountIsNoInteger()
3569     {
3570         try {
3571             $this->assertCount('a', array());
3572         } catch (PHPUnit_Framework_Exception $e) {
3573             $this->assertEquals('Argument #1 (No Value) of PHPUnit_Framework_Assert::assertCount() must be a integer', $e->getMessage());
3574
3575             return;
3576         }
3577
3578         $this->fail();
3579     }
3580
3581     /**
3582      * @covers PHPUnit_Framework_Assert::assertCount
3583      */
3584     public function testAssertCountThrowsExceptionIfElementIsNotCountable()
3585     {
3586         try {
3587             $this->assertCount(2, '');
3588         } catch (PHPUnit_Framework_Exception $e) {
3589             $this->assertEquals('Argument #2 (No Value) of PHPUnit_Framework_Assert::assertCount() must be a countable or traversable', $e->getMessage());
3590
3591             return;
3592         }
3593
3594         $this->fail();
3595     }
3596
3597     /**
3598      * @covers PHPUnit_Framework_Assert::assertAttributeCount
3599      */
3600     public function testAssertAttributeCount()
3601     {
3602         $o    = new stdClass;
3603         $o->a = array();
3604
3605         $this->assertAttributeCount(0, 'a', $o);
3606     }
3607
3608     /**
3609      * @covers PHPUnit_Framework_Assert::assertNotCount
3610      */
3611     public function testAssertNotCount()
3612     {
3613         $this->assertNotCount(2, array(1, 2, 3));
3614
3615         try {
3616             $this->assertNotCount(2, array(1, 2));
3617         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3618             return;
3619         }
3620
3621         $this->fail();
3622     }
3623
3624     /**
3625      * @covers PHPUnit_Framework_Assert::assertNotCount
3626      * @expectedException PHPUnit_Framework_Exception
3627      */
3628     public function testAssertNotCountThrowsExceptionIfExpectedCountIsNoInteger()
3629     {
3630         $this->assertNotCount('a', array());
3631     }
3632
3633     /**
3634      * @covers PHPUnit_Framework_Assert::assertNotCount
3635      * @expectedException PHPUnit_Framework_Exception
3636      */
3637     public function testAssertNotCountThrowsExceptionIfElementIsNotCountable()
3638     {
3639         $this->assertNotCount(2, '');
3640     }
3641
3642     /**
3643      * @covers PHPUnit_Framework_Assert::assertAttributeNotCount
3644      */
3645     public function testAssertAttributeNotCount()
3646     {
3647         $o    = new stdClass;
3648         $o->a = array();
3649
3650         $this->assertAttributeNotCount(1, 'a', $o);
3651     }
3652
3653     /**
3654      * @covers PHPUnit_Framework_Assert::assertSameSize
3655      */
3656     public function testAssertSameSize()
3657     {
3658         $this->assertSameSize(array(1, 2), array(3, 4));
3659
3660         try {
3661             $this->assertSameSize(array(1, 2), array(1, 2, 3));
3662         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3663             return;
3664         }
3665
3666         $this->fail();
3667     }
3668
3669     /**
3670      * @covers PHPUnit_Framework_Assert::assertSameSize
3671      */
3672     public function testAssertSameSizeThrowsExceptionIfExpectedIsNotCountable()
3673     {
3674         try {
3675             $this->assertSameSize('a', array());
3676         } catch (PHPUnit_Framework_Exception $e) {
3677             $this->assertEquals('Argument #1 (No Value) of PHPUnit_Framework_Assert::assertSameSize() must be a countable or traversable', $e->getMessage());
3678
3679             return;
3680         }
3681
3682         $this->fail();
3683     }
3684
3685     /**
3686      * @covers PHPUnit_Framework_Assert::assertSameSize
3687      */
3688     public function testAssertSameSizeThrowsExceptionIfActualIsNotCountable()
3689     {
3690         try {
3691             $this->assertSameSize(array(), '');
3692         } catch (PHPUnit_Framework_Exception $e) {
3693             $this->assertEquals('Argument #2 (No Value) of PHPUnit_Framework_Assert::assertSameSize() must be a countable or traversable', $e->getMessage());
3694
3695             return;
3696         }
3697
3698         $this->fail();
3699     }
3700
3701     /**
3702      * @covers PHPUnit_Framework_Assert::assertNotSameSize
3703      */
3704     public function testAssertNotSameSize()
3705     {
3706         $this->assertNotSameSize(array(1, 2), array(1, 2, 3));
3707
3708         try {
3709             $this->assertNotSameSize(array(1, 2), array(3, 4));
3710         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3711             return;
3712         }
3713
3714         $this->fail();
3715     }
3716
3717     /**
3718      * @covers PHPUnit_Framework_Assert::assertNotSameSize
3719      * @expectedException PHPUnit_Framework_Exception
3720      */
3721     public function testAssertNotSameSizeThrowsExceptionIfExpectedIsNotCountable()
3722     {
3723         $this->assertNotSameSize('a', array());
3724     }
3725
3726     /**
3727      * @covers PHPUnit_Framework_Assert::assertNotSameSize
3728      * @expectedException PHPUnit_Framework_Exception
3729      */
3730     public function testAssertNotSameSizeThrowsExceptionIfActualIsNotCountable()
3731     {
3732         $this->assertNotSameSize(array(), '');
3733     }
3734
3735     /**
3736      * @covers PHPUnit_Framework_Assert::assertJson
3737      * @expectedException PHPUnit_Framework_Exception
3738      */
3739     public function testAssertJsonRaisesExceptionForInvalidArgument()
3740     {
3741         $this->assertJson(null);
3742     }
3743
3744     /**
3745      * @covers PHPUnit_Framework_Assert::assertJson
3746      */
3747     public function testAssertJson()
3748     {
3749         $this->assertJson('{}');
3750     }
3751
3752     /**
3753      * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString
3754      */
3755     public function testAssertJsonStringEqualsJsonString()
3756     {
3757         $expected = '{"Mascott" : "Tux"}';
3758         $actual   = '{"Mascott" : "Tux"}';
3759         $message  = 'Given Json strings do not match';
3760
3761         $this->assertJsonStringEqualsJsonString($expected, $actual, $message);
3762     }
3763
3764     /**
3765      * @dataProvider validInvalidJsonDataprovider
3766      * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString
3767      */
3768     public function testAssertJsonStringEqualsJsonStringErrorRaised($expected, $actual)
3769     {
3770         try {
3771             $this->assertJsonStringEqualsJsonString($expected, $actual);
3772         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3773             return;
3774         }
3775         $this->fail('Expected exception not found');
3776     }
3777
3778     /**
3779      * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonString
3780      */
3781     public function testAssertJsonStringNotEqualsJsonString()
3782     {
3783         $expected = '{"Mascott" : "Beastie"}';
3784         $actual   = '{"Mascott" : "Tux"}';
3785         $message  = 'Given Json strings do match';
3786
3787         $this->assertJsonStringNotEqualsJsonString($expected, $actual, $message);
3788     }
3789
3790     /**
3791      * @dataProvider validInvalidJsonDataprovider
3792      * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonString
3793      */
3794     public function testAssertJsonStringNotEqualsJsonStringErrorRaised($expected, $actual)
3795     {
3796         try {
3797             $this->assertJsonStringNotEqualsJsonString($expected, $actual);
3798         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3799             return;
3800         }
3801         $this->fail('Expected exception not found');
3802     }
3803
3804     /**
3805      * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
3806      */
3807     public function testAssertJsonStringEqualsJsonFile()
3808     {
3809         $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3810         $actual  = json_encode(array('Mascott' => 'Tux'));
3811         $message = '';
3812         $this->assertJsonStringEqualsJsonFile($file, $actual, $message);
3813     }
3814
3815     /**
3816      * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
3817      */
3818     public function testAssertJsonStringEqualsJsonFileExpectingExpectationFailedException()
3819     {
3820         $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3821         $actual  = json_encode(array('Mascott' => 'Beastie'));
3822         $message = '';
3823         try {
3824             $this->assertJsonStringEqualsJsonFile($file, $actual, $message);
3825         } catch (PHPUnit_Framework_ExpectationFailedException $e) {
3826             $this->assertEquals(
3827                 'Failed asserting that \'{"Mascott":"Beastie"}\' matches JSON string "{"Mascott":"Tux"}".',
3828                 $e->getMessage()
3829             );
3830
3831             return;
3832         }
3833
3834         $this->fail('Expected Exception not thrown.');
3835     }
3836
3837     /**
3838      * @covers PHPUnit_Framework_Assert::assertJsonStringEqualsJsonFile
3839      */
3840     public function testAssertJsonStringEqualsJsonFileExpectingException()
3841     {
3842         $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
3843         try {
3844             $this->assertJsonStringEqualsJsonFile($file, null);
3845         } catch (PHPUnit_Framework_Exception $e) {
3846             return;
3847         }
3848         $this->fail('Expected Exception not thrown.');
3849     }
3850
3851     /**
3852      * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonFile
3853      */
3854     public function testAssertJsonStringNotEqualsJsonFile()
3855     {
3856         $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3857         $actual  = json_encode(array('Mascott' => 'Beastie'));
3858         $message = '';
3859         $this->assertJsonStringNotEqualsJsonFile($file, $actual, $message);
3860     }
3861
3862     /**
3863      * @covers PHPUnit_Framework_Assert::assertJsonStringNotEqualsJsonFile
3864      */
3865     public function testAssertJsonStringNotEqualsJsonFileExpectingException()
3866     {
3867         $file = __DIR__ . '/../_files/JsonData/simpleObject.json';
3868         try {
3869             $this->assertJsonStringNotEqualsJsonFile($file, null);
3870         } catch (PHPUnit_Framework_Exception $e) {
3871             return;
3872         }
3873         $this->fail('Expected exception not found.');
3874     }
3875
3876     /**
3877      * @covers PHPUnit_Framework_Assert::assertJsonFileNotEqualsJsonFile
3878      */
3879     public function testAssertJsonFileNotEqualsJsonFile()
3880     {
3881         $fileExpected = __DIR__ . '/../_files/JsonData/simpleObject.json';
3882         $fileActual   = __DIR__ . '/../_files/JsonData/arrayObject.json';
3883         $message      = '';
3884         $this->assertJsonFileNotEqualsJsonFile($fileExpected, $fileActual, $message);
3885     }
3886
3887     /**
3888      * @covers PHPUnit_Framework_Assert::assertJsonFileEqualsJsonFile
3889      */
3890     public function testAssertJsonFileEqualsJsonFile()
3891     {
3892         $file    = __DIR__ . '/../_files/JsonData/simpleObject.json';
3893         $message = '';
3894         $this->assertJsonFileEqualsJsonFile($file, $file, $message);
3895     }
3896
3897     /**
3898      * @covers PHPUnit_Framework_Assert::assertInstanceOf
3899      */
3900     public function testAssertInstanceOf()
3901     {
3902         $this->assertInstanceOf('stdClass', new stdClass);
3903
3904         try {
3905             $this->assertInstanceOf('Exception', new stdClass);
3906         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3907             return;
3908         }
3909
3910         $this->fail();
3911     }
3912
3913     /**
3914      * @covers PHPUnit_Framework_Assert::assertInstanceOf
3915      * @expectedException PHPUnit_Framework_Exception
3916      */
3917     public function testAssertInstanceOfThrowsExceptionForInvalidArgument()
3918     {
3919         $this->assertInstanceOf(null, new stdClass);
3920     }
3921
3922     /**
3923      * @covers PHPUnit_Framework_Assert::assertAttributeInstanceOf
3924      */
3925     public function testAssertAttributeInstanceOf()
3926     {
3927         $o    = new stdClass;
3928         $o->a = new stdClass;
3929
3930         $this->assertAttributeInstanceOf('stdClass', 'a', $o);
3931     }
3932
3933     /**
3934      * @covers PHPUnit_Framework_Assert::assertNotInstanceOf
3935      */
3936     public function testAssertNotInstanceOf()
3937     {
3938         $this->assertNotInstanceOf('Exception', new stdClass);
3939
3940         try {
3941             $this->assertNotInstanceOf('stdClass', new stdClass);
3942         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3943             return;
3944         }
3945
3946         $this->fail();
3947     }
3948
3949     /**
3950      * @covers PHPUnit_Framework_Assert::assertNotInstanceOf
3951      * @expectedException PHPUnit_Framework_Exception
3952      */
3953     public function testAssertNotInstanceOfThrowsExceptionForInvalidArgument()
3954     {
3955         $this->assertNotInstanceOf(null, new stdClass);
3956     }
3957
3958     /**
3959      * @covers PHPUnit_Framework_Assert::assertAttributeNotInstanceOf
3960      */
3961     public function testAssertAttributeNotInstanceOf()
3962     {
3963         $o    = new stdClass;
3964         $o->a = new stdClass;
3965
3966         $this->assertAttributeNotInstanceOf('Exception', 'a', $o);
3967     }
3968
3969     /**
3970      * @covers PHPUnit_Framework_Assert::assertInternalType
3971      */
3972     public function testAssertInternalType()
3973     {
3974         $this->assertInternalType('integer', 1);
3975
3976         try {
3977             $this->assertInternalType('string', 1);
3978         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3979             return;
3980         }
3981
3982         $this->fail();
3983     }
3984
3985     /**
3986      * @covers PHPUnit_Framework_Assert::assertInternalType
3987      */
3988     public function testAssertInternalTypeDouble()
3989     {
3990         $this->assertInternalType('double', 1.0);
3991
3992         try {
3993             $this->assertInternalType('double', 1);
3994         } catch (PHPUnit_Framework_AssertionFailedError $e) {
3995             return;
3996         }
3997
3998         $this->fail();
3999     }
4000
4001     /**
4002      * @covers PHPUnit_Framework_Assert::assertInternalType
4003      * @expectedException PHPUnit_Framework_Exception
4004      */
4005     public function testAssertInternalTypeThrowsExceptionForInvalidArgument()
4006     {
4007         $this->assertInternalType(null, 1);
4008     }
4009
4010     /**
4011      * @covers PHPUnit_Framework_Assert::assertAttributeInternalType
4012      */
4013     public function testAssertAttributeInternalType()
4014     {
4015         $o    = new stdClass;
4016         $o->a = 1;
4017
4018         $this->assertAttributeInternalType('integer', 'a', $o);
4019     }
4020
4021     /**
4022      * @covers PHPUnit_Framework_Assert::assertNotInternalType
4023      */
4024     public function testAssertNotInternalType()
4025     {
4026         $this->assertNotInternalType('string', 1);
4027
4028         try {
4029             $this->assertNotInternalType('integer', 1);
4030         } catch (PHPUnit_Framework_AssertionFailedError $e) {
4031             return;
4032         }
4033
4034         $this->fail();
4035     }
4036
4037     /**
4038      * @covers PHPUnit_Framework_Assert::assertNotInternalType
4039      * @expectedException PHPUnit_Framework_Exception
4040      */
4041     public function testAssertNotInternalTypeThrowsExceptionForInvalidArgument()
4042     {
4043         $this->assertNotInternalType(null, 1);
4044     }
4045
4046     /**
4047      * @covers PHPUnit_Framework_Assert::assertAttributeNotInternalType
4048      */
4049     public function testAssertAttributeNotInternalType()
4050     {
4051         $o    = new stdClass;
4052         $o->a = 1;
4053
4054         $this->assertAttributeNotInternalType('string', 'a', $o);
4055     }
4056
4057     /**
4058      * @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile
4059      * @expectedException PHPUnit_Framework_Exception
4060      */
4061     public function testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument()
4062     {
4063         $this->assertStringMatchesFormatFile('not_existing_file', '');
4064     }
4065
4066     /**
4067      * @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile
4068      * @expectedException PHPUnit_Framework_Exception
4069      */
4070     public function testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument2()
4071     {
4072         $this->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', null);
4073     }
4074
4075     /**
4076      * @covers PHPUnit_Framework_Assert::assertStringMatchesFormatFile
4077      */
4078     public function testAssertStringMatchesFormatFile()
4079     {
4080         $this->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "FOO\n");
4081
4082         try {
4083             $this->assertStringMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "BAR\n");
4084         } catch (PHPUnit_Framework_AssertionFailedError $e) {
4085             return;
4086         }
4087
4088         $this->fail();
4089     }
4090
4091     /**
4092      * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile
4093      * @expectedException PHPUnit_Framework_Exception
4094      */
4095     public function testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument()
4096     {
4097         $this->assertStringNotMatchesFormatFile('not_existing_file', '');
4098     }
4099
4100     /**
4101      * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile
4102      * @expectedException PHPUnit_Framework_Exception
4103      */
4104     public function testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument2()
4105     {
4106         $this->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', null);
4107     }
4108
4109     /**
4110      * @covers PHPUnit_Framework_Assert::assertStringNotMatchesFormatFile
4111      */
4112     public function testAssertStringNotMatchesFormatFile()
4113     {
4114         $this->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "BAR\n");
4115
4116         try {
4117             $this->assertStringNotMatchesFormatFile($this->filesDirectory . 'expectedFileFormat.txt', "FOO\n");
4118         } catch (PHPUnit_Framework_AssertionFailedError $e) {
4119             return;
4120         }
4121
4122         $this->fail();
4123     }
4124
4125     /**
4126      * @return array
4127      */
4128     public static function validInvalidJsonDataprovider()
4129     {
4130         return array(
4131             'error syntax in expected JSON' => array('{"Mascott"::}', '{"Mascott" : "Tux"}'),
4132             'error UTF-8 in actual JSON'    => array('{"Mascott" : "Tux"}', '{"Mascott" : :}'),
4133         );
4134     }
4135 }