Subversion-Projekte lars-tiefland.laravel_shop

<?php

/**

 * Mockery

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://github.com/padraic/mockery/blob/master/LICENSE

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to padraic@php.net so we can send you a copy immediately.

 *

 * @category   Mockery

 * @package    Mockery

 * @copyright  Copyright (c) 2010 Pádraic Brady (http://blog.astrumfutura.com)

 * @license    http://github.com/padraic/mockery/blob/master/LICENSE New BSD License

 */

namespace Mockery;

class Configuration

{

    /**

     * Boolean assertion of whether we can mock methods which do not actually

     * exist for the given class or object (ignored for unreal mocks)

     *

     * @var bool

     */

    protected $_allowMockingNonExistentMethod = true;

    /**

     * Boolean assertion of whether we ignore unnecessary mocking of methods,

     * i.e. when method expectations are made, set using a zeroOrMoreTimes()

     * constraint, and then never called. Essentially such expectations are

     * not required and are just taking up test space.

     *

     * @var bool

     */

    protected $_allowMockingMethodsUnnecessarily = true;

    /**

     * @var QuickDefinitionsConfiguration

     */

    protected $_quickDefinitionsConfiguration;

    /**

     * Parameter map for use with PHP internal classes.

     *

     * @var array

     */

    protected $_internalClassParamMap = array();

    protected $_constantsMap = array();

    /**

     * Boolean assertion is reflection caching enabled or not. It should be

     * always enabled, except when using PHPUnit's --static-backup option.

     *

     * @see https://github.com/mockery/mockery/issues/268

     */

    protected $_reflectionCacheEnabled = true;

    public function __construct()

    {

        $this->_quickDefinitionsConfiguration = new QuickDefinitionsConfiguration();

    }

    /**

     * Custom object formatters

     *

     * @var array

     */

    protected $_objectFormatters = array();

    /**

     * Default argument matchers

     *

     * @var array

     */

    protected $_defaultMatchers = array();

    /**

     * Set boolean to allow/prevent mocking of non-existent methods

     *

     * @param bool $flag

     */

    public function allowMockingNonExistentMethods($flag = true)

    {

        $this->_allowMockingNonExistentMethod = (bool) $flag;

    }

    /**

     * Return flag indicating whether mocking non-existent methods allowed

     *

     * @return bool

     */

    public function mockingNonExistentMethodsAllowed()

    {

        return $this->_allowMockingNonExistentMethod;

    }

    /**

     * Set boolean to allow/prevent unnecessary mocking of methods

     *

     * @param bool $flag

     *

     * @deprecated since 1.4.0

     */

    public function allowMockingMethodsUnnecessarily($flag = true)

    {

        @trigger_error(sprintf("The %s method is deprecated and will be removed in a future version of Mockery", __METHOD__), E_USER_DEPRECATED);

        $this->_allowMockingMethodsUnnecessarily = (bool) $flag;

    }

    /**

     * Return flag indicating whether mocking non-existent methods allowed

     *

     * @return bool

     *

     * @deprecated since 1.4.0

     */

    public function mockingMethodsUnnecessarilyAllowed()

    {

        @trigger_error(sprintf("The %s method is deprecated and will be removed in a future version of Mockery", __METHOD__), E_USER_DEPRECATED);

        return $this->_allowMockingMethodsUnnecessarily;

    }

    /**

     * Set a parameter map (array of param signature strings) for the method

     * of an internal PHP class.

     *

     * @param string $class

     * @param string $method

     * @param array $map

     */

    public function setInternalClassMethodParamMap($class, $method, array $map)

    {

        if (\PHP_MAJOR_VERSION > 7) {

            throw new \LogicException('Internal class parameter overriding is not available in PHP 8. Incompatible signatures have been reclassified as fatal errors.');

        }

        if (!isset($this->_internalClassParamMap[strtolower($class)])) {

            $this->_internalClassParamMap[strtolower($class)] = array();

        }

        $this->_internalClassParamMap[strtolower($class)][strtolower($method)] = $map;

    }

    /**

     * Remove all overridden parameter maps from internal PHP classes.

     */

    public function resetInternalClassMethodParamMaps()

    {

        $this->_internalClassParamMap = array();

    }

    /**

     * Get the parameter map of an internal PHP class method

     *

     * @return array|null

     */

    public function getInternalClassMethodParamMap($class, $method)

    {

        if (isset($this->_internalClassParamMap[strtolower($class)][strtolower($method)])) {

            return $this->_internalClassParamMap[strtolower($class)][strtolower($method)];

        }

    }

    public function getInternalClassMethodParamMaps()

    {

        return $this->_internalClassParamMap;

    }

    public function setConstantsMap(array $map)

    {

        $this->_constantsMap = $map;

    }

    public function getConstantsMap()

    {

        return $this->_constantsMap;

    }

    /**

     * Returns the quick definitions configuration

     */

    public function getQuickDefinitions(): QuickDefinitionsConfiguration

    {

        return $this->_quickDefinitionsConfiguration;

    }

    /**

     * Disable reflection caching

     *

     * It should be always enabled, except when using

     * PHPUnit's --static-backup option.

     *

     * @see https://github.com/mockery/mockery/issues/268

     */

    public function disableReflectionCache()

    {

        $this->_reflectionCacheEnabled = false;

    }

    /**

     * Enable reflection caching

     *

     * It should be always enabled, except when using

     * PHPUnit's --static-backup option.

     *

     * @see https://github.com/mockery/mockery/issues/268

     */

    public function enableReflectionCache()

    {

        $this->_reflectionCacheEnabled = true;

    }

    /**

     * Is reflection cache enabled?

     */

    public function reflectionCacheEnabled()

    {

        return $this->_reflectionCacheEnabled;

    }

    public function setObjectFormatter($class, $formatterCallback)

    {

        $this->_objectFormatters[$class] = $formatterCallback;

    }

    public function getObjectFormatter($class, $defaultFormatter)

    {

        $parentClass = $class;

        do {

            $classes[] = $parentClass;

            $parentClass = get_parent_class($parentClass);

        } while ($parentClass);

        $classesAndInterfaces = array_merge($classes, class_implements($class));

        foreach ($classesAndInterfaces as $type) {

            if (isset($this->_objectFormatters[$type])) {

                return $this->_objectFormatters[$type];

            }

        }

        return $defaultFormatter;

    }

    /**

     * @param string $class

     * @param string $matcherClass

     */

    public function setDefaultMatcher($class, $matcherClass)

    {

        if (!is_a($matcherClass, \Mockery\Matcher\MatcherAbstract::class, true) &&

            !is_a($matcherClass, \Hamcrest\Matcher::class, true) &&

            !is_a($matcherClass, \Hamcrest_Matcher::class, true)

        ) {

            throw new \InvalidArgumentException(

                "Matcher class must be either Hamcrest matcher or extend \Mockery\Matcher\MatcherAbstract, " .

                  "'$matcherClass' given."

            );

        }

        $this->_defaultMatchers[$class] = $matcherClass;

    }

    public function getDefaultMatcher($class)

    {

        $parentClass = $class;

        do {

            $classes[] = $parentClass;

            $parentClass = get_parent_class($parentClass);

        } while ($parentClass);

        $classesAndInterfaces = array_merge($classes, class_implements($class));

        foreach ($classesAndInterfaces as $type) {

            if (isset($this->_defaultMatchers[$type])) {

                return $this->_defaultMatchers[$type];

            }

        }

        return null;

    }

}