Laravel version update

Laravel version update

vendor/symfony/http-kernel/Tests/Controller/ArgumentResolver/ServiceValueResolverTest.php

@@ -0,0 +1,112 @@
+<?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\HttpKernel\Tests\Controller\ArgumentResolver;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\DependencyInjection\ServiceLocator;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentResolver\ServiceValueResolver;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+class ServiceValueResolverTest extends TestCase
+{
+    public function testDoNotSupportWhenControllerDoNotExists()
+    {
+        $resolver = new ServiceValueResolver(new ServiceLocator(array()));
+        $argument = new ArgumentMetadata('dummy', DummyService::class, false, false, null);
+        $request = $this->requestWithAttributes(array('_controller' => 'my_controller'));
+
+        $this->assertFalse($resolver->supports($request, $argument));
+    }
+
+    public function testExistingController()
+    {
+        $resolver = new ServiceValueResolver(new ServiceLocator(array(
+            'App\\Controller\\Mine::method' => function () {
+                return new ServiceLocator(array(
+                    'dummy' => function () {
+                        return new DummyService();
+                    },
+                ));
+            },
+        )));
+
+        $request = $this->requestWithAttributes(array('_controller' => 'App\\Controller\\Mine::method'));
+        $argument = new ArgumentMetadata('dummy', DummyService::class, false, false, null);
+
+        $this->assertTrue($resolver->supports($request, $argument));
+        $this->assertYieldEquals(array(new DummyService()), $resolver->resolve($request, $argument));
+    }
+
+    public function testExistingControllerWithATrailingBackSlash()
+    {
+        $resolver = new ServiceValueResolver(new ServiceLocator(array(
+            'App\\Controller\\Mine::method' => function () {
+                return new ServiceLocator(array(
+                    'dummy' => function () {
+                        return new DummyService();
+                    },
+                ));
+            },
+        )));
+
+        $request = $this->requestWithAttributes(array('_controller' => '\\App\\Controller\\Mine::method'));
+        $argument = new ArgumentMetadata('dummy', DummyService::class, false, false, null);
+
+        $this->assertTrue($resolver->supports($request, $argument));
+        $this->assertYieldEquals(array(new DummyService()), $resolver->resolve($request, $argument));
+    }
+
+    public function testControllerNameIsAnArray()
+    {
+        $resolver = new ServiceValueResolver(new ServiceLocator(array(
+            'App\\Controller\\Mine::method' => function () {
+                return new ServiceLocator(array(
+                    'dummy' => function () {
+                        return new DummyService();
+                    },
+                ));
+            },
+        )));
+
+        $request = $this->requestWithAttributes(array('_controller' => array('App\\Controller\\Mine', 'method')));
+        $argument = new ArgumentMetadata('dummy', DummyService::class, false, false, null);
+
+        $this->assertTrue($resolver->supports($request, $argument));
+        $this->assertYieldEquals(array(new DummyService()), $resolver->resolve($request, $argument));
+    }
+
+    private function requestWithAttributes(array $attributes)
+    {
+        $request = Request::create('/');
+
+        foreach ($attributes as $name => $value) {
+            $request->attributes->set($name, $value);
+        }
+
+        return $request;
+    }
+
+    private function assertYieldEquals(array $expected, \Generator $generator)
+    {
+        $args = array();
+        foreach ($generator as $arg) {
+            $args[] = $arg;
+        }
+
+        $this->assertEquals($expected, $args);
+    }
+}
+
+class DummyService
+{
+}

vendor/symfony/http-kernel/Tests/Controller/ArgumentResolverTest.php

@@ -0,0 +1,349 @@
+<?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\HttpKernel\Tests\Controller;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Session\Session;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
+use Symfony\Component\HttpKernel\Controller\ArgumentResolver;
+use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestAttributeValueResolver;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadataFactory;
+use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\ExtendingRequest;
+use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\ExtendingSession;
+use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
+use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
+
+class ArgumentResolverTest extends TestCase
+{
+    /** @var ArgumentResolver */
+    private static $resolver;
+
+    public static function setUpBeforeClass()
+    {
+        $factory = new ArgumentMetadataFactory();
+
+        self::$resolver = new ArgumentResolver($factory);
+    }
+
+    public function testDefaultState()
+    {
+        $this->assertEquals(self::$resolver, new ArgumentResolver());
+        $this->assertNotEquals(self::$resolver, new ArgumentResolver(null, array(new RequestAttributeValueResolver())));
+    }
+
+    public function testGetArguments()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $controller = array(new self(), 'controllerWithFoo');
+
+        $this->assertEquals(array('foo'), self::$resolver->getArguments($request, $controller), '->getArguments() returns an array of arguments for the controller method');
+    }
+
+    public function testGetArgumentsReturnsEmptyArrayWhenNoArguments()
+    {
+        $request = Request::create('/');
+        $controller = array(new self(), 'controllerWithoutArguments');
+
+        $this->assertEquals(array(), self::$resolver->getArguments($request, $controller), '->getArguments() returns an empty array if the method takes no arguments');
+    }
+
+    public function testGetArgumentsUsesDefaultValue()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $controller = array(new self(), 'controllerWithFooAndDefaultBar');
+
+        $this->assertEquals(array('foo', null), self::$resolver->getArguments($request, $controller), '->getArguments() uses default values if present');
+    }
+
+    public function testGetArgumentsOverrideDefaultValueByRequestAttribute()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('bar', 'bar');
+        $controller = array(new self(), 'controllerWithFooAndDefaultBar');
+
+        $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller), '->getArguments() overrides default values if provided in the request attributes');
+    }
+
+    public function testGetArgumentsFromClosure()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $controller = function ($foo) {};
+
+        $this->assertEquals(array('foo'), self::$resolver->getArguments($request, $controller));
+    }
+
+    public function testGetArgumentsUsesDefaultValueFromClosure()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $controller = function ($foo, $bar = 'bar') {};
+
+        $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller));
+    }
+
+    public function testGetArgumentsFromInvokableObject()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $controller = new self();
+
+        $this->assertEquals(array('foo', null), self::$resolver->getArguments($request, $controller));
+
+        // Test default bar overridden by request attribute
+        $request->attributes->set('bar', 'bar');
+
+        $this->assertEquals(array('foo', 'bar'), self::$resolver->getArguments($request, $controller));
+    }
+
+    public function testGetArgumentsFromFunctionName()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('foobar', 'foobar');
+        $controller = __NAMESPACE__.'\controller_function';
+
+        $this->assertEquals(array('foo', 'foobar'), self::$resolver->getArguments($request, $controller));
+    }
+
+    public function testGetArgumentsFailsOnUnresolvedValue()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('foobar', 'foobar');
+        $controller = array(new self(), 'controllerWithFooBarFoobar');
+
+        try {
+            self::$resolver->getArguments($request, $controller);
+            $this->fail('->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
+        } catch (\Exception $e) {
+            $this->assertInstanceOf('\RuntimeException', $e, '->getArguments() throws a \RuntimeException exception if it cannot determine the argument value');
+        }
+    }
+
+    public function testGetArgumentsInjectsRequest()
+    {
+        $request = Request::create('/');
+        $controller = array(new self(), 'controllerWithRequest');
+
+        $this->assertEquals(array($request), self::$resolver->getArguments($request, $controller), '->getArguments() injects the request');
+    }
+
+    public function testGetArgumentsInjectsExtendingRequest()
+    {
+        $request = ExtendingRequest::create('/');
+        $controller = array(new self(), 'controllerWithExtendingRequest');
+
+        $this->assertEquals(array($request), self::$resolver->getArguments($request, $controller), '->getArguments() injects the request when extended');
+    }
+
+    /**
+     * @requires PHP 5.6
+     */
+    public function testGetVariadicArguments()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('bar', array('foo', 'bar'));
+        $controller = array(new VariadicController(), 'action');
+
+        $this->assertEquals(array('foo', 'foo', 'bar'), self::$resolver->getArguments($request, $controller));
+    }
+
+    /**
+     * @requires PHP 5.6
+     * @expectedException \InvalidArgumentException
+     */
+    public function testGetVariadicArgumentsWithoutArrayInRequest()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('bar', 'foo');
+        $controller = array(new VariadicController(), 'action');
+
+        self::$resolver->getArguments($request, $controller);
+    }
+
+    /**
+     * @requires PHP 5.6
+     * @expectedException \InvalidArgumentException
+     */
+    public function testGetArgumentWithoutArray()
+    {
+        $factory = new ArgumentMetadataFactory();
+        $valueResolver = $this->getMockBuilder(ArgumentValueResolverInterface::class)->getMock();
+        $resolver = new ArgumentResolver($factory, array($valueResolver));
+
+        $valueResolver->expects($this->any())->method('supports')->willReturn(true);
+        $valueResolver->expects($this->any())->method('resolve')->willReturn('foo');
+
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('bar', 'foo');
+        $controller = array($this, 'controllerWithFooAndDefaultBar');
+        $resolver->getArguments($request, $controller);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testIfExceptionIsThrownWhenMissingAnArgument()
+    {
+        $request = Request::create('/');
+        $controller = array($this, 'controllerWithFoo');
+
+        self::$resolver->getArguments($request, $controller);
+    }
+
+    /**
+     * @requires PHP 7.1
+     */
+    public function testGetNullableArguments()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('bar', new \stdClass());
+        $request->attributes->set('mandatory', 'mandatory');
+        $controller = array(new NullableController(), 'action');
+
+        $this->assertEquals(array('foo', new \stdClass(), 'value', 'mandatory'), self::$resolver->getArguments($request, $controller));
+    }
+
+    /**
+     * @requires PHP 7.1
+     */
+    public function testGetNullableArgumentsWithDefaults()
+    {
+        $request = Request::create('/');
+        $request->attributes->set('mandatory', 'mandatory');
+        $controller = array(new NullableController(), 'action');
+
+        $this->assertEquals(array(null, null, 'value', 'mandatory'), self::$resolver->getArguments($request, $controller));
+    }
+
+    public function testGetSessionArguments()
+    {
+        $session = new Session(new MockArraySessionStorage());
+        $request = Request::create('/');
+        $request->setSession($session);
+        $controller = array($this, 'controllerWithSession');
+
+        $this->assertEquals(array($session), self::$resolver->getArguments($request, $controller));
+    }
+
+    public function testGetSessionArgumentsWithExtendedSession()
+    {
+        $session = new ExtendingSession(new MockArraySessionStorage());
+        $request = Request::create('/');
+        $request->setSession($session);
+        $controller = array($this, 'controllerWithExtendingSession');
+
+        $this->assertEquals(array($session), self::$resolver->getArguments($request, $controller));
+    }
+
+    public function testGetSessionArgumentsWithInterface()
+    {
+        $session = $this->getMockBuilder(SessionInterface::class)->getMock();
+        $request = Request::create('/');
+        $request->setSession($session);
+        $controller = array($this, 'controllerWithSessionInterface');
+
+        $this->assertEquals(array($session), self::$resolver->getArguments($request, $controller));
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testGetSessionMissMatchWithInterface()
+    {
+        $session = $this->getMockBuilder(SessionInterface::class)->getMock();
+        $request = Request::create('/');
+        $request->setSession($session);
+        $controller = array($this, 'controllerWithExtendingSession');
+
+        self::$resolver->getArguments($request, $controller);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testGetSessionMissMatchWithImplementation()
+    {
+        $session = new Session(new MockArraySessionStorage());
+        $request = Request::create('/');
+        $request->setSession($session);
+        $controller = array($this, 'controllerWithExtendingSession');
+
+        self::$resolver->getArguments($request, $controller);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testGetSessionMissMatchOnNull()
+    {
+        $request = Request::create('/');
+        $controller = array($this, 'controllerWithExtendingSession');
+
+        self::$resolver->getArguments($request, $controller);
+    }
+
+    public function __invoke($foo, $bar = null)
+    {
+    }
+
+    public function controllerWithFoo($foo)
+    {
+    }
+
+    public function controllerWithoutArguments()
+    {
+    }
+
+    protected function controllerWithFooAndDefaultBar($foo, $bar = null)
+    {
+    }
+
+    protected function controllerWithFooBarFoobar($foo, $bar, $foobar)
+    {
+    }
+
+    protected function controllerWithRequest(Request $request)
+    {
+    }
+
+    protected function controllerWithExtendingRequest(ExtendingRequest $request)
+    {
+    }
+
+    protected function controllerWithSession(Session $session)
+    {
+    }
+
+    protected function controllerWithSessionInterface(SessionInterface $session)
+    {
+    }
+
+    protected function controllerWithExtendingSession(ExtendingSession $session)
+    {
+    }
+}
+
+function controller_function($foo, $foobar)
+{
+}

vendor/symfony/http-kernel/Tests/Controller/ContainerControllerResolverTest.php

@@ -0,0 +1,308 @@
+<?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\HttpKernel\Tests\Controller;
+
+use Psr\Container\ContainerInterface;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Debug\ErrorHandler;
+use Symfony\Component\DependencyInjection\Container;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ContainerControllerResolver;
+
+class ContainerControllerResolverTest extends ControllerResolverTest
+{
+    public function testGetControllerService()
+    {
+        $container = $this->createMockContainer();
+        $container->expects($this->once())
+            ->method('has')
+            ->with('foo')
+            ->will($this->returnValue(true));
+        $container->expects($this->once())
+            ->method('get')
+            ->with('foo')
+            ->will($this->returnValue($this))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+        $request = Request::create('/');
+        $request->attributes->set('_controller', 'foo:controllerMethod1');
+
+        $controller = $resolver->getController($request);
+
+        $this->assertInstanceOf(\get_class($this), $controller[0]);
+        $this->assertSame('controllerMethod1', $controller[1]);
+    }
+
+    public function testGetControllerInvokableService()
+    {
+        $invokableController = new InvokableController('bar');
+
+        $container = $this->createMockContainer();
+        $container->expects($this->once())
+            ->method('has')
+            ->with('foo')
+            ->will($this->returnValue(true))
+        ;
+        $container->expects($this->once())
+            ->method('get')
+            ->with('foo')
+            ->will($this->returnValue($invokableController))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+        $request = Request::create('/');
+        $request->attributes->set('_controller', 'foo');
+
+        $controller = $resolver->getController($request);
+
+        $this->assertEquals($invokableController, $controller);
+    }
+
+    public function testGetControllerInvokableServiceWithClassNameAsName()
+    {
+        $invokableController = new InvokableController('bar');
+        $className = __NAMESPACE__.'\InvokableController';
+
+        $container = $this->createMockContainer();
+        $container->expects($this->once())
+            ->method('has')
+            ->with($className)
+            ->will($this->returnValue(true))
+        ;
+        $container->expects($this->once())
+            ->method('get')
+            ->with($className)
+            ->will($this->returnValue($invokableController))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+        $request = Request::create('/');
+        $request->attributes->set('_controller', $className);
+
+        $controller = $resolver->getController($request);
+
+        $this->assertEquals($invokableController, $controller);
+    }
+
+    public function testNonInstantiableController()
+    {
+        $container = $this->createMockContainer();
+        $container->expects($this->once())
+            ->method('has')
+            ->with(NonInstantiableController::class)
+            ->will($this->returnValue(false))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+        $request = Request::create('/');
+        $request->attributes->set('_controller', array(NonInstantiableController::class, 'action'));
+
+        $controller = $resolver->getController($request);
+
+        $this->assertSame(array(NonInstantiableController::class, 'action'), $controller);
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Controller "Symfony\Component\HttpKernel\Tests\Controller\ImpossibleConstructController" cannot be fetched from the container because it is private. Did you forget to tag the service with "controller.service_arguments"?
+     */
+    public function testNonConstructController()
+    {
+        $container = $this->getMockBuilder(Container::class)->getMock();
+        $container->expects($this->at(0))
+            ->method('has')
+            ->with(ImpossibleConstructController::class)
+            ->will($this->returnValue(true))
+        ;
+
+        $container->expects($this->at(1))
+            ->method('has')
+            ->with(ImpossibleConstructController::class)
+            ->will($this->returnValue(false))
+        ;
+
+        $container->expects($this->atLeastOnce())
+            ->method('getRemovedIds')
+            ->with()
+            ->will($this->returnValue(array(ImpossibleConstructController::class => true)))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+        $request = Request::create('/');
+        $request->attributes->set('_controller', array(ImpossibleConstructController::class, 'action'));
+
+        if (\PHP_VERSION_ID < 70100) {
+            ErrorHandler::register();
+            try {
+                $resolver->getController($request);
+            } finally {
+                restore_error_handler();
+                restore_exception_handler();
+            }
+        } else {
+            $resolver->getController($request);
+        }
+    }
+
+    public function testNonInstantiableControllerWithCorrespondingService()
+    {
+        $service = new \stdClass();
+
+        $container = $this->createMockContainer();
+        $container->expects($this->atLeastOnce())
+            ->method('has')
+            ->with(NonInstantiableController::class)
+            ->will($this->returnValue(true))
+        ;
+        $container->expects($this->atLeastOnce())
+            ->method('get')
+            ->with(NonInstantiableController::class)
+            ->will($this->returnValue($service))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+        $request = Request::create('/');
+        $request->attributes->set('_controller', array(NonInstantiableController::class, 'action'));
+
+        $controller = $resolver->getController($request);
+
+        $this->assertSame(array($service, 'action'), $controller);
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Controller "app.my_controller" cannot be fetched from the container because it is private. Did you forget to tag the service with "controller.service_arguments"?
+     */
+    public function testExceptionWhenUsingRemovedControllerService()
+    {
+        $container = $this->getMockBuilder(Container::class)->getMock();
+        $container->expects($this->at(0))
+            ->method('has')
+            ->with('app.my_controller')
+            ->will($this->returnValue(false))
+        ;
+
+        $container->expects($this->atLeastOnce())
+            ->method('getRemovedIds')
+            ->with()
+            ->will($this->returnValue(array('app.my_controller' => true)))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+
+        $request = Request::create('/');
+        $request->attributes->set('_controller', 'app.my_controller');
+        $resolver->getController($request);
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Controller "app.my_controller" cannot be called without a method name. Did you forget an "__invoke" method?
+     */
+    public function testExceptionWhenUsingControllerWithoutAnInvokeMethod()
+    {
+        $container = $this->getMockBuilder(Container::class)->getMock();
+        $container->expects($this->once())
+            ->method('has')
+            ->with('app.my_controller')
+            ->will($this->returnValue(true))
+        ;
+        $container->expects($this->once())
+            ->method('get')
+            ->with('app.my_controller')
+            ->will($this->returnValue(new ImpossibleConstructController('toto', 'controller')))
+        ;
+
+        $resolver = $this->createControllerResolver(null, $container);
+
+        $request = Request::create('/');
+        $request->attributes->set('_controller', 'app.my_controller');
+        $resolver->getController($request);
+    }
+
+    /**
+     * @dataProvider getUndefinedControllers
+     */
+    public function testGetControllerOnNonUndefinedFunction($controller, $exceptionName = null, $exceptionMessage = null)
+    {
+        // All this logic needs to be duplicated, since calling parent::testGetControllerOnNonUndefinedFunction will override the expected excetion and not use the regex
+        $resolver = $this->createControllerResolver();
+        if (method_exists($this, 'expectException')) {
+            $this->expectException($exceptionName);
+            $this->expectExceptionMessageRegExp($exceptionMessage);
+        } else {
+            $this->setExpectedExceptionRegExp($exceptionName, $exceptionMessage);
+        }
+
+        $request = Request::create('/');
+        $request->attributes->set('_controller', $controller);
+        $resolver->getController($request);
+    }
+
+    public function getUndefinedControllers()
+    {
+        return array(
+            array('foo', \LogicException::class, '/Controller not found: service "foo" does not exist\./'),
+            array('oof::bar', \InvalidArgumentException::class, '/Class "oof" does not exist\./'),
+            array('stdClass', \LogicException::class, '/Controller not found: service "stdClass" does not exist\./'),
+            array(
+                'Symfony\Component\HttpKernel\Tests\Controller\ControllerResolverTest::bar',
+                \InvalidArgumentException::class,
+                '/.?[cC]ontroller(.*?) for URI "\/" is not callable\.( Expected method(.*) Available methods)?/',
+            ),
+        );
+    }
+
+    protected function createControllerResolver(LoggerInterface $logger = null, ContainerInterface $container = null)
+    {
+        if (!$container) {
+            $container = $this->createMockContainer();
+        }
+
+        return new ContainerControllerResolver($container, $logger);
+    }
+
+    protected function createMockContainer()
+    {
+        return $this->getMockBuilder(ContainerInterface::class)->getMock();
+    }
+}
+
+class InvokableController
+{
+    public function __construct($bar) // mandatory argument to prevent automatic instantiation
+    {
+    }
+
+    public function __invoke()
+    {
+    }
+}
+
+abstract class NonInstantiableController
+{
+    public static function action()
+    {
+    }
+}
+
+class ImpossibleConstructController
+{
+    public function __construct($toto, $controller)
+    {
+    }
+
+    public function action()
+    {
+    }
+}

vendor/symfony/http-kernel/Tests/Controller/ControllerResolverTest.php

@@ -11,16 +11,18 @@
 
 namespace Symfony\Component\HttpKernel\Tests\Controller;
 
+use PHPUnit\Framework\TestCase;
 use Psr\Log\LoggerInterface;
-use Symfony\Component\HttpKernel\Controller\ControllerResolver;
-use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
 use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ControllerResolver;
+use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\NullableController;
+use Symfony\Component\HttpKernel\Tests\Fixtures\Controller\VariadicController;
 
-class ControllerResolverTest extends \PHPUnit_Framework_TestCase
+class ControllerResolverTest extends TestCase
 {
     public function testGetControllerWithoutControllerParameter()
     {
-        $logger = $this->getMock('Psr\Log\LoggerInterface');
+        $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
         $logger->expects($this->once())->method('warning')->with('Unable to look for the controller as the "_controller" parameter is missing.');
         $resolver = $this->createControllerResolver($logger);
 
@@ -116,7 +118,12 @@ class ControllerResolverTest extends \PHPUnit_Framework_TestCase
     public function testGetControllerOnNonUndefinedFunction($controller, $exceptionName = null, $exceptionMessage = null)
     {
         $resolver = $this->createControllerResolver();
-        $this->setExpectedException($exceptionName, $exceptionMessage);
+        if (method_exists($this, 'expectException')) {
+            $this->expectException($exceptionName);
+            $this->expectExceptionMessage($exceptionMessage);
+        } else {
+            $this->setExpectedException($exceptionName, $exceptionMessage);
+        }
 
         $request = Request::create('/');
         $request->attributes->set('_controller', $controller);
@@ -137,6 +144,9 @@ class ControllerResolverTest extends \PHPUnit_Framework_TestCase
         );
     }
 
+    /**
+     * @group legacy
+     */
     public function testGetArguments()
     {
         $resolver = $this->createControllerResolver();
@@ -200,6 +210,7 @@ class ControllerResolverTest extends \PHPUnit_Framework_TestCase
 
     /**
      * @requires PHP 5.6
+     * @group legacy
      */
     public function testGetVariadicArguments()
     {
@@ -214,7 +225,7 @@ class ControllerResolverTest extends \PHPUnit_Framework_TestCase
 
     public function testCreateControllerCanReturnAnyCallable()
     {
-        $mock = $this->getMock('Symfony\Component\HttpKernel\Controller\ControllerResolver', array('createController'));
+        $mock = $this->getMockBuilder('Symfony\Component\HttpKernel\Controller\ControllerResolver')->setMethods(array('createController'))->getMock();
         $mock->expects($this->once())->method('createController')->will($this->returnValue('Symfony\Component\HttpKernel\Tests\Controller\some_controller_function'));
 
         $request = Request::create('/');
@@ -222,6 +233,50 @@ class ControllerResolverTest extends \PHPUnit_Framework_TestCase
         $mock->getController($request);
     }
 
+    /**
+     * @expectedException \RuntimeException
+     * @group legacy
+     */
+    public function testIfExceptionIsThrownWhenMissingAnArgument()
+    {
+        $resolver = new ControllerResolver();
+        $request = Request::create('/');
+
+        $controller = array($this, 'controllerMethod1');
+
+        $resolver->getArguments($request, $controller);
+    }
+
+    /**
+     * @requires PHP 7.1
+     * @group legacy
+     */
+    public function testGetNullableArguments()
+    {
+        $resolver = new ControllerResolver();
+
+        $request = Request::create('/');
+        $request->attributes->set('foo', 'foo');
+        $request->attributes->set('bar', new \stdClass());
+        $request->attributes->set('mandatory', 'mandatory');
+        $controller = array(new NullableController(), 'action');
+        $this->assertEquals(array('foo', new \stdClass(), 'value', 'mandatory'), $resolver->getArguments($request, $controller));
+    }
+
+    /**
+     * @requires PHP 7.1
+     * @group legacy
+     */
+    public function testGetNullableArgumentsWithDefaults()
+    {
+        $resolver = new ControllerResolver();
+
+        $request = Request::create('/');
+        $request->attributes->set('mandatory', 'mandatory');
+        $controller = array(new NullableController(), 'action');
+        $this->assertEquals(array(null, null, 'value', 'mandatory'), $resolver->getArguments($request, $controller));
+    }
+
     protected function createControllerResolver(LoggerInterface $logger = null)
     {
         return new ControllerResolver($logger);