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 ); } } PK @Z R R + hamcrest-php/tests/Hamcrest/Core/IsTest.phpnu [ assertMatches(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
* //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
);
}
}
PK @Zݬ 1 hamcrest-php/generator/parts/matchers_imports.txtnu [
namespace Hamcrest;PK @Z 2 hamcrest-php/generator/parts/functions_imports.txtnu [ PK @ZZ; 0 hamcrest-php/generator/parts/matchers_footer.txtnu [ }
PK @Zc]W; ; hamcrest-php/generator/run.phpnu [ addFactoryFile(new StaticMethodFile(STATIC_MATCHERS_FILE));
$generator->addFactoryFile(new GlobalFunctionFile(GLOBAL_FUNCTIONS_FILE));
$generator->generate();
$generator->write();
PK @ZO6 - hamcrest-php/generator/GlobalFunctionFile.phpnu [ functions = '';
}
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;
}
}
PK @Z
y> & hamcrest-php/generator/FactoryFile.phpnu [ file = $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);
}
}
PK @Z<5 ? hamcrest-php/hamcrest/Hamcrest/Internal/SelfDescribingValue.phpnu [ _value = $value;
}
public function describeTo(Description $description)
{
$description->appendValue($this->_value);
}
}
PK @ZByu[ [ 4 hamcrest-php/hamcrest/Hamcrest/DiagnosingMatcher.phpnu [ matchesWithDiagnosticDescription($item, new NullDescription());
}
public function describeMismatch($item, Description $mismatchDescription)
{
$this->matchesWithDiagnosticDescription($item, $mismatchDescription);
}
abstract protected function matchesWithDiagnosticDescription($item, Description $mismatchDescription);
}
PK @Z} ' hamcrest-php/hamcrest/Hamcrest/Util.phpnu [ 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;
}
}
PK @ZOk k 2 hamcrest-php/hamcrest/Hamcrest/BaseDescription.phpnu [ 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);
}
}
PK @ZDOMDocument 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));
}
}
PK @Zٞ 0 hamcrest-php/hamcrest/Hamcrest/Core/IsTypeOf.phpnu [ _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);
}
}
PK @ZB{h h + hamcrest-php/hamcrest/Hamcrest/Core/Set.phpnu [
* 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);
}
}
PK @Z"'Q ; hamcrest-php/hamcrest/Hamcrest/Core/ShortcutCombination.phpnu [
*/
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);
}
}
PK @Z: : - hamcrest-php/hamcrest/Hamcrest/Core/IsNot.phpnu [ _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));
}
}
PK @Z3j< - hamcrest-php/hamcrest/Hamcrest/Core/AllOf.phpnu [ 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));
}
}
PK @Zb
C C / hamcrest-php/hamcrest/Hamcrest/Core/IsEqual.phpnu [ _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);
}
}
PK @Z'
: : - hamcrest-php/hamcrest/Hamcrest/Core/Every.phpnu [ _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);
}
}
PK @Z+M{K K * hamcrest-php/hamcrest/Hamcrest/Core/Is.phpnu [ _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));
}
}
PK @Z&wl l > hamcrest-php/hamcrest/Hamcrest/Core/IsCollectionContaining.phpnu [ _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);
}
}
PK @Z._ . hamcrest-php/hamcrest/Hamcrest/Core/IsNull.phpnu [ 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;
}
}
PK @Z7F F . hamcrest-php/hamcrest/Hamcrest/Core/IsSame.phpnu [ _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);
}
}
PK @Z 3 hamcrest-php/hamcrest/Hamcrest/Core/HasToString.phpnu [ toString();
}
return (string) $actual;
}
/**
* Does array size satisfy a given matcher?
*
* @factory
*/
public static function hasToString($matcher)
{
return new self(Util::wrapValueWithIsEqual($matcher));
}
}
PK @ZZb. - hamcrest-php/hamcrest/Hamcrest/Core/AnyOf.phpnu [ 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))
);
}
}
PK @ZT@9 9 3 hamcrest-php/hamcrest/Hamcrest/Core/DescribedAs.phpnu [ _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);
}
}
PK @ZF 9 hamcrest-php/hamcrest/Hamcrest/Core/CombinableMatcher.phpnu [ _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);
}
}
PK @ZUң 4 hamcrest-php/hamcrest/Hamcrest/Core/IsInstanceOf.phpnu [ _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);
}
}
PK @Zn1 3 hamcrest-php/hamcrest/Hamcrest/Core/IsIdentical.phpnu [ _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);
}
}
PK @ZGYk k 2 hamcrest-php/hamcrest/Hamcrest/Core/IsAnything.phpnu [ 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);
}
}
PK @Z̥h 1 hamcrest-php/hamcrest/Hamcrest/SelfDescribing.phpnu [ 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());
}
}
PK @Zv6J J + hamcrest-php/hamcrest/Hamcrest/Matchers.phpnu [
* 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);
}
}
PK @Z!u 1 hamcrest-php/hamcrest/Hamcrest/Type/IsBoolean.phpnu [ isHexadecimal($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;
}
}
PK @Z:a 0 hamcrest-php/hamcrest/Hamcrest/Type/IsString.phpnu [ _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';
}
}
}
PK @Z ׳i 3 hamcrest-php/hamcrest/Hamcrest/Number/IsCloseTo.phpnu [ _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);
}
}
PK @Z [ [ * hamcrest-php/hamcrest/Hamcrest/Matcher.phpnu [
* 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);
}
PK @ZF4w w 1 hamcrest-php/hamcrest/Hamcrest/AssertionError.phpnu [ _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;
}
}
PK @Zr|sp . hamcrest-php/hamcrest/Hamcrest/Description.phpnu [ featureValueOf() 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)
;
}
}
PK @ZR 2 hamcrest-php/hamcrest/Hamcrest/NullDescription.phpnu [ 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);
}
PK @Z=w;
;
0 hamcrest-php/hamcrest/Hamcrest/MatcherAssert.phpnu [
* // 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);
}
}
}
PK @ZOމR R 6 hamcrest-php/hamcrest/Hamcrest/Text/StringContains.phpnu [ _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';
}
}
PK @Zzw 6 hamcrest-php/hamcrest/Hamcrest/Text/StringEndsWith.phpnu [ _substring))) === $this->_substring);
}
protected function relationship()
{
return 'ending with';
}
}
PK @Zx x 6 hamcrest-php/hamcrest/Hamcrest/Text/MatchesPattern.phpnu [ _substring, (string) $item) >= 1;
}
protected function relationship()
{
return 'matching';
}
}
PK @Zav* * B hamcrest-php/hamcrest/Hamcrest/Text/StringContainsIgnoringCase.phpnu [ _substring));
}
protected function relationship()
{
return 'containing in any case';
}
}
PK @Z3 ; hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringCase.phpnu [ _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);
}
}
PK @Z~j 8 hamcrest-php/hamcrest/Hamcrest/Text/StringStartsWith.phpnu [ _substring)) === $this->_substring);
}
protected function relationship()
{
return 'starting with';
}
}
PK @ZG G 8 hamcrest-php/hamcrest/Hamcrest/Text/SubstringMatcher.phpnu [ _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();
}
PK @Z|[ = hamcrest-php/hamcrest/Hamcrest/Text/StringContainsInOrder.phpnu [ _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);
}
}
PK @Z 5 hamcrest-php/hamcrest/Hamcrest/Text/IsEmptyString.phpnu [ _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;
}
}
PK @Z<9 9 A hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringWhiteSpace.phpnu [ _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");
}
}
PK @ZMf f 2 hamcrest-php/hamcrest/Hamcrest/TypeSafeMatcher.phpnu [ _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;
}
}
}
PK @Z sp p B hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInOrder.phpnu [ _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));
}
}
PK @Z` 9 hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayWithSize.phpnu [ _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);
}
}
PK @Z21X > hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKey.phpnu [ _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));
}
}
PK @ZΆ E hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInAnyOrder.phpnu [ _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));
}
}
PK @Zt 1 hamcrest-php/hamcrest/Hamcrest/Arrays/IsArray.phpnu [ _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 ']';
}
}
PK @ZQ*V V 6 hamcrest-php/hamcrest/Hamcrest/Arrays/MatchingOnce.phpnu [ _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;
}
}
PK @Zh ; hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContaining.phpnu [ _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));
}
}
PK @Z! G hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKeyValuePair.phpnu [ _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)
);
}
}
PK @Zc c 4 hamcrest-php/hamcrest/Hamcrest/StringDescription.phpnu [ _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;
}
}
PK @Z(_iT iT " hamcrest-php/hamcrest/Hamcrest.phpnu [
* //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);
}
}
PK @Z旯 hamcrest-php/.gush.ymlnu [ PK @ZL hamcrest-php/.gitignorenu [ PK @Z=֦ Z hamcrest-php/composer.jsonnu [ PK @Z?J 0 J hamcrest-php/tests/Hamcrest/Xml/HasXPathTest.phpnu [ PK @Z R R + hamcrest-php/tests/Hamcrest/Core/IsTest.phpnu [ PK @ZER~ ~ , ? hamcrest-php/tests/Hamcrest/Core/SetTest.phpnu [ PK @Z
'93B B . * hamcrest-php/tests/Hamcrest/Core/EveryTest.phpnu [ PK @Z6 3 - hamcrest-php/tests/Hamcrest/Core/IsAnythingTest.phpnu [ PK @Zną> > 4 0 hamcrest-php/tests/Hamcrest/Core/HasToStringTest.phpnu [ PK @Z4 / j: hamcrest-php/tests/Hamcrest/Core/IsNullTest.phpnu [ PK @Z@S F
F
? < hamcrest-php/tests/Hamcrest/Core/IsCollectionContainingTest.phpnu [ PK @Z 4 bG hamcrest-php/tests/Hamcrest/Core/IsIdenticalTest.phpnu [ PK @Zȟ . J hamcrest-php/tests/Hamcrest/Core/AnyOfTest.phpnu [ PK @Zl
0 T hamcrest-php/tests/Hamcrest/Core/IsEqualTest.phpnu [ PK @Z* . _ hamcrest-php/tests/Hamcrest/Core/AllOfTest.phpnu [ PK @ZMY : kf hamcrest-php/tests/Hamcrest/Core/CombinableMatcherTest.phpnu [ PK @Z)/` ` 3 m hamcrest-php/tests/Hamcrest/Core/SampleSubClass.phpnu [ PK @Zo3H. . 5 n hamcrest-php/tests/Hamcrest/Core/IsInstanceOfTest.phpnu [ PK @Z#u / v hamcrest-php/tests/Hamcrest/Core/IsSameTest.phpnu [ PK @ZOp / / 4 y hamcrest-php/tests/Hamcrest/Core/DescribedAsTest.phpnu [ PK @ZR 1 %~ hamcrest-php/tests/Hamcrest/Core/IsTypeOfTest.phpnu [ PK @Zw . O hamcrest-php/tests/Hamcrest/Core/IsNotTest.phpnu [ PK @Z/o 4 hamcrest-php/tests/Hamcrest/Core/SampleBaseClass.phpnu [ PK @ZO!U 3 މ hamcrest-php/tests/Hamcrest/AbstractMatcherTest.phpnu [ PK @ZLzr r 1 hamcrest-php/tests/Hamcrest/Type/IsScalarTest.phpnu [ PK @Z$ 1 hamcrest-php/tests/Hamcrest/Type/IsDoubleTest.phpnu [ PK @Z 1 hamcrest-php/tests/Hamcrest/Type/IsObjectTest.phpnu [ PK @Ze+a8 8 2 hamcrest-php/tests/Hamcrest/Type/IsNumericTest.phpnu [ PK @Zv 2 . hamcrest-php/tests/Hamcrest/Type/IsIntegerTest.phpnu [ PK @ZtĚ 3 i hamcrest-php/tests/Hamcrest/Type/IsResourceTest.phpnu [ PK @Zv^
3 f hamcrest-php/tests/Hamcrest/Type/IsCallableTest.phpnu [ PK @ZHٷ 2 ȹ hamcrest-php/tests/Hamcrest/Type/IsBooleanTest.phpnu [ PK @Z2X 0 hamcrest-php/tests/Hamcrest/Type/IsArrayTest.phpnu [ PK @Z
VJ 1 hamcrest-php/tests/Hamcrest/Type/IsStringTest.phpnu [ PK @ZmS 1 hamcrest-php/tests/Hamcrest/MatcherAssertTest.phpnu [ PK @Zd! ! 4 hamcrest-php/tests/Hamcrest/Number/IsCloseToTest.phpnu [ PK @Z_g6 = hamcrest-php/tests/Hamcrest/Number/OrderingComparisonTest.phpnu [ PK @ZJ}2V V 5 hamcrest-php/tests/Hamcrest/StringDescriptionTest.phpnu [ PK @Z/զZ Z D hamcrest-php/tests/Hamcrest/Collection/IsTraversableWithSizeTest.phpnu [ PK @ZDK K A { hamcrest-php/tests/Hamcrest/Collection/IsEmptyTraversableTest.phpnu [ PK @ZC^ 9 7 hamcrest-php/tests/Hamcrest/Array/IsArrayWithSizeTest.phpnu [ PK @Z> > > # hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyTest.phpnu [ PK @ZB$J J G hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyValuePairTest.phpnu [ PK @ZY B hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInOrderTest.phpnu [ PK @ZZbR ; % hamcrest-php/tests/Hamcrest/Array/IsArrayContainingTest.phpnu [ PK @Z3l E s* hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInAnyOrderTest.phpnu [ PK @ZQ> 1 1 hamcrest-php/tests/Hamcrest/Array/IsArrayTest.phpnu [ PK @Z{F
F
( ; hamcrest-php/tests/Hamcrest/UtilTest.phpnu [ PK @Zpz / aF hamcrest-php/tests/Hamcrest/BaseMatcherTest.phpnu [ PK @Z4Їc c 2 H hamcrest-php/tests/Hamcrest/InvokedMatcherTest.phpnu [ PK @Z* n n B K hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringWhiteSpaceTest.phpnu [ PK @Zg۽Z
Z
7 |Q hamcrest-php/tests/Hamcrest/Text/StringContainsTest.phpnu [ PK @Z¹ C =\ hamcrest-php/tests/Hamcrest/Text/StringContainsIgnoringCaseTest.phpnu [ PK @Z4 > if hamcrest-php/tests/Hamcrest/Text/StringContainsInOrderTest.phpnu [ PK @Z/Y 6 k hamcrest-php/tests/Hamcrest/Text/IsEmptyStringTest.phpnu [ PK @Z=[ [ 7 u hamcrest-php/tests/Hamcrest/Text/MatchesPatternTest.phpnu [ PK @Za(j j 7 x hamcrest-php/tests/Hamcrest/Text/StringEndsWithTest.phpnu [ PK @ZB u u 9 hamcrest-php/tests/Hamcrest/Text/StringStartsWithTest.phpnu [ PK @ZO+| | < hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringCaseTest.phpnu [ PK @ZD:} } 2 t hamcrest-php/tests/Hamcrest/FeatureMatcherTest.phpnu [ PK @Zk k # S hamcrest-php/tests/phpunit.xml.distnu [ PK @Z_e hamcrest-php/tests/bootstrap.phpnu [ PK @Z;c| | = hamcrest-php/.travis.ymlnu [ PK @Z [ hamcrest-php/LICENSE.txtnu [ PK @ZC* * hamcrest-php/README.mdnu [ PK @Z; hamcrest-php/.coveralls.ymlnu [ PK @Z^* * c hamcrest-php/CHANGES.txtnu [ PK @Zw w ( hamcrest-php/.github/workflows/tests.ymlnu [ PK @Z5t
+ hamcrest-php/generator/FactoryParameter.phpnu [ PK @Z L ( hamcrest-php/generator/FactoryMethod.phpnu [ PK @Z{֬ + 6 hamcrest-php/generator/FactoryGenerator.phpnu [ PK @Z8j j ' E hamcrest-php/generator/FactoryClass.phpnu [ PK @ZSȴ + hamcrest-php/generator/StaticMethodFile.phpnu [ PK @Zk3c c & f hamcrest-php/generator/FactoryCall.phpnu [ PK @Z;V V 0 ! hamcrest-php/generator/parts/matchers_header.txtnu [ PK @Z| x x , ! hamcrest-php/generator/parts/file_header.txtnu [ PK @Z 1 " hamcrest-php/generator/parts/functions_footer.txtnu [ PK @Z > 1
# hamcrest-php/generator/parts/functions_header.txtnu [ PK @Zݬ 1 % hamcrest-php/generator/parts/matchers_imports.txtnu [ PK @Z 2 n& hamcrest-php/generator/parts/functions_imports.txtnu [ PK @ZZ; 0 & hamcrest-php/generator/parts/matchers_footer.txtnu [ PK @Zc]W; ; 2' hamcrest-php/generator/run.phpnu [ PK @ZO6 - + hamcrest-php/generator/GlobalFunctionFile.phpnu [ PK @Z
y> & / hamcrest-php/generator/FactoryFile.phpnu [ PK @Z<5 ? ; hamcrest-php/hamcrest/Hamcrest/Internal/SelfDescribingValue.phpnu [ PK @ZByu[ [ 4 1> hamcrest-php/hamcrest/Hamcrest/DiagnosingMatcher.phpnu [ PK @Z} ' @ hamcrest-php/hamcrest/Hamcrest/Util.phpnu [ PK @ZOk k 2 XI hamcrest-php/hamcrest/Hamcrest/BaseDescription.phpnu [ PK @Z