Subversion-Projekte lars-tiefland.laravel_shop

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

    }

}