JFIFxxC      C  " }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbrhamcrest-php/composer.json000064400000001246150364331700011666 0ustar00{ "name": "hamcrest/hamcrest-php", "type": "library", "description": "This is the PHP port of Hamcrest Matchers", "keywords": ["test"], "license": "BSD-3-Clause", "authors": [ ], "autoload": { "classmap": ["hamcrest"] }, "autoload-dev": { "classmap": ["tests", "generator"] }, "require": { "php": "^5.3|^7.0|^8.0" }, "require-dev": { "phpunit/php-file-iterator": "^1.4 || ^2.0", "phpunit/phpunit": "^4.8.36 || ^5.7 || ^6.5 || ^7.0" }, "replace": { "kodova/hamcrest-php": "*", "davedevelopment/hamcrest-php": "*", "cordoval/hamcrest-php": "*" }, "extra": { "branch-alias": { "dev-master": "2.1-dev" } } } hamcrest-php/tests/bootstrap.php000064400000000334150364331700013031 0ustar00 . ../hamcrest hamcrest-php/tests/Hamcrest/Xml/HasXPathTest.php000064400000011750150364331700015646 0ustar00 alice Alice Frankel admin bob Bob Frankel user charlie Charlie Chan user XML; self::$doc = new \DOMDocument(); self::$doc->loadXML(self::$xml); self::$html = << Home Page

Heading

Some text

HTML; } protected function createMatcher() { return \Hamcrest\Xml\HasXPath::hasXPath('/users/user'); } public function testMatchesWhenXPathIsFound() { assertThat('one match', self::$doc, hasXPath('user[id = "bob"]')); assertThat('two matches', self::$doc, hasXPath('user[role = "user"]')); } public function testDoesNotMatchWhenXPathIsNotFound() { assertThat( 'no match', self::$doc, not(hasXPath('user[contains(id, "frank")]')) ); } public function testMatchesWhenExpressionWithoutMatcherEvaluatesToTrue() { assertThat( 'one match', self::$doc, hasXPath('count(user[id = "bob"])') ); } public function testDoesNotMatchWhenExpressionWithoutMatcherEvaluatesToFalse() { assertThat( 'no matches', self::$doc, not(hasXPath('count(user[id = "frank"])')) ); } public function testMatchesWhenExpressionIsEqual() { assertThat( 'one match', self::$doc, hasXPath('count(user[id = "bob"])', 1) ); assertThat( 'two matches', self::$doc, hasXPath('count(user[role = "user"])', 2) ); } public function testDoesNotMatchWhenExpressionIsNotEqual() { assertThat( 'no match', self::$doc, not(hasXPath('count(user[id = "frank"])', 2)) ); assertThat( 'one match', self::$doc, not(hasXPath('count(user[role = "admin"])', 2)) ); } public function testMatchesWhenContentMatches() { assertThat( 'one match', self::$doc, hasXPath('user/name', containsString('ice')) ); assertThat( 'two matches', self::$doc, hasXPath('user/role', equalTo('user')) ); } public function testDoesNotMatchWhenContentDoesNotMatch() { assertThat( 'no match', self::$doc, not(hasXPath('user/name', containsString('Bobby'))) ); assertThat( 'no matches', self::$doc, not(hasXPath('user/role', equalTo('owner'))) ); } public function testProvidesConvenientShortcutForHasXPathEqualTo() { assertThat('matches', self::$doc, hasXPath('count(user)', 3)); assertThat('matches', self::$doc, hasXPath('user[2]/id', 'bob')); } public function testProvidesConvenientShortcutForHasXPathCountEqualTo() { assertThat('matches', self::$doc, hasXPath('user[id = "charlie"]', 1)); } public function testMatchesAcceptsXmlString() { assertThat('accepts XML string', self::$xml, hasXPath('user')); } public function testMatchesAcceptsHtmlString() { assertThat('accepts HTML string', self::$html, hasXPath('body/h1', 'Heading')); } public function testHasAReadableDescription() { $this->assertDescription( 'XML or HTML document with XPath "/users/user"', hasXPath('/users/user') ); $this->assertDescription( 'XML or HTML document with XPath "count(/users/user)" <2>', hasXPath('/users/user', 2) ); $this->assertDescription( 'XML or HTML document with XPath "/users/user/name"' . ' a string starting with "Alice"', hasXPath('/users/user/name', startsWith('Alice')) ); } public function testHasAReadableMismatchDescription() { $this->assertMismatchDescription( 'XPath returned no results', hasXPath('/users/name'), self::$doc ); $this->assertMismatchDescription( 'XPath expression result was <3F>', hasXPath('/users/user', 2), self::$doc ); $this->assertMismatchDescription( 'XPath returned ["alice", "bob", "charlie"]', hasXPath('/users/user/id', 'Frank'), self::$doc ); } } hamcrest-php/tests/Hamcrest/BaseMatcherTest.php000064400000001027150364331700015600 0ustar00appendText('SOME DESCRIPTION'); } public function testDescribesItselfWithToStringMethod() { $someMatcher = new \Hamcrest\SomeMatcher(); $this->assertEquals('SOME DESCRIPTION', (string) $someMatcher); } } hamcrest-php/tests/Hamcrest/Text/IsEmptyStringTest.php000064400000004367150364331700017141 0ustar00assertDoesNotMatch(emptyString(), null, 'null'); } public function testEmptyDoesNotMatchZero() { $this->assertDoesNotMatch(emptyString(), 0, 'zero'); } public function testEmptyDoesNotMatchFalse() { $this->assertDoesNotMatch(emptyString(), false, 'false'); } public function testEmptyDoesNotMatchEmptyArray() { $this->assertDoesNotMatch(emptyString(), array(), 'empty array'); } public function testEmptyMatchesEmptyString() { $this->assertMatches(emptyString(), '', 'empty string'); } public function testEmptyDoesNotMatchNonEmptyString() { $this->assertDoesNotMatch(emptyString(), 'foo', 'non-empty string'); } public function testEmptyHasAReadableDescription() { $this->assertDescription('an empty string', emptyString()); } public function testEmptyOrNullMatchesNull() { $this->assertMatches(nullOrEmptyString(), null, 'null'); } public function testEmptyOrNullMatchesEmptyString() { $this->assertMatches(nullOrEmptyString(), '', 'empty string'); } public function testEmptyOrNullDoesNotMatchNonEmptyString() { $this->assertDoesNotMatch(nullOrEmptyString(), 'foo', 'non-empty string'); } public function testEmptyOrNullHasAReadableDescription() { $this->assertDescription('(null or an empty string)', nullOrEmptyString()); } public function testNonEmptyDoesNotMatchNull() { $this->assertDoesNotMatch(nonEmptyString(), null, 'null'); } public function testNonEmptyDoesNotMatchEmptyString() { $this->assertDoesNotMatch(nonEmptyString(), '', 'empty string'); } public function testNonEmptyMatchesNonEmptyString() { $this->assertMatches(nonEmptyString(), 'foo', 'non-empty string'); } public function testNonEmptyHasAReadableDescription() { $this->assertDescription('a non-empty string', nonEmptyString()); } } hamcrest-php/tests/Hamcrest/Text/MatchesPatternTest.php000064400000001533150364331700017272 0ustar00assertDescription('a string matching "pattern"', matchesPattern('pattern')); } } hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringCaseTest.php000064400000002174150364331700020206 0ustar00assertDescription( 'equalToIgnoringCase("heLLo")', equalToIgnoringCase('heLLo') ); } } hamcrest-php/tests/Hamcrest/Text/StringContainsIgnoringCaseTest.php000064400000004671150364331700021614 0ustar00_stringContains = \Hamcrest\Text\StringContainsIgnoringCase::containsStringIgnoringCase( strtolower(self::EXCERPT) ); } protected function createMatcher() { return $this->_stringContains; } public function testEvaluatesToTrueIfArgumentContainsSpecifiedSubstring() { $this->assertTrue( $this->_stringContains->matches(self::EXCERPT . 'END'), 'should be true if excerpt at beginning' ); $this->assertTrue( $this->_stringContains->matches('START' . self::EXCERPT), 'should be true if excerpt at end' ); $this->assertTrue( $this->_stringContains->matches('START' . self::EXCERPT . 'END'), 'should be true if excerpt in middle' ); $this->assertTrue( $this->_stringContains->matches(self::EXCERPT . self::EXCERPT), 'should be true if excerpt is repeated' ); $this->assertFalse( $this->_stringContains->matches('Something else'), 'should not be true if excerpt is not in string' ); $this->assertFalse( $this->_stringContains->matches(substr(self::EXCERPT, 1)), 'should not be true if part of excerpt is in string' ); } public function testEvaluatesToTrueIfArgumentIsEqualToSubstring() { $this->assertTrue( $this->_stringContains->matches(self::EXCERPT), 'should be true if excerpt is entire string' ); } public function testEvaluatesToTrueIfArgumentContainsExactSubstring() { $this->assertTrue( $this->_stringContains->matches(strtolower(self::EXCERPT)), 'should be false if excerpt is entire string ignoring case' ); $this->assertTrue( $this->_stringContains->matches('START' . strtolower(self::EXCERPT) . 'END'), 'should be false if excerpt is contained in string ignoring case' ); } public function testHasAReadableDescription() { $this->assertDescription( 'a string containing in any case "' . strtolower(self::EXCERPT) . '"', $this->_stringContains ); } } hamcrest-php/tests/Hamcrest/Text/StringEndsWithTest.php000064400000003552150364331700017267 0ustar00_stringEndsWith = \Hamcrest\Text\StringEndsWith::endsWith(self::EXCERPT); } protected function createMatcher() { return $this->_stringEndsWith; } public function testEvaluatesToTrueIfArgumentContainsSpecifiedSubstring() { $this->assertFalse( $this->_stringEndsWith->matches(self::EXCERPT . 'END'), 'should be false if excerpt at beginning' ); $this->assertTrue( $this->_stringEndsWith->matches('START' . self::EXCERPT), 'should be true if excerpt at end' ); $this->assertFalse( $this->_stringEndsWith->matches('START' . self::EXCERPT . 'END'), 'should be false if excerpt in middle' ); $this->assertTrue( $this->_stringEndsWith->matches(self::EXCERPT . self::EXCERPT), 'should be true if excerpt is at end and repeated' ); $this->assertFalse( $this->_stringEndsWith->matches('Something else'), 'should be false if excerpt is not in string' ); $this->assertFalse( $this->_stringEndsWith->matches(substr(self::EXCERPT, 0, strlen(self::EXCERPT) - 2)), 'should be false if part of excerpt is at end of string' ); } public function testEvaluatesToTrueIfArgumentIsEqualToSubstring() { $this->assertTrue( $this->_stringEndsWith->matches(self::EXCERPT), 'should be true if excerpt is entire string' ); } public function testHasAReadableDescription() { $this->assertDescription('a string ending with "EXCERPT"', $this->_stringEndsWith); } } hamcrest-php/tests/Hamcrest/Text/StringContainsInOrderTest.php000064400000002347150364331700020604 0ustar00_m = \Hamcrest\Text\StringContainsInOrder::stringContainsInOrder(array('a', 'b', 'c')); } protected function createMatcher() { return $this->_m; } public function testMatchesOnlyIfStringContainsGivenSubstringsInTheSameOrder() { $this->assertMatches($this->_m, 'abc', 'substrings in order'); $this->assertMatches($this->_m, '1a2b3c4', 'substrings separated'); $this->assertDoesNotMatch($this->_m, 'cab', 'substrings out of order'); $this->assertDoesNotMatch($this->_m, 'xyz', 'no substrings in string'); $this->assertDoesNotMatch($this->_m, 'ac', 'substring missing'); $this->assertDoesNotMatch($this->_m, '', 'empty string'); } public function testAcceptsVariableArguments() { $this->assertMatches(stringContainsInOrder('a', 'b', 'c'), 'abc', 'substrings as variable arguments'); } public function testHasAReadableDescription() { $this->assertDescription( 'a string containing "a", "b", "c" in order', $this->_m ); } } hamcrest-php/tests/Hamcrest/Text/StringContainsTest.php000064400000005132150364331700017314 0ustar00_stringContains = \Hamcrest\Text\StringContains::containsString(self::EXCERPT); } protected function createMatcher() { return $this->_stringContains; } public function testEvaluatesToTrueIfArgumentContainsSubstring() { $this->assertTrue( $this->_stringContains->matches(self::EXCERPT . 'END'), 'should be true if excerpt at beginning' ); $this->assertTrue( $this->_stringContains->matches('START' . self::EXCERPT), 'should be true if excerpt at end' ); $this->assertTrue( $this->_stringContains->matches('START' . self::EXCERPT . 'END'), 'should be true if excerpt in middle' ); $this->assertTrue( $this->_stringContains->matches(self::EXCERPT . self::EXCERPT), 'should be true if excerpt is repeated' ); $this->assertFalse( $this->_stringContains->matches('Something else'), 'should not be true if excerpt is not in string' ); $this->assertFalse( $this->_stringContains->matches(substr(self::EXCERPT, 1)), 'should not be true if part of excerpt is in string' ); } public function testEvaluatesToTrueIfArgumentIsEqualToSubstring() { $this->assertTrue( $this->_stringContains->matches(self::EXCERPT), 'should be true if excerpt is entire string' ); } public function testEvaluatesToFalseIfArgumentContainsSubstringIgnoringCase() { $this->assertFalse( $this->_stringContains->matches(strtolower(self::EXCERPT)), 'should be false if excerpt is entire string ignoring case' ); $this->assertFalse( $this->_stringContains->matches('START' . strtolower(self::EXCERPT) . 'END'), 'should be false if excerpt is contained in string ignoring case' ); } public function testIgnoringCaseReturnsCorrectMatcher() { $this->assertTrue( $this->_stringContains->ignoringCase()->matches('EXceRpT'), 'should be true if excerpt is entire string ignoring case' ); } public function testHasAReadableDescription() { $this->assertDescription( 'a string containing "' . self::EXCERPT . '"', $this->_stringContains ); } } hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringWhiteSpaceTest.php000064400000002556150364331700021373 0ustar00_matcher = \Hamcrest\Text\IsEqualIgnoringWhiteSpace::equalToIgnoringWhiteSpace( "Hello World how\n are we? " ); } protected function createMatcher() { return $this->_matcher; } public function testPassesIfWordsAreSameButWhitespaceDiffers() { assertThat('Hello World how are we?', $this->_matcher); assertThat(" Hello \rWorld \t how are\nwe?", $this->_matcher); } public function testFailsIfTextOtherThanWhitespaceDiffers() { assertThat('Hello PLANET how are we?', not($this->_matcher)); assertThat('Hello World how are we', not($this->_matcher)); } public function testFailsIfWhitespaceIsAddedOrRemovedInMidWord() { assertThat('HelloWorld how are we?', not($this->_matcher)); assertThat('Hello Wo rld how are we?', not($this->_matcher)); } public function testFailsIfMatchingAgainstNull() { assertThat(null, not($this->_matcher)); } public function testHasAReadableDescription() { $this->assertDescription( "equalToIgnoringWhiteSpace(\"Hello World how\\n are we? \")", $this->_matcher ); } } hamcrest-php/tests/Hamcrest/Text/StringStartsWithTest.php000064400000003565150364331700017662 0ustar00_stringStartsWith = \Hamcrest\Text\StringStartsWith::startsWith(self::EXCERPT); } protected function createMatcher() { return $this->_stringStartsWith; } public function testEvaluatesToTrueIfArgumentContainsSpecifiedSubstring() { $this->assertTrue( $this->_stringStartsWith->matches(self::EXCERPT . 'END'), 'should be true if excerpt at beginning' ); $this->assertFalse( $this->_stringStartsWith->matches('START' . self::EXCERPT), 'should be false if excerpt at end' ); $this->assertFalse( $this->_stringStartsWith->matches('START' . self::EXCERPT . 'END'), 'should be false if excerpt in middle' ); $this->assertTrue( $this->_stringStartsWith->matches(self::EXCERPT . self::EXCERPT), 'should be true if excerpt is at beginning and repeated' ); $this->assertFalse( $this->_stringStartsWith->matches('Something else'), 'should be false if excerpt is not in string' ); $this->assertFalse( $this->_stringStartsWith->matches(substr(self::EXCERPT, 1)), 'should be false if part of excerpt is at start of string' ); } public function testEvaluatesToTrueIfArgumentIsEqualToSubstring() { $this->assertTrue( $this->_stringStartsWith->matches(self::EXCERPT), 'should be true if excerpt is entire string' ); } public function testHasAReadableDescription() { $this->assertDescription('a string starting with "EXCERPT"', $this->_stringStartsWith); } } hamcrest-php/tests/Hamcrest/UtilTest.php000064400000005106150364331700014341 0ustar00assertSame($matcher, $newMatcher); } public function testWrapValueWithIsEqualWrapsPrimitive() { $matcher = \Hamcrest\Util::wrapValueWithIsEqual('foo'); $this->assertInstanceOf('Hamcrest\Core\IsEqual', $matcher); $this->assertTrue($matcher->matches('foo')); } public function testCheckAllAreMatchersAcceptsMatchers() { \Hamcrest\Util::checkAllAreMatchers(array( new \Hamcrest\Text\MatchesPattern('/fo+/'), new \Hamcrest\Core\IsEqual('foo'), )); } /** * @expectedException InvalidArgumentException */ public function testCheckAllAreMatchersFailsForPrimitive() { \Hamcrest\Util::checkAllAreMatchers(array( new \Hamcrest\Text\MatchesPattern('/fo+/'), 'foo', )); } private function callAndAssertCreateMatcherArray($items) { $matchers = \Hamcrest\Util::createMatcherArray($items); $this->assertInternalType('array', $matchers); $this->assertSameSize($items, $matchers); foreach ($matchers as $matcher) { $this->assertInstanceOf('\Hamcrest\Matcher', $matcher); } return $matchers; } public function testCreateMatcherArrayLeavesMatchersUntouched() { $matcher = new \Hamcrest\Text\MatchesPattern('/fo+/'); $items = array($matcher); $matchers = $this->callAndAssertCreateMatcherArray($items); $this->assertSame($matcher, $matchers[0]); } public function testCreateMatcherArrayWrapsPrimitiveWithIsEqualMatcher() { $matchers = $this->callAndAssertCreateMatcherArray(array('foo')); $this->assertInstanceOf('Hamcrest\Core\IsEqual', $matchers[0]); $this->assertTrue($matchers[0]->matches('foo')); } public function testCreateMatcherArrayDoesntModifyOriginalArray() { $items = array('foo'); $this->callAndAssertCreateMatcherArray($items); $this->assertSame('foo', $items[0]); } public function testCreateMatcherArrayUnwrapsSingleArrayElement() { $matchers = $this->callAndAssertCreateMatcherArray(array(array('foo'))); $this->assertInstanceOf('Hamcrest\Core\IsEqual', $matchers[0]); $this->assertTrue($matchers[0]->matches('foo')); } } hamcrest-php/tests/Hamcrest/MatcherAssertTest.php000064400000016275150364331700016202 0ustar00getMessage()); } try { \Hamcrest\MatcherAssert::assertThat(null); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat(''); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat(0); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat(0.0); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat(array()); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('', $ex->getMessage()); } self::assertEquals(6, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } public function testAssertThatWithIdentifierAndTrueArgPasses() { \Hamcrest\MatcherAssert::assertThat('identifier', true); \Hamcrest\MatcherAssert::assertThat('identifier', 'non-empty'); \Hamcrest\MatcherAssert::assertThat('identifier', 1); \Hamcrest\MatcherAssert::assertThat('identifier', 3.14159); \Hamcrest\MatcherAssert::assertThat('identifier', array(true)); self::assertEquals(5, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } public function testAssertThatWithIdentifierAndFalseArgFails() { try { \Hamcrest\MatcherAssert::assertThat('identifier', false); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('identifier', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat('identifier', null); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('identifier', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat('identifier', ''); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('identifier', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat('identifier', 0); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('identifier', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat('identifier', 0.0); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('identifier', $ex->getMessage()); } try { \Hamcrest\MatcherAssert::assertThat('identifier', array()); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals('identifier', $ex->getMessage()); } self::assertEquals(6, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } public function testAssertThatWithActualValueAndMatcherArgsThatMatchPasses() { \Hamcrest\MatcherAssert::assertThat(true, is(true)); self::assertEquals(1, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } public function testAssertThatWithActualValueAndMatcherArgsThatDontMatchFails() { $expected = 'expected'; $actual = 'actual'; $expectedMessage = 'Expected: "expected"' . PHP_EOL . ' but: was "actual"'; try { \Hamcrest\MatcherAssert::assertThat($actual, equalTo($expected)); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals($expectedMessage, $ex->getMessage()); self::assertEquals(1, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } } public function testAssertThatWithIdentifierAndActualValueAndMatcherArgsThatMatchPasses() { \Hamcrest\MatcherAssert::assertThat('identifier', true, is(true)); self::assertEquals(1, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } public function testAssertThatWithIdentifierAndActualValueAndMatcherArgsThatDontMatchFails() { $expected = 'expected'; $actual = 'actual'; $expectedMessage = 'identifier' . PHP_EOL . 'Expected: "expected"' . PHP_EOL . ' but: was "actual"'; try { \Hamcrest\MatcherAssert::assertThat('identifier', $actual, equalTo($expected)); self::fail('expected assertion failure'); } catch (\Hamcrest\AssertionError $ex) { self::assertEquals($expectedMessage, $ex->getMessage()); self::assertEquals(1, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } } public function testAssertThatWithNoArgsThrowsErrorAndDoesntIncrementCount() { try { \Hamcrest\MatcherAssert::assertThat(); self::fail('expected invalid argument exception'); } catch (\InvalidArgumentException $ex) { self::assertEquals(0, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } } public function testAssertThatWithFourArgsThrowsErrorAndDoesntIncrementCount() { try { \Hamcrest\MatcherAssert::assertThat(1, 2, 3, 4); self::fail('expected invalid argument exception'); } catch (\InvalidArgumentException $ex) { self::assertEquals(0, \Hamcrest\MatcherAssert::getCount(), 'assertion count'); } } } hamcrest-php/tests/Hamcrest/AbstractMatcherTest.php000064400000003577150364331700016505 0ustar00assertTrue($matcher->matches($arg), $message); } public function assertDoesNotMatch(\Hamcrest\Matcher $matcher, $arg, $message) { $this->assertFalse($matcher->matches($arg), $message); } public function assertDescription($expected, \Hamcrest\Matcher $matcher) { $description = new \Hamcrest\StringDescription(); $description->appendDescriptionOf($matcher); $this->assertEquals($expected, (string) $description, 'Expected description'); } public function assertMismatchDescription($expected, \Hamcrest\Matcher $matcher, $arg) { $description = new \Hamcrest\StringDescription(); $this->assertFalse( $matcher->matches($arg), 'Precondtion: Matcher should not match item' ); $matcher->describeMismatch($arg, $description); $this->assertEquals( $expected, (string) $description, 'Expected mismatch description' ); } public function testIsNullSafe() { //Should not generate any notices $this->createMatcher()->matches(null); $this->createMatcher()->describeMismatch( null, new \Hamcrest\NullDescription() ); } public function testCopesWithUnknownTypes() { //Should not generate any notices $this->createMatcher()->matches(new UnknownType()); $this->createMatcher()->describeMismatch( new UnknownType(), new NullDescription() ); } } hamcrest-php/tests/Hamcrest/Core/EveryTest.php000064400000001502150364331700015402 0ustar00assertEquals('every item is a string containing "a"', (string) $each); $this->assertMismatchDescription('an item was "BbB"', $each, array('BbB')); } } hamcrest-php/tests/Hamcrest/Core/SampleSubClass.php000064400000000140150364331700016326 0ustar00_baseClassInstance = new \Hamcrest\Core\SampleBaseClass('good'); $this->_subClassInstance = new \Hamcrest\Core\SampleSubClass('good'); } protected function createMatcher() { return \Hamcrest\Core\IsInstanceOf::anInstanceOf('stdClass'); } public function testEvaluatesToTrueIfArgumentIsInstanceOfASpecificClass() { assertThat($this->_baseClassInstance, anInstanceOf('Hamcrest\Core\SampleBaseClass')); assertThat($this->_subClassInstance, anInstanceOf('Hamcrest\Core\SampleSubClass')); assertThat(null, not(anInstanceOf('Hamcrest\Core\SampleBaseClass'))); assertThat(new \stdClass(), not(anInstanceOf('Hamcrest\Core\SampleBaseClass'))); } public function testEvaluatesToFalseIfArgumentIsNotAnObject() { assertThat(null, not(anInstanceOf('Hamcrest\Core\SampleBaseClass'))); assertThat(false, not(anInstanceOf('Hamcrest\Core\SampleBaseClass'))); assertThat(5, not(anInstanceOf('Hamcrest\Core\SampleBaseClass'))); assertThat('foo', not(anInstanceOf('Hamcrest\Core\SampleBaseClass'))); assertThat(array(1, 2, 3), not(anInstanceOf('Hamcrest\Core\SampleBaseClass'))); } public function testHasAReadableDescription() { $this->assertDescription('an instance of stdClass', anInstanceOf('stdClass')); } public function testDecribesActualClassInMismatchMessage() { $this->assertMismatchDescription( '[Hamcrest\Core\SampleBaseClass] ', anInstanceOf('Hamcrest\Core\SampleSubClass'), $this->_baseClassInstance ); } } hamcrest-php/tests/Hamcrest/Core/DescribedAsTest.php000064400000002057150364331700016466 0ustar00assertDescription('m1 description', $m1); $this->assertDescription('m2 description', $m2); } public function testAppendsValuesToDescription() { $m = describedAs('value 1 = %0, value 2 = %1', anything(), 33, 97); $this->assertDescription('value 1 = <33>, value 2 = <97>', $m); } public function testDelegatesMatchingToAnotherMatcher() { $m1 = describedAs('irrelevant', anything()); $m2 = describedAs('irrelevant', not(anything())); $this->assertTrue($m1->matches(new \stdClass())); $this->assertFalse($m2->matches('hi')); } } hamcrest-php/tests/Hamcrest/Core/IsNotTest.php000064400000001746150364331700015356 0ustar00assertMatches(not(equalTo('A')), 'B', 'should match'); $this->assertDoesNotMatch(not(equalTo('B')), 'B', 'should not match'); } public function testProvidesConvenientShortcutForNotEqualTo() { $this->assertMatches(not('A'), 'B', 'should match'); $this->assertMatches(not('B'), 'A', 'should match'); $this->assertDoesNotMatch(not('A'), 'A', 'should not match'); $this->assertDoesNotMatch(not('B'), 'B', 'should not match'); } public function testUsesDescriptionOfNegatedMatcherWithPrefix() { $this->assertDescription('not a value greater than <2>', not(greaterThan(2))); $this->assertDescription('not "A"', not('A')); } } hamcrest-php/tests/Hamcrest/Core/IsIdenticalTest.php000064400000001401150364331700016476 0ustar00assertDescription('"ARG"', identicalTo('ARG')); } public function testReturnsReadableDescriptionFromToStringWhenInitialisedWithNull() { $this->assertDescription('null', identicalTo(null)); } } hamcrest-php/tests/Hamcrest/Core/IsNullTest.php000064400000000744150364331700015525 0ustar00_instanceProperty); } protected function createMatcher() { return \Hamcrest\Core\Set::set('property_name'); } public function testEvaluatesToTrueIfArrayPropertyIsSet() { assertThat(array('foo' => 'bar'), set('foo')); } public function testNegatedEvaluatesToFalseIfArrayPropertyIsSet() { assertThat(array('foo' => 'bar'), not(notSet('foo'))); } public function testEvaluatesToTrueIfClassPropertyIsSet() { self::$_classProperty = 'bar'; assertThat('Hamcrest\Core\SetTest', set('_classProperty')); } public function testNegatedEvaluatesToFalseIfClassPropertyIsSet() { self::$_classProperty = 'bar'; assertThat('Hamcrest\Core\SetTest', not(notSet('_classProperty'))); } public function testEvaluatesToTrueIfObjectPropertyIsSet() { $this->_instanceProperty = 'bar'; assertThat($this, set('_instanceProperty')); } public function testNegatedEvaluatesToFalseIfObjectPropertyIsSet() { $this->_instanceProperty = 'bar'; assertThat($this, not(notSet('_instanceProperty'))); } public function testEvaluatesToFalseIfArrayPropertyIsNotSet() { assertThat(array('foo' => 'bar'), not(set('baz'))); } public function testNegatedEvaluatesToTrueIfArrayPropertyIsNotSet() { assertThat(array('foo' => 'bar'), notSet('baz')); } public function testEvaluatesToFalseIfClassPropertyIsNotSet() { assertThat('Hamcrest\Core\SetTest', not(set('_classProperty'))); } public function testNegatedEvaluatesToTrueIfClassPropertyIsNotSet() { assertThat('Hamcrest\Core\SetTest', notSet('_classProperty')); } public function testEvaluatesToFalseIfObjectPropertyIsNotSet() { assertThat($this, not(set('_instanceProperty'))); } public function testNegatedEvaluatesToTrueIfObjectPropertyIsNotSet() { assertThat($this, notSet('_instanceProperty')); } public function testHasAReadableDescription() { $this->assertDescription('set property foo', set('foo')); $this->assertDescription('unset property bar', notSet('bar')); } public function testDecribesPropertySettingInMismatchMessage() { $this->assertMismatchDescription( 'was not set', set('bar'), array('foo' => 'bar') ); $this->assertMismatchDescription( 'was "bar"', notSet('foo'), array('foo' => 'bar') ); self::$_classProperty = 'bar'; $this->assertMismatchDescription( 'was "bar"', notSet('_classProperty'), 'Hamcrest\Core\SetTest' ); $this->_instanceProperty = 'bar'; $this->assertMismatchDescription( 'was "bar"', notSet('_instanceProperty'), $this ); } } hamcrest-php/tests/Hamcrest/Core/IsSameTest.php000064400000001433150364331700015474 0ustar00assertDescription('sameInstance("ARG")', sameInstance('ARG')); } public function testReturnsReadableDescriptionFromToStringWhenInitialisedWithNull() { $this->assertDescription('sameInstance(null)', sameInstance(null)); } } hamcrest-php/tests/Hamcrest/Core/SampleBaseClass.php000064400000000347150364331700016460 0ustar00_arg = $arg; } public function __toString() { return $this->_arg; } } hamcrest-php/tests/Hamcrest/Core/IsTest.php000064400000002122150364331700014662 0ustar00assertMatches(is(equalTo(true)), true, 'should match'); $this->assertMatches(is(equalTo(false)), false, 'should match'); $this->assertDoesNotMatch(is(equalTo(true)), false, 'should not match'); $this->assertDoesNotMatch(is(equalTo(false)), true, 'should not match'); } public function testGeneratesIsPrefixInDescription() { $this->assertDescription('is ', is(equalTo(true))); } public function testProvidesConvenientShortcutForIsEqualTo() { $this->assertMatches(is('A'), 'A', 'should match'); $this->assertMatches(is('B'), 'B', 'should match'); $this->assertDoesNotMatch(is('A'), 'B', 'should not match'); $this->assertDoesNotMatch(is('B'), 'A', 'should not match'); $this->assertDescription('is "A"', is('A')); } } hamcrest-php/tests/Hamcrest/Core/AnyOfTest.php000064400000004637150364331700015340 0ustar00assertDescription( '("good" or "bad" or "ugly")', anyOf('good', 'bad', 'ugly') ); } public function testNoneOfEvaluatesToTheLogicalDisjunctionOfTwoOtherMatchers() { assertThat('good', not(noneOf('bad', 'good'))); assertThat('good', not(noneOf('good', 'good'))); assertThat('good', not(noneOf('good', 'bad'))); assertThat('good', noneOf('bad', startsWith('b'))); } public function testNoneOfEvaluatesToTheLogicalDisjunctionOfManyOtherMatchers() { assertThat('good', not(noneOf('bad', 'good', 'bad', 'bad', 'bad'))); assertThat('good', noneOf('bad', 'bad', 'bad', 'bad', 'bad')); } public function testNoneOfSupportsMixedTypes() { $combined = noneOf( equalTo(new \Hamcrest\Core\SampleBaseClass('good')), equalTo(new \Hamcrest\Core\SampleBaseClass('ugly')), equalTo(new \Hamcrest\Core\SampleSubClass('good')) ); assertThat(new \Hamcrest\Core\SampleSubClass('bad'), $combined); } public function testNoneOfHasAReadableDescription() { $this->assertDescription( 'not ("good" or "bad" or "ugly")', noneOf('good', 'bad', 'ugly') ); } } hamcrest-php/tests/Hamcrest/Core/CombinableMatcherTest.php000064400000003355150364331700017657 0ustar00_either_3_or_4 = \Hamcrest\Core\CombinableMatcher::either(equalTo(3))->orElse(equalTo(4)); $this->_not_3_and_not_4 = \Hamcrest\Core\CombinableMatcher::both(not(equalTo(3)))->andAlso(not(equalTo(4))); } protected function createMatcher() { return \Hamcrest\Core\CombinableMatcher::either(equalTo('irrelevant'))->orElse(equalTo('ignored')); } public function testBothAcceptsAndRejects() { assertThat(2, $this->_not_3_and_not_4); assertThat(3, not($this->_not_3_and_not_4)); } public function testAcceptsAndRejectsThreeAnds() { $tripleAnd = $this->_not_3_and_not_4->andAlso(equalTo(2)); assertThat(2, $tripleAnd); assertThat(3, not($tripleAnd)); } public function testBothDescribesItself() { $this->assertEquals('(not <3> and not <4>)', (string) $this->_not_3_and_not_4); $this->assertMismatchDescription('was <3>', $this->_not_3_and_not_4, 3); } public function testEitherAcceptsAndRejects() { assertThat(3, $this->_either_3_or_4); assertThat(6, not($this->_either_3_or_4)); } public function testAcceptsAndRejectsThreeOrs() { $orTriple = $this->_either_3_or_4->orElse(greaterThan(10)); assertThat(11, $orTriple); assertThat(9, not($orTriple)); } public function testEitherDescribesItself() { $this->assertEquals('(<3> or <4>)', (string) $this->_either_3_or_4); $this->assertMismatchDescription('was <6>', $this->_either_3_or_4, 6); } } hamcrest-php/tests/Hamcrest/Core/IsEqualTest.php000064400000005316150364331700015662 0ustar00_arg = $arg; } public function __toString() { return $this->_arg; } } class IsEqualTest extends \Hamcrest\AbstractMatcherTest { protected function createMatcher() { return \Hamcrest\Core\IsEqual::equalTo('irrelevant'); } public function testComparesObjectsUsingEqualityOperator() { assertThat("hi", equalTo("hi")); assertThat("bye", not(equalTo("hi"))); assertThat(1, equalTo(1)); assertThat(1, not(equalTo(2))); assertThat("2", equalTo(2)); } public function testCanCompareNullValues() { assertThat(null, equalTo(null)); assertThat(null, not(equalTo('hi'))); assertThat('hi', not(equalTo(null))); } public function testComparesTheElementsOfAnArray() { $s1 = array('a', 'b'); $s2 = array('a', 'b'); $s3 = array('c', 'd'); $s4 = array('a', 'b', 'c', 'd'); assertThat($s1, equalTo($s1)); assertThat($s2, equalTo($s1)); assertThat($s3, not(equalTo($s1))); assertThat($s4, not(equalTo($s1))); } public function testComparesTheElementsOfAnArrayOfPrimitiveTypes() { $i1 = array(1, 2); $i2 = array(1, 2); $i3 = array(3, 4); $i4 = array(1, 2, 3, 4); assertThat($i1, equalTo($i1)); assertThat($i2, equalTo($i1)); assertThat($i3, not(equalTo($i1))); assertThat($i4, not(equalTo($i1))); } public function testRecursivelyTestsElementsOfArrays() { $i1 = array(array(1, 2), array(3, 4)); $i2 = array(array(1, 2), array(3, 4)); $i3 = array(array(5, 6), array(7, 8)); $i4 = array(array(1, 2, 3, 4), array(3, 4)); assertThat($i1, equalTo($i1)); assertThat($i2, equalTo($i1)); assertThat($i3, not(equalTo($i1))); assertThat($i4, not(equalTo($i1))); } public function testIncludesTheResultOfCallingToStringOnItsArgumentInTheDescription() { $argumentDescription = 'ARGUMENT DESCRIPTION'; $argument = new \Hamcrest\Core\DummyToStringClass($argumentDescription); $this->assertDescription('<' . $argumentDescription . '>', equalTo($argument)); } public function testReturnsAnObviousDescriptionIfCreatedWithANestedMatcherByMistake() { $innerMatcher = equalTo('NestedMatcher'); $this->assertDescription('<' . (string) $innerMatcher . '>', equalTo($innerMatcher)); } public function testReturnsGoodDescriptionIfCreatedWithNullReference() { $this->assertDescription('null', equalTo(null)); } } hamcrest-php/tests/Hamcrest/Core/HasToStringTest.php000064400000004476150364331700016532 0ustar00assertMatches( hasToString(equalTo('php')), new \Hamcrest\Core\PhpForm(), 'correct __toString' ); $this->assertMatches( hasToString(equalTo('java')), new \Hamcrest\Core\JavaForm(), 'correct toString' ); } public function testPicksJavaOverPhpToString() { $this->assertMatches( hasToString(equalTo('java')), new \Hamcrest\Core\BothForms(), 'correct toString' ); } public function testDoesNotMatchWhenToStringDoesNotMatch() { $this->assertDoesNotMatch( hasToString(equalTo('mismatch')), new \Hamcrest\Core\PhpForm(), 'incorrect __toString' ); $this->assertDoesNotMatch( hasToString(equalTo('mismatch')), new \Hamcrest\Core\JavaForm(), 'incorrect toString' ); $this->assertDoesNotMatch( hasToString(equalTo('mismatch')), new \Hamcrest\Core\BothForms(), 'incorrect __toString' ); } public function testDoesNotMatchNull() { $this->assertDoesNotMatch( hasToString(equalTo('a')), null, 'should not match null' ); } public function testProvidesConvenientShortcutForTraversableWithSizeEqualTo() { $this->assertMatches( hasToString(equalTo('php')), new \Hamcrest\Core\PhpForm(), 'correct __toString' ); } public function testHasAReadableDescription() { $this->assertDescription( 'an object with toString() "php"', hasToString(equalTo('php')) ); } } hamcrest-php/tests/Hamcrest/Core/AllOfTest.php000064400000003033150364331700015306 0ustar00assertDescription( '("good" and "bad" and "ugly")', allOf('good', 'bad', 'ugly') ); } public function testMismatchDescriptionDescribesFirstFailingMatch() { $this->assertMismatchDescription( '"good" was "bad"', allOf('bad', 'good'), 'bad' ); } } hamcrest-php/tests/Hamcrest/Core/IsAnythingTest.php000064400000001254150364331700016371 0ustar00assertDescription('ANYTHING', anything()); } public function testCanOverrideDescription() { $description = 'description'; $this->assertDescription($description, anything($description)); } } hamcrest-php/tests/Hamcrest/Core/IsTypeOfTest.php000064400000002711150364331700016015 0ustar00assertDescription('a double', typeOf('double')); $this->assertDescription('an integer', typeOf('integer')); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', typeOf('boolean'), null); $this->assertMismatchDescription('was an integer <5>', typeOf('float'), 5); } } hamcrest-php/tests/Hamcrest/Core/IsCollectionContainingTest.php000064400000005106150364331700020715 0ustar00assertMatches( $itemMatcher, array('a', 'b', 'c'), "should match list that contains 'a'" ); } public function testDoesNotMatchCollectionThatDoesntContainAnElementMatchingTheGivenMatcher() { $matcher1 = hasItem(equalTo('a')); $this->assertDoesNotMatch( $matcher1, array('b', 'c'), "should not match list that doesn't contain 'a'" ); $matcher2 = hasItem(equalTo('a')); $this->assertDoesNotMatch( $matcher2, array(), 'should not match the empty list' ); } public function testDoesNotMatchNull() { $this->assertDoesNotMatch( hasItem(equalTo('a')), null, 'should not match null' ); } public function testHasAReadableDescription() { $this->assertDescription('a collection containing "a"', hasItem(equalTo('a'))); } public function testMatchesAllItemsInCollection() { $matcher1 = hasItems(equalTo('a'), equalTo('b'), equalTo('c')); $this->assertMatches( $matcher1, array('a', 'b', 'c'), 'should match list containing all items' ); $matcher2 = hasItems('a', 'b', 'c'); $this->assertMatches( $matcher2, array('a', 'b', 'c'), 'should match list containing all items (without matchers)' ); $matcher3 = hasItems(equalTo('a'), equalTo('b'), equalTo('c')); $this->assertMatches( $matcher3, array('c', 'b', 'a'), 'should match list containing all items in any order' ); $matcher4 = hasItems(equalTo('a'), equalTo('b'), equalTo('c')); $this->assertMatches( $matcher4, array('e', 'c', 'b', 'a', 'd'), 'should match list containing all items plus others' ); $matcher5 = hasItems(equalTo('a'), equalTo('b'), equalTo('c')); $this->assertDoesNotMatch( $matcher5, array('e', 'c', 'b', 'd'), // 'a' missing 'should not match list unless it contains all items' ); } } hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInOrderTest.php000064400000003031150364331700021344 0ustar00assertDescription('[<1>, <2>]', arrayContaining(array(1, 2))); } public function testMatchesItemsInOrder() { $this->assertMatches(arrayContaining(array(1, 2, 3)), array(1, 2, 3), 'in order'); $this->assertMatches(arrayContaining(array(1)), array(1), 'single'); } public function testAppliesMatchersInOrder() { $this->assertMatches( arrayContaining(array(1, 2, 3)), array(1, 2, 3), 'in order' ); $this->assertMatches(arrayContaining(array(1)), array(1), 'single'); } public function testMismatchesItemsInAnyOrder() { if (defined('HHVM_VERSION')) { $this->markTestSkipped('Broken on HHVM.'); } $matcher = arrayContaining(array(1, 2, 3)); $this->assertMismatchDescription('was null', $matcher, null); $this->assertMismatchDescription('No item matched: <1>', $matcher, array()); $this->assertMismatchDescription('No item matched: <2>', $matcher, array(1)); $this->assertMismatchDescription('item with key 0: was <4>', $matcher, array(4, 3, 2, 1)); $this->assertMismatchDescription('item with key 2: was <4>', $matcher, array(1, 2, 4)); } } hamcrest-php/tests/Hamcrest/Array/IsArrayWithSizeTest.php000064400000002203150364331700017536 0ustar00assertMatches(arrayWithSize(equalTo(3)), array(1, 2, 3), 'correct size'); $this->assertDoesNotMatch(arrayWithSize(equalTo(2)), array(1, 2, 3), 'incorrect size'); } public function testProvidesConvenientShortcutForArrayWithSizeEqualTo() { $this->assertMatches(arrayWithSize(3), array(1, 2, 3), 'correct size'); $this->assertDoesNotMatch(arrayWithSize(2), array(1, 2, 3), 'incorrect size'); } public function testEmptyArray() { $this->assertMatches(emptyArray(), array(), 'correct size'); $this->assertDoesNotMatch(emptyArray(), array(1), 'incorrect size'); } public function testHasAReadableDescription() { $this->assertDescription('an array with size <3>', arrayWithSize(equalTo(3))); $this->assertDescription('an empty array', emptyArray()); } } hamcrest-php/tests/Hamcrest/Array/IsArrayContainingTest.php000064400000002355150364331700020071 0ustar00assertMatches( hasItemInArray('a'), array('a', 'b', 'c'), "should matches array that contains 'a'" ); } public function testDoesNotMatchAnArrayThatDoesntContainAnElementMatchingTheGivenMatcher() { $this->assertDoesNotMatch( hasItemInArray('a'), array('b', 'c'), "should not matches array that doesn't contain 'a'" ); $this->assertDoesNotMatch( hasItemInArray('a'), array(), 'should not match empty array' ); } public function testDoesNotMatchNull() { $this->assertDoesNotMatch( hasItemInArray('a'), null, 'should not match null' ); } public function testHasAReadableDescription() { $this->assertDescription('an array containing "a"', hasItemInArray('a')); } } hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyTest.php000064400000003076150364331700020543 0ustar001); $this->assertMatches(hasKey('a'), $array, 'Matches single key'); } public function testMatchesArrayContainingKey() { $array = array('a'=>1, 'b'=>2, 'c'=>3); $this->assertMatches(hasKey('a'), $array, 'Matches a'); $this->assertMatches(hasKey('c'), $array, 'Matches c'); } public function testMatchesArrayContainingKeyWithIntegerKeys() { $array = array(1=>'A', 2=>'B'); assertThat($array, hasKey(1)); } public function testMatchesArrayContainingKeyWithNumberKeys() { $array = array(1=>'A', 2=>'B'); assertThat($array, hasKey(1)); // very ugly version! assertThat($array, IsArrayContainingKey::hasKeyInArray(2)); } public function testHasReadableDescription() { $this->assertDescription('array with key "a"', hasKey('a')); } public function testDoesNotMatchEmptyArray() { $this->assertMismatchDescription('array was []', hasKey('Foo'), array()); } public function testDoesNotMatchArrayMissingKey() { $array = array('a'=>1, 'b'=>2, 'c'=>3); $this->assertMismatchDescription('array was ["a" => <1>, "b" => <2>, "c" => <3>]', hasKey('d'), $array); } } hamcrest-php/tests/Hamcrest/Array/IsArrayTest.php000064400000004676150364331700016067 0ustar00assertMatches( anArray(array(equalTo('a'), equalTo('b'), equalTo('c'))), array('a', 'b', 'c'), 'should match array with matching elements' ); } public function testDoesNotMatchAnArrayWhenElementsDoNotMatch() { $this->assertDoesNotMatch( anArray(array(equalTo('a'), equalTo('b'))), array('b', 'c'), 'should not match array with different elements' ); } public function testDoesNotMatchAnArrayOfDifferentSize() { $this->assertDoesNotMatch( anArray(array(equalTo('a'), equalTo('b'))), array('a', 'b', 'c'), 'should not match larger array' ); $this->assertDoesNotMatch( anArray(array(equalTo('a'), equalTo('b'))), array('a'), 'should not match smaller array' ); } public function testDoesNotMatchNull() { $this->assertDoesNotMatch( anArray(array(equalTo('a'))), null, 'should not match null' ); } public function testHasAReadableDescription() { $this->assertDescription( '["a", "b"]', anArray(array(equalTo('a'), equalTo('b'))) ); } public function testHasAReadableMismatchDescriptionWhenKeysDontMatch() { $this->assertMismatchDescription( 'array keys were [<1>, <2>]', anArray(array(equalTo('a'), equalTo('b'))), array(1 => 'a', 2 => 'b') ); } public function testSupportsMatchesAssociativeArrays() { $this->assertMatches( anArray(array('x'=>equalTo('a'), 'y'=>equalTo('b'), 'z'=>equalTo('c'))), array('x'=>'a', 'y'=>'b', 'z'=>'c'), 'should match associative array with matching elements' ); } public function testDoesNotMatchAnAssociativeArrayWhenKeysDoNotMatch() { $this->assertDoesNotMatch( anArray(array('x'=>equalTo('a'), 'y'=>equalTo('b'))), array('x'=>'b', 'z'=>'c'), 'should not match array with different keys' ); } } hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyValuePairTest.php000064400000002112150364331700022342 0ustar001, 'b'=>2); $this->assertMatches(hasKeyValuePair(equalTo('a'), equalTo(1)), $array, 'matcherA'); $this->assertMatches(hasKeyValuePair(equalTo('b'), equalTo(2)), $array, 'matcherB'); $this->assertMismatchDescription( 'array was ["a" => <1>, "b" => <2>]', hasKeyValuePair(equalTo('c'), equalTo(3)), $array ); } public function testDoesNotMatchNull() { $this->assertMismatchDescription('was null', hasKeyValuePair(anything(), anything()), null); } public function testHasReadableDescription() { $this->assertDescription('array containing ["a" => <2>]', hasKeyValuePair(equalTo('a'), equalTo(2))); } } hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInAnyOrderTest.php000064400000003274150364331700022025 0ustar00assertDescription('[<1>, <2>] in any order', containsInAnyOrder(array(1, 2))); } public function testMatchesItemsInAnyOrder() { $this->assertMatches(containsInAnyOrder(array(1, 2, 3)), array(1, 2, 3), 'in order'); $this->assertMatches(containsInAnyOrder(array(1, 2, 3)), array(3, 2, 1), 'out of order'); $this->assertMatches(containsInAnyOrder(array(1)), array(1), 'single'); } public function testAppliesMatchersInAnyOrder() { $this->assertMatches( containsInAnyOrder(array(1, 2, 3)), array(1, 2, 3), 'in order' ); $this->assertMatches( containsInAnyOrder(array(1, 2, 3)), array(3, 2, 1), 'out of order' ); $this->assertMatches( containsInAnyOrder(array(1)), array(1), 'single' ); } public function testMismatchesItemsInAnyOrder() { $matcher = containsInAnyOrder(array(1, 2, 3)); $this->assertMismatchDescription('was null', $matcher, null); $this->assertMismatchDescription('No item matches: <1>, <2>, <3> in []', $matcher, array()); $this->assertMismatchDescription('No item matches: <2>, <3> in [<1>]', $matcher, array(1)); $this->assertMismatchDescription('Not matched: <4>', $matcher, array(4, 3, 2, 1)); } } hamcrest-php/tests/Hamcrest/InvokedMatcherTest.php000064400000001143150364331700016324 0ustar00matchAgainst = $matchAgainst; } public function matches($item) { return $item == $this->matchAgainst; } } class InvokedMatcherTest extends TestCase { public function testInvokedMatchersCallMatches() { $sampleMatcher = new SampleInvokeMatcher('foo'); $this->assertTrue($sampleMatcher('foo')); $this->assertFalse($sampleMatcher('bar')); } } hamcrest-php/tests/Hamcrest/Number/IsCloseToTest.php000064400000001441150364331700016516 0ustar00assertTrue($p->matches(1.0)); $this->assertTrue($p->matches(0.5)); $this->assertTrue($p->matches(1.5)); $this->assertDoesNotMatch($p, 2.0, 'too large'); $this->assertMismatchDescription('<2F> differed by <0.5F>', $p, 2.0); $this->assertDoesNotMatch($p, 0.0, 'number too small'); $this->assertMismatchDescription('<0F> differed by <0.5F>', $p, 0.0); } } hamcrest-php/tests/Hamcrest/Number/OrderingComparisonTest.php000064400000001750150364331700020461 0ustar00assertDescription('a boolean', booleanValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', booleanValue(), null); $this->assertMismatchDescription('was a string "foo"', booleanValue(), 'foo'); } } hamcrest-php/tests/Hamcrest/Type/IsStringTest.php000064400000001657150364331700016116 0ustar00assertDescription('a string', stringValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', stringValue(), null); $this->assertMismatchDescription('was a double <5.2F>', stringValue(), 5.2); } } hamcrest-php/tests/Hamcrest/Type/IsResourceTest.php000064400000001632150364331700016430 0ustar00assertDescription('a resource', resourceValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', resourceValue(), null); $this->assertMismatchDescription('was a string "foo"', resourceValue(), 'foo'); } } hamcrest-php/tests/Hamcrest/Type/IsNumericTest.php000064400000003470150364331700016245 0ustar00assertDescription('a number', numericValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', numericValue(), null); $this->assertMismatchDescription('was a string "foo"', numericValue(), 'foo'); } } hamcrest-php/tests/Hamcrest/Type/IsDoubleTest.php000064400000001666150364331700016062 0ustar00assertDescription('a double', doubleValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', doubleValue(), null); $this->assertMismatchDescription('was a string "foo"', doubleValue(), 'foo'); } } hamcrest-php/tests/Hamcrest/Type/IsArrayTest.php000064400000001651150364331700015720 0ustar00assertDescription('an array', arrayValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', arrayValue(), null); $this->assertMismatchDescription('was a string "foo"', arrayValue(), 'foo'); } } hamcrest-php/tests/Hamcrest/Type/IsIntegerTest.php000064400000001731150364331700016236 0ustar00assertDescription('an integer', integerValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', integerValue(), null); $this->assertMismatchDescription('was a string "foo"', integerValue(), 'foo'); } } hamcrest-php/tests/Hamcrest/Type/IsCallableTest.php000064400000005377150364331700016352 0ustar00=')) { $this->markTestSkipped('Closures require php 5.3'); } eval('assertThat(function () {}, callableValue());'); } public function testEvaluatesToTrueIfArgumentImplementsInvoke() { if (!version_compare(PHP_VERSION, '5.3', '>=')) { $this->markTestSkipped('Magic method __invoke() requires php 5.3'); } assertThat($this, callableValue()); } public function testEvaluatesToFalseIfArgumentIsInvalidFunctionName() { if (function_exists('not_a_Hamcrest_function')) { $this->markTestSkipped('Function "not_a_Hamcrest_function" must not exist'); } assertThat('not_a_Hamcrest_function', not(callableValue())); } public function testEvaluatesToFalseIfArgumentIsInvalidStaticMethodCallback() { assertThat( array('Hamcrest\Type\IsCallableTest', 'noMethod'), not(callableValue()) ); } public function testEvaluatesToFalseIfArgumentIsInvalidInstanceMethodCallback() { assertThat(array($this, 'noMethod'), not(callableValue())); } public function testEvaluatesToFalseIfArgumentDoesntImplementInvoke() { assertThat(new \stdClass(), not(callableValue())); } public function testEvaluatesToFalseIfArgumentDoesntMatchType() { assertThat(false, not(callableValue())); assertThat(5.2, not(callableValue())); } public function testHasAReadableDescription() { $this->assertDescription('a callable', callableValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription( 'was a string "invalid-function"', callableValue(), 'invalid-function' ); } } hamcrest-php/tests/Hamcrest/Type/IsObjectTest.php000064400000001611150364331700016044 0ustar00assertDescription('an object', objectValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', objectValue(), null); $this->assertMismatchDescription('was a string "foo"', objectValue(), 'foo'); } } hamcrest-php/tests/Hamcrest/Type/IsScalarTest.php000064400000002162150364331700016045 0ustar00assertDescription('a scalar', scalarValue()); } public function testDecribesActualTypeInMismatchMessage() { $this->assertMismatchDescription('was null', scalarValue(), null); $this->assertMismatchDescription('was an array ["foo"]', scalarValue(), array('foo')); } } hamcrest-php/tests/Hamcrest/Collection/IsTraversableWithSizeTest.php000064400000002532150364331700021754 0ustar00assertMatches( traversableWithSize(equalTo(3)), new \ArrayObject(array(1, 2, 3)), 'correct size' ); } public function testDoesNotMatchWhenSizeIsIncorrect() { $this->assertDoesNotMatch( traversableWithSize(equalTo(2)), new \ArrayObject(array(1, 2, 3)), 'incorrect size' ); } public function testDoesNotMatchNull() { $this->assertDoesNotMatch( traversableWithSize(3), null, 'should not match null' ); } public function testProvidesConvenientShortcutForTraversableWithSizeEqualTo() { $this->assertMatches( traversableWithSize(3), new \ArrayObject(array(1, 2, 3)), 'correct size' ); } public function testHasAReadableDescription() { $this->assertDescription( 'a traversable with size <3>', traversableWithSize(equalTo(3)) ); } } hamcrest-php/tests/Hamcrest/Collection/IsEmptyTraversableTest.php000064400000003513150364331700021304 0ustar00assertMatches( emptyTraversable(), new \ArrayObject(array()), 'an empty traversable' ); } public function testEmptyMatcherDoesNotMatchWhenNotEmpty() { $this->assertDoesNotMatch( emptyTraversable(), new \ArrayObject(array(1, 2, 3)), 'a non-empty traversable' ); } public function testEmptyMatcherDoesNotMatchNull() { $this->assertDoesNotMatch( emptyTraversable(), null, 'should not match null' ); } public function testEmptyMatcherHasAReadableDescription() { $this->assertDescription('an empty traversable', emptyTraversable()); } public function testNonEmptyDoesNotMatchNull() { $this->assertDoesNotMatch( nonEmptyTraversable(), null, 'should not match null' ); } public function testNonEmptyDoesNotMatchWhenEmpty() { $this->assertDoesNotMatch( nonEmptyTraversable(), new \ArrayObject(array()), 'an empty traversable' ); } public function testNonEmptyMatchesWhenNotEmpty() { $this->assertMatches( nonEmptyTraversable(), new \ArrayObject(array(1, 2, 3)), 'a non-empty traversable' ); } public function testNonEmptyNonEmptyMatcherHasAReadableDescription() { $this->assertDescription('a non-empty traversable', nonEmptyTraversable()); } } hamcrest-php/tests/Hamcrest/StringDescriptionTest.php000064400000012526150364331700017102 0ustar00_text = $text; } public function describeTo(\Hamcrest\Description $description) { $description->appendText($this->_text); } } class StringDescriptionTest extends TestCase { private $_description; protected function setUp() { $this->_description = new \Hamcrest\StringDescription(); } public function testAppendTextAppendsTextInformation() { $this->_description->appendText('foo')->appendText('bar'); $this->assertEquals('foobar', (string) $this->_description); } public function testAppendValueCanAppendTextTypes() { $this->_description->appendValue('foo'); $this->assertEquals('"foo"', (string) $this->_description); } public function testSpecialCharactersAreEscapedForStringTypes() { $this->_description->appendValue("foo\\bar\"zip\r\n"); $this->assertEquals('"foo\\bar\\"zip\r\n"', (string) $this->_description); } public function testIntegerValuesCanBeAppended() { $this->_description->appendValue(42); $this->assertEquals('<42>', (string) $this->_description); } public function testFloatValuesCanBeAppended() { $this->_description->appendValue(42.78); $this->assertEquals('<42.78F>', (string) $this->_description); } public function testNullValuesCanBeAppended() { $this->_description->appendValue(null); $this->assertEquals('null', (string) $this->_description); } public function testArraysCanBeAppended() { $this->_description->appendValue(array('foo', 42.78)); $this->assertEquals('["foo", <42.78F>]', (string) $this->_description); } public function testObjectsCanBeAppended() { $this->_description->appendValue(new \stdClass()); $this->assertEquals('', (string) $this->_description); } public function testBooleanValuesCanBeAppended() { $this->_description->appendValue(false); $this->assertEquals('', (string) $this->_description); } public function testListsOfvaluesCanBeAppended() { $this->_description->appendValue(array('foo', 42.78)); $this->assertEquals('["foo", <42.78F>]', (string) $this->_description); } public function testIterableOfvaluesCanBeAppended() { $items = new \ArrayObject(array('foo', 42.78)); $this->_description->appendValue($items); $this->assertEquals('["foo", <42.78F>]', (string) $this->_description); } public function testIteratorOfvaluesCanBeAppended() { $items = new \ArrayObject(array('foo', 42.78)); $this->_description->appendValue($items->getIterator()); $this->assertEquals('["foo", <42.78F>]', (string) $this->_description); } public function testListsOfvaluesCanBeAppendedManually() { $this->_description->appendValueList('@start@', '@sep@ ', '@end@', array('foo', 42.78)); $this->assertEquals('@start@"foo"@sep@ <42.78F>@end@', (string) $this->_description); } public function testIterableOfvaluesCanBeAppendedManually() { $items = new \ArrayObject(array('foo', 42.78)); $this->_description->appendValueList('@start@', '@sep@ ', '@end@', $items); $this->assertEquals('@start@"foo"@sep@ <42.78F>@end@', (string) $this->_description); } public function testIteratorOfvaluesCanBeAppendedManually() { $items = new \ArrayObject(array('foo', 42.78)); $this->_description->appendValueList('@start@', '@sep@ ', '@end@', $items->getIterator()); $this->assertEquals('@start@"foo"@sep@ <42.78F>@end@', (string) $this->_description); } public function testSelfDescribingObjectsCanBeAppended() { $this->_description ->appendDescriptionOf(new \Hamcrest\SampleSelfDescriber('foo')) ->appendDescriptionOf(new \Hamcrest\SampleSelfDescriber('bar')) ; $this->assertEquals('foobar', (string) $this->_description); } public function testSelfDescribingObjectsCanBeAppendedAsLists() { $this->_description->appendList('@start@', '@sep@ ', '@end@', array( new \Hamcrest\SampleSelfDescriber('foo'), new \Hamcrest\SampleSelfDescriber('bar') )); $this->assertEquals('@start@foo@sep@ bar@end@', (string) $this->_description); } public function testSelfDescribingObjectsCanBeAppendedAsIteratedLists() { $items = new \ArrayObject(array( new \Hamcrest\SampleSelfDescriber('foo'), new \Hamcrest\SampleSelfDescriber('bar') )); $this->_description->appendList('@start@', '@sep@ ', '@end@', $items); $this->assertEquals('@start@foo@sep@ bar@end@', (string) $this->_description); } public function testSelfDescribingObjectsCanBeAppendedAsIterators() { $items = new \ArrayObject(array( new \Hamcrest\SampleSelfDescriber('foo'), new \Hamcrest\SampleSelfDescriber('bar') )); $this->_description->appendList('@start@', '@sep@ ', '@end@', $items->getIterator()); $this->assertEquals('@start@foo@sep@ bar@end@', (string) $this->_description); } } hamcrest-php/tests/Hamcrest/FeatureMatcherTest.php000064400000003175150364331700016327 0ustar00_result = $result; } public function getResult() { return $this->_result; } } /* Test-specific subclass only */ class ResultMatcher extends \Hamcrest\FeatureMatcher { public function __construct() { parent::__construct(self::TYPE_ANY, null, equalTo('bar'), 'Thingy with result', 'result'); } public function featureValueOf($actual) { if ($actual instanceof \Hamcrest\Thingy) { return $actual->getResult(); } } } class FeatureMatcherTest extends \Hamcrest\AbstractMatcherTest { private $_resultMatcher; protected function setUp() { $this->_resultMatcher = $this->_resultMatcher(); } protected function createMatcher() { return $this->_resultMatcher(); } public function testMatchesPartOfAnObject() { $this->assertMatches($this->_resultMatcher, new \Hamcrest\Thingy('bar'), 'feature'); $this->assertDescription('Thingy with result "bar"', $this->_resultMatcher); } public function testMismatchesPartOfAnObject() { $this->assertMismatchDescription( 'result was "foo"', $this->_resultMatcher, new \Hamcrest\Thingy('foo') ); } public function testDoesNotGenerateNoticesForNull() { $this->assertMismatchDescription('result was null', $this->_resultMatcher, null); } // -- Creation Methods private function _resultMatcher() { return new \Hamcrest\ResultMatcher(); } } hamcrest-php/generator/FactoryMethod.php000064400000013014150364331700014407 0ustar00class = $class; $this->reflector = $reflector; $this->extractCommentWithoutLeadingShashesAndStars(); $this->extractFactoryNamesFromComment(); $this->extractParameters(); } public function extractCommentWithoutLeadingShashesAndStars() { $this->comment = explode("\n", $this->reflector->getDocComment()); foreach ($this->comment as &$line) { $line = preg_replace('#^\s*(/\\*+|\\*+/|\\*)\s?#', '', $line); } $this->trimLeadingBlankLinesFromComment(); $this->trimTrailingBlankLinesFromComment(); } public function trimLeadingBlankLinesFromComment() { while (count($this->comment) > 0) { $line = array_shift($this->comment); if (trim($line) != '') { array_unshift($this->comment, $line); break; } } } public function trimTrailingBlankLinesFromComment() { while (count($this->comment) > 0) { $line = array_pop($this->comment); if (trim($line) != '') { array_push($this->comment, $line); break; } } } public function extractFactoryNamesFromComment() { $this->calls = array(); for ($i = 0; $i < count($this->comment); $i++) { if ($this->extractFactoryNamesFromLine($this->comment[$i])) { unset($this->comment[$i]); } } $this->trimTrailingBlankLinesFromComment(); } public function extractFactoryNamesFromLine($line) { if (preg_match('/^\s*@factory(\s+(.+))?$/', $line, $match)) { $this->createCalls( $this->extractFactoryNamesFromAnnotation( isset($match[2]) ? trim($match[2]) : null ) ); return true; } return false; } public function extractFactoryNamesFromAnnotation($value) { $primaryName = $this->reflector->getName(); if (empty($value)) { return array($primaryName); } preg_match_all('/(\.{3}|-|[a-zA-Z_][a-zA-Z_0-9]*)/', $value, $match); $names = $match[0]; if (in_array('...', $names)) { $this->isVarArgs = true; } if (!in_array('-', $names) && !in_array($primaryName, $names)) { array_unshift($names, $primaryName); } return $names; } public function createCalls(array $names) { $names = array_unique($names); foreach ($names as $name) { if ($name != '-' && $name != '...') { $this->calls[] = new FactoryCall($this, $name); } } } public function extractParameters() { $this->parameters = array(); if (!$this->isVarArgs) { foreach ($this->reflector->getParameters() as $parameter) { $this->parameters[] = new FactoryParameter($this, $parameter); } } } public function getParameterDeclarations() { if ($this->isVarArgs || !$this->hasParameters()) { return ''; } $params = array(); foreach ($this->parameters as /** @var $parameter FactoryParameter */ $parameter) { $params[] = $parameter->getDeclaration(); } return implode(', ', $params); } public function getParameterInvocations() { if ($this->isVarArgs) { return ''; } $params = array(); foreach ($this->parameters as $parameter) { $params[] = $parameter->getInvocation(); } return implode(', ', $params); } public function getClass() { return $this->class; } public function getClassName() { return $this->class->getName(); } public function getName() { return $this->reflector->name; } public function isFactory() { return count($this->calls) > 0; } public function getCalls() { return $this->calls; } public function acceptsVariableArguments() { return $this->isVarArgs; } public function hasParameters() { return !empty($this->parameters); } public function getParameters() { return $this->parameters; } public function getFullName() { return $this->getClassName() . '::' . $this->getName(); } public function getCommentText() { return implode("\n", $this->comment); } public function getComment($indent = '') { $comment = $indent . '/**'; foreach ($this->comment as $line) { $comment .= "\n" . rtrim($indent . ' * ' . $line); } $comment .= "\n" . $indent . ' */'; return $comment; } } hamcrest-php/generator/FactoryFile.php000064400000005720150364331700014053 0ustar00file = $file; $this->indent = $indent; } abstract public function addCall(FactoryCall $call); abstract public function build(); public function addFileHeader() { $this->code = ''; $this->addPart('file_header'); } public function addPart($name) { $this->addCode($this->readPart($name)); } public function addCode($code) { $this->code .= $code; } public function readPart($name) { return file_get_contents(__DIR__ . "/parts/$name.txt"); } public function generateFactoryCall(FactoryCall $call) { $method = $call->getMethod(); $code = $method->getComment($this->indent) . "\n"; $code .= $this->generateDeclaration($call->getName(), $method); $code .= $this->generateCall($method); $code .= $this->generateClosing(); return $code; } public function generateDeclaration($name, FactoryMethod $method) { $code = $this->indent . $this->getDeclarationModifiers() . 'function ' . $name . '(' . $this->generateDeclarationArguments($method) . ')' . "\n" . $this->indent . '{' . "\n"; return $code; } public function getDeclarationModifiers() { return ''; } public function generateDeclarationArguments(FactoryMethod $method) { if ($method->acceptsVariableArguments()) { return '/* args... */'; } else { return $method->getParameterDeclarations(); } } public function generateImport(FactoryMethod $method) { return $this->indent . self::INDENT . "require_once '" . $method->getClass()->getFile() . "';" . "\n"; } public function generateCall(FactoryMethod $method) { $code = ''; if ($method->acceptsVariableArguments()) { $code .= $this->indent . self::INDENT . '$args = func_get_args();' . "\n"; } $code .= $this->indent . self::INDENT . 'return '; if ($method->acceptsVariableArguments()) { $code .= 'call_user_func_array(array(\'' . '\\' . $method->getClassName() . '\', \'' . $method->getName() . '\'), $args);' . "\n"; } else { $code .= '\\' . $method->getClassName() . '::' . $method->getName() . '(' . $method->getParameterInvocations() . ');' . "\n"; } return $code; } public function generateClosing() { return $this->indent . '}' . "\n"; } public function write() { file_put_contents($this->file, $this->code); } } hamcrest-php/generator/parts/functions_footer.txt000064400000000000150364331700016375 0ustar00hamcrest-php/generator/parts/file_header.txt000064400000000170150364331700015246 0ustar00 * //With an identifier * assertThat("assertion identifier", $apple->flavour(), equalTo("tasty")); * //Without an identifier * assertThat($apple->flavour(), equalTo("tasty")); * //Evaluating a boolean expression * assertThat("some error", $a > $b); * */ function assertThat() { $args = func_get_args(); call_user_func_array( array('Hamcrest\MatcherAssert', 'assertThat'), $args ); } } hamcrest-php/generator/parts/matchers_header.txt000064400000000126150364331700016136 0ustar00 /** * A series of static factories for all hamcrest matchers. */ class Matchers { hamcrest-php/generator/parts/matchers_imports.txt000064400000000024150364331700016400 0ustar00 namespace Hamcrest;hamcrest-php/generator/parts/matchers_footer.txt000064400000000002150364331700016175 0ustar00} hamcrest-php/generator/GlobalFunctionFile.php000064400000001642150364331700015351 0ustar00functions = ''; } public function addCall(FactoryCall $call) { $this->functions .= "\n" . $this->generateFactoryCall($call); } public function build() { $this->addFileHeader(); $this->addPart('functions_imports'); $this->addPart('functions_header'); $this->addCode($this->functions); $this->addPart('functions_footer'); } public function generateFactoryCall(FactoryCall $call) { $code = "if (!function_exists('{$call->getName()}')) {\n"; $code.= parent::generateFactoryCall($call); $code.= "}\n"; return $code; } } hamcrest-php/generator/run.php000064400000002073150364331700012446 0ustar00addFactoryFile(new StaticMethodFile(STATIC_MATCHERS_FILE)); $generator->addFactoryFile(new GlobalFunctionFile(GLOBAL_FUNCTIONS_FILE)); $generator->generate(); $generator->write(); hamcrest-php/generator/FactoryClass.php000064400000002552150364331700014241 0ustar00file = $file; $this->reflector = $class; $this->extractFactoryMethods(); } public function extractFactoryMethods() { $this->methods = array(); foreach ($this->getPublicStaticMethods() as $method) { if ($method->isFactory()) { $this->methods[] = $method; } } } public function getPublicStaticMethods() { $methods = array(); foreach ($this->reflector->getMethods(ReflectionMethod::IS_STATIC) as $method) { if ($method->isPublic() && $method->getDeclaringClass() == $this->reflector) { $methods[] = new FactoryMethod($this, $method); } } return $methods; } public function getFile() { return $this->file; } public function getName() { return $this->reflector->name; } public function isFactory() { return !empty($this->methods); } public function getMethods() { return $this->methods; } } hamcrest-php/generator/FactoryGenerator.php000064400000005664150364331700015131 0ustar00path = $path; $this->factoryFiles = array(); } public function addFactoryFile(FactoryFile $factoryFile) { $this->factoryFiles[] = $factoryFile; } public function generate() { $classes = $this->getClassesWithFactoryMethods(); foreach ($classes as $class) { foreach ($class->getMethods() as $method) { foreach ($method->getCalls() as $call) { foreach ($this->factoryFiles as $file) { $file->addCall($call); } } } } } public function write() { foreach ($this->factoryFiles as $file) { $file->build(); $file->write(); } } public function getClassesWithFactoryMethods() { $classes = array(); $files = $this->getSortedFiles(); foreach ($files as $file) { $class = $this->getFactoryClass($file); if ($class !== null) { $classes[] = $class; } } return $classes; } public function getSortedFiles() { $iter = $this->getFileIterator(); $files = array(); foreach ($iter as $file) { $files[] = $file; } sort($files, SORT_STRING); return $files; } private function getFileIterator() { $factoryClass = class_exists('File_Iterator_Factory') ? 'File_Iterator_Factory' : 'SebastianBergmann\FileIterator\Factory'; $factory = new $factoryClass(); return $factory->getFileIterator($this->path, '.php'); } public function getFactoryClass($file) { $name = $this->getFactoryClassName($file); if ($name !== null) { require_once $file; if (class_exists($name)) { $class = new FactoryClass(substr($file, strpos($file, 'Hamcrest/')), new ReflectionClass($name)); if ($class->isFactory()) { return $class; } } } return null; } public function getFactoryClassName($file) { $content = file_get_contents($file); if (preg_match('/namespace\s+(.+);/', $content, $namespace) && preg_match('/\n\s*class\s+(\w+)\s+extends\b/', $content, $className) && preg_match('/@factory\b/', $content) ) { return $namespace[1] . '\\' . $className[1]; } return null; } } hamcrest-php/generator/FactoryParameter.php000064400000006723150364331700015120 0ustar00method = $method; $this->reflector = $reflector; } /** * Compute the declaration code. * * @return string */ public function getDeclaration() { $code = $this->getTypeCode() . $this->getInvocation(); if ($this->reflector->isOptional()) { $default = $this->reflector->getDefaultValue(); if (is_null($default)) { $default = 'null'; } elseif (is_bool($default)) { $default = $default ? 'true' : 'false'; } elseif (is_string($default)) { $default = "'" . $default . "'"; } elseif (is_numeric($default)) { $default = strval($default); } elseif (is_array($default)) { $default = 'array()'; } else { echo 'Warning: unknown default type for ' . $this->getMethod()->getFullName() . "\n"; var_dump($default); $default = 'null'; } $code .= ' = ' . $default; } return $code; } /** * Compute the type code for the paramater. * * @return string */ private function getTypeCode() { // Handle PHP 5 separately if (PHP_VERSION_ID < 70000) { if ($this->reflector->isArray()) { return 'array'; } $class = $this->reflector->getClass(); return $class ? sprintf('\\%s ', $class->getName()) : ''; } if (!$this->reflector->hasType()) { return ''; } $type = $this->reflector->getType(); $name = self::getQualifiedName($type); // PHP 7.1+ supports nullable types via a leading question mark return (PHP_VERSION_ID >= 70100 && $type->allowsNull()) ? sprintf('?%s ', $name) : sprintf('%s ', $name); } /** * Compute qualified name for the given type. * * This function knows how to prefix class names with a leading slash and * also how to handle PHP 8's union types. * * @param ReflectionType $type * * @return string */ private static function getQualifiedName(ReflectionType $type) { // PHP 8 union types can be recursively processed if ($type instanceof ReflectionUnionType) { return implode('|', array_map(function (ReflectionType $type) { // The "self::" call within a Closure is fine here because this // code will only ever be executed on PHP 7.0+ return self::getQualifiedName($type); }, $type->getTypes())); } // PHP 7.0 doesn't have named types, but 7.1+ does $name = $type instanceof ReflectionNamedType ? $type->getName() : (string) $type; return $type->isBuiltin() ? $name : sprintf('\\%s', $name); } /** * Compute the invocation code. * * @return string */ public function getInvocation() { return sprintf('$%s', $this->reflector->getName()); } /** * Compute the method name. * * @return string */ public function getMethod() { return $this->method; } } hamcrest-php/generator/FactoryCall.php000064400000001143150364331700014042 0ustar00method = $method; $this->name = $name; } public function getMethod() { return $this->method; } public function getName() { return $this->name; } } hamcrest-php/generator/StaticMethodFile.php000064400000001405150364331700015030 0ustar00methods = ''; } public function addCall(FactoryCall $call) { $this->methods .= PHP_EOL . $this->generateFactoryCall($call); } public function getDeclarationModifiers() { return 'public static '; } public function build() { $this->addFileHeader(); $this->addPart('matchers_imports'); $this->addPart('matchers_header'); $this->addCode($this->methods); $this->addPart('matchers_footer'); } } hamcrest-php/LICENSE.txt000064400000002712150364331700010766 0ustar00BSD License Copyright (c) 2000-2014, www.hamcrest.org All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of Hamcrest nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. hamcrest-php/.gush.yml000064400000000270150364331700010707 0ustar00adapter: github issue_tracker: github meta-header: "Copyright (c) 2009-2015 hamcrest.org" table-pr: fixed_tickets: ['Fixed Tickets', ''] license: ['License', MIT] base: master hamcrest-php/README.md000064400000025255150364331700010431 0ustar00This is the PHP port of Hamcrest Matchers ========================================= [![Build Status](https://travis-ci.org/hamcrest/hamcrest-php.png?branch=master)](https://travis-ci.org/hamcrest/hamcrest-php) Hamcrest is a matching library originally written for Java, but subsequently ported to many other languages. hamcrest-php is the official PHP port of Hamcrest and essentially follows a literal translation of the original Java API for Hamcrest, with a few Exceptions, mostly down to PHP language barriers: 1. `instanceOf($theClass)` is actually `anInstanceOf($theClass)` 2. `both(containsString('a'))->and(containsString('b'))` is actually `both(containsString('a'))->andAlso(containsString('b'))` 3. `either(containsString('a'))->or(containsString('b'))` is actually `either(containsString('a'))->orElse(containsString('b'))` 4. Unless it would be non-semantic for a matcher to do so, hamcrest-php allows dynamic typing for it's input, in "the PHP way". Exception are where semantics surrounding the type itself would suggest otherwise, such as stringContains() and greaterThan(). 5. Several official matchers have not been ported because they don't make sense or don't apply in PHP: - `typeCompatibleWith($theClass)` - `eventFrom($source)` - `hasProperty($name)` ** - `samePropertyValuesAs($obj)` ** 6. When most of the collections matchers are finally ported, PHP-specific aliases will probably be created due to a difference in naming conventions between Java's Arrays, Collections, Sets and Maps compared with PHP's Arrays. --- ** [Unless we consider POPO's (Plain Old PHP Objects) akin to JavaBeans] - The POPO thing is a joke. Java devs coin the term POJO's (Plain Old Java Objects). Usage ----- Hamcrest matchers are easy to use as: ```php Hamcrest_MatcherAssert::assertThat('a', Hamcrest_Matchers::equalToIgnoringCase('A')); ``` Alternatively, you can use the global proxy-functions: ```php $result = true; // with an identifier assertThat("result should be true", $result, equalTo(true)); // without an identifier assertThat($result, equalTo(true)); // evaluate a boolean expression assertThat($result === true); // with syntactic sugar is() assertThat(true, is(true)); ``` :warning: **NOTE:** the global proxy-functions aren't autoloaded by default, so you will need to load them first: ```php \Hamcrest\Util::registerGlobalFunctions(); ``` For brevity, all of the examples below use the proxy-functions. Documentation ------------- A tutorial can be found on the [Hamcrest site](https://code.google.com/archive/p/hamcrest/wikis/TutorialPHP.wiki). Available Matchers ------------------ * [Array](../master/README.md#array) * [Collection](../master/README.md#collection) * [Object](../master/README.md#object) * [Numbers](../master/README.md#numbers) * [Type checking](../master/README.md#type-checking) * [XML](../master/README.md#xml) ### Array * `anArray` - evaluates an array ```php assertThat([], anArray()); ``` * `hasItemInArray` - check if item exists in array ```php $list = range(2, 7, 2); $item = 4; assertThat($list, hasItemInArray($item)); ``` * `hasValue` - alias of hasItemInArray * `arrayContainingInAnyOrder` - check if array contains elements in any order ```php assertThat([2, 4, 6], arrayContainingInAnyOrder([6, 4, 2])); assertThat([2, 4, 6], arrayContainingInAnyOrder([4, 2, 6])); ``` * `containsInAnyOrder` - alias of arrayContainingInAnyOrder * `arrayContaining` - An array with elements that match the given matchers in the same order. ```php assertThat([2, 4, 6], arrayContaining([2, 4, 6])); assertthat([2, 4, 6], not(arrayContaining([6, 4, 2]))); ``` * `contains` - check array in same order ```php assertThat([2, 4, 6], contains([2, 4, 6])); ``` * `hasKeyInArray` - check if array has given key ```php assertThat(['name'=> 'foobar'], hasKeyInArray('name')); ``` * `hasKey` - alias of hasKeyInArray * `hasKeyValuePair` - check if arary has given key, value pair ```php assertThat(['name'=> 'foobar'], hasKeyValuePair('name', 'foobar')); ``` * `hasEntry` - same as hasKeyValuePair * `arrayWithSize` - check array has given size ```php assertthat([2, 4, 6], arrayWithSize(3)); ``` * `emptyArray` - check if array is emtpy ```php assertThat([], emptyArray()); ``` * `nonEmptyArray` ```php assertThat([1], nonEmptyArray()); ``` ### Collection * `emptyTraversable` - check if traversable is empty ```php $empty_it = new EmptyIterator; assertThat($empty_it, emptyTraversable()); ``` * `nonEmptyTraversable` - check if traversable isn't empty ```php $non_empty_it = new ArrayIterator(range(1, 10)); assertThat($non_empty_it, nonEmptyTraversable()); a ``` * `traversableWithSize` ```php $non_empty_it = new ArrayIterator(range(1, 10)); assertThat($non_empty_it, traversableWithSize(count(range(1, 10)))); ` ``` ### Core * `allOf` - Evaluates to true only if ALL of the passed in matchers evaluate to true. ```php assertThat([2,4,6], allOf(hasValue(2), arrayWithSize(3))); ``` * `anyOf` - Evaluates to true if ANY of the passed in matchers evaluate to true. ```php assertThat([2, 4, 6], anyOf(hasValue(8), hasValue(2))); ``` * `noneOf` - Evaluates to false if ANY of the passed in matchers evaluate to true. ```php assertThat([2, 4, 6], noneOf(hasValue(1), hasValue(3))); ``` * `both` + `andAlso` - This is useful for fluently combining matchers that must both pass. ```php assertThat([2, 4, 6], both(hasValue(2))->andAlso(hasValue(4))); ``` * `either` + `orElse` - This is useful for fluently combining matchers where either may pass, ```php assertThat([2, 4, 6], either(hasValue(2))->orElse(hasValue(4))); ``` * `describedAs` - Wraps an existing matcher and overrides the description when it fails. ```php $expected = "Dog"; $found = null; // this assertion would result error message as Expected: is not null but: was null //assertThat("Expected {$expected}, got {$found}", $found, is(notNullValue())); // and this assertion would result error message as Expected: Dog but: was null //assertThat($found, describedAs($expected, notNullValue())); ``` * `everyItem` - A matcher to apply to every element in an array. ```php assertThat([2, 4, 6], everyItem(notNullValue())); ``` * `hasItem` - check array has given item, it can take a matcher argument ```php assertThat([2, 4, 6], hasItem(equalTo(2))); ``` * `hasItems` - check array has givem items, it can take multiple matcher as arguments ```php assertThat([1, 3, 5], hasItems(equalTo(1), equalTo(3))); ``` ### Object * `hasToString` - check `__toString` or `toString` method ```php class Foo { public $name = null; public function __toString() { return "[Foo]Instance"; } } $foo = new Foo; assertThat($foo, hasToString(equalTo("[Foo]Instance"))); ``` * `equalTo` - compares two instances using comparison operator '==' ```php $foo = new Foo; $foo2 = new Foo; assertThat($foo, equalTo($foo2)); ``` * `identicalTo` - compares two instances using identity operator '===' ```php assertThat($foo, is(not(identicalTo($foo2)))); ``` * `anInstanceOf` - check instance is an instance|sub-class of given class ```php assertThat($foo, anInstanceOf(Foo::class)); ``` * `any` - alias of `anInstanceOf` * `nullValue` check null ```php assertThat(null, is(nullValue())); ``` * `notNullValue` check not null ```php assertThat("", notNullValue()); ``` * `sameInstance` - check for same instance ```php assertThat($foo, is(not(sameInstance($foo2)))); assertThat($foo, is(sameInstance($foo))); ``` * `typeOf`- check type ```php assertThat(1, typeOf("integer")); ``` * `notSet` - check if instance property is not set ```php assertThat($foo, notSet("name")); ``` * `set` - check if instance property is set ```php $foo->name = "bar"; assertThat($foo, set("name")); ``` ### Numbers * `closeTo` - check value close to a range ```php assertThat(3, closeTo(3, 0.5)); ``` * `comparesEqualTo` - check with '==' ```php assertThat(2, comparesEqualTo(2)); ``` * `greaterThan` - check '>' ``` assertThat(2, greaterThan(1)); ``` * `greaterThanOrEqualTo` ```php assertThat(2, greaterThanOrEqualTo(2)); ``` * `atLeast` - The value is >= given value ```php assertThat(3, atLeast(2)); ``` * `lessThan` ```php assertThat(2, lessThan(3)); ``` * `lessThanOrEqualTo` ```php assertThat(2, lessThanOrEqualTo(3)); ``` * `atMost` - The value is <= given value ```php assertThat(2, atMost(3)); ``` ### String * `emptyString` - check for empty string ```php assertThat("", emptyString()); ``` * `isEmptyOrNullString` ```php assertThat(null, isEmptyOrNullString()); ``` * `nullOrEmptyString` ```php assertThat("", nullOrEmptyString()); ``` * `isNonEmptyString` ```php assertThat("foo", isNonEmptyString()); ``` * `nonEmptyString` ```php assertThat("foo", nonEmptyString()); ``` * `equalToIgnoringCase` ```php assertThat("Foo", equalToIgnoringCase("foo")); ``` * `equalToIgnoringWhiteSpace` ```php assertThat(" Foo ", equalToIgnoringWhiteSpace("Foo")); ``` * `matchesPattern` - matches with regex pattern ```php assertThat("foobarbaz", matchesPattern('/(foo)(bar)(baz)/')); ``` * `containsString` - check for substring ```php assertThat("foobar", containsString("foo")); ``` * `containsStringIgnoringCase` ```php assertThat("fooBar", containsStringIgnoringCase("bar")); ``` * `stringContainsInOrder` ```php assertThat("foo", stringContainsInOrder("foo")); ``` * `endsWith` - check string that ends with given value ```php assertThat("foo", endsWith("oo")); ``` * `startsWith` - check string that starts with given value ```php assertThat("bar", startsWith("ba")); ``` ### Type-checking * `arrayValue` - check array type ```php assertThat([], arrayValue()); ``` * `booleanValue` ```php assertThat(true, booleanValue()); ``` * `boolValue` - alias of booleanValue * `callableValue` - check if value is callable ```php $func = function () {}; assertThat($func, callableValue()); ``` * `doubleValue` ```php assertThat(3.14, doubleValue()); ``` * `floatValue` ```php assertThat(3.14, floatValue()); ``` * `integerValue` ```php assertThat(1, integerValue()); ``` * `intValue` - alias of `integerValue` * `numericValue` - check if value is numeric ```php assertThat("123", numericValue()); ``` * `objectValue` - check for object ```php $obj = new stdClass; assertThat($obj, objectValue()); ``` * `anObject` ```php assertThat($obj, anObject()); ``` * `resourceValue` - check resource type ```php $fp = fopen("/tmp/foo", "w+"); assertThat($fp, resourceValue()); ``` * `scalarValue` - check for scaler value ```php assertThat(1, scalarValue()); ``` * `stringValue` ```php assertThat("", stringValue()); ``` ### XML * `hasXPath` - check xml with a xpath ```php $xml = << 1 2 XML; $doc = new DOMDocument; $doc->loadXML($xml); assertThat($doc, hasXPath("book", 2)); ``` hamcrest-php/.github/workflows/tests.yml000064400000001567150364331700014434 0ustar00name: tests on: push: pull_request: jobs: tests: runs-on: ubuntu-latest strategy: matrix: php: ['7.0', '7.1', '7.2', '7.3', '7.4', '8.0'] name: PHP ${{ matrix.php }} steps: - name: Checkout code uses: actions/checkout@v2 - name: Setup PHP uses: shivammathur/setup-php@v2 with: php-version: ${{ matrix.php }} extensions: curl tools: composer:v2 coverage: none - name: Install PHP 7 dependencies run: composer update --prefer-dist --no-interaction --no-progress if: "matrix.php != '8.0'" - name: Install PHP 8 dependencies run: composer update --prefer-dist --no-interaction --no-progress --ignore-platform-reqs if: "matrix.php == '8.0'" - name: Execute tests run: vendor/bin/phpunit -c tests/phpunit.xml.dist hamcrest-php/.travis.yml000064400000000574150364331700011260 0ustar00language: php dist: trusty matrix: include: - name: PHP 5.3 php: 5.3 dist: precise - name: PHP 5.4 php: 5.4 - name: PHP 5.5 php: 5.5 - name: PHP 5.6 php: 5.6 - name: HHVM 3.18 php: hhvm-3.18 install: - travis_retry composer update --prefer-dist --no-progress script: - vendor/bin/phpunit -c tests/phpunit.xml.dist hamcrest-php/hamcrest/Hamcrest.php000064400000052151150364331700013232 0ustar00 * //With an identifier * assertThat("assertion identifier", $apple->flavour(), equalTo("tasty")); * //Without an identifier * assertThat($apple->flavour(), equalTo("tasty")); * //Evaluating a boolean expression * assertThat("some error", $a > $b); * */ function assertThat() { $args = func_get_args(); call_user_func_array( array('Hamcrest\MatcherAssert', 'assertThat'), $args ); } } if (!function_exists('anArray')) { /** * Evaluates to true only if each $matcher[$i] is satisfied by $array[$i]. */ function anArray(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Arrays\IsArray', 'anArray'), $args); } } if (!function_exists('hasItemInArray')) { /** * Evaluates to true if any item in an array satisfies the given matcher. * * @param mixed $item as a {@link Hamcrest\Matcher} or a value. * * @return \Hamcrest\Arrays\IsArrayContaining */ function hasItemInArray($item) { return \Hamcrest\Arrays\IsArrayContaining::hasItemInArray($item); } } if (!function_exists('hasValue')) { /** * Evaluates to true if any item in an array satisfies the given matcher. * * @param mixed $item as a {@link Hamcrest\Matcher} or a value. * * @return \Hamcrest\Arrays\IsArrayContaining */ function hasValue($item) { return \Hamcrest\Arrays\IsArrayContaining::hasItemInArray($item); } } if (!function_exists('arrayContainingInAnyOrder')) { /** * An array with elements that match the given matchers. */ function arrayContainingInAnyOrder(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInAnyOrder', 'arrayContainingInAnyOrder'), $args); } } if (!function_exists('containsInAnyOrder')) { /** * An array with elements that match the given matchers. */ function containsInAnyOrder(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInAnyOrder', 'arrayContainingInAnyOrder'), $args); } } if (!function_exists('arrayContaining')) { /** * An array with elements that match the given matchers in the same order. */ function arrayContaining(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInOrder', 'arrayContaining'), $args); } } if (!function_exists('contains')) { /** * An array with elements that match the given matchers in the same order. */ function contains(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInOrder', 'arrayContaining'), $args); } } if (!function_exists('hasKeyInArray')) { /** * Evaluates to true if any key in an array matches the given matcher. * * @param mixed $key as a {@link Hamcrest\Matcher} or a value. * * @return \Hamcrest\Arrays\IsArrayContainingKey */ function hasKeyInArray($key) { return \Hamcrest\Arrays\IsArrayContainingKey::hasKeyInArray($key); } } if (!function_exists('hasKey')) { /** * Evaluates to true if any key in an array matches the given matcher. * * @param mixed $key as a {@link Hamcrest\Matcher} or a value. * * @return \Hamcrest\Arrays\IsArrayContainingKey */ function hasKey($key) { return \Hamcrest\Arrays\IsArrayContainingKey::hasKeyInArray($key); } } if (!function_exists('hasKeyValuePair')) { /** * Test if an array has both an key and value in parity with each other. */ function hasKeyValuePair($key, $value) { return \Hamcrest\Arrays\IsArrayContainingKeyValuePair::hasKeyValuePair($key, $value); } } if (!function_exists('hasEntry')) { /** * Test if an array has both an key and value in parity with each other. */ function hasEntry($key, $value) { return \Hamcrest\Arrays\IsArrayContainingKeyValuePair::hasKeyValuePair($key, $value); } } if (!function_exists('arrayWithSize')) { /** * Does array size satisfy a given matcher? * * @param \Hamcrest\Matcher|int $size as a {@link Hamcrest\Matcher} or a value. * * @return \Hamcrest\Arrays\IsArrayWithSize */ function arrayWithSize($size) { return \Hamcrest\Arrays\IsArrayWithSize::arrayWithSize($size); } } if (!function_exists('emptyArray')) { /** * Matches an empty array. */ function emptyArray() { return \Hamcrest\Arrays\IsArrayWithSize::emptyArray(); } } if (!function_exists('nonEmptyArray')) { /** * Matches an empty array. */ function nonEmptyArray() { return \Hamcrest\Arrays\IsArrayWithSize::nonEmptyArray(); } } if (!function_exists('emptyTraversable')) { /** * Returns true if traversable is empty. */ function emptyTraversable() { return \Hamcrest\Collection\IsEmptyTraversable::emptyTraversable(); } } if (!function_exists('nonEmptyTraversable')) { /** * Returns true if traversable is not empty. */ function nonEmptyTraversable() { return \Hamcrest\Collection\IsEmptyTraversable::nonEmptyTraversable(); } } if (!function_exists('traversableWithSize')) { /** * Does traversable size satisfy a given matcher? */ function traversableWithSize($size) { return \Hamcrest\Collection\IsTraversableWithSize::traversableWithSize($size); } } if (!function_exists('allOf')) { /** * Evaluates to true only if ALL of the passed in matchers evaluate to true. */ function allOf(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\AllOf', 'allOf'), $args); } } if (!function_exists('anyOf')) { /** * Evaluates to true if ANY of the passed in matchers evaluate to true. */ function anyOf(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\AnyOf', 'anyOf'), $args); } } if (!function_exists('noneOf')) { /** * Evaluates to false if ANY of the passed in matchers evaluate to true. */ function noneOf(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\AnyOf', 'noneOf'), $args); } } if (!function_exists('both')) { /** * This is useful for fluently combining matchers that must both pass. * For example: *
     *   assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
     * 
*/ function both(\Hamcrest\Matcher $matcher) { return \Hamcrest\Core\CombinableMatcher::both($matcher); } } if (!function_exists('either')) { /** * This is useful for fluently combining matchers where either may pass, * for example: *
     *   assertThat($string, either(containsString("a"))->orElse(containsString("b")));
     * 
*/ function either(\Hamcrest\Matcher $matcher) { return \Hamcrest\Core\CombinableMatcher::either($matcher); } } if (!function_exists('describedAs')) { /** * Wraps an existing matcher and overrides the description when it fails. */ function describedAs(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\DescribedAs', 'describedAs'), $args); } } if (!function_exists('everyItem')) { /** * @param Matcher $itemMatcher * A matcher to apply to every element in an array. * * @return \Hamcrest\Core\Every * Evaluates to TRUE for a collection in which every item matches $itemMatcher */ function everyItem(\Hamcrest\Matcher $itemMatcher) { return \Hamcrest\Core\Every::everyItem($itemMatcher); } } if (!function_exists('hasToString')) { /** * Does array size satisfy a given matcher? */ function hasToString($matcher) { return \Hamcrest\Core\HasToString::hasToString($matcher); } } if (!function_exists('is')) { /** * Decorates another Matcher, retaining the behavior but allowing tests * to be slightly more expressive. * * For example: assertThat($cheese, equalTo($smelly)) * vs. assertThat($cheese, is(equalTo($smelly))) */ function is($value) { return \Hamcrest\Core\Is::is($value); } } if (!function_exists('anything')) { /** * This matcher always evaluates to true. * * @param string $description A meaningful string used when describing itself. * * @return \Hamcrest\Core\IsAnything */ function anything($description = 'ANYTHING') { return \Hamcrest\Core\IsAnything::anything($description); } } if (!function_exists('hasItem')) { /** * Test if the value is an array containing this matcher. * * Example: *
     * assertThat(array('a', 'b'), hasItem(equalTo('b')));
     * //Convenience defaults to equalTo()
     * assertThat(array('a', 'b'), hasItem('b'));
     * 
*/ function hasItem(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItem'), $args); } } if (!function_exists('hasItems')) { /** * Test if the value is an array containing elements that match all of these * matchers. * * Example: *
     * assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
     * 
*/ function hasItems(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItems'), $args); } } if (!function_exists('equalTo')) { /** * Is the value equal to another value, as tested by the use of the "==" * comparison operator? */ function equalTo($item) { return \Hamcrest\Core\IsEqual::equalTo($item); } } if (!function_exists('identicalTo')) { /** * Tests of the value is identical to $value as tested by the "===" operator. */ function identicalTo($value) { return \Hamcrest\Core\IsIdentical::identicalTo($value); } } if (!function_exists('anInstanceOf')) { /** * Is the value an instance of a particular type? * This version assumes no relationship between the required type and * the signature of the method that sets it up, for example in * assertThat($anObject, anInstanceOf('Thing')); */ function anInstanceOf($theClass) { return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass); } } if (!function_exists('any')) { /** * Is the value an instance of a particular type? * This version assumes no relationship between the required type and * the signature of the method that sets it up, for example in * assertThat($anObject, anInstanceOf('Thing')); */ function any($theClass) { return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass); } } if (!function_exists('not')) { /** * Matches if value does not match $value. */ function not($value) { return \Hamcrest\Core\IsNot::not($value); } } if (!function_exists('nullValue')) { /** * Matches if value is null. */ function nullValue() { return \Hamcrest\Core\IsNull::nullValue(); } } if (!function_exists('notNullValue')) { /** * Matches if value is not null. */ function notNullValue() { return \Hamcrest\Core\IsNull::notNullValue(); } } if (!function_exists('sameInstance')) { /** * Creates a new instance of IsSame. * * @param mixed $object * The predicate evaluates to true only when the argument is * this object. * * @return \Hamcrest\Core\IsSame */ function sameInstance($object) { return \Hamcrest\Core\IsSame::sameInstance($object); } } if (!function_exists('typeOf')) { /** * Is the value a particular built-in type? */ function typeOf($theType) { return \Hamcrest\Core\IsTypeOf::typeOf($theType); } } if (!function_exists('set')) { /** * Matches if value (class, object, or array) has named $property. */ function set($property) { return \Hamcrest\Core\Set::set($property); } } if (!function_exists('notSet')) { /** * Matches if value (class, object, or array) does not have named $property. */ function notSet($property) { return \Hamcrest\Core\Set::notSet($property); } } if (!function_exists('closeTo')) { /** * Matches if value is a number equal to $value within some range of * acceptable error $delta. */ function closeTo($value, $delta) { return \Hamcrest\Number\IsCloseTo::closeTo($value, $delta); } } if (!function_exists('comparesEqualTo')) { /** * The value is not > $value, nor < $value. */ function comparesEqualTo($value) { return \Hamcrest\Number\OrderingComparison::comparesEqualTo($value); } } if (!function_exists('greaterThan')) { /** * The value is > $value. */ function greaterThan($value) { return \Hamcrest\Number\OrderingComparison::greaterThan($value); } } if (!function_exists('greaterThanOrEqualTo')) { /** * The value is >= $value. */ function greaterThanOrEqualTo($value) { return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value); } } if (!function_exists('atLeast')) { /** * The value is >= $value. */ function atLeast($value) { return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value); } } if (!function_exists('lessThan')) { /** * The value is < $value. */ function lessThan($value) { return \Hamcrest\Number\OrderingComparison::lessThan($value); } } if (!function_exists('lessThanOrEqualTo')) { /** * The value is <= $value. */ function lessThanOrEqualTo($value) { return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value); } } if (!function_exists('atMost')) { /** * The value is <= $value. */ function atMost($value) { return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value); } } if (!function_exists('isEmptyString')) { /** * Matches if value is a zero-length string. */ function isEmptyString() { return \Hamcrest\Text\IsEmptyString::isEmptyString(); } } if (!function_exists('emptyString')) { /** * Matches if value is a zero-length string. */ function emptyString() { return \Hamcrest\Text\IsEmptyString::isEmptyString(); } } if (!function_exists('isEmptyOrNullString')) { /** * Matches if value is null or a zero-length string. */ function isEmptyOrNullString() { return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString(); } } if (!function_exists('nullOrEmptyString')) { /** * Matches if value is null or a zero-length string. */ function nullOrEmptyString() { return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString(); } } if (!function_exists('isNonEmptyString')) { /** * Matches if value is a non-zero-length string. */ function isNonEmptyString() { return \Hamcrest\Text\IsEmptyString::isNonEmptyString(); } } if (!function_exists('nonEmptyString')) { /** * Matches if value is a non-zero-length string. */ function nonEmptyString() { return \Hamcrest\Text\IsEmptyString::isNonEmptyString(); } } if (!function_exists('equalToIgnoringCase')) { /** * Matches if value is a string equal to $string, regardless of the case. */ function equalToIgnoringCase($string) { return \Hamcrest\Text\IsEqualIgnoringCase::equalToIgnoringCase($string); } } if (!function_exists('equalToIgnoringWhiteSpace')) { /** * Matches if value is a string equal to $string, regardless of whitespace. */ function equalToIgnoringWhiteSpace($string) { return \Hamcrest\Text\IsEqualIgnoringWhiteSpace::equalToIgnoringWhiteSpace($string); } } if (!function_exists('matchesPattern')) { /** * Matches if value is a string that matches regular expression $pattern. */ function matchesPattern($pattern) { return \Hamcrest\Text\MatchesPattern::matchesPattern($pattern); } } if (!function_exists('containsString')) { /** * Matches if value is a string that contains $substring. */ function containsString($substring) { return \Hamcrest\Text\StringContains::containsString($substring); } } if (!function_exists('containsStringIgnoringCase')) { /** * Matches if value is a string that contains $substring regardless of the case. */ function containsStringIgnoringCase($substring) { return \Hamcrest\Text\StringContainsIgnoringCase::containsStringIgnoringCase($substring); } } if (!function_exists('stringContainsInOrder')) { /** * Matches if value contains $substrings in a constrained order. */ function stringContainsInOrder(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Text\StringContainsInOrder', 'stringContainsInOrder'), $args); } } if (!function_exists('endsWith')) { /** * Matches if value is a string that ends with $substring. */ function endsWith($substring) { return \Hamcrest\Text\StringEndsWith::endsWith($substring); } } if (!function_exists('startsWith')) { /** * Matches if value is a string that starts with $substring. */ function startsWith($substring) { return \Hamcrest\Text\StringStartsWith::startsWith($substring); } } if (!function_exists('arrayValue')) { /** * Is the value an array? */ function arrayValue() { return \Hamcrest\Type\IsArray::arrayValue(); } } if (!function_exists('booleanValue')) { /** * Is the value a boolean? */ function booleanValue() { return \Hamcrest\Type\IsBoolean::booleanValue(); } } if (!function_exists('boolValue')) { /** * Is the value a boolean? */ function boolValue() { return \Hamcrest\Type\IsBoolean::booleanValue(); } } if (!function_exists('callableValue')) { /** * Is the value callable? */ function callableValue() { return \Hamcrest\Type\IsCallable::callableValue(); } } if (!function_exists('doubleValue')) { /** * Is the value a float/double? */ function doubleValue() { return \Hamcrest\Type\IsDouble::doubleValue(); } } if (!function_exists('floatValue')) { /** * Is the value a float/double? */ function floatValue() { return \Hamcrest\Type\IsDouble::doubleValue(); } } if (!function_exists('integerValue')) { /** * Is the value an integer? */ function integerValue() { return \Hamcrest\Type\IsInteger::integerValue(); } } if (!function_exists('intValue')) { /** * Is the value an integer? */ function intValue() { return \Hamcrest\Type\IsInteger::integerValue(); } } if (!function_exists('numericValue')) { /** * Is the value a numeric? */ function numericValue() { return \Hamcrest\Type\IsNumeric::numericValue(); } } if (!function_exists('objectValue')) { /** * Is the value an object? */ function objectValue() { return \Hamcrest\Type\IsObject::objectValue(); } } if (!function_exists('anObject')) { /** * Is the value an object? */ function anObject() { return \Hamcrest\Type\IsObject::objectValue(); } } if (!function_exists('resourceValue')) { /** * Is the value a resource? */ function resourceValue() { return \Hamcrest\Type\IsResource::resourceValue(); } } if (!function_exists('scalarValue')) { /** * Is the value a scalar (boolean, integer, double, or string)? */ function scalarValue() { return \Hamcrest\Type\IsScalar::scalarValue(); } } if (!function_exists('stringValue')) { /** * Is the value a string? */ function stringValue() { return \Hamcrest\Type\IsString::stringValue(); } } if (!function_exists('hasXPath')) { /** * Wraps $matcher with {@link Hamcrest\Core\IsEqual) * if it's not a matcher and the XPath in count() * if it's an integer. */ function hasXPath($xpath, $matcher = null) { return \Hamcrest\Xml\HasXPath::hasXPath($xpath, $matcher); } } hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayWithSize.php000064400000002715150364331700017535 0ustar00_elementMatchers = $elementMatchers; } protected function matchesSafely($array) { if (array_keys($array) != array_keys($this->_elementMatchers)) { return false; } /** @var $matcher \Hamcrest\Matcher */ foreach ($this->_elementMatchers as $k => $matcher) { if (!$matcher->matches($array[$k])) { return false; } } return true; } protected function describeMismatchSafely($actual, Description $mismatchDescription) { if (count($actual) != count($this->_elementMatchers)) { $mismatchDescription->appendText('array length was ' . count($actual)); return; } elseif (array_keys($actual) != array_keys($this->_elementMatchers)) { $mismatchDescription->appendText('array keys were ') ->appendValueList( $this->descriptionStart(), $this->descriptionSeparator(), $this->descriptionEnd(), array_keys($actual) ) ; return; } /** @var $matcher \Hamcrest\Matcher */ foreach ($this->_elementMatchers as $k => $matcher) { if (!$matcher->matches($actual[$k])) { $mismatchDescription->appendText('element ')->appendValue($k) ->appendText(' was ')->appendValue($actual[$k]); return; } } } public function describeTo(Description $description) { $description->appendList( $this->descriptionStart(), $this->descriptionSeparator(), $this->descriptionEnd(), $this->_elementMatchers ); } /** * Evaluates to true only if each $matcher[$i] is satisfied by $array[$i]. * * @factory ... */ public static function anArray(/* args... */) { $args = func_get_args(); return new self(Util::createMatcherArray($args)); } // -- Protected Methods protected function descriptionStart() { return '['; } protected function descriptionSeparator() { return ', '; } protected function descriptionEnd() { return ']'; } } hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKey.php000064400000003654150364331700020534 0ustar00_keyMatcher = $keyMatcher; } protected function matchesSafely($array) { foreach ($array as $key => $element) { if ($this->_keyMatcher->matches($key)) { return true; } } return false; } protected function describeMismatchSafely($array, Description $mismatchDescription) { //Not using appendValueList() so that keys can be shown $mismatchDescription->appendText('array was ') ->appendText('[') ; $loop = false; foreach ($array as $key => $value) { if ($loop) { $mismatchDescription->appendText(', '); } $mismatchDescription->appendValue($key)->appendText(' => ')->appendValue($value); $loop = true; } $mismatchDescription->appendText(']'); } public function describeTo(Description $description) { $description ->appendText('array with key ') ->appendDescriptionOf($this->_keyMatcher) ; } /** * Evaluates to true if any key in an array matches the given matcher. * * @param mixed $key as a {@link Hamcrest\Matcher} or a value. * * @return \Hamcrest\Arrays\IsArrayContainingKey * @factory hasKey */ public static function hasKeyInArray($key) { return new self(Util::wrapValueWithIsEqual($key)); } } hamcrest-php/hamcrest/Hamcrest/Arrays/SeriesMatchingOnce.php000064400000003454150364331700020207 0ustar00_elementMatchers = $elementMatchers; $this->_keys = array_keys($elementMatchers); $this->_mismatchDescription = $mismatchDescription; } public function matches($item) { return $this->_isNotSurplus($item) && $this->_isMatched($item); } public function isFinished() { if (!empty($this->_elementMatchers)) { $nextMatcher = current($this->_elementMatchers); $this->_mismatchDescription->appendText('No item matched: ')->appendDescriptionOf($nextMatcher); return false; } return true; } // -- Private Methods private function _isNotSurplus($item) { if (empty($this->_elementMatchers)) { $this->_mismatchDescription->appendText('Not matched: ')->appendValue($item); return false; } return true; } private function _isMatched($item) { $this->_nextMatchKey = array_shift($this->_keys); $nextMatcher = array_shift($this->_elementMatchers); if (!$nextMatcher->matches($item)) { $this->_describeMismatch($nextMatcher, $item); return false; } return true; } private function _describeMismatch(Matcher $matcher, $item) { $this->_mismatchDescription->appendText('item with key ' . $this->_nextMatchKey . ': '); $matcher->describeMismatch($item, $this->_mismatchDescription); } } hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInOrder.php000064400000002560150364331700021341 0ustar00_elementMatchers = $elementMatchers; } protected function matchesSafelyWithDiagnosticDescription($array, Description $mismatchDescription) { $series = new SeriesMatchingOnce($this->_elementMatchers, $mismatchDescription); foreach ($array as $element) { if (!$series->matches($element)) { return false; } } return $series->isFinished(); } public function describeTo(Description $description) { $description->appendList('[', ', ', ']', $this->_elementMatchers); } /** * An array with elements that match the given matchers in the same order. * * @factory contains ... */ public static function arrayContaining(/* args... */) { $args = func_get_args(); return new self(Util::createMatcherArray($args)); } } hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInAnyOrder.php000064400000002732150364331700022012 0ustar00_elementMatchers = $elementMatchers; } protected function matchesSafelyWithDiagnosticDescription($array, Description $mismatchDescription) { $matching = new MatchingOnce($this->_elementMatchers, $mismatchDescription); foreach ($array as $element) { if (!$matching->matches($element)) { return false; } } return $matching->isFinished($array); } public function describeTo(Description $description) { $description->appendList('[', ', ', ']', $this->_elementMatchers) ->appendText(' in any order') ; } /** * An array with elements that match the given matchers. * * @factory containsInAnyOrder ... */ public static function arrayContainingInAnyOrder(/* args... */) { $args = func_get_args(); return new self(Util::createMatcherArray($args)); } } hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKeyValuePair.php000064400000004323150364331700022337 0ustar00_keyMatcher = $keyMatcher; $this->_valueMatcher = $valueMatcher; } protected function matchesSafely($array) { foreach ($array as $key => $value) { if ($this->_keyMatcher->matches($key) && $this->_valueMatcher->matches($value)) { return true; } } return false; } protected function describeMismatchSafely($array, Description $mismatchDescription) { //Not using appendValueList() so that keys can be shown $mismatchDescription->appendText('array was ') ->appendText('[') ; $loop = false; foreach ($array as $key => $value) { if ($loop) { $mismatchDescription->appendText(', '); } $mismatchDescription->appendValue($key)->appendText(' => ')->appendValue($value); $loop = true; } $mismatchDescription->appendText(']'); } public function describeTo(Description $description) { $description->appendText('array containing [') ->appendDescriptionOf($this->_keyMatcher) ->appendText(' => ') ->appendDescriptionOf($this->_valueMatcher) ->appendText(']') ; } /** * Test if an array has both an key and value in parity with each other. * * @factory hasEntry */ public static function hasKeyValuePair($key, $value) { return new self( Util::wrapValueWithIsEqual($key), Util::wrapValueWithIsEqual($value) ); } } hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContaining.php000064400000002731150364331700020056 0ustar00_elementMatcher = $elementMatcher; } protected function matchesSafely($array) { foreach ($array as $element) { if ($this->_elementMatcher->matches($element)) { return true; } } return false; } protected function describeMismatchSafely($array, Description $mismatchDescription) { $mismatchDescription->appendText('was ')->appendValue($array); } public function describeTo(Description $description) { $description ->appendText('an array containing ') ->appendDescriptionOf($this->_elementMatcher) ; } /** * Evaluates to true if any item in an array satisfies the given matcher. * * @param mixed $item as a {@link Hamcrest\Matcher} or a value. * * @return \Hamcrest\Arrays\IsArrayContaining * @factory hasValue */ public static function hasItemInArray($item) { return new self(Util::wrapValueWithIsEqual($item)); } } hamcrest-php/hamcrest/Hamcrest/Arrays/MatchingOnce.php000064400000003126150364331700017030 0ustar00_elementMatchers = $elementMatchers; $this->_mismatchDescription = $mismatchDescription; } public function matches($item) { return $this->_isNotSurplus($item) && $this->_isMatched($item); } public function isFinished($items) { if (empty($this->_elementMatchers)) { return true; } $this->_mismatchDescription ->appendText('No item matches: ')->appendList('', ', ', '', $this->_elementMatchers) ->appendText(' in ')->appendValueList('[', ', ', ']', $items) ; return false; } // -- Private Methods private function _isNotSurplus($item) { if (empty($this->_elementMatchers)) { $this->_mismatchDescription->appendText('Not matched: ')->appendValue($item); return false; } return true; } private function _isMatched($item) { /** @var $matcher \Hamcrest\Matcher */ foreach ($this->_elementMatchers as $i => $matcher) { if ($matcher->matches($item)) { unset($this->_elementMatchers[$i]); return true; } } $this->_mismatchDescription->appendText('Not matched: ')->appendValue($item); return false; } } hamcrest-php/hamcrest/Hamcrest/Xml/HasXPath.php000064400000013747150364331700015462 0ustar00_xpath = $xpath; $this->_matcher = $matcher; } /** * Matches if the XPath matches against the DOM node and the matcher. * * @param string|\DOMNode $actual * @param Description $mismatchDescription * @return bool */ protected function matchesWithDiagnosticDescription($actual, Description $mismatchDescription) { if (is_string($actual)) { $actual = $this->createDocument($actual); } elseif (!$actual instanceof \DOMNode) { $mismatchDescription->appendText('was ')->appendValue($actual); return false; } $result = $this->evaluate($actual); if ($result instanceof \DOMNodeList) { return $this->matchesContent($result, $mismatchDescription); } else { return $this->matchesExpression($result, $mismatchDescription); } } /** * Creates and returns a DOMDocument from the given * XML or HTML string. * * @param string $text * @return \DOMDocument built from $text * @throws \InvalidArgumentException if the document is not valid */ protected function createDocument($text) { $document = new \DOMDocument(); if (preg_match('/^\s*<\?xml/', $text)) { if (!@$document->loadXML($text)) { throw new \InvalidArgumentException('Must pass a valid XML document'); } } else { if (!@$document->loadHTML($text)) { throw new \InvalidArgumentException('Must pass a valid HTML or XHTML document'); } } return $document; } /** * Applies the configured XPath to the DOM node and returns either * the result if it's an expression or the node list if it's a query. * * @param \DOMNode $node context from which to issue query * @return mixed result of expression or DOMNodeList from query */ protected function evaluate(\DOMNode $node) { if ($node instanceof \DOMDocument) { $xpathDocument = new \DOMXPath($node); return $xpathDocument->evaluate($this->_xpath); } else { $xpathDocument = new \DOMXPath($node->ownerDocument); return $xpathDocument->evaluate($this->_xpath, $node); } } /** * Matches if the list of nodes is not empty and the content of at least * one node matches the configured matcher, if supplied. * * @param \DOMNodeList $nodes selected by the XPath query * @param Description $mismatchDescription * @return bool */ protected function matchesContent(\DOMNodeList $nodes, Description $mismatchDescription) { if ($nodes->length == 0) { $mismatchDescription->appendText('XPath returned no results'); } elseif ($this->_matcher === null) { return true; } else { foreach ($nodes as $node) { if ($this->_matcher->matches($node->textContent)) { return true; } } $content = array(); foreach ($nodes as $node) { $content[] = $node->textContent; } $mismatchDescription->appendText('XPath returned ') ->appendValue($content); } return false; } /** * Matches if the result of the XPath expression matches the configured * matcher or evaluates to true if there is none. * * @param mixed $result result of the XPath expression * @param Description $mismatchDescription * @return bool */ protected function matchesExpression($result, Description $mismatchDescription) { if ($this->_matcher === null) { if ($result) { return true; } $mismatchDescription->appendText('XPath expression result was ') ->appendValue($result); } else { if ($this->_matcher->matches($result)) { return true; } $mismatchDescription->appendText('XPath expression result '); $this->_matcher->describeMismatch($result, $mismatchDescription); } return false; } public function describeTo(Description $description) { $description->appendText('XML or HTML document with XPath "') ->appendText($this->_xpath) ->appendText('"'); if ($this->_matcher !== null) { $description->appendText(' '); $this->_matcher->describeTo($description); } } /** * Wraps $matcher with {@link Hamcrest\Core\IsEqual) * if it's not a matcher and the XPath in count() * if it's an integer. * * @factory */ public static function hasXPath($xpath, $matcher = null) { if ($matcher === null || $matcher instanceof Matcher) { return new self($xpath, $matcher); } elseif (is_int($matcher) && strpos($xpath, 'count(') !== 0) { $xpath = 'count(' . $xpath . ')'; } return new self($xpath, IsEqual::equalTo($matcher)); } } hamcrest-php/hamcrest/Hamcrest/Matchers.php000064400000045021150364331700014776 0ustar00 * assertThat($string, both(containsString("a"))->andAlso(containsString("b"))); * */ public static function both(\Hamcrest\Matcher $matcher) { return \Hamcrest\Core\CombinableMatcher::both($matcher); } /** * This is useful for fluently combining matchers where either may pass, * for example: *
     *   assertThat($string, either(containsString("a"))->orElse(containsString("b")));
     * 
*/ public static function either(\Hamcrest\Matcher $matcher) { return \Hamcrest\Core\CombinableMatcher::either($matcher); } /** * Wraps an existing matcher and overrides the description when it fails. */ public static function describedAs(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\DescribedAs', 'describedAs'), $args); } /** * @param Matcher $itemMatcher * A matcher to apply to every element in an array. * * @return \Hamcrest\Core\Every * Evaluates to TRUE for a collection in which every item matches $itemMatcher */ public static function everyItem(\Hamcrest\Matcher $itemMatcher) { return \Hamcrest\Core\Every::everyItem($itemMatcher); } /** * Does array size satisfy a given matcher? */ public static function hasToString($matcher) { return \Hamcrest\Core\HasToString::hasToString($matcher); } /** * Decorates another Matcher, retaining the behavior but allowing tests * to be slightly more expressive. * * For example: assertThat($cheese, equalTo($smelly)) * vs. assertThat($cheese, is(equalTo($smelly))) */ public static function is($value) { return \Hamcrest\Core\Is::is($value); } /** * This matcher always evaluates to true. * * @param string $description A meaningful string used when describing itself. * * @return \Hamcrest\Core\IsAnything */ public static function anything($description = 'ANYTHING') { return \Hamcrest\Core\IsAnything::anything($description); } /** * Test if the value is an array containing this matcher. * * Example: *
     * assertThat(array('a', 'b'), hasItem(equalTo('b')));
     * //Convenience defaults to equalTo()
     * assertThat(array('a', 'b'), hasItem('b'));
     * 
*/ public static function hasItem(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItem'), $args); } /** * Test if the value is an array containing elements that match all of these * matchers. * * Example: *
     * assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
     * 
*/ public static function hasItems(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Core\IsCollectionContaining', 'hasItems'), $args); } /** * Is the value equal to another value, as tested by the use of the "==" * comparison operator? */ public static function equalTo($item) { return \Hamcrest\Core\IsEqual::equalTo($item); } /** * Tests of the value is identical to $value as tested by the "===" operator. */ public static function identicalTo($value) { return \Hamcrest\Core\IsIdentical::identicalTo($value); } /** * Is the value an instance of a particular type? * This version assumes no relationship between the required type and * the signature of the method that sets it up, for example in * assertThat($anObject, anInstanceOf('Thing')); */ public static function anInstanceOf($theClass) { return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass); } /** * Is the value an instance of a particular type? * This version assumes no relationship between the required type and * the signature of the method that sets it up, for example in * assertThat($anObject, anInstanceOf('Thing')); */ public static function any($theClass) { return \Hamcrest\Core\IsInstanceOf::anInstanceOf($theClass); } /** * Matches if value does not match $value. */ public static function not($value) { return \Hamcrest\Core\IsNot::not($value); } /** * Matches if value is null. */ public static function nullValue() { return \Hamcrest\Core\IsNull::nullValue(); } /** * Matches if value is not null. */ public static function notNullValue() { return \Hamcrest\Core\IsNull::notNullValue(); } /** * Creates a new instance of IsSame. * * @param mixed $object * The predicate evaluates to true only when the argument is * this object. * * @return \Hamcrest\Core\IsSame */ public static function sameInstance($object) { return \Hamcrest\Core\IsSame::sameInstance($object); } /** * Is the value a particular built-in type? */ public static function typeOf($theType) { return \Hamcrest\Core\IsTypeOf::typeOf($theType); } /** * Matches if value (class, object, or array) has named $property. */ public static function set($property) { return \Hamcrest\Core\Set::set($property); } /** * Matches if value (class, object, or array) does not have named $property. */ public static function notSet($property) { return \Hamcrest\Core\Set::notSet($property); } /** * Matches if value is a number equal to $value within some range of * acceptable error $delta. */ public static function closeTo($value, $delta) { return \Hamcrest\Number\IsCloseTo::closeTo($value, $delta); } /** * The value is not > $value, nor < $value. */ public static function comparesEqualTo($value) { return \Hamcrest\Number\OrderingComparison::comparesEqualTo($value); } /** * The value is > $value. */ public static function greaterThan($value) { return \Hamcrest\Number\OrderingComparison::greaterThan($value); } /** * The value is >= $value. */ public static function greaterThanOrEqualTo($value) { return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value); } /** * The value is >= $value. */ public static function atLeast($value) { return \Hamcrest\Number\OrderingComparison::greaterThanOrEqualTo($value); } /** * The value is < $value. */ public static function lessThan($value) { return \Hamcrest\Number\OrderingComparison::lessThan($value); } /** * The value is <= $value. */ public static function lessThanOrEqualTo($value) { return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value); } /** * The value is <= $value. */ public static function atMost($value) { return \Hamcrest\Number\OrderingComparison::lessThanOrEqualTo($value); } /** * Matches if value is a zero-length string. */ public static function isEmptyString() { return \Hamcrest\Text\IsEmptyString::isEmptyString(); } /** * Matches if value is a zero-length string. */ public static function emptyString() { return \Hamcrest\Text\IsEmptyString::isEmptyString(); } /** * Matches if value is null or a zero-length string. */ public static function isEmptyOrNullString() { return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString(); } /** * Matches if value is null or a zero-length string. */ public static function nullOrEmptyString() { return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString(); } /** * Matches if value is a non-zero-length string. */ public static function isNonEmptyString() { return \Hamcrest\Text\IsEmptyString::isNonEmptyString(); } /** * Matches if value is a non-zero-length string. */ public static function nonEmptyString() { return \Hamcrest\Text\IsEmptyString::isNonEmptyString(); } /** * Matches if value is a string equal to $string, regardless of the case. */ public static function equalToIgnoringCase($string) { return \Hamcrest\Text\IsEqualIgnoringCase::equalToIgnoringCase($string); } /** * Matches if value is a string equal to $string, regardless of whitespace. */ public static function equalToIgnoringWhiteSpace($string) { return \Hamcrest\Text\IsEqualIgnoringWhiteSpace::equalToIgnoringWhiteSpace($string); } /** * Matches if value is a string that matches regular expression $pattern. */ public static function matchesPattern($pattern) { return \Hamcrest\Text\MatchesPattern::matchesPattern($pattern); } /** * Matches if value is a string that contains $substring. */ public static function containsString($substring) { return \Hamcrest\Text\StringContains::containsString($substring); } /** * Matches if value is a string that contains $substring regardless of the case. */ public static function containsStringIgnoringCase($substring) { return \Hamcrest\Text\StringContainsIgnoringCase::containsStringIgnoringCase($substring); } /** * Matches if value contains $substrings in a constrained order. */ public static function stringContainsInOrder(/* args... */) { $args = func_get_args(); return call_user_func_array(array('\Hamcrest\Text\StringContainsInOrder', 'stringContainsInOrder'), $args); } /** * Matches if value is a string that ends with $substring. */ public static function endsWith($substring) { return \Hamcrest\Text\StringEndsWith::endsWith($substring); } /** * Matches if value is a string that starts with $substring. */ public static function startsWith($substring) { return \Hamcrest\Text\StringStartsWith::startsWith($substring); } /** * Is the value an array? */ public static function arrayValue() { return \Hamcrest\Type\IsArray::arrayValue(); } /** * Is the value a boolean? */ public static function booleanValue() { return \Hamcrest\Type\IsBoolean::booleanValue(); } /** * Is the value a boolean? */ public static function boolValue() { return \Hamcrest\Type\IsBoolean::booleanValue(); } /** * Is the value callable? */ public static function callableValue() { return \Hamcrest\Type\IsCallable::callableValue(); } /** * Is the value a float/double? */ public static function doubleValue() { return \Hamcrest\Type\IsDouble::doubleValue(); } /** * Is the value a float/double? */ public static function floatValue() { return \Hamcrest\Type\IsDouble::doubleValue(); } /** * Is the value an integer? */ public static function integerValue() { return \Hamcrest\Type\IsInteger::integerValue(); } /** * Is the value an integer? */ public static function intValue() { return \Hamcrest\Type\IsInteger::integerValue(); } /** * Is the value a numeric? */ public static function numericValue() { return \Hamcrest\Type\IsNumeric::numericValue(); } /** * Is the value an object? */ public static function objectValue() { return \Hamcrest\Type\IsObject::objectValue(); } /** * Is the value an object? */ public static function anObject() { return \Hamcrest\Type\IsObject::objectValue(); } /** * Is the value a resource? */ public static function resourceValue() { return \Hamcrest\Type\IsResource::resourceValue(); } /** * Is the value a scalar (boolean, integer, double, or string)? */ public static function scalarValue() { return \Hamcrest\Type\IsScalar::scalarValue(); } /** * Is the value a string? */ public static function stringValue() { return \Hamcrest\Type\IsString::stringValue(); } /** * Wraps $matcher with {@link Hamcrest\Core\IsEqual) * if it's not a matcher and the XPath in count() * if it's an integer. */ public static function hasXPath($xpath, $matcher = null) { return \Hamcrest\Xml\HasXPath::hasXPath($xpath, $matcher); } } hamcrest-php/hamcrest/Hamcrest/TypeSafeDiagnosingMatcher.php000064400000001511150364331700020253 0ustar00matchesSafelyWithDiagnosticDescription($item, new NullDescription()); } final public function describeMismatchSafely($item, Description $mismatchDescription) { $this->matchesSafelyWithDiagnosticDescription($item, $mismatchDescription); } // -- Protected Methods /** * Subclasses should implement these. The item will already have been checked for * the specific type. */ abstract protected function matchesSafelyWithDiagnosticDescription($item, Description $mismatchDescription); } hamcrest-php/hamcrest/Hamcrest/Text/StringEndsWith.php000064400000001363150364331700017071 0ustar00_substring))) === $this->_substring); } protected function relationship() { return 'ending with'; } } hamcrest-php/hamcrest/Hamcrest/Text/StringContainsIgnoringCase.php000064400000001452150364331700021412 0ustar00_substring)); } protected function relationship() { return 'containing in any case'; } } hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringCase.php000064400000002270150364331700020007 0ustar00_string = $string; } protected function matchesSafely($item) { return strtolower($this->_string) === strtolower($item); } protected function describeMismatchSafely($item, Description $mismatchDescription) { $mismatchDescription->appendText('was ')->appendText($item); } public function describeTo(Description $description) { $description->appendText('equalToIgnoringCase(') ->appendValue($this->_string) ->appendText(')') ; } /** * Matches if value is a string equal to $string, regardless of the case. * * @factory */ public static function equalToIgnoringCase($string) { return new self($string); } } hamcrest-php/hamcrest/Hamcrest/Text/IsEmptyString.php000064400000003434150364331700016737 0ustar00_empty = $empty; } public function matches($item) { return $this->_empty ? ($item === '') : is_string($item) && $item !== ''; } public function describeTo(Description $description) { $description->appendText($this->_empty ? 'an empty string' : 'a non-empty string'); } /** * Matches if value is a zero-length string. * * @factory emptyString */ public static function isEmptyString() { if (!self::$_INSTANCE) { self::$_INSTANCE = new self(true); } return self::$_INSTANCE; } /** * Matches if value is null or a zero-length string. * * @factory nullOrEmptyString */ public static function isEmptyOrNullString() { if (!self::$_NULL_OR_EMPTY_INSTANCE) { self::$_NULL_OR_EMPTY_INSTANCE = AnyOf::anyOf( IsNull::nullvalue(), self::isEmptyString() ); } return self::$_NULL_OR_EMPTY_INSTANCE; } /** * Matches if value is a non-zero-length string. * * @factory nonEmptyString */ public static function isNonEmptyString() { if (!self::$_NOT_INSTANCE) { self::$_NOT_INSTANCE = new self(false); } return self::$_NOT_INSTANCE; } } hamcrest-php/hamcrest/Hamcrest/Text/MatchesPattern.php000064400000001353150364331700017076 0ustar00_substring, (string) $item) >= 1; } protected function relationship() { return 'matching'; } } hamcrest-php/hamcrest/Hamcrest/Text/SubstringMatcher.php000064400000002107150364331700017436 0ustar00_substring = $substring; } protected function matchesSafely($item) { return $this->evalSubstringOf($item); } protected function describeMismatchSafely($item, Description $mismatchDescription) { $mismatchDescription->appendText('was "')->appendText($item)->appendText('"'); } public function describeTo(Description $description) { $description->appendText('a string ') ->appendText($this->relationship()) ->appendText(' ') ->appendValue($this->_substring) ; } abstract protected function evalSubstringOf($string); abstract protected function relationship(); } hamcrest-php/hamcrest/Hamcrest/Text/StringContainsInOrder.php000064400000003035150364331700020403 0ustar00_substrings = $substrings; } protected function matchesSafely($item) { $fromIndex = 0; foreach ($this->_substrings as $substring) { if (false === $fromIndex = strpos($item, $substring, $fromIndex)) { return false; } } return true; } protected function describeMismatchSafely($item, Description $mismatchDescription) { $mismatchDescription->appendText('was ')->appendText($item); } public function describeTo(Description $description) { $description->appendText('a string containing ') ->appendValueList('', ', ', '', $this->_substrings) ->appendText(' in order') ; } /** * Matches if value contains $substrings in a constrained order. * * @factory ... */ public static function stringContainsInOrder(/* args... */) { $args = func_get_args(); if (isset($args[0]) && is_array($args[0])) { $args = $args[0]; } return new self($args); } } hamcrest-php/hamcrest/Hamcrest/Text/StringContains.php000064400000001522150364331700017117 0ustar00_substring); } /** * Matches if value is a string that contains $substring. * * @factory */ public static function containsString($substring) { return new self($substring); } // -- Protected Methods protected function evalSubstringOf($item) { return (false !== strpos((string) $item, $this->_substring)); } protected function relationship() { return 'containing'; } } hamcrest-php/hamcrest/Hamcrest/Text/StringStartsWith.php000064400000001366150364331700017463 0ustar00_substring)) === $this->_substring); } protected function relationship() { return 'starting with'; } } hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringWhiteSpace.php000064400000003071150364331700021170 0ustar00_string = $string; } protected function matchesSafely($item) { return (strtolower($this->_stripSpace($item)) === strtolower($this->_stripSpace($this->_string))); } protected function describeMismatchSafely($item, Description $mismatchDescription) { $mismatchDescription->appendText('was ')->appendText($item); } public function describeTo(Description $description) { $description->appendText('equalToIgnoringWhiteSpace(') ->appendValue($this->_string) ->appendText(')') ; } /** * Matches if value is a string equal to $string, regardless of whitespace. * * @factory */ public static function equalToIgnoringWhiteSpace($string) { return new self($string); } // -- Private Methods private function _stripSpace($string) { $parts = preg_split("/[\r\n\t ]+/", $string); foreach ($parts as $i => $part) { $parts[$i] = trim($part, " \r\n\t"); } return trim(implode(' ', $parts), " \r\n\t"); } } hamcrest-php/hamcrest/Hamcrest/FeatureMatcher.php000064400000003711150364331700016127 0ustar00featureValueOf() in a subclass to pull out the feature to be * matched against. */ abstract class FeatureMatcher extends TypeSafeDiagnosingMatcher { private $_subMatcher; private $_featureDescription; private $_featureName; /** * Constructor. * * @param string $type * @param string $subtype * @param \Hamcrest\Matcher $subMatcher The matcher to apply to the feature * @param string $featureDescription Descriptive text to use in describeTo * @param string $featureName Identifying text for mismatch message */ public function __construct($type, $subtype, Matcher $subMatcher, $featureDescription, $featureName) { parent::__construct($type, $subtype); $this->_subMatcher = $subMatcher; $this->_featureDescription = $featureDescription; $this->_featureName = $featureName; } /** * Implement this to extract the interesting feature. * * @param mixed $actual the target object * * @return mixed the feature to be matched */ abstract protected function featureValueOf($actual); public function matchesSafelyWithDiagnosticDescription($actual, Description $mismatchDescription) { $featureValue = $this->featureValueOf($actual); if (!$this->_subMatcher->matches($featureValue)) { $mismatchDescription->appendText($this->_featureName) ->appendText(' was ')->appendValue($featureValue); return false; } return true; } final public function describeTo(Description $description) { $description->appendText($this->_featureDescription)->appendText(' ') ->appendDescriptionOf($this->_subMatcher) ; } } hamcrest-php/hamcrest/Hamcrest/SelfDescribing.php000064400000001027150364331700016111 0ustar00_value = $value; } public function describeTo(Description $description) { $description->appendValue($this->_value); } } hamcrest-php/hamcrest/Hamcrest/Core/Set.php000064400000004550150364331700014655 0ustar00 * assertThat(array('a', 'b'), set('b')); * assertThat($foo, set('bar')); * assertThat('Server', notSet('defaultPort')); * * * @todo Replace $property with a matcher and iterate all property names. */ class Set extends BaseMatcher { private $_property; private $_not; public function __construct($property, $not = false) { $this->_property = $property; $this->_not = $not; } public function matches($item) { if ($item === null) { return false; } $property = $this->_property; if (is_array($item)) { $result = isset($item[$property]); } elseif (is_object($item)) { $result = isset($item->$property); } elseif (is_string($item)) { $result = isset($item::$$property); } else { throw new \InvalidArgumentException('Must pass an object, array, or class name'); } return $this->_not ? !$result : $result; } public function describeTo(Description $description) { $description->appendText($this->_not ? 'unset property ' : 'set property ')->appendText($this->_property); } public function describeMismatch($item, Description $description) { $value = ''; if (!$this->_not) { $description->appendText('was not set'); } else { $property = $this->_property; if (is_array($item)) { $value = $item[$property]; } elseif (is_object($item)) { $value = $item->$property; } elseif (is_string($item)) { $value = $item::$$property; } parent::describeMismatch($value, $description); } } /** * Matches if value (class, object, or array) has named $property. * * @factory */ public static function set($property) { return new self($property); } /** * Matches if value (class, object, or array) does not have named $property. * * @factory */ public static function notSet($property) { return new self($property, true); } } hamcrest-php/hamcrest/Hamcrest/Core/AnyOf.php000064400000002356150364331700015140 0ustar00true. */ class AnyOf extends ShortcutCombination { public function __construct(array $matchers) { parent::__construct($matchers); } public function matches($item) { return $this->matchesWithShortcut($item, true); } public function describeTo(Description $description) { $this->describeToWithOperator($description, 'or'); } /** * Evaluates to true if ANY of the passed in matchers evaluate to true. * * @factory ... */ public static function anyOf(/* args... */) { $args = func_get_args(); return new self(Util::createMatcherArray($args)); } /** * Evaluates to false if ANY of the passed in matchers evaluate to true. * * @factory ... */ public static function noneOf(/* args... */) { $args = func_get_args(); return IsNot::not( new self(Util::createMatcherArray($args)) ); } } hamcrest-php/hamcrest/Hamcrest/Core/IsIdentical.php000064400000001304150364331700016304 0ustar00_value = $value; } public function describeTo(Description $description) { $description->appendValue($this->_value); } /** * Tests of the value is identical to $value as tested by the "===" operator. * * @factory */ public static function identicalTo($value) { return new self($value); } } hamcrest-php/hamcrest/Hamcrest/Core/IsNot.php000064400000001472150364331700015156 0ustar00_matcher = $matcher; } public function matches($arg) { return !$this->_matcher->matches($arg); } public function describeTo(Description $description) { $description->appendText('not ')->appendDescriptionOf($this->_matcher); } /** * Matches if value does not match $value. * * @factory */ public static function not($value) { return new self(Util::wrapValueWithIsEqual($value)); } } hamcrest-php/hamcrest/Hamcrest/Core/IsTypeOf.php000064400000003221150364331700015616 0ustar00_theType = strtolower($theType); } public function matches($item) { return strtolower(gettype($item)) == $this->_theType; } public function describeTo(Description $description) { $description->appendText(self::getTypeDescription($this->_theType)); } public function describeMismatch($item, Description $description) { if ($item === null) { $description->appendText('was null'); } else { $description->appendText('was ') ->appendText(self::getTypeDescription(strtolower(gettype($item)))) ->appendText(' ') ->appendValue($item) ; } } public static function getTypeDescription($type) { if ($type == 'null') { return 'null'; } return (strpos('aeiou', substr($type, 0, 1)) === false ? 'a ' : 'an ') . $type; } /** * Is the value a particular built-in type? * * @factory */ public static function typeOf($theType) { return new self($theType); } } hamcrest-php/hamcrest/Hamcrest/Core/CombinableMatcher.php000064400000003365150364331700017464 0ustar00_matcher = $matcher; } public function matches($item) { return $this->_matcher->matches($item); } public function describeTo(Description $description) { $description->appendDescriptionOf($this->_matcher); } /** Diversion from Hamcrest-Java... Logical "and" not permitted */ public function andAlso(Matcher $other) { return new self(new AllOf($this->_templatedListWith($other))); } /** Diversion from Hamcrest-Java... Logical "or" not permitted */ public function orElse(Matcher $other) { return new self(new AnyOf($this->_templatedListWith($other))); } /** * This is useful for fluently combining matchers that must both pass. * For example: *
     *   assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
     * 
* * @factory */ public static function both(Matcher $matcher) { return new self($matcher); } /** * This is useful for fluently combining matchers where either may pass, * for example: *
     *   assertThat($string, either(containsString("a"))->orElse(containsString("b")));
     * 
* * @factory */ public static function either(Matcher $matcher) { return new self($matcher); } // -- Private Methods private function _templatedListWith(Matcher $other) { return array($this->_matcher, $other); } } hamcrest-php/hamcrest/Hamcrest/Core/Is.php000064400000002513150364331700014472 0ustar00_matcher = $matcher; } public function matches($arg) { return $this->_matcher->matches($arg); } public function describeTo(Description $description) { $description->appendText('is ')->appendDescriptionOf($this->_matcher); } public function describeMismatch($item, Description $mismatchDescription) { $this->_matcher->describeMismatch($item, $mismatchDescription); } /** * Decorates another Matcher, retaining the behavior but allowing tests * to be slightly more expressive. * * For example: assertThat($cheese, equalTo($smelly)) * vs. assertThat($cheese, is(equalTo($smelly))) * * @factory */ public static function is($value) { return new self(Util::wrapValueWithIsEqual($value)); } } hamcrest-php/hamcrest/Hamcrest/Core/IsSame.php000064400000002106150364331700015276 0ustar00_object = $object; } public function matches($object) { return ($object === $this->_object) && ($this->_object === $object); } public function describeTo(Description $description) { $description->appendText('sameInstance(') ->appendValue($this->_object) ->appendText(')') ; } /** * Creates a new instance of IsSame. * * @param mixed $object * The predicate evaluates to true only when the argument is * this object. * * @return \Hamcrest\Core\IsSame * @factory */ public static function sameInstance($object) { return new self($object); } } hamcrest-php/hamcrest/Hamcrest/Core/HasToString.php000064400000002371150364331700016326 0ustar00toString(); } return (string) $actual; } /** * Does array size satisfy a given matcher? * * @factory */ public static function hasToString($matcher) { return new self(Util::wrapValueWithIsEqual($matcher)); } } hamcrest-php/hamcrest/Hamcrest/Core/ShortcutCombination.php000064400000001630150364331700020114 0ustar00 */ private $_matchers; public function __construct(array $matchers) { Util::checkAllAreMatchers($matchers); $this->_matchers = $matchers; } protected function matchesWithShortcut($item, $shortcut) { /** @var $matcher \Hamcrest\Matcher */ foreach ($this->_matchers as $matcher) { if ($matcher->matches($item) == $shortcut) { return $shortcut; } } return !$shortcut; } public function describeToWithOperator(Description $description, $operator) { $description->appendList('(', ' ' . $operator . ' ', ')', $this->_matchers); } } hamcrest-php/hamcrest/Hamcrest/Core/IsCollectionContaining.php000064400000004154150364331700020523 0ustar00_elementMatcher = $elementMatcher; } protected function matchesSafely($items) { foreach ($items as $item) { if ($this->_elementMatcher->matches($item)) { return true; } } return false; } protected function describeMismatchSafely($items, Description $mismatchDescription) { $mismatchDescription->appendText('was ')->appendValue($items); } public function describeTo(Description $description) { $description ->appendText('a collection containing ') ->appendDescriptionOf($this->_elementMatcher) ; } /** * Test if the value is an array containing this matcher. * * Example: *
     * assertThat(array('a', 'b'), hasItem(equalTo('b')));
     * //Convenience defaults to equalTo()
     * assertThat(array('a', 'b'), hasItem('b'));
     * 
* * @factory ... */ public static function hasItem() { $args = func_get_args(); $firstArg = array_shift($args); return new self(Util::wrapValueWithIsEqual($firstArg)); } /** * Test if the value is an array containing elements that match all of these * matchers. * * Example: *
     * assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
     * 
* * @factory ... */ public static function hasItems(/* args... */) { $args = func_get_args(); $matchers = array(); foreach ($args as $arg) { $matchers[] = self::hasItem($arg); } return AllOf::allOf($matchers); } } hamcrest-php/hamcrest/Hamcrest/Core/IsInstanceOf.php000064400000003250150364331700016443 0ustar00_theClass = $theClass; } protected function matchesWithDiagnosticDescription($item, Description $mismatchDescription) { if (!is_object($item)) { $mismatchDescription->appendText('was ')->appendValue($item); return false; } if (!($item instanceof $this->_theClass)) { $mismatchDescription->appendText('[' . get_class($item) . '] ') ->appendValue($item); return false; } return true; } public function describeTo(Description $description) { $description->appendText('an instance of ') ->appendText($this->_theClass) ; } /** * Is the value an instance of a particular type? * This version assumes no relationship between the required type and * the signature of the method that sets it up, for example in * assertThat($anObject, anInstanceOf('Thing')); * * @factory any */ public static function anInstanceOf($theClass) { return new self($theClass); } } hamcrest-php/hamcrest/Hamcrest/Core/AllOf.php000064400000002654150364331700015122 0ustar00false. */ class AllOf extends DiagnosingMatcher { private $_matchers; public function __construct(array $matchers) { Util::checkAllAreMatchers($matchers); $this->_matchers = $matchers; } public function matchesWithDiagnosticDescription($item, Description $mismatchDescription) { /** @var $matcher \Hamcrest\Matcher */ foreach ($this->_matchers as $matcher) { if (!$matcher->matches($item)) { $mismatchDescription->appendDescriptionOf($matcher)->appendText(' '); $matcher->describeMismatch($item, $mismatchDescription); return false; } } return true; } public function describeTo(Description $description) { $description->appendList('(', ' and ', ')', $this->_matchers); } /** * Evaluates to true only if ALL of the passed in matchers evaluate to true. * * @factory ... */ public static function allOf(/* args... */) { $args = func_get_args(); return new self(Util::createMatcherArray($args)); } } hamcrest-php/hamcrest/Hamcrest/Core/IsNull.php000064400000001720150364331700015324 0ustar00appendText('null'); } /** * Matches if value is null. * * @factory */ public static function nullValue() { if (!self::$_INSTANCE) { self::$_INSTANCE = new self(); } return self::$_INSTANCE; } /** * Matches if value is not null. * * @factory */ public static function notNullValue() { if (!self::$_NOT_INSTANCE) { self::$_NOT_INSTANCE = IsNot::not(self::nullValue()); } return self::$_NOT_INSTANCE; } } hamcrest-php/hamcrest/Hamcrest/Core/IsAnything.php000064400000001553150364331700016177 0ustar00true. */ class IsAnything extends BaseMatcher { private $_message; public function __construct($message = 'ANYTHING') { $this->_message = $message; } public function matches($item) { return true; } public function describeTo(Description $description) { $description->appendText($this->_message); } /** * This matcher always evaluates to true. * * @param string $description A meaningful string used when describing itself. * * @return \Hamcrest\Core\IsAnything * @factory */ public static function anything($description = 'ANYTHING') { return new self($description); } } hamcrest-php/hamcrest/Hamcrest/Core/IsEqual.php000064400000001503150364331700015460 0ustar00_item = $item; } public function matches($arg) { return (($arg == $this->_item) && ($this->_item == $arg)); } public function describeTo(Description $description) { $description->appendValue($this->_item); } /** * Is the value equal to another value, as tested by the use of the "==" * comparison operator? * * @factory */ public static function equalTo($item) { return new self($item); } } hamcrest-php/hamcrest/Hamcrest/Core/Every.php000064400000002472150364331700015215 0ustar00_matcher = $matcher; } protected function matchesSafelyWithDiagnosticDescription($items, Description $mismatchDescription) { foreach ($items as $item) { if (!$this->_matcher->matches($item)) { $mismatchDescription->appendText('an item '); $this->_matcher->describeMismatch($item, $mismatchDescription); return false; } } return true; } public function describeTo(Description $description) { $description->appendText('every item is ')->appendDescriptionOf($this->_matcher); } /** * @param Matcher $itemMatcher * A matcher to apply to every element in an array. * * @return \Hamcrest\Core\Every * Evaluates to TRUE for a collection in which every item matches $itemMatcher * * @factory */ public static function everyItem(Matcher $itemMatcher) { return new self($itemMatcher); } } hamcrest-php/hamcrest/Hamcrest/Core/DescribedAs.php000064400000003471150364331700016273 0ustar00_descriptionTemplate = $descriptionTemplate; $this->_matcher = $matcher; $this->_values = $values; } public function matches($item) { return $this->_matcher->matches($item); } public function describeTo(Description $description) { $textStart = 0; while (preg_match(self::ARG_PATTERN, $this->_descriptionTemplate, $matches, PREG_OFFSET_CAPTURE, $textStart)) { $text = $matches[0][0]; $index = $matches[1][0]; $offset = $matches[0][1]; $description->appendText(substr($this->_descriptionTemplate, $textStart, $offset - $textStart)); $description->appendValue($this->_values[$index]); $textStart = $offset + strlen($text); } if ($textStart < strlen($this->_descriptionTemplate)) { $description->appendText(substr($this->_descriptionTemplate, $textStart)); } } /** * Wraps an existing matcher and overrides the description when it fails. * * @factory ... */ public static function describedAs(/* $description, Hamcrest\Matcher $matcher, $values... */) { $args = func_get_args(); $description = array_shift($args); $matcher = array_shift($args); $values = $args; return new self($description, $matcher, $values); } } hamcrest-php/hamcrest/Hamcrest/DiagnosingMatcher.php000064400000001133150364331700016612 0ustar00matchesWithDiagnosticDescription($item, new NullDescription()); } public function describeMismatch($item, Description $mismatchDescription) { $this->matchesWithDiagnosticDescription($item, $mismatchDescription); } abstract protected function matchesWithDiagnosticDescription($item, Description $mismatchDescription); } hamcrest-php/hamcrest/Hamcrest/Matcher.php000064400000003133150364331700014611 0ustar00 * Matcher implementations should NOT directly implement this interface. * Instead, extend the {@link Hamcrest\BaseMatcher} abstract class, * which will ensure that the Matcher API can grow to support * new features and remain compatible with all Matcher implementations. *

* For easy access to common Matcher implementations, use the static factory * methods in {@link Hamcrest\CoreMatchers}. * * @see Hamcrest\CoreMatchers * @see Hamcrest\BaseMatcher */ interface Matcher extends SelfDescribing { /** * Evaluates the matcher for argument $item. * * @param mixed $item the object against which the matcher is evaluated. * * @return boolean true if $item matches, * otherwise false. * * @see Hamcrest\BaseMatcher */ public function matches($item); /** * Generate a description of why the matcher has not accepted the item. * The description will be part of a larger description of why a matching * failed, so it should be concise. * This method assumes that matches($item) is false, but * will not check this. * * @param mixed $item The item that the Matcher has rejected. * @param Description $description * @return */ public function describeMismatch($item, Description $description); } hamcrest-php/hamcrest/Hamcrest/Description.php000064400000003230150364331700015507 0ustar00_value = $value; $this->_minCompare = $minCompare; $this->_maxCompare = $maxCompare; } protected function matchesSafely($other) { $compare = $this->_compare($this->_value, $other); return ($this->_minCompare <= $compare) && ($compare <= $this->_maxCompare); } protected function describeMismatchSafely($item, Description $mismatchDescription) { $mismatchDescription ->appendValue($item)->appendText(' was ') ->appendText($this->_comparison($this->_compare($this->_value, $item))) ->appendText(' ')->appendValue($this->_value) ; } public function describeTo(Description $description) { $description->appendText('a value ') ->appendText($this->_comparison($this->_minCompare)) ; if ($this->_minCompare != $this->_maxCompare) { $description->appendText(' or ') ->appendText($this->_comparison($this->_maxCompare)) ; } $description->appendText(' ')->appendValue($this->_value); } /** * The value is not > $value, nor < $value. * * @factory */ public static function comparesEqualTo($value) { return new self($value, 0, 0); } /** * The value is > $value. * * @factory */ public static function greaterThan($value) { return new self($value, -1, -1); } /** * The value is >= $value. * * @factory atLeast */ public static function greaterThanOrEqualTo($value) { return new self($value, -1, 0); } /** * The value is < $value. * * @factory */ public static function lessThan($value) { return new self($value, 1, 1); } /** * The value is <= $value. * * @factory atMost */ public static function lessThanOrEqualTo($value) { return new self($value, 0, 1); } // -- Private Methods private function _compare($left, $right) { $a = $left; $b = $right; if ($a < $b) { return -1; } elseif ($a == $b) { return 0; } else { return 1; } } private function _comparison($compare) { if ($compare > 0) { return 'less than'; } elseif ($compare == 0) { return 'equal to'; } else { return 'greater than'; } } } hamcrest-php/hamcrest/Hamcrest/Number/IsCloseTo.php000064400000003233150364331700016323 0ustar00_value = $value; $this->_delta = $delta; } protected function matchesSafely($item) { return $this->_actualDelta($item) <= 0.0; } protected function describeMismatchSafely($item, Description $mismatchDescription) { $mismatchDescription->appendValue($item) ->appendText(' differed by ') ->appendValue($this->_actualDelta($item)) ; } public function describeTo(Description $description) { $description->appendText('a numeric value within ') ->appendValue($this->_delta) ->appendText(' of ') ->appendValue($this->_value) ; } /** * Matches if value is a number equal to $value within some range of * acceptable error $delta. * * @factory */ public static function closeTo($value, $delta) { return new self($value, $delta); } // -- Private Methods private function _actualDelta($item) { return (abs(($item - $this->_value)) - $this->_delta); } } hamcrest-php/hamcrest/Hamcrest/Util.php000064400000004021150364331700014140 0ustar00 all items are */ public static function createMatcherArray(array $items) { //Extract single array item if (count($items) == 1 && is_array($items[0])) { $items = $items[0]; } //Replace non-matchers foreach ($items as &$item) { if (!($item instanceof Matcher)) { $item = Core\IsEqual::equalTo($item); } } return $items; } } hamcrest-php/hamcrest/Hamcrest/Type/IsString.php000064400000000735150364331700015716 0ustar00isHexadecimal($item)) { return true; } return is_numeric($item); } /** * Return if the string passed is a valid hexadecimal number. * This check is necessary because PHP 7 doesn't recognize hexadecimal string as numeric anymore. * * @param mixed $item * @return boolean */ private function isHexadecimal($item) { if (is_string($item) && preg_match('/^0x(.*)$/', $item, $matches)) { return ctype_xdigit($matches[1]); } return false; } /** * Is the value a numeric? * * @factory */ public static function numericValue() { return new self; } } hamcrest-php/hamcrest/Hamcrest/Type/IsScalar.php000064400000001100150364331700015640 0ustar00_out = (string) $out; } public function __toString() { return $this->_out; } /** * Return the description of a {@link Hamcrest\SelfDescribing} object as a * String. * * @param \Hamcrest\SelfDescribing $selfDescribing * The object to be described. * * @return string * The description of the object. */ public static function toString(SelfDescribing $selfDescribing) { $self = new self(); return (string) $self->appendDescriptionOf($selfDescribing); } /** * Alias for {@link toString()}. */ public static function asString(SelfDescribing $selfDescribing) { return self::toString($selfDescribing); } // -- Protected Methods protected function append($str) { $this->_out .= $str; } } hamcrest-php/hamcrest/Hamcrest/AssertionError.php000064400000000167150364331700016213 0ustar00append($text); return $this; } public function appendDescriptionOf(SelfDescribing $value) { $value->describeTo($this); return $this; } public function appendValue($value) { if (is_null($value)) { $this->append('null'); } elseif (is_string($value)) { $this->_toPhpSyntax($value); } elseif (is_float($value)) { $this->append('<'); $this->append($value); $this->append('F>'); } elseif (is_bool($value)) { $this->append('<'); $this->append($value ? 'true' : 'false'); $this->append('>'); } elseif (is_array($value) || $value instanceof \Iterator || $value instanceof \IteratorAggregate) { $this->appendValueList('[', ', ', ']', $value); } elseif (is_object($value) && !method_exists($value, '__toString')) { $this->append('<'); $this->append(get_class($value)); $this->append('>'); } else { $this->append('<'); $this->append($value); $this->append('>'); } return $this; } public function appendValueList($start, $separator, $end, $values) { $list = array(); foreach ($values as $v) { $list[] = new SelfDescribingValue($v); } $this->appendList($start, $separator, $end, $list); return $this; } public function appendList($start, $separator, $end, $values) { $this->append($start); $separate = false; foreach ($values as $value) { /*if (!($value instanceof Hamcrest\SelfDescribing)) { $value = new Hamcrest\Internal\SelfDescribingValue($value); }*/ if ($separate) { $this->append($separator); } $this->appendDescriptionOf($value); $separate = true; } $this->append($end); return $this; } // -- Protected Methods /** * Append the String $str to the description. */ abstract protected function append($str); // -- Private Methods private function _toPhpSyntax($value) { $str = '"'; for ($i = 0, $len = strlen($value); $i < $len; ++$i) { switch ($value[$i]) { case '"': $str .= '\\"'; break; case "\t": $str .= '\\t'; break; case "\r": $str .= '\\r'; break; case "\n": $str .= '\\n'; break; default: $str .= $value[$i]; } } $str .= '"'; $this->append($str); } } hamcrest-php/hamcrest/Hamcrest/Collection/IsEmptyTraversable.php000064400000002545150364331700021114 0ustar00_empty = $empty; } public function matches($item) { if (!$item instanceof \Traversable) { return false; } foreach ($item as $value) { return !$this->_empty; } return $this->_empty; } public function describeTo(Description $description) { $description->appendText($this->_empty ? 'an empty traversable' : 'a non-empty traversable'); } /** * Returns true if traversable is empty. * * @factory */ public static function emptyTraversable() { if (!self::$_INSTANCE) { self::$_INSTANCE = new self; } return self::$_INSTANCE; } /** * Returns true if traversable is not empty. * * @factory */ public static function nonEmptyTraversable() { if (!self::$_NOT_INSTANCE) { self::$_NOT_INSTANCE = new self(false); } return self::$_NOT_INSTANCE; } } hamcrest-php/hamcrest/Hamcrest/Collection/IsTraversableWithSize.php000064400000001633150364331700021561 0ustar00 * // With an identifier * assertThat("apple flavour", $apple->flavour(), equalTo("tasty")); * // Without an identifier * assertThat($apple->flavour(), equalTo("tasty")); * // Evaluating a boolean expression * assertThat("some error", $a > $b); * assertThat($a > $b); * */ public static function assertThat(/* $args ... */) { $args = func_get_args(); switch (count($args)) { case 1: self::$_count++; if (!$args[0]) { throw new AssertionError(); } break; case 2: self::$_count++; if ($args[1] instanceof Matcher) { self::doAssert('', $args[0], $args[1]); } elseif (!$args[1]) { throw new AssertionError($args[0]); } break; case 3: self::$_count++; self::doAssert( $args[0], $args[1], Util::wrapValueWithIsEqual($args[2]) ); break; default: throw new \InvalidArgumentException('assertThat() requires one to three arguments'); } } /** * Returns the number of assertions performed. * * @return int */ public static function getCount() { return self::$_count; } /** * Resets the number of assertions performed to zero. */ public static function resetCount() { self::$_count = 0; } /** * Performs the actual assertion logic. * * If $matcher doesn't match $actual, * throws a {@link Hamcrest\AssertionError} with a description * of the failure along with the optional $identifier. * * @param string $identifier added to the message upon failure * @param mixed $actual value to compare against $matcher * @param \Hamcrest\Matcher $matcher applied to $actual * @throws AssertionError */ private static function doAssert($identifier, $actual, Matcher $matcher) { if (!$matcher->matches($actual)) { $description = new StringDescription(); if (!empty($identifier)) { $description->appendText($identifier . PHP_EOL); } $description->appendText('Expected: ') ->appendDescriptionOf($matcher) ->appendText(PHP_EOL . ' but: '); $matcher->describeMismatch($actual, $description); throw new AssertionError((string) $description); } } } hamcrest-php/hamcrest/Hamcrest/TypeSafeMatcher.php000064400000005546150364331700016264 0ustar00_expectedType = $expectedType; $this->_expectedSubtype = $expectedSubtype; } final public function matches($item) { return $this->_isSafeType($item) && $this->matchesSafely($item); } final public function describeMismatch($item, Description $mismatchDescription) { if (!$this->_isSafeType($item)) { parent::describeMismatch($item, $mismatchDescription); } else { $this->describeMismatchSafely($item, $mismatchDescription); } } // -- Protected Methods /** * The item will already have been checked for the specific type and subtype. */ abstract protected function matchesSafely($item); /** * The item will already have been checked for the specific type and subtype. */ abstract protected function describeMismatchSafely($item, Description $mismatchDescription); // -- Private Methods private function _isSafeType($value) { switch ($this->_expectedType) { case self::TYPE_ANY: return true; case self::TYPE_STRING: return is_string($value) || is_numeric($value); case self::TYPE_NUMERIC: return is_numeric($value) || is_string($value); case self::TYPE_ARRAY: return is_array($value); case self::TYPE_OBJECT: return is_object($value) && ($this->_expectedSubtype === null || $value instanceof $this->_expectedSubtype); case self::TYPE_RESOURCE: return is_resource($value) && ($this->_expectedSubtype === null || get_resource_type($value) == $this->_expectedSubtype); case self::TYPE_BOOLEAN: return true; default: return true; } } } hamcrest-php/hamcrest/Hamcrest/BaseMatcher.php000064400000001065150364331700015406 0ustar00appendText('was ')->appendValue($item); } public function __toString() { return StringDescription::toString($this); } public function __invoke() { return call_user_func_array(array($this, 'matches'), func_get_args()); } } hamcrest-php/hamcrest/Hamcrest/NullDescription.php000064400000001273150364331700016347 0ustar00ignoringCase()); * Fixed Hamcrest_Core_IsInstanceOf to return false for native types. * Moved string-based matchers to Hamcrest_Text package. StringContains, StringEndsWith, StringStartsWith, and SubstringMatcher * Hamcrest.php and Hamcrest_Matchers.php are now built from @factory doctags. Added @factory doctag to every static factory method. * Hamcrest_Matchers and Hamcrest.php now import each matcher as-needed and Hamcrest.php calls the matchers directly instead of Hamcrest_Matchers. == Version 0.3.0: Released Jul 26 2010 == * Added running count to Hamcrest_MatcherAssert with methods to get and reset it. This can be used by unit testing frameworks for reporting. * Added Hamcrest_Core_HasToString to assert return value of toString() or __toString(). assertThat($anObject, hasToString('foo')); * Added Hamcrest_Type_IsScalar to assert is_scalar(). Matches values of type bool, int, float, double, and string. assertThat($count, scalarValue()); assertThat('foo', scalarValue()); * Added Hamcrest_Collection package. - IsEmptyTraversable - IsTraversableWithSize assertThat($iterator, emptyTraversable()); assertThat($iterator, traversableWithSize(5)); * Added Hamcrest_Xml_HasXPath to assert XPath expressions or the content of nodes in an XML/HTML DOM. assertThat($dom, hasXPath('books/book/title')); assertThat($dom, hasXPath('books/book[contains(title, "Alice")]', 3)); assertThat($dom, hasXPath('books/book/title', 'Alice in Wonderland')); assertThat($dom, hasXPath('count(books/book)', greaterThan(10))); * Added aliases to match the Java API. hasEntry() -> hasKeyValuePair() hasValue() -> hasItemInArray() contains() -> arrayContaining() containsInAnyOrder() -> arrayContainingInAnyOrder() * Added optional subtype to Hamcrest_TypeSafeMatcher to enforce object class or resource type. * Hamcrest_TypeSafeDiagnosingMatcher now extends Hamcrest_TypeSafeMatcher. == Version 0.2.0: Released Jul 14 2010 == Issues Fixed: 109, 111, 114, 115 * Description::appendValues() and appendValueList() accept Iterator and IteratorAggregate. [111] BaseDescription::appendValue() handles IteratorAggregate. * assertThat() accepts a single boolean parameter and wraps any non-Matcher third parameter with equalTo(). * Removed null return value from assertThat(). [114] * Fixed wrong variable name in contains(). [109] * Added Hamcrest_Core_IsSet to assert isset(). assertThat(array('foo' => 'bar'), set('foo')); assertThat(array('foo' => 'bar'), notSet('bar')); * Added Hamcrest_Core_IsTypeOf to assert built-in types with gettype(). [115] Types: array, boolean, double, integer, null, object, resource, and string. Note that gettype() returns "double" for float values. assertThat($count, typeOf('integer')); assertThat(3.14159, typeOf('double')); assertThat(array('foo', 'bar'), typeOf('array')); assertThat(new stdClass(), typeOf('object')); * Added type-specific matchers in new Hamcrest_Type package. - IsArray - IsBoolean - IsDouble (includes float values) - IsInteger - IsObject - IsResource - IsString assertThat($count, integerValue()); assertThat(3.14159, floatValue()); assertThat('foo', stringValue()); * Added Hamcrest_Type_IsNumeric to assert is_numeric(). Matches values of type int and float/double or strings that are formatted as numbers. assertThat(5, numericValue()); assertThat('-5e+3', numericValue()); * Added Hamcrest_Type_IsCallable to assert is_callable(). assertThat('preg_match', callable()); assertThat(array('SomeClass', 'SomeMethod'), callable()); assertThat(array($object, 'SomeMethod'), callable()); assertThat($object, callable()); assertThat(function ($x, $y) { return $x + $y; }, callable()); * Added Hamcrest_Text_MatchesPattern for regex matching with preg_match(). assertThat('foobar', matchesPattern('/o+b/')); * Added aliases: - atLeast() for greaterThanOrEqualTo() - atMost() for lessThanOrEqualTo() == Version 0.1.0: Released Jul 7 2010 == * Created PEAR package * Core matchers hamcrest-php/.gitignore000064400000000025150364331700011126 0ustar00composer.lock vendor