Hamcrest.php
No OneTemporary
Actions

Size

21 KB

Referenced Files

None

Subscribers

None

Hamcrest.php
View Options

	<?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);
	}
	}

File Metadata

Mime Type: text/x-php
Expires: Sat, Oct 3, 20:15 (3 d, 13 h ago)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 16/6e/217874d849bc8d39db943e6478c4
Default Alt Text: Hamcrest.php (21 KB)

Hamcrest.phpNo OneTemporaryActions

Hamcrest.phpView Options

File Metadata

Event Timeline

Hamcrest.php
No OneTemporary
Actions

Hamcrest.php
View Options