Use createMock() and use import instead of FQCN

OskarStark · nicolas-grekas · commit 87529f6e305c · 2021-01-27T10:09:26.000+01:00
diff --git a/Tests/Generator/Dumper/CompiledUrlGeneratorDumperTest.php b/Tests/Generator/Dumper/CompiledUrlGeneratorDumperTest.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Routing\Tests\Generator\Dumper;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Exception\RouteNotFoundException;
 use Symfony\Component\Routing\Generator\CompiledUrlGenerator;
 use Symfony\Component\Routing\Generator\Dumper\CompiledUrlGeneratorDumper;
 use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
@@ -118,7 +119,7 @@ public function testDumpWithSimpleLocalizedRoutes()
 
     public function testDumpWithRouteNotFoundLocalizedRoutes()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);
+        $this->expectException(RouteNotFoundException::class);
         $this->expectExceptionMessage('Unable to generate a URL for the named route "test" as such route does not exist.');
         $this->routeCollection->add('test.en', (new Route('/testing/is/fun'))->setDefault('_locale', 'en')->setDefault('_canonical_route', 'test')->setRequirement('_locale', 'en'));
 
@@ -188,7 +189,7 @@ public function testDumpWithoutRoutes()
 
     public function testGenerateNonExistingRoute()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);
+        $this->expectException(RouteNotFoundException::class);
         $this->routeCollection->add('Test', new Route('/test'));
 
         file_put_contents($this->testTmpFilepath, $this->generatorDumper->dump());
diff --git a/Tests/Generator/Dumper/PhpGeneratorDumperTest.php b/Tests/Generator/Dumper/PhpGeneratorDumperTest.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Routing\Tests\Generator\Dumper;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Exception\RouteNotFoundException;
 use Symfony\Component\Routing\Generator\Dumper\PhpGeneratorDumper;
 use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
 use Symfony\Component\Routing\RequestContext;
@@ -124,7 +125,7 @@ public function testDumpWithSimpleLocalizedRoutes()
 
     public function testDumpWithRouteNotFoundLocalizedRoutes()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);
+        $this->expectException(RouteNotFoundException::class);
         $this->expectExceptionMessage('Unable to generate a URL for the named route "test" as such route does not exist.');
         $this->routeCollection->add('test.en', (new Route('/testing/is/fun'))->setDefault('_locale', 'en')->setDefault('_canonical_route', 'test')->setRequirement('_locale', 'en'));
 
@@ -204,7 +205,7 @@ public function testDumpWithoutRoutes()
 
     public function testGenerateNonExistingRoute()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);
+        $this->expectException(RouteNotFoundException::class);
         $this->routeCollection->add('Test', new Route('/test'));
 
         file_put_contents($this->testTmpFilepath, $this->generatorDumper->dump(['class' => 'NonExistingRoutesUrlGenerator']));
diff --git a/Tests/Generator/UrlGeneratorTest.php b/Tests/Generator/UrlGeneratorTest.php
@@ -12,6 +12,10 @@
 namespace Symfony\Component\Routing\Tests\Generator;
 
 use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Routing\Exception\InvalidParameterException;
+use Symfony\Component\Routing\Exception\MissingMandatoryParametersException;
+use Symfony\Component\Routing\Exception\RouteNotFoundException;
 use Symfony\Component\Routing\Generator\UrlGenerator;
 use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
 use Symfony\Component\Routing\RequestContext;
@@ -78,7 +82,7 @@ public function testRelativeUrlWithNullParameter()
 
     public function testRelativeUrlWithNullParameterButNotOptional()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/testing/{foo}/bar', ['foo' => null]));
         // This must raise an exception because the default requirement for "foo" is "[^/]+" which is not met with these params.
         // Generating path "/testing//bar" would be wrong as matching this route would fail.
@@ -264,14 +268,14 @@ public function testDumpWithLocalizedRoutesPreserveTheGoodLocaleInTheUrl()
 
     public function testGenerateWithoutRoutes()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);
+        $this->expectException(RouteNotFoundException::class);
         $routes = $this->getRoutes('foo', new Route('/testing/{foo}'));
         $this->getGenerator($routes)->generate('test', [], UrlGeneratorInterface::ABSOLUTE_URL);
     }
 
     public function testGenerateWithInvalidLocale()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);
+        $this->expectException(RouteNotFoundException::class);
         $routes = new RouteCollection();
 
         $route = new Route('');
@@ -293,21 +297,21 @@ public function testGenerateWithInvalidLocale()
 
     public function testGenerateForRouteWithoutMandatoryParameter()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\MissingMandatoryParametersException::class);
+        $this->expectException(MissingMandatoryParametersException::class);
         $routes = $this->getRoutes('test', new Route('/testing/{foo}'));
         $this->getGenerator($routes)->generate('test', [], UrlGeneratorInterface::ABSOLUTE_URL);
     }
 
     public function testGenerateForRouteWithInvalidOptionalParameter()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/testing/{foo}', ['foo' => '1'], ['foo' => 'd+']));
         $this->getGenerator($routes)->generate('test', ['foo' => 'bar'], UrlGeneratorInterface::ABSOLUTE_URL);
     }
 
     public function testGenerateForRouteWithInvalidParameter()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/testing/{foo}', [], ['foo' => '1|2']));
         $this->getGenerator($routes)->generate('test', ['foo' => '0'], UrlGeneratorInterface::ABSOLUTE_URL);
     }
@@ -323,7 +327,7 @@ public function testGenerateForRouteWithInvalidOptionalParameterNonStrict()
     public function testGenerateForRouteWithInvalidOptionalParameterNonStrictWithLogger()
     {
         $routes = $this->getRoutes('test', new Route('/testing/{foo}', ['foo' => '1'], ['foo' => 'd+']));
-        $logger = $this->getMockBuilder(\Psr\Log\LoggerInterface::class)->getMock();
+        $logger = $this->createMock(LoggerInterface::class);
         $logger->expects($this->once())
             ->method('error');
         $generator = $this->getGenerator($routes, [], $logger);
@@ -341,21 +345,21 @@ public function testGenerateForRouteWithInvalidParameterButDisabledRequirementsC
 
     public function testGenerateForRouteWithInvalidMandatoryParameter()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/testing/{foo}', [], ['foo' => 'd+']));
         $this->getGenerator($routes)->generate('test', ['foo' => 'bar'], UrlGeneratorInterface::ABSOLUTE_URL);
     }
 
     public function testGenerateForRouteWithInvalidUtf8Parameter()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/testing/{foo}', [], ['foo' => '\pL+'], ['utf8' => true]));
         $this->getGenerator($routes)->generate('test', ['foo' => 'abc123'], UrlGeneratorInterface::ABSOLUTE_URL);
     }
 
     public function testRequiredParamAndEmptyPassed()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/{slug}', [], ['slug' => '.+']));
         $this->getGenerator($routes)->generate('test', ['slug' => '']);
     }
@@ -476,7 +480,7 @@ public function testAdjacentVariables()
 
         // The default requirement for 'x' should not allow the separator '.' in this case because it would otherwise match everything
         // and following optional variables like _format could never match.
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $generator->generate('test', ['x' => 'do.t', 'y' => '123', 'z' => 'bar', '_format' => 'xml']);
     }
 
@@ -517,7 +521,7 @@ public function testImportantVariable()
 
     public function testImportantVariableWithNoDefault()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\MissingMandatoryParametersException::class);
+        $this->expectException(MissingMandatoryParametersException::class);
         $routes = $this->getRoutes('test', new Route('/{page}.{!_format}'));
         $generator = $this->getGenerator($routes);
 
@@ -526,14 +530,14 @@ public function testImportantVariableWithNoDefault()
 
     public function testDefaultRequirementOfVariableDisallowsSlash()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/{page}.{_format}'));
         $this->getGenerator($routes)->generate('test', ['page' => 'index', '_format' => 'sl/ash']);
     }
 
     public function testDefaultRequirementOfVariableDisallowsNextSeparator()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/{page}.{_format}'));
         $this->getGenerator($routes)->generate('test', ['page' => 'do.t', '_format' => 'html']);
     }
@@ -561,21 +565,21 @@ public function testWithHostSameAsContextAndAbsolute()
 
     public function testUrlWithInvalidParameterInHost()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/', [], ['foo' => 'bar'], [], '{foo}.example.com'));
         $this->getGenerator($routes)->generate('test', ['foo' => 'baz'], UrlGeneratorInterface::ABSOLUTE_PATH);
     }
 
     public function testUrlWithInvalidParameterInHostWhenParamHasADefaultValue()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/', ['foo' => 'bar'], ['foo' => 'bar'], [], '{foo}.example.com'));
         $this->getGenerator($routes)->generate('test', ['foo' => 'baz'], UrlGeneratorInterface::ABSOLUTE_PATH);
     }
 
     public function testUrlWithInvalidParameterEqualsDefaultValueInHost()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);
+        $this->expectException(InvalidParameterException::class);
         $routes = $this->getRoutes('test', new Route('/', ['foo' => 'baz'], ['foo' => 'bar'], [], '{foo}.example.com'));
         $this->getGenerator($routes)->generate('test', ['foo' => 'baz'], UrlGeneratorInterface::ABSOLUTE_PATH);
     }
diff --git a/Tests/Loader/AbstractAnnotationLoaderTest.php b/Tests/Loader/AbstractAnnotationLoaderTest.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Routing\Tests\Loader;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Loader\AnnotationClassLoader;
 
 abstract class AbstractAnnotationLoaderTest extends TestCase
 {
@@ -25,7 +26,7 @@ public function getReader()
 
     public function getClassLoader($reader)
     {
-        return $this->getMockBuilder(\Symfony\Component\Routing\Loader\AnnotationClassLoader::class)
+        return $this->getMockBuilder(AnnotationClassLoader::class)
             ->setConstructorArgs([$reader])
             ->getMockForAbstractClass()
         ;
diff --git a/Tests/Loader/PhpFileLoaderTest.php b/Tests/Loader/PhpFileLoaderTest.php
@@ -22,7 +22,7 @@ class PhpFileLoaderTest extends TestCase
 {
     public function testSupports()
     {
-        $loader = new PhpFileLoader($this->getMockBuilder(FileLocator::class)->getMock());
+        $loader = new PhpFileLoader($this->createMock(FileLocator::class));
 
         $this->assertTrue($loader->supports('foo.php'), '->supports() returns true if the resource is loadable');
         $this->assertFalse($loader->supports('foo.foo'), '->supports() returns true if the resource is loadable');
diff --git a/Tests/Loader/XmlFileLoaderTest.php b/Tests/Loader/XmlFileLoaderTest.php
@@ -23,7 +23,7 @@ class XmlFileLoaderTest extends TestCase
 {
     public function testSupports()
     {
-        $loader = new XmlFileLoader($this->getMockBuilder(FileLocator::class)->getMock());
+        $loader = new XmlFileLoader($this->createMock(FileLocator::class));
 
         $this->assertTrue($loader->supports('foo.xml'), '->supports() returns true if the resource is loadable');
         $this->assertFalse($loader->supports('foo.foo'), '->supports() returns true if the resource is loadable');
diff --git a/Tests/Loader/YamlFileLoaderTest.php b/Tests/Loader/YamlFileLoaderTest.php
@@ -22,7 +22,7 @@ class YamlFileLoaderTest extends TestCase
 {
     public function testSupports()
     {
-        $loader = new YamlFileLoader($this->getMockBuilder(FileLocator::class)->getMock());
+        $loader = new YamlFileLoader($this->createMock(FileLocator::class));
 
         $this->assertTrue($loader->supports('foo.yml'), '->supports() returns true if the resource is loadable');
         $this->assertTrue($loader->supports('foo.yaml'), '->supports() returns true if the resource is loadable');
diff --git a/Tests/Matcher/RedirectableUrlMatcherTest.php b/Tests/Matcher/RedirectableUrlMatcherTest.php
@@ -11,6 +11,8 @@
 
 namespace Symfony\Component\Routing\Tests\Matcher;
 
+use Symfony\Component\Routing\Exception\ResourceNotFoundException;
+use Symfony\Component\Routing\Matcher\RedirectableUrlMatcher;
 use Symfony\Component\Routing\RequestContext;
 use Symfony\Component\Routing\Route;
 use Symfony\Component\Routing\RouteCollection;
@@ -39,7 +41,7 @@ public function testExtraTrailingSlash()
 
     public function testRedirectWhenNoSlashForNonSafeMethod()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\ResourceNotFoundException::class);
+        $this->expectException(ResourceNotFoundException::class);
         $coll = new RouteCollection();
         $coll->add('foo', new Route('/foo/'));
 
@@ -209,6 +211,6 @@ public function testTrailingRequirementWithDefault_A()
 
     protected function getUrlMatcher(RouteCollection $routes, RequestContext $context = null)
     {
-        return $this->getMockForAbstractClass(\Symfony\Component\Routing\Matcher\RedirectableUrlMatcher::class, [$routes, $context ?: new RequestContext()]);
+        return $this->getMockForAbstractClass(RedirectableUrlMatcher::class, [$routes, $context ?: new RequestContext()]);
     }
 }
diff --git a/Tests/Matcher/UrlMatcherTest.php b/Tests/Matcher/UrlMatcherTest.php
@@ -13,6 +13,7 @@
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Routing\Exception\MethodNotAllowedException;
+use Symfony\Component\Routing\Exception\NoConfigurationException;
 use Symfony\Component\Routing\Exception\ResourceNotFoundException;
 use Symfony\Component\Routing\Matcher\UrlMatcher;
 use Symfony\Component\Routing\RequestContext;
@@ -687,7 +688,7 @@ public function testHostIsCaseInsensitive()
 
     public function testNoConfiguration()
     {
-        $this->expectException(\Symfony\Component\Routing\Exception\NoConfigurationException::class);
+        $this->expectException(NoConfigurationException::class);
         $coll = new RouteCollection();
 
         $matcher = $this->getUrlMatcher($coll);
diff --git a/Tests/RouteCollectionBuilderTest.php b/Tests/RouteCollectionBuilderTest.php
@@ -13,6 +13,8 @@
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Config\FileLocator;
+use Symfony\Component\Config\Loader\LoaderInterface;
+use Symfony\Component\Config\Loader\LoaderResolverInterface;
 use Symfony\Component\Config\Resource\FileResource;
 use Symfony\Component\Routing\Loader\YamlFileLoader;
 use Symfony\Component\Routing\Route;
@@ -23,8 +25,8 @@ class RouteCollectionBuilderTest extends TestCase
 {
     public function testImport()
     {
-        $resolvedLoader = $this->getMockBuilder(\Symfony\Component\Config\Loader\LoaderInterface::class)->getMock();
-        $resolver = $this->getMockBuilder(\Symfony\Component\Config\Loader\LoaderResolverInterface::class)->getMock();
+        $resolvedLoader = $this->createMock(LoaderInterface::class);
+        $resolver = $this->createMock(LoaderResolverInterface::class);
         $resolver->expects($this->once())
             ->method('resolve')
             ->with('admin_routing.yml', 'yaml')
@@ -41,7 +43,7 @@ public function testImport()
             ->with('admin_routing.yml', 'yaml')
             ->willReturn($expectedCollection);
 
-        $loader = $this->getMockBuilder(\Symfony\Component\Config\Loader\LoaderInterface::class)->getMock();
+        $loader = $this->createMock(LoaderInterface::class);
         $loader->expects($this->any())
             ->method('getResolver')
             ->willReturn($resolver);
@@ -101,7 +103,7 @@ public function testFlushOrdering()
         $importedCollection->add('imported_route1', new Route('/imported/foo1'));
         $importedCollection->add('imported_route2', new Route('/imported/foo2'));
 
-        $loader = $this->getMockBuilder(\Symfony\Component\Config\Loader\LoaderInterface::class)->getMock();
+        $loader = $this->createMock(LoaderInterface::class);
         // make this loader able to do the import - keeps mocking simple
         $loader->expects($this->any())
             ->method('supports')
@@ -264,7 +266,7 @@ public function providePrefixTests()
 
     public function testFlushSetsPrefixedWithMultipleLevels()
     {
-        $loader = $this->getMockBuilder(\Symfony\Component\Config\Loader\LoaderInterface::class)->getMock();
+        $loader = $this->createMock(LoaderInterface::class);
         $routes = new RouteCollectionBuilder($loader);
 
         $routes->add('homepage', 'MainController::homepageAction', 'homepage');
@@ -342,7 +344,7 @@ public function testAddsThePrefixOnlyOnceWhenLoadingMultipleCollections()
         $secondCollection = new RouteCollection();
         $secondCollection->add('b', new Route('/b'));
 
-        $loader = $this->getMockBuilder(\Symfony\Component\Config\Loader\LoaderInterface::class)->getMock();
+        $loader = $this->createMock(LoaderInterface::class);
         $loader->expects($this->any())
             ->method('supports')
             ->willReturn(true);
diff --git a/Tests/RouteTest.php b/Tests/RouteTest.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Routing\Tests;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\CompiledRoute;
 use Symfony\Component\Routing\Route;
 use Symfony\Component\Routing\Tests\Fixtures\CustomCompiledRoute;
 use Symfony\Component\Routing\Tests\Fixtures\CustomRouteCompiler;
@@ -188,7 +189,7 @@ public function testCondition()
     public function testCompile()
     {
         $route = new Route('/{foo}');
-        $this->assertInstanceOf(\Symfony\Component\Routing\CompiledRoute::class, $compiled = $route->compile(), '->compile() returns a compiled route');
+        $this->assertInstanceOf(CompiledRoute::class, $compiled = $route->compile(), '->compile() returns a compiled route');
         $this->assertSame($compiled, $route->compile(), '->compile() only compiled the route once if unchanged');
         $route->setRequirement('foo', '.*');
         $this->assertNotSame($compiled, $route->compile(), '->compile() recompiles if the route was modified');
diff --git a/Tests/RouterTest.php b/Tests/RouterTest.php

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,10 @@`
`12`	`12`	`namespace Symfony\Component\Routing\Tests\Generator;`
`13`	`13`
`14`	`14`	`use PHPUnit\Framework\TestCase;`
	`15`	`+use Psr\Log\LoggerInterface;`
	`16`	`+use Symfony\Component\Routing\Exception\InvalidParameterException;`
	`17`	`+use Symfony\Component\Routing\Exception\MissingMandatoryParametersException;`
	`18`	`+use Symfony\Component\Routing\Exception\RouteNotFoundException;`
`15`	`19`	`use Symfony\Component\Routing\Generator\UrlGenerator;`
`16`	`20`	`use Symfony\Component\Routing\Generator\UrlGeneratorInterface;`
`17`	`21`	`use Symfony\Component\Routing\RequestContext;`
`@@ -78,7 +82,7 @@ public function testRelativeUrlWithNullParameter()`
`78`	`82`
`79`	`83`	`public function testRelativeUrlWithNullParameterButNotOptional()`
`80`	`84`	`{`
`81`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`85`	`+ $this->expectException(InvalidParameterException::class);`
`82`	`86`	`$routes = $this->getRoutes('test', new Route('/testing/{foo}/bar', ['foo' => null]));`
`83`	`87`	`// This must raise an exception because the default requirement for "foo" is "[^/]+" which is not met with these params.`
`84`	`88`	`// Generating path "/testing//bar" would be wrong as matching this route would fail.`
`@@ -264,14 +268,14 @@ public function testDumpWithLocalizedRoutesPreserveTheGoodLocaleInTheUrl()`
`264`	`268`
`265`	`269`	`public function testGenerateWithoutRoutes()`
`266`	`270`	`{`
`267`		`- $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);`
	`271`	`+ $this->expectException(RouteNotFoundException::class);`
`268`	`272`	`$routes = $this->getRoutes('foo', new Route('/testing/{foo}'));`
`269`	`273`	`$this->getGenerator($routes)->generate('test', [], UrlGeneratorInterface::ABSOLUTE_URL);`
`270`	`274`	`}`
`271`	`275`
`272`	`276`	`public function testGenerateWithInvalidLocale()`
`273`	`277`	`{`
`274`		`- $this->expectException(\Symfony\Component\Routing\Exception\RouteNotFoundException::class);`
	`278`	`+ $this->expectException(RouteNotFoundException::class);`
`275`	`279`	`$routes = new RouteCollection();`
`276`	`280`
`277`	`281`	`$route = new Route('');`
`@@ -293,21 +297,21 @@ public function testGenerateWithInvalidLocale()`
`293`	`297`
`294`	`298`	`public function testGenerateForRouteWithoutMandatoryParameter()`
`295`	`299`	`{`
`296`		`- $this->expectException(\Symfony\Component\Routing\Exception\MissingMandatoryParametersException::class);`
	`300`	`+ $this->expectException(MissingMandatoryParametersException::class);`
`297`	`301`	`$routes = $this->getRoutes('test', new Route('/testing/{foo}'));`
`298`	`302`	`$this->getGenerator($routes)->generate('test', [], UrlGeneratorInterface::ABSOLUTE_URL);`
`299`	`303`	`}`
`300`	`304`
`301`	`305`	`public function testGenerateForRouteWithInvalidOptionalParameter()`
`302`	`306`	`{`
`303`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`307`	`+ $this->expectException(InvalidParameterException::class);`
`304`	`308`	`$routes = $this->getRoutes('test', new Route('/testing/{foo}', ['foo' => '1'], ['foo' => 'd+']));`
`305`	`309`	`$this->getGenerator($routes)->generate('test', ['foo' => 'bar'], UrlGeneratorInterface::ABSOLUTE_URL);`
`306`	`310`	`}`
`307`	`311`
`308`	`312`	`public function testGenerateForRouteWithInvalidParameter()`
`309`	`313`	`{`
`310`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`314`	`+ $this->expectException(InvalidParameterException::class);`
`311`	`315`	`$routes = $this->getRoutes('test', new Route('/testing/{foo}', [], ['foo' => '1\|2']));`
`312`	`316`	`$this->getGenerator($routes)->generate('test', ['foo' => '0'], UrlGeneratorInterface::ABSOLUTE_URL);`
`313`	`317`	`}`
`@@ -323,7 +327,7 @@ public function testGenerateForRouteWithInvalidOptionalParameterNonStrict()`
`323`	`327`	`public function testGenerateForRouteWithInvalidOptionalParameterNonStrictWithLogger()`
`324`	`328`	`{`
`325`	`329`	`$routes = $this->getRoutes('test', new Route('/testing/{foo}', ['foo' => '1'], ['foo' => 'd+']));`
`326`		`- $logger = $this->getMockBuilder(\Psr\Log\LoggerInterface::class)->getMock();`
	`330`	`+ $logger = $this->createMock(LoggerInterface::class);`
`327`	`331`	`$logger->expects($this->once())`
`328`	`332`	`->method('error');`
`329`	`333`	`$generator = $this->getGenerator($routes, [], $logger);`
`@@ -341,21 +345,21 @@ public function testGenerateForRouteWithInvalidParameterButDisabledRequirementsC`
`341`	`345`
`342`	`346`	`public function testGenerateForRouteWithInvalidMandatoryParameter()`
`343`	`347`	`{`
`344`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`348`	`+ $this->expectException(InvalidParameterException::class);`
`345`	`349`	`$routes = $this->getRoutes('test', new Route('/testing/{foo}', [], ['foo' => 'd+']));`
`346`	`350`	`$this->getGenerator($routes)->generate('test', ['foo' => 'bar'], UrlGeneratorInterface::ABSOLUTE_URL);`
`347`	`351`	`}`
`348`	`352`
`349`	`353`	`public function testGenerateForRouteWithInvalidUtf8Parameter()`
`350`	`354`	`{`
`351`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`355`	`+ $this->expectException(InvalidParameterException::class);`
`352`	`356`	`$routes = $this->getRoutes('test', new Route('/testing/{foo}', [], ['foo' => '\pL+'], ['utf8' => true]));`
`353`	`357`	`$this->getGenerator($routes)->generate('test', ['foo' => 'abc123'], UrlGeneratorInterface::ABSOLUTE_URL);`
`354`	`358`	`}`
`355`	`359`
`356`	`360`	`public function testRequiredParamAndEmptyPassed()`
`357`	`361`	`{`
`358`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`362`	`+ $this->expectException(InvalidParameterException::class);`
`359`	`363`	`$routes = $this->getRoutes('test', new Route('/{slug}', [], ['slug' => '.+']));`
`360`	`364`	`$this->getGenerator($routes)->generate('test', ['slug' => '']);`
`361`	`365`	`}`
`@@ -476,7 +480,7 @@ public function testAdjacentVariables()`
`476`	`480`
`477`	`481`	`// The default requirement for 'x' should not allow the separator '.' in this case because it would otherwise match everything`
`478`	`482`	`// and following optional variables like _format could never match.`
`479`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`483`	`+ $this->expectException(InvalidParameterException::class);`
`480`	`484`	`$generator->generate('test', ['x' => 'do.t', 'y' => '123', 'z' => 'bar', '_format' => 'xml']);`
`481`	`485`	`}`
`482`	`486`
`@@ -517,7 +521,7 @@ public function testImportantVariable()`
`517`	`521`
`518`	`522`	`public function testImportantVariableWithNoDefault()`
`519`	`523`	`{`
`520`		`- $this->expectException(\Symfony\Component\Routing\Exception\MissingMandatoryParametersException::class);`
	`524`	`+ $this->expectException(MissingMandatoryParametersException::class);`
`521`	`525`	`$routes = $this->getRoutes('test', new Route('/{page}.{!_format}'));`
`522`	`526`	`$generator = $this->getGenerator($routes);`
`523`	`527`
`@@ -526,14 +530,14 @@ public function testImportantVariableWithNoDefault()`
`526`	`530`
`527`	`531`	`public function testDefaultRequirementOfVariableDisallowsSlash()`
`528`	`532`	`{`
`529`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`533`	`+ $this->expectException(InvalidParameterException::class);`
`530`	`534`	`$routes = $this->getRoutes('test', new Route('/{page}.{_format}'));`
`531`	`535`	`$this->getGenerator($routes)->generate('test', ['page' => 'index', '_format' => 'sl/ash']);`
`532`	`536`	`}`
`533`	`537`
`534`	`538`	`public function testDefaultRequirementOfVariableDisallowsNextSeparator()`
`535`	`539`	`{`
`536`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`540`	`+ $this->expectException(InvalidParameterException::class);`
`537`	`541`	`$routes = $this->getRoutes('test', new Route('/{page}.{_format}'));`
`538`	`542`	`$this->getGenerator($routes)->generate('test', ['page' => 'do.t', '_format' => 'html']);`
`539`	`543`	`}`
`@@ -561,21 +565,21 @@ public function testWithHostSameAsContextAndAbsolute()`
`561`	`565`
`562`	`566`	`public function testUrlWithInvalidParameterInHost()`
`563`	`567`	`{`
`564`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`568`	`+ $this->expectException(InvalidParameterException::class);`
`565`	`569`	`$routes = $this->getRoutes('test', new Route('/', [], ['foo' => 'bar'], [], '{foo}.example.com'));`
`566`	`570`	`$this->getGenerator($routes)->generate('test', ['foo' => 'baz'], UrlGeneratorInterface::ABSOLUTE_PATH);`
`567`	`571`	`}`
`568`	`572`
`569`	`573`	`public function testUrlWithInvalidParameterInHostWhenParamHasADefaultValue()`
`570`	`574`	`{`
`571`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`575`	`+ $this->expectException(InvalidParameterException::class);`
`572`	`576`	`$routes = $this->getRoutes('test', new Route('/', ['foo' => 'bar'], ['foo' => 'bar'], [], '{foo}.example.com'));`
`573`	`577`	`$this->getGenerator($routes)->generate('test', ['foo' => 'baz'], UrlGeneratorInterface::ABSOLUTE_PATH);`
`574`	`578`	`}`
`575`	`579`
`576`	`580`	`public function testUrlWithInvalidParameterEqualsDefaultValueInHost()`
`577`	`581`	`{`
`578`		`- $this->expectException(\Symfony\Component\Routing\Exception\InvalidParameterException::class);`
	`582`	`+ $this->expectException(InvalidParameterException::class);`
`579`	`583`	`$routes = $this->getRoutes('test', new Route('/', ['foo' => 'baz'], ['foo' => 'bar'], [], '{foo}.example.com'));`
`580`	`584`	`$this->getGenerator($routes)->generate('test', ['foo' => 'baz'], UrlGeneratorInterface::ABSOLUTE_PATH);`
`581`	`585`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`namespace Symfony\Component\Routing\Tests\Loader;`
`13`	`13`
`14`	`14`	`use PHPUnit\Framework\TestCase;`
	`15`	`+use Symfony\Component\Routing\Loader\AnnotationClassLoader;`
`15`	`16`
`16`	`17`	`abstract class AbstractAnnotationLoaderTest extends TestCase`
`17`	`18`	`{`
`@@ -25,7 +26,7 @@ public function getReader()`
`25`	`26`
`26`	`27`	`public function getClassLoader($reader)`
`27`	`28`	`{`
`28`		`- return $this->getMockBuilder(\Symfony\Component\Routing\Loader\AnnotationClassLoader::class)`
	`29`	`+ return $this->getMockBuilder(AnnotationClassLoader::class)`
`29`	`30`	`->setConstructorArgs([$reader])`
`30`	`31`	`->getMockForAbstractClass()`
`31`	`32`	`;`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ class PhpFileLoaderTest extends TestCase`
`22`	`22`	`{`
`23`	`23`	`public function testSupports()`
`24`	`24`	`{`
`25`		`- $loader = new PhpFileLoader($this->getMockBuilder(FileLocator::class)->getMock());`
	`25`	`+ $loader = new PhpFileLoader($this->createMock(FileLocator::class));`
`26`	`26`
`27`	`27`	`$this->assertTrue($loader->supports('foo.php'), '->supports() returns true if the resource is loadable');`
`28`	`28`	`$this->assertFalse($loader->supports('foo.foo'), '->supports() returns true if the resource is loadable');`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class XmlFileLoaderTest extends TestCase`
`23`	`23`	`{`
`24`	`24`	`public function testSupports()`
`25`	`25`	`{`
`26`		`- $loader = new XmlFileLoader($this->getMockBuilder(FileLocator::class)->getMock());`
	`26`	`+ $loader = new XmlFileLoader($this->createMock(FileLocator::class));`
`27`	`27`
`28`	`28`	`$this->assertTrue($loader->supports('foo.xml'), '->supports() returns true if the resource is loadable');`
`29`	`29`	`$this->assertFalse($loader->supports('foo.foo'), '->supports() returns true if the resource is loadable');`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ class YamlFileLoaderTest extends TestCase`
`22`	`22`	`{`
`23`	`23`	`public function testSupports()`
`24`	`24`	`{`
`25`		`- $loader = new YamlFileLoader($this->getMockBuilder(FileLocator::class)->getMock());`
	`25`	`+ $loader = new YamlFileLoader($this->createMock(FileLocator::class));`
`26`	`26`
`27`	`27`	`$this->assertTrue($loader->supports('foo.yml'), '->supports() returns true if the resource is loadable');`
`28`	`28`	`$this->assertTrue($loader->supports('foo.yaml'), '->supports() returns true if the resource is loadable');`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,8 @@`
`11`	`11`
`12`	`12`	`namespace Symfony\Component\Routing\Tests\Matcher;`
`13`	`13`
	`14`	`+use Symfony\Component\Routing\Exception\ResourceNotFoundException;`
	`15`	`+use Symfony\Component\Routing\Matcher\RedirectableUrlMatcher;`
`14`	`16`	`use Symfony\Component\Routing\RequestContext;`
`15`	`17`	`use Symfony\Component\Routing\Route;`
`16`	`18`	`use Symfony\Component\Routing\RouteCollection;`
`@@ -39,7 +41,7 @@ public function testExtraTrailingSlash()`
`39`	`41`
`40`	`42`	`public function testRedirectWhenNoSlashForNonSafeMethod()`
`41`	`43`	`{`
`42`		`- $this->expectException(\Symfony\Component\Routing\Exception\ResourceNotFoundException::class);`
	`44`	`+ $this->expectException(ResourceNotFoundException::class);`
`43`	`45`	`$coll = new RouteCollection();`
`44`	`46`	`$coll->add('foo', new Route('/foo/'));`
`45`	`47`
`@@ -209,6 +211,6 @@ public function testTrailingRequirementWithDefault_A()`
`209`	`211`
`210`	`212`	`protected function getUrlMatcher(RouteCollection $routes, RequestContext $context = null)`
`211`	`213`	`{`
`212`		`- return $this->getMockForAbstractClass(\Symfony\Component\Routing\Matcher\RedirectableUrlMatcher::class, [$routes, $context ?: new RequestContext()]);`
	`214`	`+ return $this->getMockForAbstractClass(RedirectableUrlMatcher::class, [$routes, $context ?: new RequestContext()]);`
`213`	`215`	`}`
`214`	`216`	`}`