{@inheritdoc}

@param $actual
@return Match
483545
public function match($actual = '')
    {
        $match = parent::match($actual);

        return $match->setActual($this->type);
    }
60823
private function requestMethodMatchesExpectation(ServerRequestInterface $httpRequest, RequestConditions $expectedRequest)
    {
        $inputSource = $this->inputSourceLocator->locate(InputSources::METHOD);
        $matcher = $this->matcherLocator->locate(Matchers::SAME_STRING);

        return $matcher->match(
            $inputSource->getValue($httpRequest),
            $expectedRequest->getMethod()->asString()
        );
    }
365613
public static function assertEquals($actual, $expected, Throwable $exception)
    {
        static::makeAssertion($actual === $expected, $exception);
        return $actual;
    }
196764
public static function factory($expected, $actual)
    {
        return new self(sprintf(
            'Expected instance of %s. Got %s',
            $expected,
            is_object($actual) ? get_class($actual) : gettype($actual)
        ));
    }
1220002
public static function _sameMessage($actual, $expected)
    {
        if (preg_match('~^(?P<char>\~|/|@|#).*?(?P=char)$~', (string) $expected)) {
            $same = preg_match($expected, $actual);
        } else {
            $same = $actual === $expected;
        }
        return $same || !$expected;
    }
723168
public static function match($actual, $expected)
    {
        if (is_array($expected) || $expected instanceof Traversable) {
            foreach ($expected as $key => $value) {
                if ($value == $actual) {
                    return true;
                }
            }
        }

        return false;
    }
299006
public static function invalidEntityType($expected, $actual)
    {
        return new self(sprintf(
            'Entity must be an instance of "%s"; got "%s".',
            $expected,
            is_object($actual) ? get_class($actual) : gettype($actual)
        ));
    }
543860
protected function doMatch($actual)
    {
        if ($actual instanceof Traversable) {
            return $this->matchTraversable($actual);
        }

        if (is_array($actual)) {
            return array_search($this->expected, $actual, true) !== false;
        }

        if (is_string($actual)) {
            return strpos($actual, $this->expected) !== false;
        }

        throw new InvalidArgumentException('Inclusion matcher requires a string or array');
    }
956321
@Override
	protected boolean matchesSafely(T actual, Description mismatch)
	{
		boolean matches = true;
		
		for (Matcher<? super T> matcher : matchers)
		{
			if (!matcher.matches(actual))
			{
				if (!matches)
				{
					mismatch.appendText(SEPARATOR);
				}
				
				matches = false;
				
				matcher.describeMismatch(actual, mismatch);
			}
		}
		
		return matches;
	}
497147
public function match($data)
    {
        $match = false;
        $operator = $this->getOperator();

        foreach ($this->getFilters() as $filter) {
            $match = $filter->match($data);

            if ((!$match && $operator === self::LOGICAL_AND)
                || ($match && $operator === self::LOGICAL_OR)
            ) {
                break;
            }
        }

        return $match;
    }
686116
public static function match ($reBody) 
    {
        if (strpos($reBody, '#') !== false) {
            $reBody = str_replace('#', '\#', $reBody);
        }
        $regexp = "#{$reBody}#D";
        return function (Field $field) use ($regexp) {
            return (bool)preg_match($regexp, $field->getShorthand());
        };
    }
1165377
public function match($key, $value, $bool, $filter = false, array $params = []) {
        if (is_array($key)) {
            return $this->multiMatch($key, $value, $bool, $filter, $params);
        }
        if (is_array($value)) {
            return $this->matches($key, $value, $bool, $filter, $params);
        }
        $this->addBool($this->makeFilteredQuery(["match" => [$key => ["query" => $value] + $params]], $filter), $bool, $filter);
        return $this;
    }
494536
public function compareRute(string $actual, string $peticion): bool {
        $this->identifyIndexes($actual);
        $this->clean($actual, $peticion);

        return $this->actual === $this->peticion;
    }
1056154
public function doMatch($actual)
    {
        $this->type = gettype($actual);

        return $this->expected === $this->type;
    }
1066143
public static function match($actual, $expected = null)
    {
        if (! is_callable($actual)) {
            throw new InvalidArgumentException('actual must be callable');
        }

        $a = static::actual($actual);
        static::_buildDescription($a, $expected);

        if (is_callable($expected)) {
            return $expected($a);
        }

        return !!preg_match($expected, $a);
    }
126754
public static function match($actual, $expected)
    {
        $actual = static::_nl($actual);
        $expected = static::_nl($expected);
        return $actual == $expected;
    }
1202366
public function match(ServerRequestInterface $request)
    {
        $method = strtoupper($request->getMethod());
        if (! empty($this->methods) && ! in_array($method, $this->methods)) {
            return false;
        }
        $uri    = $request->getUri();
        $scheme = $uri->getScheme();
        if (! empty($this->schemes) && ! in_array($scheme, $this->schemes)) {
            return false;
        }
        $path = rtrim($uri->getPath(), '/');

        $regex  = $this->compiled;
        $result = preg_match($regex, $path, $matches);

        if (! $result) {
            return false;
        }

        $params = $this->defaults;
        foreach ($matches as $key => &$value) {
            if (is_int($key)) {
                continue;
            }
            if ($value === '') {
                continue;
            }
            $params[$key] = $value;
        }
        $params['request_method'] = $method;
        $params['request_scheme'] = $scheme;

        return new RouteMatch($params);
    }