Join Free Webinar: My Favorite Cypress Plugins |Register Now 
How to use AssertionFailedError class
Best Phpunit code snippet using AssertionFailedError
AssertTest.php
Source:AssertTest.php 
...21 public function testFail(): void22 {23 try {24 $this->fail();25 } catch (AssertionFailedError $e) {26 return;27 }28 throw new AssertionFailedError('Fail did not throw fail exception');29 }30 public function testAssertSplObjectStorageContainsObject(): void31 {32 $a = new \stdClass;33 $b = new \stdClass;34 $c = new \SplObjectStorage;35 $c->attach($a);36 $this->assertContains($a, $c);37 $this->expectException(AssertionFailedError::class);38 $this->assertContains($b, $c);39 }40 public function testAssertArrayContainsObject(): void41 {42 $a = new \stdClass;43 $b = new \stdClass;44 $this->assertContains($a, [$a]);45 $this->expectException(AssertionFailedError::class);46 $this->assertContains($a, [$b]);47 }48 public function testAssertArrayContainsString(): void49 {50 $this->assertContains('foo', ['foo']);51 $this->expectException(AssertionFailedError::class);52 $this->assertContains('foo', ['bar']);53 }54 public function testAssertArrayContainsNonObject(): void55 {56 $this->assertContains('foo', [true]);57 $this->expectException(AssertionFailedError::class);58 $this->assertContains('foo', [true], '', false, true, true);59 }60 public function testAssertContainsOnlyInstancesOf(): void61 {62 $test = [new \Book, new \Book];63 $this->assertContainsOnlyInstancesOf(\Book::class, $test);64 $this->assertContainsOnlyInstancesOf(\stdClass::class, [new \stdClass]);65 $test2 = [new \Author('Test')];66 $this->expectException(AssertionFailedError::class);67 $this->assertContainsOnlyInstancesOf(\Book::class, $test2);68 }69 public function testAssertContainsPartialStringInString(): void70 {71 $this->assertContains('bar', 'foo bar');72 $this->expectException(AssertionFailedError::class);73 $this->assertContains('cake', 'foo bar');74 }75 public function testAssertContainsNonCaseSensitiveStringInString(): void76 {77 $this->assertContains('Foo', 'foo', '', true);78 $this->expectException(AssertionFailedError::class);79 $this->assertContains('Foo', 'foo', '', false);80 }81 public function testAssertContainsEmptyStringInString(): void82 {83 $this->assertContains('', 'test');84 }85 public function testAssertStringContainsNonString(): void86 {87 $this->expectException(Exception::class);88 $this->assertContains(null, '');89 }90 public function testAssertStringNotContainsNonString(): void91 {92 $this->expectException(Exception::class);93 $this->assertNotContains(null, '');94 }95 public function testAssertArrayHasKeyThrowsExceptionForInvalidFirstArgument(): void96 {97 $this->expectException(Exception::class);98 $this->assertArrayHasKey(null, []);99 }100 public function testAssertArrayHasKeyThrowsExceptionForInvalidSecondArgument(): void101 {102 $this->expectException(Exception::class);103 $this->assertArrayHasKey(0, null);104 }105 public function testAssertArrayHasIntegerKey(): void106 {107 $this->assertArrayHasKey(0, ['foo']);108 $this->expectException(AssertionFailedError::class);109 $this->assertArrayHasKey(1, ['foo']);110 }111 public function testAssertArraySubset(): void112 {113 $array = [114 'a' => 'item a',115 'b' => 'item b',116 'c' => ['a2' => 'item a2', 'b2' => 'item b2'],117 'd' => ['a2' => ['a3' => 'item a3', 'b3' => 'item b3']],118 ];119 $this->assertArraySubset(['a' => 'item a', 'c' => ['a2' => 'item a2']], $array);120 $this->assertArraySubset(['a' => 'item a', 'd' => ['a2' => ['b3' => 'item b3']]], $array);121 $arrayAccessData = new \ArrayObject($array);122 $this->assertArraySubset(['a' => 'item a', 'c' => ['a2' => 'item a2']], $arrayAccessData);123 $this->assertArraySubset(['a' => 'item a', 'd' => ['a2' => ['b3' => 'item b3']]], $arrayAccessData);124 try {125 $this->assertArraySubset(['a' => 'bad value'], $array);126 } catch (AssertionFailedError $e) {127 }128 try {129 $this->assertArraySubset(['d' => ['a2' => ['bad index' => 'item b3']]], $array);130 } catch (AssertionFailedError $e) {131 return;132 }133 $this->fail();134 }135 public function testAssertArraySubsetWithDeepNestedArrays(): void136 {137 $array = [138 'path' => [139 'to' => [140 'the' => [141 'cake' => 'is a lie',142 ],143 ],144 ],145 ];146 $this->assertArraySubset(['path' => []], $array);147 $this->assertArraySubset(['path' => ['to' => []]], $array);148 $this->assertArraySubset(['path' => ['to' => ['the' => []]]], $array);149 $this->assertArraySubset(['path' => ['to' => ['the' => ['cake' => 'is a lie']]]], $array);150 $this->expectException(AssertionFailedError::class);151 $this->assertArraySubset(['path' => ['to' => ['the' => ['cake' => 'is not a lie']]]], $array);152 }153 public function testAssertArraySubsetWithNoStrictCheckAndObjects(): void154 {155 $obj = new \stdClass;156 $reference = &$obj;157 $array = ['a' => $obj];158 $this->assertArraySubset(['a' => $reference], $array);159 $this->assertArraySubset(['a' => new \stdClass], $array);160 }161 public function testAssertArraySubsetWithStrictCheckAndObjects(): void162 {163 $obj = new \stdClass;164 $reference = &$obj;165 $array = ['a' => $obj];166 $this->assertArraySubset(['a' => $reference], $array, true);167 $this->expectException(AssertionFailedError::class);168 $this->assertArraySubset(['a' => new \stdClass], $array, true);169 }170 /**171 * @dataProvider assertArraySubsetInvalidArgumentProvider172 *173 * @throws Exception174 * @throws ExpectationFailedException175 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException176 */177 public function testAssertArraySubsetRaisesExceptionForInvalidArguments($partial, $subject): void178 {179 $this->expectException(Exception::class);180 $this->assertArraySubset($partial, $subject);181 }182 public function assertArraySubsetInvalidArgumentProvider(): array183 {184 return [185 [false, []],186 [[], false],187 ];188 }189 public function testAssertArrayNotHasKeyThrowsExceptionForInvalidFirstArgument(): void190 {191 $this->expectException(Exception::class);192 $this->assertArrayNotHasKey(null, []);193 }194 public function testAssertArrayNotHasKeyThrowsExceptionForInvalidSecondArgument(): void195 {196 $this->expectException(Exception::class);197 $this->assertArrayNotHasKey(0, null);198 }199 public function testAssertArrayNotHasIntegerKey(): void200 {201 $this->assertArrayNotHasKey(1, ['foo']);202 $this->expectException(AssertionFailedError::class);203 $this->assertArrayNotHasKey(0, ['foo']);204 }205 public function testAssertArrayHasStringKey(): void206 {207 $this->assertArrayHasKey('foo', ['foo' => 'bar']);208 $this->expectException(AssertionFailedError::class);209 $this->assertArrayHasKey('bar', ['foo' => 'bar']);210 }211 public function testAssertArrayNotHasStringKey(): void212 {213 $this->assertArrayNotHasKey('bar', ['foo' => 'bar']);214 $this->expectException(AssertionFailedError::class);215 $this->assertArrayNotHasKey('foo', ['foo' => 'bar']);216 }217 public function testAssertArrayHasKeyAcceptsArrayObjectValue(): void218 {219 $array = new \ArrayObject;220 $array['foo'] = 'bar';221 $this->assertArrayHasKey('foo', $array);222 }223 public function testAssertArrayHasKeyProperlyFailsWithArrayObjectValue(): void224 {225 $array = new \ArrayObject;226 $array['bar'] = 'bar';227 $this->expectException(AssertionFailedError::class);228 $this->assertArrayHasKey('foo', $array);229 }230 public function testAssertArrayHasKeyAcceptsArrayAccessValue(): void231 {232 $array = new \SampleArrayAccess;233 $array['foo'] = 'bar';234 $this->assertArrayHasKey('foo', $array);235 }236 public function testAssertArrayHasKeyProperlyFailsWithArrayAccessValue(): void237 {238 $array = new \SampleArrayAccess;239 $array['bar'] = 'bar';240 $this->expectException(AssertionFailedError::class);241 $this->assertArrayHasKey('foo', $array);242 }243 public function testAssertArrayNotHasKeyAcceptsArrayAccessValue(): void244 {245 $array = new \ArrayObject;246 $array['foo'] = 'bar';247 $this->assertArrayNotHasKey('bar', $array);248 }249 public function testAssertArrayNotHasKeyPropertlyFailsWithArrayAccessValue(): void250 {251 $array = new \ArrayObject;252 $array['bar'] = 'bar';253 $this->expectException(AssertionFailedError::class);254 $this->assertArrayNotHasKey('bar', $array);255 }256 public function testAssertContainsThrowsException(): void257 {258 $this->expectException(Exception::class);259 $this->assertContains(null, null);260 }261 public function testAssertIteratorContainsObject(): void262 {263 $foo = new \stdClass;264 $this->assertContains($foo, new \TestIterator([$foo]));265 $this->expectException(AssertionFailedError::class);266 $this->assertContains($foo, new \TestIterator([new \stdClass]));267 }268 public function testAssertIteratorContainsString(): void269 {270 $this->assertContains('foo', new \TestIterator(['foo']));271 $this->expectException(AssertionFailedError::class);272 $this->assertContains('foo', new \TestIterator(['bar']));273 }274 public function testAssertStringContainsString(): void275 {276 $this->assertContains('foo', 'foobar');277 $this->expectException(AssertionFailedError::class);278 $this->assertContains('foo', 'bar');279 }280 public function testAssertStringContainsStringForUtf8(): void281 {282 $this->assertContains('oryginaÅ', 'oryginaÅ');283 $this->expectException(AssertionFailedError::class);284 $this->assertContains('ORYGINAÅ', 'oryginaÅ');285 }286 public function testAssertStringContainsStringForUtf8WhenIgnoreCase(): void287 {288 $this->assertContains('oryginaÅ', 'oryginaÅ', '', true);289 $this->assertContains('ORYGINAÅ', 'oryginaÅ', '', true);290 $this->expectException(AssertionFailedError::class);291 $this->assertContains('foo', 'oryginaÅ', '', true);292 }293 public function testAssertNotContainsThrowsException(): void294 {295 $this->expectException(Exception::class);296 $this->assertNotContains(null, null);297 }298 public function testAssertSplObjectStorageNotContainsObject(): void299 {300 $a = new \stdClass;301 $b = new \stdClass;302 $c = new \SplObjectStorage;303 $c->attach($a);304 $this->assertNotContains($b, $c);305 $this->expectException(AssertionFailedError::class);306 $this->assertNotContains($a, $c);307 }308 public function testAssertArrayNotContainsObject(): void309 {310 $a = new \stdClass;311 $b = new \stdClass;312 $this->assertNotContains($a, [$b]);313 $this->expectException(AssertionFailedError::class);314 $this->assertNotContains($a, [$a]);315 }316 public function testAssertArrayNotContainsString(): void317 {318 $this->assertNotContains('foo', ['bar']);319 $this->expectException(AssertionFailedError::class);320 $this->assertNotContains('foo', ['foo']);321 }322 public function testAssertArrayNotContainsNonObject(): void323 {324 $this->assertNotContains('foo', [true], '', false, true, true);325 $this->expectException(AssertionFailedError::class);326 $this->assertNotContains('foo', [true]);327 }328 public function testAssertStringNotContainsString(): void329 {330 $this->assertNotContains('foo', 'bar');331 $this->expectException(AssertionFailedError::class);332 $this->assertNotContains('foo', 'foo');333 }334 public function testAssertStringNotContainsStringForUtf8(): void335 {336 $this->assertNotContains('ORYGINAÅ', 'oryginaÅ');337 $this->expectException(AssertionFailedError::class);338 $this->assertNotContains('oryginaÅ', 'oryginaÅ');339 }340 public function testAssertStringNotContainsStringForUtf8WhenIgnoreCase(): void341 {342 $this->expectException(AssertionFailedError::class);343 $this->assertNotContains('ORYGINAÅ', 'oryginaÅ', '', true);344 }345 public function testAssertArrayContainsOnlyIntegers(): void346 {347 $this->assertContainsOnly('integer', [1, 2, 3]);348 $this->expectException(AssertionFailedError::class);349 $this->assertContainsOnly('integer', ['1', 2, 3]);350 }351 public function testAssertArrayNotContainsOnlyIntegers(): void352 {353 $this->assertNotContainsOnly('integer', ['1', 2, 3]);354 $this->expectException(AssertionFailedError::class);355 $this->assertNotContainsOnly('integer', [1, 2, 3]);356 }357 public function testAssertArrayContainsOnlyStdClass(): void358 {359 $this->assertContainsOnly('StdClass', [new \stdClass]);360 $this->expectException(AssertionFailedError::class);361 $this->assertContainsOnly('StdClass', ['StdClass']);362 }363 public function testAssertArrayNotContainsOnlyStdClass(): void364 {365 $this->assertNotContainsOnly('StdClass', ['StdClass']);366 $this->expectException(AssertionFailedError::class);367 $this->assertNotContainsOnly('StdClass', [new \stdClass]);368 }369 public function equalProvider(): array370 {371 // same |= equal372 return \array_merge($this->equalValues(), $this->sameValues());373 }374 public function notEqualProvider()375 {376 return $this->notEqualValues();377 }378 public function sameProvider(): array379 {380 return $this->sameValues();381 }382 public function notSameProvider(): array383 {384 // not equal |= not same385 // equal, ¬same |= not same386 return \array_merge($this->notEqualValues(), $this->equalValues());387 }388 /**389 * @dataProvider equalProvider390 *391 * @throws ExpectationFailedException392 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException393 */394 public function testAssertEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false): void395 {396 $this->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);397 }398 /**399 * @dataProvider notEqualProvider400 *401 * @throws ExpectationFailedException402 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException403 */404 public function testAssertEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false): void405 {406 $this->expectException(AssertionFailedError::class);407 $this->assertEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);408 }409 /**410 * @dataProvider notEqualProvider411 *412 * @throws ExpectationFailedException413 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException414 */415 public function testAssertNotEqualsSucceeds($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false): void416 {417 $this->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);418 }419 /**420 * @dataProvider equalProvider421 *422 * @throws ExpectationFailedException423 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException424 */425 public function testAssertNotEqualsFails($a, $b, $delta = 0.0, $canonicalize = false, $ignoreCase = false): void426 {427 $this->expectException(AssertionFailedError::class);428 $this->assertNotEquals($a, $b, '', $delta, 10, $canonicalize, $ignoreCase);429 }430 /**431 * @dataProvider sameProvider432 *433 * @throws ExpectationFailedException434 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException435 */436 public function testAssertSameSucceeds($a, $b): void437 {438 $this->assertSame($a, $b);439 }440 /**441 * @dataProvider notSameProvider442 *443 * @throws ExpectationFailedException444 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException445 */446 public function testAssertSameFails($a, $b): void447 {448 $this->expectException(AssertionFailedError::class);449 $this->assertSame($a, $b);450 }451 /**452 * @dataProvider notSameProvider453 *454 * @throws ExpectationFailedException455 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException456 */457 public function testAssertNotSameSucceeds($a, $b): void458 {459 $this->assertNotSame($a, $b);460 }461 /**462 * @dataProvider sameProvider463 *464 * @throws ExpectationFailedException465 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException466 */467 public function testAssertNotSameFails($a, $b): void468 {469 $this->expectException(AssertionFailedError::class);470 $this->assertNotSame($a, $b);471 }472 public function testAssertXmlFileEqualsXmlFile(): void473 {474 $this->assertXmlFileEqualsXmlFile(475 TEST_FILES_PATH . 'foo.xml',476 TEST_FILES_PATH . 'foo.xml'477 );478 $this->expectException(AssertionFailedError::class);479 $this->assertXmlFileEqualsXmlFile(480 TEST_FILES_PATH . 'foo.xml',481 TEST_FILES_PATH . 'bar.xml'482 );483 }484 public function testAssertXmlFileNotEqualsXmlFile(): void485 {486 $this->assertXmlFileNotEqualsXmlFile(487 TEST_FILES_PATH . 'foo.xml',488 TEST_FILES_PATH . 'bar.xml'489 );490 $this->expectException(AssertionFailedError::class);491 $this->assertXmlFileNotEqualsXmlFile(492 TEST_FILES_PATH . 'foo.xml',493 TEST_FILES_PATH . 'foo.xml'494 );495 }496 public function testAssertXmlStringEqualsXmlFile(): void497 {498 $this->assertXmlStringEqualsXmlFile(499 TEST_FILES_PATH . 'foo.xml',500 \file_get_contents(TEST_FILES_PATH . 'foo.xml')501 );502 $this->expectException(AssertionFailedError::class);503 $this->assertXmlStringEqualsXmlFile(504 TEST_FILES_PATH . 'foo.xml',505 \file_get_contents(TEST_FILES_PATH . 'bar.xml')506 );507 }508 public function testXmlStringNotEqualsXmlFile(): void509 {510 $this->assertXmlStringNotEqualsXmlFile(511 TEST_FILES_PATH . 'foo.xml',512 \file_get_contents(TEST_FILES_PATH . 'bar.xml')513 );514 $this->expectException(AssertionFailedError::class);515 $this->assertXmlStringNotEqualsXmlFile(516 TEST_FILES_PATH . 'foo.xml',517 \file_get_contents(TEST_FILES_PATH . 'foo.xml')518 );519 }520 public function testAssertXmlStringEqualsXmlString(): void521 {522 $this->assertXmlStringEqualsXmlString('<root/>', '<root/>');523 $this->expectException(AssertionFailedError::class);524 $this->assertXmlStringEqualsXmlString('<foo/>', '<bar/>');525 }526 /**527 * @ticket 1860528 */529 public function testAssertXmlStringEqualsXmlString2(): void530 {531 $this->expectException(Exception::class);532 $this->assertXmlStringEqualsXmlString('<a></b>', '<c></d>');533 }534 /**535 * @ticket 1860536 */537 public function testAssertXmlStringEqualsXmlString3(): void538 {539 $expected = <<<XML540<?xml version="1.0"?>541<root>542 <node />543</root>544XML;545 $actual = <<<XML546<?xml version="1.0"?>547<root>548<node />549</root>550XML;551 $this->assertXmlStringEqualsXmlString($expected, $actual);552 }553 public function testAssertXmlStringNotEqualsXmlString(): void554 {555 $this->assertXmlStringNotEqualsXmlString('<foo/>', '<bar/>');556 $this->expectException(AssertionFailedError::class);557 $this->assertXmlStringNotEqualsXmlString('<root/>', '<root/>');558 }559 public function testXMLStructureIsSame(): void560 {561 $expected = new \DOMDocument;562 $expected->load(TEST_FILES_PATH . 'structureExpected.xml');563 $actual = new \DOMDocument;564 $actual->load(TEST_FILES_PATH . 'structureExpected.xml');565 $this->assertEqualXMLStructure(566 $expected->firstChild,567 $actual->firstChild,568 true569 );570 }571 public function testXMLStructureWrongNumberOfAttributes(): void572 {573 $expected = new \DOMDocument;574 $expected->load(TEST_FILES_PATH . 'structureExpected.xml');575 $actual = new \DOMDocument;576 $actual->load(TEST_FILES_PATH . 'structureWrongNumberOfAttributes.xml');577 $this->expectException(ExpectationFailedException::class);578 $this->assertEqualXMLStructure(579 $expected->firstChild,580 $actual->firstChild,581 true582 );583 }584 public function testXMLStructureWrongNumberOfNodes(): void585 {586 $expected = new \DOMDocument;587 $expected->load(TEST_FILES_PATH . 'structureExpected.xml');588 $actual = new \DOMDocument;589 $actual->load(TEST_FILES_PATH . 'structureWrongNumberOfNodes.xml');590 $this->expectException(ExpectationFailedException::class);591 $this->assertEqualXMLStructure(592 $expected->firstChild,593 $actual->firstChild,594 true595 );596 }597 public function testXMLStructureIsSameButDataIsNot(): void598 {599 $expected = new \DOMDocument;600 $expected->load(TEST_FILES_PATH . 'structureExpected.xml');601 $actual = new \DOMDocument;602 $actual->load(TEST_FILES_PATH . 'structureIsSameButDataIsNot.xml');603 $this->assertEqualXMLStructure(604 $expected->firstChild,605 $actual->firstChild,606 true607 );608 }609 public function testXMLStructureAttributesAreSameButValuesAreNot(): void610 {611 $expected = new \DOMDocument;612 $expected->load(TEST_FILES_PATH . 'structureExpected.xml');613 $actual = new \DOMDocument;614 $actual->load(TEST_FILES_PATH . 'structureAttributesAreSameButValuesAreNot.xml');615 $this->assertEqualXMLStructure(616 $expected->firstChild,617 $actual->firstChild,618 true619 );620 }621 public function testXMLStructureIgnoreTextNodes(): void622 {623 $expected = new \DOMDocument;624 $expected->load(TEST_FILES_PATH . 'structureExpected.xml');625 $actual = new \DOMDocument;626 $actual->load(TEST_FILES_PATH . 'structureIgnoreTextNodes.xml');627 $this->assertEqualXMLStructure(628 $expected->firstChild,629 $actual->firstChild,630 true631 );632 }633 public function testAssertStringEqualsNumeric(): void634 {635 $this->assertEquals('0', 0);636 $this->expectException(AssertionFailedError::class);637 $this->assertEquals('0', 1);638 }639 public function testAssertStringEqualsNumeric2(): void640 {641 $this->assertNotEquals('A', 0);642 }643 public function testAssertIsReadable(): void644 {645 $this->assertIsReadable(__FILE__);646 $this->expectException(AssertionFailedError::class);647 $this->assertIsReadable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');648 }649 public function testAssertNotIsReadable(): void650 {651 $this->assertNotIsReadable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');652 $this->expectException(AssertionFailedError::class);653 $this->assertNotIsReadable(__FILE__);654 }655 public function testAssertIsWritable(): void656 {657 $this->assertIsWritable(__FILE__);658 $this->expectException(AssertionFailedError::class);659 $this->assertIsWritable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');660 }661 public function testAssertNotIsWritable(): void662 {663 $this->assertNotIsWritable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');664 $this->expectException(AssertionFailedError::class);665 $this->assertNotIsWritable(__FILE__);666 }667 public function testAssertDirectoryExists(): void668 {669 $this->assertDirectoryExists(__DIR__);670 $this->expectException(AssertionFailedError::class);671 $this->assertDirectoryExists(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');672 }673 public function testAssertDirectoryNotExists(): void674 {675 $this->assertDirectoryNotExists(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');676 $this->expectException(AssertionFailedError::class);677 $this->assertDirectoryNotExists(__DIR__);678 }679 public function testAssertDirectoryIsReadable(): void680 {681 $this->assertDirectoryIsReadable(__DIR__);682 $this->expectException(AssertionFailedError::class);683 $this->assertDirectoryIsReadable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');684 }685 public function testAssertDirectoryIsWritable(): void686 {687 $this->assertDirectoryIsWritable(__DIR__);688 $this->expectException(AssertionFailedError::class);689 $this->assertDirectoryIsWritable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');690 }691 public function testAssertFileExists(): void692 {693 $this->assertFileExists(__FILE__);694 $this->expectException(AssertionFailedError::class);695 $this->assertFileExists(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');696 }697 public function testAssertFileNotExists(): void698 {699 $this->assertFileNotExists(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');700 $this->expectException(AssertionFailedError::class);701 $this->assertFileNotExists(__FILE__);702 }703 public function testAssertFileIsReadable(): void704 {705 $this->assertFileIsReadable(__FILE__);706 $this->expectException(AssertionFailedError::class);707 $this->assertFileIsReadable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');708 }709 public function testAssertFileIsWritable(): void710 {711 $this->assertFileIsWritable(__FILE__);712 $this->expectException(AssertionFailedError::class);713 $this->assertFileIsWritable(__DIR__ . \DIRECTORY_SEPARATOR . 'NotExisting');714 }715 public function testAssertObjectHasAttribute(): void716 {717 $o = new \Author('Terry Pratchett');718 $this->assertObjectHasAttribute('name', $o);719 $this->expectException(AssertionFailedError::class);720 $this->assertObjectHasAttribute('foo', $o);721 }722 public function testAssertObjectHasAttributeNumericAttribute(): void723 {724 $object = new \stdClass;725 $object->{'2020'} = 'Tokyo';726 $this->assertObjectHasAttribute('2020', $object);727 $this->expectException(AssertionFailedError::class);728 $this->assertObjectHasAttribute('2018', $object);729 }730 public function testAssertObjectHasAttributeMultiByteAttribute(): void731 {732 $object = new \stdClass;733 $object->{'æ±äº¬'} = 2020;734 $this->assertObjectHasAttribute('æ±äº¬', $object);735 $this->expectException(AssertionFailedError::class);736 $this->assertObjectHasAttribute('é·é', $object);737 }738 public function testAssertObjectNotHasAttribute(): void739 {740 $o = new \Author('Terry Pratchett');741 $this->assertObjectNotHasAttribute('foo', $o);742 $this->expectException(AssertionFailedError::class);743 $this->assertObjectNotHasAttribute('name', $o);744 }745 public function testAssertObjectNotHasAttributeNumericAttribute(): void746 {747 $object = new \stdClass;748 $object->{'2020'} = 'Tokyo';749 $this->assertObjectNotHasAttribute('2018', $object);750 $this->expectException(AssertionFailedError::class);751 $this->assertObjectNotHasAttribute('2020', $object);752 }753 public function testAssertObjectNotHasAttributeMultiByteAttribute(): void754 {755 $object = new \stdClass;756 $object->{'æ±äº¬'} = 2020;757 $this->assertObjectNotHasAttribute('é·é', $object);758 $this->expectException(AssertionFailedError::class);759 $this->assertObjectNotHasAttribute('æ±äº¬', $object);760 }761 public function testAssertFinite(): void762 {763 $this->assertFinite(1);764 $this->expectException(AssertionFailedError::class);765 $this->assertFinite(\INF);766 }767 public function testAssertInfinite(): void768 {769 $this->assertInfinite(\INF);770 $this->expectException(AssertionFailedError::class);771 $this->assertInfinite(1);772 }773 public function testAssertNan(): void774 {775 $this->assertNan(\NAN);776 $this->expectException(AssertionFailedError::class);777 $this->assertNan(1);778 }779 public function testAssertNull(): void780 {781 $this->assertNull(null);782 $this->expectException(AssertionFailedError::class);783 $this->assertNull(new \stdClass);784 }785 public function testAssertNotNull(): void786 {787 $this->assertNotNull(new \stdClass);788 $this->expectException(AssertionFailedError::class);789 $this->assertNotNull(null);790 }791 public function testAssertTrue(): void792 {793 $this->assertTrue(true);794 $this->expectException(AssertionFailedError::class);795 $this->assertTrue(false);796 }797 public function testAssertNotTrue(): void798 {799 $this->assertNotTrue(false);800 $this->assertNotTrue(1);801 $this->assertNotTrue('true');802 $this->expectException(AssertionFailedError::class);803 $this->assertNotTrue(true);804 }805 public function testAssertFalse(): void806 {807 $this->assertFalse(false);808 $this->expectException(AssertionFailedError::class);809 $this->assertFalse(true);810 }811 public function testAssertNotFalse(): void812 {813 $this->assertNotFalse(true);814 $this->assertNotFalse(0);815 $this->assertNotFalse('');816 $this->expectException(AssertionFailedError::class);817 $this->assertNotFalse(false);818 }819 public function testAssertRegExp(): void820 {821 $this->assertRegExp('/foo/', 'foobar');822 $this->expectException(AssertionFailedError::class);823 $this->assertRegExp('/foo/', 'bar');824 }825 public function testAssertNotRegExp(): void826 {827 $this->assertNotRegExp('/foo/', 'bar');828 $this->expectException(AssertionFailedError::class);829 $this->assertNotRegExp('/foo/', 'foobar');830 }831 public function testAssertSame(): void832 {833 $o = new \stdClass;834 $this->assertSame($o, $o);835 $this->expectException(AssertionFailedError::class);836 $this->assertSame(new \stdClass, new \stdClass);837 }838 public function testAssertSame2(): void839 {840 $this->assertSame(true, true);841 $this->assertSame(false, false);842 $this->expectException(AssertionFailedError::class);843 $this->assertSame(true, false);844 }845 public function testAssertNotSame(): void846 {847 $this->assertNotSame(848 new \stdClass,849 null850 );851 $this->assertNotSame(852 null,853 new \stdClass854 );855 $this->assertNotSame(856 new \stdClass,857 new \stdClass858 );859 $o = new \stdClass;860 $this->expectException(AssertionFailedError::class);861 $this->assertNotSame($o, $o);862 }863 public function testAssertNotSame2(): void864 {865 $this->assertNotSame(true, false);866 $this->assertNotSame(false, true);867 $this->expectException(AssertionFailedError::class);868 $this->assertNotSame(true, true);869 }870 public function testAssertNotSameFailsNull(): void871 {872 $this->expectException(AssertionFailedError::class);873 $this->assertNotSame(null, null);874 }875 public function testGreaterThan(): void876 {877 $this->assertGreaterThan(1, 2);878 $this->expectException(AssertionFailedError::class);879 $this->assertGreaterThan(2, 1);880 }881 public function testAttributeGreaterThan(): void882 {883 $this->assertAttributeGreaterThan(884 1,885 'bar',886 new \ClassWithNonPublicAttributes887 );888 $this->expectException(AssertionFailedError::class);889 $this->assertAttributeGreaterThan(890 1,891 'foo',892 new \ClassWithNonPublicAttributes893 );894 }895 public function testGreaterThanOrEqual(): void896 {897 $this->assertGreaterThanOrEqual(1, 2);898 $this->expectException(AssertionFailedError::class);899 $this->assertGreaterThanOrEqual(2, 1);900 }901 public function testAttributeGreaterThanOrEqual(): void902 {903 $this->assertAttributeGreaterThanOrEqual(904 1,905 'bar',906 new \ClassWithNonPublicAttributes907 );908 $this->expectException(AssertionFailedError::class);909 $this->assertAttributeGreaterThanOrEqual(910 2,911 'foo',912 new \ClassWithNonPublicAttributes913 );914 }915 public function testLessThan(): void916 {917 $this->assertLessThan(2, 1);918 try {919 $this->assertLessThan(1, 2);920 } catch (AssertionFailedError $e) {921 return;922 }923 $this->fail();924 }925 public function testAttributeLessThan(): void926 {927 $this->assertAttributeLessThan(928 2,929 'foo',930 new \ClassWithNonPublicAttributes931 );932 $this->expectException(AssertionFailedError::class);933 $this->assertAttributeLessThan(934 1,935 'bar',936 new \ClassWithNonPublicAttributes937 );938 }939 public function testLessThanOrEqual(): void940 {941 $this->assertLessThanOrEqual(2, 1);942 $this->expectException(AssertionFailedError::class);943 $this->assertLessThanOrEqual(1, 2);944 }945 public function testAttributeLessThanOrEqual(): void946 {947 $this->assertAttributeLessThanOrEqual(948 2,949 'foo',950 new \ClassWithNonPublicAttributes951 );952 $this->expectException(AssertionFailedError::class);953 $this->assertAttributeLessThanOrEqual(954 1,955 'bar',956 new \ClassWithNonPublicAttributes957 );958 }959 public function testReadAttribute(): void960 {961 $obj = new \ClassWithNonPublicAttributes;962 $this->assertEquals('foo', $this->readAttribute($obj, 'publicAttribute'));963 $this->assertEquals('bar', $this->readAttribute($obj, 'protectedAttribute'));964 $this->assertEquals('baz', $this->readAttribute($obj, 'privateAttribute'));965 $this->assertEquals('bar', $this->readAttribute($obj, 'protectedParentAttribute'));966 //$this->assertEquals('bar', $this->readAttribute($obj, 'privateParentAttribute'));967 }968 public function testReadAttribute2(): void969 {970 $this->assertEquals('foo', $this->readAttribute(\ClassWithNonPublicAttributes::class, 'publicStaticAttribute'));971 $this->assertEquals('bar', $this->readAttribute(\ClassWithNonPublicAttributes::class, 'protectedStaticAttribute'));972 $this->assertEquals('baz', $this->readAttribute(\ClassWithNonPublicAttributes::class, 'privateStaticAttribute'));973 $this->assertEquals('foo', $this->readAttribute(\ClassWithNonPublicAttributes::class, 'protectedStaticParentAttribute'));974 $this->assertEquals('foo', $this->readAttribute(\ClassWithNonPublicAttributes::class, 'privateStaticParentAttribute'));975 }976 public function testReadAttribute4(): void977 {978 $this->expectException(Exception::class);979 $this->readAttribute('NotExistingClass', 'foo');980 }981 public function testReadAttribute5(): void982 {983 $this->expectException(Exception::class);984 $this->readAttribute(null, 'foo');985 }986 public function testReadAttributeIfAttributeNameIsNotValid(): void987 {988 $this->expectException(Exception::class);989 $this->readAttribute(\stdClass::class, '2');990 }991 public function testGetStaticAttributeRaisesExceptionForInvalidFirstArgument2(): void992 {993 $this->expectException(Exception::class);994 $this->getStaticAttribute('NotExistingClass', 'foo');995 }996 public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument2(): void997 {998 $this->expectException(Exception::class);999 $this->getStaticAttribute(\stdClass::class, '0');1000 }1001 public function testGetStaticAttributeRaisesExceptionForInvalidSecondArgument3(): void1002 {1003 $this->expectException(Exception::class);1004 $this->getStaticAttribute(\stdClass::class, 'foo');1005 }1006 public function testGetObjectAttributeRaisesExceptionForInvalidFirstArgument(): void1007 {1008 $this->expectException(Exception::class);1009 $this->getObjectAttribute(null, 'foo');1010 }1011 public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument2(): void1012 {1013 $this->expectException(Exception::class);1014 $this->getObjectAttribute(new \stdClass, '0');1015 }1016 public function testGetObjectAttributeRaisesExceptionForInvalidSecondArgument3(): void1017 {1018 $this->expectException(Exception::class);1019 $this->getObjectAttribute(new \stdClass, 'foo');1020 }1021 public function testGetObjectAttributeWorksForInheritedAttributes(): void1022 {1023 $this->assertEquals(1024 'bar',1025 $this->getObjectAttribute(new \ClassWithNonPublicAttributes, 'privateParentAttribute')1026 );1027 }1028 public function testAssertPublicAttributeContains(): void1029 {1030 $obj = new \ClassWithNonPublicAttributes;1031 $this->assertAttributeContains('foo', 'publicArray', $obj);1032 $this->expectException(AssertionFailedError::class);1033 $this->assertAttributeContains('bar', 'publicArray', $obj);1034 }1035 public function testAssertPublicAttributeContainsOnly(): void1036 {1037 $obj = new \ClassWithNonPublicAttributes;1038 $this->assertAttributeContainsOnly('string', 'publicArray', $obj);1039 $this->expectException(AssertionFailedError::class);1040 $this->assertAttributeContainsOnly('integer', 'publicArray', $obj);1041 }1042 public function testAssertPublicAttributeNotContains(): void1043 {1044 $obj = new \ClassWithNonPublicAttributes;1045 $this->assertAttributeNotContains('bar', 'publicArray', $obj);1046 $this->expectException(AssertionFailedError::class);1047 $this->assertAttributeNotContains('foo', 'publicArray', $obj);1048 }1049 public function testAssertPublicAttributeNotContainsOnly(): void1050 {1051 $obj = new \ClassWithNonPublicAttributes;1052 $this->assertAttributeNotContainsOnly('integer', 'publicArray', $obj);1053 $this->expectException(AssertionFailedError::class);1054 $this->assertAttributeNotContainsOnly('string', 'publicArray', $obj);1055 }1056 public function testAssertProtectedAttributeContains(): void1057 {1058 $obj = new \ClassWithNonPublicAttributes;1059 $this->assertAttributeContains('bar', 'protectedArray', $obj);1060 $this->expectException(AssertionFailedError::class);1061 $this->assertAttributeContains('foo', 'protectedArray', $obj);1062 }1063 public function testAssertProtectedAttributeNotContains(): void1064 {1065 $obj = new \ClassWithNonPublicAttributes;1066 $this->assertAttributeNotContains('foo', 'protectedArray', $obj);1067 $this->expectException(AssertionFailedError::class);1068 $this->assertAttributeNotContains('bar', 'protectedArray', $obj);1069 }1070 public function testAssertPrivateAttributeContains(): void1071 {1072 $obj = new \ClassWithNonPublicAttributes;1073 $this->assertAttributeContains('baz', 'privateArray', $obj);1074 $this->expectException(AssertionFailedError::class);1075 $this->assertAttributeContains('foo', 'privateArray', $obj);1076 }1077 public function testAssertPrivateAttributeNotContains(): void1078 {1079 $obj = new \ClassWithNonPublicAttributes;1080 $this->assertAttributeNotContains('foo', 'privateArray', $obj);1081 $this->expectException(AssertionFailedError::class);1082 $this->assertAttributeNotContains('baz', 'privateArray', $obj);1083 }1084 public function testAssertAttributeContainsNonObject(): void1085 {1086 $obj = new \ClassWithNonPublicAttributes;1087 $this->assertAttributeContains(true, 'privateArray', $obj);1088 $this->expectException(AssertionFailedError::class);1089 $this->assertAttributeContains(true, 'privateArray', $obj, '', false, true, true);1090 }1091 public function testAssertAttributeNotContainsNonObject(): void1092 {1093 $obj = new \ClassWithNonPublicAttributes;1094 $this->assertAttributeNotContains(true, 'privateArray', $obj, '', false, true, true);1095 $this->expectException(AssertionFailedError::class);1096 $this->assertAttributeNotContains(true, 'privateArray', $obj);1097 }1098 public function testAssertPublicAttributeEquals(): void1099 {1100 $obj = new \ClassWithNonPublicAttributes;1101 $this->assertAttributeEquals('foo', 'publicAttribute', $obj);1102 $this->expectException(AssertionFailedError::class);1103 $this->assertAttributeEquals('bar', 'publicAttribute', $obj);1104 }1105 public function testAssertPublicAttributeNotEquals(): void1106 {1107 $obj = new \ClassWithNonPublicAttributes;1108 $this->assertAttributeNotEquals('bar', 'publicAttribute', $obj);1109 $this->expectException(AssertionFailedError::class);1110 $this->assertAttributeNotEquals('foo', 'publicAttribute', $obj);1111 }1112 public function testAssertPublicAttributeSame(): void1113 {1114 $obj = new \ClassWithNonPublicAttributes;1115 $this->assertAttributeSame('foo', 'publicAttribute', $obj);1116 $this->expectException(AssertionFailedError::class);1117 $this->assertAttributeSame('bar', 'publicAttribute', $obj);1118 }1119 public function testAssertPublicAttributeNotSame(): void1120 {1121 $obj = new \ClassWithNonPublicAttributes;1122 $this->assertAttributeNotSame('bar', 'publicAttribute', $obj);1123 $this->expectException(AssertionFailedError::class);1124 $this->assertAttributeNotSame('foo', 'publicAttribute', $obj);1125 }1126 public function testAssertProtectedAttributeEquals(): void1127 {1128 $obj = new \ClassWithNonPublicAttributes;1129 $this->assertAttributeEquals('bar', 'protectedAttribute', $obj);1130 $this->expectException(AssertionFailedError::class);1131 $this->assertAttributeEquals('foo', 'protectedAttribute', $obj);1132 }1133 public function testAssertProtectedAttributeNotEquals(): void1134 {1135 $obj = new \ClassWithNonPublicAttributes;1136 $this->assertAttributeNotEquals('foo', 'protectedAttribute', $obj);1137 $this->expectException(AssertionFailedError::class);1138 $this->assertAttributeNotEquals('bar', 'protectedAttribute', $obj);1139 }1140 public function testAssertPrivateAttributeEquals(): void1141 {1142 $obj = new \ClassWithNonPublicAttributes;1143 $this->assertAttributeEquals('baz', 'privateAttribute', $obj);1144 $this->expectException(AssertionFailedError::class);1145 $this->assertAttributeEquals('foo', 'privateAttribute', $obj);1146 }1147 public function testAssertPrivateAttributeNotEquals(): void1148 {1149 $obj = new \ClassWithNonPublicAttributes;1150 $this->assertAttributeNotEquals('foo', 'privateAttribute', $obj);1151 $this->expectException(AssertionFailedError::class);1152 $this->assertAttributeNotEquals('baz', 'privateAttribute', $obj);1153 }1154 public function testAssertPublicStaticAttributeEquals(): void1155 {1156 $this->assertAttributeEquals('foo', 'publicStaticAttribute', \ClassWithNonPublicAttributes::class);1157 $this->expectException(AssertionFailedError::class);1158 $this->assertAttributeEquals('bar', 'publicStaticAttribute', \ClassWithNonPublicAttributes::class);1159 }1160 public function testAssertPublicStaticAttributeNotEquals(): void1161 {1162 $this->assertAttributeNotEquals('bar', 'publicStaticAttribute', \ClassWithNonPublicAttributes::class);1163 $this->expectException(AssertionFailedError::class);1164 $this->assertAttributeNotEquals('foo', 'publicStaticAttribute', \ClassWithNonPublicAttributes::class);1165 }1166 public function testAssertProtectedStaticAttributeEquals(): void1167 {1168 $this->assertAttributeEquals('bar', 'protectedStaticAttribute', \ClassWithNonPublicAttributes::class);1169 $this->expectException(AssertionFailedError::class);1170 $this->assertAttributeEquals('foo', 'protectedStaticAttribute', \ClassWithNonPublicAttributes::class);1171 }1172 public function testAssertProtectedStaticAttributeNotEquals(): void1173 {1174 $this->assertAttributeNotEquals('foo', 'protectedStaticAttribute', \ClassWithNonPublicAttributes::class);1175 $this->expectException(AssertionFailedError::class);1176 $this->assertAttributeNotEquals('bar', 'protectedStaticAttribute', \ClassWithNonPublicAttributes::class);1177 }1178 public function testAssertPrivateStaticAttributeEquals(): void1179 {1180 $this->assertAttributeEquals('baz', 'privateStaticAttribute', \ClassWithNonPublicAttributes::class);1181 $this->expectException(AssertionFailedError::class);1182 $this->assertAttributeEquals('foo', 'privateStaticAttribute', \ClassWithNonPublicAttributes::class);1183 }1184 public function testAssertPrivateStaticAttributeNotEquals(): void1185 {1186 $this->assertAttributeNotEquals('foo', 'privateStaticAttribute', \ClassWithNonPublicAttributes::class);1187 $this->expectException(AssertionFailedError::class);1188 $this->assertAttributeNotEquals('baz', 'privateStaticAttribute', \ClassWithNonPublicAttributes::class);1189 }1190 public function testAssertClassHasAttributeThrowsExceptionIfAttributeNameIsNotValid(): void1191 {1192 $this->expectException(Exception::class);1193 $this->assertClassHasAttribute('1', \ClassWithNonPublicAttributes::class);1194 }1195 public function testAssertClassHasAttributeThrowsExceptionIfClassDoesNotExist(): void1196 {1197 $this->expectException(Exception::class);1198 $this->assertClassHasAttribute('attribute', 'ClassThatDoesNotExist');1199 }1200 public function testAssertClassNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid(): void1201 {1202 $this->expectException(Exception::class);1203 $this->assertClassNotHasAttribute('1', \ClassWithNonPublicAttributes::class);1204 }1205 public function testAssertClassNotHasAttributeThrowsExceptionIfClassDoesNotExist(): void1206 {1207 $this->expectException(Exception::class);1208 $this->assertClassNotHasAttribute('attribute', 'ClassThatDoesNotExist');1209 }1210 public function testAssertClassHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid(): void1211 {1212 $this->expectException(Exception::class);1213 $this->assertClassHasStaticAttribute('1', \ClassWithNonPublicAttributes::class);1214 }1215 public function testAssertClassHasStaticAttributeThrowsExceptionIfClassDoesNotExist(): void1216 {1217 $this->expectException(Exception::class);1218 $this->assertClassHasStaticAttribute('attribute', 'ClassThatDoesNotExist');1219 }1220 public function testAssertClassNotHasStaticAttributeThrowsExceptionIfAttributeNameIsNotValid(): void1221 {1222 $this->expectException(Exception::class);1223 $this->assertClassNotHasStaticAttribute('1', \ClassWithNonPublicAttributes::class);1224 }1225 public function testAssertClassNotHasStaticAttributeThrowsExceptionIfClassDoesNotExist(): void1226 {1227 $this->expectException(Exception::class);1228 $this->assertClassNotHasStaticAttribute('attribute', 'ClassThatDoesNotExist');1229 }1230 public function testAssertObjectHasAttributeThrowsException2(): void1231 {1232 $this->expectException(Exception::class);1233 $this->assertObjectHasAttribute('foo', null);1234 }1235 public function testAssertObjectHasAttributeThrowsExceptionIfAttributeNameIsNotValid(): void1236 {1237 $this->expectException(Exception::class);1238 $this->assertObjectHasAttribute('1', \ClassWithNonPublicAttributes::class);1239 }1240 public function testAssertObjectNotHasAttributeThrowsException2(): void1241 {1242 $this->expectException(Exception::class);1243 $this->assertObjectNotHasAttribute('foo', null);1244 }1245 public function testAssertObjectNotHasAttributeThrowsExceptionIfAttributeNameIsNotValid(): void1246 {1247 $this->expectException(Exception::class);1248 $this->assertObjectNotHasAttribute('1', \ClassWithNonPublicAttributes::class);1249 }1250 public function testClassHasPublicAttribute(): void1251 {1252 $this->assertClassHasAttribute('publicAttribute', \ClassWithNonPublicAttributes::class);1253 $this->expectException(AssertionFailedError::class);1254 $this->assertClassHasAttribute('attribute', \ClassWithNonPublicAttributes::class);1255 }1256 public function testClassNotHasPublicAttribute(): void1257 {1258 $this->assertClassNotHasAttribute('attribute', \ClassWithNonPublicAttributes::class);1259 $this->expectException(AssertionFailedError::class);1260 $this->assertClassNotHasAttribute('publicAttribute', \ClassWithNonPublicAttributes::class);1261 }1262 public function testClassHasPublicStaticAttribute(): void1263 {1264 $this->assertClassHasStaticAttribute('publicStaticAttribute', \ClassWithNonPublicAttributes::class);1265 $this->expectException(AssertionFailedError::class);1266 $this->assertClassHasStaticAttribute('attribute', \ClassWithNonPublicAttributes::class);1267 }1268 public function testClassNotHasPublicStaticAttribute(): void1269 {1270 $this->assertClassNotHasStaticAttribute('attribute', \ClassWithNonPublicAttributes::class);1271 $this->expectException(AssertionFailedError::class);1272 $this->assertClassNotHasStaticAttribute('publicStaticAttribute', \ClassWithNonPublicAttributes::class);1273 }1274 public function testObjectHasPublicAttribute(): void1275 {1276 $obj = new \ClassWithNonPublicAttributes;1277 $this->assertObjectHasAttribute('publicAttribute', $obj);1278 $this->expectException(AssertionFailedError::class);1279 $this->assertObjectHasAttribute('attribute', $obj);1280 }1281 public function testObjectNotHasPublicAttribute(): void1282 {1283 $obj = new \ClassWithNonPublicAttributes;1284 $this->assertObjectNotHasAttribute('attribute', $obj);1285 $this->expectException(AssertionFailedError::class);1286 $this->assertObjectNotHasAttribute('publicAttribute', $obj);1287 }1288 public function testObjectHasOnTheFlyAttribute(): void1289 {1290 $obj = new \stdClass;1291 $obj->foo = 'bar';1292 $this->assertObjectHasAttribute('foo', $obj);1293 $this->expectException(AssertionFailedError::class);1294 $this->assertObjectHasAttribute('bar', $obj);1295 }1296 public function testObjectNotHasOnTheFlyAttribute(): void1297 {1298 $obj = new \stdClass;1299 $obj->foo = 'bar';1300 $this->assertObjectNotHasAttribute('bar', $obj);1301 $this->expectException(AssertionFailedError::class);1302 $this->assertObjectNotHasAttribute('foo', $obj);1303 }1304 public function testObjectHasProtectedAttribute(): void1305 {1306 $obj = new \ClassWithNonPublicAttributes;1307 $this->assertObjectHasAttribute('protectedAttribute', $obj);1308 $this->expectException(AssertionFailedError::class);1309 $this->assertObjectHasAttribute('attribute', $obj);1310 }1311 public function testObjectNotHasProtectedAttribute(): void1312 {1313 $obj = new \ClassWithNonPublicAttributes;1314 $this->assertObjectNotHasAttribute('attribute', $obj);1315 $this->expectException(AssertionFailedError::class);1316 $this->assertObjectNotHasAttribute('protectedAttribute', $obj);1317 }1318 public function testObjectHasPrivateAttribute(): void1319 {1320 $obj = new \ClassWithNonPublicAttributes;1321 $this->assertObjectHasAttribute('privateAttribute', $obj);1322 $this->expectException(AssertionFailedError::class);1323 $this->assertObjectHasAttribute('attribute', $obj);1324 }1325 public function testObjectNotHasPrivateAttribute(): void1326 {1327 $obj = new \ClassWithNonPublicAttributes;1328 $this->assertObjectNotHasAttribute('attribute', $obj);1329 $this->expectException(AssertionFailedError::class);1330 $this->assertObjectNotHasAttribute('privateAttribute', $obj);1331 }1332 public function testAssertThatAttributeEquals(): void1333 {1334 $this->assertThat(1335 new \ClassWithNonPublicAttributes,1336 $this->attribute(1337 $this->equalTo('foo'),1338 'publicAttribute'1339 )1340 );1341 }1342 public function testAssertThatAttributeEquals2(): void1343 {1344 $this->expectException(AssertionFailedError::class);1345 $this->assertThat(1346 new \ClassWithNonPublicAttributes,1347 $this->attribute(1348 $this->equalTo('bar'),1349 'publicAttribute'1350 )1351 );1352 }1353 public function testAssertThatAttributeEqualTo(): void1354 {1355 $this->assertThat(1356 new \ClassWithNonPublicAttributes,1357 $this->attributeEqualTo('publicAttribute', 'foo')1358 );1359 }1360 /**1361 * @doesNotPerformAssertions1362 */1363 public function testAssertThatAnything(): void1364 {1365 $this->assertThat('anything', $this->anything());1366 }1367 public function testAssertThatIsTrue(): void1368 {1369 $this->assertThat(true, $this->isTrue());1370 }1371 public function testAssertThatIsFalse(): void1372 {1373 $this->assertThat(false, $this->isFalse());1374 }1375 public function testAssertThatIsJson(): void1376 {1377 $this->assertThat('{}', $this->isJson());1378 }1379 /**1380 * @doesNotPerformAssertions1381 */1382 public function testAssertThatAnythingAndAnything(): void1383 {1384 $this->assertThat(1385 'anything',1386 $this->logicalAnd(1387 $this->anything(),1388 $this->anything()1389 )1390 );1391 }1392 /**1393 * @doesNotPerformAssertions1394 */1395 public function testAssertThatAnythingOrAnything(): void1396 {1397 $this->assertThat(1398 'anything',1399 $this->logicalOr(1400 $this->anything(),1401 $this->anything()1402 )1403 );1404 }1405 /**1406 * @doesNotPerformAssertions1407 */1408 public function testAssertThatAnythingXorNotAnything(): void1409 {1410 $this->assertThat(1411 'anything',1412 $this->logicalXor(1413 $this->anything(),1414 $this->logicalNot($this->anything())1415 )1416 );1417 }1418 public function testAssertThatContains(): void1419 {1420 $this->assertThat(['foo'], $this->contains('foo'));1421 }1422 public function testAssertThatStringContains(): void1423 {1424 $this->assertThat('barfoobar', $this->stringContains('foo'));1425 }1426 public function testAssertThatContainsOnly(): void1427 {1428 $this->assertThat(['foo'], $this->containsOnly('string'));1429 }1430 public function testAssertThatContainsOnlyInstancesOf(): void1431 {1432 $this->assertThat([new \Book], $this->containsOnlyInstancesOf(\Book::class));1433 }1434 public function testAssertThatArrayHasKey(): void1435 {1436 $this->assertThat(['foo' => 'bar'], $this->arrayHasKey('foo'));1437 }1438 public function testAssertThatClassHasAttribute(): void1439 {1440 $this->assertThat(1441 new \ClassWithNonPublicAttributes,1442 $this->classHasAttribute('publicAttribute')1443 );1444 }1445 public function testAssertThatClassHasStaticAttribute(): void1446 {1447 $this->assertThat(1448 new \ClassWithNonPublicAttributes,1449 $this->classHasStaticAttribute('publicStaticAttribute')1450 );1451 }1452 public function testAssertThatObjectHasAttribute(): void1453 {1454 $this->assertThat(1455 new \ClassWithNonPublicAttributes,1456 $this->objectHasAttribute('publicAttribute')1457 );1458 }1459 public function testAssertThatEqualTo(): void1460 {1461 $this->assertThat('foo', $this->equalTo('foo'));1462 }1463 public function testAssertThatIdenticalTo(): void1464 {1465 $value = new \stdClass;1466 $constraint = $this->identicalTo($value);1467 $this->assertThat($value, $constraint);1468 }1469 public function testAssertThatIsInstanceOf(): void1470 {1471 $this->assertThat(new \stdClass, $this->isInstanceOf('StdClass'));1472 }1473 public function testAssertThatIsType(): void1474 {1475 $this->assertThat('string', $this->isType('string'));1476 }1477 public function testAssertThatIsEmpty(): void1478 {1479 $this->assertThat([], $this->isEmpty());1480 }1481 public function testAssertThatFileExists(): void1482 {1483 $this->assertThat(__FILE__, $this->fileExists());1484 }1485 public function testAssertThatGreaterThan(): void1486 {1487 $this->assertThat(2, $this->greaterThan(1));1488 }1489 public function testAssertThatGreaterThanOrEqual(): void1490 {1491 $this->assertThat(2, $this->greaterThanOrEqual(1));1492 }1493 public function testAssertThatLessThan(): void1494 {1495 $this->assertThat(1, $this->lessThan(2));1496 }1497 public function testAssertThatLessThanOrEqual(): void1498 {1499 $this->assertThat(1, $this->lessThanOrEqual(2));1500 }1501 public function testAssertThatMatchesRegularExpression(): void1502 {1503 $this->assertThat('foobar', $this->matchesRegularExpression('/foo/'));1504 }1505 public function testAssertThatCallback(): void1506 {1507 $this->assertThat(1508 null,1509 $this->callback(function ($other) {1510 return true;1511 })1512 );1513 }1514 public function testAssertThatCountOf(): void1515 {1516 $this->assertThat([1], $this->countOf(1));1517 }1518 public function testAssertFileEquals(): void1519 {1520 $this->assertFileEquals(1521 TEST_FILES_PATH . 'foo.xml',1522 TEST_FILES_PATH . 'foo.xml'1523 );1524 $this->expectException(AssertionFailedError::class);1525 $this->assertFileEquals(1526 TEST_FILES_PATH . 'foo.xml',1527 TEST_FILES_PATH . 'bar.xml'1528 );1529 }1530 public function testAssertFileNotEquals(): void1531 {1532 $this->assertFileNotEquals(1533 TEST_FILES_PATH . 'foo.xml',1534 TEST_FILES_PATH . 'bar.xml'1535 );1536 $this->expectException(AssertionFailedError::class);1537 $this->assertFileNotEquals(1538 TEST_FILES_PATH . 'foo.xml',1539 TEST_FILES_PATH . 'foo.xml'1540 );1541 }1542 public function testAssertStringEqualsFile(): void1543 {1544 $this->assertStringEqualsFile(1545 TEST_FILES_PATH . 'foo.xml',1546 \file_get_contents(TEST_FILES_PATH . 'foo.xml')1547 );1548 $this->expectException(AssertionFailedError::class);1549 $this->assertStringEqualsFile(1550 TEST_FILES_PATH . 'foo.xml',1551 \file_get_contents(TEST_FILES_PATH . 'bar.xml')1552 );1553 }1554 public function testAssertStringNotEqualsFile(): void1555 {1556 $this->assertStringNotEqualsFile(1557 TEST_FILES_PATH . 'foo.xml',1558 \file_get_contents(TEST_FILES_PATH . 'bar.xml')1559 );1560 $this->expectException(AssertionFailedError::class);1561 $this->assertStringNotEqualsFile(1562 TEST_FILES_PATH . 'foo.xml',1563 \file_get_contents(TEST_FILES_PATH . 'foo.xml')1564 );1565 }1566 public function testAssertStringStartsNotWithThrowsException2(): void1567 {1568 $this->expectException(Exception::class);1569 $this->assertStringStartsNotWith('', null);1570 }1571 public function testAssertStringStartsWith(): void1572 {1573 $this->assertStringStartsWith('prefix', 'prefixfoo');1574 $this->expectException(AssertionFailedError::class);1575 $this->assertStringStartsWith('prefix', 'foo');1576 }1577 public function testAssertStringStartsNotWith(): void1578 {1579 $this->assertStringStartsNotWith('prefix', 'foo');1580 $this->expectException(AssertionFailedError::class);1581 $this->assertStringStartsNotWith('prefix', 'prefixfoo');1582 }1583 public function testAssertStringEndsWith(): void1584 {1585 $this->assertStringEndsWith('suffix', 'foosuffix');1586 $this->expectException(AssertionFailedError::class);1587 $this->assertStringEndsWith('suffix', 'foo');1588 }1589 public function testAssertStringEndsNotWith(): void1590 {1591 $this->assertStringEndsNotWith('suffix', 'foo');1592 $this->expectException(AssertionFailedError::class);1593 $this->assertStringEndsNotWith('suffix', 'foosuffix');1594 }1595 public function testAssertStringMatchesFormat(): void1596 {1597 $this->assertStringMatchesFormat('*%s*', '***');1598 }1599 public function testAssertStringMatchesFormatFailure(): void1600 {1601 $this->expectException(AssertionFailedError::class);1602 $this->assertStringMatchesFormat('*%s*', '**');1603 }1604 public function testAssertStringNotMatchesFormat(): void1605 {1606 $this->assertStringNotMatchesFormat('*%s*', '**');1607 $this->expectException(AssertionFailedError::class);1608 $this->assertStringMatchesFormat('*%s*', '**');1609 }1610 public function testAssertEmpty(): void1611 {1612 $this->assertEmpty([]);1613 $this->expectException(AssertionFailedError::class);1614 $this->assertEmpty(['foo']);1615 }1616 public function testAssertNotEmpty(): void1617 {1618 $this->assertNotEmpty(['foo']);1619 $this->expectException(AssertionFailedError::class);1620 $this->assertNotEmpty([]);1621 }1622 public function testAssertAttributeEmpty(): void1623 {1624 $o = new \stdClass;1625 $o->a = [];1626 $this->assertAttributeEmpty('a', $o);1627 $o->a = ['b'];1628 $this->expectException(AssertionFailedError::class);1629 $this->assertAttributeEmpty('a', $o);1630 }1631 public function testAssertAttributeNotEmpty(): void1632 {1633 $o = new \stdClass;1634 $o->a = ['b'];1635 $this->assertAttributeNotEmpty('a', $o);1636 $o->a = [];1637 $this->expectException(AssertionFailedError::class);1638 $this->assertAttributeNotEmpty('a', $o);1639 }1640 public function testMarkTestIncomplete(): void1641 {1642 try {1643 $this->markTestIncomplete('incomplete');1644 } catch (IncompleteTestError $e) {1645 $this->assertEquals('incomplete', $e->getMessage());1646 return;1647 }1648 $this->fail();1649 }1650 public function testMarkTestSkipped(): void1651 {1652 try {1653 $this->markTestSkipped('skipped');1654 } catch (SkippedTestError $e) {1655 $this->assertEquals('skipped', $e->getMessage());1656 return;1657 }1658 $this->fail();1659 }1660 public function testAssertCount(): void1661 {1662 $this->assertCount(2, [1, 2]);1663 $this->expectException(AssertionFailedError::class);1664 $this->assertCount(2, [1, 2, 3]);1665 }1666 public function testAssertCountTraversable(): void1667 {1668 $this->assertCount(2, new \ArrayIterator([1, 2]));1669 $this->expectException(AssertionFailedError::class);1670 $this->assertCount(2, new \ArrayIterator([1, 2, 3]));1671 }1672 public function testAssertCountThrowsExceptionIfElementIsNotCountable(): void1673 {1674 try {1675 $this->assertCount(2, '');1676 } catch (Exception $e) {1677 $this->assertEquals('Argument #2 (No Value) of PHPUnit\Framework\Assert::assertCount() must be a countable or iterable', $e->getMessage());1678 return;1679 }1680 $this->fail();1681 }1682 public function testAssertAttributeCount(): void1683 {1684 $o = new \stdClass;1685 $o->a = [];1686 $this->assertAttributeCount(0, 'a', $o);1687 }1688 public function testAssertNotCount(): void1689 {1690 $this->assertNotCount(2, [1, 2, 3]);1691 $this->expectException(AssertionFailedError::class);1692 $this->assertNotCount(2, [1, 2]);1693 }1694 public function testAssertNotCountThrowsExceptionIfElementIsNotCountable(): void1695 {1696 $this->expectException(Exception::class);1697 $this->assertNotCount(2, '');1698 }1699 public function testAssertAttributeNotCount(): void1700 {1701 $o = new \stdClass;1702 $o->a = [];1703 $this->assertAttributeNotCount(1, 'a', $o);1704 }1705 public function testAssertSameSize(): void1706 {1707 $this->assertSameSize([1, 2], [3, 4]);1708 $this->expectException(AssertionFailedError::class);1709 $this->assertSameSize([1, 2], [1, 2, 3]);1710 }1711 public function testAssertSameSizeThrowsExceptionIfExpectedIsNotCountable(): void1712 {1713 try {1714 $this->assertSameSize('a', []);1715 } catch (Exception $e) {1716 $this->assertEquals('Argument #1 (No Value) of PHPUnit\Framework\Assert::assertSameSize() must be a countable or iterable', $e->getMessage());1717 return;1718 }1719 $this->fail();1720 }1721 public function testAssertSameSizeThrowsExceptionIfActualIsNotCountable(): void1722 {1723 try {1724 $this->assertSameSize([], '');1725 } catch (Exception $e) {1726 $this->assertEquals('Argument #2 (No Value) of PHPUnit\Framework\Assert::assertSameSize() must be a countable or iterable', $e->getMessage());1727 return;1728 }1729 $this->fail();1730 }1731 public function testAssertNotSameSize(): void1732 {1733 $this->assertNotSameSize([1, 2], [1, 2, 3]);1734 $this->expectException(AssertionFailedError::class);1735 $this->assertNotSameSize([1, 2], [3, 4]);1736 }1737 public function testAssertNotSameSizeThrowsExceptionIfExpectedIsNotCountable(): void1738 {1739 $this->expectException(Exception::class);1740 $this->assertNotSameSize('a', []);1741 }1742 public function testAssertNotSameSizeThrowsExceptionIfActualIsNotCountable(): void1743 {1744 $this->expectException(Exception::class);1745 $this->assertNotSameSize([], '');1746 }1747 public function testAssertJson(): void1748 {1749 $this->assertJson('{}');1750 }1751 public function testAssertJsonStringEqualsJsonString(): void1752 {1753 $expected = '{"Mascott" : "Tux"}';1754 $actual = '{"Mascott" : "Tux"}';1755 $message = 'Given Json strings do not match';1756 $this->assertJsonStringEqualsJsonString($expected, $actual, $message);1757 }1758 /**1759 * @dataProvider validInvalidJsonDataprovider1760 *1761 * @throws ExpectationFailedException1762 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException1763 */1764 public function testAssertJsonStringEqualsJsonStringErrorRaised($expected, $actual): void1765 {1766 $this->expectException(AssertionFailedError::class);1767 $this->assertJsonStringEqualsJsonString($expected, $actual);1768 }1769 public function testAssertJsonStringNotEqualsJsonString(): void1770 {1771 $expected = '{"Mascott" : "Beastie"}';1772 $actual = '{"Mascott" : "Tux"}';1773 $message = 'Given Json strings do match';1774 $this->assertJsonStringNotEqualsJsonString($expected, $actual, $message);1775 }1776 /**1777 * @dataProvider validInvalidJsonDataprovider1778 *1779 * @throws ExpectationFailedException1780 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException1781 */1782 public function testAssertJsonStringNotEqualsJsonStringErrorRaised($expected, $actual): void1783 {1784 $this->expectException(AssertionFailedError::class);1785 $this->assertJsonStringNotEqualsJsonString($expected, $actual);1786 }1787 public function testAssertJsonStringEqualsJsonFile(): void1788 {1789 $file = TEST_FILES_PATH . 'JsonData/simpleObject.json';1790 $actual = \json_encode(['Mascott' => 'Tux']);1791 $message = '';1792 $this->assertJsonStringEqualsJsonFile($file, $actual, $message);1793 }1794 public function testAssertJsonStringEqualsJsonFileExpectingExpectationFailedException(): void1795 {1796 $file = TEST_FILES_PATH . 'JsonData/simpleObject.json';1797 $actual = \json_encode(['Mascott' => 'Beastie']);1798 $message = '';1799 try {1800 $this->assertJsonStringEqualsJsonFile($file, $actual, $message);1801 } catch (ExpectationFailedException $e) {1802 $this->assertEquals(1803 'Failed asserting that \'{"Mascott":"Beastie"}\' matches JSON string "{"Mascott":"Tux"}".',1804 $e->getMessage()1805 );1806 return;1807 }1808 $this->fail('Expected Exception not thrown.');1809 }1810 public function testAssertJsonStringNotEqualsJsonFile(): void1811 {1812 $file = TEST_FILES_PATH . 'JsonData/simpleObject.json';1813 $actual = \json_encode(['Mascott' => 'Beastie']);1814 $message = '';1815 $this->assertJsonStringNotEqualsJsonFile($file, $actual, $message);1816 }1817 public function testAssertJsonFileNotEqualsJsonFile(): void1818 {1819 $fileExpected = TEST_FILES_PATH . 'JsonData/simpleObject.json';1820 $fileActual = TEST_FILES_PATH . 'JsonData/arrayObject.json';1821 $message = '';1822 $this->assertJsonFileNotEqualsJsonFile($fileExpected, $fileActual, $message);1823 }1824 public function testAssertJsonFileEqualsJsonFile(): void1825 {1826 $file = TEST_FILES_PATH . 'JsonData/simpleObject.json';1827 $message = '';1828 $this->assertJsonFileEqualsJsonFile($file, $file, $message);1829 }1830 public function testAssertInstanceOfThrowsExceptionIfTypeDoesNotExist(): void1831 {1832 $this->expectException(Exception::class);1833 $this->assertInstanceOf('ClassThatDoesNotExist', new \stdClass);1834 }1835 public function testAssertInstanceOf(): void1836 {1837 $this->assertInstanceOf(\stdClass::class, new \stdClass);1838 $this->expectException(AssertionFailedError::class);1839 $this->assertInstanceOf(\Exception::class, new \stdClass);1840 }1841 public function testAssertAttributeInstanceOf(): void1842 {1843 $o = new \stdClass;1844 $o->a = new \stdClass;1845 $this->assertAttributeInstanceOf(\stdClass::class, 'a', $o);1846 }1847 public function testAssertNotInstanceOfThrowsExceptionIfTypeDoesNotExist(): void1848 {1849 $this->expectException(Exception::class);1850 $this->assertNotInstanceOf('ClassThatDoesNotExist', new \stdClass);1851 }1852 public function testAssertNotInstanceOf(): void1853 {1854 $this->assertNotInstanceOf(\Exception::class, new \stdClass);1855 $this->expectException(AssertionFailedError::class);1856 $this->assertNotInstanceOf(\stdClass::class, new \stdClass);1857 }1858 public function testAssertAttributeNotInstanceOf(): void1859 {1860 $o = new \stdClass;1861 $o->a = new \stdClass;1862 $this->assertAttributeNotInstanceOf(\Exception::class, 'a', $o);1863 }1864 public function testAssertInternalType(): void1865 {1866 $this->assertInternalType('integer', 1);1867 $this->expectException(AssertionFailedError::class);1868 $this->assertInternalType('string', 1);1869 }1870 public function testAssertInternalTypeDouble(): void1871 {1872 $this->assertInternalType('double', 1.0);1873 $this->expectException(AssertionFailedError::class);1874 $this->assertInternalType('double', 1);1875 }1876 public function testAssertAttributeInternalType(): void1877 {1878 $o = new \stdClass;1879 $o->a = 1;1880 $this->assertAttributeInternalType('integer', 'a', $o);1881 }1882 public function testAssertNotInternalType(): void1883 {1884 $this->assertNotInternalType('string', 1);1885 $this->expectException(AssertionFailedError::class);1886 $this->assertNotInternalType('integer', 1);1887 }1888 public function testAssertAttributeNotInternalType(): void1889 {1890 $o = new \stdClass;1891 $o->a = 1;1892 $this->assertAttributeNotInternalType('string', 'a', $o);1893 }1894 public function testAssertStringMatchesFormatFileThrowsExceptionForInvalidArgument(): void1895 {1896 $this->expectException(Exception::class);1897 $this->assertStringMatchesFormatFile('not_existing_file', '');1898 }1899 public function testAssertStringMatchesFormatFile(): void1900 {1901 $this->assertStringMatchesFormatFile(TEST_FILES_PATH . 'expectedFileFormat.txt', "FOO\n");1902 $this->expectException(AssertionFailedError::class);1903 $this->assertStringMatchesFormatFile(TEST_FILES_PATH . 'expectedFileFormat.txt', "BAR\n");1904 }1905 public function testAssertStringNotMatchesFormatFileThrowsExceptionForInvalidArgument(): void1906 {1907 $this->expectException(Exception::class);1908 $this->assertStringNotMatchesFormatFile('not_existing_file', '');1909 }1910 public function testAssertStringNotMatchesFormatFile(): void1911 {1912 $this->assertStringNotMatchesFormatFile(TEST_FILES_PATH . 'expectedFileFormat.txt', "BAR\n");1913 $this->expectException(AssertionFailedError::class);1914 $this->assertStringNotMatchesFormatFile(TEST_FILES_PATH . 'expectedFileFormat.txt', "FOO\n");1915 }1916 public function testStringsCanBeComparedForEqualityIgnoringCase(): void1917 {1918 $this->assertEqualsIgnoringCase('a', 'A');1919 $this->assertNotEqualsIgnoringCase('a', 'B');1920 }1921 public function testArraysOfStringsCanBeComparedForEqualityIgnoringCase(): void1922 {1923 $this->assertEqualsIgnoringCase(['a'], ['A']);1924 $this->assertNotEqualsIgnoringCase(['a'], ['B']);1925 }1926 public function testStringsCanBeComparedForEqualityWithDelta(): void1927 {1928 $this->assertEqualsWithDelta(2.3, 2.5, 0.5);1929 $this->assertNotEqualsWithDelta(2.3, 3.5, 0.5);1930 }1931 public function testArraysOfStringsCanBeComparedForEqualityWithDelta(): void1932 {1933 $this->assertEqualsWithDelta([2.3], [2.5], 0.5);1934 $this->assertNotEqualsWithDelta([2.3], [3.5], 0.5);1935 }1936 public function testArraysCanBeComparedForEqualityWithCanonicalization(): void1937 {1938 $this->assertEqualsCanonicalizing([3, 2, 1], [2, 3, 1]);1939 $this->assertNotEqualsCanonicalizing([3, 2, 1], [2, 3, 4]);1940 }1941 public function testArrayTypeCanBeAsserted(): void1942 {1943 $this->assertIsArray([]);1944 try {1945 $this->assertIsArray(null);1946 } catch (AssertionFailedError $e) {1947 return;1948 }1949 $this->fail();1950 }1951 public function testBoolTypeCanBeAsserted(): void1952 {1953 $this->assertIsBool(true);1954 try {1955 $this->assertIsBool(null);1956 } catch (AssertionFailedError $e) {1957 return;1958 }1959 $this->fail();1960 }1961 public function testFloatTypeCanBeAsserted(): void1962 {1963 $this->assertIsFloat(0.0);1964 try {1965 $this->assertIsFloat(null);1966 } catch (AssertionFailedError $e) {1967 return;1968 }1969 $this->fail();1970 }1971 public function testIntTypeCanBeAsserted(): void1972 {1973 $this->assertIsInt(1);1974 try {1975 $this->assertIsInt(null);1976 } catch (AssertionFailedError $e) {1977 return;1978 }1979 $this->fail();1980 }1981 public function testNumericTypeCanBeAsserted(): void1982 {1983 $this->assertIsNumeric('1.0');1984 try {1985 $this->assertIsNumeric('abc');1986 } catch (AssertionFailedError $e) {1987 return;1988 }1989 $this->fail();1990 }1991 public function testObjectTypeCanBeAsserted(): void1992 {1993 $this->assertIsObject(new \stdClass);1994 try {1995 $this->assertIsObject(null);1996 } catch (AssertionFailedError $e) {1997 return;1998 }1999 $this->fail();2000 }2001 public function testResourceTypeCanBeAsserted(): void2002 {2003 $this->assertIsResource(\fopen(__FILE__, 'r'));2004 try {2005 $this->assertIsResource(null);2006 } catch (AssertionFailedError $e) {2007 return;2008 }2009 $this->fail();2010 }2011 public function testStringTypeCanBeAsserted(): void2012 {2013 $this->assertIsString('');2014 try {2015 $this->assertIsString(null);2016 } catch (AssertionFailedError $e) {2017 return;2018 }2019 $this->fail();2020 }2021 public function testScalarTypeCanBeAsserted(): void2022 {2023 $this->assertIsScalar(true);2024 try {2025 $this->assertIsScalar(new \stdClass);2026 } catch (AssertionFailedError $e) {2027 return;2028 }2029 $this->fail();2030 }2031 public function testCallableTypeCanBeAsserted(): void2032 {2033 $this->assertIsCallable(function () {2034 });2035 try {2036 $this->assertIsCallable(null);2037 } catch (AssertionFailedError $e) {2038 return;2039 }2040 $this->fail();2041 }2042 public function testIterableTypeCanBeAsserted(): void2043 {2044 $this->assertIsIterable([]);2045 try {2046 $this->assertIsIterable(null);2047 } catch (AssertionFailedError $e) {2048 return;2049 }2050 $this->fail();2051 }2052 public function testNotArrayTypeCanBeAsserted(): void2053 {2054 $this->assertIsNotArray(null);2055 try {2056 $this->assertIsNotArray([]);2057 } catch (AssertionFailedError $e) {2058 return;2059 }2060 $this->fail();2061 }2062 public function testNotBoolTypeCanBeAsserted(): void2063 {2064 $this->assertIsNotBool(null);2065 try {2066 $this->assertIsNotBool(true);2067 } catch (AssertionFailedError $e) {2068 return;2069 }2070 $this->fail();2071 }2072 public function testNotFloatTypeCanBeAsserted(): void2073 {2074 $this->assertIsNotFloat(null);2075 try {2076 $this->assertIsNotFloat(0.0);2077 } catch (AssertionFailedError $e) {2078 return;2079 }2080 $this->fail();2081 }2082 public function testNotIntTypeCanBeAsserted(): void2083 {2084 $this->assertIsNotInt(null);2085 try {2086 $this->assertIsNotInt(1);2087 } catch (AssertionFailedError $e) {2088 return;2089 }2090 $this->fail();2091 }2092 public function testNotNumericTypeCanBeAsserted(): void2093 {2094 $this->assertIsNotNumeric('abc');2095 try {2096 $this->assertIsNotNumeric('1.0');2097 } catch (AssertionFailedError $e) {2098 return;2099 }2100 $this->fail();2101 }2102 public function testNotObjectTypeCanBeAsserted(): void2103 {2104 $this->assertIsNotObject(null);2105 try {2106 $this->assertIsNotObject(new \stdClass);2107 } catch (AssertionFailedError $e) {2108 return;2109 }2110 $this->fail();2111 }2112 public function testNotResourceTypeCanBeAsserted(): void2113 {2114 $this->assertIsNotResource(null);2115 try {2116 $this->assertIsNotResource(\fopen(__FILE__, 'r'));2117 } catch (AssertionFailedError $e) {2118 return;2119 }2120 $this->fail();2121 }2122 public function testNotScalarTypeCanBeAsserted(): void2123 {2124 $this->assertIsNotScalar(new \stdClass);2125 try {2126 $this->assertIsNotScalar(true);2127 } catch (AssertionFailedError $e) {2128 return;2129 }2130 $this->fail();2131 }2132 public function testNotStringTypeCanBeAsserted(): void2133 {2134 $this->assertIsNotString(null);2135 try {2136 $this->assertIsNotString('');2137 } catch (AssertionFailedError $e) {2138 return;2139 }2140 $this->fail();2141 }2142 public function testNotCallableTypeCanBeAsserted(): void2143 {2144 $this->assertIsNotCallable(null);2145 try {2146 $this->assertIsNotCallable(function () {2147 });2148 } catch (AssertionFailedError $e) {2149 return;2150 }2151 $this->fail();2152 }2153 public function testNotIterableTypeCanBeAsserted(): void2154 {2155 $this->assertIsNotIterable(null);2156 try {2157 $this->assertIsNotIterable([]);2158 } catch (AssertionFailedError $e) {2159 return;2160 }2161 $this->fail();2162 }2163 public function testLogicalAnd(): void2164 {2165 $this->assertThat(2166 true,2167 $this->logicalAnd(2168 $this->isTrue(),2169 $this->isTrue()2170 )2171 );2172 $this->expectException(AssertionFailedError::class);2173 $this->assertThat(2174 true,2175 $this->logicalAnd(2176 $this->isTrue(),2177 $this->isFalse()2178 )2179 );2180 }2181 public function testLogicalOr(): void2182 {2183 $this->assertThat(2184 true,2185 $this->logicalOr(2186 $this->isTrue(),2187 $this->isFalse()2188 )2189 );2190 $this->expectException(AssertionFailedError::class);2191 $this->assertThat(2192 true,2193 $this->logicalOr(2194 $this->isFalse(),2195 $this->isFalse()2196 )2197 );2198 }2199 public function testLogicalXor(): void2200 {2201 $this->assertThat(2202 true,2203 $this->logicalXor(2204 $this->isTrue(),2205 $this->isFalse()2206 )2207 );2208 $this->expectException(AssertionFailedError::class);2209 $this->assertThat(2210 true,2211 $this->logicalXor(2212 $this->isTrue(),2213 $this->isTrue()2214 )2215 );2216 }2217 public function testStringContainsStringCanBeAsserted(): void2218 {2219 $this->assertStringContainsString('bar', 'foobarbaz');2220 try {2221 $this->assertStringContainsString('barbara', 'foobarbaz');2222 } catch (AssertionFailedError $e) {2223 return;2224 }2225 $this->fail();2226 }2227 public function testStringNotContainsStringCanBeAsserted(): void2228 {2229 $this->assertStringNotContainsString('barbara', 'foobarbaz');2230 try {2231 $this->assertStringNotContainsString('bar', 'foobarbaz');2232 } catch (AssertionFailedError $e) {2233 return;2234 }2235 $this->fail();2236 }2237 public function testStringContainsStringCanBeAssertedIgnoringCase(): void2238 {2239 $this->assertStringContainsStringIgnoringCase('BAR', 'foobarbaz');2240 try {2241 $this->assertStringContainsStringIgnoringCase('BARBARA', 'foobarbaz');2242 } catch (AssertionFailedError $e) {2243 return;2244 }2245 $this->fail();2246 }2247 public function testStringNotContainsStringCanBeAssertedIgnoringCase(): void2248 {2249 $this->assertStringNotContainsStringIgnoringCase('BARBARA', 'foobarbaz');2250 try {2251 $this->assertStringNotContainsStringIgnoringCase('BAR', 'foobarbaz');2252 } catch (AssertionFailedError $e) {2253 return;2254 }2255 $this->fail();2256 }2257 public function testIterableContainsSameObjectCanBeAsserted(): void2258 {2259 $object = new \stdClass;2260 $iterable = [$object];2261 $this->assertContains($object, $iterable);2262 try {2263 $this->assertContains(new \stdClass, $iterable);2264 } catch (AssertionFailedError $e) {2265 return;2266 }2267 $this->fail();2268 }2269 public function testIterableNotContainsSameObjectCanBeAsserted(): void2270 {2271 $object = new \stdClass;2272 $iterable = [$object];2273 $this->assertNotContains(new \stdClass, $iterable);2274 try {2275 $this->assertNotContains($object, $iterable);2276 } catch (AssertionFailedError $e) {2277 return;2278 }2279 $this->fail();2280 }2281 protected function sameValues(): array2282 {2283 $object = new \SampleClass(4, 8, 15);2284 $file = TEST_FILES_PATH . 'foo.xml';2285 $resource = \fopen($file, 'r');2286 return [2287 // null2288 [null, null],2289 // strings2290 ['a', 'a'],...
AssertionFailedError
Using AI Code Generation
1require_once 'PHPUnit/Framework/Assert/Functions.php';2require_once 'PHPUnit/Framework/TestCase.php';3require_once 'PHPUnit/Framework/TestSuite.php';4require_once 'PHPUnit/TextUI/TestRunner.php';5require_once 'PHPUnit/Util/Filter.php';6require_once '2.php';7require_once 'PHPUnit/Util/Test.php';8require_once 'PHPUnit/Framework/TestResult.php';9require_once 'PHPUnit/Framework/TestListener.php';10require_once 'PHPUnit/Framework/TestSuite.php';11require_once 'PHPUnit/Framework/Test.php';12require_once 'PHPUnit/Framework/AssertionFailedError.php';13require_once 'PHPUnit/Framework/Exception.php';14require_once 'PHPUnit/Framework/TestFailure.php';15require_once 'PHPUnit/Framework/TestListener.php';16require_once 'PHPUnit/Framework/TestResult.php';17require_once 'PHPUnit/Framework/TestSuite.php';18require_once 'PHPUnit/Framework/Warning.php';19require_once 'PHPUnit/TextUI/ResultPrinter.php';20require_once 'PHPUnit/TextUI/TestRunner.php';21require_once 'PHPUnit/Util/ErrorHandler.php';22require_once 'PHPUnit/Util/Filter.php';
AssertionFailedError
Using AI Code Generation
1use PHPUnit\Framework\TestCase;2use PHPUnit\Framework\AssertionFailedError;3{4 public function testAssert()5 {6 $this->assertEquals(1, 2);7 }8}9use PHPUnit\Framework\TestCase;10use PHPUnit\Framework\Assert;11{12 public function testAssert()13 {14 Assert::assertEquals(1, 2);15 }16}17use PHPUnit\Framework\TestCase;18use PHPUnit\Framework\Assert;19{20 public function testAssert()21 {22 $this->assertTrue(false);23 }24}
AssertionFailedError
Using AI Code Generation
1use PHPUnit\Framework\AssertionFailedError;2{3 public function testAssertStringContainsString()4 {5 $this->assertStringContainsString('foo', 'foobar');6 }7}8use PHPUnit\Framework\AssertionFailedError;9{10 public function testAssertStringContainsString()11 {12 $this->assertStringContainsString('foo', 'foobar');13 }14}15use PHPUnit\Framework\AssertionFailedError;16{17 public function testAssertStringContainsString()18 {19 $this->assertStringContainsString('foo', 'foobar');20 }21}22use PHPUnit\Framework\AssertionFailedError;23{24 public function testAssertStringContainsString()25 {26 $this->assertStringContainsString('foo', 'foobar');27 }28}29use PHPUnit\Framework\AssertionFailedError;30{31 public function testAssertStringContainsString()32 {33 $this->assertStringContainsString('foo', 'foobar');34 }35}36use PHPUnit\Framework\AssertionFailedError;37{38 public function testAssertStringContainsString()39 {40 $this->assertStringContainsString('foo', 'foobar');41 }42}43use PHPUnit\Framework\AssertionFailedError;44{45 public function testAssertStringContainsString()46 {47 $this->assertStringContainsString('foo', 'foobar');48 }49}50use PHPUnit\Framework\AssertionFailedError;51{52 public function testAssertStringContainsString()53 {
AssertionFailedError
Using AI Code Generation
1use PHPUnit\Framework\AssertionFailedError;2{3 use \PHPUnit\Framework\Assert;4 public function testOne()5 {6 $this->assertFileExists('/path/to/file');7 }8}9assertFileNotExists() method10public void assertFileNotExists ( string $filename [, string $message = '' ] )11use PHPUnit\Framework\AssertionFailedError;12{13 use \PHPUnit\Framework\Assert;14 public function testOne()15 {16 $this->assertFileNotExists('/path/to/file');17 }18}19OK (1 test, 1 assertion)20assertDirectoryExists() method
AssertionFailedError
Using AI Code Generation
1require_once 'PHPUnit/Framework/Assert/Functions.php';2require_once 'PHPUnit/Framework/Assert.php';3PHPUnit_Framework_Assert::fail('test failed');4require_once 'PHPUnit/Framework/Assert/Functions.php';5fail('test failed');6require_once 'PHPUnit/Framework/Assert.php';
AssertionFailedError
Using AI Code Generation
1class Test extends PHPUnit_Framework_TestCase {2 public function testFailure() {3 $this->assertStringStartsWith('foo', 'bar');4 }5}6assertStringStartsWith(string $prefix, string $string, string $message = '')7class Test extends PHPUnit_Framework_TestCase {8 public function testFailure() {9 $this->assertStringStartsWith('foo', 'foobar');10 }11}12OK (1 test, 1 assertion)13assertStringEndsWith(string $suffix, string $string, string $message = '')
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Phpunit automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used methods in AssertionFailedError
Run Selenium Automation Tests on LambdaTest Cloud Grid
Trigger Selenium automation tests on a cloud-based Grid of 3000+ real browsers and operating systems.
Test now for FreeTry LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
