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 11class Framework_ConstraintTest extends PHPUnit_Framework_TestCase 12{ 13 public function testConstraintArrayHasKey() 14 { 15 $constraint = PHPUnit_Framework_Assert::arrayHasKey(0); 16 17 $this->assertFalse($constraint->evaluate([], '', true)); 18 $this->assertEquals('has the key 0', $constraint->toString()); 19 $this->assertCount(1, $constraint); 20 21 try { 22 $constraint->evaluate([]); 23 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 24 $this->assertEquals(<<<EOF 25Failed asserting that an array has the key 0. 26 27EOF 28 , 29 PHPUnit_Framework_TestFailure::exceptionToString($e) 30 ); 31 32 return; 33 } 34 35 $this->fail(); 36 } 37 38 public function testConstraintArrayHasKey2() 39 { 40 $constraint = PHPUnit_Framework_Assert::arrayHasKey(0); 41 42 try { 43 $constraint->evaluate([], 'custom message'); 44 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 45 $this->assertEquals( 46 <<<EOF 47custom message\nFailed asserting that an array has the key 0. 48 49EOF 50 , 51 PHPUnit_Framework_TestFailure::exceptionToString($e) 52 ); 53 54 return; 55 } 56 57 $this->fail(); 58 } 59 60 public function testConstraintArrayNotHasKey() 61 { 62 $constraint = PHPUnit_Framework_Assert::logicalNot( 63 PHPUnit_Framework_Assert::arrayHasKey(0) 64 ); 65 66 $this->assertFalse($constraint->evaluate([0 => 1], '', true)); 67 $this->assertEquals('does not have the key 0', $constraint->toString()); 68 $this->assertCount(1, $constraint); 69 70 try { 71 $constraint->evaluate([0 => 1]); 72 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 73 $this->assertEquals( 74 <<<EOF 75Failed asserting that an array does not have the key 0. 76 77EOF 78 , 79 PHPUnit_Framework_TestFailure::exceptionToString($e) 80 ); 81 82 return; 83 } 84 85 $this->fail(); 86 } 87 88 public function testConstraintArrayNotHasKey2() 89 { 90 $constraint = PHPUnit_Framework_Assert::logicalNot( 91 PHPUnit_Framework_Assert::arrayHasKey(0) 92 ); 93 94 try { 95 $constraint->evaluate([0], 'custom message'); 96 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 97 $this->assertEquals( 98 <<<EOF 99custom message 100Failed asserting that an array does not have the key 0. 101 102EOF 103 , 104 PHPUnit_Framework_TestFailure::exceptionToString($e) 105 ); 106 107 return; 108 } 109 110 $this->fail(); 111 } 112 113 public function testConstraintIsReadable() 114 { 115 $constraint = PHPUnit_Framework_Assert::isReadable(); 116 117 $this->assertFalse($constraint->evaluate('foo', '', true)); 118 $this->assertEquals('is readable', $constraint->toString()); 119 $this->assertCount(1, $constraint); 120 121 try { 122 $constraint->evaluate('foo'); 123 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 124 $this->assertEquals( 125 <<<EOF 126Failed asserting that "foo" is readable. 127 128EOF 129 , 130 PHPUnit_Framework_TestFailure::exceptionToString($e) 131 ); 132 133 return; 134 } 135 136 $this->fail(); 137 } 138 139 public function testConstraintIsWritable() 140 { 141 $constraint = PHPUnit_Framework_Assert::isWritable(); 142 143 $this->assertFalse($constraint->evaluate('foo', '', true)); 144 $this->assertEquals('is writable', $constraint->toString()); 145 $this->assertCount(1, $constraint); 146 147 try { 148 $constraint->evaluate('foo'); 149 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 150 $this->assertEquals( 151 <<<EOF 152Failed asserting that "foo" is writable. 153 154EOF 155 , 156 PHPUnit_Framework_TestFailure::exceptionToString($e) 157 ); 158 159 return; 160 } 161 162 $this->fail(); 163 } 164 165 public function testConstraintDirectoryExists() 166 { 167 $constraint = PHPUnit_Framework_Assert::directoryExists(); 168 169 $this->assertFalse($constraint->evaluate('foo', '', true)); 170 $this->assertEquals('directory exists', $constraint->toString()); 171 $this->assertCount(1, $constraint); 172 173 try { 174 $constraint->evaluate('foo'); 175 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 176 $this->assertEquals( 177 <<<EOF 178Failed asserting that directory "foo" exists. 179 180EOF 181 , 182 PHPUnit_Framework_TestFailure::exceptionToString($e) 183 ); 184 185 return; 186 } 187 188 $this->fail(); 189 } 190 191 public function testConstraintFileExists() 192 { 193 $constraint = PHPUnit_Framework_Assert::fileExists(); 194 195 $this->assertFalse($constraint->evaluate('foo', '', true)); 196 $this->assertEquals('file exists', $constraint->toString()); 197 $this->assertCount(1, $constraint); 198 199 try { 200 $constraint->evaluate('foo'); 201 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 202 $this->assertEquals( 203 <<<EOF 204Failed asserting that file "foo" exists. 205 206EOF 207 , 208 PHPUnit_Framework_TestFailure::exceptionToString($e) 209 ); 210 211 return; 212 } 213 214 $this->fail(); 215 } 216 217 public function testConstraintFileExists2() 218 { 219 $constraint = PHPUnit_Framework_Assert::fileExists(); 220 221 try { 222 $constraint->evaluate('foo', 'custom message'); 223 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 224 $this->assertEquals(<<<EOF 225custom message 226Failed asserting that file "foo" exists. 227 228EOF 229 , 230 PHPUnit_Framework_TestFailure::exceptionToString($e) 231 ); 232 233 return; 234 } 235 236 $this->fail(); 237 } 238 239 public function testConstraintFileNotExists() 240 { 241 $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php'; 242 243 $constraint = PHPUnit_Framework_Assert::logicalNot( 244 PHPUnit_Framework_Assert::fileExists() 245 ); 246 247 $this->assertFalse($constraint->evaluate($file, '', true)); 248 $this->assertEquals('file does not exist', $constraint->toString()); 249 $this->assertCount(1, $constraint); 250 251 try { 252 $constraint->evaluate($file); 253 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 254 $this->assertEquals( 255 <<<EOF 256Failed asserting that file "$file" does not exist. 257 258EOF 259 , 260 PHPUnit_Framework_TestFailure::exceptionToString($e) 261 ); 262 263 return; 264 } 265 266 $this->fail(); 267 } 268 269 public function testConstraintFileNotExists2() 270 { 271 $file = dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'ClassWithNonPublicAttributes.php'; 272 273 $constraint = PHPUnit_Framework_Assert::logicalNot( 274 PHPUnit_Framework_Assert::fileExists() 275 ); 276 277 try { 278 $constraint->evaluate($file, 'custom message'); 279 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 280 $this->assertEquals(<<<EOF 281custom message 282Failed asserting that file "$file" does not exist. 283 284EOF 285 , 286 PHPUnit_Framework_TestFailure::exceptionToString($e) 287 ); 288 289 return; 290 } 291 292 $this->fail(); 293 } 294 295 public function testConstraintGreaterThan() 296 { 297 $constraint = PHPUnit_Framework_Assert::greaterThan(1); 298 299 $this->assertFalse($constraint->evaluate(0, '', true)); 300 $this->assertTrue($constraint->evaluate(2, '', true)); 301 $this->assertEquals('is greater than 1', $constraint->toString()); 302 $this->assertCount(1, $constraint); 303 304 try { 305 $constraint->evaluate(0); 306 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 307 $this->assertEquals( 308 <<<EOF 309Failed asserting that 0 is greater than 1. 310 311EOF 312 , 313 PHPUnit_Framework_TestFailure::exceptionToString($e) 314 ); 315 316 return; 317 } 318 319 $this->fail(); 320 } 321 322 public function testConstraintGreaterThan2() 323 { 324 $constraint = PHPUnit_Framework_Assert::greaterThan(1); 325 326 try { 327 $constraint->evaluate(0, 'custom message'); 328 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 329 $this->assertEquals( 330 <<<EOF 331custom message 332Failed asserting that 0 is greater than 1. 333 334EOF 335 , 336 PHPUnit_Framework_TestFailure::exceptionToString($e) 337 ); 338 339 return; 340 } 341 342 $this->fail(); 343 } 344 345 public function testConstraintNotGreaterThan() 346 { 347 $constraint = PHPUnit_Framework_Assert::logicalNot( 348 PHPUnit_Framework_Assert::greaterThan(1) 349 ); 350 351 $this->assertTrue($constraint->evaluate(1, '', true)); 352 $this->assertEquals('is not greater than 1', $constraint->toString()); 353 $this->assertCount(1, $constraint); 354 355 try { 356 $constraint->evaluate(2); 357 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 358 $this->assertEquals( 359 <<<EOF 360Failed asserting that 2 is not greater than 1. 361 362EOF 363 , 364 PHPUnit_Framework_TestFailure::exceptionToString($e) 365 ); 366 367 return; 368 } 369 370 $this->fail(); 371 } 372 373 public function testConstraintNotGreaterThan2() 374 { 375 $constraint = PHPUnit_Framework_Assert::logicalNot( 376 PHPUnit_Framework_Assert::greaterThan(1) 377 ); 378 379 try { 380 $constraint->evaluate(2, 'custom message'); 381 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 382 $this->assertEquals( 383 <<<EOF 384custom message 385Failed asserting that 2 is not greater than 1. 386 387EOF 388 , 389 PHPUnit_Framework_TestFailure::exceptionToString($e) 390 ); 391 392 return; 393 } 394 395 $this->fail(); 396 } 397 398 public function testConstraintGreaterThanOrEqual() 399 { 400 $constraint = PHPUnit_Framework_Assert::greaterThanOrEqual(1); 401 402 $this->assertTrue($constraint->evaluate(1, '', true)); 403 $this->assertFalse($constraint->evaluate(0, '', true)); 404 $this->assertEquals('is equal to 1 or is greater than 1', $constraint->toString()); 405 $this->assertCount(2, $constraint); 406 407 try { 408 $constraint->evaluate(0); 409 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 410 $this->assertEquals( 411 <<<EOF 412Failed asserting that 0 is equal to 1 or is greater than 1. 413 414EOF 415 , 416 PHPUnit_Framework_TestFailure::exceptionToString($e) 417 ); 418 419 return; 420 } 421 422 $this->fail(); 423 } 424 425 public function testConstraintGreaterThanOrEqual2() 426 { 427 $constraint = PHPUnit_Framework_Assert::greaterThanOrEqual(1); 428 429 try { 430 $constraint->evaluate(0, 'custom message'); 431 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 432 $this->assertEquals( 433 <<<EOF 434custom message 435Failed asserting that 0 is equal to 1 or is greater than 1. 436 437EOF 438 , 439 PHPUnit_Framework_TestFailure::exceptionToString($e) 440 ); 441 442 return; 443 } 444 445 $this->fail(); 446 } 447 448 public function testConstraintNotGreaterThanOrEqual() 449 { 450 $constraint = PHPUnit_Framework_Assert::logicalNot( 451 PHPUnit_Framework_Assert::greaterThanOrEqual(1) 452 ); 453 454 $this->assertFalse($constraint->evaluate(1, '', true)); 455 $this->assertEquals('not( is equal to 1 or is greater than 1 )', $constraint->toString()); 456 $this->assertCount(2, $constraint); 457 458 try { 459 $constraint->evaluate(1); 460 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 461 $this->assertEquals( 462 <<<EOF 463Failed asserting that not( 1 is equal to 1 or is greater than 1 ). 464 465EOF 466 , 467 PHPUnit_Framework_TestFailure::exceptionToString($e) 468 ); 469 470 return; 471 } 472 473 $this->fail(); 474 } 475 476 public function testConstraintNotGreaterThanOrEqual2() 477 { 478 $constraint = PHPUnit_Framework_Assert::logicalNot( 479 PHPUnit_Framework_Assert::greaterThanOrEqual(1) 480 ); 481 482 try { 483 $constraint->evaluate(1, 'custom message'); 484 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 485 $this->assertEquals( 486 <<<EOF 487custom message 488Failed asserting that not( 1 is equal to 1 or is greater than 1 ). 489 490EOF 491 , 492 PHPUnit_Framework_TestFailure::exceptionToString($e) 493 ); 494 495 return; 496 } 497 498 $this->fail(); 499 } 500 501 public function testConstraintIsAnything() 502 { 503 $constraint = PHPUnit_Framework_Assert::anything(); 504 505 $this->assertTrue($constraint->evaluate(null, '', true)); 506 $this->assertNull($constraint->evaluate(null)); 507 $this->assertEquals('is anything', $constraint->toString()); 508 $this->assertCount(0, $constraint); 509 } 510 511 public function testConstraintNotIsAnything() 512 { 513 $constraint = PHPUnit_Framework_Assert::logicalNot( 514 PHPUnit_Framework_Assert::anything() 515 ); 516 517 $this->assertFalse($constraint->evaluate(null, '', true)); 518 $this->assertEquals('is not anything', $constraint->toString()); 519 $this->assertCount(0, $constraint); 520 521 try { 522 $constraint->evaluate(null); 523 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 524 $this->assertEquals( 525 <<<EOF 526Failed asserting that null is not anything. 527 528EOF 529 , 530 PHPUnit_Framework_TestFailure::exceptionToString($e) 531 ); 532 533 return; 534 } 535 536 $this->fail(); 537 } 538 539 public function testConstraintIsEqual() 540 { 541 $constraint = PHPUnit_Framework_Assert::equalTo(1); 542 543 $this->assertTrue($constraint->evaluate(1, '', true)); 544 $this->assertFalse($constraint->evaluate(0, '', true)); 545 $this->assertEquals('is equal to 1', $constraint->toString()); 546 $this->assertCount(1, $constraint); 547 548 try { 549 $constraint->evaluate(0); 550 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 551 $this->assertEquals( 552 <<<EOF 553Failed asserting that 0 matches expected 1. 554 555EOF 556 , 557 PHPUnit_Framework_TestFailure::exceptionToString($e) 558 ); 559 560 return; 561 } 562 563 $this->fail(); 564 } 565 566 public function isEqualProvider() 567 { 568 $a = new stdClass; 569 $a->foo = 'bar'; 570 $b = new stdClass; 571 $ahash = spl_object_hash($a); 572 $bhash = spl_object_hash($b); 573 574 $c = new stdClass; 575 $c->foo = 'bar'; 576 $c->int = 1; 577 $c->array = [0, [1], [2], 3]; 578 $c->related = new stdClass; 579 $c->related->foo = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk"; 580 $c->self = $c; 581 $c->c = $c; 582 $d = new stdClass; 583 $d->foo = 'bar'; 584 $d->int = 2; 585 $d->array = [0, [4], [2], 3]; 586 $d->related = new stdClass; 587 $d->related->foo = "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk"; 588 $d->self = $d; 589 $d->c = $c; 590 591 $storage1 = new SplObjectStorage; 592 $storage1->attach($a); 593 $storage1->attach($b); 594 $storage2 = new SplObjectStorage; 595 $storage2->attach($b); 596 $storage1hash = spl_object_hash($storage1); 597 $storage2hash = spl_object_hash($storage2); 598 599 $dom1 = new DOMDocument; 600 $dom1->preserveWhiteSpace = false; 601 $dom1->loadXML('<root></root>'); 602 $dom2 = new DOMDocument; 603 $dom2->preserveWhiteSpace = false; 604 $dom2->loadXML('<root><foo/></root>'); 605 606 $data = [ 607 [1, 0, <<<EOF 608Failed asserting that 0 matches expected 1. 609 610EOF 611 ], 612 [1.1, 0, <<<EOF 613Failed asserting that 0 matches expected 1.1. 614 615EOF 616 ], 617 ['a', 'b', <<<EOF 618Failed asserting that two strings are equal. 619--- Expected 620+++ Actual 621@@ @@ 622-'a' 623+'b' 624 625EOF 626 ], 627 ["a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk", "a\np\nc\nd\ne\nf\ng\nh\ni\nw\nk", <<<EOF 628Failed asserting that two strings are equal. 629--- Expected 630+++ Actual 631@@ @@ 632 'a 633-b 634+p 635@@ @@ 636 i 637-j 638+w 639 k' 640 641EOF 642 ], 643 [1, [0], <<<EOF 644Array (...) does not match expected type "integer". 645 646EOF 647 ], 648 [[0], 1, <<<EOF 6491 does not match expected type "array". 650 651EOF 652 ], 653 [[0], [1], <<<EOF 654Failed asserting that two arrays are equal. 655--- Expected 656+++ Actual 657@@ @@ 658 Array ( 659- 0 => 0 660+ 0 => 1 661 ) 662 663EOF 664 ], 665 [[true], ['true'], <<<EOF 666Failed asserting that two arrays are equal. 667--- Expected 668+++ Actual 669@@ @@ 670 Array ( 671- 0 => true 672+ 0 => 'true' 673 ) 674 675EOF 676 ], 677 [[0, [1], [2], 3], [0, [4], [2], 3], <<<EOF 678Failed asserting that two arrays are equal. 679--- Expected 680+++ Actual 681@@ @@ 682 Array ( 683 0 => 0 684 1 => Array ( 685- 0 => 1 686+ 0 => 4 687 ) 688 2 => Array (...) 689 3 => 3 690 ) 691 692EOF 693 ], 694 [$a, [0], <<<EOF 695Array (...) does not match expected type "object". 696 697EOF 698 ], 699 [[0], $a, <<<EOF 700stdClass Object (...) does not match expected type "array". 701 702EOF 703 ], 704 [$a, $b, <<<EOF 705Failed asserting that two objects are equal. 706--- Expected 707+++ Actual 708@@ @@ 709 stdClass Object ( 710- 'foo' => 'bar' 711 ) 712 713EOF 714 ], 715 [$c, $d, <<<EOF 716Failed asserting that two objects are equal. 717--- Expected 718+++ Actual 719@@ @@ 720 stdClass Object ( 721 'foo' => 'bar' 722- 'int' => 1 723+ 'int' => 2 724 'array' => Array ( 725 0 => 0 726 1 => Array ( 727- 0 => 1 728+ 0 => 4 729@@ @@ 730 'foo' => 'a 731- b 732+ p 733@@ @@ 734 i 735- j 736+ w 737 k' 738 ) 739 'self' => stdClass Object (...) 740 'c' => stdClass Object (...) 741 ) 742 743EOF 744 ], 745 [$dom1, $dom2, <<<EOF 746Failed asserting that two DOM documents are equal. 747--- Expected 748+++ Actual 749@@ @@ 750 <?xml version="1.0"?> 751-<root/> 752+<root> 753+ <foo/> 754+</root> 755 756EOF 757 ], 758 [ 759 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')), 760 new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/Chicago')), 761 <<<EOF 762Failed asserting that two DateTime objects are equal. 763--- Expected 764+++ Actual 765@@ @@ 766-2013-03-29T04:13:35.000000-0400 767+2013-03-29T04:13:35.000000-0500 768 769EOF 770 ], 771 ]; 772 773 if (PHP_MAJOR_VERSION < 7) { 774 $data[] = [$storage1, $storage2, <<<EOF 775Failed asserting that two objects are equal. 776--- Expected 777+++ Actual 778@@ @@ 779-SplObjectStorage Object &$storage1hash ( 780- '$ahash' => Array &0 ( 781- 'obj' => stdClass Object &$ahash ( 782- 'foo' => 'bar' 783- ) 784- 'inf' => null 785- ) 786- '$bhash' => Array &1 ( 787+SplObjectStorage Object &$storage2hash ( 788+ '$bhash' => Array &0 ( 789 'obj' => stdClass Object &$bhash () 790 'inf' => null 791 ) 792 ) 793 794EOF 795 ]; 796 } else { 797 $data[] = [$storage1, $storage2, <<<EOF 798Failed asserting that two objects are equal. 799--- Expected 800+++ Actual 801@@ @@ 802-SplObjectStorage Object &$storage1hash ( 803- '$ahash' => Array &0 ( 804- 'obj' => stdClass Object &$ahash ( 805- 'foo' => 'bar' 806- ) 807- 'inf' => null 808- ) 809- '$bhash' => Array &1 ( 810+SplObjectStorage Object &$storage2hash ( 811+ '$bhash' => Array &0 ( 812 'obj' => stdClass Object &$bhash () 813 'inf' => null 814 ) 815 ) 816 817EOF 818 ]; 819 } 820 821 return $data; 822 } 823 824 /** 825 * @dataProvider isEqualProvider 826 */ 827 public function testConstraintIsEqual2($expected, $actual, $message) 828 { 829 $constraint = PHPUnit_Framework_Assert::equalTo($expected); 830 831 try { 832 $constraint->evaluate($actual, 'custom message'); 833 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 834 $this->assertEquals( 835 "custom message\n$message", 836 $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e)) 837 ); 838 839 return; 840 } 841 842 $this->fail(); 843 } 844 845 public function testConstraintIsNotEqual() 846 { 847 $constraint = PHPUnit_Framework_Assert::logicalNot( 848 PHPUnit_Framework_Assert::equalTo(1) 849 ); 850 851 $this->assertTrue($constraint->evaluate(0, '', true)); 852 $this->assertFalse($constraint->evaluate(1, '', true)); 853 $this->assertEquals('is not equal to 1', $constraint->toString()); 854 $this->assertCount(1, $constraint); 855 856 try { 857 $constraint->evaluate(1); 858 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 859 $this->assertEquals( 860 <<<EOF 861Failed asserting that 1 is not equal to 1. 862 863EOF 864 , 865 PHPUnit_Framework_TestFailure::exceptionToString($e) 866 ); 867 868 return; 869 } 870 871 $this->fail(); 872 } 873 874 public function testConstraintIsNotEqual2() 875 { 876 $constraint = PHPUnit_Framework_Assert::logicalNot( 877 PHPUnit_Framework_Assert::equalTo(1) 878 ); 879 880 try { 881 $constraint->evaluate(1, 'custom message'); 882 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 883 $this->assertEquals( 884 <<<EOF 885custom message 886Failed asserting that 1 is not equal to 1. 887 888EOF 889 , 890 PHPUnit_Framework_TestFailure::exceptionToString($e) 891 ); 892 893 return; 894 } 895 896 $this->fail(); 897 } 898 899 public function testConstraintIsIdentical() 900 { 901 $a = new stdClass; 902 $b = new stdClass; 903 904 $constraint = PHPUnit_Framework_Assert::identicalTo($a); 905 906 $this->assertFalse($constraint->evaluate($b, '', true)); 907 $this->assertTrue($constraint->evaluate($a, '', true)); 908 $this->assertEquals('is identical to an object of class "stdClass"', $constraint->toString()); 909 $this->assertCount(1, $constraint); 910 911 try { 912 $constraint->evaluate($b); 913 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 914 $this->assertEquals(<<<EOF 915Failed asserting that two variables reference the same object. 916 917EOF 918 , 919 PHPUnit_Framework_TestFailure::exceptionToString($e) 920 ); 921 922 return; 923 } 924 925 $this->fail(); 926 } 927 928 public function testConstraintIsIdentical2() 929 { 930 $a = new stdClass; 931 $b = new stdClass; 932 933 $constraint = PHPUnit_Framework_Assert::identicalTo($a); 934 935 try { 936 $constraint->evaluate($b, 'custom message'); 937 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 938 $this->assertEquals(<<<EOF 939custom message 940Failed asserting that two variables reference the same object. 941 942EOF 943 , 944 PHPUnit_Framework_TestFailure::exceptionToString($e) 945 ); 946 947 return; 948 } 949 950 $this->fail(); 951 } 952 953 public function testConstraintIsIdentical3() 954 { 955 $constraint = PHPUnit_Framework_Assert::identicalTo('a'); 956 957 try { 958 $constraint->evaluate('b', 'custom message'); 959 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 960 $this->assertEquals(<<<EOF 961custom message 962Failed asserting that two strings are identical. 963--- Expected 964+++ Actual 965@@ @@ 966-a 967+b 968 969EOF 970 , 971 PHPUnit_Framework_TestFailure::exceptionToString($e) 972 ); 973 974 return; 975 } 976 977 $this->fail(); 978 } 979 980 public function testConstraintIsNotIdentical() 981 { 982 $a = new stdClass; 983 $b = new stdClass; 984 985 $constraint = PHPUnit_Framework_Assert::logicalNot( 986 PHPUnit_Framework_Assert::identicalTo($a) 987 ); 988 989 $this->assertTrue($constraint->evaluate($b, '', true)); 990 $this->assertFalse($constraint->evaluate($a, '', true)); 991 $this->assertEquals('is not identical to an object of class "stdClass"', $constraint->toString()); 992 $this->assertCount(1, $constraint); 993 994 try { 995 $constraint->evaluate($a); 996 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 997 $this->assertEquals(<<<EOF 998Failed asserting that two variables don't reference the same object. 999 1000EOF 1001 , 1002 $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e)) 1003 ); 1004 1005 return; 1006 } 1007 1008 $this->fail(); 1009 } 1010 1011 public function testConstraintIsNotIdentical2() 1012 { 1013 $a = new stdClass; 1014 1015 $constraint = PHPUnit_Framework_Assert::logicalNot( 1016 PHPUnit_Framework_Assert::identicalTo($a) 1017 ); 1018 1019 try { 1020 $constraint->evaluate($a, 'custom message'); 1021 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1022 $this->assertEquals(<<<EOF 1023custom message 1024Failed asserting that two variables don't reference the same object. 1025 1026EOF 1027 , 1028 PHPUnit_Framework_TestFailure::exceptionToString($e) 1029 ); 1030 1031 return; 1032 } 1033 1034 $this->fail(); 1035 } 1036 1037 public function testConstraintIsNotIdentical3() 1038 { 1039 $constraint = PHPUnit_Framework_Assert::logicalNot( 1040 PHPUnit_Framework_Assert::identicalTo('a') 1041 ); 1042 1043 try { 1044 $constraint->evaluate('a', 'custom message'); 1045 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1046 $this->assertEquals(<<<EOF 1047custom message 1048Failed asserting that two strings are not identical. 1049 1050EOF 1051 , 1052 $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e)) 1053 ); 1054 1055 return; 1056 } 1057 1058 $this->fail(); 1059 } 1060 1061 public function testConstraintIsInstanceOf() 1062 { 1063 $constraint = PHPUnit_Framework_Assert::isInstanceOf('Exception'); 1064 1065 $this->assertFalse($constraint->evaluate(new stdClass, '', true)); 1066 $this->assertTrue($constraint->evaluate(new Exception, '', true)); 1067 $this->assertEquals('is instance of class "Exception"', $constraint->toString()); 1068 $this->assertCount(1, $constraint); 1069 1070 $interfaceConstraint = PHPUnit_Framework_Assert::isInstanceOf('Countable'); 1071 $this->assertFalse($interfaceConstraint->evaluate(new stdClass, '', true)); 1072 $this->assertTrue($interfaceConstraint->evaluate(new ArrayObject, '', true)); 1073 $this->assertEquals('is instance of interface "Countable"', $interfaceConstraint->toString()); 1074 1075 try { 1076 $constraint->evaluate(new stdClass); 1077 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1078 $this->assertEquals( 1079 <<<EOF 1080Failed asserting that stdClass Object () is an instance of class "Exception". 1081 1082EOF 1083 , 1084 PHPUnit_Framework_TestFailure::exceptionToString($e) 1085 ); 1086 1087 return; 1088 } 1089 1090 $this->fail(); 1091 } 1092 1093 public function testConstraintIsInstanceOf2() 1094 { 1095 $constraint = PHPUnit_Framework_Assert::isInstanceOf('Exception'); 1096 1097 try { 1098 $constraint->evaluate(new stdClass, 'custom message'); 1099 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1100 $this->assertEquals(<<<EOF 1101custom message 1102Failed asserting that stdClass Object () is an instance of class "Exception". 1103 1104EOF 1105 , 1106 PHPUnit_Framework_TestFailure::exceptionToString($e) 1107 ); 1108 1109 return; 1110 } 1111 1112 $this->fail(); 1113 } 1114 1115 public function testConstraintIsNotInstanceOf() 1116 { 1117 $constraint = PHPUnit_Framework_Assert::logicalNot( 1118 PHPUnit_Framework_Assert::isInstanceOf('stdClass') 1119 ); 1120 1121 $this->assertFalse($constraint->evaluate(new stdClass, '', true)); 1122 $this->assertTrue($constraint->evaluate(new Exception, '', true)); 1123 $this->assertEquals('is not instance of class "stdClass"', $constraint->toString()); 1124 $this->assertCount(1, $constraint); 1125 1126 try { 1127 $constraint->evaluate(new stdClass); 1128 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1129 $this->assertEquals( 1130 <<<EOF 1131Failed asserting that stdClass Object () is not an instance of class "stdClass". 1132 1133EOF 1134 , 1135 PHPUnit_Framework_TestFailure::exceptionToString($e) 1136 ); 1137 1138 return; 1139 } 1140 1141 $this->fail(); 1142 } 1143 1144 public function testConstraintIsNotInstanceOf2() 1145 { 1146 $constraint = PHPUnit_Framework_Assert::logicalNot( 1147 PHPUnit_Framework_Assert::isInstanceOf('stdClass') 1148 ); 1149 1150 try { 1151 $constraint->evaluate(new stdClass, 'custom message'); 1152 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1153 $this->assertEquals(<<<EOF 1154custom message 1155Failed asserting that stdClass Object () is not an instance of class "stdClass". 1156 1157EOF 1158 , 1159 PHPUnit_Framework_TestFailure::exceptionToString($e) 1160 ); 1161 1162 return; 1163 } 1164 1165 $this->fail(); 1166 } 1167 1168 public function testConstraintIsType() 1169 { 1170 $constraint = PHPUnit_Framework_Assert::isType('string'); 1171 1172 $this->assertFalse($constraint->evaluate(0, '', true)); 1173 $this->assertTrue($constraint->evaluate('', '', true)); 1174 $this->assertEquals('is of type "string"', $constraint->toString()); 1175 $this->assertCount(1, $constraint); 1176 1177 try { 1178 $constraint->evaluate(new stdClass); 1179 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1180 $this->assertStringMatchesFormat(<<<EOF 1181Failed asserting that stdClass Object &%x () is of type "string". 1182 1183EOF 1184 , 1185 $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e)) 1186 ); 1187 1188 return; 1189 } 1190 1191 $this->fail(); 1192 } 1193 1194 public function testConstraintIsType2() 1195 { 1196 $constraint = PHPUnit_Framework_Assert::isType('string'); 1197 1198 try { 1199 $constraint->evaluate(new stdClass, 'custom message'); 1200 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1201 $this->assertStringMatchesFormat(<<<EOF 1202custom message 1203Failed asserting that stdClass Object &%x () is of type "string". 1204 1205EOF 1206 , 1207 $this->trimnl(PHPUnit_Framework_TestFailure::exceptionToString($e)) 1208 ); 1209 1210 return; 1211 } 1212 1213 $this->fail(); 1214 } 1215 1216 public function resources() 1217 { 1218 $fh = fopen(__FILE__, 'r'); 1219 fclose($fh); 1220 1221 return [ 1222 'open resource' => [fopen(__FILE__, 'r')], 1223 'closed resource' => [$fh], 1224 ]; 1225 } 1226 1227 /** 1228 * @dataProvider resources 1229 */ 1230 public function testConstraintIsResourceTypeEvaluatesCorrectlyWithResources($resource) 1231 { 1232 $constraint = PHPUnit_Framework_Assert::isType('resource'); 1233 1234 $this->assertTrue($constraint->evaluate($resource, '', true)); 1235 1236 @fclose($resource); 1237 } 1238 1239 public function testConstraintIsNotType() 1240 { 1241 $constraint = PHPUnit_Framework_Assert::logicalNot( 1242 PHPUnit_Framework_Assert::isType('string') 1243 ); 1244 1245 $this->assertTrue($constraint->evaluate(0, '', true)); 1246 $this->assertFalse($constraint->evaluate('', '', true)); 1247 $this->assertEquals('is not of type "string"', $constraint->toString()); 1248 $this->assertCount(1, $constraint); 1249 1250 try { 1251 $constraint->evaluate(''); 1252 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1253 $this->assertEquals( 1254 <<<EOF 1255Failed asserting that '' is not of type "string". 1256 1257EOF 1258 , 1259 PHPUnit_Framework_TestFailure::exceptionToString($e) 1260 ); 1261 1262 return; 1263 } 1264 1265 $this->fail(); 1266 } 1267 1268 public function testConstraintIsNotType2() 1269 { 1270 $constraint = PHPUnit_Framework_Assert::logicalNot( 1271 PHPUnit_Framework_Assert::isType('string') 1272 ); 1273 1274 try { 1275 $constraint->evaluate('', 'custom message'); 1276 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1277 $this->assertEquals(<<<EOF 1278custom message 1279Failed asserting that '' is not of type "string". 1280 1281EOF 1282 , 1283 PHPUnit_Framework_TestFailure::exceptionToString($e) 1284 ); 1285 1286 return; 1287 } 1288 1289 $this->fail(); 1290 } 1291 1292 public function testConstraintIsNull() 1293 { 1294 $constraint = PHPUnit_Framework_Assert::isNull(); 1295 1296 $this->assertFalse($constraint->evaluate(0, '', true)); 1297 $this->assertTrue($constraint->evaluate(null, '', true)); 1298 $this->assertEquals('is null', $constraint->toString()); 1299 $this->assertCount(1, $constraint); 1300 1301 try { 1302 $constraint->evaluate(0); 1303 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1304 $this->assertEquals(<<<EOF 1305Failed asserting that 0 is null. 1306 1307EOF 1308 , 1309 PHPUnit_Framework_TestFailure::exceptionToString($e) 1310 ); 1311 1312 return; 1313 } 1314 1315 $this->fail(); 1316 } 1317 1318 public function testConstraintIsNull2() 1319 { 1320 $constraint = PHPUnit_Framework_Assert::isNull(); 1321 1322 try { 1323 $constraint->evaluate(0, 'custom message'); 1324 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1325 $this->assertEquals(<<<EOF 1326custom message 1327Failed asserting that 0 is null. 1328 1329EOF 1330 , 1331 PHPUnit_Framework_TestFailure::exceptionToString($e) 1332 ); 1333 1334 return; 1335 } 1336 1337 $this->fail(); 1338 } 1339 1340 public function testConstraintIsNotNull() 1341 { 1342 $constraint = PHPUnit_Framework_Assert::logicalNot( 1343 PHPUnit_Framework_Assert::isNull() 1344 ); 1345 1346 $this->assertFalse($constraint->evaluate(null, '', true)); 1347 $this->assertTrue($constraint->evaluate(0, '', true)); 1348 $this->assertEquals('is not null', $constraint->toString()); 1349 $this->assertCount(1, $constraint); 1350 1351 try { 1352 $constraint->evaluate(null); 1353 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1354 $this->assertEquals(<<<EOF 1355Failed asserting that null is not null. 1356 1357EOF 1358 , 1359 PHPUnit_Framework_TestFailure::exceptionToString($e) 1360 ); 1361 1362 return; 1363 } 1364 1365 $this->fail(); 1366 } 1367 1368 public function testConstraintIsNotNull2() 1369 { 1370 $constraint = PHPUnit_Framework_Assert::logicalNot( 1371 PHPUnit_Framework_Assert::isNull() 1372 ); 1373 1374 try { 1375 $constraint->evaluate(null, 'custom message'); 1376 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1377 $this->assertEquals(<<<EOF 1378custom message 1379Failed asserting that null is not null. 1380 1381EOF 1382 , 1383 PHPUnit_Framework_TestFailure::exceptionToString($e) 1384 ); 1385 1386 return; 1387 } 1388 1389 $this->fail(); 1390 } 1391 1392 public function testConstraintLessThan() 1393 { 1394 $constraint = PHPUnit_Framework_Assert::lessThan(1); 1395 1396 $this->assertTrue($constraint->evaluate(0, '', true)); 1397 $this->assertFalse($constraint->evaluate(1, '', true)); 1398 $this->assertEquals('is less than 1', $constraint->toString()); 1399 $this->assertCount(1, $constraint); 1400 1401 try { 1402 $constraint->evaluate(1); 1403 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1404 $this->assertEquals( 1405 <<<EOF 1406Failed asserting that 1 is less than 1. 1407 1408EOF 1409 , 1410 PHPUnit_Framework_TestFailure::exceptionToString($e) 1411 ); 1412 1413 return; 1414 } 1415 1416 $this->fail(); 1417 } 1418 1419 public function testConstraintLessThan2() 1420 { 1421 $constraint = PHPUnit_Framework_Assert::lessThan(1); 1422 1423 try { 1424 $constraint->evaluate(1, 'custom message'); 1425 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1426 $this->assertEquals( 1427 <<<EOF 1428custom message 1429Failed asserting that 1 is less than 1. 1430 1431EOF 1432 , 1433 PHPUnit_Framework_TestFailure::exceptionToString($e) 1434 ); 1435 1436 return; 1437 } 1438 1439 $this->fail(); 1440 } 1441 1442 public function testConstraintNotLessThan() 1443 { 1444 $constraint = PHPUnit_Framework_Assert::logicalNot( 1445 PHPUnit_Framework_Assert::lessThan(1) 1446 ); 1447 1448 $this->assertTrue($constraint->evaluate(1, '', true)); 1449 $this->assertFalse($constraint->evaluate(0, '', true)); 1450 $this->assertEquals('is not less than 1', $constraint->toString()); 1451 $this->assertCount(1, $constraint); 1452 1453 try { 1454 $constraint->evaluate(0); 1455 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1456 $this->assertEquals( 1457 <<<EOF 1458Failed asserting that 0 is not less than 1. 1459 1460EOF 1461 , 1462 PHPUnit_Framework_TestFailure::exceptionToString($e) 1463 ); 1464 1465 return; 1466 } 1467 1468 $this->fail(); 1469 } 1470 1471 public function testConstraintNotLessThan2() 1472 { 1473 $constraint = PHPUnit_Framework_Assert::logicalNot( 1474 PHPUnit_Framework_Assert::lessThan(1) 1475 ); 1476 1477 try { 1478 $constraint->evaluate(0, 'custom message'); 1479 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1480 $this->assertEquals( 1481 <<<EOF 1482custom message 1483Failed asserting that 0 is not less than 1. 1484 1485EOF 1486 , 1487 PHPUnit_Framework_TestFailure::exceptionToString($e) 1488 ); 1489 1490 return; 1491 } 1492 1493 $this->fail(); 1494 } 1495 1496 public function testConstraintLessThanOrEqual() 1497 { 1498 $constraint = PHPUnit_Framework_Assert::lessThanOrEqual(1); 1499 1500 $this->assertTrue($constraint->evaluate(1, '', true)); 1501 $this->assertFalse($constraint->evaluate(2, '', true)); 1502 $this->assertEquals('is equal to 1 or is less than 1', $constraint->toString()); 1503 $this->assertCount(2, $constraint); 1504 1505 try { 1506 $constraint->evaluate(2); 1507 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1508 $this->assertEquals( 1509 <<<EOF 1510Failed asserting that 2 is equal to 1 or is less than 1. 1511 1512EOF 1513 , 1514 PHPUnit_Framework_TestFailure::exceptionToString($e) 1515 ); 1516 1517 return; 1518 } 1519 1520 $this->fail(); 1521 } 1522 1523 public function testConstraintCallback() 1524 { 1525 $closureReflect = function ($parameter) { 1526 return $parameter; 1527 }; 1528 1529 $closureWithoutParameter = function () { 1530 return true; 1531 }; 1532 1533 $constraint = PHPUnit_Framework_Assert::callback($closureWithoutParameter); 1534 $this->assertTrue($constraint->evaluate('', '', true)); 1535 1536 $constraint = PHPUnit_Framework_Assert::callback($closureReflect); 1537 $this->assertTrue($constraint->evaluate(true, '', true)); 1538 $this->assertFalse($constraint->evaluate(false, '', true)); 1539 1540 $callback = [$this, 'callbackReturningTrue']; 1541 $constraint = PHPUnit_Framework_Assert::callback($callback); 1542 $this->assertTrue($constraint->evaluate(false, '', true)); 1543 1544 $callback = ['Framework_ConstraintTest', 'staticCallbackReturningTrue']; 1545 $constraint = PHPUnit_Framework_Assert::callback($callback); 1546 $this->assertTrue($constraint->evaluate(null, '', true)); 1547 1548 $this->assertEquals('is accepted by specified callback', $constraint->toString()); 1549 } 1550 1551 /** 1552 * @expectedException PHPUnit_Framework_ExpectationFailedException 1553 * @expectedExceptionMessage Failed asserting that 'This fails' is accepted by specified callback. 1554 */ 1555 public function testConstraintCallbackFailure() 1556 { 1557 $constraint = PHPUnit_Framework_Assert::callback(function () { 1558 return false; 1559 }); 1560 $constraint->evaluate('This fails'); 1561 } 1562 1563 public function callbackReturningTrue() 1564 { 1565 return true; 1566 } 1567 1568 public static function staticCallbackReturningTrue() 1569 { 1570 return true; 1571 } 1572 1573 public function testConstraintLessThanOrEqual2() 1574 { 1575 $constraint = PHPUnit_Framework_Assert::lessThanOrEqual(1); 1576 1577 try { 1578 $constraint->evaluate(2, 'custom message'); 1579 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1580 $this->assertEquals( 1581 <<<EOF 1582custom message 1583Failed asserting that 2 is equal to 1 or is less than 1. 1584 1585EOF 1586 , 1587 PHPUnit_Framework_TestFailure::exceptionToString($e) 1588 ); 1589 1590 return; 1591 } 1592 1593 $this->fail(); 1594 } 1595 1596 public function testConstraintNotLessThanOrEqual() 1597 { 1598 $constraint = PHPUnit_Framework_Assert::logicalNot( 1599 PHPUnit_Framework_Assert::lessThanOrEqual(1) 1600 ); 1601 1602 $this->assertTrue($constraint->evaluate(2, '', true)); 1603 $this->assertFalse($constraint->evaluate(1, '', true)); 1604 $this->assertEquals('not( is equal to 1 or is less than 1 )', $constraint->toString()); 1605 $this->assertCount(2, $constraint); 1606 1607 try { 1608 $constraint->evaluate(1); 1609 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1610 $this->assertEquals( 1611 <<<EOF 1612Failed asserting that not( 1 is equal to 1 or is less than 1 ). 1613 1614EOF 1615 , 1616 PHPUnit_Framework_TestFailure::exceptionToString($e) 1617 ); 1618 1619 return; 1620 } 1621 1622 $this->fail(); 1623 } 1624 1625 public function testConstraintNotLessThanOrEqual2() 1626 { 1627 $constraint = PHPUnit_Framework_Assert::logicalNot( 1628 PHPUnit_Framework_Assert::lessThanOrEqual(1) 1629 ); 1630 1631 try { 1632 $constraint->evaluate(1, 'custom message'); 1633 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1634 $this->assertEquals( 1635 <<<EOF 1636custom message 1637Failed asserting that not( 1 is equal to 1 or is less than 1 ). 1638 1639EOF 1640 , 1641 PHPUnit_Framework_TestFailure::exceptionToString($e) 1642 ); 1643 1644 return; 1645 } 1646 1647 $this->fail(); 1648 } 1649 1650 public function testConstraintClassHasAttribute() 1651 { 1652 $constraint = PHPUnit_Framework_Assert::classHasAttribute('privateAttribute'); 1653 1654 $this->assertTrue($constraint->evaluate('ClassWithNonPublicAttributes', '', true)); 1655 $this->assertFalse($constraint->evaluate('stdClass', '', true)); 1656 $this->assertEquals('has attribute "privateAttribute"', $constraint->toString()); 1657 $this->assertCount(1, $constraint); 1658 1659 try { 1660 $constraint->evaluate('stdClass'); 1661 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1662 $this->assertEquals( 1663 <<<EOF 1664Failed asserting that class "stdClass" has attribute "privateAttribute". 1665 1666EOF 1667 , 1668 PHPUnit_Framework_TestFailure::exceptionToString($e) 1669 ); 1670 1671 return; 1672 } 1673 1674 $this->fail(); 1675 } 1676 1677 public function testConstraintClassHasAttribute2() 1678 { 1679 $constraint = PHPUnit_Framework_Assert::classHasAttribute('privateAttribute'); 1680 1681 try { 1682 $constraint->evaluate('stdClass', 'custom message'); 1683 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1684 $this->assertEquals(<<<EOF 1685custom message 1686Failed asserting that class "stdClass" has attribute "privateAttribute". 1687 1688EOF 1689 , 1690 PHPUnit_Framework_TestFailure::exceptionToString($e) 1691 ); 1692 1693 return; 1694 } 1695 1696 $this->fail(); 1697 } 1698 1699 public function testConstraintClassNotHasAttribute() 1700 { 1701 $constraint = PHPUnit_Framework_Assert::logicalNot( 1702 PHPUnit_Framework_Assert::classHasAttribute('privateAttribute') 1703 ); 1704 1705 $this->assertTrue($constraint->evaluate('stdClass', '', true)); 1706 $this->assertFalse($constraint->evaluate('ClassWithNonPublicAttributes', '', true)); 1707 $this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString()); 1708 $this->assertCount(1, $constraint); 1709 1710 try { 1711 $constraint->evaluate('ClassWithNonPublicAttributes'); 1712 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1713 $this->assertEquals( 1714 <<<EOF 1715Failed asserting that class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute". 1716 1717EOF 1718 , 1719 PHPUnit_Framework_TestFailure::exceptionToString($e) 1720 ); 1721 1722 return; 1723 } 1724 1725 $this->fail(); 1726 } 1727 1728 public function testConstraintClassNotHasAttribute2() 1729 { 1730 $constraint = PHPUnit_Framework_Assert::logicalNot( 1731 PHPUnit_Framework_Assert::classHasAttribute('privateAttribute') 1732 ); 1733 1734 try { 1735 $constraint->evaluate('ClassWithNonPublicAttributes', 'custom message'); 1736 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1737 $this->assertEquals(<<<EOF 1738custom message 1739Failed asserting that class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute". 1740 1741EOF 1742 , 1743 PHPUnit_Framework_TestFailure::exceptionToString($e) 1744 ); 1745 1746 return; 1747 } 1748 1749 $this->fail(); 1750 } 1751 1752 public function testConstraintClassHasStaticAttribute() 1753 { 1754 $constraint = PHPUnit_Framework_Assert::classHasStaticAttribute('privateStaticAttribute'); 1755 1756 $this->assertTrue($constraint->evaluate('ClassWithNonPublicAttributes', '', true)); 1757 $this->assertFalse($constraint->evaluate('stdClass', '', true)); 1758 $this->assertEquals('has static attribute "privateStaticAttribute"', $constraint->toString()); 1759 $this->assertCount(1, $constraint); 1760 1761 try { 1762 $constraint->evaluate('stdClass'); 1763 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1764 $this->assertEquals( 1765 <<<EOF 1766Failed asserting that class "stdClass" has static attribute "privateStaticAttribute". 1767 1768EOF 1769 , 1770 PHPUnit_Framework_TestFailure::exceptionToString($e) 1771 ); 1772 1773 return; 1774 } 1775 1776 $this->fail(); 1777 } 1778 1779 public function testConstraintClassHasStaticAttribute2() 1780 { 1781 $constraint = PHPUnit_Framework_Assert::classHasStaticAttribute('foo'); 1782 1783 try { 1784 $constraint->evaluate('stdClass', 'custom message'); 1785 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1786 $this->assertEquals(<<<EOF 1787custom message 1788Failed asserting that class "stdClass" has static attribute "foo". 1789 1790EOF 1791 , 1792 PHPUnit_Framework_TestFailure::exceptionToString($e) 1793 ); 1794 1795 return; 1796 } 1797 1798 $this->fail(); 1799 } 1800 1801 public function testConstraintClassNotHasStaticAttribute() 1802 { 1803 $constraint = PHPUnit_Framework_Assert::logicalNot( 1804 PHPUnit_Framework_Assert::classHasStaticAttribute('privateStaticAttribute') 1805 ); 1806 1807 $this->assertTrue($constraint->evaluate('stdClass', '', true)); 1808 $this->assertFalse($constraint->evaluate('ClassWithNonPublicAttributes', '', true)); 1809 $this->assertEquals('does not have static attribute "privateStaticAttribute"', $constraint->toString()); 1810 $this->assertCount(1, $constraint); 1811 1812 try { 1813 $constraint->evaluate('ClassWithNonPublicAttributes'); 1814 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1815 $this->assertEquals( 1816 <<<EOF 1817Failed asserting that class "ClassWithNonPublicAttributes" does not have static attribute "privateStaticAttribute". 1818 1819EOF 1820 , 1821 PHPUnit_Framework_TestFailure::exceptionToString($e) 1822 ); 1823 1824 return; 1825 } 1826 1827 $this->fail(); 1828 } 1829 1830 public function testConstraintClassNotHasStaticAttribute2() 1831 { 1832 $constraint = PHPUnit_Framework_Assert::logicalNot( 1833 PHPUnit_Framework_Assert::classHasStaticAttribute('privateStaticAttribute') 1834 ); 1835 1836 try { 1837 $constraint->evaluate('ClassWithNonPublicAttributes', 'custom message'); 1838 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1839 $this->assertEquals(<<<EOF 1840custom message 1841Failed asserting that class "ClassWithNonPublicAttributes" does not have static attribute "privateStaticAttribute". 1842 1843EOF 1844 , 1845 PHPUnit_Framework_TestFailure::exceptionToString($e) 1846 ); 1847 1848 return; 1849 } 1850 1851 $this->fail(); 1852 } 1853 1854 public function testConstraintObjectHasAttribute() 1855 { 1856 $constraint = PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute'); 1857 1858 $this->assertTrue($constraint->evaluate(new ClassWithNonPublicAttributes, '', true)); 1859 $this->assertFalse($constraint->evaluate(new stdClass, '', true)); 1860 $this->assertEquals('has attribute "privateAttribute"', $constraint->toString()); 1861 $this->assertCount(1, $constraint); 1862 1863 try { 1864 $constraint->evaluate(new stdClass); 1865 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1866 $this->assertEquals( 1867 <<<EOF 1868Failed asserting that object of class "stdClass" has attribute "privateAttribute". 1869 1870EOF 1871 , 1872 PHPUnit_Framework_TestFailure::exceptionToString($e) 1873 ); 1874 1875 return; 1876 } 1877 1878 $this->fail(); 1879 } 1880 1881 public function testConstraintObjectHasAttribute2() 1882 { 1883 $constraint = PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute'); 1884 1885 try { 1886 $constraint->evaluate(new stdClass, 'custom message'); 1887 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1888 $this->assertEquals(<<<EOF 1889custom message 1890Failed asserting that object of class "stdClass" has attribute "privateAttribute". 1891 1892EOF 1893 , 1894 PHPUnit_Framework_TestFailure::exceptionToString($e) 1895 ); 1896 1897 return; 1898 } 1899 1900 $this->fail(); 1901 } 1902 1903 public function testConstraintObjectNotHasAttribute() 1904 { 1905 $constraint = PHPUnit_Framework_Assert::logicalNot( 1906 PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute') 1907 ); 1908 1909 $this->assertTrue($constraint->evaluate(new stdClass, '', true)); 1910 $this->assertFalse($constraint->evaluate(new ClassWithNonPublicAttributes, '', true)); 1911 $this->assertEquals('does not have attribute "privateAttribute"', $constraint->toString()); 1912 $this->assertCount(1, $constraint); 1913 1914 try { 1915 $constraint->evaluate(new ClassWithNonPublicAttributes); 1916 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1917 $this->assertEquals( 1918 <<<EOF 1919Failed asserting that object of class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute". 1920 1921EOF 1922 , 1923 PHPUnit_Framework_TestFailure::exceptionToString($e) 1924 ); 1925 1926 return; 1927 } 1928 1929 $this->fail(); 1930 } 1931 1932 public function testConstraintObjectNotHasAttribute2() 1933 { 1934 $constraint = PHPUnit_Framework_Assert::logicalNot( 1935 PHPUnit_Framework_Assert::objectHasAttribute('privateAttribute') 1936 ); 1937 1938 try { 1939 $constraint->evaluate(new ClassWithNonPublicAttributes, 'custom message'); 1940 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1941 $this->assertEquals(<<<EOF 1942custom message 1943Failed asserting that object of class "ClassWithNonPublicAttributes" does not have attribute "privateAttribute". 1944 1945EOF 1946 , 1947 PHPUnit_Framework_TestFailure::exceptionToString($e) 1948 ); 1949 1950 return; 1951 } 1952 1953 $this->fail(); 1954 } 1955 1956 public function testConstraintPCREMatch() 1957 { 1958 $constraint = PHPUnit_Framework_Assert::matchesRegularExpression('/foo/'); 1959 1960 $this->assertFalse($constraint->evaluate('barbazbar', '', true)); 1961 $this->assertTrue($constraint->evaluate('barfoobar', '', true)); 1962 $this->assertEquals('matches PCRE pattern "/foo/"', $constraint->toString()); 1963 $this->assertCount(1, $constraint); 1964 1965 try { 1966 $constraint->evaluate('barbazbar'); 1967 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1968 $this->assertEquals( 1969 <<<EOF 1970Failed asserting that 'barbazbar' matches PCRE pattern "/foo/". 1971 1972EOF 1973 , 1974 PHPUnit_Framework_TestFailure::exceptionToString($e) 1975 ); 1976 1977 return; 1978 } 1979 1980 $this->fail(); 1981 } 1982 1983 public function testConstraintPCREMatch2() 1984 { 1985 $constraint = PHPUnit_Framework_Assert::matchesRegularExpression('/foo/'); 1986 1987 try { 1988 $constraint->evaluate('barbazbar', 'custom message'); 1989 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 1990 $this->assertEquals(<<<EOF 1991custom message 1992Failed asserting that 'barbazbar' matches PCRE pattern "/foo/". 1993 1994EOF 1995 , 1996 PHPUnit_Framework_TestFailure::exceptionToString($e) 1997 ); 1998 1999 return; 2000 } 2001 2002 $this->fail(); 2003 } 2004 2005 public function testConstraintPCRENotMatch() 2006 { 2007 $constraint = PHPUnit_Framework_Assert::logicalNot( 2008 PHPUnit_Framework_Assert::matchesRegularExpression('/foo/') 2009 ); 2010 2011 $this->assertTrue($constraint->evaluate('barbazbar', '', true)); 2012 $this->assertFalse($constraint->evaluate('barfoobar', '', true)); 2013 $this->assertEquals('does not match PCRE pattern "/foo/"', $constraint->toString()); 2014 $this->assertCount(1, $constraint); 2015 2016 try { 2017 $constraint->evaluate('barfoobar'); 2018 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2019 $this->assertEquals( 2020 <<<EOF 2021Failed asserting that 'barfoobar' does not match PCRE pattern "/foo/". 2022 2023EOF 2024 , 2025 PHPUnit_Framework_TestFailure::exceptionToString($e) 2026 ); 2027 2028 return; 2029 } 2030 2031 $this->fail(); 2032 } 2033 2034 public function testConstraintPCRENotMatch2() 2035 { 2036 $constraint = PHPUnit_Framework_Assert::logicalNot( 2037 PHPUnit_Framework_Assert::matchesRegularExpression('/foo/') 2038 ); 2039 2040 try { 2041 $constraint->evaluate('barfoobar', 'custom message'); 2042 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2043 $this->assertEquals(<<<EOF 2044custom message 2045Failed asserting that 'barfoobar' does not match PCRE pattern "/foo/". 2046 2047EOF 2048 , 2049 PHPUnit_Framework_TestFailure::exceptionToString($e) 2050 ); 2051 2052 return; 2053 } 2054 2055 $this->fail(); 2056 } 2057 2058 public function testConstraintStringMatches() 2059 { 2060 $constraint = PHPUnit_Framework_Assert::matches('*%c*'); 2061 $this->assertFalse($constraint->evaluate('**', '', true)); 2062 $this->assertTrue($constraint->evaluate('***', '', true)); 2063 $this->assertEquals('matches PCRE pattern "/^\*.\*$/s"', $constraint->toString()); 2064 $this->assertCount(1, $constraint); 2065 } 2066 2067 public function testConstraintStringMatches2() 2068 { 2069 $constraint = PHPUnit_Framework_Assert::matches('*%s*'); 2070 $this->assertFalse($constraint->evaluate('**', '', true)); 2071 $this->assertTrue($constraint->evaluate('***', '', true)); 2072 $this->assertEquals('matches PCRE pattern "/^\*[^\r\n]+\*$/s"', $constraint->toString()); 2073 $this->assertCount(1, $constraint); 2074 } 2075 2076 public function testConstraintStringMatches3() 2077 { 2078 $constraint = PHPUnit_Framework_Assert::matches('*%i*'); 2079 $this->assertFalse($constraint->evaluate('**', '', true)); 2080 $this->assertTrue($constraint->evaluate('*0*', '', true)); 2081 $this->assertEquals('matches PCRE pattern "/^\*[+-]?\d+\*$/s"', $constraint->toString()); 2082 $this->assertCount(1, $constraint); 2083 } 2084 2085 public function testConstraintStringMatches4() 2086 { 2087 $constraint = PHPUnit_Framework_Assert::matches('*%d*'); 2088 $this->assertFalse($constraint->evaluate('**', '', true)); 2089 $this->assertTrue($constraint->evaluate('*0*', '', true)); 2090 $this->assertEquals('matches PCRE pattern "/^\*\d+\*$/s"', $constraint->toString()); 2091 $this->assertCount(1, $constraint); 2092 } 2093 2094 public function testConstraintStringMatches5() 2095 { 2096 $constraint = PHPUnit_Framework_Assert::matches('*%x*'); 2097 $this->assertFalse($constraint->evaluate('**', '', true)); 2098 $this->assertTrue($constraint->evaluate('*0f0f0f*', '', true)); 2099 $this->assertEquals('matches PCRE pattern "/^\*[0-9a-fA-F]+\*$/s"', $constraint->toString()); 2100 $this->assertCount(1, $constraint); 2101 } 2102 2103 public function testConstraintStringMatches6() 2104 { 2105 $constraint = PHPUnit_Framework_Assert::matches('*%f*'); 2106 $this->assertFalse($constraint->evaluate('**', '', true)); 2107 $this->assertTrue($constraint->evaluate('*1.0*', '', true)); 2108 $this->assertEquals('matches PCRE pattern "/^\*[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?\*$/s"', $constraint->toString()); 2109 $this->assertCount(1, $constraint); 2110 } 2111 2112 public function testConstraintStringStartsWith() 2113 { 2114 $constraint = PHPUnit_Framework_Assert::stringStartsWith('prefix'); 2115 2116 $this->assertFalse($constraint->evaluate('foo', '', true)); 2117 $this->assertTrue($constraint->evaluate('prefixfoo', '', true)); 2118 $this->assertEquals('starts with "prefix"', $constraint->toString()); 2119 $this->assertCount(1, $constraint); 2120 2121 try { 2122 $constraint->evaluate('foo'); 2123 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2124 $this->assertEquals( 2125 <<<EOF 2126Failed asserting that 'foo' starts with "prefix". 2127 2128EOF 2129 , 2130 PHPUnit_Framework_TestFailure::exceptionToString($e) 2131 ); 2132 2133 return; 2134 } 2135 2136 $this->fail(); 2137 } 2138 2139 public function testConstraintStringStartsWith2() 2140 { 2141 $constraint = PHPUnit_Framework_Assert::stringStartsWith('prefix'); 2142 2143 try { 2144 $constraint->evaluate('foo', 'custom message'); 2145 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2146 $this->assertEquals( 2147 <<<EOF 2148custom message\nFailed asserting that 'foo' starts with "prefix". 2149 2150EOF 2151 , 2152 PHPUnit_Framework_TestFailure::exceptionToString($e) 2153 ); 2154 2155 return; 2156 } 2157 2158 $this->fail(); 2159 } 2160 2161 public function testConstraintStringStartsNotWith() 2162 { 2163 $constraint = PHPUnit_Framework_Assert::logicalNot( 2164 PHPUnit_Framework_Assert::stringStartsWith('prefix') 2165 ); 2166 2167 $this->assertTrue($constraint->evaluate('foo', '', true)); 2168 $this->assertFalse($constraint->evaluate('prefixfoo', '', true)); 2169 $this->assertEquals('starts not with "prefix"', $constraint->toString()); 2170 $this->assertCount(1, $constraint); 2171 2172 try { 2173 $constraint->evaluate('prefixfoo'); 2174 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2175 $this->assertEquals( 2176 <<<EOF 2177Failed asserting that 'prefixfoo' starts not with "prefix". 2178 2179EOF 2180 , 2181 PHPUnit_Framework_TestFailure::exceptionToString($e) 2182 ); 2183 2184 return; 2185 } 2186 2187 $this->fail(); 2188 } 2189 2190 public function testConstraintStringStartsNotWith2() 2191 { 2192 $constraint = PHPUnit_Framework_Assert::logicalNot( 2193 PHPUnit_Framework_Assert::stringStartsWith('prefix') 2194 ); 2195 2196 try { 2197 $constraint->evaluate('prefixfoo', 'custom message'); 2198 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2199 $this->assertEquals( 2200 <<<EOF 2201custom message 2202Failed asserting that 'prefixfoo' starts not with "prefix". 2203 2204EOF 2205 , 2206 PHPUnit_Framework_TestFailure::exceptionToString($e) 2207 ); 2208 2209 return; 2210 } 2211 2212 $this->fail(); 2213 } 2214 2215 public function testConstraintStringContains() 2216 { 2217 $constraint = PHPUnit_Framework_Assert::stringContains('foo'); 2218 2219 $this->assertFalse($constraint->evaluate('barbazbar', '', true)); 2220 $this->assertTrue($constraint->evaluate('barfoobar', '', true)); 2221 $this->assertEquals('contains "foo"', $constraint->toString()); 2222 $this->assertCount(1, $constraint); 2223 2224 try { 2225 $constraint->evaluate('barbazbar'); 2226 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2227 $this->assertEquals( 2228 <<<EOF 2229Failed asserting that 'barbazbar' contains "foo". 2230 2231EOF 2232 , 2233 PHPUnit_Framework_TestFailure::exceptionToString($e) 2234 ); 2235 2236 return; 2237 } 2238 2239 $this->fail(); 2240 } 2241 2242 public function testConstraintStringContainsWhenIgnoreCase() 2243 { 2244 $constraint = PHPUnit_Framework_Assert::stringContains('oryginał', true); 2245 2246 $this->assertFalse($constraint->evaluate('oryginal', '', true)); 2247 $this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true)); 2248 $this->assertTrue($constraint->evaluate('oryginał', '', true)); 2249 $this->assertEquals('contains "oryginał"', $constraint->toString()); 2250 $this->assertEquals(1, count($constraint)); 2251 2252 try { 2253 $constraint->evaluate('oryginal'); 2254 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2255 $this->assertEquals( 2256 <<<EOF 2257Failed asserting that 'oryginal' contains "oryginał". 2258 2259EOF 2260 , 2261 PHPUnit_Framework_TestFailure::exceptionToString($e) 2262 ); 2263 2264 return; 2265 } 2266 2267 $this->fail(); 2268 } 2269 2270 public function testConstraintStringContainsForUtf8StringWhenNotIgnoreCase() 2271 { 2272 $constraint = PHPUnit_Framework_Assert::stringContains('oryginał', false); 2273 2274 $this->assertFalse($constraint->evaluate('oryginal', '', true)); 2275 $this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true)); 2276 $this->assertTrue($constraint->evaluate('oryginał', '', true)); 2277 $this->assertEquals('contains "oryginał"', $constraint->toString()); 2278 $this->assertEquals(1, count($constraint)); 2279 2280 try { 2281 $constraint->evaluate('oryginal'); 2282 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2283 $this->assertEquals( 2284 <<<EOF 2285Failed asserting that 'oryginal' contains "oryginał". 2286 2287EOF 2288 , 2289 PHPUnit_Framework_TestFailure::exceptionToString($e) 2290 ); 2291 2292 return; 2293 } 2294 2295 $this->fail(); 2296 } 2297 2298 public function testConstraintStringContains2() 2299 { 2300 $constraint = PHPUnit_Framework_Assert::stringContains('foo'); 2301 2302 try { 2303 $constraint->evaluate('barbazbar', 'custom message'); 2304 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2305 $this->assertEquals( 2306 <<<EOF 2307custom message 2308Failed asserting that 'barbazbar' contains "foo". 2309 2310EOF 2311 , 2312 PHPUnit_Framework_TestFailure::exceptionToString($e) 2313 ); 2314 2315 return; 2316 } 2317 2318 $this->fail(); 2319 } 2320 2321 public function testConstraintStringNotContains() 2322 { 2323 $constraint = PHPUnit_Framework_Assert::logicalNot( 2324 PHPUnit_Framework_Assert::stringContains('foo') 2325 ); 2326 2327 $this->assertTrue($constraint->evaluate('barbazbar', '', true)); 2328 $this->assertFalse($constraint->evaluate('barfoobar', '', true)); 2329 $this->assertEquals('does not contain "foo"', $constraint->toString()); 2330 $this->assertCount(1, $constraint); 2331 2332 try { 2333 $constraint->evaluate('barfoobar'); 2334 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2335 $this->assertEquals( 2336 <<<EOF 2337Failed asserting that 'barfoobar' does not contain "foo". 2338 2339EOF 2340 , 2341 PHPUnit_Framework_TestFailure::exceptionToString($e) 2342 ); 2343 2344 return; 2345 } 2346 2347 $this->fail(); 2348 } 2349 2350 public function testConstraintStringNotContainsWhenIgnoreCase() 2351 { 2352 $constraint = PHPUnit_Framework_Assert::logicalNot( 2353 PHPUnit_Framework_Assert::stringContains('oryginał') 2354 ); 2355 2356 $this->assertTrue($constraint->evaluate('original', '', true)); 2357 $this->assertFalse($constraint->evaluate('ORYGINAŁ', '', true)); 2358 $this->assertFalse($constraint->evaluate('oryginał', '', true)); 2359 $this->assertEquals('does not contain "oryginał"', $constraint->toString()); 2360 $this->assertEquals(1, count($constraint)); 2361 2362 try { 2363 $constraint->evaluate('ORYGINAŁ'); 2364 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2365 $this->assertEquals( 2366 <<<EOF 2367Failed asserting that 'ORYGINAŁ' does not contain "oryginał". 2368 2369EOF 2370 , 2371 PHPUnit_Framework_TestFailure::exceptionToString($e) 2372 ); 2373 2374 return; 2375 } 2376 2377 $this->fail(); 2378 } 2379 2380 public function testConstraintStringNotContainsForUtf8StringWhenNotIgnoreCase() 2381 { 2382 $constraint = PHPUnit_Framework_Assert::logicalNot( 2383 PHPUnit_Framework_Assert::stringContains('oryginał', false) 2384 ); 2385 2386 $this->assertTrue($constraint->evaluate('original', '', true)); 2387 $this->assertTrue($constraint->evaluate('ORYGINAŁ', '', true)); 2388 $this->assertFalse($constraint->evaluate('oryginał', '', true)); 2389 $this->assertEquals('does not contain "oryginał"', $constraint->toString()); 2390 $this->assertEquals(1, count($constraint)); 2391 2392 try { 2393 $constraint->evaluate('oryginał'); 2394 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2395 $this->assertEquals( 2396 <<<EOF 2397Failed asserting that 'oryginał' does not contain "oryginał". 2398 2399EOF 2400 , 2401 PHPUnit_Framework_TestFailure::exceptionToString($e) 2402 ); 2403 2404 return; 2405 } 2406 2407 $this->fail(); 2408 } 2409 2410 public function testConstraintStringNotContains2() 2411 { 2412 $constraint = PHPUnit_Framework_Assert::logicalNot( 2413 PHPUnit_Framework_Assert::stringContains('foo') 2414 ); 2415 2416 try { 2417 $constraint->evaluate('barfoobar', 'custom message'); 2418 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2419 $this->assertEquals( 2420 <<<EOF 2421custom message 2422Failed asserting that 'barfoobar' does not contain "foo". 2423 2424EOF 2425 , 2426 PHPUnit_Framework_TestFailure::exceptionToString($e) 2427 ); 2428 2429 return; 2430 } 2431 2432 $this->fail(); 2433 } 2434 2435 public function testConstraintStringEndsWith() 2436 { 2437 $constraint = PHPUnit_Framework_Assert::stringEndsWith('suffix'); 2438 2439 $this->assertFalse($constraint->evaluate('foo', '', true)); 2440 $this->assertTrue($constraint->evaluate('foosuffix', '', true)); 2441 $this->assertEquals('ends with "suffix"', $constraint->toString()); 2442 $this->assertCount(1, $constraint); 2443 2444 try { 2445 $constraint->evaluate('foo'); 2446 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2447 $this->assertEquals( 2448 <<<EOF 2449Failed asserting that 'foo' ends with "suffix". 2450 2451EOF 2452 , 2453 PHPUnit_Framework_TestFailure::exceptionToString($e) 2454 ); 2455 2456 return; 2457 } 2458 2459 $this->fail(); 2460 } 2461 2462 public function testConstraintStringEndsWith2() 2463 { 2464 $constraint = PHPUnit_Framework_Assert::stringEndsWith('suffix'); 2465 2466 try { 2467 $constraint->evaluate('foo', 'custom message'); 2468 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2469 $this->assertEquals( 2470 <<<EOF 2471custom message 2472Failed asserting that 'foo' ends with "suffix". 2473 2474EOF 2475 , 2476 PHPUnit_Framework_TestFailure::exceptionToString($e) 2477 ); 2478 2479 return; 2480 } 2481 2482 $this->fail(); 2483 } 2484 2485 public function testConstraintStringEndsNotWith() 2486 { 2487 $constraint = PHPUnit_Framework_Assert::logicalNot( 2488 PHPUnit_Framework_Assert::stringEndsWith('suffix') 2489 ); 2490 2491 $this->assertTrue($constraint->evaluate('foo', '', true)); 2492 $this->assertFalse($constraint->evaluate('foosuffix', '', true)); 2493 $this->assertEquals('ends not with "suffix"', $constraint->toString()); 2494 $this->assertCount(1, $constraint); 2495 2496 try { 2497 $constraint->evaluate('foosuffix'); 2498 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2499 $this->assertEquals( 2500 <<<EOF 2501Failed asserting that 'foosuffix' ends not with "suffix". 2502 2503EOF 2504 , 2505 PHPUnit_Framework_TestFailure::exceptionToString($e) 2506 ); 2507 2508 return; 2509 } 2510 2511 $this->fail(); 2512 } 2513 2514 public function testConstraintStringEndsNotWith2() 2515 { 2516 $constraint = PHPUnit_Framework_Assert::logicalNot( 2517 PHPUnit_Framework_Assert::stringEndsWith('suffix') 2518 ); 2519 2520 try { 2521 $constraint->evaluate('foosuffix', 'custom message'); 2522 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2523 $this->assertEquals( 2524 <<<EOF 2525custom message 2526Failed asserting that 'foosuffix' ends not with "suffix". 2527 2528EOF 2529 , 2530 PHPUnit_Framework_TestFailure::exceptionToString($e) 2531 ); 2532 2533 return; 2534 } 2535 2536 $this->fail(); 2537 } 2538 2539 public function testConstraintArrayContainsCheckForObjectIdentity() 2540 { 2541 // Check for primitive type. 2542 $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo', true, true); 2543 2544 $this->assertFalse($constraint->evaluate([0], '', true)); 2545 $this->assertFalse($constraint->evaluate([true], '', true)); 2546 2547 // Default case. 2548 $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo'); 2549 2550 $this->assertTrue($constraint->evaluate([0], '', true)); 2551 $this->assertTrue($constraint->evaluate([true], '', true)); 2552 } 2553 2554 public function testConstraintArrayContains() 2555 { 2556 $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo'); 2557 2558 $this->assertFalse($constraint->evaluate(['bar'], '', true)); 2559 $this->assertTrue($constraint->evaluate(['foo'], '', true)); 2560 $this->assertEquals("contains 'foo'", $constraint->toString()); 2561 $this->assertCount(1, $constraint); 2562 2563 try { 2564 $constraint->evaluate(['bar']); 2565 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2566 $this->assertEquals( 2567 <<<EOF 2568Failed asserting that an array contains 'foo'. 2569 2570EOF 2571 , 2572 PHPUnit_Framework_TestFailure::exceptionToString($e) 2573 ); 2574 2575 return; 2576 } 2577 2578 $this->fail(); 2579 } 2580 2581 public function testConstraintArrayContains2() 2582 { 2583 $constraint = new PHPUnit_Framework_Constraint_TraversableContains('foo'); 2584 2585 try { 2586 $constraint->evaluate(['bar'], 'custom message'); 2587 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2588 $this->assertEquals( 2589 <<<EOF 2590custom message 2591Failed asserting that an array contains 'foo'. 2592 2593EOF 2594 , 2595 PHPUnit_Framework_TestFailure::exceptionToString($e) 2596 ); 2597 2598 return; 2599 } 2600 2601 $this->fail(); 2602 } 2603 2604 public function testConstraintArrayNotContains() 2605 { 2606 $constraint = PHPUnit_Framework_Assert::logicalNot( 2607 new PHPUnit_Framework_Constraint_TraversableContains('foo') 2608 ); 2609 2610 $this->assertTrue($constraint->evaluate(['bar'], '', true)); 2611 $this->assertFalse($constraint->evaluate(['foo'], '', true)); 2612 $this->assertEquals("does not contain 'foo'", $constraint->toString()); 2613 $this->assertCount(1, $constraint); 2614 2615 try { 2616 $constraint->evaluate(['foo']); 2617 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2618 $this->assertEquals( 2619 <<<EOF 2620Failed asserting that an array does not contain 'foo'. 2621 2622EOF 2623 , 2624 PHPUnit_Framework_TestFailure::exceptionToString($e) 2625 ); 2626 2627 return; 2628 } 2629 2630 $this->fail(); 2631 } 2632 2633 public function testConstraintArrayNotContains2() 2634 { 2635 $constraint = PHPUnit_Framework_Assert::logicalNot( 2636 new PHPUnit_Framework_Constraint_TraversableContains('foo') 2637 ); 2638 2639 try { 2640 $constraint->evaluate(['foo'], 'custom message'); 2641 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2642 $this->assertEquals( 2643 <<<EOF 2644custom message 2645Failed asserting that an array does not contain 'foo'. 2646 2647EOF 2648 , 2649 PHPUnit_Framework_TestFailure::exceptionToString($e) 2650 ); 2651 2652 return; 2653 } 2654 2655 $this->fail(); 2656 } 2657 2658 public function testConstraintSplObjectStorageContains() 2659 { 2660 $object = new StdClass; 2661 $constraint = new PHPUnit_Framework_Constraint_TraversableContains($object); 2662 $this->assertStringMatchesFormat('contains stdClass Object &%s ()', $constraint->toString()); 2663 2664 $storage = new SplObjectStorage; 2665 $this->assertFalse($constraint->evaluate($storage, '', true)); 2666 2667 $storage->attach($object); 2668 $this->assertTrue($constraint->evaluate($storage, '', true)); 2669 2670 try { 2671 $constraint->evaluate(new SplObjectStorage); 2672 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2673 $this->assertStringMatchesFormat( 2674 <<<EOF 2675Failed asserting that a traversable contains stdClass Object &%x (). 2676 2677EOF 2678 , 2679 PHPUnit_Framework_TestFailure::exceptionToString($e) 2680 ); 2681 2682 return; 2683 } 2684 2685 $this->fail(); 2686 } 2687 2688 public function testConstraintSplObjectStorageContains2() 2689 { 2690 $object = new StdClass; 2691 $constraint = new PHPUnit_Framework_Constraint_TraversableContains($object); 2692 2693 try { 2694 $constraint->evaluate(new SplObjectStorage, 'custom message'); 2695 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2696 $this->assertStringMatchesFormat( 2697 <<<EOF 2698custom message 2699Failed asserting that a traversable contains stdClass Object &%x (). 2700 2701EOF 2702 , 2703 PHPUnit_Framework_TestFailure::exceptionToString($e) 2704 ); 2705 2706 return; 2707 } 2708 2709 $this->fail(); 2710 } 2711 2712 public function testAttributeEqualTo() 2713 { 2714 $object = new ClassWithNonPublicAttributes; 2715 $constraint = PHPUnit_Framework_Assert::attributeEqualTo('foo', 1); 2716 2717 $this->assertTrue($constraint->evaluate($object, '', true)); 2718 $this->assertEquals('attribute "foo" is equal to 1', $constraint->toString()); 2719 $this->assertCount(1, $constraint); 2720 2721 $constraint = PHPUnit_Framework_Assert::attributeEqualTo('foo', 2); 2722 2723 $this->assertFalse($constraint->evaluate($object, '', true)); 2724 2725 try { 2726 $constraint->evaluate($object); 2727 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2728 $this->assertEquals( 2729 <<<EOF 2730Failed asserting that attribute "foo" is equal to 2. 2731 2732EOF 2733 , 2734 PHPUnit_Framework_TestFailure::exceptionToString($e) 2735 ); 2736 2737 return; 2738 } 2739 2740 $this->fail(); 2741 } 2742 2743 public function testAttributeEqualTo2() 2744 { 2745 $object = new ClassWithNonPublicAttributes; 2746 $constraint = PHPUnit_Framework_Assert::attributeEqualTo('foo', 2); 2747 2748 try { 2749 $constraint->evaluate($object, 'custom message'); 2750 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2751 $this->assertEquals( 2752 <<<EOF 2753custom message\nFailed asserting that attribute "foo" is equal to 2. 2754 2755EOF 2756 , 2757 PHPUnit_Framework_TestFailure::exceptionToString($e) 2758 ); 2759 2760 return; 2761 } 2762 2763 $this->fail(); 2764 } 2765 2766 public function testAttributeNotEqualTo() 2767 { 2768 $object = new ClassWithNonPublicAttributes; 2769 $constraint = PHPUnit_Framework_Assert::logicalNot( 2770 PHPUnit_Framework_Assert::attributeEqualTo('foo', 2) 2771 ); 2772 2773 $this->assertTrue($constraint->evaluate($object, '', true)); 2774 $this->assertEquals('attribute "foo" is not equal to 2', $constraint->toString()); 2775 $this->assertCount(1, $constraint); 2776 2777 $constraint = PHPUnit_Framework_Assert::logicalNot( 2778 PHPUnit_Framework_Assert::attributeEqualTo('foo', 1) 2779 ); 2780 2781 $this->assertFalse($constraint->evaluate($object, '', true)); 2782 2783 try { 2784 $constraint->evaluate($object); 2785 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2786 $this->assertEquals( 2787 <<<EOF 2788Failed asserting that attribute "foo" is not equal to 1. 2789 2790EOF 2791 , 2792 PHPUnit_Framework_TestFailure::exceptionToString($e) 2793 ); 2794 2795 return; 2796 } 2797 2798 $this->fail(); 2799 } 2800 2801 public function testAttributeNotEqualTo2() 2802 { 2803 $object = new ClassWithNonPublicAttributes; 2804 $constraint = PHPUnit_Framework_Assert::logicalNot( 2805 PHPUnit_Framework_Assert::attributeEqualTo('foo', 1) 2806 ); 2807 2808 try { 2809 $constraint->evaluate($object, 'custom message'); 2810 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2811 $this->assertEquals( 2812 <<<EOF 2813custom message\nFailed asserting that attribute "foo" is not equal to 1. 2814 2815EOF 2816 , 2817 PHPUnit_Framework_TestFailure::exceptionToString($e) 2818 ); 2819 2820 return; 2821 } 2822 2823 $this->fail(); 2824 } 2825 2826 public function testConstraintIsEmpty() 2827 { 2828 $constraint = new PHPUnit_Framework_Constraint_IsEmpty; 2829 2830 $this->assertFalse($constraint->evaluate(['foo'], '', true)); 2831 $this->assertTrue($constraint->evaluate([], '', true)); 2832 $this->assertFalse($constraint->evaluate(new ArrayObject(['foo']), '', true)); 2833 $this->assertTrue($constraint->evaluate(new ArrayObject([]), '', true)); 2834 $this->assertEquals('is empty', $constraint->toString()); 2835 $this->assertCount(1, $constraint); 2836 2837 try { 2838 $constraint->evaluate(['foo']); 2839 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2840 $this->assertEquals( 2841 <<<EOF 2842Failed asserting that an array is empty. 2843 2844EOF 2845 , 2846 PHPUnit_Framework_TestFailure::exceptionToString($e) 2847 ); 2848 2849 return; 2850 } 2851 2852 $this->fail(); 2853 } 2854 2855 public function testConstraintIsEmpty2() 2856 { 2857 $constraint = new PHPUnit_Framework_Constraint_IsEmpty; 2858 2859 try { 2860 $constraint->evaluate(['foo'], 'custom message'); 2861 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2862 $this->assertEquals( 2863 <<<EOF 2864custom message\nFailed asserting that an array is empty. 2865 2866EOF 2867 , 2868 PHPUnit_Framework_TestFailure::exceptionToString($e) 2869 ); 2870 2871 return; 2872 } 2873 2874 $this->fail(); 2875 } 2876 2877 public function testConstraintCountWithAnArray() 2878 { 2879 $constraint = new PHPUnit_Framework_Constraint_Count(5); 2880 2881 $this->assertTrue($constraint->evaluate([1, 2, 3, 4, 5], '', true)); 2882 $this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true)); 2883 } 2884 2885 public function testConstraintCountWithAnIteratorWhichDoesNotImplementCountable() 2886 { 2887 $constraint = new PHPUnit_Framework_Constraint_Count(5); 2888 2889 $this->assertTrue($constraint->evaluate(new TestIterator([1, 2, 3, 4, 5]), '', true)); 2890 $this->assertFalse($constraint->evaluate(new TestIterator([1, 2, 3, 4]), '', true)); 2891 } 2892 2893 public function testConstraintCountWithAnObjectImplementingCountable() 2894 { 2895 $constraint = new PHPUnit_Framework_Constraint_Count(5); 2896 2897 $this->assertTrue($constraint->evaluate(new ArrayObject([1, 2, 3, 4, 5]), '', true)); 2898 $this->assertFalse($constraint->evaluate(new ArrayObject([1, 2, 3, 4]), '', true)); 2899 } 2900 2901 public function testConstraintCountFailing() 2902 { 2903 $constraint = new PHPUnit_Framework_Constraint_Count(5); 2904 2905 try { 2906 $constraint->evaluate([1, 2]); 2907 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2908 $this->assertEquals( 2909 <<<EOF 2910Failed asserting that actual size 2 matches expected size 5. 2911 2912EOF 2913 , 2914 PHPUnit_Framework_TestFailure::exceptionToString($e) 2915 ); 2916 2917 return; 2918 } 2919 2920 $this->fail(); 2921 } 2922 2923 public function testConstraintNotCountFailing() 2924 { 2925 $constraint = PHPUnit_Framework_Assert::logicalNot( 2926 new PHPUnit_Framework_Constraint_Count(2) 2927 ); 2928 2929 try { 2930 $constraint->evaluate([1, 2]); 2931 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2932 $this->assertEquals( 2933 <<<EOF 2934Failed asserting that actual size 2 does not match expected size 2. 2935 2936EOF 2937 , 2938 PHPUnit_Framework_TestFailure::exceptionToString($e) 2939 ); 2940 2941 return; 2942 } 2943 2944 $this->fail(); 2945 } 2946 2947 public function testConstraintSameSizeWithAnArray() 2948 { 2949 $constraint = new PHPUnit_Framework_Constraint_SameSize([1, 2, 3, 4, 5]); 2950 2951 $this->assertTrue($constraint->evaluate([6, 7, 8, 9, 10], '', true)); 2952 $this->assertFalse($constraint->evaluate([1, 2, 3, 4], '', true)); 2953 } 2954 2955 public function testConstraintSameSizeWithAnIteratorWhichDoesNotImplementCountable() 2956 { 2957 $constraint = new PHPUnit_Framework_Constraint_SameSize(new TestIterator([1, 2, 3, 4, 5])); 2958 2959 $this->assertTrue($constraint->evaluate(new TestIterator([6, 7, 8, 9, 10]), '', true)); 2960 $this->assertFalse($constraint->evaluate(new TestIterator([1, 2, 3, 4]), '', true)); 2961 } 2962 2963 public function testConstraintSameSizeWithAnObjectImplementingCountable() 2964 { 2965 $constraint = new PHPUnit_Framework_Constraint_SameSize(new ArrayObject([1, 2, 3, 4, 5])); 2966 2967 $this->assertTrue($constraint->evaluate(new ArrayObject([6, 7, 8, 9, 10]), '', true)); 2968 $this->assertFalse($constraint->evaluate(new ArrayObject([1, 2, 3, 4]), '', true)); 2969 } 2970 2971 public function testConstraintSameSizeFailing() 2972 { 2973 $constraint = new PHPUnit_Framework_Constraint_SameSize([1, 2, 3, 4, 5]); 2974 2975 try { 2976 $constraint->evaluate([1, 2]); 2977 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 2978 $this->assertEquals( 2979 <<<EOF 2980Failed asserting that actual size 2 matches expected size 5. 2981 2982EOF 2983 , 2984 PHPUnit_Framework_TestFailure::exceptionToString($e) 2985 ); 2986 2987 return; 2988 } 2989 2990 $this->fail(); 2991 } 2992 2993 public function testConstraintNotSameSizeFailing() 2994 { 2995 $constraint = PHPUnit_Framework_Assert::logicalNot( 2996 new PHPUnit_Framework_Constraint_SameSize([1, 2]) 2997 ); 2998 2999 try { 3000 $constraint->evaluate([3, 4]); 3001 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 3002 $this->assertEquals( 3003 <<<EOF 3004Failed asserting that actual size 2 does not match expected size 2. 3005 3006EOF 3007 , 3008 PHPUnit_Framework_TestFailure::exceptionToString($e) 3009 ); 3010 3011 return; 3012 } 3013 3014 $this->fail(); 3015 } 3016 3017 public function testConstraintException() 3018 { 3019 $constraint = new PHPUnit_Framework_Constraint_Exception('FoobarException'); 3020 $exception = new DummyException('Test'); 3021 $stackTrace = PHPUnit_Util_Filter::getFilteredStacktrace($exception); 3022 3023 try { 3024 $constraint->evaluate($exception); 3025 } catch (PHPUnit_Framework_ExpectationFailedException $e) { 3026 $this->assertEquals( 3027 <<<EOF 3028Failed asserting that exception of type "DummyException" matches expected exception "FoobarException". Message was: "Test" at 3029$stackTrace. 3030 3031EOF 3032 , 3033 PHPUnit_Framework_TestFailure::exceptionToString($e) 3034 ); 3035 3036 return; 3037 } 3038 3039 $this->fail(); 3040 } 3041 3042 /** 3043 * Removes spaces in front of newlines 3044 * 3045 * @param string $string 3046 * 3047 * @return string 3048 */ 3049 private function trimnl($string) 3050 { 3051 return preg_replace('/[ ]*\n/', "\n", $string); 3052 } 3053} 3054