<form method="POST">
    <h3>Editing: InvocationHandler.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Framework\MockObject;

use function strtolower;
use Exception;
use PHPUnit\Framework\MockObject\Builder\InvocationMocker;
use PHPUnit\Framework\MockObject\Rule\InvocationOrder;
use Throwable;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class InvocationHandler
{
    /**
     * @var Matcher[]
     */
    private $matchers = [];

    /**
     * @var Matcher[]
     */
    private $matcherMap = [];

    /**
     * @var ConfigurableMethod[]
     */
    private $configurableMethods;

    /**
     * @var bool
     */
    private $returnValueGeneration;

    /**
     * @var Throwable
     */
    private $deferredError;

    public function __construct(array $configurableMethods, bool $returnValueGeneration)
    {
        $this-&gt;configurableMethods   = $configurableMethods;
        $this-&gt;returnValueGeneration = $returnValueGeneration;
    }

    public function hasMatchers(): bool
    {
        foreach ($this-&gt;matchers as $matcher) {
            if ($matcher-&gt;hasMatchers()) {
                return true;
            }
        }

        return false;
    }

    /**
     * Looks up the match builder with identification $id and returns it.
     *
     * @param string $id The identification of the match builder
     */
    public function lookupMatcher(string $id): ?Matcher
    {
        if (isset($this-&gt;matcherMap[$id])) {
            return $this-&gt;matcherMap[$id];
        }

        return null;
    }

    /**
     * Registers a matcher with the identification $id. The matcher can later be
     * looked up using lookupMatcher() to figure out if it has been invoked.
     *
     * @param string  $id      The identification of the matcher
     * @param Matcher $matcher The builder which is being registered
     *
     * @throws MatcherAlreadyRegisteredException
     */
    public function registerMatcher(string $id, Matcher $matcher): void
    {
        if (isset($this-&gt;matcherMap[$id])) {
            throw new MatcherAlreadyRegisteredException($id);
        }

        $this-&gt;matcherMap[$id] = $matcher;
    }

    public function expects(InvocationOrder $rule): InvocationMocker
    {
        $matcher = new Matcher($rule);
        $this-&gt;addMatcher($matcher);

        return new InvocationMocker(
            $this,
            $matcher,
            ...$this-&gt;configurableMethods,
        );
    }

    /**
     * @throws Exception
     * @throws RuntimeException
     */
    public function invoke(Invocation $invocation)
    {
        $exception      = null;
        $hasReturnValue = false;
        $returnValue    = null;

        foreach ($this-&gt;matchers as $match) {
            try {
                if ($match-&gt;matches($invocation)) {
                    $value = $match-&gt;invoked($invocation);

                    if (!$hasReturnValue) {
                        $returnValue    = $value;
                        $hasReturnValue = true;
                    }
                }
            } catch (Exception $e) {
                $exception = $e;
            }
        }

        if ($exception !== null) {
            throw $exception;
        }

        if ($hasReturnValue) {
            return $returnValue;
        }

        if (!$this-&gt;returnValueGeneration) {
            $exception = new ReturnValueNotConfiguredException($invocation);

            if (strtolower($invocation-&gt;getMethodName()) === '__tostring') {
                $this-&gt;deferredError = $exception;

                return '';
            }

            throw $exception;
        }

        return $invocation-&gt;generateReturnValue();
    }

    public function matches(Invocation $invocation): bool
    {
        foreach ($this-&gt;matchers as $matcher) {
            if (!$matcher-&gt;matches($invocation)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @throws Throwable
     */
    public function verify(): void
    {
        foreach ($this-&gt;matchers as $matcher) {
            $matcher-&gt;verify();
        }

        if ($this-&gt;deferredError) {
            throw $this-&gt;deferredError;
        }
    }

    private function addMatcher(Matcher $matcher): void
    {
        $this-&gt;matchers[] = $matcher;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>