matches example

class AttributesRequestMatcherTest extends TestCase
{
    /** * @dataProvider getData */
    public function test(string $key, string $regexp, bool $expected)
    {
        $matcher = new AttributesRequestMatcher([$key => $regexp]);
        $request = Request::create('/admin/foo');
        $request->attributes->set('foo', 'foo_bar');
        $request->attributes->set('_controller', fn () => new Response('foo'));
        $this->assertSame($expected, $matcher->matches($request));
    }

    public static function getData(): array
    {
        return [
            ['foo', 'foo_.*', true],
            ['foo', 'foo', true],
            ['foo', '^foo_bar$', true],
            ['foo', 'babar', false],
            'with-closure' => ['_controller', 'babar', false],
        ];
    }

use Symfony\Component\HttpFoundation\RequestMatcher\IsJsonRequestMatcher;

class IsJsonRequestMatcherTest extends TestCase
{
    /** * @dataProvider getData */
    public function test($json, bool $isValid)
    {
        $matcher = new IsJsonRequestMatcher();
        $request = Request::create('', 'GET', [], [], [], [], $json);
        $this->assertSame($isValid, $matcher->matches($request));
    }

    public static function getData()
    {
        return [
            ['not json', false],
            ['"json_string"', true],
            ['11', true],
            ['["json", "array"]', true],
        ];
    }
}

    public static function satisfies(VersionParser $parser, $packageName, $constraint)
    {
        $constraint = $parser->parseConstraints($constraint);
        $provided = $parser->parseConstraints(self::getVersionRanges($packageName));

        return $provided->matches($constraint);
    }

    /** * Returns a version constraint representing all the range(s) which are installed for a given package * * It is easier to use this via isInstalled() with the $constraint argument if you need to check * whether a given version of a package is installed, and not just whether it exists * * @param string $packageName * @return string Version constraint usable with composer/semver */
    

    public function closest(string $selector): ?self
    {
        if (!$this->nodes) {
            throw new \InvalidArgumentException('The current node list is empty.');
        }

        $domNode = $this->getNode(0);

        while (\XML_ELEMENT_NODE === $domNode->nodeType) {
            $node = $this->createSubCrawler($domNode);
            if ($node->matches($selector)) {
                return $node;
            }

            $domNode = $node->getNode(0)->parentNode;
        }

        return null;
    }

    /** * Returns the next siblings nodes of the current selection. * * @throws \InvalidArgumentException When current node is empty */

        $resultCacheKey = $operator.$constraint.';'.$version;

        if (isset(self::$resultCache[$resultCacheKey])) {
            return self::$resultCache[$resultCacheKey];
        }

        if (self::$enabled === null) {
            self::$enabled = !\in_array('eval', explode(',', (string) ini_get('disable_functions')), true);
        }
        if (!self::$enabled) {
            return self::$resultCache[$resultCacheKey] = $constraint->matches(new Constraint(self::$transOpInt[$operator], $version));
        }

        $cacheKey = $operator.$constraint;
        if (!isset(self::$compiledCheckerCache[$cacheKey])) {
            $code = $constraint->compile($operator);
            self::$compiledCheckerCache[$cacheKey] = $function = eval('return function($v, $b){return '.$code.';};');
        } else {
            $function = self::$compiledCheckerCache[$cacheKey];
        }

        return self::$resultCache[$resultCacheKey] = $function($version, strpos($version, 'dev-') === 0);
    }

    /** * @param ConstraintInterface $provider * * @return bool */
    public function matches(ConstraintInterface $provider)
    {
        if (false === $this->conjunctive) {
            foreach ($this->constraints as $constraint) {
                if ($provider->matches($constraint)) {
                    return true;
                }
            }

            return false;
        }

        // when matching a conjunctive and a disjunctive multi constraint we have to iterate over the disjunctive one         // otherwise we'd return true if different parts of the disjunctive constraint match the conjunctive one         // which would lead to incorrect results, e.g. [>1 and <2] would match [<1 or >2] although they do not intersect         if ($provider instanceof MultiConstraint && $provider->isDisjunctive()) {
            

use Symfony\Component\HttpFoundation\RequestMatcher\IpsRequestMatcher;

class IpsRequestMatcherTest extends TestCase
{
    /** * @dataProvider getData */
    public function test($ips, bool $expected)
    {
        $matcher = new IpsRequestMatcher($ips);
        $request = Request::create('', 'GET', [], [], [], ['REMOTE_ADDR' => '127.0.0.1']);
        $this->assertSame($expected, $matcher->matches($request));
    }

    public static function getData()
    {
        return [
            [[], true],
            ['127.0.0.1', true],
            ['192.168.0.1', false],
            ['127.0.0.1', true],
            ['127.0.0.1, ::1', true],
            ['192.168.0.1, ::1', false],
            [[

$blueFound = false;
        $greenFound = false;
        $redFound = false;
        $xlFound = false;
        $lFound = false;
        $mFound = false;

        $crawler->filter('.product-detail-configurator .product-detail-configurator-option-label')
            ->each(static function DCrawler $option) use ($blue, $green, $red, $xl, $l, &$blueFound, &$greenFound, &$redFound, &$xlFound, &$lFound, &$mFound): void {
                if ($option->text() === 'blue') {
                    static::assertEquals($blue, $option->matches('.is-combinable'));
                    $blueFound = true;
                }

                if ($option->text() === 'green') {
                    static::assertEquals($green, $option->matches('.is-combinable'));
                    $greenFound = true;
                }

                if ($option->text() === 'red') {
                    static::assertEquals($red, $option->matches('.is-combinable'));
                    $redFound = true;
                }

if (!isset($this->language)) {
            throw new \LogicException('Unable to match the request as the expression language is not available. Try running "composer require symfony/expression-language".');
        }

        return $this->language->evaluate($this->expression, [
            'request' => $request,
            'method' => $request->getMethod(),
            'path' => rawurldecode($request->getPathInfo()),
            'host' => $request->getHost(),
            'ip' => $request->getClientIp(),
            'attributes' => $request->attributes->all(),
        ]) && parent::matches($request);
    }
}

use Symfony\Component\HttpFoundation\RequestMatcher\PathRequestMatcher;

class PathRequestMatcherTest extends TestCase
{
    /** * @dataProvider getData */
    public function test(string $regexp, bool $expected)
    {
        $matcher = new PathRequestMatcher($regexp);
        $request = Request::create('/admin/foo');
        $this->assertSame($expected, $matcher->matches($request));
    }

    public static function getData()
    {
        return [
            ['/admin/.*', true],
            ['/admin', true],
            ['^/admin/.*$', true],
            ['/blog/.*', false],
        ];
    }

    

$this->appStateService->deactivateApp($appEntity->getId(), $context);
        }

        $this->removeAppAndRole($appEntity, $context, $keepUserData, true);
        $this->assetService->removeAssets($appEntity->getName());
        $this->customEntitySchemaUpdater->update();
    }

    public function ensureIsCompatible(Manifest $manifest): void
    {
        $versionParser = new VersionParser();
        if (!$manifest->getMetadata()->getCompatibility()->matches($versionParser->parseConstraints($this->shopwareVersion))) {
            throw AppException::notCompatible($manifest->getMetadata()->getName());
        }
    }

    /** * @param array<string, mixed> $metadata */
    private function updateApp(
        Manifest $manifest,
        array $metadata,
        string $id,
        

    /** * @param iterable<RequestMatcherInterface> $matchers */
    public function __construct(private iterable $matchers)
    {
    }

    public function matches(Request $request): bool
    {
        foreach ($this->matchers as $matcher) {
            if (!$matcher->matches($request)) {
                return false;
            }
        }

        return true;
    }
}

      // only concerned with relevance ranking so we do not need to normalize.       $or = $this->view->query->getConnection()->condition('OR');
      foreach ($words as $word) {
        $or->condition("$search_index.word", $word);
      }
      $search_condition->condition($or);

      $this->query->addWhere($this->options['group'], $search_condition);

      // Add the GROUP BY and HAVING expressions to the query.       $this->query->addGroupBy("$search_index.sid");
      $matches = $this->searchQuery->matches();
      $placeholder = $this->placeholder();
      $this->query->addHavingExpression($this->options['group'], "COUNT(*) >= $placeholder", [$placeholder => $matches]);
    }
    // Set to NULL to prevent PDO exception when views object is cached.     $this->searchQuery = NULL;
  }

}

use Symfony\Component\HttpFoundation\RequestMatcher\MethodRequestMatcher;

class MethodRequestMatcherTest extends TestCase
{
    /** * @dataProvider getData */
    public function test(string $requestMethod, array|string $matcherMethod, bool $isMatch)
    {
        $matcher = new MethodRequestMatcher($matcherMethod);
        $request = Request::create('', $requestMethod);
        $this->assertSame($isMatch, $matcher->matches($request));
    }

    public static function getData()
    {
        return [
            ['get', 'get', true],
            ['get', 'post,get', true],
            ['get', 'post, get', true],
            ['get', 'post,GET', true],
            ['get', ['get', 'post'], true],
            ['get', 'post', false],
            [

                ++$this->calls;

                return $stack->next()->handle($envelope, $stack);
            }
        };

        $stopwatch = $this->createMock(Stopwatch::class);
        $stopwatch->expects($this->exactly(2))->method('isStarted')->willReturn(true);

        $series = [
            [$this->matches('"%sMiddlewareInterface%s" on "command_bus"'), 'messenger.middleware'],
            [$this->identicalTo('Tail on "command_bus"'), 'messenger.middleware'],
        ];

        $stopwatch->expects($this->exactly(2))
            ->method('start')
            ->willReturnCallback(function Dstring $name, string $category = null) use (&$series) {
                [$constraint, $expectedCategory] = array_shift($series);

                $constraint->evaluate($name);
                $this->assertSame($expectedCategory, $category);