upgrade

vendor/symfony/routing/Tests/Matcher/DumpedRedirectableUrlMatcherTest.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Routing\Tests\Matcher;
+
+use Symfony\Component\Routing\Matcher\Dumper\PhpMatcherDumper;
+use Symfony\Component\Routing\Matcher\RedirectableUrlMatcherInterface;
+use Symfony\Component\Routing\Matcher\UrlMatcher;
+use Symfony\Component\Routing\RequestContext;
+use Symfony\Component\Routing\RouteCollection;
+
+class DumpedRedirectableUrlMatcherTest extends RedirectableUrlMatcherTest
+{
+    protected function getUrlMatcher(RouteCollection $routes, RequestContext $context = null)
+    {
+        static $i = 0;
+
+        $class = 'DumpedRedirectableUrlMatcher'.++$i;
+        $dumper = new PhpMatcherDumper($routes);
+        eval('?>'.$dumper->dump(['class' => $class, 'base_class' => 'Symfony\Component\Routing\Tests\Matcher\TestDumpedRedirectableUrlMatcher']));
+
+        return $this->getMockBuilder($class)
+            ->setConstructorArgs([$context ?: new RequestContext()])
+            ->setMethods(['redirect'])
+            ->getMock();
+    }
+}
+
+class TestDumpedRedirectableUrlMatcher extends UrlMatcher implements RedirectableUrlMatcherInterface
+{
+    public function redirect($path, $route, $scheme = null)
+    {
+        return [];
+    }
+}

vendor/symfony/routing/Tests/Matcher/DumpedUrlMatcherTest.php

@@ -0,0 +1,44 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Routing\Tests\Matcher;
+
+use Symfony\Component\Routing\Matcher\Dumper\PhpMatcherDumper;
+use Symfony\Component\Routing\RequestContext;
+use Symfony\Component\Routing\RouteCollection;
+
+class DumpedUrlMatcherTest extends UrlMatcherTest
+{
+    public function testSchemeRequirement()
+    {
+        $this->expectException('LogicException');
+        $this->expectExceptionMessage('The "schemes" requirement is only supported for URL matchers that implement RedirectableUrlMatcherInterface.');
+        parent::testSchemeRequirement();
+    }
+
+    public function testSchemeAndMethodMismatch()
+    {
+        $this->expectException('LogicException');
+        $this->expectExceptionMessage('The "schemes" requirement is only supported for URL matchers that implement RedirectableUrlMatcherInterface.');
+        parent::testSchemeRequirement();
+    }
+
+    protected function getUrlMatcher(RouteCollection $routes, RequestContext $context = null)
+    {
+        static $i = 0;
+
+        $class = 'DumpedUrlMatcher'.++$i;
+        $dumper = new PhpMatcherDumper($routes);
+        eval('?>'.$dumper->dump(['class' => $class]));
+
+        return new $class($context ?: new RequestContext());
+    }
+}

vendor/symfony/routing/Tests/Matcher/Dumper/DumperCollectionTest.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Routing\Tests\Matcher\Dumper;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Matcher\Dumper\DumperCollection;
+
+class DumperCollectionTest extends TestCase
+{
+    public function testGetRoot()
+    {
+        $a = new DumperCollection();
+
+        $b = new DumperCollection();
+        $a->add($b);
+
+        $c = new DumperCollection();
+        $b->add($c);
+
+        $d = new DumperCollection();
+        $c->add($d);
+
+        $this->assertSame($a, $c->getRoot());
+    }
+}

vendor/symfony/routing/Tests/Matcher/Dumper/PhpMatcherDumperTest.php

@@ -0,0 +1,454 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Routing\Tests\Matcher\Dumper;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Matcher\Dumper\PhpMatcherDumper;
+use Symfony\Component\Routing\Matcher\RedirectableUrlMatcherInterface;
+use Symfony\Component\Routing\Matcher\UrlMatcher;
+use Symfony\Component\Routing\RequestContext;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+class PhpMatcherDumperTest extends TestCase
+{
+    /**
+     * @var string
+     */
+    private $matcherClass;
+
+    /**
+     * @var string
+     */
+    private $dumpPath;
+
+    protected function setUp()
+    {
+        parent::setUp();
+
+        $this->matcherClass = uniqid('ProjectUrlMatcher');
+        $this->dumpPath = sys_get_temp_dir().\DIRECTORY_SEPARATOR.'php_matcher.'.$this->matcherClass.'.php';
+    }
+
+    protected function tearDown()
+    {
+        parent::tearDown();
+
+        @unlink($this->dumpPath);
+    }
+
+    public function testDumpWhenSchemeIsUsedWithoutAProperDumper()
+    {
+        $this->expectException('LogicException');
+        $collection = new RouteCollection();
+        $collection->add('secure', new Route(
+            '/secure',
+            [],
+            [],
+            [],
+            '',
+            ['https']
+        ));
+        $dumper = new PhpMatcherDumper($collection);
+        $dumper->dump();
+    }
+
+    public function testRedirectPreservesUrlEncoding()
+    {
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/foo:bar/'));
+
+        $class = $this->generateDumpedMatcher($collection, true);
+
+        $matcher = $this->getMockBuilder($class)
+                        ->setMethods(['redirect'])
+                        ->setConstructorArgs([new RequestContext()])
+                        ->getMock();
+
+        $matcher->expects($this->once())->method('redirect')->with('/foo%3Abar/', 'foo')->willReturn([]);
+
+        $matcher->match('/foo%3Abar');
+    }
+
+    /**
+     * @dataProvider getRouteCollections
+     */
+    public function testDump(RouteCollection $collection, $fixture, $options = [])
+    {
+        $basePath = __DIR__.'/../../Fixtures/dumper/';
+
+        $dumper = new PhpMatcherDumper($collection);
+        $this->assertStringEqualsFile($basePath.$fixture, $dumper->dump($options), '->dump() correctly dumps routes as optimized PHP code.');
+    }
+
+    public function getRouteCollections()
+    {
+        /* test case 1 */
+
+        $collection = new RouteCollection();
+
+        $collection->add('overridden', new Route('/overridden'));
+
+        // defaults and requirements
+        $collection->add('foo', new Route(
+            '/foo/{bar}',
+            ['def' => 'test'],
+            ['bar' => 'baz|symfony']
+        ));
+        // method requirement
+        $collection->add('bar', new Route(
+            '/bar/{foo}',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['GET', 'head']
+        ));
+        // GET method requirement automatically adds HEAD as valid
+        $collection->add('barhead', new Route(
+            '/barhead/{foo}',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['GET']
+        ));
+        // simple
+        $collection->add('baz', new Route(
+            '/test/baz'
+        ));
+        // simple with extension
+        $collection->add('baz2', new Route(
+            '/test/baz.html'
+        ));
+        // trailing slash
+        $collection->add('baz3', new Route(
+            '/test/baz3/'
+        ));
+        // trailing slash with variable
+        $collection->add('baz4', new Route(
+            '/test/{foo}/'
+        ));
+        // trailing slash and method
+        $collection->add('baz5', new Route(
+            '/test/{foo}/',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['post']
+        ));
+        // complex name
+        $collection->add('baz.baz6', new Route(
+            '/test/{foo}/',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['put']
+        ));
+        // defaults without variable
+        $collection->add('foofoo', new Route(
+            '/foofoo',
+            ['def' => 'test']
+        ));
+        // pattern with quotes
+        $collection->add('quoter', new Route(
+            '/{quoter}',
+            [],
+            ['quoter' => '[\']+']
+        ));
+        // space in pattern
+        $collection->add('space', new Route(
+            '/spa ce'
+        ));
+
+        // prefixes
+        $collection1 = new RouteCollection();
+        $collection1->add('overridden', new Route('/overridden1'));
+        $collection1->add('foo1', new Route('/{foo}'));
+        $collection1->add('bar1', new Route('/{bar}'));
+        $collection1->addPrefix('/b\'b');
+        $collection2 = new RouteCollection();
+        $collection2->addCollection($collection1);
+        $collection2->add('overridden', new Route('/{var}', [], ['var' => '.*']));
+        $collection1 = new RouteCollection();
+        $collection1->add('foo2', new Route('/{foo1}'));
+        $collection1->add('bar2', new Route('/{bar1}'));
+        $collection1->addPrefix('/b\'b');
+        $collection2->addCollection($collection1);
+        $collection2->addPrefix('/a');
+        $collection->addCollection($collection2);
+
+        // overridden through addCollection() and multiple sub-collections with no own prefix
+        $collection1 = new RouteCollection();
+        $collection1->add('overridden2', new Route('/old'));
+        $collection1->add('helloWorld', new Route('/hello/{who}', ['who' => 'World!']));
+        $collection2 = new RouteCollection();
+        $collection3 = new RouteCollection();
+        $collection3->add('overridden2', new Route('/new'));
+        $collection3->add('hey', new Route('/hey/'));
+        $collection2->addCollection($collection3);
+        $collection1->addCollection($collection2);
+        $collection1->addPrefix('/multi');
+        $collection->addCollection($collection1);
+
+        // "dynamic" prefix
+        $collection1 = new RouteCollection();
+        $collection1->add('foo3', new Route('/{foo}'));
+        $collection1->add('bar3', new Route('/{bar}'));
+        $collection1->addPrefix('/b');
+        $collection1->addPrefix('{_locale}');
+        $collection->addCollection($collection1);
+
+        // route between collections
+        $collection->add('ababa', new Route('/ababa'));
+
+        // collection with static prefix but only one route
+        $collection1 = new RouteCollection();
+        $collection1->add('foo4', new Route('/{foo}'));
+        $collection1->addPrefix('/aba');
+        $collection->addCollection($collection1);
+
+        // prefix and host
+
+        $collection1 = new RouteCollection();
+
+        $route1 = new Route('/route1', [], [], [], 'a.example.com');
+        $collection1->add('route1', $route1);
+
+        $route2 = new Route('/c2/route2', [], [], [], 'a.example.com');
+        $collection1->add('route2', $route2);
+
+        $route3 = new Route('/c2/route3', [], [], [], 'b.example.com');
+        $collection1->add('route3', $route3);
+
+        $route4 = new Route('/route4', [], [], [], 'a.example.com');
+        $collection1->add('route4', $route4);
+
+        $route5 = new Route('/route5', [], [], [], 'c.example.com');
+        $collection1->add('route5', $route5);
+
+        $route6 = new Route('/route6', [], [], [], null);
+        $collection1->add('route6', $route6);
+
+        $collection->addCollection($collection1);
+
+        // host and variables
+
+        $collection1 = new RouteCollection();
+
+        $route11 = new Route('/route11', [], [], [], '{var1}.example.com');
+        $collection1->add('route11', $route11);
+
+        $route12 = new Route('/route12', ['var1' => 'val'], [], [], '{var1}.example.com');
+        $collection1->add('route12', $route12);
+
+        $route13 = new Route('/route13/{name}', [], [], [], '{var1}.example.com');
+        $collection1->add('route13', $route13);
+
+        $route14 = new Route('/route14/{name}', ['var1' => 'val'], [], [], '{var1}.example.com');
+        $collection1->add('route14', $route14);
+
+        $route15 = new Route('/route15/{name}', [], [], [], 'c.example.com');
+        $collection1->add('route15', $route15);
+
+        $route16 = new Route('/route16/{name}', ['var1' => 'val'], [], [], null);
+        $collection1->add('route16', $route16);
+
+        $route17 = new Route('/route17', [], [], [], null);
+        $collection1->add('route17', $route17);
+
+        $collection->addCollection($collection1);
+
+        // multiple sub-collections with a single route and a prefix each
+        $collection1 = new RouteCollection();
+        $collection1->add('a', new Route('/a...'));
+        $collection2 = new RouteCollection();
+        $collection2->add('b', new Route('/{var}'));
+        $collection3 = new RouteCollection();
+        $collection3->add('c', new Route('/{var}'));
+        $collection3->addPrefix('/c');
+        $collection2->addCollection($collection3);
+        $collection2->addPrefix('/b');
+        $collection1->addCollection($collection2);
+        $collection1->addPrefix('/a');
+        $collection->addCollection($collection1);
+
+        /* test case 2 */
+
+        $redirectCollection = clone $collection;
+
+        // force HTTPS redirection
+        $redirectCollection->add('secure', new Route(
+            '/secure',
+            [],
+            [],
+            [],
+            '',
+            ['https']
+        ));
+
+        // force HTTP redirection
+        $redirectCollection->add('nonsecure', new Route(
+            '/nonsecure',
+            [],
+            [],
+            [],
+            '',
+            ['http']
+        ));
+
+        /* test case 3 */
+
+        $rootprefixCollection = new RouteCollection();
+        $rootprefixCollection->add('static', new Route('/test'));
+        $rootprefixCollection->add('dynamic', new Route('/{var}'));
+        $rootprefixCollection->addPrefix('rootprefix');
+        $route = new Route('/with-condition');
+        $route->setCondition('context.getMethod() == "GET"');
+        $rootprefixCollection->add('with-condition', $route);
+
+        /* test case 4 */
+        $headMatchCasesCollection = new RouteCollection();
+        $headMatchCasesCollection->add('just_head', new Route(
+            '/just_head',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['HEAD']
+        ));
+        $headMatchCasesCollection->add('head_and_get', new Route(
+            '/head_and_get',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['HEAD', 'GET']
+        ));
+        $headMatchCasesCollection->add('get_and_head', new Route(
+            '/get_and_head',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['GET', 'HEAD']
+        ));
+        $headMatchCasesCollection->add('post_and_head', new Route(
+            '/post_and_head',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['POST', 'HEAD']
+        ));
+        $headMatchCasesCollection->add('put_and_post', new Route(
+            '/put_and_post',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['PUT', 'POST']
+        ));
+        $headMatchCasesCollection->add('put_and_get_and_head', new Route(
+            '/put_and_post',
+            [],
+            [],
+            [],
+            '',
+            [],
+            ['PUT', 'GET', 'HEAD']
+        ));
+
+        /* test case 5 */
+        $groupOptimisedCollection = new RouteCollection();
+        $groupOptimisedCollection->add('a_first', new Route('/a/11'));
+        $groupOptimisedCollection->add('a_second', new Route('/a/22'));
+        $groupOptimisedCollection->add('a_third', new Route('/a/333'));
+        $groupOptimisedCollection->add('a_wildcard', new Route('/{param}'));
+        $groupOptimisedCollection->add('a_fourth', new Route('/a/44/'));
+        $groupOptimisedCollection->add('a_fifth', new Route('/a/55/'));
+        $groupOptimisedCollection->add('a_sixth', new Route('/a/66/'));
+        $groupOptimisedCollection->add('nested_wildcard', new Route('/nested/{param}'));
+        $groupOptimisedCollection->add('nested_a', new Route('/nested/group/a/'));
+        $groupOptimisedCollection->add('nested_b', new Route('/nested/group/b/'));
+        $groupOptimisedCollection->add('nested_c', new Route('/nested/group/c/'));
+
+        $groupOptimisedCollection->add('slashed_a', new Route('/slashed/group/'));
+        $groupOptimisedCollection->add('slashed_b', new Route('/slashed/group/b/'));
+        $groupOptimisedCollection->add('slashed_c', new Route('/slashed/group/c/'));
+
+        $trailingSlashCollection = new RouteCollection();
+        $trailingSlashCollection->add('simple_trailing_slash_no_methods', new Route('/trailing/simple/no-methods/', [], [], [], '', [], []));
+        $trailingSlashCollection->add('simple_trailing_slash_GET_method', new Route('/trailing/simple/get-method/', [], [], [], '', [], ['GET']));
+        $trailingSlashCollection->add('simple_trailing_slash_HEAD_method', new Route('/trailing/simple/head-method/', [], [], [], '', [], ['HEAD']));
+        $trailingSlashCollection->add('simple_trailing_slash_POST_method', new Route('/trailing/simple/post-method/', [], [], [], '', [], ['POST']));
+        $trailingSlashCollection->add('regex_trailing_slash_no_methods', new Route('/trailing/regex/no-methods/{param}/', [], [], [], '', [], []));
+        $trailingSlashCollection->add('regex_trailing_slash_GET_method', new Route('/trailing/regex/get-method/{param}/', [], [], [], '', [], ['GET']));
+        $trailingSlashCollection->add('regex_trailing_slash_HEAD_method', new Route('/trailing/regex/head-method/{param}/', [], [], [], '', [], ['HEAD']));
+        $trailingSlashCollection->add('regex_trailing_slash_POST_method', new Route('/trailing/regex/post-method/{param}/', [], [], [], '', [], ['POST']));
+
+        $trailingSlashCollection->add('simple_not_trailing_slash_no_methods', new Route('/not-trailing/simple/no-methods', [], [], [], '', [], []));
+        $trailingSlashCollection->add('simple_not_trailing_slash_GET_method', new Route('/not-trailing/simple/get-method', [], [], [], '', [], ['GET']));
+        $trailingSlashCollection->add('simple_not_trailing_slash_HEAD_method', new Route('/not-trailing/simple/head-method', [], [], [], '', [], ['HEAD']));
+        $trailingSlashCollection->add('simple_not_trailing_slash_POST_method', new Route('/not-trailing/simple/post-method', [], [], [], '', [], ['POST']));
+        $trailingSlashCollection->add('regex_not_trailing_slash_no_methods', new Route('/not-trailing/regex/no-methods/{param}', [], [], [], '', [], []));
+        $trailingSlashCollection->add('regex_not_trailing_slash_GET_method', new Route('/not-trailing/regex/get-method/{param}', [], [], [], '', [], ['GET']));
+        $trailingSlashCollection->add('regex_not_trailing_slash_HEAD_method', new Route('/not-trailing/regex/head-method/{param}', [], [], [], '', [], ['HEAD']));
+        $trailingSlashCollection->add('regex_not_trailing_slash_POST_method', new Route('/not-trailing/regex/post-method/{param}', [], [], [], '', [], ['POST']));
+
+        return [
+           [new RouteCollection(), 'url_matcher0.php', []],
+           [$collection, 'url_matcher1.php', []],
+           [$redirectCollection, 'url_matcher2.php', ['base_class' => 'Symfony\Component\Routing\Tests\Fixtures\RedirectableUrlMatcher']],
+           [$rootprefixCollection, 'url_matcher3.php', []],
+           [$headMatchCasesCollection, 'url_matcher4.php', []],
+           [$groupOptimisedCollection, 'url_matcher5.php', ['base_class' => 'Symfony\Component\Routing\Tests\Fixtures\RedirectableUrlMatcher']],
+           [$trailingSlashCollection, 'url_matcher6.php', []],
+           [$trailingSlashCollection, 'url_matcher7.php', ['base_class' => 'Symfony\Component\Routing\Tests\Fixtures\RedirectableUrlMatcher']],
+        ];
+    }
+
+    private function generateDumpedMatcher(RouteCollection $collection, $redirectableStub = false)
+    {
+        $options = ['class' => $this->matcherClass];
+
+        if ($redirectableStub) {
+            $options['base_class'] = '\Symfony\Component\Routing\Tests\Matcher\Dumper\RedirectableUrlMatcherStub';
+        }
+
+        $dumper = new PhpMatcherDumper($collection);
+        $code = $dumper->dump($options);
+
+        file_put_contents($this->dumpPath, $code);
+        include $this->dumpPath;
+
+        return $this->matcherClass;
+    }
+}
+
+abstract class RedirectableUrlMatcherStub extends UrlMatcher implements RedirectableUrlMatcherInterface
+{
+    public function redirect($path, $route, $scheme = null)
+    {
+    }
+}

vendor/symfony/routing/Tests/Matcher/Dumper/StaticPrefixCollectionTest.php

@@ -0,0 +1,175 @@
+<?php
+
+namespace Symfony\Component\Routing\Tests\Matcher\Dumper;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Matcher\Dumper\StaticPrefixCollection;
+use Symfony\Component\Routing\Route;
+
+class StaticPrefixCollectionTest extends TestCase
+{
+    /**
+     * @dataProvider routeProvider
+     */
+    public function testGrouping(array $routes, $expected)
+    {
+        $collection = new StaticPrefixCollection('/');
+
+        foreach ($routes as $route) {
+            list($path, $name) = $route;
+            $staticPrefix = (new Route($path))->compile()->getStaticPrefix();
+            $collection->addRoute($staticPrefix, $name);
+        }
+
+        $collection->optimizeGroups();
+        $dumped = $this->dumpCollection($collection);
+        $this->assertEquals($expected, $dumped);
+    }
+
+    public function routeProvider()
+    {
+        return [
+            'Simple - not nested' => [
+                [
+                    ['/', 'root'],
+                    ['/prefix/segment/', 'prefix_segment'],
+                    ['/leading/segment/', 'leading_segment'],
+                ],
+                <<<EOF
+/ root
+/prefix/segment prefix_segment
+/leading/segment leading_segment
+EOF
+            ],
+            'Not nested - group too small' => [
+                [
+                    ['/', 'root'],
+                    ['/prefix/segment/aa', 'prefix_segment'],
+                    ['/prefix/segment/bb', 'leading_segment'],
+                ],
+                <<<EOF
+/ root
+/prefix/segment/aa prefix_segment
+/prefix/segment/bb leading_segment
+EOF
+            ],
+            'Nested - contains item at intersection' => [
+                [
+                    ['/', 'root'],
+                    ['/prefix/segment/', 'prefix_segment'],
+                    ['/prefix/segment/bb', 'leading_segment'],
+                ],
+                <<<EOF
+/ root
+/prefix/segment
+-> /prefix/segment prefix_segment
+-> /prefix/segment/bb leading_segment
+EOF
+            ],
+            'Simple one level nesting' => [
+                [
+                    ['/', 'root'],
+                    ['/group/segment/', 'nested_segment'],
+                    ['/group/thing/', 'some_segment'],
+                    ['/group/other/', 'other_segment'],
+                ],
+                <<<EOF
+/ root
+/group
+-> /group/segment nested_segment
+-> /group/thing some_segment
+-> /group/other other_segment
+EOF
+            ],
+            'Retain matching order with groups' => [
+                [
+                    ['/group/aa/', 'aa'],
+                    ['/group/bb/', 'bb'],
+                    ['/group/cc/', 'cc'],
+                    ['/', 'root'],
+                    ['/group/dd/', 'dd'],
+                    ['/group/ee/', 'ee'],
+                    ['/group/ff/', 'ff'],
+                ],
+                <<<EOF
+/group
+-> /group/aa aa
+-> /group/bb bb
+-> /group/cc cc
+/ root
+/group
+-> /group/dd dd
+-> /group/ee ee
+-> /group/ff ff
+EOF
+            ],
+            'Retain complex matching order with groups at base' => [
+                [
+                    ['/aaa/111/', 'first_aaa'],
+                    ['/prefixed/group/aa/', 'aa'],
+                    ['/prefixed/group/bb/', 'bb'],
+                    ['/prefixed/group/cc/', 'cc'],
+                    ['/prefixed/', 'root'],
+                    ['/prefixed/group/dd/', 'dd'],
+                    ['/prefixed/group/ee/', 'ee'],
+                    ['/prefixed/group/ff/', 'ff'],
+                    ['/aaa/222/', 'second_aaa'],
+                    ['/aaa/333/', 'third_aaa'],
+                ],
+                <<<EOF
+/aaa
+-> /aaa/111 first_aaa
+-> /aaa/222 second_aaa
+-> /aaa/333 third_aaa
+/prefixed
+-> /prefixed/group
+-> -> /prefixed/group/aa aa
+-> -> /prefixed/group/bb bb
+-> -> /prefixed/group/cc cc
+-> /prefixed root
+-> /prefixed/group
+-> -> /prefixed/group/dd dd
+-> -> /prefixed/group/ee ee
+-> -> /prefixed/group/ff ff
+EOF
+            ],
+
+            'Group regardless of segments' => [
+                [
+                    ['/aaa-111/', 'a1'],
+                    ['/aaa-222/', 'a2'],
+                    ['/aaa-333/', 'a3'],
+                    ['/group-aa/', 'g1'],
+                    ['/group-bb/', 'g2'],
+                    ['/group-cc/', 'g3'],
+                ],
+                <<<EOF
+/aaa-
+-> /aaa-111 a1
+-> /aaa-222 a2
+-> /aaa-333 a3
+/group-
+-> /group-aa g1
+-> /group-bb g2
+-> /group-cc g3
+EOF
+            ],
+        ];
+    }
+
+    private function dumpCollection(StaticPrefixCollection $collection, $prefix = '')
+    {
+        $lines = [];
+
+        foreach ($collection->getItems() as $item) {
+            if ($item instanceof StaticPrefixCollection) {
+                $lines[] = $prefix.$item->getPrefix();
+                $lines[] = $this->dumpCollection($item, $prefix.'-> ');
+            } else {
+                $lines[] = $prefix.implode(' ', $item);
+            }
+        }
+
+        return implode("\n", $lines);
+    }
+}

vendor/symfony/routing/Tests/Matcher/RedirectableUrlMatcherTest.php

@@ -0,0 +1,150 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Routing\Tests\Matcher;
+
+use Symfony\Component\Routing\RequestContext;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+class RedirectableUrlMatcherTest extends UrlMatcherTest
+{
+    public function testMissingTrailingSlash()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->expects($this->once())->method('redirect')->willReturn([]);
+        $matcher->match('/foo');
+    }
+
+    public function testRedirectWhenNoSlashForNonSafeMethod()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/'));
+
+        $context = new RequestContext();
+        $context->setMethod('POST');
+        $matcher = $this->getUrlMatcher($coll, $context);
+        $matcher->match('/foo');
+    }
+
+    public function testSchemeRedirectRedirectsToFirstScheme()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo', [], [], [], '', ['FTP', 'HTTPS']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher
+            ->expects($this->once())
+            ->method('redirect')
+            ->with('/foo', 'foo', 'ftp')
+            ->willReturn(['_route' => 'foo'])
+        ;
+        $matcher->match('/foo');
+    }
+
+    public function testNoSchemaRedirectIfOneOfMultipleSchemesMatches()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo', [], [], [], '', ['https', 'http']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher
+            ->expects($this->never())
+            ->method('redirect');
+        $matcher->match('/foo');
+    }
+
+    public function testSchemeRedirectWithParams()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/{bar}', [], [], [], '', ['https']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher
+            ->expects($this->once())
+            ->method('redirect')
+            ->with('/foo/baz', 'foo', 'https')
+            ->willReturn(['redirect' => 'value'])
+        ;
+        $this->assertEquals(['_route' => 'foo', 'bar' => 'baz', 'redirect' => 'value'], $matcher->match('/foo/baz'));
+    }
+
+    public function testSlashRedirectWithParams()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/{bar}/'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher
+            ->expects($this->once())
+            ->method('redirect')
+            ->with('/foo/baz/', 'foo', null)
+            ->willReturn(['redirect' => 'value'])
+        ;
+        $this->assertEquals(['_route' => 'foo', 'bar' => 'baz', 'redirect' => 'value'], $matcher->match('/foo/baz'));
+    }
+
+    public function testRedirectPreservesUrlEncoding()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo:bar/'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->expects($this->once())->method('redirect')->with('/foo%3Abar/')->willReturn([]);
+        $matcher->match('/foo%3Abar');
+    }
+
+    public function testSchemeRequirement()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo', [], [], [], '', ['https']));
+        $matcher = $this->getUrlMatcher($coll, new RequestContext());
+        $matcher->expects($this->once())->method('redirect')->with('/foo', 'foo', 'https')->willReturn([]);
+        $this->assertSame(['_route' => 'foo'], $matcher->match('/foo'));
+    }
+
+    public function testFallbackPage()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/'));
+        $coll->add('bar', new Route('/{name}'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->expects($this->once())->method('redirect')->with('/foo/')->willReturn(['_route' => 'foo']);
+        $this->assertSame(['_route' => 'foo'], $matcher->match('/foo'));
+    }
+
+    public function testSlashAndVerbPrecedenceWithRedirection()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/api/customers/{customerId}/contactpersons', [], [], [], '', [], ['post']));
+        $coll->add('b', new Route('/api/customers/{customerId}/contactpersons/', [], [], [], '', [], ['get']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $expected = [
+            '_route' => 'b',
+            'customerId' => '123',
+        ];
+        $this->assertEquals($expected, $matcher->match('/api/customers/123/contactpersons/'));
+
+        $matcher->expects($this->once())->method('redirect')->with('/api/customers/123/contactpersons/')->willReturn([]);
+        $this->assertEquals($expected, $matcher->match('/api/customers/123/contactpersons'));
+    }
+
+    protected function getUrlMatcher(RouteCollection $routes, RequestContext $context = null)
+    {
+        return $this->getMockForAbstractClass('Symfony\Component\Routing\Matcher\RedirectableUrlMatcher', [$routes, $context ?: new RequestContext()]);
+    }
+}

vendor/symfony/routing/Tests/Matcher/TraceableUrlMatcherTest.php

@@ -0,0 +1,126 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Routing\Tests\Matcher;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\Routing\Matcher\TraceableUrlMatcher;
+use Symfony\Component\Routing\RequestContext;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+class TraceableUrlMatcherTest extends UrlMatcherTest
+{
+    public function test()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo', [], [], [], '', [], ['POST']));
+        $coll->add('bar', new Route('/bar/{id}', [], ['id' => '\d+']));
+        $coll->add('bar1', new Route('/bar/{name}', [], ['id' => '\w+'], [], '', [], ['POST']));
+        $coll->add('bar2', new Route('/foo', [], [], [], 'baz'));
+        $coll->add('bar3', new Route('/foo1', [], [], [], 'baz'));
+        $coll->add('bar4', new Route('/foo2', [], [], [], 'baz', [], [], 'context.getMethod() == "GET"'));
+
+        $context = new RequestContext();
+        $context->setHost('baz');
+
+        $matcher = new TraceableUrlMatcher($coll, $context);
+        $traces = $matcher->getTraces('/babar');
+        $this->assertSame([0, 0, 0, 0, 0, 0], $this->getLevels($traces));
+
+        $traces = $matcher->getTraces('/foo');
+        $this->assertSame([1, 0, 0, 2], $this->getLevels($traces));
+
+        $traces = $matcher->getTraces('/bar/12');
+        $this->assertSame([0, 2], $this->getLevels($traces));
+
+        $traces = $matcher->getTraces('/bar/dd');
+        $this->assertSame([0, 1, 1, 0, 0, 0], $this->getLevels($traces));
+
+        $traces = $matcher->getTraces('/foo1');
+        $this->assertSame([0, 0, 0, 0, 2], $this->getLevels($traces));
+
+        $context->setMethod('POST');
+        $traces = $matcher->getTraces('/foo');
+        $this->assertSame([2], $this->getLevels($traces));
+
+        $traces = $matcher->getTraces('/bar/dd');
+        $this->assertSame([0, 1, 2], $this->getLevels($traces));
+
+        $traces = $matcher->getTraces('/foo2');
+        $this->assertSame([0, 0, 0, 0, 0, 1], $this->getLevels($traces));
+    }
+
+    public function testMatchRouteOnMultipleHosts()
+    {
+        $routes = new RouteCollection();
+        $routes->add('first', new Route(
+            '/mypath/',
+            ['_controller' => 'MainBundle:Info:first'],
+            [],
+            [],
+            'some.example.com'
+        ));
+
+        $routes->add('second', new Route(
+            '/mypath/',
+            ['_controller' => 'MainBundle:Info:second'],
+            [],
+            [],
+            'another.example.com'
+        ));
+
+        $context = new RequestContext();
+        $context->setHost('baz');
+
+        $matcher = new TraceableUrlMatcher($routes, $context);
+
+        $traces = $matcher->getTraces('/mypath/');
+        $this->assertSame(
+            [TraceableUrlMatcher::ROUTE_ALMOST_MATCHES, TraceableUrlMatcher::ROUTE_ALMOST_MATCHES],
+            $this->getLevels($traces)
+        );
+    }
+
+    public function getLevels($traces)
+    {
+        $levels = [];
+        foreach ($traces as $trace) {
+            $levels[] = $trace['level'];
+        }
+
+        return $levels;
+    }
+
+    public function testRoutesWithConditions()
+    {
+        $routes = new RouteCollection();
+        $routes->add('foo', new Route('/foo', [], [], [], 'baz', [], [], "request.headers.get('User-Agent') matches '/firefox/i'"));
+
+        $context = new RequestContext();
+        $context->setHost('baz');
+
+        $matcher = new TraceableUrlMatcher($routes, $context);
+
+        $notMatchingRequest = Request::create('/foo', 'GET');
+        $traces = $matcher->getTracesForRequest($notMatchingRequest);
+        $this->assertEquals("Condition \"request.headers.get('User-Agent') matches '/firefox/i'\" does not evaluate to \"true\"", $traces[0]['log']);
+
+        $matchingRequest = Request::create('/foo', 'GET', [], [], [], ['HTTP_USER_AGENT' => 'Firefox']);
+        $traces = $matcher->getTracesForRequest($matchingRequest);
+        $this->assertEquals('Route matches!', $traces[0]['log']);
+    }
+
+    protected function getUrlMatcher(RouteCollection $routes, RequestContext $context = null)
+    {
+        return new TraceableUrlMatcher($routes, $context ?: new RequestContext());
+    }
+}

vendor/symfony/routing/Tests/Matcher/UrlMatcherTest.php

@@ -0,0 +1,616 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Routing\Tests\Matcher;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Exception\MethodNotAllowedException;
+use Symfony\Component\Routing\Exception\ResourceNotFoundException;
+use Symfony\Component\Routing\Matcher\UrlMatcher;
+use Symfony\Component\Routing\RequestContext;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+class UrlMatcherTest extends TestCase
+{
+    public function testNoMethodSoAllowed()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertIsArray($matcher->match('/foo'));
+    }
+
+    public function testMethodNotAllowed()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo', [], [], [], '', [], ['post']));
+
+        $matcher = $this->getUrlMatcher($coll);
+
+        try {
+            $matcher->match('/foo');
+            $this->fail();
+        } catch (MethodNotAllowedException $e) {
+            $this->assertEquals(['POST'], $e->getAllowedMethods());
+        }
+    }
+
+    public function testMethodNotAllowedOnRoot()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/', [], [], [], '', [], ['GET']));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'POST'));
+
+        try {
+            $matcher->match('/');
+            $this->fail();
+        } catch (MethodNotAllowedException $e) {
+            $this->assertEquals(['GET'], $e->getAllowedMethods());
+        }
+    }
+
+    public function testHeadAllowedWhenRequirementContainsGet()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo', [], [], [], '', [], ['get']));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'head'));
+        $this->assertIsArray($matcher->match('/foo'));
+    }
+
+    public function testMethodNotAllowedAggregatesAllowedMethods()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo1', new Route('/foo', [], [], [], '', [], ['post']));
+        $coll->add('foo2', new Route('/foo', [], [], [], '', [], ['put', 'delete']));
+
+        $matcher = $this->getUrlMatcher($coll);
+
+        try {
+            $matcher->match('/foo');
+            $this->fail();
+        } catch (MethodNotAllowedException $e) {
+            $this->assertEquals(['POST', 'PUT', 'DELETE'], $e->getAllowedMethods());
+        }
+    }
+
+    public function testMatch()
+    {
+        // test the patterns are matched and parameters are returned
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/foo/{bar}'));
+        $matcher = $this->getUrlMatcher($collection);
+        try {
+            $matcher->match('/no-match');
+            $this->fail();
+        } catch (ResourceNotFoundException $e) {
+        }
+        $this->assertEquals(['_route' => 'foo', 'bar' => 'baz'], $matcher->match('/foo/baz'));
+
+        // test that defaults are merged
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/foo/{bar}', ['def' => 'test']));
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => 'foo', 'bar' => 'baz', 'def' => 'test'], $matcher->match('/foo/baz'));
+
+        // test that route "method" is ignored if no method is given in the context
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/foo', [], [], [], '', [], ['get', 'head']));
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertIsArray($matcher->match('/foo'));
+
+        // route does not match with POST method context
+        $matcher = $this->getUrlMatcher($collection, new RequestContext('', 'post'));
+        try {
+            $matcher->match('/foo');
+            $this->fail();
+        } catch (MethodNotAllowedException $e) {
+        }
+
+        // route does match with GET or HEAD method context
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertIsArray($matcher->match('/foo'));
+        $matcher = $this->getUrlMatcher($collection, new RequestContext('', 'head'));
+        $this->assertIsArray($matcher->match('/foo'));
+
+        // route with an optional variable as the first segment
+        $collection = new RouteCollection();
+        $collection->add('bar', new Route('/{bar}/foo', ['bar' => 'bar'], ['bar' => 'foo|bar']));
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => 'bar', 'bar' => 'bar'], $matcher->match('/bar/foo'));
+        $this->assertEquals(['_route' => 'bar', 'bar' => 'foo'], $matcher->match('/foo/foo'));
+
+        $collection = new RouteCollection();
+        $collection->add('bar', new Route('/{bar}', ['bar' => 'bar'], ['bar' => 'foo|bar']));
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => 'bar', 'bar' => 'foo'], $matcher->match('/foo'));
+        $this->assertEquals(['_route' => 'bar', 'bar' => 'bar'], $matcher->match('/'));
+
+        // route with only optional variables
+        $collection = new RouteCollection();
+        $collection->add('bar', new Route('/{foo}/{bar}', ['foo' => 'foo', 'bar' => 'bar'], []));
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => 'bar', 'foo' => 'foo', 'bar' => 'bar'], $matcher->match('/'));
+        $this->assertEquals(['_route' => 'bar', 'foo' => 'a', 'bar' => 'bar'], $matcher->match('/a'));
+        $this->assertEquals(['_route' => 'bar', 'foo' => 'a', 'bar' => 'b'], $matcher->match('/a/b'));
+    }
+
+    public function testMatchWithPrefixes()
+    {
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/{foo}'));
+        $collection->addPrefix('/b');
+        $collection->addPrefix('/a');
+
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => 'foo', 'foo' => 'foo'], $matcher->match('/a/b/foo'));
+    }
+
+    public function testMatchWithDynamicPrefix()
+    {
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/{foo}'));
+        $collection->addPrefix('/b');
+        $collection->addPrefix('/{_locale}');
+
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_locale' => 'fr', '_route' => 'foo', 'foo' => 'foo'], $matcher->match('/fr/b/foo'));
+    }
+
+    public function testMatchSpecialRouteName()
+    {
+        $collection = new RouteCollection();
+        $collection->add('$péß^a|', new Route('/bar'));
+
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => '$péß^a|'], $matcher->match('/bar'));
+    }
+
+    public function testTrailingEncodedNewlineIsNotOverlooked()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/foo'));
+
+        $matcher = $this->getUrlMatcher($collection);
+        $matcher->match('/foo%0a');
+    }
+
+    public function testMatchNonAlpha()
+    {
+        $collection = new RouteCollection();
+        $chars = '!"$%éà &\'()*+,./:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\\[]^_`abcdefghijklmnopqrstuvwxyz{|}~-';
+        $collection->add('foo', new Route('/{foo}/bar', [], ['foo' => '['.preg_quote($chars).']+'], ['utf8' => true]));
+
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => 'foo', 'foo' => $chars], $matcher->match('/'.rawurlencode($chars).'/bar'));
+        $this->assertEquals(['_route' => 'foo', 'foo' => $chars], $matcher->match('/'.strtr($chars, ['%' => '%25']).'/bar'));
+    }
+
+    public function testMatchWithDotMetacharacterInRequirements()
+    {
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/{foo}/bar', [], ['foo' => '.+']));
+
+        $matcher = $this->getUrlMatcher($collection);
+        $this->assertEquals(['_route' => 'foo', 'foo' => "\n"], $matcher->match('/'.urlencode("\n").'/bar'), 'linefeed character is matched');
+    }
+
+    public function testMatchOverriddenRoute()
+    {
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/foo'));
+
+        $collection1 = new RouteCollection();
+        $collection1->add('foo', new Route('/foo1'));
+
+        $collection->addCollection($collection1);
+
+        $matcher = $this->getUrlMatcher($collection);
+
+        $this->assertEquals(['_route' => 'foo'], $matcher->match('/foo1'));
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $this->assertEquals([], $matcher->match('/foo'));
+    }
+
+    public function testMatchRegression()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/{foo}'));
+        $coll->add('bar', new Route('/foo/bar/{foo}'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['foo' => 'bar', '_route' => 'bar'], $matcher->match('/foo/bar/bar'));
+
+        $collection = new RouteCollection();
+        $collection->add('foo', new Route('/{bar}'));
+        $matcher = $this->getUrlMatcher($collection);
+        try {
+            $matcher->match('/');
+            $this->fail();
+        } catch (ResourceNotFoundException $e) {
+        }
+    }
+
+    public function testDefaultRequirementForOptionalVariables()
+    {
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/{page}.{_format}', ['page' => 'index', '_format' => 'html']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['page' => 'my-page', '_format' => 'xml', '_route' => 'test'], $matcher->match('/my-page.xml'));
+    }
+
+    public function testMatchingIsEager()
+    {
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/{foo}-{bar}-', [], ['foo' => '.+', 'bar' => '.+']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['foo' => 'text1-text2-text3', 'bar' => 'text4', '_route' => 'test'], $matcher->match('/text1-text2-text3-text4-'));
+    }
+
+    public function testAdjacentVariables()
+    {
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/{w}{x}{y}{z}.{_format}', ['z' => 'default-z', '_format' => 'html'], ['y' => 'y|Y']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        // 'w' eagerly matches as much as possible and the other variables match the remaining chars.
+        // This also shows that the variables w-z must all exclude the separating char (the dot '.' in this case) by default requirement.
+        // Otherwise they would also consume '.xml' and _format would never match as it's an optional variable.
+        $this->assertEquals(['w' => 'wwwww', 'x' => 'x', 'y' => 'Y', 'z' => 'Z', '_format' => 'xml', '_route' => 'test'], $matcher->match('/wwwwwxYZ.xml'));
+        // As 'y' has custom requirement and can only be of value 'y|Y', it will leave  'ZZZ' to variable z.
+        // So with carefully chosen requirements adjacent variables, can be useful.
+        $this->assertEquals(['w' => 'wwwww', 'x' => 'x', 'y' => 'y', 'z' => 'ZZZ', '_format' => 'html', '_route' => 'test'], $matcher->match('/wwwwwxyZZZ'));
+        // z and _format are optional.
+        $this->assertEquals(['w' => 'wwwww', 'x' => 'x', 'y' => 'y', 'z' => 'default-z', '_format' => 'html', '_route' => 'test'], $matcher->match('/wwwwwxy'));
+
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $matcher->match('/wxy.html');
+    }
+
+    public function testOptionalVariableWithNoRealSeparator()
+    {
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/get{what}', ['what' => 'All']));
+        $matcher = $this->getUrlMatcher($coll);
+
+        $this->assertEquals(['what' => 'All', '_route' => 'test'], $matcher->match('/get'));
+        $this->assertEquals(['what' => 'Sites', '_route' => 'test'], $matcher->match('/getSites'));
+
+        // Usually the character in front of an optional parameter can be left out, e.g. with pattern '/get/{what}' just '/get' would match.
+        // But here the 't' in 'get' is not a separating character, so it makes no sense to match without it.
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $matcher->match('/ge');
+    }
+
+    public function testRequiredVariableWithNoRealSeparator()
+    {
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/get{what}Suffix'));
+        $matcher = $this->getUrlMatcher($coll);
+
+        $this->assertEquals(['what' => 'Sites', '_route' => 'test'], $matcher->match('/getSitesSuffix'));
+    }
+
+    public function testDefaultRequirementOfVariable()
+    {
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/{page}.{_format}'));
+        $matcher = $this->getUrlMatcher($coll);
+
+        $this->assertEquals(['page' => 'index', '_format' => 'mobile.html', '_route' => 'test'], $matcher->match('/index.mobile.html'));
+    }
+
+    public function testDefaultRequirementOfVariableDisallowsSlash()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/{page}.{_format}'));
+        $matcher = $this->getUrlMatcher($coll);
+
+        $matcher->match('/index.sl/ash');
+    }
+
+    public function testDefaultRequirementOfVariableDisallowsNextSeparator()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $coll->add('test', new Route('/{page}.{_format}', [], ['_format' => 'html|xml']));
+        $matcher = $this->getUrlMatcher($coll);
+
+        $matcher->match('/do.t.html');
+    }
+
+    public function testSchemeRequirement()
+    {
+        $this->getExpectedException() ?: $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo', [], [], [], '', ['https']));
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->match('/foo');
+    }
+
+    public function testCondition()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $route = new Route('/foo');
+        $route->setCondition('context.getMethod() == "POST"');
+        $coll->add('foo', $route);
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->match('/foo');
+    }
+
+    public function testRequestCondition()
+    {
+        $coll = new RouteCollection();
+        $route = new Route('/foo/{bar}');
+        $route->setCondition('request.getBaseUrl() == "/sub/front.php" and request.getPathInfo() == "/foo/bar"');
+        $coll->add('foo', $route);
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('/sub/front.php'));
+        $this->assertEquals(['bar' => 'bar', '_route' => 'foo'], $matcher->match('/foo/bar'));
+    }
+
+    public function testDecodeOnce()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/{foo}'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['foo' => 'bar%23', '_route' => 'foo'], $matcher->match('/foo/bar%2523'));
+    }
+
+    public function testCannotRelyOnPrefix()
+    {
+        $coll = new RouteCollection();
+
+        $subColl = new RouteCollection();
+        $subColl->add('bar', new Route('/bar'));
+        $subColl->addPrefix('/prefix');
+        // overwrite the pattern, so the prefix is not valid anymore for this route in the collection
+        $subColl->get('bar')->setPath('/new');
+
+        $coll->addCollection($subColl);
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['_route' => 'bar'], $matcher->match('/new'));
+    }
+
+    public function testWithHost()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/{foo}', [], [], [], '{locale}.example.com'));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'GET', 'en.example.com'));
+        $this->assertEquals(['foo' => 'bar', '_route' => 'foo', 'locale' => 'en'], $matcher->match('/foo/bar'));
+    }
+
+    public function testWithHostOnRouteCollection()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/{foo}'));
+        $coll->add('bar', new Route('/bar/{foo}', [], [], [], '{locale}.example.net'));
+        $coll->setHost('{locale}.example.com');
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'GET', 'en.example.com'));
+        $this->assertEquals(['foo' => 'bar', '_route' => 'foo', 'locale' => 'en'], $matcher->match('/foo/bar'));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'GET', 'en.example.com'));
+        $this->assertEquals(['foo' => 'bar', '_route' => 'bar', 'locale' => 'en'], $matcher->match('/bar/bar'));
+    }
+
+    public function testWithOutHostHostDoesNotMatch()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/foo/{foo}', [], [], [], '{locale}.example.com'));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'GET', 'example.com'));
+        $matcher->match('/foo/bar');
+    }
+
+    public function testPathIsCaseSensitive()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/locale', [], ['locale' => 'EN|FR|DE']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->match('/en');
+    }
+
+    public function testHostIsCaseInsensitive()
+    {
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/', [], ['locale' => 'EN|FR|DE'], [], '{locale}.example.com'));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'GET', 'en.example.com'));
+        $this->assertEquals(['_route' => 'foo', 'locale' => 'en'], $matcher->match('/'));
+    }
+
+    public function testNoConfiguration()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\NoConfigurationException');
+        $coll = new RouteCollection();
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->match('/');
+    }
+
+    public function testNestedCollections()
+    {
+        $coll = new RouteCollection();
+
+        $subColl = new RouteCollection();
+        $subColl->add('a', new Route('/a'));
+        $subColl->add('b', new Route('/b'));
+        $subColl->add('c', new Route('/c'));
+        $subColl->addPrefix('/p');
+        $coll->addCollection($subColl);
+
+        $coll->add('baz', new Route('/{baz}'));
+
+        $subColl = new RouteCollection();
+        $subColl->add('buz', new Route('/buz'));
+        $subColl->addPrefix('/prefix');
+        $coll->addCollection($subColl);
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['_route' => 'a'], $matcher->match('/p/a'));
+        $this->assertEquals(['_route' => 'baz', 'baz' => 'p'], $matcher->match('/p'));
+        $this->assertEquals(['_route' => 'buz'], $matcher->match('/prefix/buz'));
+    }
+
+    public function testSchemeAndMethodMismatch()
+    {
+        $this->expectException('Symfony\Component\Routing\Exception\ResourceNotFoundException');
+        $coll = new RouteCollection();
+        $coll->add('foo', new Route('/', [], [], [], null, ['https'], ['POST']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $matcher->match('/');
+    }
+
+    public function testSiblingRoutes()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', (new Route('/a{a}'))->setMethods('POST'));
+        $coll->add('b', (new Route('/a{a}'))->setMethods('PUT'));
+        $coll->add('c', new Route('/a{a}'));
+        $coll->add('d', (new Route('/b{a}'))->setCondition('false'));
+        $coll->add('e', (new Route('/{b}{a}'))->setCondition('false'));
+        $coll->add('f', (new Route('/{b}{a}'))->setRequirements(['b' => 'b']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['_route' => 'c', 'a' => 'a'], $matcher->match('/aa'));
+        $this->assertEquals(['_route' => 'f', 'b' => 'b', 'a' => 'a'], $matcher->match('/ba'));
+    }
+
+    public function testRequirementWithCapturingGroup()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/{a}/{b}', [], ['a' => '(a|b)']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['_route' => 'a', 'a' => 'a', 'b' => 'b'], $matcher->match('/a/b'));
+    }
+
+    public function testDotAllWithCatchAll()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/{id}.html', [], ['id' => '.+']));
+        $coll->add('b', new Route('/{all}', [], ['all' => '.+']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals(['_route' => 'a', 'id' => 'foo/bar'], $matcher->match('/foo/bar.html'));
+    }
+
+    public function testHostPattern()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/{app}/{action}/{unused}', [], [], [], '{host}'));
+
+        $expected = [
+            '_route' => 'a',
+            'app' => 'an_app',
+            'action' => 'an_action',
+            'unused' => 'unused',
+            'host' => 'foo',
+        ];
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'GET', 'foo'));
+        $this->assertEquals($expected, $matcher->match('/an_app/an_action/unused'));
+    }
+
+    public function testHostWithDot()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/foo', [], [], [], 'foo.example.com'));
+        $coll->add('b', new Route('/bar/{baz}'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals('b', $matcher->match('/bar/abc.123')['_route']);
+    }
+
+    public function testSlashVariant()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/foo/{bar}', [], ['bar' => '.*']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertEquals('a', $matcher->match('/foo/')['_route']);
+    }
+
+    public function testSlashWithVerb()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/{foo}', [], [], [], '', [], ['put', 'delete']));
+        $coll->add('b', new Route('/bar/'));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $this->assertSame(['_route' => 'b'], $matcher->match('/bar/'));
+
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/dav/{foo}', [], ['foo' => '.*'], [], '', [], ['GET', 'OPTIONS']));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'OPTIONS'));
+        $expected = [
+            '_route' => 'a',
+            'foo' => 'files/bar/',
+        ];
+        $this->assertEquals($expected, $matcher->match('/dav/files/bar/'));
+    }
+
+    public function testSlashAndVerbPrecedence()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/api/customers/{customerId}/contactpersons/', [], [], [], '', [], ['post']));
+        $coll->add('b', new Route('/api/customers/{customerId}/contactpersons', [], [], [], '', [], ['get']));
+
+        $matcher = $this->getUrlMatcher($coll);
+        $expected = [
+            '_route' => 'b',
+            'customerId' => '123',
+        ];
+        $this->assertEquals($expected, $matcher->match('/api/customers/123/contactpersons'));
+
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/api/customers/{customerId}/contactpersons/', [], [], [], '', [], ['get']));
+        $coll->add('b', new Route('/api/customers/{customerId}/contactpersons', [], [], [], '', [], ['post']));
+
+        $matcher = $this->getUrlMatcher($coll, new RequestContext('', 'POST'));
+        $expected = [
+            '_route' => 'b',
+            'customerId' => '123',
+        ];
+        $this->assertEquals($expected, $matcher->match('/api/customers/123/contactpersons'));
+    }
+
+    public function testGreedyTrailingRequirement()
+    {
+        $coll = new RouteCollection();
+        $coll->add('a', new Route('/{a}', [], ['a' => '.+']));
+
+        $matcher = $this->getUrlMatcher($coll);
+
+        $this->assertEquals(['_route' => 'a', 'a' => 'foo'], $matcher->match('/foo'));
+        $this->assertEquals(['_route' => 'a', 'a' => 'foo/'], $matcher->match('/foo/'));
+    }
+
+    protected function getUrlMatcher(RouteCollection $routes, RequestContext $context = null)
+    {
+        return new UrlMatcher($routes, $context ?: new RequestContext());
+    }
+}