dependabot-composer 0.113.19 → 0.113.20

data/helpers/vendor/symfony/options-resolver/README.md

@@ -1,15 +0,0 @@
-OptionsResolver Component
-=========================
-
-The OptionsResolver component is `array_replace` on steroids. It allows you to
-create an options system with required options, defaults, validation (type,
-value), normalization and more.
-
-Resources
----------
-
-  * [Documentation](https://symfony.com/doc/current/components/options_resolver.html)
-  * [Contributing](https://symfony.com/doc/current/contributing/index.html)
-  * [Report issues](https://github.com/symfony/symfony/issues) and
-    [send Pull Requests](https://github.com/symfony/symfony/pulls)
-    in the [main Symfony repository](https://github.com/symfony/symfony)

data/helpers/vendor/symfony/options-resolver/Tests/Debug/OptionsResolverIntrospectorTest.php

@@ -1,183 +0,0 @@
-<?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\OptionsResolver\Tests\Debug;
-
-use PHPUnit\Framework\TestCase;
-use Symfony\Component\OptionsResolver\Debug\OptionsResolverIntrospector;
-use Symfony\Component\OptionsResolver\Options;
-use Symfony\Component\OptionsResolver\OptionsResolver;
-
-class OptionsResolverIntrospectorTest extends TestCase
-{
-    public function testGetDefault()
-    {
-        $resolver = new OptionsResolver();
-        $resolver->setDefault($option = 'foo', 'bar');
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getDefault($option));
-    }
-
-    public function testGetDefaultNull()
-    {
-        $resolver = new OptionsResolver();
-        $resolver->setDefault($option = 'foo', null);
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertNull($debug->getDefault($option));
-    }
-
-    public function testGetDefaultThrowsOnNoConfiguredValue()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\NoConfigurationException');
-        $this->expectExceptionMessage('No default value was set for the "foo" option.');
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getDefault($option));
-    }
-
-    public function testGetDefaultThrowsOnNotDefinedOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->expectExceptionMessage('The option "foo" does not exist.');
-        $resolver = new OptionsResolver();
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getDefault('foo'));
-    }
-
-    public function testGetLazyClosures()
-    {
-        $resolver = new OptionsResolver();
-        $closures = [];
-        $resolver->setDefault($option = 'foo', $closures[] = function (Options $options) {});
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame($closures, $debug->getLazyClosures($option));
-    }
-
-    public function testGetLazyClosuresThrowsOnNoConfiguredValue()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\NoConfigurationException');
-        $this->expectExceptionMessage('No lazy closures were set for the "foo" option.');
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getLazyClosures($option));
-    }
-
-    public function testGetLazyClosuresThrowsOnNotDefinedOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->expectExceptionMessage('The option "foo" does not exist.');
-        $resolver = new OptionsResolver();
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getLazyClosures('foo'));
-    }
-
-    public function testGetAllowedTypes()
-    {
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-        $resolver->setAllowedTypes($option = 'foo', $allowedTypes = ['string', 'bool']);
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame($allowedTypes, $debug->getAllowedTypes($option));
-    }
-
-    public function testGetAllowedTypesThrowsOnNoConfiguredValue()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\NoConfigurationException');
-        $this->expectExceptionMessage('No allowed types were set for the "foo" option.');
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getAllowedTypes($option));
-    }
-
-    public function testGetAllowedTypesThrowsOnNotDefinedOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->expectExceptionMessage('The option "foo" does not exist.');
-        $resolver = new OptionsResolver();
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getAllowedTypes('foo'));
-    }
-
-    public function testGetAllowedValues()
-    {
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-        $resolver->setAllowedValues($option = 'foo', $allowedValues = ['bar', 'baz']);
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame($allowedValues, $debug->getAllowedValues($option));
-    }
-
-    public function testGetAllowedValuesThrowsOnNoConfiguredValue()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\NoConfigurationException');
-        $this->expectExceptionMessage('No allowed values were set for the "foo" option.');
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getAllowedValues($option));
-    }
-
-    public function testGetAllowedValuesThrowsOnNotDefinedOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->expectExceptionMessage('The option "foo" does not exist.');
-        $resolver = new OptionsResolver();
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getAllowedValues('foo'));
-    }
-
-    public function testGetNormalizer()
-    {
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-        $resolver->setNormalizer($option = 'foo', $normalizer = function () {});
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame($normalizer, $debug->getNormalizer($option));
-    }
-
-    public function testGetNormalizerThrowsOnNoConfiguredValue()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\NoConfigurationException');
-        $this->expectExceptionMessage('No normalizer was set for the "foo" option.');
-        $resolver = new OptionsResolver();
-        $resolver->setDefined($option = 'foo');
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getNormalizer($option));
-    }
-
-    public function testGetNormalizerThrowsOnNotDefinedOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->expectExceptionMessage('The option "foo" does not exist.');
-        $resolver = new OptionsResolver();
-
-        $debug = new OptionsResolverIntrospector($resolver);
-        $this->assertSame('bar', $debug->getNormalizer('foo'));
-    }
-}

data/helpers/vendor/symfony/options-resolver/Tests/OptionsResolverTest.php

@@ -1,1619 +0,0 @@
-<?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\OptionsResolver\Tests;
-
-use PHPUnit\Framework\Assert;
-use PHPUnit\Framework\TestCase;
-use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
-use Symfony\Component\OptionsResolver\Options;
-use Symfony\Component\OptionsResolver\OptionsResolver;
-
-class OptionsResolverTest extends TestCase
-{
-    /**
-     * @var OptionsResolver
-     */
-    private $resolver;
-
-    protected function setUp()
-    {
-        $this->resolver = new OptionsResolver();
-    }
-
-    public function testResolveFailsIfNonExistingOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->expectExceptionMessage('The option "foo" does not exist. Defined options are: "a", "z".');
-        $this->resolver->setDefault('z', '1');
-        $this->resolver->setDefault('a', '2');
-
-        $this->resolver->resolve(['foo' => 'bar']);
-    }
-
-    public function testResolveFailsIfMultipleNonExistingOptions()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->expectExceptionMessage('The options "baz", "foo", "ping" do not exist. Defined options are: "a", "z".');
-        $this->resolver->setDefault('z', '1');
-        $this->resolver->setDefault('a', '2');
-
-        $this->resolver->resolve(['ping' => 'pong', 'foo' => 'bar', 'baz' => 'bam']);
-    }
-
-    public function testResolveFailsFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->resolve([]);
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testSetDefaultReturnsThis()
-    {
-        $this->assertSame($this->resolver, $this->resolver->setDefault('foo', 'bar'));
-    }
-
-    public function testSetDefault()
-    {
-        $this->resolver->setDefault('one', '1');
-        $this->resolver->setDefault('two', '20');
-
-        $this->assertEquals([
-            'one' => '1',
-            'two' => '20',
-        ], $this->resolver->resolve());
-    }
-
-    public function testFailIfSetDefaultFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('lazy', function (Options $options) {
-            $options->setDefault('default', 42);
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testHasDefault()
-    {
-        $this->assertFalse($this->resolver->hasDefault('foo'));
-        $this->resolver->setDefault('foo', 42);
-        $this->assertTrue($this->resolver->hasDefault('foo'));
-    }
-
-    public function testHasDefaultWithNullValue()
-    {
-        $this->assertFalse($this->resolver->hasDefault('foo'));
-        $this->resolver->setDefault('foo', null);
-        $this->assertTrue($this->resolver->hasDefault('foo'));
-    }
-
-    public function testSetLazyReturnsThis()
-    {
-        $this->assertSame($this->resolver, $this->resolver->setDefault('foo', function (Options $options) {}));
-    }
-
-    public function testSetLazyClosure()
-    {
-        $this->resolver->setDefault('foo', function (Options $options) {
-            return 'lazy';
-        });
-
-        $this->assertEquals(['foo' => 'lazy'], $this->resolver->resolve());
-    }
-
-    public function testClosureWithoutTypeHintNotInvoked()
-    {
-        $closure = function ($options) {
-            Assert::fail('Should not be called');
-        };
-
-        $this->resolver->setDefault('foo', $closure);
-
-        $this->assertSame(['foo' => $closure], $this->resolver->resolve());
-    }
-
-    public function testClosureWithoutParametersNotInvoked()
-    {
-        $closure = function () {
-            Assert::fail('Should not be called');
-        };
-
-        $this->resolver->setDefault('foo', $closure);
-
-        $this->assertSame(['foo' => $closure], $this->resolver->resolve());
-    }
-
-    public function testAccessPreviousDefaultValue()
-    {
-        // defined by superclass
-        $this->resolver->setDefault('foo', 'bar');
-
-        // defined by subclass
-        $this->resolver->setDefault('foo', function (Options $options, $previousValue) {
-            Assert::assertEquals('bar', $previousValue);
-
-            return 'lazy';
-        });
-
-        $this->assertEquals(['foo' => 'lazy'], $this->resolver->resolve());
-    }
-
-    public function testAccessPreviousLazyDefaultValue()
-    {
-        // defined by superclass
-        $this->resolver->setDefault('foo', function (Options $options) {
-            return 'bar';
-        });
-
-        // defined by subclass
-        $this->resolver->setDefault('foo', function (Options $options, $previousValue) {
-            Assert::assertEquals('bar', $previousValue);
-
-            return 'lazy';
-        });
-
-        $this->assertEquals(['foo' => 'lazy'], $this->resolver->resolve());
-    }
-
-    public function testPreviousValueIsNotEvaluatedIfNoSecondArgument()
-    {
-        // defined by superclass
-        $this->resolver->setDefault('foo', function () {
-            Assert::fail('Should not be called');
-        });
-
-        // defined by subclass, no $previousValue argument defined!
-        $this->resolver->setDefault('foo', function (Options $options) {
-            return 'lazy';
-        });
-
-        $this->assertEquals(['foo' => 'lazy'], $this->resolver->resolve());
-    }
-
-    public function testOverwrittenLazyOptionNotEvaluated()
-    {
-        $this->resolver->setDefault('foo', function (Options $options) {
-            Assert::fail('Should not be called');
-        });
-
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testInvokeEachLazyOptionOnlyOnce()
-    {
-        $calls = 0;
-
-        $this->resolver->setDefault('lazy1', function (Options $options) use (&$calls) {
-            Assert::assertSame(1, ++$calls);
-
-            $options['lazy2'];
-        });
-
-        $this->resolver->setDefault('lazy2', function (Options $options) use (&$calls) {
-            Assert::assertSame(2, ++$calls);
-        });
-
-        $this->resolver->resolve();
-
-        $this->assertSame(2, $calls);
-    }
-
-    public function testSetRequiredReturnsThis()
-    {
-        $this->assertSame($this->resolver, $this->resolver->setRequired('foo'));
-    }
-
-    public function testFailIfSetRequiredFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->setRequired('bar');
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveFailsIfRequiredOptionMissing()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\MissingOptionsException');
-        $this->resolver->setRequired('foo');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfRequiredOptionSet()
-    {
-        $this->resolver->setRequired('foo');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testResolveSucceedsIfRequiredOptionPassed()
-    {
-        $this->resolver->setRequired('foo');
-
-        $this->assertNotEmpty($this->resolver->resolve(['foo' => 'bar']));
-    }
-
-    public function testIsRequired()
-    {
-        $this->assertFalse($this->resolver->isRequired('foo'));
-        $this->resolver->setRequired('foo');
-        $this->assertTrue($this->resolver->isRequired('foo'));
-    }
-
-    public function testRequiredIfSetBefore()
-    {
-        $this->assertFalse($this->resolver->isRequired('foo'));
-
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setRequired('foo');
-
-        $this->assertTrue($this->resolver->isRequired('foo'));
-    }
-
-    public function testStillRequiredAfterSet()
-    {
-        $this->assertFalse($this->resolver->isRequired('foo'));
-
-        $this->resolver->setRequired('foo');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertTrue($this->resolver->isRequired('foo'));
-    }
-
-    public function testIsNotRequiredAfterRemove()
-    {
-        $this->assertFalse($this->resolver->isRequired('foo'));
-        $this->resolver->setRequired('foo');
-        $this->resolver->remove('foo');
-        $this->assertFalse($this->resolver->isRequired('foo'));
-    }
-
-    public function testIsNotRequiredAfterClear()
-    {
-        $this->assertFalse($this->resolver->isRequired('foo'));
-        $this->resolver->setRequired('foo');
-        $this->resolver->clear();
-        $this->assertFalse($this->resolver->isRequired('foo'));
-    }
-
-    public function testGetRequiredOptions()
-    {
-        $this->resolver->setRequired(['foo', 'bar']);
-        $this->resolver->setDefault('bam', 'baz');
-        $this->resolver->setDefault('foo', 'boo');
-
-        $this->assertSame(['foo', 'bar'], $this->resolver->getRequiredOptions());
-    }
-
-    public function testIsMissingIfNotSet()
-    {
-        $this->assertFalse($this->resolver->isMissing('foo'));
-        $this->resolver->setRequired('foo');
-        $this->assertTrue($this->resolver->isMissing('foo'));
-    }
-
-    public function testIsNotMissingIfSet()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertFalse($this->resolver->isMissing('foo'));
-        $this->resolver->setRequired('foo');
-        $this->assertFalse($this->resolver->isMissing('foo'));
-    }
-
-    public function testIsNotMissingAfterRemove()
-    {
-        $this->resolver->setRequired('foo');
-        $this->resolver->remove('foo');
-        $this->assertFalse($this->resolver->isMissing('foo'));
-    }
-
-    public function testIsNotMissingAfterClear()
-    {
-        $this->resolver->setRequired('foo');
-        $this->resolver->clear();
-        $this->assertFalse($this->resolver->isRequired('foo'));
-    }
-
-    public function testGetMissingOptions()
-    {
-        $this->resolver->setRequired(['foo', 'bar']);
-        $this->resolver->setDefault('bam', 'baz');
-        $this->resolver->setDefault('foo', 'boo');
-
-        $this->assertSame(['bar'], $this->resolver->getMissingOptions());
-    }
-
-    public function testFailIfSetDefinedFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->setDefined('bar');
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testDefinedOptionsNotIncludedInResolvedOptions()
-    {
-        $this->resolver->setDefined('foo');
-
-        $this->assertSame([], $this->resolver->resolve());
-    }
-
-    public function testDefinedOptionsIncludedIfDefaultSetBefore()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setDefined('foo');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testDefinedOptionsIncludedIfDefaultSetAfter()
-    {
-        $this->resolver->setDefined('foo');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testDefinedOptionsIncludedIfPassedToResolve()
-    {
-        $this->resolver->setDefined('foo');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve(['foo' => 'bar']));
-    }
-
-    public function testIsDefined()
-    {
-        $this->assertFalse($this->resolver->isDefined('foo'));
-        $this->resolver->setDefined('foo');
-        $this->assertTrue($this->resolver->isDefined('foo'));
-    }
-
-    public function testLazyOptionsAreDefined()
-    {
-        $this->assertFalse($this->resolver->isDefined('foo'));
-        $this->resolver->setDefault('foo', function (Options $options) {});
-        $this->assertTrue($this->resolver->isDefined('foo'));
-    }
-
-    public function testRequiredOptionsAreDefined()
-    {
-        $this->assertFalse($this->resolver->isDefined('foo'));
-        $this->resolver->setRequired('foo');
-        $this->assertTrue($this->resolver->isDefined('foo'));
-    }
-
-    public function testSetOptionsAreDefined()
-    {
-        $this->assertFalse($this->resolver->isDefined('foo'));
-        $this->resolver->setDefault('foo', 'bar');
-        $this->assertTrue($this->resolver->isDefined('foo'));
-    }
-
-    public function testGetDefinedOptions()
-    {
-        $this->resolver->setDefined(['foo', 'bar']);
-        $this->resolver->setDefault('baz', 'bam');
-        $this->resolver->setRequired('boo');
-
-        $this->assertSame(['foo', 'bar', 'baz', 'boo'], $this->resolver->getDefinedOptions());
-    }
-
-    public function testRemovedOptionsAreNotDefined()
-    {
-        $this->assertFalse($this->resolver->isDefined('foo'));
-        $this->resolver->setDefined('foo');
-        $this->assertTrue($this->resolver->isDefined('foo'));
-        $this->resolver->remove('foo');
-        $this->assertFalse($this->resolver->isDefined('foo'));
-    }
-
-    public function testClearedOptionsAreNotDefined()
-    {
-        $this->assertFalse($this->resolver->isDefined('foo'));
-        $this->resolver->setDefined('foo');
-        $this->assertTrue($this->resolver->isDefined('foo'));
-        $this->resolver->clear();
-        $this->assertFalse($this->resolver->isDefined('foo'));
-    }
-
-    public function testSetAllowedTypesFailsIfUnknownOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->resolver->setAllowedTypes('foo', 'string');
-    }
-
-    public function testResolveTypedArray()
-    {
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'string[]');
-        $options = $this->resolver->resolve(['foo' => ['bar', 'baz']]);
-
-        $this->assertSame(['foo' => ['bar', 'baz']], $options);
-    }
-
-    public function testFailIfSetAllowedTypesFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->setAllowedTypes('bar', 'string');
-        });
-
-        $this->resolver->setDefault('bar', 'baz');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveFailsIfInvalidTypedArray()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "int[]", but one of the elements is of type "DateTime[]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[]');
-
-        $this->resolver->resolve(['foo' => [new \DateTime()]]);
-    }
-
-    public function testResolveFailsWithNonArray()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value "bar" is expected to be of type "int[]", but is of type "string".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[]');
-
-        $this->resolver->resolve(['foo' => 'bar']);
-    }
-
-    public function testResolveFailsIfTypedArrayContainsInvalidTypes()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "int[]", but one of the elements is of type "stdClass[]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[]');
-        $values = range(1, 5);
-        $values[] = new \stdClass();
-        $values[] = [];
-        $values[] = new \DateTime();
-        $values[] = 123;
-
-        $this->resolver->resolve(['foo' => $values]);
-    }
-
-    public function testResolveFailsWithCorrectLevelsButWrongScalar()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "int[][]", but one of the elements is of type "double[][]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[][]');
-
-        $this->resolver->resolve([
-            'foo' => [
-                [1.2],
-            ],
-        ]);
-    }
-
-    /**
-     * @dataProvider provideInvalidTypes
-     */
-    public function testResolveFailsIfInvalidType($actualType, $allowedType, $exceptionMessage)
-    {
-        $this->resolver->setDefined('option');
-        $this->resolver->setAllowedTypes('option', $allowedType);
-
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage($exceptionMessage);
-
-        $this->resolver->resolve(['option' => $actualType]);
-    }
-
-    public function provideInvalidTypes()
-    {
-        return [
-            [true, 'string', 'The option "option" with value true is expected to be of type "string", but is of type "boolean".'],
-            [false, 'string', 'The option "option" with value false is expected to be of type "string", but is of type "boolean".'],
-            [fopen(__FILE__, 'r'), 'string', 'The option "option" with value resource is expected to be of type "string", but is of type "resource".'],
-            [[], 'string', 'The option "option" with value array is expected to be of type "string", but is of type "array".'],
-            [new OptionsResolver(), 'string', 'The option "option" with value Symfony\Component\OptionsResolver\OptionsResolver is expected to be of type "string", but is of type "Symfony\Component\OptionsResolver\OptionsResolver".'],
-            [42, 'string', 'The option "option" with value 42 is expected to be of type "string", but is of type "integer".'],
-            [null, 'string', 'The option "option" with value null is expected to be of type "string", but is of type "NULL".'],
-            ['bar', '\stdClass', 'The option "option" with value "bar" is expected to be of type "\stdClass", but is of type "string".'],
-        ];
-    }
-
-    public function testResolveSucceedsIfValidType()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedTypes('foo', 'string');
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testResolveFailsIfInvalidTypeMultiple()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value 42 is expected to be of type "string" or "bool", but is of type "integer".');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->setAllowedTypes('foo', ['string', 'bool']);
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfValidTypeMultiple()
-    {
-        $this->resolver->setDefault('foo', true);
-        $this->resolver->setAllowedTypes('foo', ['string', 'bool']);
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testResolveSucceedsIfInstanceOfClass()
-    {
-        $this->resolver->setDefault('foo', new \stdClass());
-        $this->resolver->setAllowedTypes('foo', '\stdClass');
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testResolveSucceedsIfTypedArray()
-    {
-        $this->resolver->setDefault('foo', null);
-        $this->resolver->setAllowedTypes('foo', ['null', 'DateTime[]']);
-
-        $data = [
-            'foo' => [
-                new \DateTime(),
-                new \DateTime(),
-            ],
-        ];
-        $result = $this->resolver->resolve($data);
-        $this->assertEquals($data, $result);
-    }
-
-    public function testResolveFailsIfNotInstanceOfClass()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedTypes('foo', '\stdClass');
-
-        $this->resolver->resolve();
-    }
-
-    public function testAddAllowedTypesFailsIfUnknownOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->resolver->addAllowedTypes('foo', 'string');
-    }
-
-    public function testFailIfAddAllowedTypesFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->addAllowedTypes('bar', 'string');
-        });
-
-        $this->resolver->setDefault('bar', 'baz');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveFailsIfInvalidAddedType()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->addAllowedTypes('foo', 'string');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfValidAddedType()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->addAllowedTypes('foo', 'string');
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testResolveFailsIfInvalidAddedTypeMultiple()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->addAllowedTypes('foo', ['string', 'bool']);
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfValidAddedTypeMultiple()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->addAllowedTypes('foo', ['string', 'bool']);
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testAddAllowedTypesDoesNotOverwrite()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedTypes('foo', 'string');
-        $this->resolver->addAllowedTypes('foo', 'bool');
-
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testAddAllowedTypesDoesNotOverwrite2()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedTypes('foo', 'string');
-        $this->resolver->addAllowedTypes('foo', 'bool');
-
-        $this->resolver->setDefault('foo', false);
-
-        $this->assertNotEmpty($this->resolver->resolve());
-    }
-
-    public function testSetAllowedValuesFailsIfUnknownOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->resolver->setAllowedValues('foo', 'bar');
-    }
-
-    public function testFailIfSetAllowedValuesFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->setAllowedValues('bar', 'baz');
-        });
-
-        $this->resolver->setDefault('bar', 'baz');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveFailsIfInvalidValue()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value 42 is invalid. Accepted values are: "bar".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedValues('foo', 'bar');
-
-        $this->resolver->resolve(['foo' => 42]);
-    }
-
-    public function testResolveFailsIfInvalidValueIsNull()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value null is invalid. Accepted values are: "bar".');
-        $this->resolver->setDefault('foo', null);
-        $this->resolver->setAllowedValues('foo', 'bar');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveFailsIfInvalidValueStrict()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->setAllowedValues('foo', '42');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfValidValue()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', 'bar');
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testResolveSucceedsIfValidValueIsNull()
-    {
-        $this->resolver->setDefault('foo', null);
-        $this->resolver->setAllowedValues('foo', null);
-
-        $this->assertEquals(['foo' => null], $this->resolver->resolve());
-    }
-
-    public function testResolveFailsIfInvalidValueMultiple()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value 42 is invalid. Accepted values are: "bar", false, null.');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->setAllowedValues('foo', ['bar', false, null]);
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfValidValueMultiple()
-    {
-        $this->resolver->setDefault('foo', 'baz');
-        $this->resolver->setAllowedValues('foo', ['bar', 'baz']);
-
-        $this->assertEquals(['foo' => 'baz'], $this->resolver->resolve());
-    }
-
-    public function testResolveFailsIfClosureReturnsFalse()
-    {
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->setAllowedValues('foo', function ($value) use (&$passedValue) {
-            $passedValue = $value;
-
-            return false;
-        });
-
-        try {
-            $this->resolver->resolve();
-            $this->fail('Should fail');
-        } catch (InvalidOptionsException $e) {
-        }
-
-        $this->assertSame(42, $passedValue);
-    }
-
-    public function testResolveSucceedsIfClosureReturnsTrue()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', function ($value) use (&$passedValue) {
-            $passedValue = $value;
-
-            return true;
-        });
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-        $this->assertSame('bar', $passedValue);
-    }
-
-    public function testResolveFailsIfAllClosuresReturnFalse()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->setAllowedValues('foo', [
-            function () { return false; },
-            function () { return false; },
-            function () { return false; },
-        ]);
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfAnyClosureReturnsTrue()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', [
-            function () { return false; },
-            function () { return true; },
-            function () { return false; },
-        ]);
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testAddAllowedValuesFailsIfUnknownOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->resolver->addAllowedValues('foo', 'bar');
-    }
-
-    public function testFailIfAddAllowedValuesFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->addAllowedValues('bar', 'baz');
-        });
-
-        $this->resolver->setDefault('bar', 'baz');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveFailsIfInvalidAddedValue()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->addAllowedValues('foo', 'bar');
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfValidAddedValue()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->addAllowedValues('foo', 'bar');
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testResolveSucceedsIfValidAddedValueIsNull()
-    {
-        $this->resolver->setDefault('foo', null);
-        $this->resolver->addAllowedValues('foo', null);
-
-        $this->assertEquals(['foo' => null], $this->resolver->resolve());
-    }
-
-    public function testResolveFailsIfInvalidAddedValueMultiple()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->addAllowedValues('foo', ['bar', 'baz']);
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfValidAddedValueMultiple()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->addAllowedValues('foo', ['bar', 'baz']);
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testAddAllowedValuesDoesNotOverwrite()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', 'bar');
-        $this->resolver->addAllowedValues('foo', 'baz');
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testAddAllowedValuesDoesNotOverwrite2()
-    {
-        $this->resolver->setDefault('foo', 'baz');
-        $this->resolver->setAllowedValues('foo', 'bar');
-        $this->resolver->addAllowedValues('foo', 'baz');
-
-        $this->assertEquals(['foo' => 'baz'], $this->resolver->resolve());
-    }
-
-    public function testResolveFailsIfAllAddedClosuresReturnFalse()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 42);
-        $this->resolver->setAllowedValues('foo', function () { return false; });
-        $this->resolver->addAllowedValues('foo', function () { return false; });
-
-        $this->resolver->resolve();
-    }
-
-    public function testResolveSucceedsIfAnyAddedClosureReturnsTrue()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', function () { return false; });
-        $this->resolver->addAllowedValues('foo', function () { return true; });
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testResolveSucceedsIfAnyAddedClosureReturnsTrue2()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', function () { return true; });
-        $this->resolver->addAllowedValues('foo', function () { return false; });
-
-        $this->assertEquals(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testSetNormalizerReturnsThis()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->assertSame($this->resolver, $this->resolver->setNormalizer('foo', function () {}));
-    }
-
-    public function testSetNormalizerClosure()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setNormalizer('foo', function () {
-            return 'normalized';
-        });
-
-        $this->assertEquals(['foo' => 'normalized'], $this->resolver->resolve());
-    }
-
-    public function testSetNormalizerFailsIfUnknownOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException');
-        $this->resolver->setNormalizer('foo', function () {});
-    }
-
-    public function testFailIfSetNormalizerFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->setNormalizer('foo', function () {});
-        });
-
-        $this->resolver->setDefault('bar', 'baz');
-
-        $this->resolver->resolve();
-    }
-
-    public function testNormalizerReceivesSetOption()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->resolver->setNormalizer('foo', function (Options $options, $value) {
-            return 'normalized['.$value.']';
-        });
-
-        $this->assertEquals(['foo' => 'normalized[bar]'], $this->resolver->resolve());
-    }
-
-    public function testNormalizerReceivesPassedOption()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->resolver->setNormalizer('foo', function (Options $options, $value) {
-            return 'normalized['.$value.']';
-        });
-
-        $resolved = $this->resolver->resolve(['foo' => 'baz']);
-
-        $this->assertEquals(['foo' => 'normalized[baz]'], $resolved);
-    }
-
-    public function testValidateTypeBeforeNormalization()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->resolver->setAllowedTypes('foo', 'int');
-
-        $this->resolver->setNormalizer('foo', function () {
-            Assert::fail('Should not be called.');
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testValidateValueBeforeNormalization()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->resolver->setAllowedValues('foo', 'baz');
-
-        $this->resolver->setNormalizer('foo', function () {
-            Assert::fail('Should not be called.');
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testNormalizerCanAccessOtherOptions()
-    {
-        $this->resolver->setDefault('default', 'bar');
-        $this->resolver->setDefault('norm', 'baz');
-
-        $this->resolver->setNormalizer('norm', function (Options $options) {
-            /* @var TestCase $test */
-            Assert::assertSame('bar', $options['default']);
-
-            return 'normalized';
-        });
-
-        $this->assertEquals([
-            'default' => 'bar',
-            'norm' => 'normalized',
-        ], $this->resolver->resolve());
-    }
-
-    public function testNormalizerCanAccessLazyOptions()
-    {
-        $this->resolver->setDefault('lazy', function (Options $options) {
-            return 'bar';
-        });
-        $this->resolver->setDefault('norm', 'baz');
-
-        $this->resolver->setNormalizer('norm', function (Options $options) {
-            /* @var TestCase $test */
-            Assert::assertEquals('bar', $options['lazy']);
-
-            return 'normalized';
-        });
-
-        $this->assertEquals([
-            'lazy' => 'bar',
-            'norm' => 'normalized',
-        ], $this->resolver->resolve());
-    }
-
-    public function testFailIfCyclicDependencyBetweenNormalizers()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\OptionDefinitionException');
-        $this->resolver->setDefault('norm1', 'bar');
-        $this->resolver->setDefault('norm2', 'baz');
-
-        $this->resolver->setNormalizer('norm1', function (Options $options) {
-            $options['norm2'];
-        });
-
-        $this->resolver->setNormalizer('norm2', function (Options $options) {
-            $options['norm1'];
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testFailIfCyclicDependencyBetweenNormalizerAndLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\OptionDefinitionException');
-        $this->resolver->setDefault('lazy', function (Options $options) {
-            $options['norm'];
-        });
-
-        $this->resolver->setDefault('norm', 'baz');
-
-        $this->resolver->setNormalizer('norm', function (Options $options) {
-            $options['lazy'];
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testCaughtExceptionFromNormalizerDoesNotCrashOptionResolver()
-    {
-        $throw = true;
-
-        $this->resolver->setDefaults(['catcher' => null, 'thrower' => null]);
-
-        $this->resolver->setNormalizer('catcher', function (Options $options) {
-            try {
-                return $options['thrower'];
-            } catch (\Exception $e) {
-                return false;
-            }
-        });
-
-        $this->resolver->setNormalizer('thrower', function () use (&$throw) {
-            if ($throw) {
-                $throw = false;
-                throw new \UnexpectedValueException('throwing');
-            }
-
-            return true;
-        });
-
-        $this->assertSame(['catcher' => false, 'thrower' => true], $this->resolver->resolve());
-    }
-
-    public function testCaughtExceptionFromLazyDoesNotCrashOptionResolver()
-    {
-        $throw = true;
-
-        $this->resolver->setDefault('catcher', function (Options $options) {
-            try {
-                return $options['thrower'];
-            } catch (\Exception $e) {
-                return false;
-            }
-        });
-
-        $this->resolver->setDefault('thrower', function (Options $options) use (&$throw) {
-            if ($throw) {
-                $throw = false;
-                throw new \UnexpectedValueException('throwing');
-            }
-
-            return true;
-        });
-
-        $this->assertSame(['catcher' => false, 'thrower' => true], $this->resolver->resolve());
-    }
-
-    public function testInvokeEachNormalizerOnlyOnce()
-    {
-        $calls = 0;
-
-        $this->resolver->setDefault('norm1', 'bar');
-        $this->resolver->setDefault('norm2', 'baz');
-
-        $this->resolver->setNormalizer('norm1', function ($options) use (&$calls) {
-            Assert::assertSame(1, ++$calls);
-
-            $options['norm2'];
-        });
-        $this->resolver->setNormalizer('norm2', function () use (&$calls) {
-            Assert::assertSame(2, ++$calls);
-        });
-
-        $this->resolver->resolve();
-
-        $this->assertSame(2, $calls);
-    }
-
-    public function testNormalizerNotCalledForUnsetOptions()
-    {
-        $this->resolver->setDefined('norm');
-
-        $this->resolver->setNormalizer('norm', function () {
-            Assert::fail('Should not be called.');
-        });
-
-        $this->assertEmpty($this->resolver->resolve());
-    }
-
-    public function testSetDefaultsReturnsThis()
-    {
-        $this->assertSame($this->resolver, $this->resolver->setDefaults(['foo', 'bar']));
-    }
-
-    public function testSetDefaults()
-    {
-        $this->resolver->setDefault('one', '1');
-        $this->resolver->setDefault('two', 'bar');
-
-        $this->resolver->setDefaults([
-            'two' => '2',
-            'three' => '3',
-        ]);
-
-        $this->assertEquals([
-            'one' => '1',
-            'two' => '2',
-            'three' => '3',
-        ], $this->resolver->resolve());
-    }
-
-    public function testFailIfSetDefaultsFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->setDefaults(['two' => '2']);
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testRemoveReturnsThis()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame($this->resolver, $this->resolver->remove('foo'));
-    }
-
-    public function testRemoveSingleOption()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setDefault('baz', 'boo');
-        $this->resolver->remove('foo');
-
-        $this->assertSame(['baz' => 'boo'], $this->resolver->resolve());
-    }
-
-    public function testRemoveMultipleOptions()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setDefault('baz', 'boo');
-        $this->resolver->setDefault('doo', 'dam');
-
-        $this->resolver->remove(['foo', 'doo']);
-
-        $this->assertSame(['baz' => 'boo'], $this->resolver->resolve());
-    }
-
-    public function testRemoveLazyOption()
-    {
-        $this->resolver->setDefault('foo', function (Options $options) {
-            return 'lazy';
-        });
-        $this->resolver->remove('foo');
-
-        $this->assertSame([], $this->resolver->resolve());
-    }
-
-    public function testRemoveNormalizer()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setNormalizer('foo', function (Options $options, $value) {
-            return 'normalized';
-        });
-        $this->resolver->remove('foo');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testRemoveAllowedTypes()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedTypes('foo', 'int');
-        $this->resolver->remove('foo');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testRemoveAllowedValues()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', ['baz', 'boo']);
-        $this->resolver->remove('foo');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testFailIfRemoveFromLazyOption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->remove('bar');
-        });
-
-        $this->resolver->setDefault('bar', 'baz');
-
-        $this->resolver->resolve();
-    }
-
-    public function testRemoveUnknownOptionIgnored()
-    {
-        $this->assertNotNull($this->resolver->remove('foo'));
-    }
-
-    public function testClearReturnsThis()
-    {
-        $this->assertSame($this->resolver, $this->resolver->clear());
-    }
-
-    public function testClearRemovesAllOptions()
-    {
-        $this->resolver->setDefault('one', 1);
-        $this->resolver->setDefault('two', 2);
-
-        $this->resolver->clear();
-
-        $this->assertEmpty($this->resolver->resolve());
-    }
-
-    public function testClearLazyOption()
-    {
-        $this->resolver->setDefault('foo', function (Options $options) {
-            return 'lazy';
-        });
-        $this->resolver->clear();
-
-        $this->assertSame([], $this->resolver->resolve());
-    }
-
-    public function testClearNormalizer()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setNormalizer('foo', function (Options $options, $value) {
-            return 'normalized';
-        });
-        $this->resolver->clear();
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testClearAllowedTypes()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedTypes('foo', 'int');
-        $this->resolver->clear();
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testClearAllowedValues()
-    {
-        $this->resolver->setDefault('foo', 'bar');
-        $this->resolver->setAllowedValues('foo', 'baz');
-        $this->resolver->clear();
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->assertSame(['foo' => 'bar'], $this->resolver->resolve());
-    }
-
-    public function testFailIfClearFromLazyption()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', function (Options $options) {
-            $options->clear();
-        });
-
-        $this->resolver->setDefault('bar', 'baz');
-
-        $this->resolver->resolve();
-    }
-
-    public function testClearOptionAndNormalizer()
-    {
-        $this->resolver->setDefault('foo1', 'bar');
-        $this->resolver->setNormalizer('foo1', function (Options $options) {
-            return '';
-        });
-        $this->resolver->setDefault('foo2', 'bar');
-        $this->resolver->setNormalizer('foo2', function (Options $options) {
-            return '';
-        });
-
-        $this->resolver->clear();
-        $this->assertEmpty($this->resolver->resolve());
-    }
-
-    public function testArrayAccess()
-    {
-        $this->resolver->setDefault('default1', 0);
-        $this->resolver->setDefault('default2', 1);
-        $this->resolver->setRequired('required');
-        $this->resolver->setDefined('defined');
-        $this->resolver->setDefault('lazy1', function (Options $options) {
-            return 'lazy';
-        });
-
-        $this->resolver->setDefault('lazy2', function (Options $options) {
-            Assert::assertArrayHasKey('default1', $options);
-            Assert::assertArrayHasKey('default2', $options);
-            Assert::assertArrayHasKey('required', $options);
-            Assert::assertArrayHasKey('lazy1', $options);
-            Assert::assertArrayHasKey('lazy2', $options);
-            Assert::assertArrayNotHasKey('defined', $options);
-
-            Assert::assertSame(0, $options['default1']);
-            Assert::assertSame(42, $options['default2']);
-            Assert::assertSame('value', $options['required']);
-            Assert::assertSame('lazy', $options['lazy1']);
-
-            // Obviously $options['lazy'] and $options['defined'] cannot be
-            // accessed
-        });
-
-        $this->resolver->resolve(['default2' => 42, 'required' => 'value']);
-    }
-
-    public function testArrayAccessGetFailsOutsideResolve()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('default', 0);
-
-        $this->resolver['default'];
-    }
-
-    public function testArrayAccessExistsFailsOutsideResolve()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('default', 0);
-
-        isset($this->resolver['default']);
-    }
-
-    public function testArrayAccessSetNotSupported()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver['default'] = 0;
-    }
-
-    public function testArrayAccessUnsetNotSupported()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('default', 0);
-
-        unset($this->resolver['default']);
-    }
-
-    public function testFailIfGetNonExisting()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\NoSuchOptionException');
-        $this->expectExceptionMessage('The option "undefined" does not exist. Defined options are: "foo", "lazy".');
-        $this->resolver->setDefault('foo', 'bar');
-
-        $this->resolver->setDefault('lazy', function (Options $options) {
-            $options['undefined'];
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testFailIfGetDefinedButUnset()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\NoSuchOptionException');
-        $this->expectExceptionMessage('The optional option "defined" has no value set. You should make sure it is set with "isset" before reading it.');
-        $this->resolver->setDefined('defined');
-
-        $this->resolver->setDefault('lazy', function (Options $options) {
-            $options['defined'];
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testFailIfCyclicDependency()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\OptionDefinitionException');
-        $this->resolver->setDefault('lazy1', function (Options $options) {
-            $options['lazy2'];
-        });
-
-        $this->resolver->setDefault('lazy2', function (Options $options) {
-            $options['lazy1'];
-        });
-
-        $this->resolver->resolve();
-    }
-
-    public function testCount()
-    {
-        $this->resolver->setDefault('default', 0);
-        $this->resolver->setRequired('required');
-        $this->resolver->setDefined('defined');
-        $this->resolver->setDefault('lazy1', function () {});
-
-        $this->resolver->setDefault('lazy2', function (Options $options) {
-            Assert::assertCount(4, $options);
-        });
-
-        $this->assertCount(4, $this->resolver->resolve(['required' => 'value']));
-    }
-
-    /**
-     * In resolve() we count the options that are actually set (which may be
-     * only a subset of the defined options). Outside of resolve(), it's not
-     * clear what is counted.
-     */
-    public function testCountFailsOutsideResolve()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\AccessException');
-        $this->resolver->setDefault('foo', 0);
-        $this->resolver->setRequired('bar');
-        $this->resolver->setDefined('bar');
-        $this->resolver->setDefault('lazy1', function () {});
-
-        \count($this->resolver);
-    }
-
-    public function testNestedArrays()
-    {
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[][]');
-
-        $this->assertEquals([
-            'foo' => [
-                [
-                    1, 2,
-                ],
-            ],
-        ], $this->resolver->resolve([
-            'foo' => [
-                [1, 2],
-            ],
-        ]));
-    }
-
-    public function testNested2Arrays()
-    {
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[][][][]');
-
-        $this->assertEquals([
-            'foo' => [
-                [
-                    [
-                        [
-                            1, 2,
-                        ],
-                    ],
-                ],
-            ],
-        ], $this->resolver->resolve(
-            [
-                'foo' => [
-                    [
-                        [
-                            [1, 2],
-                        ],
-                    ],
-                ],
-            ]
-        ));
-    }
-
-    public function testNestedArraysException()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "float[][][][]", but one of the elements is of type "integer[][][][]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'float[][][][]');
-
-        $this->resolver->resolve([
-            'foo' => [
-                [
-                    [
-                        [1, 2],
-                    ],
-                ],
-            ],
-        ]);
-    }
-
-    public function testNestedArrayException1()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "int[][]", but one of the elements is of type "boolean[][]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[][]');
-        $this->resolver->resolve([
-            'foo' => [
-                [1, true, 'str', [2, 3]],
-            ],
-        ]);
-    }
-
-    public function testNestedArrayException2()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "int[][]", but one of the elements is of type "boolean[][]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'int[][]');
-        $this->resolver->resolve([
-            'foo' => [
-                [true, 'str', [2, 3]],
-            ],
-        ]);
-    }
-
-    public function testNestedArrayException3()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "string[][][]", but one of the elements is of type "string[][]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'string[][][]');
-        $this->resolver->resolve([
-            'foo' => [
-                ['str', [1, 2]],
-            ],
-        ]);
-    }
-
-    public function testNestedArrayException4()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "string[][][]", but one of the elements is of type "integer[][][]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'string[][][]');
-        $this->resolver->resolve([
-            'foo' => [
-                [
-                    ['str'], [1, 2], ],
-            ],
-        ]);
-    }
-
-    public function testNestedArrayException5()
-    {
-        $this->expectException('Symfony\Component\OptionsResolver\Exception\InvalidOptionsException');
-        $this->expectExceptionMessage('The option "foo" with value array is expected to be of type "string[]", but one of the elements is of type "array[]".');
-        $this->resolver->setDefined('foo');
-        $this->resolver->setAllowedTypes('foo', 'string[]');
-        $this->resolver->resolve([
-            'foo' => [
-                [
-                    ['str'], [1, 2], ],
-            ],
-        ]);
-    }
-}