/home/mip/mip/public/vendor/laravel-filemanager/files/folder-1/821668/hamcrest.zip
PK �8]f%
� � # hamcrest-php/tests/phpunit.xml.distnu �Iw�� <phpunit backupGlobals="false"
backupStaticAttributes="false"
bootstrap="bootstrap.php"
colors="false"
convertErrorsToExceptions="true"
convertNoticesToExceptions="true"
convertWarningsToExceptions="true"
processIsolation="false"
stopOnFailure="false"
syntaxCheck="false">
<testsuites>
<testsuite name="hamcrest-php">
<directory suffix="Test.php">.</directory>
</testsuite>
</testsuites>
<filter>
<whitelist addUncoveredFilesFromWhitelist="true">
<directory suffix=".php">../hamcrest</directory>
</whitelist>
</filter>
</phpunit>
PK �8]��6� � hamcrest-php/tests/bootstrap.phpnu �Iw�� <?php
error_reporting(E_ALL | E_STRICT);
require __DIR__ . '/../vendor/autoload.php';
if (defined('E_DEPRECATED')) {
error_reporting(error_reporting() | E_DEPRECATED);
}
define('HAMCREST_TEST_BASE', realpath(dirname(__FILE__)));
define('HAMCREST_BASE', realpath(dirname(dirname(__FILE__))));
set_include_path(implode(PATH_SEPARATOR, array(
HAMCREST_TEST_BASE,
HAMCREST_BASE . '/hamcrest',
get_include_path()
)));
require_once 'Hamcrest.php';
PK �8]�L �8
8
( hamcrest-php/tests/Hamcrest/UtilTest.phpnu �Iw�� <?php
namespace Hamcrest;
class UtilTest extends \PhpUnit_Framework_TestCase
{
public function testWrapValueWithIsEqualLeavesMatchersUntouched()
{
$matcher = new \Hamcrest\Text\MatchesPattern('/fo+/');
$newMatcher = \Hamcrest\Util::wrapValueWithIsEqual($matcher);
$this->assertSame($matcher, $newMatcher);
}
public function testWrapValueWithIsEqualWrapsPrimitive()
{
$matcher = \Hamcrest\Util::wrapValueWithIsEqual('foo');
$this->assertInstanceOf('Hamcrest\Core\IsEqual', $matcher);
$this->assertTrue($matcher->matches('foo'));
}
public function testCheckAllAreMatchersAcceptsMatchers()
{
\Hamcrest\Util::checkAllAreMatchers(array(
new \Hamcrest\Text\MatchesPattern('/fo+/'),
new \Hamcrest\Core\IsEqual('foo'),
));
}
/**
* @expectedException InvalidArgumentException
*/
public function testCheckAllAreMatchersFailsForPrimitive()
{
\Hamcrest\Util::checkAllAreMatchers(array(
new \Hamcrest\Text\MatchesPattern('/fo+/'),
'foo',
));
}
private function callAndAssertCreateMatcherArray($items)
{
$matchers = \Hamcrest\Util::createMatcherArray($items);
$this->assertInternalType('array', $matchers);
$this->assertSameSize($items, $matchers);
foreach ($matchers as $matcher) {
$this->assertInstanceOf('\Hamcrest\Matcher', $matcher);
}
return $matchers;
}
public function testCreateMatcherArrayLeavesMatchersUntouched()
{
$matcher = new \Hamcrest\Text\MatchesPattern('/fo+/');
$items = array($matcher);
$matchers = $this->callAndAssertCreateMatcherArray($items);
$this->assertSame($matcher, $matchers[0]);
}
public function testCreateMatcherArrayWrapsPrimitiveWithIsEqualMatcher()
{
$matchers = $this->callAndAssertCreateMatcherArray(array('foo'));
$this->assertInstanceOf('Hamcrest\Core\IsEqual', $matchers[0]);
$this->assertTrue($matchers[0]->matches('foo'));
}
public function testCreateMatcherArrayDoesntModifyOriginalArray()
{
$items = array('foo');
$this->callAndAssertCreateMatcherArray($items);
$this->assertSame('foo', $items[0]);
}
public function testCreateMatcherArrayUnwrapsSingleArrayElement()
{
$matchers = $this->callAndAssertCreateMatcherArray(array(array('foo')));
$this->assertInstanceOf('Hamcrest\Core\IsEqual', $matchers[0]);
$this->assertTrue($matchers[0]->matches('foo'));
}
}
PK �8]ną> > 4 hamcrest-php/tests/Hamcrest/Core/HasToStringTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class PhpForm
{
public function __toString()
{
return 'php';
}
}
class JavaForm
{
public function toString()
{
return 'java';
}
}
class BothForms
{
public function __toString()
{
return 'php';
}
public function toString()
{
return 'java';
}
}
class HasToStringTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\HasToString::hasToString('foo');
}
public function testMatchesWhenToStringMatches()
{
$this->assertMatches(
hasToString(equalTo('php')),
new \Hamcrest\Core\PhpForm(),
'correct __toString'
);
$this->assertMatches(
hasToString(equalTo('java')),
new \Hamcrest\Core\JavaForm(),
'correct toString'
);
}
public function testPicksJavaOverPhpToString()
{
$this->assertMatches(
hasToString(equalTo('java')),
new \Hamcrest\Core\BothForms(),
'correct toString'
);
}
public function testDoesNotMatchWhenToStringDoesNotMatch()
{
$this->assertDoesNotMatch(
hasToString(equalTo('mismatch')),
new \Hamcrest\Core\PhpForm(),
'incorrect __toString'
);
$this->assertDoesNotMatch(
hasToString(equalTo('mismatch')),
new \Hamcrest\Core\JavaForm(),
'incorrect toString'
);
$this->assertDoesNotMatch(
hasToString(equalTo('mismatch')),
new \Hamcrest\Core\BothForms(),
'incorrect __toString'
);
}
public function testDoesNotMatchNull()
{
$this->assertDoesNotMatch(
hasToString(equalTo('a')),
null,
'should not match null'
);
}
public function testProvidesConvenientShortcutForTraversableWithSizeEqualTo()
{
$this->assertMatches(
hasToString(equalTo('php')),
new \Hamcrest\Core\PhpForm(),
'correct __toString'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription(
'an object with toString() "php"',
hasToString(equalTo('php'))
);
}
}
PK �8]��ȟ � . hamcrest-php/tests/Hamcrest/Core/AnyOfTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class AnyOfTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\AnyOf::anyOf('irrelevant');
}
public function testAnyOfEvaluatesToTheLogicalDisjunctionOfTwoOtherMatchers()
{
assertThat('good', anyOf('bad', 'good'));
assertThat('good', anyOf('good', 'good'));
assertThat('good', anyOf('good', 'bad'));
assertThat('good', not(anyOf('bad', startsWith('b'))));
}
public function testAnyOfEvaluatesToTheLogicalDisjunctionOfManyOtherMatchers()
{
assertThat('good', anyOf('bad', 'good', 'bad', 'bad', 'bad'));
assertThat('good', not(anyOf('bad', 'bad', 'bad', 'bad', 'bad')));
}
public function testAnyOfSupportsMixedTypes()
{
$combined = anyOf(
equalTo(new \Hamcrest\Core\SampleBaseClass('good')),
equalTo(new \Hamcrest\Core\SampleBaseClass('ugly')),
equalTo(new \Hamcrest\Core\SampleSubClass('good'))
);
assertThat(new \Hamcrest\Core\SampleSubClass('good'), $combined);
}
public function testAnyOfHasAReadableDescription()
{
$this->assertDescription(
'("good" or "bad" or "ugly")',
anyOf('good', 'bad', 'ugly')
);
}
public function testNoneOfEvaluatesToTheLogicalDisjunctionOfTwoOtherMatchers()
{
assertThat('good', not(noneOf('bad', 'good')));
assertThat('good', not(noneOf('good', 'good')));
assertThat('good', not(noneOf('good', 'bad')));
assertThat('good', noneOf('bad', startsWith('b')));
}
public function testNoneOfEvaluatesToTheLogicalDisjunctionOfManyOtherMatchers()
{
assertThat('good', not(noneOf('bad', 'good', 'bad', 'bad', 'bad')));
assertThat('good', noneOf('bad', 'bad', 'bad', 'bad', 'bad'));
}
public function testNoneOfSupportsMixedTypes()
{
$combined = noneOf(
equalTo(new \Hamcrest\Core\SampleBaseClass('good')),
equalTo(new \Hamcrest\Core\SampleBaseClass('ugly')),
equalTo(new \Hamcrest\Core\SampleSubClass('good'))
);
assertThat(new \Hamcrest\Core\SampleSubClass('bad'), $combined);
}
public function testNoneOfHasAReadableDescription()
{
$this->assertDescription(
'not ("good" or "bad" or "ugly")',
noneOf('good', 'bad', 'ugly')
);
}
}
PK �8]�/�o� � 4 hamcrest-php/tests/Hamcrest/Core/SampleBaseClass.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class SampleBaseClass
{
private $_arg;
public function __construct($arg)
{
$this->_arg = $arg;
}
public function __toString()
{
return $this->_arg;
}
}
PK �8]Op� / / 4 hamcrest-php/tests/Hamcrest/Core/DescribedAsTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class DescribedAsTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\DescribedAs::describedAs('irrelevant', anything());
}
public function testOverridesDescriptionOfOtherMatcherWithThatPassedToConstructor()
{
$m1 = describedAs('m1 description', anything());
$m2 = describedAs('m2 description', not(anything()));
$this->assertDescription('m1 description', $m1);
$this->assertDescription('m2 description', $m2);
}
public function testAppendsValuesToDescription()
{
$m = describedAs('value 1 = %0, value 2 = %1', anything(), 33, 97);
$this->assertDescription('value 1 = <33>, value 2 = <97>', $m);
}
public function testDelegatesMatchingToAnotherMatcher()
{
$m1 = describedAs('irrelevant', anything());
$m2 = describedAs('irrelevant', not(anything()));
$this->assertTrue($m1->matches(new \stdClass()));
$this->assertFalse($m2->matches('hi'));
}
}
PK �8]e���� � : hamcrest-php/tests/Hamcrest/Core/CombinableMatcherTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class CombinableMatcherTest extends \Hamcrest\AbstractMatcherTest
{
private $_either_3_or_4;
private $_not_3_and_not_4;
public function setUp()
{
$this->_either_3_or_4 = \Hamcrest\Core\CombinableMatcher::either(equalTo(3))->orElse(equalTo(4));
$this->_not_3_and_not_4 = \Hamcrest\Core\CombinableMatcher::both(not(equalTo(3)))->andAlso(not(equalTo(4)));
}
protected function createMatcher()
{
return \Hamcrest\Core\CombinableMatcher::either(equalTo('irrelevant'))->orElse(equalTo('ignored'));
}
public function testBothAcceptsAndRejects()
{
assertThat(2, $this->_not_3_and_not_4);
assertThat(3, not($this->_not_3_and_not_4));
}
public function testAcceptsAndRejectsThreeAnds()
{
$tripleAnd = $this->_not_3_and_not_4->andAlso(equalTo(2));
assertThat(2, $tripleAnd);
assertThat(3, not($tripleAnd));
}
public function testBothDescribesItself()
{
$this->assertEquals('(not <3> and not <4>)', (string) $this->_not_3_and_not_4);
$this->assertMismatchDescription('was <3>', $this->_not_3_and_not_4, 3);
}
public function testEitherAcceptsAndRejects()
{
assertThat(3, $this->_either_3_or_4);
assertThat(6, not($this->_either_3_or_4));
}
public function testAcceptsAndRejectsThreeOrs()
{
$orTriple = $this->_either_3_or_4->orElse(greaterThan(10));
assertThat(11, $orTriple);
assertThat(9, not($orTriple));
}
public function testEitherDescribesItself()
{
$this->assertEquals('(<3> or <4>)', (string) $this->_either_3_or_4);
$this->assertMismatchDescription('was <6>', $this->_either_3_or_4, 6);
}
}
PK �8]@S �F
F
? hamcrest-php/tests/Hamcrest/Core/IsCollectionContainingTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsCollectionContainingTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsCollectionContaining::hasItem(equalTo('irrelevant'));
}
public function testMatchesACollectionThatContainsAnElementMatchingTheGivenMatcher()
{
$itemMatcher = hasItem(equalTo('a'));
$this->assertMatches(
$itemMatcher,
array('a', 'b', 'c'),
"should match list that contains 'a'"
);
}
public function testDoesNotMatchCollectionThatDoesntContainAnElementMatchingTheGivenMatcher()
{
$matcher1 = hasItem(equalTo('a'));
$this->assertDoesNotMatch(
$matcher1,
array('b', 'c'),
"should not match list that doesn't contain 'a'"
);
$matcher2 = hasItem(equalTo('a'));
$this->assertDoesNotMatch(
$matcher2,
array(),
'should not match the empty list'
);
}
public function testDoesNotMatchNull()
{
$this->assertDoesNotMatch(
hasItem(equalTo('a')),
null,
'should not match null'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription('a collection containing "a"', hasItem(equalTo('a')));
}
public function testMatchesAllItemsInCollection()
{
$matcher1 = hasItems(equalTo('a'), equalTo('b'), equalTo('c'));
$this->assertMatches(
$matcher1,
array('a', 'b', 'c'),
'should match list containing all items'
);
$matcher2 = hasItems('a', 'b', 'c');
$this->assertMatches(
$matcher2,
array('a', 'b', 'c'),
'should match list containing all items (without matchers)'
);
$matcher3 = hasItems(equalTo('a'), equalTo('b'), equalTo('c'));
$this->assertMatches(
$matcher3,
array('c', 'b', 'a'),
'should match list containing all items in any order'
);
$matcher4 = hasItems(equalTo('a'), equalTo('b'), equalTo('c'));
$this->assertMatches(
$matcher4,
array('e', 'c', 'b', 'a', 'd'),
'should match list containing all items plus others'
);
$matcher5 = hasItems(equalTo('a'), equalTo('b'), equalTo('c'));
$this->assertDoesNotMatch(
$matcher5,
array('e', 'c', 'b', 'd'), // 'a' missing
'should not match list unless it contains all items'
);
}
}
PK �8]� ��R R + hamcrest-php/tests/Hamcrest/Core/IsTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\Is::is('something');
}
public function testJustMatchesTheSameWayTheUnderylingMatcherDoes()
{
$this->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 <true>', is(equalTo(true)));
}
public function testProvidesConvenientShortcutForIsEqualTo()
{
$this->assertMatches(is('A'), 'A', 'should match');
$this->assertMatches(is('B'), 'B', 'should match');
$this->assertDoesNotMatch(is('A'), 'B', 'should not match');
$this->assertDoesNotMatch(is('B'), 'A', 'should not match');
$this->assertDescription('is "A"', is('A'));
}
}
PK �8]�)�/` ` 3 hamcrest-php/tests/Hamcrest/Core/SampleSubClass.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class SampleSubClass extends \Hamcrest\Core\SampleBaseClass
{
}
PK �8]��4�� � / hamcrest-php/tests/Hamcrest/Core/IsNullTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsNullTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsNull::nullValue();
}
public function testEvaluatesToTrueIfArgumentIsNull()
{
assertThat(null, nullValue());
assertThat(self::ANY_NON_NULL_ARGUMENT, not(nullValue()));
assertThat(self::ANY_NON_NULL_ARGUMENT, notNullValue());
assertThat(null, not(notNullValue()));
}
}
PK �8]��� 4 hamcrest-php/tests/Hamcrest/Core/IsIdenticalTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsIdenticalTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsIdentical::identicalTo('irrelevant');
}
public function testEvaluatesToTrueIfArgumentIsReferenceToASpecifiedObject()
{
$o1 = new \stdClass();
$o2 = new \stdClass();
assertThat($o1, identicalTo($o1));
assertThat($o2, not(identicalTo($o1)));
}
public function testReturnsReadableDescriptionFromToString()
{
$this->assertDescription('"ARG"', identicalTo('ARG'));
}
public function testReturnsReadableDescriptionFromToStringWhenInitialisedWithNull()
{
$this->assertDescription('null', identicalTo(null));
}
}
PK �8]���w� � . hamcrest-php/tests/Hamcrest/Core/IsNotTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsNotTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsNot::not('something');
}
public function testEvaluatesToTheTheLogicalNegationOfAnotherMatcher()
{
$this->assertMatches(not(equalTo('A')), 'B', 'should match');
$this->assertDoesNotMatch(not(equalTo('B')), 'B', 'should not match');
}
public function testProvidesConvenientShortcutForNotEqualTo()
{
$this->assertMatches(not('A'), 'B', 'should match');
$this->assertMatches(not('B'), 'A', 'should match');
$this->assertDoesNotMatch(not('A'), 'A', 'should not match');
$this->assertDoesNotMatch(not('B'), 'B', 'should not match');
}
public function testUsesDescriptionOfNegatedMatcherWithPrefix()
{
$this->assertDescription('not a value greater than <2>', not(greaterThan(2)));
$this->assertDescription('not "A"', not('A'));
}
}
PK �8]�l���
�
0 hamcrest-php/tests/Hamcrest/Core/IsEqualTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class DummyToStringClass
{
private $_arg;
public function __construct($arg)
{
$this->_arg = $arg;
}
public function __toString()
{
return $this->_arg;
}
}
class IsEqualTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsEqual::equalTo('irrelevant');
}
public function testComparesObjectsUsingEqualityOperator()
{
assertThat("hi", equalTo("hi"));
assertThat("bye", not(equalTo("hi")));
assertThat(1, equalTo(1));
assertThat(1, not(equalTo(2)));
assertThat("2", equalTo(2));
}
public function testCanCompareNullValues()
{
assertThat(null, equalTo(null));
assertThat(null, not(equalTo('hi')));
assertThat('hi', not(equalTo(null)));
}
public function testComparesTheElementsOfAnArray()
{
$s1 = array('a', 'b');
$s2 = array('a', 'b');
$s3 = array('c', 'd');
$s4 = array('a', 'b', 'c', 'd');
assertThat($s1, equalTo($s1));
assertThat($s2, equalTo($s1));
assertThat($s3, not(equalTo($s1)));
assertThat($s4, not(equalTo($s1)));
}
public function testComparesTheElementsOfAnArrayOfPrimitiveTypes()
{
$i1 = array(1, 2);
$i2 = array(1, 2);
$i3 = array(3, 4);
$i4 = array(1, 2, 3, 4);
assertThat($i1, equalTo($i1));
assertThat($i2, equalTo($i1));
assertThat($i3, not(equalTo($i1)));
assertThat($i4, not(equalTo($i1)));
}
public function testRecursivelyTestsElementsOfArrays()
{
$i1 = array(array(1, 2), array(3, 4));
$i2 = array(array(1, 2), array(3, 4));
$i3 = array(array(5, 6), array(7, 8));
$i4 = array(array(1, 2, 3, 4), array(3, 4));
assertThat($i1, equalTo($i1));
assertThat($i2, equalTo($i1));
assertThat($i3, not(equalTo($i1)));
assertThat($i4, not(equalTo($i1)));
}
public function testIncludesTheResultOfCallingToStringOnItsArgumentInTheDescription()
{
$argumentDescription = 'ARGUMENT DESCRIPTION';
$argument = new \Hamcrest\Core\DummyToStringClass($argumentDescription);
$this->assertDescription('<' . $argumentDescription . '>', equalTo($argument));
}
public function testReturnsAnObviousDescriptionIfCreatedWithANestedMatcherByMistake()
{
$innerMatcher = equalTo('NestedMatcher');
$this->assertDescription('<' . (string) $innerMatcher . '>', equalTo($innerMatcher));
}
public function testReturnsGoodDescriptionIfCreatedWithNullReference()
{
$this->assertDescription('null', equalTo(null));
}
}
PK �8]�#�u / hamcrest-php/tests/Hamcrest/Core/IsSameTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsSameTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsSame::sameInstance(new \stdClass());
}
public function testEvaluatesToTrueIfArgumentIsReferenceToASpecifiedObject()
{
$o1 = new \stdClass();
$o2 = new \stdClass();
assertThat($o1, sameInstance($o1));
assertThat($o2, not(sameInstance($o1)));
}
public function testReturnsReadableDescriptionFromToString()
{
$this->assertDescription('sameInstance("ARG")', sameInstance('ARG'));
}
public function testReturnsReadableDescriptionFromToStringWhenInitialisedWithNull()
{
$this->assertDescription('sameInstance(null)', sameInstance(null));
}
}
PK �8]�6 � � 3 hamcrest-php/tests/Hamcrest/Core/IsAnythingTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsAnythingTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsAnything::anything();
}
public function testAlwaysEvaluatesToTrue()
{
assertThat(null, anything());
assertThat(new \stdClass(), anything());
assertThat('hi', anything());
}
public function testHasUsefulDefaultDescription()
{
$this->assertDescription('ANYTHING', anything());
}
public function testCanOverrideDescription()
{
$description = 'description';
$this->assertDescription($description, anything($description));
}
}
PK �8]E��R~ ~ , hamcrest-php/tests/Hamcrest/Core/SetTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class SetTest extends \Hamcrest\AbstractMatcherTest
{
public static $_classProperty;
public $_instanceProperty;
protected function setUp()
{
self::$_classProperty = null;
unset($this->_instanceProperty);
}
protected function createMatcher()
{
return \Hamcrest\Core\Set::set('property_name');
}
public function testEvaluatesToTrueIfArrayPropertyIsSet()
{
assertThat(array('foo' => 'bar'), set('foo'));
}
public function testNegatedEvaluatesToFalseIfArrayPropertyIsSet()
{
assertThat(array('foo' => 'bar'), not(notSet('foo')));
}
public function testEvaluatesToTrueIfClassPropertyIsSet()
{
self::$_classProperty = 'bar';
assertThat('Hamcrest\Core\SetTest', set('_classProperty'));
}
public function testNegatedEvaluatesToFalseIfClassPropertyIsSet()
{
self::$_classProperty = 'bar';
assertThat('Hamcrest\Core\SetTest', not(notSet('_classProperty')));
}
public function testEvaluatesToTrueIfObjectPropertyIsSet()
{
$this->_instanceProperty = 'bar';
assertThat($this, set('_instanceProperty'));
}
public function testNegatedEvaluatesToFalseIfObjectPropertyIsSet()
{
$this->_instanceProperty = 'bar';
assertThat($this, not(notSet('_instanceProperty')));
}
public function testEvaluatesToFalseIfArrayPropertyIsNotSet()
{
assertThat(array('foo' => 'bar'), not(set('baz')));
}
public function testNegatedEvaluatesToTrueIfArrayPropertyIsNotSet()
{
assertThat(array('foo' => 'bar'), notSet('baz'));
}
public function testEvaluatesToFalseIfClassPropertyIsNotSet()
{
assertThat('Hamcrest\Core\SetTest', not(set('_classProperty')));
}
public function testNegatedEvaluatesToTrueIfClassPropertyIsNotSet()
{
assertThat('Hamcrest\Core\SetTest', notSet('_classProperty'));
}
public function testEvaluatesToFalseIfObjectPropertyIsNotSet()
{
assertThat($this, not(set('_instanceProperty')));
}
public function testNegatedEvaluatesToTrueIfObjectPropertyIsNotSet()
{
assertThat($this, notSet('_instanceProperty'));
}
public function testHasAReadableDescription()
{
$this->assertDescription('set property foo', set('foo'));
$this->assertDescription('unset property bar', notSet('bar'));
}
public function testDecribesPropertySettingInMismatchMessage()
{
$this->assertMismatchDescription(
'was not set',
set('bar'),
array('foo' => 'bar')
);
$this->assertMismatchDescription(
'was "bar"',
notSet('foo'),
array('foo' => 'bar')
);
self::$_classProperty = 'bar';
$this->assertMismatchDescription(
'was "bar"',
notSet('_classProperty'),
'Hamcrest\Core\SetTest'
);
$this->_instanceProperty = 'bar';
$this->assertMismatchDescription(
'was "bar"',
notSet('_instanceProperty'),
$this
);
}
}
PK �8]���I+ + 5 hamcrest-php/tests/Hamcrest/Core/IsInstanceOfTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsInstanceOfTest extends \Hamcrest\AbstractMatcherTest
{
private $_baseClassInstance;
private $_subClassInstance;
public function setUp()
{
$this->_baseClassInstance = new \Hamcrest\Core\SampleBaseClass('good');
$this->_subClassInstance = new \Hamcrest\Core\SampleSubClass('good');
}
protected function createMatcher()
{
return \Hamcrest\Core\IsInstanceOf::anInstanceOf('stdClass');
}
public function testEvaluatesToTrueIfArgumentIsInstanceOfASpecificClass()
{
assertThat($this->_baseClassInstance, anInstanceOf('Hamcrest\Core\SampleBaseClass'));
assertThat($this->_subClassInstance, anInstanceOf('Hamcrest\Core\SampleSubClass'));
assertThat(null, not(anInstanceOf('Hamcrest\Core\SampleBaseClass')));
assertThat(new \stdClass(), not(anInstanceOf('Hamcrest\Core\SampleBaseClass')));
}
public function testEvaluatesToFalseIfArgumentIsNotAnObject()
{
assertThat(null, not(anInstanceOf('Hamcrest\Core\SampleBaseClass')));
assertThat(false, not(anInstanceOf('Hamcrest\Core\SampleBaseClass')));
assertThat(5, not(anInstanceOf('Hamcrest\Core\SampleBaseClass')));
assertThat('foo', not(anInstanceOf('Hamcrest\Core\SampleBaseClass')));
assertThat(array(1, 2, 3), not(anInstanceOf('Hamcrest\Core\SampleBaseClass')));
}
public function testHasAReadableDescription()
{
$this->assertDescription('an instance of stdClass', anInstanceOf('stdClass'));
}
public function testDecribesActualClassInMismatchMessage()
{
$this->assertMismatchDescription(
'[Hamcrest\Core\SampleBaseClass] <good>',
anInstanceOf('Hamcrest\Core\SampleSubClass'),
$this->_baseClassInstance
);
}
}
PK �8]* . hamcrest-php/tests/Hamcrest/Core/AllOfTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class AllOfTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\AllOf::allOf('irrelevant');
}
public function testEvaluatesToTheLogicalConjunctionOfTwoOtherMatchers()
{
assertThat('good', allOf('good', 'good'));
assertThat('good', not(allOf('bad', 'good')));
assertThat('good', not(allOf('good', 'bad')));
assertThat('good', not(allOf('bad', 'bad')));
}
public function testEvaluatesToTheLogicalConjunctionOfManyOtherMatchers()
{
assertThat('good', allOf('good', 'good', 'good', 'good', 'good'));
assertThat('good', not(allOf('good', endsWith('d'), 'bad', 'good', 'good')));
}
public function testSupportsMixedTypes()
{
$all = allOf(
equalTo(new \Hamcrest\Core\SampleBaseClass('good')),
equalTo(new \Hamcrest\Core\SampleBaseClass('good')),
equalTo(new \Hamcrest\Core\SampleSubClass('ugly'))
);
$negated = not($all);
assertThat(new \Hamcrest\Core\SampleSubClass('good'), $negated);
}
public function testHasAReadableDescription()
{
$this->assertDescription(
'("good" and "bad" and "ugly")',
allOf('good', 'bad', 'ugly')
);
}
public function testMismatchDescriptionDescribesFirstFailingMatch()
{
$this->assertMismatchDescription(
'"good" was "bad"',
allOf('bad', 'good'),
'bad'
);
}
}
PK �8]
'93B B . hamcrest-php/tests/Hamcrest/Core/EveryTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class EveryTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\Every::everyItem(anything());
}
public function testIsTrueWhenEveryValueMatches()
{
assertThat(array('AaA', 'BaB', 'CaC'), everyItem(containsString('a')));
assertThat(array('AbA', 'BbB', 'CbC'), not(everyItem(containsString('a'))));
}
public function testIsAlwaysTrueForEmptyLists()
{
assertThat(array(), everyItem(containsString('a')));
}
public function testDescribesItself()
{
$each = everyItem(containsString('a'));
$this->assertEquals('every item is a string containing "a"', (string) $each);
$this->assertMismatchDescription('an item was "BbB"', $each, array('BbB'));
}
}
PK �8]��R�� � 1 hamcrest-php/tests/Hamcrest/Core/IsTypeOfTest.phpnu �Iw�� <?php
namespace Hamcrest\Core;
class IsTypeOfTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Core\IsTypeOf::typeOf('integer');
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(array('5', 5), typeOf('array'));
assertThat(false, typeOf('boolean'));
assertThat(5, typeOf('integer'));
assertThat(5.2, typeOf('double'));
assertThat(null, typeOf('null'));
assertThat(tmpfile(), typeOf('resource'));
assertThat('a string', typeOf('string'));
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(typeOf('array')));
assertThat(array('5', 5), not(typeOf('boolean')));
assertThat(5.2, not(typeOf('integer')));
assertThat(5, not(typeOf('double')));
assertThat(false, not(typeOf('null')));
assertThat('a string', not(typeOf('resource')));
assertThat(tmpfile(), not(typeOf('string')));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a double', typeOf('double'));
$this->assertDescription('an integer', typeOf('integer'));
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', typeOf('boolean'), null);
$this->assertMismatchDescription('was an integer <5>', typeOf('float'), 5);
}
}
PK �8]��
�E E 5 hamcrest-php/tests/Hamcrest/StringDescriptionTest.phpnu �Iw�� <?php
namespace Hamcrest;
class SampleSelfDescriber implements \Hamcrest\SelfDescribing
{
private $_text;
public function __construct($text)
{
$this->_text = $text;
}
public function describeTo(\Hamcrest\Description $description)
{
$description->appendText($this->_text);
}
}
class StringDescriptionTest extends \PhpUnit_Framework_TestCase
{
private $_description;
public 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('<stdClass>', (string) $this->_description);
}
public function testBooleanValuesCanBeAppended()
{
$this->_description->appendValue(false);
$this->assertEquals('<false>', (string) $this->_description);
}
public function testListsOfvaluesCanBeAppended()
{
$this->_description->appendValue(array('foo', 42.78));
$this->assertEquals('["foo", <42.78F>]', (string) $this->_description);
}
public function testIterableOfvaluesCanBeAppended()
{
$items = new \ArrayObject(array('foo', 42.78));
$this->_description->appendValue($items);
$this->assertEquals('["foo", <42.78F>]', (string) $this->_description);
}
public function testIteratorOfvaluesCanBeAppended()
{
$items = new \ArrayObject(array('foo', 42.78));
$this->_description->appendValue($items->getIterator());
$this->assertEquals('["foo", <42.78F>]', (string) $this->_description);
}
public function testListsOfvaluesCanBeAppendedManually()
{
$this->_description->appendValueList('@start@', '@sep@ ', '@end@', array('foo', 42.78));
$this->assertEquals('@start@"foo"@sep@ <42.78F>@end@', (string) $this->_description);
}
public function testIterableOfvaluesCanBeAppendedManually()
{
$items = new \ArrayObject(array('foo', 42.78));
$this->_description->appendValueList('@start@', '@sep@ ', '@end@', $items);
$this->assertEquals('@start@"foo"@sep@ <42.78F>@end@', (string) $this->_description);
}
public function testIteratorOfvaluesCanBeAppendedManually()
{
$items = new \ArrayObject(array('foo', 42.78));
$this->_description->appendValueList('@start@', '@sep@ ', '@end@', $items->getIterator());
$this->assertEquals('@start@"foo"@sep@ <42.78F>@end@', (string) $this->_description);
}
public function testSelfDescribingObjectsCanBeAppended()
{
$this->_description
->appendDescriptionOf(new \Hamcrest\SampleSelfDescriber('foo'))
->appendDescriptionOf(new \Hamcrest\SampleSelfDescriber('bar'))
;
$this->assertEquals('foobar', (string) $this->_description);
}
public function testSelfDescribingObjectsCanBeAppendedAsLists()
{
$this->_description->appendList('@start@', '@sep@ ', '@end@', array(
new \Hamcrest\SampleSelfDescriber('foo'),
new \Hamcrest\SampleSelfDescriber('bar')
));
$this->assertEquals('@start@foo@sep@ bar@end@', (string) $this->_description);
}
public function testSelfDescribingObjectsCanBeAppendedAsIteratedLists()
{
$items = new \ArrayObject(array(
new \Hamcrest\SampleSelfDescriber('foo'),
new \Hamcrest\SampleSelfDescriber('bar')
));
$this->_description->appendList('@start@', '@sep@ ', '@end@', $items);
$this->assertEquals('@start@foo@sep@ bar@end@', (string) $this->_description);
}
public function testSelfDescribingObjectsCanBeAppendedAsIterators()
{
$items = new \ArrayObject(array(
new \Hamcrest\SampleSelfDescriber('foo'),
new \Hamcrest\SampleSelfDescriber('bar')
));
$this->_description->appendList('@start@', '@sep@ ', '@end@', $items->getIterator());
$this->assertEquals('@start@foo@sep@ bar@end@', (string) $this->_description);
}
}
PK �8]�ob�z z 2 hamcrest-php/tests/Hamcrest/FeatureMatcherTest.phpnu �Iw�� <?php
namespace Hamcrest;
class Thingy
{
private $_result;
public function __construct($result)
{
$this->_result = $result;
}
public function getResult()
{
return $this->_result;
}
}
/* Test-specific subclass only */
class ResultMatcher extends \Hamcrest\FeatureMatcher
{
public function __construct()
{
parent::__construct(self::TYPE_ANY, null, equalTo('bar'), 'Thingy with result', 'result');
}
public function featureValueOf($actual)
{
if ($actual instanceof \Hamcrest\Thingy) {
return $actual->getResult();
}
}
}
class FeatureMatcherTest extends \Hamcrest\AbstractMatcherTest
{
private $_resultMatcher;
public function setUp()
{
$this->_resultMatcher = $this->_resultMatcher();
}
protected function createMatcher()
{
return $this->_resultMatcher();
}
public function testMatchesPartOfAnObject()
{
$this->assertMatches($this->_resultMatcher, new \Hamcrest\Thingy('bar'), 'feature');
$this->assertDescription('Thingy with result "bar"', $this->_resultMatcher);
}
public function testMismatchesPartOfAnObject()
{
$this->assertMismatchDescription(
'result was "foo"',
$this->_resultMatcher,
new \Hamcrest\Thingy('foo')
);
}
public function testDoesNotGenerateNoticesForNull()
{
$this->assertMismatchDescription('result was null', $this->_resultMatcher, null);
}
// -- Creation Methods
private function _resultMatcher()
{
return new \Hamcrest\ResultMatcher();
}
}
PK �8]_g�6� � = hamcrest-php/tests/Hamcrest/Number/OrderingComparisonTest.phpnu �Iw�� <?php
namespace Hamcrest\Number;
class OrderingComparisonTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Number\OrderingComparison::greaterThan(1);
}
public function testComparesValuesForGreaterThan()
{
assertThat(2, greaterThan(1));
assertThat(0, not(greaterThan(1)));
}
public function testComparesValuesForLessThan()
{
assertThat(2, lessThan(3));
assertThat(0, lessThan(1));
}
public function testComparesValuesForEquality()
{
assertThat(3, comparesEqualTo(3));
assertThat('aa', comparesEqualTo('aa'));
}
public function testAllowsForInclusiveComparisons()
{
assertThat(1, lessThanOrEqualTo(1));
assertThat(1, greaterThanOrEqualTo(1));
}
public function testSupportsDifferentTypesOfComparableValues()
{
assertThat(1.1, greaterThan(1.0));
assertThat("cc", greaterThan("bb"));
}
}
PK �8]�d��! ! 4 hamcrest-php/tests/Hamcrest/Number/IsCloseToTest.phpnu �Iw�� <?php
namespace Hamcrest\Number;
class IsCloseToTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
$irrelevant = 0.1;
return \Hamcrest\Number\IsCloseTo::closeTo($irrelevant, $irrelevant);
}
public function testEvaluatesToTrueIfArgumentIsEqualToADoubleValueWithinSomeError()
{
$p = closeTo(1.0, 0.5);
$this->assertTrue($p->matches(1.0));
$this->assertTrue($p->matches(0.5));
$this->assertTrue($p->matches(1.5));
$this->assertDoesNotMatch($p, 2.0, 'too large');
$this->assertMismatchDescription('<2F> differed by <0.5F>', $p, 2.0);
$this->assertDoesNotMatch($p, 0.0, 'number too small');
$this->assertMismatchDescription('<0F> differed by <0.5F>', $p, 0.0);
}
}
PK �8]�Hٷ � 2 hamcrest-php/tests/Hamcrest/Type/IsBooleanTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsBooleanTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsBoolean::booleanValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(false, booleanValue());
assertThat(true, booleanValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(array(), not(booleanValue()));
assertThat(5, not(booleanValue()));
assertThat('foo', not(booleanValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a boolean', booleanValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', booleanValue(), null);
$this->assertMismatchDescription('was a string "foo"', booleanValue(), 'foo');
}
}
PK �8]��� � 1 hamcrest-php/tests/Hamcrest/Type/IsObjectTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsObjectTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsObject::objectValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(new \stdClass, objectValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(objectValue()));
assertThat(5, not(objectValue()));
assertThat('foo', not(objectValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('an object', objectValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', objectValue(), null);
$this->assertMismatchDescription('was a string "foo"', objectValue(), 'foo');
}
}
PK �8]�v��� � 2 hamcrest-php/tests/Hamcrest/Type/IsIntegerTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsIntegerTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsInteger::integerValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(5, integerValue());
assertThat(0, integerValue());
assertThat(-5, integerValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(integerValue()));
assertThat(5.2, not(integerValue()));
assertThat('foo', not(integerValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('an integer', integerValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', integerValue(), null);
$this->assertMismatchDescription('was a string "foo"', integerValue(), 'foo');
}
}
PK �8]Lz��r r 1 hamcrest-php/tests/Hamcrest/Type/IsScalarTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsScalarTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsScalar::scalarValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(true, scalarValue());
assertThat(5, scalarValue());
assertThat(5.3, scalarValue());
assertThat('5', scalarValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(null, not(scalarValue()));
assertThat(array(), not(scalarValue()));
assertThat(array(5), not(scalarValue()));
assertThat(tmpfile(), not(scalarValue()));
assertThat(new \stdClass(), not(scalarValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a scalar', scalarValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', scalarValue(), null);
$this->assertMismatchDescription('was an array ["foo"]', scalarValue(), array('foo'));
}
}
PK �8]�v^�
�
3 hamcrest-php/tests/Hamcrest/Type/IsCallableTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsCallableTest extends \Hamcrest\AbstractMatcherTest
{
public static function callableFunction()
{
}
public function __invoke()
{
}
protected function createMatcher()
{
return \Hamcrest\Type\IsCallable::callableValue();
}
public function testEvaluatesToTrueIfArgumentIsFunctionName()
{
assertThat('preg_match', callableValue());
}
public function testEvaluatesToTrueIfArgumentIsStaticMethodCallback()
{
assertThat(
array('Hamcrest\Type\IsCallableTest', 'callableFunction'),
callableValue()
);
}
public function testEvaluatesToTrueIfArgumentIsInstanceMethodCallback()
{
assertThat(
array($this, 'testEvaluatesToTrueIfArgumentIsInstanceMethodCallback'),
callableValue()
);
}
public function testEvaluatesToTrueIfArgumentIsClosure()
{
if (!version_compare(PHP_VERSION, '5.3', '>=')) {
$this->markTestSkipped('Closures require php 5.3');
}
eval('assertThat(function () {}, callableValue());');
}
public function testEvaluatesToTrueIfArgumentImplementsInvoke()
{
if (!version_compare(PHP_VERSION, '5.3', '>=')) {
$this->markTestSkipped('Magic method __invoke() requires php 5.3');
}
assertThat($this, callableValue());
}
public function testEvaluatesToFalseIfArgumentIsInvalidFunctionName()
{
if (function_exists('not_a_Hamcrest_function')) {
$this->markTestSkipped('Function "not_a_Hamcrest_function" must not exist');
}
assertThat('not_a_Hamcrest_function', not(callableValue()));
}
public function testEvaluatesToFalseIfArgumentIsInvalidStaticMethodCallback()
{
assertThat(
array('Hamcrest\Type\IsCallableTest', 'noMethod'),
not(callableValue())
);
}
public function testEvaluatesToFalseIfArgumentIsInvalidInstanceMethodCallback()
{
assertThat(array($this, 'noMethod'), not(callableValue()));
}
public function testEvaluatesToFalseIfArgumentDoesntImplementInvoke()
{
assertThat(new \stdClass(), not(callableValue()));
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(callableValue()));
assertThat(5.2, not(callableValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a callable', callableValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription(
'was a string "invalid-function"',
callableValue(),
'invalid-function'
);
}
}
PK �8]�tĚ � 3 hamcrest-php/tests/Hamcrest/Type/IsResourceTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsResourceTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsResource::resourceValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(tmpfile(), resourceValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(resourceValue()));
assertThat(5, not(resourceValue()));
assertThat('foo', not(resourceValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a resource', resourceValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', resourceValue(), null);
$this->assertMismatchDescription('was a string "foo"', resourceValue(), 'foo');
}
}
PK �8]�$�� � 1 hamcrest-php/tests/Hamcrest/Type/IsDoubleTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsDoubleTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsDouble::doubleValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat((float) 5.2, floatValue());
assertThat((double) 5.3, doubleValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(doubleValue()));
assertThat(5, not(doubleValue()));
assertThat('foo', not(doubleValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a double', doubleValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', doubleValue(), null);
$this->assertMismatchDescription('was a string "foo"', doubleValue(), 'foo');
}
}
PK �8]
V�J� � 1 hamcrest-php/tests/Hamcrest/Type/IsStringTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsStringTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsString::stringValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat('', stringValue());
assertThat("foo", stringValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(stringValue()));
assertThat(5, not(stringValue()));
assertThat(array(1, 2, 3), not(stringValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a string', stringValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', stringValue(), null);
$this->assertMismatchDescription('was a double <5.2F>', stringValue(), 5.2);
}
}
PK �8]zٸJ! ! 2 hamcrest-php/tests/Hamcrest/Type/IsNumericTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsNumericTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsNumeric::numericValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(5, numericValue());
assertThat(0, numericValue());
assertThat(-5, numericValue());
assertThat(5.3, numericValue());
assertThat(0.53, numericValue());
assertThat(-5.3, numericValue());
assertThat('5', numericValue());
assertThat('0', numericValue());
assertThat('-5', numericValue());
assertThat('5.3', numericValue());
assertThat('5e+3', numericValue());
assertThat('0.053e-2', numericValue());
assertThat('-53.253e+25', numericValue());
assertThat('+53.253e+25', numericValue());
assertThat('0x4F2a04', numericValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(numericValue()));
assertThat('foo', not(numericValue()));
assertThat('foo5', not(numericValue()));
assertThat('5foo', not(numericValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a number', numericValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', numericValue(), null);
$this->assertMismatchDescription('was a string "foo"', numericValue(), 'foo');
}
}
PK �8]�2�X� � 0 hamcrest-php/tests/Hamcrest/Type/IsArrayTest.phpnu �Iw�� <?php
namespace Hamcrest\Type;
class IsArrayTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Type\IsArray::arrayValue();
}
public function testEvaluatesToTrueIfArgumentMatchesType()
{
assertThat(array('5', 5), arrayValue());
assertThat(array(), arrayValue());
}
public function testEvaluatesToFalseIfArgumentDoesntMatchType()
{
assertThat(false, not(arrayValue()));
assertThat(5, not(arrayValue()));
assertThat('foo', not(arrayValue()));
}
public function testHasAReadableDescription()
{
$this->assertDescription('an array', arrayValue());
}
public function testDecribesActualTypeInMismatchMessage()
{
$this->assertMismatchDescription('was null', arrayValue(), null);
$this->assertMismatchDescription('was a string "foo"', arrayValue(), 'foo');
}
}
PK �8]�=�� � 1 hamcrest-php/tests/Hamcrest/MatcherAssertTest.phpnu �Iw�� <?php
namespace Hamcrest;
class MatcherAssertTest extends \PhpUnit_Framework_TestCase
{
protected function setUp()
{
\Hamcrest\MatcherAssert::resetCount();
}
public function testResetCount()
{
\Hamcrest\MatcherAssert::assertThat(true);
self::assertEquals(1, \Hamcrest\MatcherAssert::getCount(), 'assertion count');
\Hamcrest\MatcherAssert::resetCount();
self::assertEquals(0, \Hamcrest\MatcherAssert::getCount(), 'assertion count');
}
public function testAssertThatWithTrueArgPasses()
{
\Hamcrest\MatcherAssert::assertThat(true);
\Hamcrest\MatcherAssert::assertThat('non-empty');
\Hamcrest\MatcherAssert::assertThat(1);
\Hamcrest\MatcherAssert::assertThat(3.14159);
\Hamcrest\MatcherAssert::assertThat(array(true));
self::assertEquals(5, \Hamcrest\MatcherAssert::getCount(), 'assertion count');
}
public function testAssertThatWithFalseArgFails()
{
try {
\Hamcrest\MatcherAssert::assertThat(false);
self::fail('expected assertion failure');
} catch (\Hamcrest\AssertionError $ex) {
self::assertEquals('', $ex->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');
}
}
}
PK �8]���> > > hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyTest.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
use Hamcrest\AbstractMatcherTest;
class IsArrayContainingKeyTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsArrayContainingKey::hasKeyInArray('irrelevant');
}
public function testMatchesSingleElementArrayContainingKey()
{
$array = array('a'=>1);
$this->assertMatches(hasKey('a'), $array, 'Matches single key');
}
public function testMatchesArrayContainingKey()
{
$array = array('a'=>1, 'b'=>2, 'c'=>3);
$this->assertMatches(hasKey('a'), $array, 'Matches a');
$this->assertMatches(hasKey('c'), $array, 'Matches c');
}
public function testMatchesArrayContainingKeyWithIntegerKeys()
{
$array = array(1=>'A', 2=>'B');
assertThat($array, hasKey(1));
}
public function testMatchesArrayContainingKeyWithNumberKeys()
{
$array = array(1=>'A', 2=>'B');
assertThat($array, hasKey(1));
// very ugly version!
assertThat($array, IsArrayContainingKey::hasKeyInArray(2));
}
public function testHasReadableDescription()
{
$this->assertDescription('array with key "a"', hasKey('a'));
}
public function testDoesNotMatchEmptyArray()
{
$this->assertMismatchDescription('array was []', hasKey('Foo'), array());
}
public function testDoesNotMatchArrayMissingKey()
{
$array = array('a'=>1, 'b'=>2, 'c'=>3);
$this->assertMismatchDescription('array was ["a" => <1>, "b" => <2>, "c" => <3>]', hasKey('d'), $array);
}
}
PK �8]Z�bR� � ; hamcrest-php/tests/Hamcrest/Array/IsArrayContainingTest.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
use Hamcrest\AbstractMatcherTest;
class IsArrayContainingTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsArrayContaining::hasItemInArray('irrelevant');
}
public function testMatchesAnArrayThatContainsAnElementMatchingTheGivenMatcher()
{
$this->assertMatches(
hasItemInArray('a'),
array('a', 'b', 'c'),
"should matches array that contains 'a'"
);
}
public function testDoesNotMatchAnArrayThatDoesntContainAnElementMatchingTheGivenMatcher()
{
$this->assertDoesNotMatch(
hasItemInArray('a'),
array('b', 'c'),
"should not matches array that doesn't contain 'a'"
);
$this->assertDoesNotMatch(
hasItemInArray('a'),
array(),
'should not match empty array'
);
}
public function testDoesNotMatchNull()
{
$this->assertDoesNotMatch(
hasItemInArray('a'),
null,
'should not match null'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription('an array containing "a"', hasItemInArray('a'));
}
}
PK �8]8Sb�� � B hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInOrderTest.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
use Hamcrest\AbstractMatcherTest;
class IsArrayContainingInOrderTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsArrayContainingInOrder::arrayContaining(array(1, 2));
}
public function testHasAReadableDescription()
{
$this->assertDescription('[<1>, <2>]', arrayContaining(array(1, 2)));
}
public function testMatchesItemsInOrder()
{
$this->assertMatches(arrayContaining(array(1, 2, 3)), array(1, 2, 3), 'in order');
$this->assertMatches(arrayContaining(array(1)), array(1), 'single');
}
public function testAppliesMatchersInOrder()
{
$this->assertMatches(
arrayContaining(array(1, 2, 3)),
array(1, 2, 3),
'in order'
);
$this->assertMatches(arrayContaining(array(1)), array(1), 'single');
}
public function testMismatchesItemsInAnyOrder()
{
$matcher = arrayContaining(array(1, 2, 3));
$this->assertMismatchDescription('was null', $matcher, null);
$this->assertMismatchDescription('No item matched: <1>', $matcher, array());
$this->assertMismatchDescription('No item matched: <2>', $matcher, array(1));
$this->assertMismatchDescription('item with key 0: was <4>', $matcher, array(4, 3, 2, 1));
$this->assertMismatchDescription('item with key 2: was <4>', $matcher, array(1, 2, 4));
}
}
PK �8]��3l� � E hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInAnyOrderTest.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
use Hamcrest\AbstractMatcherTest;
class IsArrayContainingInAnyOrderTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsArrayContainingInAnyOrder::arrayContainingInAnyOrder(array(1, 2));
}
public function testHasAReadableDescription()
{
$this->assertDescription('[<1>, <2>] in any order', containsInAnyOrder(array(1, 2)));
}
public function testMatchesItemsInAnyOrder()
{
$this->assertMatches(containsInAnyOrder(array(1, 2, 3)), array(1, 2, 3), 'in order');
$this->assertMatches(containsInAnyOrder(array(1, 2, 3)), array(3, 2, 1), 'out of order');
$this->assertMatches(containsInAnyOrder(array(1)), array(1), 'single');
}
public function testAppliesMatchersInAnyOrder()
{
$this->assertMatches(
containsInAnyOrder(array(1, 2, 3)),
array(1, 2, 3),
'in order'
);
$this->assertMatches(
containsInAnyOrder(array(1, 2, 3)),
array(3, 2, 1),
'out of order'
);
$this->assertMatches(
containsInAnyOrder(array(1)),
array(1),
'single'
);
}
public function testMismatchesItemsInAnyOrder()
{
$matcher = containsInAnyOrder(array(1, 2, 3));
$this->assertMismatchDescription('was null', $matcher, null);
$this->assertMismatchDescription('No item matches: <1>, <2>, <3> in []', $matcher, array());
$this->assertMismatchDescription('No item matches: <2>, <3> in [<1>]', $matcher, array(1));
$this->assertMismatchDescription('Not matched: <4>', $matcher, array(4, 3, 2, 1));
}
}
PK �8]C�^�� � 9 hamcrest-php/tests/Hamcrest/Array/IsArrayWithSizeTest.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
use Hamcrest\AbstractMatcherTest;
class IsArrayWithSizeTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsArrayWithSize::arrayWithSize(equalTo(2));
}
public function testMatchesWhenSizeIsCorrect()
{
$this->assertMatches(arrayWithSize(equalTo(3)), array(1, 2, 3), 'correct size');
$this->assertDoesNotMatch(arrayWithSize(equalTo(2)), array(1, 2, 3), 'incorrect size');
}
public function testProvidesConvenientShortcutForArrayWithSizeEqualTo()
{
$this->assertMatches(arrayWithSize(3), array(1, 2, 3), 'correct size');
$this->assertDoesNotMatch(arrayWithSize(2), array(1, 2, 3), 'incorrect size');
}
public function testEmptyArray()
{
$this->assertMatches(emptyArray(), array(), 'correct size');
$this->assertDoesNotMatch(emptyArray(), array(1), 'incorrect size');
}
public function testHasAReadableDescription()
{
$this->assertDescription('an array with size <3>', arrayWithSize(equalTo(3)));
$this->assertDescription('an empty array', emptyArray());
}
}
PK �8]�B$J J G hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyValuePairTest.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
use Hamcrest\AbstractMatcherTest;
class IsArrayContainingKeyValuePairTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsArrayContainingKeyValuePair::hasKeyValuePair('irrelevant', 'irrelevant');
}
public function testMatchesArrayContainingMatchingKeyAndValue()
{
$array = array('a'=>1, 'b'=>2);
$this->assertMatches(hasKeyValuePair(equalTo('a'), equalTo(1)), $array, 'matcherA');
$this->assertMatches(hasKeyValuePair(equalTo('b'), equalTo(2)), $array, 'matcherB');
$this->assertMismatchDescription(
'array was ["a" => <1>, "b" => <2>]',
hasKeyValuePair(equalTo('c'), equalTo(3)),
$array
);
}
public function testDoesNotMatchNull()
{
$this->assertMismatchDescription('was null', hasKeyValuePair(anything(), anything()), null);
}
public function testHasReadableDescription()
{
$this->assertDescription('array containing ["a" => <2>]', hasKeyValuePair(equalTo('a'), equalTo(2)));
}
}
PK �8]��Q>� � 1 hamcrest-php/tests/Hamcrest/Array/IsArrayTest.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
use Hamcrest\AbstractMatcherTest;
class IsArrayTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsArray::anArray(array(equalTo('irrelevant')));
}
public function testMatchesAnArrayThatMatchesAllTheElementMatchers()
{
$this->assertMatches(
anArray(array(equalTo('a'), equalTo('b'), equalTo('c'))),
array('a', 'b', 'c'),
'should match array with matching elements'
);
}
public function testDoesNotMatchAnArrayWhenElementsDoNotMatch()
{
$this->assertDoesNotMatch(
anArray(array(equalTo('a'), equalTo('b'))),
array('b', 'c'),
'should not match array with different elements'
);
}
public function testDoesNotMatchAnArrayOfDifferentSize()
{
$this->assertDoesNotMatch(
anArray(array(equalTo('a'), equalTo('b'))),
array('a', 'b', 'c'),
'should not match larger array'
);
$this->assertDoesNotMatch(
anArray(array(equalTo('a'), equalTo('b'))),
array('a'),
'should not match smaller array'
);
}
public function testDoesNotMatchNull()
{
$this->assertDoesNotMatch(
anArray(array(equalTo('a'))),
null,
'should not match null'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription(
'["a", "b"]',
anArray(array(equalTo('a'), equalTo('b')))
);
}
public function testHasAReadableMismatchDescriptionWhenKeysDontMatch()
{
$this->assertMismatchDescription(
'array keys were [<1>, <2>]',
anArray(array(equalTo('a'), equalTo('b'))),
array(1 => 'a', 2 => 'b')
);
}
public function testSupportsMatchesAssociativeArrays()
{
$this->assertMatches(
anArray(array('x'=>equalTo('a'), 'y'=>equalTo('b'), 'z'=>equalTo('c'))),
array('x'=>'a', 'y'=>'b', 'z'=>'c'),
'should match associative array with matching elements'
);
}
public function testDoesNotMatchAnAssociativeArrayWhenKeysDoNotMatch()
{
$this->assertDoesNotMatch(
anArray(array('x'=>equalTo('a'), 'y'=>equalTo('b'))),
array('x'=>'b', 'z'=>'c'),
'should not match array with different keys'
);
}
}
PK �8]�D�K K A hamcrest-php/tests/Hamcrest/Collection/IsEmptyTraversableTest.phpnu �Iw�� <?php
namespace Hamcrest\Collection;
use Hamcrest\AbstractMatcherTest;
class IsEmptyTraversableTest extends AbstractMatcherTest
{
protected function createMatcher()
{
return IsEmptyTraversable::emptyTraversable();
}
public function testEmptyMatcherMatchesWhenEmpty()
{
$this->assertMatches(
emptyTraversable(),
new \ArrayObject(array()),
'an empty traversable'
);
}
public function testEmptyMatcherDoesNotMatchWhenNotEmpty()
{
$this->assertDoesNotMatch(
emptyTraversable(),
new \ArrayObject(array(1, 2, 3)),
'a non-empty traversable'
);
}
public function testEmptyMatcherDoesNotMatchNull()
{
$this->assertDoesNotMatch(
emptyTraversable(),
null,
'should not match null'
);
}
public function testEmptyMatcherHasAReadableDescription()
{
$this->assertDescription('an empty traversable', emptyTraversable());
}
public function testNonEmptyDoesNotMatchNull()
{
$this->assertDoesNotMatch(
nonEmptyTraversable(),
null,
'should not match null'
);
}
public function testNonEmptyDoesNotMatchWhenEmpty()
{
$this->assertDoesNotMatch(
nonEmptyTraversable(),
new \ArrayObject(array()),
'an empty traversable'
);
}
public function testNonEmptyMatchesWhenNotEmpty()
{
$this->assertMatches(
nonEmptyTraversable(),
new \ArrayObject(array(1, 2, 3)),
'a non-empty traversable'
);
}
public function testNonEmptyNonEmptyMatcherHasAReadableDescription()
{
$this->assertDescription('a non-empty traversable', nonEmptyTraversable());
}
}
PK �8]�/զZ Z D hamcrest-php/tests/Hamcrest/Collection/IsTraversableWithSizeTest.phpnu �Iw�� <?php
namespace Hamcrest\Collection;
class IsTraversableWithSizeTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Collection\IsTraversableWithSize::traversableWithSize(
equalTo(2)
);
}
public function testMatchesWhenSizeIsCorrect()
{
$this->assertMatches(
traversableWithSize(equalTo(3)),
new \ArrayObject(array(1, 2, 3)),
'correct size'
);
}
public function testDoesNotMatchWhenSizeIsIncorrect()
{
$this->assertDoesNotMatch(
traversableWithSize(equalTo(2)),
new \ArrayObject(array(1, 2, 3)),
'incorrect size'
);
}
public function testDoesNotMatchNull()
{
$this->assertDoesNotMatch(
traversableWithSize(3),
null,
'should not match null'
);
}
public function testProvidesConvenientShortcutForTraversableWithSizeEqualTo()
{
$this->assertMatches(
traversableWithSize(3),
new \ArrayObject(array(1, 2, 3)),
'correct size'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription(
'a traversable with size <3>',
traversableWithSize(equalTo(3))
);
}
}
PK �8]�K�q q 3 hamcrest-php/tests/Hamcrest/AbstractMatcherTest.phpnu �Iw�� <?php
namespace Hamcrest;
class UnknownType {
}
abstract class AbstractMatcherTest extends \PHPUnit_Framework_TestCase
{
const ARGUMENT_IGNORED = "ignored";
const ANY_NON_NULL_ARGUMENT = "notnull";
abstract protected function createMatcher();
public function assertMatches(\Hamcrest\Matcher $matcher, $arg, $message)
{
$this->assertTrue($matcher->matches($arg), $message);
}
public function assertDoesNotMatch(\Hamcrest\Matcher $matcher, $arg, $message)
{
$this->assertFalse($matcher->matches($arg), $message);
}
public function assertDescription($expected, \Hamcrest\Matcher $matcher)
{
$description = new \Hamcrest\StringDescription();
$description->appendDescriptionOf($matcher);
$this->assertEquals($expected, (string) $description, 'Expected description');
}
public function assertMismatchDescription($expected, \Hamcrest\Matcher $matcher, $arg)
{
$description = new \Hamcrest\StringDescription();
$this->assertFalse(
$matcher->matches($arg),
'Precondtion: Matcher should not match item'
);
$matcher->describeMismatch($arg, $description);
$this->assertEquals(
$expected,
(string) $description,
'Expected mismatch description'
);
}
public function testIsNullSafe()
{
//Should not generate any notices
$this->createMatcher()->matches(null);
$this->createMatcher()->describeMismatch(
null,
new \Hamcrest\NullDescription()
);
}
public function testCopesWithUnknownTypes()
{
//Should not generate any notices
$this->createMatcher()->matches(new UnknownType());
$this->createMatcher()->describeMismatch(
new UnknownType(),
new NullDescription()
);
}
}
PK �8]pz�� / hamcrest-php/tests/Hamcrest/BaseMatcherTest.phpnu �Iw�� <?php
namespace Hamcrest;
/* Test-specific subclass only */
class BaseMatcherTest extends \Hamcrest\BaseMatcher
{
public function matches($item)
{
throw new \RuntimeException();
}
public function describeTo(\Hamcrest\Description $description)
{
$description->appendText('SOME DESCRIPTION');
}
public function testDescribesItselfWithToStringMethod()
{
$someMatcher = new \Hamcrest\SomeMatcher();
$this->assertEquals('SOME DESCRIPTION', (string) $someMatcher);
}
}
PK �8]�=�[ [ 7 hamcrest-php/tests/Hamcrest/Text/MatchesPatternTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class MatchesPatternTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return matchesPattern('/o+b/');
}
public function testEvaluatesToTrueIfArgumentmatchesPattern()
{
assertThat('foobar', matchesPattern('/o+b/'));
assertThat('foobar', matchesPattern('/^foo/'));
assertThat('foobar', matchesPattern('/ba*r$/'));
assertThat('foobar', matchesPattern('/^foobar$/'));
}
public function testEvaluatesToFalseIfArgumentDoesntMatchRegex()
{
assertThat('foobar', not(matchesPattern('/^foob$/')));
assertThat('foobar', not(matchesPattern('/oobe/')));
}
public function testHasAReadableDescription()
{
$this->assertDescription('a string matching "pattern"', matchesPattern('pattern'));
}
}
PK �8] XѶ � C hamcrest-php/tests/Hamcrest/Text/StringContainsIgnoringCaseTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class StringContainsIgnoringCaseTest extends \Hamcrest\AbstractMatcherTest
{
const EXCERPT = 'ExcErPt';
private $_stringContains;
public function setUp()
{
$this->_stringContains = \Hamcrest\Text\StringContainsIgnoringCase::containsStringIgnoringCase(
strtolower(self::EXCERPT)
);
}
protected function createMatcher()
{
return $this->_stringContains;
}
public function testEvaluatesToTrueIfArgumentContainsSpecifiedSubstring()
{
$this->assertTrue(
$this->_stringContains->matches(self::EXCERPT . 'END'),
'should be true if excerpt at beginning'
);
$this->assertTrue(
$this->_stringContains->matches('START' . self::EXCERPT),
'should be true if excerpt at end'
);
$this->assertTrue(
$this->_stringContains->matches('START' . self::EXCERPT . 'END'),
'should be true if excerpt in middle'
);
$this->assertTrue(
$this->_stringContains->matches(self::EXCERPT . self::EXCERPT),
'should be true if excerpt is repeated'
);
$this->assertFalse(
$this->_stringContains->matches('Something else'),
'should not be true if excerpt is not in string'
);
$this->assertFalse(
$this->_stringContains->matches(substr(self::EXCERPT, 1)),
'should not be true if part of excerpt is in string'
);
}
public function testEvaluatesToTrueIfArgumentIsEqualToSubstring()
{
$this->assertTrue(
$this->_stringContains->matches(self::EXCERPT),
'should be true if excerpt is entire string'
);
}
public function testEvaluatesToTrueIfArgumentContainsExactSubstring()
{
$this->assertTrue(
$this->_stringContains->matches(strtolower(self::EXCERPT)),
'should be false if excerpt is entire string ignoring case'
);
$this->assertTrue(
$this->_stringContains->matches('START' . strtolower(self::EXCERPT) . 'END'),
'should be false if excerpt is contained in string ignoring case'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription(
'a string containing in any case "'
. strtolower(self::EXCERPT) . '"',
$this->_stringContains
);
}
}
PK �8]�&� � > hamcrest-php/tests/Hamcrest/Text/StringContainsInOrderTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class StringContainsInOrderTest extends \Hamcrest\AbstractMatcherTest
{
private $_m;
public function setUp()
{
$this->_m = \Hamcrest\Text\StringContainsInOrder::stringContainsInOrder(array('a', 'b', 'c'));
}
protected function createMatcher()
{
return $this->_m;
}
public function testMatchesOnlyIfStringContainsGivenSubstringsInTheSameOrder()
{
$this->assertMatches($this->_m, 'abc', 'substrings in order');
$this->assertMatches($this->_m, '1a2b3c4', 'substrings separated');
$this->assertDoesNotMatch($this->_m, 'cab', 'substrings out of order');
$this->assertDoesNotMatch($this->_m, 'xyz', 'no substrings in string');
$this->assertDoesNotMatch($this->_m, 'ac', 'substring missing');
$this->assertDoesNotMatch($this->_m, '', 'empty string');
}
public function testAcceptsVariableArguments()
{
$this->assertMatches(stringContainsInOrder('a', 'b', 'c'), 'abc', 'substrings as variable arguments');
}
public function testHasAReadableDescription()
{
$this->assertDescription(
'a string containing "a", "b", "c" in order',
$this->_m
);
}
}
PK �8]1�\Qg g 7 hamcrest-php/tests/Hamcrest/Text/StringEndsWithTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class StringEndsWithTest extends \Hamcrest\AbstractMatcherTest
{
const EXCERPT = 'EXCERPT';
private $_stringEndsWith;
public function setUp()
{
$this->_stringEndsWith = \Hamcrest\Text\StringEndsWith::endsWith(self::EXCERPT);
}
protected function createMatcher()
{
return $this->_stringEndsWith;
}
public function testEvaluatesToTrueIfArgumentContainsSpecifiedSubstring()
{
$this->assertFalse(
$this->_stringEndsWith->matches(self::EXCERPT . 'END'),
'should be false if excerpt at beginning'
);
$this->assertTrue(
$this->_stringEndsWith->matches('START' . self::EXCERPT),
'should be true if excerpt at end'
);
$this->assertFalse(
$this->_stringEndsWith->matches('START' . self::EXCERPT . 'END'),
'should be false if excerpt in middle'
);
$this->assertTrue(
$this->_stringEndsWith->matches(self::EXCERPT . self::EXCERPT),
'should be true if excerpt is at end and repeated'
);
$this->assertFalse(
$this->_stringEndsWith->matches('Something else'),
'should be false if excerpt is not in string'
);
$this->assertFalse(
$this->_stringEndsWith->matches(substr(self::EXCERPT, 0, strlen(self::EXCERPT) - 2)),
'should be false if part of excerpt is at end of string'
);
}
public function testEvaluatesToTrueIfArgumentIsEqualToSubstring()
{
$this->assertTrue(
$this->_stringEndsWith->matches(self::EXCERPT),
'should be true if excerpt is entire string'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription('a string ending with "EXCERPT"', $this->_stringEndsWith);
}
}
PK �8]1�;r r 9 hamcrest-php/tests/Hamcrest/Text/StringStartsWithTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class StringStartsWithTest extends \Hamcrest\AbstractMatcherTest
{
const EXCERPT = 'EXCERPT';
private $_stringStartsWith;
public function setUp()
{
$this->_stringStartsWith = \Hamcrest\Text\StringStartsWith::startsWith(self::EXCERPT);
}
protected function createMatcher()
{
return $this->_stringStartsWith;
}
public function testEvaluatesToTrueIfArgumentContainsSpecifiedSubstring()
{
$this->assertTrue(
$this->_stringStartsWith->matches(self::EXCERPT . 'END'),
'should be true if excerpt at beginning'
);
$this->assertFalse(
$this->_stringStartsWith->matches('START' . self::EXCERPT),
'should be false if excerpt at end'
);
$this->assertFalse(
$this->_stringStartsWith->matches('START' . self::EXCERPT . 'END'),
'should be false if excerpt in middle'
);
$this->assertTrue(
$this->_stringStartsWith->matches(self::EXCERPT . self::EXCERPT),
'should be true if excerpt is at beginning and repeated'
);
$this->assertFalse(
$this->_stringStartsWith->matches('Something else'),
'should be false if excerpt is not in string'
);
$this->assertFalse(
$this->_stringStartsWith->matches(substr(self::EXCERPT, 1)),
'should be false if part of excerpt is at start of string'
);
}
public function testEvaluatesToTrueIfArgumentIsEqualToSubstring()
{
$this->assertTrue(
$this->_stringStartsWith->matches(self::EXCERPT),
'should be true if excerpt is entire string'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription('a string starting with "EXCERPT"', $this->_stringStartsWith);
}
}
PK �8]/Y� � � 6 hamcrest-php/tests/Hamcrest/Text/IsEmptyStringTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class IsEmptyStringTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Text\IsEmptyString::isEmptyOrNullString();
}
public function testEmptyDoesNotMatchNull()
{
$this->assertDoesNotMatch(emptyString(), null, 'null');
}
public function testEmptyDoesNotMatchZero()
{
$this->assertDoesNotMatch(emptyString(), 0, 'zero');
}
public function testEmptyDoesNotMatchFalse()
{
$this->assertDoesNotMatch(emptyString(), false, 'false');
}
public function testEmptyDoesNotMatchEmptyArray()
{
$this->assertDoesNotMatch(emptyString(), array(), 'empty array');
}
public function testEmptyMatchesEmptyString()
{
$this->assertMatches(emptyString(), '', 'empty string');
}
public function testEmptyDoesNotMatchNonEmptyString()
{
$this->assertDoesNotMatch(emptyString(), 'foo', 'non-empty string');
}
public function testEmptyHasAReadableDescription()
{
$this->assertDescription('an empty string', emptyString());
}
public function testEmptyOrNullMatchesNull()
{
$this->assertMatches(nullOrEmptyString(), null, 'null');
}
public function testEmptyOrNullMatchesEmptyString()
{
$this->assertMatches(nullOrEmptyString(), '', 'empty string');
}
public function testEmptyOrNullDoesNotMatchNonEmptyString()
{
$this->assertDoesNotMatch(nullOrEmptyString(), 'foo', 'non-empty string');
}
public function testEmptyOrNullHasAReadableDescription()
{
$this->assertDescription('(null or an empty string)', nullOrEmptyString());
}
public function testNonEmptyDoesNotMatchNull()
{
$this->assertDoesNotMatch(nonEmptyString(), null, 'null');
}
public function testNonEmptyDoesNotMatchEmptyString()
{
$this->assertDoesNotMatch(nonEmptyString(), '', 'empty string');
}
public function testNonEmptyMatchesNonEmptyString()
{
$this->assertMatches(nonEmptyString(), 'foo', 'non-empty string');
}
public function testNonEmptyHasAReadableDescription()
{
$this->assertDescription('a non-empty string', nonEmptyString());
}
}
PK �8]�O+| | < hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringCaseTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class IsEqualIgnoringCaseTest extends \Hamcrest\AbstractMatcherTest
{
protected function createMatcher()
{
return \Hamcrest\Text\IsEqualIgnoringCase::equalToIgnoringCase('irrelevant');
}
public function testIgnoresCaseOfCharsInString()
{
assertThat('HELLO', equalToIgnoringCase('heLLo'));
assertThat('hello', equalToIgnoringCase('heLLo'));
assertThat('HelLo', equalToIgnoringCase('heLLo'));
assertThat('bye', not(equalToIgnoringCase('heLLo')));
}
public function testFailsIfAdditionalWhitespaceIsPresent()
{
assertThat('heLLo ', not(equalToIgnoringCase('heLLo')));
assertThat(' heLLo', not(equalToIgnoringCase('heLLo')));
assertThat('hello', not(equalToIgnoringCase(' heLLo')));
}
public function testFailsIfMatchingAgainstNull()
{
assertThat(null, not(equalToIgnoringCase('heLLo')));
}
public function testDescribesItselfAsCaseInsensitive()
{
$this->assertDescription(
'equalToIgnoringCase("heLLo")',
equalToIgnoringCase('heLLo')
);
}
}
PK �8]=�'�W
W
7 hamcrest-php/tests/Hamcrest/Text/StringContainsTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class StringContainsTest extends \Hamcrest\AbstractMatcherTest
{
const EXCERPT = 'EXCERPT';
private $_stringContains;
public function setUp()
{
$this->_stringContains = \Hamcrest\Text\StringContains::containsString(self::EXCERPT);
}
protected function createMatcher()
{
return $this->_stringContains;
}
public function testEvaluatesToTrueIfArgumentContainsSubstring()
{
$this->assertTrue(
$this->_stringContains->matches(self::EXCERPT . 'END'),
'should be true if excerpt at beginning'
);
$this->assertTrue(
$this->_stringContains->matches('START' . self::EXCERPT),
'should be true if excerpt at end'
);
$this->assertTrue(
$this->_stringContains->matches('START' . self::EXCERPT . 'END'),
'should be true if excerpt in middle'
);
$this->assertTrue(
$this->_stringContains->matches(self::EXCERPT . self::EXCERPT),
'should be true if excerpt is repeated'
);
$this->assertFalse(
$this->_stringContains->matches('Something else'),
'should not be true if excerpt is not in string'
);
$this->assertFalse(
$this->_stringContains->matches(substr(self::EXCERPT, 1)),
'should not be true if part of excerpt is in string'
);
}
public function testEvaluatesToTrueIfArgumentIsEqualToSubstring()
{
$this->assertTrue(
$this->_stringContains->matches(self::EXCERPT),
'should be true if excerpt is entire string'
);
}
public function testEvaluatesToFalseIfArgumentContainsSubstringIgnoringCase()
{
$this->assertFalse(
$this->_stringContains->matches(strtolower(self::EXCERPT)),
'should be false if excerpt is entire string ignoring case'
);
$this->assertFalse(
$this->_stringContains->matches('START' . strtolower(self::EXCERPT) . 'END'),
'should be false if excerpt is contained in string ignoring case'
);
}
public function testIgnoringCaseReturnsCorrectMatcher()
{
$this->assertTrue(
$this->_stringContains->ignoringCase()->matches('EXceRpT'),
'should be true if excerpt is entire string ignoring case'
);
}
public function testHasAReadableDescription()
{
$this->assertDescription(
'a string containing "'
. self::EXCERPT . '"',
$this->_stringContains
);
}
}
PK �8]���pk k B hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringWhiteSpaceTest.phpnu �Iw�� <?php
namespace Hamcrest\Text;
class IsEqualIgnoringWhiteSpaceTest extends \Hamcrest\AbstractMatcherTest
{
private $_matcher;
public function setUp()
{
$this->_matcher = \Hamcrest\Text\IsEqualIgnoringWhiteSpace::equalToIgnoringWhiteSpace(
"Hello World how\n are we? "
);
}
protected function createMatcher()
{
return $this->_matcher;
}
public function testPassesIfWordsAreSameButWhitespaceDiffers()
{
assertThat('Hello World how are we?', $this->_matcher);
assertThat(" Hello \rWorld \t how are\nwe?", $this->_matcher);
}
public function testFailsIfTextOtherThanWhitespaceDiffers()
{
assertThat('Hello PLANET how are we?', not($this->_matcher));
assertThat('Hello World how are we', not($this->_matcher));
}
public function testFailsIfWhitespaceIsAddedOrRemovedInMidWord()
{
assertThat('HelloWorld how are we?', not($this->_matcher));
assertThat('Hello Wo rld how are we?', not($this->_matcher));
}
public function testFailsIfMatchingAgainstNull()
{
assertThat(null, not($this->_matcher));
}
public function testHasAReadableDescription()
{
$this->assertDescription(
"equalToIgnoringWhiteSpace(\"Hello World how\\n are we? \")",
$this->_matcher
);
}
}
PK �8]�?J�� � 0 hamcrest-php/tests/Hamcrest/Xml/HasXPathTest.phpnu �Iw�� <?php
namespace Hamcrest\Xml;
class HasXPathTest extends \Hamcrest\AbstractMatcherTest
{
protected static $xml;
protected static $doc;
protected static $html;
public static function setUpBeforeClass()
{
self::$xml = <<<XML
<?xml version="1.0"?>
<users>
<user>
<id>alice</id>
<name>Alice Frankel</name>
<role>admin</role>
</user>
<user>
<id>bob</id>
<name>Bob Frankel</name>
<role>user</role>
</user>
<user>
<id>charlie</id>
<name>Charlie Chan</name>
<role>user</role>
</user>
</users>
XML;
self::$doc = new \DOMDocument();
self::$doc->loadXML(self::$xml);
self::$html = <<<HTML
<html>
<head>
<title>Home Page</title>
</head>
<body>
<h1>Heading</h1>
<p>Some text</p>
</body>
</html>
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 �8]!0�� � hamcrest-php/CHANGES.txtnu �Iw�� == Version 1.1.0: Released Feb 2 2012 ==
Issues Fixed: 121, 138, 147
* Added non-empty matchers to complement the emptiness-matching forms.
- nonEmptyString()
- nonEmptyArray()
- nonEmptyTraversable()
* Added ability to pass variable arguments to several array-based matcher
factory methods so they work like allOf() et al.
- anArray()
- arrayContainingInAnyOrder(), containsInAnyOrder()
- arrayContaining(), contains()
- stringContainsInOrder()
* Matchers that accept an array of matchers now also accept variable arguments.
Any non-matcher arguments are wrapped by IsEqual.
* Added noneOf() as a shortcut for not(anyOf()).
== Version 1.0.0: Released Jan 20 2012 ==
Issues Fixed: 119, 136, 139, 141, 148, 149, 172
* Moved hamcrest.php into Hamcrest folder and renamed to Hamcrest.php.
This is more in line with PEAR packaging standards.
* Renamed callable() to callableValue() for compatibility with PHP 5.4.
* Added Hamcrest_Text_StringContainsIgnoringCase to assert using stripos().
assertThat('fOObAr', containsStringIgnoringCase('oba'));
assertThat('fOObAr', containsString('oba')->ignoringCase());
* Fixed Hamcrest_Core_IsInstanceOf to return false for native types.
* Moved string-based matchers to Hamcrest_Text package.
StringContains, StringEndsWith, StringStartsWith, and SubstringMatcher
* Hamcrest.php and Hamcrest_Matchers.php are now built from @factory doctags.
Added @factory doctag to every static factory method.
* Hamcrest_Matchers and Hamcrest.php now import each matcher as-needed
and Hamcrest.php calls the matchers directly instead of Hamcrest_Matchers.
== Version 0.3.0: Released Jul 26 2010 ==
* Added running count to Hamcrest_MatcherAssert with methods to get and reset it.
This can be used by unit testing frameworks for reporting.
* Added Hamcrest_Core_HasToString to assert return value of toString() or __toString().
assertThat($anObject, hasToString('foo'));
* Added Hamcrest_Type_IsScalar to assert is_scalar().
Matches values of type bool, int, float, double, and string.
assertThat($count, scalarValue());
assertThat('foo', scalarValue());
* Added Hamcrest_Collection package.
- IsEmptyTraversable
- IsTraversableWithSize
assertThat($iterator, emptyTraversable());
assertThat($iterator, traversableWithSize(5));
* Added Hamcrest_Xml_HasXPath to assert XPath expressions or the content of nodes in an XML/HTML DOM.
assertThat($dom, hasXPath('books/book/title'));
assertThat($dom, hasXPath('books/book[contains(title, "Alice")]', 3));
assertThat($dom, hasXPath('books/book/title', 'Alice in Wonderland'));
assertThat($dom, hasXPath('count(books/book)', greaterThan(10)));
* Added aliases to match the Java API.
hasEntry() -> hasKeyValuePair()
hasValue() -> hasItemInArray()
contains() -> arrayContaining()
containsInAnyOrder() -> arrayContainingInAnyOrder()
* Added optional subtype to Hamcrest_TypeSafeMatcher to enforce object class or resource type.
* Hamcrest_TypeSafeDiagnosingMatcher now extends Hamcrest_TypeSafeMatcher.
== Version 0.2.0: Released Jul 14 2010 ==
Issues Fixed: 109, 111, 114, 115
* Description::appendValues() and appendValueList() accept Iterator and IteratorAggregate. [111]
BaseDescription::appendValue() handles IteratorAggregate.
* assertThat() accepts a single boolean parameter and
wraps any non-Matcher third parameter with equalTo().
* Removed null return value from assertThat(). [114]
* Fixed wrong variable name in contains(). [109]
* Added Hamcrest_Core_IsSet to assert isset().
assertThat(array('foo' => 'bar'), set('foo'));
assertThat(array('foo' => 'bar'), notSet('bar'));
* Added Hamcrest_Core_IsTypeOf to assert built-in types with gettype(). [115]
Types: array, boolean, double, integer, null, object, resource, and string.
Note that gettype() returns "double" for float values.
assertThat($count, typeOf('integer'));
assertThat(3.14159, typeOf('double'));
assertThat(array('foo', 'bar'), typeOf('array'));
assertThat(new stdClass(), typeOf('object'));
* Added type-specific matchers in new Hamcrest_Type package.
- IsArray
- IsBoolean
- IsDouble (includes float values)
- IsInteger
- IsObject
- IsResource
- IsString
assertThat($count, integerValue());
assertThat(3.14159, floatValue());
assertThat('foo', stringValue());
* Added Hamcrest_Type_IsNumeric to assert is_numeric().
Matches values of type int and float/double or strings that are formatted as numbers.
assertThat(5, numericValue());
assertThat('-5e+3', numericValue());
* Added Hamcrest_Type_IsCallable to assert is_callable().
assertThat('preg_match', callable());
assertThat(array('SomeClass', 'SomeMethod'), callable());
assertThat(array($object, 'SomeMethod'), callable());
assertThat($object, callable());
assertThat(function ($x, $y) { return $x + $y; }, callable());
* Added Hamcrest_Text_MatchesPattern for regex matching with preg_match().
assertThat('foobar', matchesPattern('/o+b/'));
* Added aliases:
- atLeast() for greaterThanOrEqualTo()
- atMost() for lessThanOrEqualTo()
== Version 0.1.0: Released Jul 7 2010 ==
* Created PEAR package
* Core matchers
PK �8]旯� � hamcrest-php/.gush.ymlnu �Iw�� adapter: github
issue_tracker: github
meta-header: "Copyright (c) 2009-2015 hamcrest.org"
table-pr:
fixed_tickets: ['Fixed Tickets', '']
license: ['License', MIT]
base: master
PK �8])�� hamcrest-php/.gitignorenu �Iw�� vendor
composer.lock
PK �8] �[� � hamcrest-php/LICENSE.txtnu �Iw�� BSD License
Copyright (c) 2000-2014, www.hamcrest.org
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer. Redistributions in binary form must reproduce
the above copyright notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
Neither the name of Hamcrest nor the names of its contributors may be used to endorse
or promote products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
PK �8]u��� � - hamcrest-php/generator/GlobalFunctionFile.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class GlobalFunctionFile extends FactoryFile
{
/**
* @var string containing function definitions
*/
private $functions;
public function __construct($file)
{
parent::__construct($file, ' ');
$this->functions = '';
}
public function addCall(FactoryCall $call)
{
$this->functions .= PHP_EOL . $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()}')) {";
$code.= parent::generateFactoryCall($call);
$code.= "}\n";
return $code;
}
}
PK �8]�g�) & hamcrest-php/generator/FactoryFile.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
abstract class FactoryFile
{
/**
* Hamcrest standard is two spaces for each level of indentation.
*
* @var string
*/
const INDENT = ' ';
private $indent;
private $file;
private $code;
public function __construct($file, $indent)
{
$this->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) . PHP_EOL;
$code .= $this->generateDeclaration($call->getName(), $method);
// $code .= $this->generateImport($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)
. ')' . PHP_EOL . $this->indent . '{' . PHP_EOL;
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() . "';" . PHP_EOL;
}
public function generateCall(FactoryMethod $method)
{
$code = '';
if ($method->acceptsVariableArguments()) {
$code .= $this->indent . self::INDENT . '$args = func_get_args();' . PHP_EOL;
}
$code .= $this->indent . self::INDENT . 'return ';
if ($method->acceptsVariableArguments()) {
$code .= 'call_user_func_array(array(\''
. '\\' . $method->getClassName() . '\', \''
. $method->getName() . '\'), $args);' . PHP_EOL;
} else {
$code .= '\\' . $method->getClassName() . '::'
. $method->getName() . '('
. $method->getParameterInvocations() . ');' . PHP_EOL;
}
return $code;
}
public function generateClosing()
{
return $this->indent . '}' . PHP_EOL;
}
public function write()
{
file_put_contents($this->file, $this->code);
}
}
PK �8]c]�W; ; hamcrest-php/generator/run.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
require __DIR__ . '/../vendor/autoload.php';
/*
* Generates the Hamcrest\Matchers factory class and factory functions
* from the @factory doctags in the various matchers.
*/
define('GENERATOR_BASE', __DIR__);
define('HAMCREST_BASE', realpath(dirname(GENERATOR_BASE) . DIRECTORY_SEPARATOR . 'hamcrest'));
define('GLOBAL_FUNCTIONS_FILE', HAMCREST_BASE . DIRECTORY_SEPARATOR . 'Hamcrest.php');
define('STATIC_MATCHERS_FILE', HAMCREST_BASE . DIRECTORY_SEPARATOR . 'Hamcrest' . DIRECTORY_SEPARATOR . 'Matchers.php');
set_include_path(
implode(
PATH_SEPARATOR,
array(
GENERATOR_BASE,
HAMCREST_BASE,
get_include_path()
)
)
);
@unlink(GLOBAL_FUNCTIONS_FILE);
@unlink(STATIC_MATCHERS_FILE);
$generator = new FactoryGenerator(HAMCREST_BASE . DIRECTORY_SEPARATOR . 'Hamcrest');
$generator->addFactoryFile(new StaticMethodFile(STATIC_MATCHERS_FILE));
$generator->addFactoryFile(new GlobalFunctionFile(GLOBAL_FUNCTIONS_FILE));
$generator->generate();
$generator->write();
PK �8]�k�3c c & hamcrest-php/generator/FactoryCall.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class FactoryCall
{
/**
* Hamcrest standard is two spaces for each level of indentation.
*
* @var string
*/
const INDENT = ' ';
/**
* @var FactoryMethod
*/
private $method;
/**
* @var string
*/
private $name;
public function __construct(FactoryMethod $method, $name)
{
$this->method = $method;
$this->name = $name;
}
public function getMethod()
{
return $this->method;
}
public function getName()
{
return $this->name;
}
}
PK �8]�G��
�
+ hamcrest-php/generator/FactoryGenerator.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Controls the process of extracting @factory doctags
* and generating factory method files.
*
* Uses File_Iterator to scan for PHP files.
*/
class FactoryGenerator
{
/**
* Path to the Hamcrest PHP files to process.
*
* @var string
*/
private $path;
/**
* @var array of FactoryFile
*/
private $factoryFiles;
public function __construct($path)
{
$this->path = $path;
$this->factoryFiles = array();
}
public function addFactoryFile(FactoryFile $factoryFile)
{
$this->factoryFiles[] = $factoryFile;
}
public function generate()
{
$classes = $this->getClassesWithFactoryMethods();
foreach ($classes as $class) {
foreach ($class->getMethods() as $method) {
foreach ($method->getCalls() as $call) {
foreach ($this->factoryFiles as $file) {
$file->addCall($call);
}
}
}
}
}
public function write()
{
foreach ($this->factoryFiles as $file) {
$file->build();
$file->write();
}
}
public function getClassesWithFactoryMethods()
{
$classes = array();
$files = $this->getSortedFiles();
foreach ($files as $file) {
$class = $this->getFactoryClass($file);
if ($class !== null) {
$classes[] = $class;
}
}
return $classes;
}
public function getSortedFiles()
{
$iter = \File_Iterator_Factory::getFileIterator($this->path, '.php');
$files = array();
foreach ($iter as $file) {
$files[] = $file;
}
sort($files, SORT_STRING);
return $files;
}
public function getFactoryClass($file)
{
$name = $this->getFactoryClassName($file);
if ($name !== null) {
require_once $file;
if (class_exists($name)) {
$class = new FactoryClass(substr($file, strpos($file, 'Hamcrest/')), new ReflectionClass($name));
if ($class->isFactory()) {
return $class;
}
}
}
return null;
}
public function getFactoryClassName($file)
{
$content = file_get_contents($file);
if (preg_match('/namespace\s+(.+);/', $content, $namespace)
&& preg_match('/\n\s*class\s+(\w+)\s+extends\b/', $content, $className)
&& preg_match('/@factory\b/', $content)
) {
return $namespace[1] . '\\' . $className[1];
}
return null;
}
}
PK �8]��ݬ 1 hamcrest-php/generator/parts/matchers_imports.txtnu �Iw��
namespace Hamcrest;PK �8] 1 hamcrest-php/generator/parts/functions_footer.txtnu �Iw�� PK �8] 2 hamcrest-php/generator/parts/functions_imports.txtnu �Iw�� PK �8]�| �x x , hamcrest-php/generator/parts/file_header.txtnu �Iw�� <?php
/*
Copyright (c) 2009-2010 hamcrest.org
*/
// This file is generated from the static method @factory doctags.
PK �8];��V V 0 hamcrest-php/generator/parts/matchers_header.txtnu �Iw��
/**
* A series of static factories for all hamcrest matchers.
*/
class Matchers
{
PK �8]Z��; 0 hamcrest-php/generator/parts/matchers_footer.txtnu �Iw�� }
PK �8] �>� � 1 hamcrest-php/generator/parts/functions_header.txtnu �Iw��
if (!function_exists('assertThat')) {
/**
* Make an assertion and throw {@link Hamcrest_AssertionError} if it fails.
*
* Example:
* <pre>
* //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);
* </pre>
*/
function assertThat()
{
$args = func_get_args();
call_user_func_array(
array('Hamcrest\MatcherAssert', 'assertThat'),
$args
);
}
}
PK �8]s�T�� � + hamcrest-php/generator/FactoryParameter.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class FactoryParameter
{
/**
* @var FactoryMethod
*/
private $method;
/**
* @var ReflectionParameter
*/
private $reflector;
public function __construct(FactoryMethod $method, ReflectionParameter $reflector)
{
$this->method = $method;
$this->reflector = $reflector;
}
public function getDeclaration()
{
if ($this->reflector->isArray()) {
$code = 'array ';
} else {
$class = $this->reflector->getClass();
if ($class !== null) {
$code = '\\' . $class->name . ' ';
} else {
$code = '';
}
}
$code .= '$' . $this->reflector->name;
if ($this->reflector->isOptional()) {
$default = $this->reflector->getDefaultValue();
if (is_null($default)) {
$default = 'null';
} elseif (is_bool($default)) {
$default = $default ? 'true' : 'false';
} elseif (is_string($default)) {
$default = "'" . $default . "'";
} elseif (is_numeric($default)) {
$default = strval($default);
} elseif (is_array($default)) {
$default = 'array()';
} else {
echo 'Warning: unknown default type for ' . $this->getMethod()->getFullName() . PHP_EOL;
var_dump($default);
$default = 'null';
}
$code .= ' = ' . $default;
}
return $code;
}
public function getInvocation()
{
return '$' . $this->reflector->name;
}
public function getMethod()
{
return $this->method;
}
}
PK �8]D.G ( hamcrest-php/generator/FactoryMethod.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Represents a single static factory method from a {@link Matcher} class.
*
* @todo Search method in file contents for func_get_args() to replace factoryVarArgs.
*/
class FactoryMethod
{
/**
* @var FactoryClass
*/
private $class;
/**
* @var ReflectionMethod
*/
private $reflector;
/**
* @var array of string
*/
private $comment;
/**
* @var bool
*/
private $isVarArgs;
/**
* @var array of FactoryCall
*/
private $calls;
/**
* @var array FactoryParameter
*/
private $parameters;
public function __construct(FactoryClass $class, ReflectionMethod $reflector)
{
$this->class = $class;
$this->reflector = $reflector;
$this->extractCommentWithoutLeadingShashesAndStars();
$this->extractFactoryNamesFromComment();
$this->extractParameters();
}
public function extractCommentWithoutLeadingShashesAndStars()
{
$this->comment = explode("\n", $this->reflector->getDocComment());
foreach ($this->comment as &$line) {
$line = preg_replace('#^\s*(/\\*+|\\*+/|\\*)\s?#', '', $line);
}
$this->trimLeadingBlankLinesFromComment();
$this->trimTrailingBlankLinesFromComment();
}
public function trimLeadingBlankLinesFromComment()
{
while (count($this->comment) > 0) {
$line = array_shift($this->comment);
if (trim($line) != '') {
array_unshift($this->comment, $line);
break;
}
}
}
public function trimTrailingBlankLinesFromComment()
{
while (count($this->comment) > 0) {
$line = array_pop($this->comment);
if (trim($line) != '') {
array_push($this->comment, $line);
break;
}
}
}
public function extractFactoryNamesFromComment()
{
$this->calls = array();
for ($i = 0; $i < count($this->comment); $i++) {
if ($this->extractFactoryNamesFromLine($this->comment[$i])) {
unset($this->comment[$i]);
}
}
$this->trimTrailingBlankLinesFromComment();
}
public function extractFactoryNamesFromLine($line)
{
if (preg_match('/^\s*@factory(\s+(.+))?$/', $line, $match)) {
$this->createCalls(
$this->extractFactoryNamesFromAnnotation(
isset($match[2]) ? trim($match[2]) : null
)
);
return true;
}
return false;
}
public function extractFactoryNamesFromAnnotation($value)
{
$primaryName = $this->reflector->getName();
if (empty($value)) {
return array($primaryName);
}
preg_match_all('/(\.{3}|-|[a-zA-Z_][a-zA-Z_0-9]*)/', $value, $match);
$names = $match[0];
if (in_array('...', $names)) {
$this->isVarArgs = true;
}
if (!in_array('-', $names) && !in_array($primaryName, $names)) {
array_unshift($names, $primaryName);
}
return $names;
}
public function createCalls(array $names)
{
$names = array_unique($names);
foreach ($names as $name) {
if ($name != '-' && $name != '...') {
$this->calls[] = new FactoryCall($this, $name);
}
}
}
public function extractParameters()
{
$this->parameters = array();
if (!$this->isVarArgs) {
foreach ($this->reflector->getParameters() as $parameter) {
$this->parameters[] = new FactoryParameter($this, $parameter);
}
}
}
public function getParameterDeclarations()
{
if ($this->isVarArgs || !$this->hasParameters()) {
return '';
}
$params = array();
foreach ($this->parameters as /** @var $parameter FactoryParameter */
$parameter) {
$params[] = $parameter->getDeclaration();
}
return implode(', ', $params);
}
public function getParameterInvocations()
{
if ($this->isVarArgs) {
return '';
}
$params = array();
foreach ($this->parameters as $parameter) {
$params[] = $parameter->getInvocation();
}
return implode(', ', $params);
}
public function getClass()
{
return $this->class;
}
public function getClassName()
{
return $this->class->getName();
}
public function getName()
{
return $this->reflector->name;
}
public function isFactory()
{
return count($this->calls) > 0;
}
public function getCalls()
{
return $this->calls;
}
public function acceptsVariableArguments()
{
return $this->isVarArgs;
}
public function hasParameters()
{
return !empty($this->parameters);
}
public function getParameters()
{
return $this->parameters;
}
public function getFullName()
{
return $this->getClassName() . '::' . $this->getName();
}
public function getCommentText()
{
return implode(PHP_EOL, $this->comment);
}
public function getComment($indent = '')
{
$comment = $indent . '/**';
foreach ($this->comment as $line) {
$comment .= PHP_EOL . rtrim($indent . ' * ' . $line);
}
$comment .= PHP_EOL . $indent . ' */';
return $comment;
}
}
PK �8]���;� � ' hamcrest-php/generator/FactoryClass.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class FactoryClass
{
/**
* @var string
*/
private $file;
/**
* @var ReflectionClass
*/
private $reflector;
/**
* @var array
*/
private $methods;
public function __construct($file, ReflectionClass $class)
{
$this->file = $file;
$this->reflector = $class;
$this->extractFactoryMethods();
}
public function extractFactoryMethods()
{
$this->methods = array();
foreach ($this->getPublicStaticMethods() as $method) {
if ($method->isFactory()) {
// echo $this->getName() . '::' . $method->getName() . ' : ' . count($method->getCalls()) . PHP_EOL;
$this->methods[] = $method;
}
}
}
public function getPublicStaticMethods()
{
$methods = array();
foreach ($this->reflector->getMethods(ReflectionMethod::IS_STATIC) as $method) {
if ($method->isPublic() && $method->getDeclaringClass() == $this->reflector) {
$methods[] = new FactoryMethod($this, $method);
}
}
return $methods;
}
public function getFile()
{
return $this->file;
}
public function getName()
{
return $this->reflector->name;
}
public function isFactory()
{
return !empty($this->methods);
}
public function getMethods()
{
return $this->methods;
}
}
PK �8]�Sȴ + hamcrest-php/generator/StaticMethodFile.phpnu �Iw�� <?php
/*
Copyright (c) 2009 hamcrest.org
*/
class StaticMethodFile extends FactoryFile
{
/**
* @var string containing method definitions
*/
private $methods;
public function __construct($file)
{
parent::__construct($file, ' ');
$this->methods = '';
}
public function addCall(FactoryCall $call)
{
$this->methods .= PHP_EOL . $this->generateFactoryCall($call);
}
public function getDeclarationModifiers()
{
return 'public static ';
}
public function build()
{
$this->addFileHeader();
$this->addPart('matchers_imports');
$this->addPart('matchers_header');
$this->addCode($this->methods);
$this->addPart('matchers_footer');
}
}
PK �8]��igf f hamcrest-php/.travis.ymlnu �Iw�� language: php
php:
- 5.4
- 5.3
install:
- composer install
script:
- mkdir -p build/logs
- cd tests
- phpunit --coverage-clover=../build/logs/clover.xml .
- cd ../
after_script:
- php vendor/bin/coveralls -v
- wget https://scrutinizer-ci.com/ocular.phar
- php ocular.phar code-coverage:upload --format=php-clover build/logs/clover.xml
PK �8]&�=� T T " hamcrest-php/hamcrest/Hamcrest.phpnu �Iw�� <?php
/*
Copyright (c) 2009-2010 hamcrest.org
*/
// This file is generated from the static method @factory doctags.
if (!function_exists('assertThat')) {
/**
* Make an assertion and throw {@link Hamcrest_AssertionError} if it fails.
*
* Example:
* <pre>
* //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);
* </pre>
*/
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:
* <pre>
* assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
* </pre>
*/
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:
* <pre>
* assertThat($string, either(containsString("a"))->orElse(containsString("b")));
* </pre>
*/
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:
* <pre>
* assertThat(array('a', 'b'), hasItem(equalTo('b')));
* //Convenience defaults to equalTo()
* assertThat(array('a', 'b'), hasItem('b'));
* </pre>
*/
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:
* <pre>
* assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
* </pre>
*/
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
* <code>assertThat($anObject, anInstanceOf('Thing'));</code>
*/
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
* <code>assertThat($anObject, anInstanceOf('Thing'));</code>
*/
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 <code>$matcher</code> with {@link Hamcrest\Core\IsEqual)
* if it's not a matcher and the XPath in <code>count()</code>
* if it's an integer.
*/
function hasXPath($xpath, $matcher = null)
{
return \Hamcrest\Xml\HasXPath::hasXPath($xpath, $matcher);
}
}
PK �8]���Ok k 2 hamcrest-php/hamcrest/Hamcrest/BaseDescription.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Internal\SelfDescribingValue;
/**
* A {@link Hamcrest\Description} that is stored as a string.
*/
abstract class BaseDescription implements Description
{
public function appendText($text)
{
$this->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 <var>$str</var> 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 �8]&�w�l l > hamcrest-php/hamcrest/Hamcrest/Core/IsCollectionContaining.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\Matcher;
use Hamcrest\TypeSafeMatcher;
use Hamcrest\Util;
/**
* Tests if an array contains values that match one or more Matchers.
*/
class IsCollectionContaining extends TypeSafeMatcher
{
private $_elementMatcher;
public function __construct(Matcher $elementMatcher)
{
parent::__construct(self::TYPE_ARRAY);
$this->_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:
* <pre>
* assertThat(array('a', 'b'), hasItem(equalTo('b')));
* //Convenience defaults to equalTo()
* assertThat(array('a', 'b'), hasItem('b'));
* </pre>
*
* @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:
* <pre>
* assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
* </pre>
*
* @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 �8]F���� � 9 hamcrest-php/hamcrest/Hamcrest/Core/CombinableMatcher.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
use Hamcrest\Matcher;
class CombinableMatcher extends BaseMatcher
{
private $_matcher;
public function __construct(Matcher $matcher)
{
$this->_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:
* <pre>
* assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
* </pre>
*
* @factory
*/
public static function both(Matcher $matcher)
{
return new self($matcher);
}
/**
* This is useful for fluently combining matchers where either may pass,
* for example:
* <pre>
* assertThat($string, either(containsString("a"))->orElse(containsString("b")));
* </pre>
*
* @factory
*/
public static function either(Matcher $matcher)
{
return new self($matcher);
}
// -- Private Methods
private function _templatedListWith(Matcher $other)
{
return array($this->_matcher, $other);
}
}
PK �8]3j<� � - hamcrest-php/hamcrest/Hamcrest/Core/AllOf.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\DiagnosingMatcher;
use Hamcrest\Util;
/**
* Calculates the logical conjunction of multiple matchers. Evaluation is
* shortcut, so subsequent matchers are not called if an earlier matcher
* returns <code>false</code>.
*/
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 �8]7���F F . hamcrest-php/hamcrest/Hamcrest/Core/IsSame.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
/**
* Is the value the same object as another value?
* In PHP terms, does $a === $b?
*/
class IsSame extends BaseMatcher
{
private $_object;
public function __construct($object)
{
$this->_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 �8]Zb.� � - hamcrest-php/hamcrest/Hamcrest/Core/AnyOf.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\Util;
/**
* Calculates the logical disjunction of multiple matchers. Evaluation is
* shortcut, so subsequent matchers are not called if an earlier matcher
* returns <code>true</code>.
*/
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 �8]��: : - hamcrest-php/hamcrest/Hamcrest/Core/IsNot.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
use Hamcrest\Matcher;
use Hamcrest\Util;
/**
* Calculates the logical negation of a matcher.
*/
class IsNot extends BaseMatcher
{
private $_matcher;
public function __construct(Matcher $matcher)
{
$this->_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 �8]�ٞ� � 0 hamcrest-php/hamcrest/Hamcrest/Core/IsTypeOf.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
/**
* Tests whether the value has a built-in type.
*/
class IsTypeOf extends BaseMatcher
{
private $_theType;
/**
* Creates a new instance of IsTypeOf
*
* @param string $theType
* The predicate evaluates to true for values with this built-in type.
*/
public function __construct($theType)
{
$this->_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 �8]"'Q� � ; hamcrest-php/hamcrest/Hamcrest/Core/ShortcutCombination.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
use Hamcrest\Util;
abstract class ShortcutCombination extends BaseMatcher
{
/**
* @var array<\Hamcrest\Matcher>
*/
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 �8]�._�� � . hamcrest-php/hamcrest/Hamcrest/Core/IsNull.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
/**
* Is the value null?
*/
class IsNull extends BaseMatcher
{
private static $_INSTANCE;
private static $_NOT_INSTANCE;
public function matches($item)
{
return is_null($item);
}
public function describeTo(Description $description)
{
$description->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 �8]� � � 3 hamcrest-php/hamcrest/Hamcrest/Core/HasToString.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\FeatureMatcher;
use Hamcrest\Matcher;
use Hamcrest\Util;
/**
* Matches if array size satisfies a nested matcher.
*/
class HasToString extends FeatureMatcher
{
public function __construct(Matcher $toStringMatcher)
{
parent::__construct(
self::TYPE_OBJECT,
null,
$toStringMatcher,
'an object with toString()',
'toString()'
);
}
public function matchesSafelyWithDiagnosticDescription($actual, Description $mismatchDescription)
{
if (method_exists($actual, 'toString') || method_exists($actual, '__toString')) {
return parent::matchesSafelyWithDiagnosticDescription($actual, $mismatchDescription);
}
return false;
}
protected function featureValueOf($actual)
{
if (method_exists($actual, 'toString')) {
return $actual->toString();
}
return (string) $actual;
}
/**
* Does array size satisfy a given matcher?
*
* @factory
*/
public static function hasToString($matcher)
{
return new self(Util::wrapValueWithIsEqual($matcher));
}
}
PK �8]Uң�� � 4 hamcrest-php/hamcrest/Hamcrest/Core/IsInstanceOf.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\DiagnosingMatcher;
/**
* Tests whether the value is an instance of a class.
*/
class IsInstanceOf extends DiagnosingMatcher
{
private $_theClass;
/**
* Creates a new instance of IsInstanceOf
*
* @param string $theClass
* The predicate evaluates to true for instances of this class
* or one of its subclasses.
*/
public function __construct($theClass)
{
$this->_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
* <code>assertThat($anObject, anInstanceOf('Thing'));</code>
*
* @factory any
*/
public static function anInstanceOf($theClass)
{
return new self($theClass);
}
}
PK �8]�n�1� � 3 hamcrest-php/hamcrest/Hamcrest/Core/IsIdentical.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
/**
* The same as {@link Hamcrest\Core\IsSame} but with slightly different
* semantics.
*/
class IsIdentical extends IsSame
{
private $_value;
public function __construct($value)
{
parent::__construct($value);
$this->_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 �8]��B{h h + hamcrest-php/hamcrest/Hamcrest/Core/Set.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
/**
* Tests if a value (class, object, or array) has a named property.
*
* For example:
* <pre>
* assertThat(array('a', 'b'), set('b'));
* assertThat($foo, set('bar'));
* assertThat('Server', notSet('defaultPort'));
* </pre>
*
* @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 �8]+M{K K * hamcrest-php/hamcrest/Hamcrest/Core/Is.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
use Hamcrest\Matcher;
use Hamcrest\Util;
/**
* 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)))
*/
class Is extends BaseMatcher
{
private $_matcher;
public function __construct(Matcher $matcher)
{
$this->_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 �8]'�
: : - hamcrest-php/hamcrest/Hamcrest/Core/Every.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\Matcher;
use Hamcrest\TypeSafeDiagnosingMatcher;
class Every extends TypeSafeDiagnosingMatcher
{
private $_matcher;
public function __construct(Matcher $matcher)
{
parent::__construct(self::TYPE_ARRAY);
$this->_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 �8]T��@9 9 3 hamcrest-php/hamcrest/Hamcrest/Core/DescribedAs.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
use Hamcrest\Matcher;
/**
* Provides a custom description to another matcher.
*/
class DescribedAs extends BaseMatcher
{
private $_descriptionTemplate;
private $_matcher;
private $_values;
const ARG_PATTERN = '/%([0-9]+)/';
public function __construct($descriptionTemplate, Matcher $matcher, array $values)
{
$this->_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 �8]�b
�C C / hamcrest-php/hamcrest/Hamcrest/Core/IsEqual.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
/**
* Is the value equal to another value, as tested by the use of the "=="
* comparison operator?
*/
class IsEqual extends BaseMatcher
{
private $_item;
public function __construct($item)
{
$this->_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 �8]GY��k k 2 hamcrest-php/hamcrest/Hamcrest/Core/IsAnything.phpnu �Iw�� <?php
namespace Hamcrest\Core;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
/**
* A matcher that always returns <code>true</code>.
*/
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 �8] ׳i� � 3 hamcrest-php/hamcrest/Hamcrest/Number/IsCloseTo.phpnu �Iw�� <?php
namespace Hamcrest\Number;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeMatcher;
/**
* Is the value a number equal to a value within some range of
* acceptable error?
*/
class IsCloseTo extends TypeSafeMatcher
{
private $_value;
private $_delta;
public function __construct($value, $delta)
{
parent::__construct(self::TYPE_NUMERIC);
$this->_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 �8]��e e < hamcrest-php/hamcrest/Hamcrest/Number/OrderingComparison.phpnu �Iw�� <?php
namespace Hamcrest\Number;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeMatcher;
class OrderingComparison extends TypeSafeMatcher
{
private $_value;
private $_minCompare;
private $_maxCompare;
public function __construct($value, $minCompare, $maxCompare)
{
parent::__construct(self::TYPE_NUMERIC);
$this->_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 �8]�<�5� � ? hamcrest-php/hamcrest/Hamcrest/Internal/SelfDescribingValue.phpnu �Iw�� <?php
namespace Hamcrest\Internal;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\SelfDescribing;
/**
* A wrapper around any value so that it describes itself.
*/
class SelfDescribingValue implements SelfDescribing
{
private $_value;
public function __construct($value)
{
$this->_value = $value;
}
public function describeTo(Description $description)
{
$description->appendValue($this->_value);
}
}
PK �8]�Z�W� � 1 hamcrest-php/hamcrest/Hamcrest/FeatureMatcher.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Supporting class for matching a feature of an object. Implement
* <code>featureValueOf()</code> 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 �8]~2I I < hamcrest-php/hamcrest/Hamcrest/TypeSafeDiagnosingMatcher.phpnu �Iw�� <?php
namespace Hamcrest;
/**
* Convenient base class for Matchers that require a value of a specific type.
* This simply checks the type and then casts.
*/
abstract class TypeSafeDiagnosingMatcher extends TypeSafeMatcher
{
final public function matchesSafely($item)
{
return $this->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 �8]����c c 4 hamcrest-php/hamcrest/Hamcrest/StringDescription.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* A {@link Hamcrest\Description} that is stored as a string.
*/
class StringDescription extends BaseDescription
{
private $_out;
public function __construct($out = '')
{
$this->_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 �8]Byu�[ [ 4 hamcrest-php/hamcrest/Hamcrest/DiagnosingMatcher.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Official documentation for this class is missing.
*/
abstract class DiagnosingMatcher extends BaseMatcher
{
final public function matches($item)
{
return $this->matchesWithDiagnosticDescription($item, new NullDescription());
}
public function describeMismatch($item, Description $mismatchDescription)
{
$this->matchesWithDiagnosticDescription($item, $mismatchDescription);
}
abstract protected function matchesWithDiagnosticDescription($item, Description $mismatchDescription);
}
PK �8]�! � � G hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKeyValuePair.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/**
* Tests for the presence of both a key and value inside an array.
*/
use Hamcrest\Description;
use Hamcrest\Matcher;
use Hamcrest\TypeSafeMatcher;
use Hamcrest\Util;
/**
* @namespace
*/
class IsArrayContainingKeyValuePair extends TypeSafeMatcher
{
private $_keyMatcher;
private $_valueMatcher;
public function __construct(Matcher $keyMatcher, Matcher $valueMatcher)
{
parent::__construct(self::TYPE_ARRAY);
$this->_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 �8]�"l, , < hamcrest-php/hamcrest/Hamcrest/Arrays/SeriesMatchingOnce.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\Matcher;
class SeriesMatchingOnce
{
private $_elementMatchers;
private $_keys;
private $_mismatchDescription;
private $_nextMatchKey;
public function __construct(array $elementMatchers, Description $mismatchDescription)
{
$this->_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 �8]h�� � ; hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContaining.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\Matcher;
use Hamcrest\TypeSafeMatcher;
use Hamcrest\Util;
/**
* Matches if an array contains an item satisfying a nested matcher.
*/
class IsArrayContaining extends TypeSafeMatcher
{
private $_elementMatcher;
public function __construct(Matcher $elementMatcher)
{
parent::__construct(self::TYPE_ARRAY);
$this->_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 �8]Q�*�V V 6 hamcrest-php/hamcrest/Hamcrest/Arrays/MatchingOnce.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
class MatchingOnce
{
private $_elementMatchers;
private $_mismatchDescription;
public function __construct(array $elementMatchers, Description $mismatchDescription)
{
$this->_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 �8] ��sp p B hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInOrder.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeDiagnosingMatcher;
use Hamcrest\Util;
/**
* Matches if an array contains a set of items satisfying nested matchers.
*/
class IsArrayContainingInOrder extends TypeSafeDiagnosingMatcher
{
private $_elementMatchers;
public function __construct(array $elementMatchers)
{
parent::__construct(self::TYPE_ARRAY);
Util::checkAllAreMatchers($elementMatchers);
$this->_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 �8]21X� � > hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKey.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\Matcher;
use Hamcrest\TypeSafeMatcher;
use Hamcrest\Util;
/**
* Matches if an array contains the specified key.
*/
class IsArrayContainingKey extends TypeSafeMatcher
{
private $_keyMatcher;
public function __construct(Matcher $keyMatcher)
{
parent::__construct(self::TYPE_ARRAY);
$this->_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 �8]Ά��� � E hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInAnyOrder.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeDiagnosingMatcher;
use Hamcrest\Util;
/**
* Matches if an array contains a set of items satisfying nested matchers.
*/
class IsArrayContainingInAnyOrder extends TypeSafeDiagnosingMatcher
{
private $_elementMatchers;
public function __construct(array $elementMatchers)
{
parent::__construct(self::TYPE_ARRAY);
Util::checkAllAreMatchers($elementMatchers);
$this->_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 �8]t�� � � 1 hamcrest-php/hamcrest/Hamcrest/Arrays/IsArray.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
// NOTE: This class is not exactly a direct port of Java's since Java handles
// arrays quite differently than PHP
// TODO: Allow this to take matchers or values within the array
use Hamcrest\Description;
use Hamcrest\TypeSafeMatcher;
use Hamcrest\Util;
/**
* Matcher for array whose elements satisfy a sequence of matchers.
* The array size must equal the number of element matchers.
*/
class IsArray extends TypeSafeMatcher
{
private $_elementMatchers;
public function __construct(array $elementMatchers)
{
parent::__construct(self::TYPE_ARRAY);
Util::checkAllAreMatchers($elementMatchers);
$this->_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 �8]�`��� � 9 hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayWithSize.phpnu �Iw�� <?php
namespace Hamcrest\Arrays;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Core\DescribedAs;
use Hamcrest\Core\IsNot;
use Hamcrest\FeatureMatcher;
use Hamcrest\Matcher;
use Hamcrest\Util;
/**
* Matches if array size satisfies a nested matcher.
*/
class IsArrayWithSize extends FeatureMatcher
{
public function __construct(Matcher $sizeMatcher)
{
parent::__construct(
self::TYPE_ARRAY,
null,
$sizeMatcher,
'an array with size',
'array size'
);
}
protected function featureValueOf($array)
{
return count($array);
}
/**
* Does array size satisfy a given matcher?
*
* @param \Hamcrest\Matcher|int $size as a {@link Hamcrest\Matcher} or a value.
*
* @return \Hamcrest\Arrays\IsArrayWithSize
* @factory
*/
public static function arrayWithSize($size)
{
return new self(Util::wrapValueWithIsEqual($size));
}
/**
* Matches an empty array.
*
* @factory
*/
public static function emptyArray()
{
return DescribedAs::describedAs(
'an empty array',
self::arrayWithSize(0)
);
}
/**
* Matches an empty array.
*
* @factory
*/
public static function nonEmptyArray()
{
return DescribedAs::describedAs(
'a non-empty array',
self::arrayWithSize(IsNot::not(0))
);
}
}
PK �8]�R��� � 2 hamcrest-php/hamcrest/Hamcrest/NullDescription.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Null implementation of {@link Hamcrest\Description}.
*/
class NullDescription implements Description
{
public function appendText($text)
{
return $this;
}
public function appendDescriptionOf(SelfDescribing $value)
{
return $this;
}
public function appendValue($value)
{
return $this;
}
public function appendValueList($start, $separator, $end, $values)
{
return $this;
}
public function appendList($start, $separator, $end, $values)
{
return $this;
}
public function __toString()
{
return '';
}
}
PK �8]��M�f f 2 hamcrest-php/hamcrest/Hamcrest/TypeSafeMatcher.phpnu �Iw�� <?php
namespace Hamcrest;
/**
* Convenient base class for Matchers that require a value of a specific type.
* This simply checks the type.
*
* While it may seem a useless exercise to have this in PHP, objects cannot
* be cast to certain data types such as numerics (or even strings if
* __toString() has not be defined).
*/
abstract class TypeSafeMatcher extends BaseMatcher
{
/* Types that PHP can compare against */
const TYPE_ANY = 0;
const TYPE_STRING = 1;
const TYPE_NUMERIC = 2;
const TYPE_ARRAY = 3;
const TYPE_OBJECT = 4;
const TYPE_RESOURCE = 5;
const TYPE_BOOLEAN = 6;
/**
* The type that is required for a safe comparison
*
* @var int
*/
private $_expectedType;
/**
* The subtype (e.g. class for objects) that is required
*
* @var string
*/
private $_expectedSubtype;
public function __construct($expectedType, $expectedSubtype = null)
{
$this->_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 �8]_O�� � 0 hamcrest-php/hamcrest/Hamcrest/Type/IsObject.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is an object.
*/
class IsObject extends IsTypeOf
{
/**
* Creates a new instance of IsObject
*/
public function __construct()
{
parent::__construct('object');
}
/**
* Is the value an object?
*
* @factory anObject
*/
public static function objectValue()
{
return new self;
}
}
PK �8]�:�a� � 0 hamcrest-php/hamcrest/Hamcrest/Type/IsString.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is a string.
*/
class IsString extends IsTypeOf
{
/**
* Creates a new instance of IsString
*/
public function __construct()
{
parent::__construct('string');
}
/**
* Is the value a string?
*
* @factory
*/
public static function stringValue()
{
return new self;
}
}
PK �8]�Yˌ� � 2 hamcrest-php/hamcrest/Hamcrest/Type/IsResource.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is a resource.
*/
class IsResource extends IsTypeOf
{
/**
* Creates a new instance of IsResource
*/
public function __construct()
{
parent::__construct('resource');
}
/**
* Is the value a resource?
*
* @factory
*/
public static function resourceValue()
{
return new self;
}
}
PK �8]!�u� � 1 hamcrest-php/hamcrest/Hamcrest/Type/IsBoolean.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is a boolean.
*/
class IsBoolean extends IsTypeOf
{
/**
* Creates a new instance of IsBoolean
*/
public function __construct()
{
parent::__construct('boolean');
}
/**
* Is the value a boolean?
*
* @factory boolValue
*/
public static function booleanValue()
{
return new self;
}
}
PK �8]���+ + 0 hamcrest-php/hamcrest/Hamcrest/Type/IsDouble.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is a float/double.
*
* PHP returns "double" for values of type "float".
*/
class IsDouble extends IsTypeOf
{
/**
* Creates a new instance of IsDouble
*/
public function __construct()
{
parent::__construct('double');
}
/**
* Is the value a float/double?
*
* @factory floatValue
*/
public static function doubleValue()
{
return new self;
}
}
PK �8]ku"� � 1 hamcrest-php/hamcrest/Hamcrest/Type/IsNumeric.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is numeric.
*/
class IsNumeric extends IsTypeOf
{
public function __construct()
{
parent::__construct('number');
}
public function matches($item)
{
return is_numeric($item);
}
/**
* Is the value a numeric?
*
* @factory
*/
public static function numericValue()
{
return new self;
}
}
PK �8]_�L�8 8 2 hamcrest-php/hamcrest/Hamcrest/Type/IsCallable.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is callable.
*/
class IsCallable extends IsTypeOf
{
/**
* Creates a new instance of IsCallable
*/
public function __construct()
{
parent::__construct('callable');
}
public function matches($item)
{
return is_callable($item);
}
/**
* Is the value callable?
*
* @factory
*/
public static function callableValue()
{
return new self;
}
}
PK �8]��@ @ 0 hamcrest-php/hamcrest/Hamcrest/Type/IsScalar.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is a scalar (boolean, integer, double, or string).
*/
class IsScalar extends IsTypeOf
{
public function __construct()
{
parent::__construct('scalar');
}
public function matches($item)
{
return is_scalar($item);
}
/**
* Is the value a scalar (boolean, integer, double, or string)?
*
* @factory
*/
public static function scalarValue()
{
return new self;
}
}
PK �8]��@� � / hamcrest-php/hamcrest/Hamcrest/Type/IsArray.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is an array.
*/
class IsArray extends IsTypeOf
{
/**
* Creates a new instance of IsArray
*/
public function __construct()
{
parent::__construct('array');
}
/**
* Is the value an array?
*
* @factory
*/
public static function arrayValue()
{
return new self;
}
}
PK �8]Ȏp�� � 1 hamcrest-php/hamcrest/Hamcrest/Type/IsInteger.phpnu �Iw�� <?php
namespace Hamcrest\Type;
/*
Copyright (c) 2010 hamcrest.org
*/
use Hamcrest\Core\IsTypeOf;
/**
* Tests whether the value is an integer.
*/
class IsInteger extends IsTypeOf
{
/**
* Creates a new instance of IsInteger
*/
public function __construct()
{
parent::__construct('integer');
}
/**
* Is the value an integer?
*
* @factory intValue
*/
public static function integerValue()
{
return new self;
}
}
PK �8]r|sp� � . hamcrest-php/hamcrest/Hamcrest/Description.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* A description of a Matcher. A Matcher will describe itself to a description
* which can later be used for reporting.
*
* @see Hamcrest\Matcher::describeTo()
*/
interface Description
{
/**
* Appends some plain text to the description.
*
* @param string $text
*
* @return \Hamcrest\Description
*/
public function appendText($text);
/**
* Appends the description of a {@link Hamcrest\SelfDescribing} value to
* this description.
*
* @param \Hamcrest\SelfDescribing $value
*
* @return \Hamcrest\Description
*/
public function appendDescriptionOf(SelfDescribing $value);
/**
* Appends an arbitary value to the description.
*
* @param mixed $value
*
* @return \Hamcrest\Description
*/
public function appendValue($value);
/**
* Appends a list of values to the description.
*
* @param string $start
* @param string $separator
* @param string $end
* @param array|\IteratorAggregate|\Iterator $values
*
* @return \Hamcrest\Description
*/
public function appendValueList($start, $separator, $end, $values);
/**
* Appends a list of {@link Hamcrest\SelfDescribing} objects to the
* description.
*
* @param string $start
* @param string $separator
* @param string $end
* @param array|\\IteratorAggregate|\\Iterator $values
* must be instances of {@link Hamcrest\SelfDescribing}
*
* @return \Hamcrest\Description
*/
public function appendList($start, $separator, $end, $values);
}
PK �8] ��[ [ * hamcrest-php/hamcrest/Hamcrest/Matcher.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* A matcher over acceptable values.
* A matcher is able to describe itself to give feedback when it fails.
* <p/>
* Matcher implementations should <b>NOT directly implement this interface</b>.
* Instead, <b>extend</b> 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.
* <p/>
* 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 <var>$item</var>.
*
* @param mixed $item the object against which the matcher is evaluated.
*
* @return boolean <code>true</code> if <var>$item</var> matches,
* otherwise <code>false</code>.
*
* @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 <code>matches($item)</code> 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 �8]
( � � ' hamcrest-php/hamcrest/Hamcrest/Util.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2012 hamcrest.org
*/
/**
* Contains utility methods for handling Hamcrest matchers.
*
* @see Hamcrest\Matcher
*/
class Util
{
/**
* Wraps the item with an IsEqual matcher if it isn't a matcher already.
*
* @param mixed $item matcher or any value
* @return \Hamcrest\Matcher
*/
public static function wrapValueWithIsEqual($item)
{
return ($item instanceof Matcher)
? $item
: Core\IsEqual::equalTo($item)
;
}
/**
* Throws an exception if any item in $matchers is not a Hamcrest\Matcher.
*
* @param array $matchers expected to contain only matchers
* @throws \InvalidArgumentException if any item is not a matcher
*/
public static function checkAllAreMatchers(array $matchers)
{
foreach ($matchers as $m) {
if (!($m instanceof Matcher)) {
throw new \InvalidArgumentException(
'Each argument or element must be a Hamcrest matcher'
);
}
}
}
/**
* Returns a copy of $items where each non-Matcher item is replaced by
* a Hamcrest\Core\IsEqual matcher for the item. If the first and only item
* is an array, it is used as the $items array to support the old style
* of passing an array as the sole argument to a matcher.
*
* @param array $items contains items and matchers
* @return array<Matchers> 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 �8]� �e e @ hamcrest-php/hamcrest/Hamcrest/Collection/IsEmptyTraversable.phpnu �Iw�� <?php
namespace Hamcrest\Collection;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Description;
/**
* Matches if traversable is empty or non-empty.
*/
class IsEmptyTraversable extends BaseMatcher
{
private static $_INSTANCE;
private static $_NOT_INSTANCE;
private $_empty;
public function __construct($empty = true)
{
$this->_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 �8]|/N�� � C hamcrest-php/hamcrest/Hamcrest/Collection/IsTraversableWithSize.phpnu �Iw�� <?php
namespace Hamcrest\Collection;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\FeatureMatcher;
use Hamcrest\Matcher;
use Hamcrest\Util;
/**
* Matches if traversable size satisfies a nested matcher.
*/
class IsTraversableWithSize extends FeatureMatcher
{
public function __construct(Matcher $sizeMatcher)
{
parent::__construct(
self::TYPE_OBJECT,
'Traversable',
$sizeMatcher,
'a traversable with size',
'traversable size'
);
}
protected function featureValueOf($actual)
{
$size = 0;
foreach ($actual as $value) {
$size++;
}
return $size;
}
/**
* Does traversable size satisfy a given matcher?
*
* @factory
*/
public static function traversableWithSize($size)
{
return new self(Util::wrapValueWithIsEqual($size));
}
}
PK �8]�F4�w w 1 hamcrest-php/hamcrest/Hamcrest/AssertionError.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
class AssertionError extends \RuntimeException
{
}
PK �8]v�6�J J + hamcrest-php/hamcrest/Hamcrest/Matchers.phpnu �Iw�� <?php
/*
Copyright (c) 2009-2010 hamcrest.org
*/
// This file is generated from the static method @factory doctags.
namespace Hamcrest;
/**
* A series of static factories for all hamcrest matchers.
*/
class Matchers
{
/**
* Evaluates to true only if each $matcher[$i] is satisfied by $array[$i].
*/
public static function anArray(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Arrays\IsArray', 'anArray'), $args);
}
/**
* 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
*/
public static function hasItemInArray($item)
{
return \Hamcrest\Arrays\IsArrayContaining::hasItemInArray($item);
}
/**
* 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
*/
public static function hasValue($item)
{
return \Hamcrest\Arrays\IsArrayContaining::hasItemInArray($item);
}
/**
* An array with elements that match the given matchers.
*/
public static function arrayContainingInAnyOrder(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInAnyOrder', 'arrayContainingInAnyOrder'), $args);
}
/**
* An array with elements that match the given matchers.
*/
public static function containsInAnyOrder(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInAnyOrder', 'arrayContainingInAnyOrder'), $args);
}
/**
* An array with elements that match the given matchers in the same order.
*/
public static function arrayContaining(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInOrder', 'arrayContaining'), $args);
}
/**
* An array with elements that match the given matchers in the same order.
*/
public static function contains(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Arrays\IsArrayContainingInOrder', 'arrayContaining'), $args);
}
/**
* 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
*/
public static function hasKeyInArray($key)
{
return \Hamcrest\Arrays\IsArrayContainingKey::hasKeyInArray($key);
}
/**
* 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
*/
public static function hasKey($key)
{
return \Hamcrest\Arrays\IsArrayContainingKey::hasKeyInArray($key);
}
/**
* Test if an array has both an key and value in parity with each other.
*/
public static function hasKeyValuePair($key, $value)
{
return \Hamcrest\Arrays\IsArrayContainingKeyValuePair::hasKeyValuePair($key, $value);
}
/**
* Test if an array has both an key and value in parity with each other.
*/
public static function hasEntry($key, $value)
{
return \Hamcrest\Arrays\IsArrayContainingKeyValuePair::hasKeyValuePair($key, $value);
}
/**
* Does array size satisfy a given matcher?
*
* @param \Hamcrest\Matcher|int $size as a {@link Hamcrest\Matcher} or a value.
*
* @return \Hamcrest\Arrays\IsArrayWithSize
*/
public static function arrayWithSize($size)
{
return \Hamcrest\Arrays\IsArrayWithSize::arrayWithSize($size);
}
/**
* Matches an empty array.
*/
public static function emptyArray()
{
return \Hamcrest\Arrays\IsArrayWithSize::emptyArray();
}
/**
* Matches an empty array.
*/
public static function nonEmptyArray()
{
return \Hamcrest\Arrays\IsArrayWithSize::nonEmptyArray();
}
/**
* Returns true if traversable is empty.
*/
public static function emptyTraversable()
{
return \Hamcrest\Collection\IsEmptyTraversable::emptyTraversable();
}
/**
* Returns true if traversable is not empty.
*/
public static function nonEmptyTraversable()
{
return \Hamcrest\Collection\IsEmptyTraversable::nonEmptyTraversable();
}
/**
* Does traversable size satisfy a given matcher?
*/
public static function traversableWithSize($size)
{
return \Hamcrest\Collection\IsTraversableWithSize::traversableWithSize($size);
}
/**
* Evaluates to true only if ALL of the passed in matchers evaluate to true.
*/
public static function allOf(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Core\AllOf', 'allOf'), $args);
}
/**
* Evaluates to true if ANY of the passed in matchers evaluate to true.
*/
public static function anyOf(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Core\AnyOf', 'anyOf'), $args);
}
/**
* Evaluates to false if ANY of the passed in matchers evaluate to true.
*/
public static function noneOf(/* args... */)
{
$args = func_get_args();
return call_user_func_array(array('\Hamcrest\Core\AnyOf', 'noneOf'), $args);
}
/**
* This is useful for fluently combining matchers that must both pass.
* For example:
* <pre>
* assertThat($string, both(containsString("a"))->andAlso(containsString("b")));
* </pre>
*/
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:
* <pre>
* assertThat($string, either(containsString("a"))->orElse(containsString("b")));
* </pre>
*/
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:
* <pre>
* assertThat(array('a', 'b'), hasItem(equalTo('b')));
* //Convenience defaults to equalTo()
* assertThat(array('a', 'b'), hasItem('b'));
* </pre>
*/
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:
* <pre>
* assertThat(array('a', 'b', 'c'), hasItems(equalTo('a'), equalTo('b')));
* </pre>
*/
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
* <code>assertThat($anObject, anInstanceOf('Thing'));</code>
*/
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
* <code>assertThat($anObject, anInstanceOf('Thing'));</code>
*/
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 <code>$matcher</code> with {@link Hamcrest\Core\IsEqual)
* if it's not a matcher and the XPath in <code>count()</code>
* if it's an integer.
*/
public static function hasXPath($xpath, $matcher = null)
{
return \Hamcrest\Xml\HasXPath::hasXPath($xpath, $matcher);
}
}
PK �8]��=w;
;
0 hamcrest-php/hamcrest/Hamcrest/MatcherAssert.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
class MatcherAssert
{
/**
* Number of assertions performed.
*
* @var int
*/
private static $_count = 0;
/**
* Make an assertion and throw {@link Hamcrest\AssertionError} if it fails.
*
* The first parameter may optionally be a string identifying the assertion
* to be included in the failure message.
*
* If the third parameter is not a matcher it is passed to
* {@link Hamcrest\Core\IsEqual#equalTo} to create one.
*
* Example:
* <pre>
* // 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);
* </pre>
*/
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 <code>$matcher</code> doesn't match <code>$actual</code>,
* throws a {@link Hamcrest\AssertionError} with a description
* of the failure along with the optional <code>$identifier</code>.
*
* @param string $identifier added to the message upon failure
* @param mixed $actual value to compare against <code>$matcher</code>
* @param \Hamcrest\Matcher $matcher applied to <code>$actual</code>
* @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 �8]av�* * B hamcrest-php/hamcrest/Hamcrest/Text/StringContainsIgnoringCase.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2010 hamcrest.org
*/
/**
* Tests if the argument is a string that contains a substring ignoring case.
*/
class StringContainsIgnoringCase extends SubstringMatcher
{
public function __construct($substring)
{
parent::__construct($substring);
}
/**
* Matches if value is a string that contains $substring regardless of the case.
*
* @factory
*/
public static function containsStringIgnoringCase($substring)
{
return new self($substring);
}
// -- Protected Methods
protected function evalSubstringOf($item)
{
return (false !== stripos((string) $item, $this->_substring));
}
protected function relationship()
{
return 'containing in any case';
}
}
PK �8]O�މR R 6 hamcrest-php/hamcrest/Hamcrest/Text/StringContains.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Tests if the argument is a string that contains a substring.
*/
class StringContains extends SubstringMatcher
{
public function __construct($substring)
{
parent::__construct($substring);
}
public function ignoringCase()
{
return new StringContainsIgnoringCase($this->_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 �8]�3��� � ; hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringCase.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeMatcher;
/**
* Tests if a string is equal to another string, regardless of the case.
*/
class IsEqualIgnoringCase extends TypeSafeMatcher
{
private $_string;
public function __construct($string)
{
parent::__construct(self::TYPE_STRING);
$this->_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 �8]z�w � � 6 hamcrest-php/hamcrest/Hamcrest/Text/StringEndsWith.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Tests if the argument is a string that ends with a substring.
*/
class StringEndsWith extends SubstringMatcher
{
public function __construct($substring)
{
parent::__construct($substring);
}
/**
* Matches if value is a string that ends with $substring.
*
* @factory
*/
public static function endsWith($substring)
{
return new self($substring);
}
// -- Protected Methods
protected function evalSubstringOf($string)
{
return (substr($string, (-1 * strlen($this->_substring))) === $this->_substring);
}
protected function relationship()
{
return 'ending with';
}
}
PK �8]�|[� = hamcrest-php/hamcrest/Hamcrest/Text/StringContainsInOrder.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeMatcher;
/**
* Tests if the value contains a series of substrings in a constrained order.
*/
class StringContainsInOrder extends TypeSafeMatcher
{
private $_substrings;
public function __construct(array $substrings)
{
parent::__construct(self::TYPE_STRING);
$this->_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 �8]<��9 9 A hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringWhiteSpace.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeMatcher;
/**
* Tests if a string is equal to another string, ignoring any changes in
* whitespace.
*/
class IsEqualIgnoringWhiteSpace extends TypeSafeMatcher
{
private $_string;
public function __construct($string)
{
parent::__construct(self::TYPE_STRING);
$this->_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 �8]��� 5 hamcrest-php/hamcrest/Hamcrest/Text/IsEmptyString.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\BaseMatcher;
use Hamcrest\Core\AnyOf;
use Hamcrest\Core\IsNull;
use Hamcrest\Description;
/**
* Matches empty Strings (and null).
*/
class IsEmptyString extends BaseMatcher
{
private static $_INSTANCE;
private static $_NULL_OR_EMPTY_INSTANCE;
private static $_NOT_INSTANCE;
private $_empty;
public function __construct($empty = true)
{
$this->_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 �8]���G G 8 hamcrest-php/hamcrest/Hamcrest/Text/SubstringMatcher.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Description;
use Hamcrest\TypeSafeMatcher;
abstract class SubstringMatcher extends TypeSafeMatcher
{
protected $_substring;
public function __construct($substring)
{
parent::__construct(self::TYPE_STRING);
$this->_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 �8]�~j� � 8 hamcrest-php/hamcrest/Hamcrest/Text/StringStartsWith.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* Tests if the argument is a string that contains a substring.
*/
class StringStartsWith extends SubstringMatcher
{
public function __construct($substring)
{
parent::__construct($substring);
}
/**
* Matches if value is a string that starts with $substring.
*
* @factory
*/
public static function startsWith($substring)
{
return new self($substring);
}
// -- Protected Methods
protected function evalSubstringOf($string)
{
return (substr($string, 0, strlen($this->_substring)) === $this->_substring);
}
protected function relationship()
{
return 'starting with';
}
}
PK �8]x �x� � 6 hamcrest-php/hamcrest/Hamcrest/Text/MatchesPattern.phpnu �Iw�� <?php
namespace Hamcrest\Text;
/*
Copyright (c) 2010 hamcrest.org
*/
/**
* Tests if the argument is a string that matches a regular expression.
*/
class MatchesPattern extends SubstringMatcher
{
public function __construct($pattern)
{
parent::__construct($pattern);
}
/**
* Matches if value is a string that matches regular expression $pattern.
*
* @factory
*/
public static function matchesPattern($pattern)
{
return new self($pattern);
}
// -- Protected Methods
protected function evalSubstringOf($item)
{
return preg_match($this->_substring, (string) $item) >= 1;
}
protected function relationship()
{
return 'matching';
}
}
PK �8]A��v� � . hamcrest-php/hamcrest/Hamcrest/BaseMatcher.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* BaseClass for all Matcher implementations.
*
* @see Hamcrest\Matcher
*/
abstract class BaseMatcher implements Matcher
{
public function describeMismatch($item, Description $description)
{
$description->appendText('was ')->appendValue($item);
}
public function __toString()
{
return StringDescription::toString($this);
}
}
PK �8]̥�h 1 hamcrest-php/hamcrest/Hamcrest/SelfDescribing.phpnu �Iw�� <?php
namespace Hamcrest;
/*
Copyright (c) 2009 hamcrest.org
*/
/**
* The ability of an object to describe itself.
*/
interface SelfDescribing
{
/**
* Generates a description of the object. The description may be part
* of a description of a larger object of which this is just a component,
* so it should be worded appropriately.
*
* @param \Hamcrest\Description $description
* The description to be built or appended to.
*/
public function describeTo(Description $description);
}
PK �8]<Z��� � / hamcrest-php/hamcrest/Hamcrest/Xml/HasXPath.phpnu �Iw�� <?php
namespace Hamcrest\Xml;
/*
Copyright (c) 2009 hamcrest.org
*/
use Hamcrest\Core\IsEqual;
use Hamcrest\Description;
use Hamcrest\DiagnosingMatcher;
use Hamcrest\Matcher;
/**
* Matches if XPath applied to XML/HTML/XHTML document either
* evaluates to result matching the matcher or returns at least
* one node, matching the matcher if present.
*/
class HasXPath extends DiagnosingMatcher
{
/**
* XPath to apply to the DOM.
*
* @var string
*/
private $_xpath;
/**
* Optional matcher to apply to the XPath expression result
* or the content of the returned nodes.
*
* @var Matcher
*/
private $_matcher;
public function __construct($xpath, Matcher $matcher = null)
{
$this->_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 <code>DOMDocument</code> from the given
* XML or HTML string.
*
* @param string $text
* @return \DOMDocument built from <code>$text</code>
* @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 <code>true</code> 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 <code>$matcher</code> with {@link Hamcrest\Core\IsEqual)
* if it's not a matcher and the XPath in <code>count()</code>
* 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 �8]k_�YH H hamcrest-php/composer.jsonnu �Iw�� {
"name": "hamcrest/hamcrest-php",
"type": "library",
"description": "This is the PHP port of Hamcrest Matchers",
"keywords": ["test"],
"license": "BSD",
"authors": [
],
"autoload": {
"classmap": ["hamcrest"],
"files": ["hamcrest/Hamcrest.php"]
},
"autoload-dev": {
"classmap": ["tests", "generator"]
},
"require": {
"php": ">=5.3.2"
},
"require-dev": {
"satooshi/php-coveralls": "dev-master",
"phpunit/php-file-iterator": "1.3.3"
},
"replace": {
"kodova/hamcrest-php": "*",
"davedevelopment/hamcrest-php": "*",
"cordoval/hamcrest-php": "*"
}
}
PK �8]O��� � hamcrest-php/README.mdnu �Iw�� This is the PHP port of Hamcrest Matchers
=========================================
[](https://scrutinizer-ci.com/g/hamcrest/hamcrest-php/)
[](https://travis-ci.org/hamcrest/hamcrest-php)
[](https://coveralls.io/r/hamcrest/hamcrest-php)
Hamcrest is a matching library originally written for Java, but
subsequently ported to many other languages. hamcrest-php is the
official PHP port of Hamcrest and essentially follows a literal
translation of the original Java API for Hamcrest, with a few
Exceptions, mostly down to PHP language barriers:
1. `instanceOf($theClass)` is actually `anInstanceOf($theClass)`
2. `both(containsString('a'))->and(containsString('b'))`
is actually `both(containsString('a'))->andAlso(containsString('b'))`
3. `either(containsString('a'))->or(containsString('b'))`
is actually `either(containsString('a'))->orElse(containsString('b'))`
4. Unless it would be non-semantic for a matcher to do so, hamcrest-php
allows dynamic typing for it's input, in "the PHP way". Exception are
where semantics surrounding the type itself would suggest otherwise,
such as stringContains() and greaterThan().
5. Several official matchers have not been ported because they don't
make sense or don't apply in PHP:
- `typeCompatibleWith($theClass)`
- `eventFrom($source)`
- `hasProperty($name)` **
- `samePropertyValuesAs($obj)` **
6. When most of the collections matchers are finally ported, PHP-specific
aliases will probably be created due to a difference in naming
conventions between Java's Arrays, Collections, Sets and Maps compared
with PHP's Arrays.
Usage
-----
Hamcrest matchers are easy to use as:
```php
Hamcrest_MatcherAssert::assertThat('a', Hamcrest_Matchers::equalToIgnoringCase('A'));
```
** [Unless we consider POPO's (Plain Old PHP Objects) akin to JavaBeans]
- The POPO thing is a joke. Java devs coin the term POJO's (Plain Old
Java Objects).
PK �8]��;� hamcrest-php/.coveralls.ymlnu �Iw�� src_dir: hamcrest
PK �8]}�}1 1 hamcrest-php/TODO.txtnu �Iw�� Still TODO Before Complete for PHP
----------------------------------
Port:
- Hamcrest_Collection_*
- IsCollectionWithSize
- IsEmptyCollection
- IsIn
- IsTraversableContainingInAnyOrder
- IsTraversableContainingInOrder
- IsMapContaining (aliases)
Aliasing/Deprecation (questionable):
- Find and fix any factory methods that start with "is".
Namespaces:
- Investigate adding PHP 5.3+ namespace support in a way that still permits
use in PHP 5.2.
- Other than a parallel codebase, I don't see how this could be possible.
PK �8]f%
� � # hamcrest-php/tests/phpunit.xml.distnu �Iw�� PK �8]��6� � � hamcrest-php/tests/bootstrap.phpnu �Iw�� PK �8]�L �8
8
( � hamcrest-php/tests/Hamcrest/UtilTest.phpnu �Iw�� PK �8]ną> > 4 � hamcrest-php/tests/Hamcrest/Core/HasToStringTest.phpnu �Iw�� PK �8]��ȟ � . + hamcrest-php/tests/Hamcrest/Core/AnyOfTest.phpnu �Iw�� PK �8]�/�o� � 4 (# hamcrest-php/tests/Hamcrest/Core/SampleBaseClass.phpnu �Iw�� PK �8]Op� / / 4 s$ hamcrest-php/tests/Hamcrest/Core/DescribedAsTest.phpnu �Iw�� PK �8]e���� � : ) hamcrest-php/tests/Hamcrest/Core/CombinableMatcherTest.phpnu �Iw�� PK �8]@S �F
F
? Z0 hamcrest-php/tests/Hamcrest/Core/IsCollectionContainingTest.phpnu �Iw�� PK �8]� ��R R + ; hamcrest-php/tests/Hamcrest/Core/IsTest.phpnu �Iw�� PK �8]�)�/` ` 3 �? hamcrest-php/tests/Hamcrest/Core/SampleSubClass.phpnu �Iw�� PK �8]��4�� � / @ hamcrest-php/tests/Hamcrest/Core/IsNullTest.phpnu �Iw�� PK �8]��� 4 �B hamcrest-php/tests/Hamcrest/Core/IsIdenticalTest.phpnu �Iw�� PK �8]���w� � . 'F hamcrest-php/tests/Hamcrest/Core/IsNotTest.phpnu �Iw�� PK �8]�l���
�
0 kJ hamcrest-php/tests/Hamcrest/Core/IsEqualTest.phpnu �Iw�� PK �8]�#�u / �U hamcrest-php/tests/Hamcrest/Core/IsSameTest.phpnu �Iw�� PK �8]�6 � � 3 Y hamcrest-php/tests/Hamcrest/Core/IsAnythingTest.phpnu �Iw�� PK �8]E��R~ ~ , "\ hamcrest-php/tests/Hamcrest/Core/SetTest.phpnu �Iw�� PK �8]���I+ + 5 �h hamcrest-php/tests/Hamcrest/Core/IsInstanceOfTest.phpnu �Iw�� PK �8]* . �p hamcrest-php/tests/Hamcrest/Core/AllOfTest.phpnu �Iw�� PK �8]
'93B B . w hamcrest-php/tests/Hamcrest/Core/EveryTest.phpnu �Iw�� PK �8]��R�� � 1 �z hamcrest-php/tests/Hamcrest/Core/IsTypeOfTest.phpnu �Iw�� PK �8]��
�E E 5 π hamcrest-php/tests/Hamcrest/StringDescriptionTest.phpnu �Iw�� PK �8]�ob�z z 2 y� hamcrest-php/tests/Hamcrest/FeatureMatcherTest.phpnu �Iw�� PK �8]_g�6� � = U� hamcrest-php/tests/Hamcrest/Number/OrderingComparisonTest.phpnu �Iw�� PK �8]�d��! ! 4 �� hamcrest-php/tests/Hamcrest/Number/IsCloseToTest.phpnu �Iw�� PK �8]�Hٷ � 2 /� hamcrest-php/tests/Hamcrest/Type/IsBooleanTest.phpnu �Iw�� PK �8]��� � 1 H� hamcrest-php/tests/Hamcrest/Type/IsObjectTest.phpnu �Iw�� PK �8]�v��� � 2 2� hamcrest-php/tests/Hamcrest/Type/IsIntegerTest.phpnu �Iw�� PK �8]Lz��r r 1 m� hamcrest-php/tests/Hamcrest/Type/IsScalarTest.phpnu �Iw�� PK �8]�v^�
�
3 @� hamcrest-php/tests/Hamcrest/Type/IsCallableTest.phpnu �Iw�� PK �8]�tĚ � 3 �� hamcrest-php/tests/Hamcrest/Type/IsResourceTest.phpnu �Iw�� PK �8]�$�� � 1 �� hamcrest-php/tests/Hamcrest/Type/IsDoubleTest.phpnu �Iw�� PK �8]
V�J� � 1 �� hamcrest-php/tests/Hamcrest/Type/IsStringTest.phpnu �Iw�� PK �8]zٸJ! ! 2 �� hamcrest-php/tests/Hamcrest/Type/IsNumericTest.phpnu �Iw�� PK �8]�2�X� � 0 I� hamcrest-php/tests/Hamcrest/Type/IsArrayTest.phpnu �Iw�� PK �8]�=�� � 1 R� hamcrest-php/tests/Hamcrest/MatcherAssertTest.phpnu �Iw�� PK �8]���> > > b� hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyTest.phpnu �Iw�� PK �8]Z�bR� � ; � hamcrest-php/tests/Hamcrest/Array/IsArrayContainingTest.phpnu �Iw�� PK �8]8Sb�� � B f hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInOrderTest.phpnu �Iw�� PK �8]��3l� � E � hamcrest-php/tests/Hamcrest/Array/IsArrayContainingInAnyOrderTest.phpnu �Iw�� PK �8]C�^�� � 9 � hamcrest-php/tests/Hamcrest/Array/IsArrayWithSizeTest.phpnu �Iw�� PK �8]�B$J J G � hamcrest-php/tests/Hamcrest/Array/IsArrayContainingKeyValuePairTest.phpnu �Iw�� PK �8]��Q>� � 1 f hamcrest-php/tests/Hamcrest/Array/IsArrayTest.phpnu �Iw�� PK �8]�D�K K A �" hamcrest-php/tests/Hamcrest/Collection/IsEmptyTraversableTest.phpnu �Iw�� PK �8]�/զZ Z D A* hamcrest-php/tests/Hamcrest/Collection/IsTraversableWithSizeTest.phpnu �Iw�� PK �8]�K�q q 3 0 hamcrest-php/tests/Hamcrest/AbstractMatcherTest.phpnu �Iw�� PK �8]pz�� / �7 hamcrest-php/tests/Hamcrest/BaseMatcherTest.phpnu �Iw�� PK �8]�=�[ [ 7 Y: hamcrest-php/tests/Hamcrest/Text/MatchesPatternTest.phpnu �Iw�� PK �8] XѶ � C > hamcrest-php/tests/Hamcrest/Text/StringContainsIgnoringCaseTest.phpnu �Iw�� PK �8]�&� � > DH hamcrest-php/tests/Hamcrest/Text/StringContainsInOrderTest.phpnu �Iw�� PK �8]1�\Qg g 7 �M hamcrest-php/tests/Hamcrest/Text/StringEndsWithTest.phpnu �Iw�� PK �8]1�;r r 9 dU hamcrest-php/tests/Hamcrest/Text/StringStartsWithTest.phpnu �Iw�� PK �8]/Y� � � 6 ?] hamcrest-php/tests/Hamcrest/Text/IsEmptyStringTest.phpnu �Iw�� PK �8]�O+| | < �f hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringCaseTest.phpnu �Iw�� PK �8]=�'�W
W
7 �k hamcrest-php/tests/Hamcrest/Text/StringContainsTest.phpnu �Iw�� PK �8]���pk k B Bv hamcrest-php/tests/Hamcrest/Text/IsEqualIgnoringWhiteSpaceTest.phpnu �Iw�� PK �8]�?J�� � 0 | hamcrest-php/tests/Hamcrest/Xml/HasXPathTest.phpnu �Iw�� PK �8]!0�� � g� hamcrest-php/CHANGES.txtnu �Iw�� PK �8]旯� � 7� hamcrest-php/.gush.ymlnu �Iw�� PK �8])�� 5� hamcrest-php/.gitignorenu �Iw�� PK �8] �[� � �� hamcrest-php/LICENSE.txtnu �Iw�� PK �8]u��� � - �� hamcrest-php/generator/GlobalFunctionFile.phpnu �Iw�� PK �8]�g�) & �� hamcrest-php/generator/FactoryFile.phpnu �Iw�� PK �8]c]�W; ; � hamcrest-php/generator/run.phpnu �Iw�� PK �8]�k�3c c & �� hamcrest-php/generator/FactoryCall.phpnu �Iw�� PK �8]�G��
�
+ W� hamcrest-php/generator/FactoryGenerator.phpnu �Iw�� PK �8]��ݬ 1 i� hamcrest-php/generator/parts/matchers_imports.txtnu �Iw�� PK �8] 1 �� hamcrest-php/generator/parts/functions_footer.txtnu �Iw�� PK �8] 2 ?� hamcrest-php/generator/parts/functions_imports.txtnu �Iw�� PK �8]�| �x x , �� hamcrest-php/generator/parts/file_header.txtnu �Iw�� PK �8];��V V 0 u� hamcrest-php/generator/parts/matchers_header.txtnu �Iw�� PK �8]Z��; 0 +� hamcrest-php/generator/parts/matchers_footer.txtnu �Iw�� PK �8] �>� � 1 �� hamcrest-php/generator/parts/functions_header.txtnu �Iw�� PK �8]s�T�� � + |� hamcrest-php/generator/FactoryParameter.phpnu �Iw�� PK �8]D.G ( �� hamcrest-php/generator/FactoryMethod.phpnu �Iw�� PK �8]���;� � ' 3� hamcrest-php/generator/FactoryClass.phpnu �Iw�� PK �8]�Sȴ + h� hamcrest-php/generator/StaticMethodFile.phpnu �Iw�� PK �8]��igf f � hamcrest-php/.travis.ymlnu �Iw�� PK �8]&�=� T T " v� hamcrest-php/hamcrest/Hamcrest.phpnu �Iw�� PK �8]���Ok k 2 �R hamcrest-php/hamcrest/Hamcrest/BaseDescription.phpnu �Iw�� PK �8]&�w�l l > �_ hamcrest-php/hamcrest/Hamcrest/Core/IsCollectionContaining.phpnu �Iw�� PK �8]F���� � 9 �h hamcrest-php/hamcrest/Hamcrest/Core/CombinableMatcher.phpnu �Iw�� PK �8]3j<� � - �o hamcrest-php/hamcrest/Hamcrest/Core/AllOf.phpnu �Iw�� PK �8]7���F F . �u hamcrest-php/hamcrest/Hamcrest/Core/IsSame.phpnu �Iw�� PK �8]Zb.� � - �z hamcrest-php/hamcrest/Hamcrest/Core/AnyOf.phpnu �Iw�� PK �8]��: : - � hamcrest-php/hamcrest/Hamcrest/Core/IsNot.phpnu �Iw�� PK �8]�ٞ� � 0 x� hamcrest-php/hamcrest/Hamcrest/Core/IsTypeOf.phpnu �Iw�� PK �8]"'Q� � ; i� hamcrest-php/hamcrest/Hamcrest/Core/ShortcutCombination.phpnu �Iw�� PK �8]�._�� � . l� hamcrest-php/hamcrest/Hamcrest/Core/IsNull.phpnu �Iw�� PK �8]� � � 3 �� hamcrest-php/hamcrest/Hamcrest/Core/HasToString.phpnu �Iw�� PK �8]Uң�� � 4 �� hamcrest-php/hamcrest/Hamcrest/Core/IsInstanceOf.phpnu �Iw�� PK �8]�n�1� � 3 � hamcrest-php/hamcrest/Hamcrest/Core/IsIdentical.phpnu �Iw�� PK �8]��B{h h + )� hamcrest-php/hamcrest/Hamcrest/Core/Set.phpnu �Iw�� PK �8]+M{K K * � hamcrest-php/hamcrest/Hamcrest/Core/Is.phpnu �Iw�� PK �8]'�
: : - �� hamcrest-php/hamcrest/Hamcrest/Core/Every.phpnu �Iw�� PK �8]T��@9 9 3 (� hamcrest-php/hamcrest/Hamcrest/Core/DescribedAs.phpnu �Iw�� PK �8]�b
�C C / ľ hamcrest-php/hamcrest/Hamcrest/Core/IsEqual.phpnu �Iw�� PK �8]GY��k k 2 f� hamcrest-php/hamcrest/Hamcrest/Core/IsAnything.phpnu �Iw�� PK �8] ׳i� � 3 3� hamcrest-php/hamcrest/Hamcrest/Number/IsCloseTo.phpnu �Iw�� PK �8]��e e < 1� hamcrest-php/hamcrest/Hamcrest/Number/OrderingComparison.phpnu �Iw�� PK �8]�<�5� � ? � hamcrest-php/hamcrest/Hamcrest/Internal/SelfDescribingValue.phpnu �Iw�� PK �8]�Z�W� � 1 S� hamcrest-php/hamcrest/Hamcrest/FeatureMatcher.phpnu �Iw�� PK �8]~2I I < }� hamcrest-php/hamcrest/Hamcrest/TypeSafeDiagnosingMatcher.phpnu �Iw�� PK �8]����c c 4 2� hamcrest-php/hamcrest/Hamcrest/StringDescription.phpnu �Iw�� PK �8]Byu�[ [ 4 �� hamcrest-php/hamcrest/Hamcrest/DiagnosingMatcher.phpnu �Iw�� PK �8]�! � � G �� hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKeyValuePair.phpnu �Iw�� PK �8]�"l, , < � hamcrest-php/hamcrest/Hamcrest/Arrays/SeriesMatchingOnce.phpnu �Iw�� PK �8]h�� � ; �� hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContaining.phpnu �Iw�� PK �8]Q�*�V V 6 � hamcrest-php/hamcrest/Hamcrest/Arrays/MatchingOnce.phpnu �Iw�� PK �8] ��sp p B � hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInOrder.phpnu �Iw�� PK �8]21X� � > | hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingKey.phpnu �Iw�� PK �8]Ά��� � E � hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayContainingInAnyOrder.phpnu �Iw�� PK �8]t�� � � 1 � hamcrest-php/hamcrest/Hamcrest/Arrays/IsArray.phpnu �Iw�� PK �8]�`��� � 9 . hamcrest-php/hamcrest/Hamcrest/Arrays/IsArrayWithSize.phpnu �Iw�� PK �8]�R��� � 2 T4 hamcrest-php/hamcrest/Hamcrest/NullDescription.phpnu �Iw�� PK �8]��M�f f 2 q7 hamcrest-php/hamcrest/Hamcrest/TypeSafeMatcher.phpnu �Iw�� PK �8]_O�� � 0 9C hamcrest-php/hamcrest/Hamcrest/Type/IsObject.phpnu �Iw�� PK �8]�:�a� � 0 �E hamcrest-php/hamcrest/Hamcrest/Type/IsString.phpnu �Iw�� PK �8]�Yˌ� � 2 �G hamcrest-php/hamcrest/Hamcrest/Type/IsResource.phpnu �Iw�� PK �8]!�u� � 1 J hamcrest-php/hamcrest/Hamcrest/Type/IsBoolean.phpnu �Iw�� PK �8]���+ + 0 WL hamcrest-php/hamcrest/Hamcrest/Type/IsDouble.phpnu �Iw�� PK �8]ku"� � 1 �N hamcrest-php/hamcrest/Hamcrest/Type/IsNumeric.phpnu �Iw�� PK �8]_�L�8 8 2 :Q hamcrest-php/hamcrest/Hamcrest/Type/IsCallable.phpnu �Iw�� PK �8]��@ @ 0 �S hamcrest-php/hamcrest/Hamcrest/Type/IsScalar.phpnu �Iw�� PK �8]��@� � / tV hamcrest-php/hamcrest/Hamcrest/Type/IsArray.phpnu �Iw�� PK �8]Ȏp�� � 1 �X hamcrest-php/hamcrest/Hamcrest/Type/IsInteger.phpnu �Iw�� PK �8]r|sp� � . �Z hamcrest-php/hamcrest/Hamcrest/Description.phpnu �Iw�� PK �8] ��[ [ * �a hamcrest-php/hamcrest/Hamcrest/Matcher.phpnu �Iw�� PK �8]
( � � ' �h hamcrest-php/hamcrest/Hamcrest/Util.phpnu �Iw�� PK �8]� �e e @ �p hamcrest-php/hamcrest/Hamcrest/Collection/IsEmptyTraversable.phpnu �Iw�� PK �8]|/N�� � C qv hamcrest-php/hamcrest/Hamcrest/Collection/IsTraversableWithSize.phpnu �Iw�� PK �8]�F4�w w 1 z hamcrest-php/hamcrest/Hamcrest/AssertionError.phpnu �Iw�� PK �8]v�6�J J + W{ hamcrest-php/hamcrest/Hamcrest/Matchers.phpnu �Iw�� PK �8]��=w;
;
0 �� hamcrest-php/hamcrest/Hamcrest/MatcherAssert.phpnu �Iw�� PK �8]av�* * B ^� hamcrest-php/hamcrest/Hamcrest/Text/StringContainsIgnoringCase.phpnu �Iw�� PK �8]O�މR R 6 �� hamcrest-php/hamcrest/Hamcrest/Text/StringContains.phpnu �Iw�� PK �8]�3��� � ; �� hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringCase.phpnu �Iw�� PK �8]z�w � � 6 �� hamcrest-php/hamcrest/Hamcrest/Text/StringEndsWith.phpnu �Iw�� PK �8]�|[� = .� hamcrest-php/hamcrest/Hamcrest/Text/StringContainsInOrder.phpnu �Iw�� PK �8]<��9 9 A �� hamcrest-php/hamcrest/Hamcrest/Text/IsEqualIgnoringWhiteSpace.phpnu �Iw�� PK �8]��� 5 b� hamcrest-php/hamcrest/Hamcrest/Text/IsEmptyString.phpnu �Iw�� PK �8]���G G 8 � hamcrest-php/hamcrest/Hamcrest/Text/SubstringMatcher.phpnu �Iw�� PK �8]�~j� � 8 �� hamcrest-php/hamcrest/Hamcrest/Text/StringStartsWith.phpnu �Iw�� PK �8]x �x� � 6 � hamcrest-php/hamcrest/Hamcrest/Text/MatchesPattern.phpnu �Iw�� PK �8]A��v� � . A hamcrest-php/hamcrest/Hamcrest/BaseMatcher.phpnu �Iw�� PK �8]̥�h 1 Y hamcrest-php/hamcrest/Hamcrest/SelfDescribing.phpnu �Iw�� PK �8]<Z��� � / � hamcrest-php/hamcrest/Hamcrest/Xml/HasXPath.phpnu �Iw�� PK �8]k_�YH H hamcrest-php/composer.jsonnu �Iw�� PK �8]O��� � �" hamcrest-php/README.mdnu �Iw�� PK �8]��;� �+ hamcrest-php/.coveralls.ymlnu �Iw�� PK �8]}�}1 1 <, hamcrest-php/TODO.txtnu �Iw�� PK � � �C �.
