Full Access File Manager

Current Path: /home/codingbd/demos/ecom3.codingbd.xyz/vendor/mockery/mockery/library/Mockery

Name	Type	Actions
Adapter	Folder
ClosureWrapper.php	File	Edit
CompositeExpectation.php	File	Edit
Configuration.php	File	Edit
Container.php	File	Edit
CountValidator	Folder
Exception	Folder
Exception.php	File	Edit
Expectation.php	File	Edit
ExpectationDirector.php	File	Edit
ExpectationInterface.php	File	Edit
ExpectsHigherOrderMessage.php	File	Edit
Generator	Folder
HigherOrderMessage.php	File	Edit
Instantiator.php	File	Edit
LegacyMockInterface.php	File	Edit
Loader	Folder
Matcher	Folder
MethodCall.php	File	Edit
Mock.php	File	Edit
MockInterface.php	File	Edit
QuickDefinitionsConfiguration.php	File	Edit
ReceivedMethodCalls.php	File	Edit
Reflector.php	File	Edit
Undefined.php	File	Edit
VerificationDirector.php	File	Edit
VerificationExpectation.php	File	Edit

Editing: Configuration.php

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

📁 Full File Explorer

Create New

Editing: Configuration.php