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 ); } } MatcherAssertTest.php 0000644 00000016275 15052465105 0010700 0 ustar 00 getMessage()); } 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'); } } } InvokedMatcherTest.php 0000644 00000001143 15052465105 0011022 0 ustar 00 matchAgainst = $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')); } } BaseMatcherTest.php 0000644 00000001027 15052465105 0010276 0 ustar 00 appendText('SOME DESCRIPTION'); } public function testDescribesItselfWithToStringMethod() { $someMatcher = new \Hamcrest\SomeMatcher(); $this->assertEquals('SOME DESCRIPTION', (string) $someMatcher); } } StringDescriptionTest.php 0000644 00000012526 15052465105 0011600 0 ustar 00 _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('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);
}
Text/MatchesPattern.php 0000644 00000001353 15052465116 0011132 0 ustar 00 _substring, (string) $item) >= 1;
}
protected function relationship()
{
return 'matching';
}
}
Text/StringContainsIgnoringCase.php 0000644 00000001452 15052465116 0013446 0 ustar 00 _substring));
}
protected function relationship()
{
return 'containing in any case';
}
}
Text/StringContains.php 0000644 00000001522 15052465116 0011153 0 ustar 00 _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';
}
}
Text/IsEqualIgnoringWhiteSpace.php 0000644 00000003071 15052465116 0013224 0 ustar 00 _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");
}
}
Text/SubstringMatcher.php 0000644 00000002107 15052465116 0011472 0 ustar 00 _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();
}
Text/IsEqualIgnoringCase.php 0000644 00000002270 15052465116 0012043 0 ustar 00 _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);
}
}
Text/StringEndsWith.php 0000644 00000001363 15052465116 0011125 0 ustar 00 _substring))) === $this->_substring);
}
protected function relationship()
{
return 'ending with';
}
}
Text/IsEmptyString.php 0000644 00000003434 15052465116 0010773 0 ustar 00 _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;
}
}
Text/StringStartsWith.php 0000644 00000001366 15052465116 0011517 0 ustar 00 _substring)) === $this->_substring);
}
protected function relationship()
{
return 'starting with';
}
}
Text/StringContainsInOrder.php 0000644 00000003035 15052465116 0012437 0 ustar 00 _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);
}
}
NullDescription.php 0000644 00000001273 15052465116 0010403 0 ustar 00 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;
}
}
StringDescription.php 0000644 00000002143 15052465116 0010734 0 ustar 00 _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;
}
}
Xml/HasXPath.php 0000644 00000013747 15052465116 0007516 0 ustar 00 _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));
}
}
BaseMatcher.php 0000644 00000001065 15052465116 0007442 0 ustar 00 appendText('was ')->appendValue($item);
}
public function __toString()
{
return StringDescription::toString($this);
}
public function __invoke()
{
return call_user_func_array(array($this, 'matches'), func_get_args());
}
}
TypeSafeDiagnosingMatcher.php 0000644 00000001511 15052465116 0012307 0 ustar 00 matchesSafelyWithDiagnosticDescription($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);
}
Arrays/IsArrayContainingKeyValuePair.php 0000644 00000004323 15052465116 0014373 0 ustar 00 _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)
);
}
}
Arrays/MatchingOnce.php 0000644 00000003126 15052465116 0011064 0 ustar 00 _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;
}
}
Arrays/IsArrayWithSize.php 0000644 00000002715 15052465116 0011571 0 ustar 00 _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 ']';
}
}
Arrays/IsArrayContaining.php 0000644 00000002731 15052465116 0012112 0 ustar 00 _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));
}
}
Arrays/SeriesMatchingOnce.php 0000644 00000003454 15052465116 0012243 0 ustar 00 _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);
}
}
Arrays/IsArrayContainingInAnyOrder.php 0000644 00000002732 15052465116 0014046 0 ustar 00 _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));
}
}
Arrays/IsArrayContainingKey.php 0000644 00000003654 15052465116 0012570 0 ustar 00 _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));
}
}
Arrays/IsArrayContainingInOrder.php 0000644 00000002560 15052465116 0013375 0 ustar 00 _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));
}
}
BaseDescription.php 0000644 00000006153 15052465116 0010345 0 ustar 00 append($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);
}
}
Collection/IsTraversableWithSize.php 0000644 00000001633 15052465116 0013615 0 ustar 00 _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;
}
}
Core/IsNot.php 0000644 00000001472 15052465116 0007212 0 ustar 00 _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));
}
}
Core/Every.php 0000644 00000002472 15052465116 0007251 0 ustar 00 _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);
}
}
Core/IsTypeOf.php 0000644 00000003221 15052465116 0007652 0 ustar 00 _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);
}
}
Core/AnyOf.php 0000644 00000002356 15052465116 0007174 0 ustar 00 true.
*/
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))
);
}
}
Core/CombinableMatcher.php 0000644 00000003365 15052465116 0011520 0 ustar 00 _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);
}
}
Core/IsEqual.php 0000644 00000001503 15052465116 0007514 0 ustar 00 _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);
}
}
Core/IsCollectionContaining.php 0000644 00000004154 15052465116 0012557 0 ustar 00 _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);
}
}
Core/HasToString.php 0000644 00000002371 15052465116 0010362 0 ustar 00 toString();
}
return (string) $actual;
}
/**
* Does array size satisfy a given matcher?
*
* @factory
*/
public static function hasToString($matcher)
{
return new self(Util::wrapValueWithIsEqual($matcher));
}
}
Core/ShortcutCombination.php 0000644 00000001630 15052465116 0012150 0 ustar 00
*/
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);
}
}
Core/IsInstanceOf.php 0000644 00000003250 15052465116 0010477 0 ustar 00 _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);
}
}
Core/AllOf.php 0000644 00000002654 15052465116 0007156 0 ustar 00 false.
*/
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));
}
}
Core/IsIdentical.php 0000644 00000001304 15052465116 0010340 0 ustar 00 _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);
}
}
Core/Is.php 0000644 00000002513 15052465116 0006526 0 ustar 00 _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));
}
}
Core/Set.php 0000644 00000004550 15052465116 0006711 0 ustar 00
* 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);
}
}
Core/IsAnything.php 0000644 00000001553 15052465116 0010233 0 ustar 00 true.
*/
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);
}
}
Core/IsNull.php 0000644 00000001720 15052465116 0007360 0 ustar 00 appendText('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;
}
}
Core/IsSame.php 0000644 00000002106 15052465116 0007332 0 ustar 00 _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);
}
}
Core/DescribedAs.php 0000644 00000003471 15052465116 0010327 0 ustar 00 _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);
}
}
Number/OrderingComparison.php 0000644 00000005545 15052465116 0012327 0 ustar 00 _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';
}
}
}
Number/IsCloseTo.php 0000644 00000003233 15052465116 0010357 0 ustar 00 _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);
}
}
TypeSafeMatcher.php 0000644 00000005546 15052465116 0010320 0 ustar 00 _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;
}
}
}
Internal/SelfDescribingValue.php 0000644 00000000742 15052465116 0012721 0 ustar 00 _value = $value;
}
public function describeTo(Description $description)
{
$description->appendValue($this->_value);
}
}
SelfDescribing.php 0000644 00000001027 15052465116 0010145 0 ustar 00 matchesWithDiagnosticDescription($item, new NullDescription());
}
public function describeMismatch($item, Description $mismatchDescription)
{
$this->matchesWithDiagnosticDescription($item, $mismatchDescription);
}
abstract protected function matchesWithDiagnosticDescription($item, Description $mismatchDescription);
}
MatcherAssert.php 0000644 00000006473 15052465116 0010041 0 ustar 00
* // 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);
}
}
}
Matchers.php 0000644 00000045021 15052465116 0007032 0 ustar 00
* 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);
}
}