upgrade

vendor/symfony/serializer/Tests/Normalizer/AbstractNormalizerTest.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace Symfony\Component\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
+use Symfony\Component\Serializer\Encoder\JsonEncoder;
+use Symfony\Component\Serializer\Mapping\AttributeMetadata;
+use Symfony\Component\Serializer\Mapping\ClassMetadata;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
+use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
+use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
+use Symfony\Component\Serializer\Normalizer\PropertyNormalizer;
+use Symfony\Component\Serializer\Serializer;
+use Symfony\Component\Serializer\Tests\Fixtures\AbstractNormalizerDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Dummy;
+use Symfony\Component\Serializer\Tests\Fixtures\NullableConstructorArgumentDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\ProxyDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\StaticConstructorDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\StaticConstructorNormalizer;
+use Symfony\Component\Serializer\Tests\Fixtures\VariadicConstructorTypedArgsDummy;
+
+/**
+ * Provides a dummy Normalizer which extends the AbstractNormalizer.
+ *
+ * @author Konstantin S. M. Möllers <ksm.moellers@gmail.com>
+ */
+class AbstractNormalizerTest extends TestCase
+{
+    /**
+     * @var AbstractNormalizerDummy
+     */
+    private $normalizer;
+
+    /**
+     * @var ClassMetadataFactoryInterface|MockObject
+     */
+    private $classMetadata;
+
+    protected function setUp()
+    {
+        $loader = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\Loader\LoaderChain')->setConstructorArgs([[]])->getMock();
+        $this->classMetadata = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory')->setConstructorArgs([$loader])->getMock();
+        $this->normalizer = new AbstractNormalizerDummy($this->classMetadata);
+    }
+
+    public function testGetAllowedAttributesAsString()
+    {
+        $classMetadata = new ClassMetadata('c');
+
+        $a1 = new AttributeMetadata('a1');
+        $classMetadata->addAttributeMetadata($a1);
+
+        $a2 = new AttributeMetadata('a2');
+        $a2->addGroup('test');
+        $classMetadata->addAttributeMetadata($a2);
+
+        $a3 = new AttributeMetadata('a3');
+        $a3->addGroup('other');
+        $classMetadata->addAttributeMetadata($a3);
+
+        $a4 = new AttributeMetadata('a4');
+        $a4->addGroup('test');
+        $a4->addGroup('other');
+        $classMetadata->addAttributeMetadata($a4);
+
+        $this->classMetadata->method('getMetadataFor')->willReturn($classMetadata);
+
+        $result = $this->normalizer->getAllowedAttributes('c', [AbstractNormalizer::GROUPS => ['test']], true);
+        $this->assertEquals(['a2', 'a4'], $result);
+
+        $result = $this->normalizer->getAllowedAttributes('c', [AbstractNormalizer::GROUPS => ['other']], true);
+        $this->assertEquals(['a3', 'a4'], $result);
+    }
+
+    public function testGetAllowedAttributesAsObjects()
+    {
+        $classMetadata = new ClassMetadata('c');
+
+        $a1 = new AttributeMetadata('a1');
+        $classMetadata->addAttributeMetadata($a1);
+
+        $a2 = new AttributeMetadata('a2');
+        $a2->addGroup('test');
+        $classMetadata->addAttributeMetadata($a2);
+
+        $a3 = new AttributeMetadata('a3');
+        $a3->addGroup('other');
+        $classMetadata->addAttributeMetadata($a3);
+
+        $a4 = new AttributeMetadata('a4');
+        $a4->addGroup('test');
+        $a4->addGroup('other');
+        $classMetadata->addAttributeMetadata($a4);
+
+        $this->classMetadata->method('getMetadataFor')->willReturn($classMetadata);
+
+        $result = $this->normalizer->getAllowedAttributes('c', [AbstractNormalizer::GROUPS => ['test']], false);
+        $this->assertEquals([$a2, $a4], $result);
+
+        $result = $this->normalizer->getAllowedAttributes('c', [AbstractNormalizer::GROUPS => ['other']], false);
+        $this->assertEquals([$a3, $a4], $result);
+    }
+
+    public function testObjectToPopulateWithProxy()
+    {
+        $proxyDummy = new ProxyDummy();
+
+        $context = [AbstractNormalizer::OBJECT_TO_POPULATE => $proxyDummy];
+
+        $normalizer = new ObjectNormalizer();
+        $normalizer->denormalize(['foo' => 'bar'], 'Symfony\Component\Serializer\Tests\Fixtures\ToBeProxyfiedDummy', null, $context);
+
+        $this->assertSame('bar', $proxyDummy->getFoo());
+    }
+
+    public function testObjectWithStaticConstructor()
+    {
+        $normalizer = new StaticConstructorNormalizer();
+        $dummy = $normalizer->denormalize(['foo' => 'baz'], StaticConstructorDummy::class);
+
+        $this->assertInstanceOf(StaticConstructorDummy::class, $dummy);
+        $this->assertEquals('baz', $dummy->quz);
+        $this->assertNull($dummy->foo);
+    }
+
+    /**
+     * @requires PHP 7.1
+     */
+    public function testObjectWithNullableConstructorArgument()
+    {
+        $normalizer = new ObjectNormalizer();
+        $dummy = $normalizer->denormalize(['foo' => null], NullableConstructorArgumentDummy::class);
+
+        $this->assertNull($dummy->getFoo());
+    }
+
+    /**
+     * @dataProvider getNormalizer
+     *
+     * @requires PHP 5.6
+     */
+    public function testObjectWithVariadicConstructorTypedArguments(AbstractNormalizer $normalizer)
+    {
+        $d1 = new Dummy();
+        $d1->foo = 'Foo';
+        $d1->bar = 'Bar';
+        $d1->baz = 'Baz';
+        $d1->qux = 'Quz';
+        $d2 = new Dummy();
+        $d2->foo = 'FOO';
+        $d2->bar = 'BAR';
+        $d2->baz = 'BAZ';
+        $d2->qux = 'QUZ';
+        $obj = new VariadicConstructorTypedArgsDummy($d1, $d2);
+
+        $serializer = new Serializer([$normalizer], [new JsonEncoder()]);
+        $normalizer->setSerializer($serializer);
+        $data = $serializer->serialize($obj, 'json');
+        $dummy = $normalizer->denormalize(json_decode($data, true), VariadicConstructorTypedArgsDummy::class);
+        $this->assertInstanceOf(VariadicConstructorTypedArgsDummy::class, $dummy);
+        $this->assertCount(2, $dummy->getFoo());
+        foreach ($dummy->getFoo() as $foo) {
+            $this->assertInstanceOf(Dummy::class, $foo);
+        }
+
+        $dummy = $serializer->deserialize($data, VariadicConstructorTypedArgsDummy::class, 'json');
+        $this->assertInstanceOf(VariadicConstructorTypedArgsDummy::class, $dummy);
+        $this->assertCount(2, $dummy->getFoo());
+        foreach ($dummy->getFoo() as $foo) {
+            $this->assertInstanceOf(Dummy::class, $foo);
+        }
+    }
+
+    public function getNormalizer()
+    {
+        $extractor = new PhpDocExtractor();
+
+        yield [new PropertyNormalizer()];
+        yield [new PropertyNormalizer(null, null, $extractor)];
+        yield [new ObjectNormalizer()];
+        yield [new ObjectNormalizer(null, null, null, $extractor)];
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/AbstractObjectNormalizerTest.php

@@ -0,0 +1,401 @@
+<?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\Serializer\Tests\Normalizer;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
+use Symfony\Component\PropertyInfo\Type;
+use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
+use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
+use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
+use Symfony\Component\Serializer\SerializerAwareInterface;
+use Symfony\Component\Serializer\SerializerInterface;
+
+class AbstractObjectNormalizerTest extends TestCase
+{
+    public function testDenormalize()
+    {
+        $normalizer = new AbstractObjectNormalizerDummy();
+        $normalizedData = $normalizer->denormalize(['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'], Dummy::class);
+
+        $this->assertSame('foo', $normalizedData->foo);
+        $this->assertNull($normalizedData->bar);
+        $this->assertSame('baz', $normalizedData->baz);
+    }
+
+    public function testInstantiateObjectDenormalizer()
+    {
+        $data = ['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'];
+        $class = Dummy::class;
+        $context = [];
+
+        $normalizer = new AbstractObjectNormalizerDummy();
+
+        $this->assertInstanceOf(Dummy::class, $normalizer->instantiateObject($data, $class, $context, new \ReflectionClass($class), []));
+    }
+
+    public function testDenormalizeWithExtraAttributes()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\ExtraAttributesException');
+        $this->expectExceptionMessage('Extra attributes are not allowed ("fooFoo", "fooBar" are unknown).');
+        $factory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $normalizer = new AbstractObjectNormalizerDummy($factory);
+        $normalizer->denormalize(
+            ['fooFoo' => 'foo', 'fooBar' => 'bar'],
+            Dummy::class,
+            'any',
+            ['allow_extra_attributes' => false]
+        );
+    }
+
+    public function testDenormalizeWithExtraAttributesAndNoGroupsWithMetadataFactory()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\ExtraAttributesException');
+        $this->expectExceptionMessage('Extra attributes are not allowed ("fooFoo", "fooBar" are unknown).');
+        $normalizer = new AbstractObjectNormalizerWithMetadata();
+        $normalizer->denormalize(
+            ['fooFoo' => 'foo', 'fooBar' => 'bar', 'bar' => 'bar'],
+            Dummy::class,
+            'any',
+            ['allow_extra_attributes' => false]
+        );
+    }
+
+    public function testDenormalizeCollectionDecodedFromXmlWithOneChild()
+    {
+        $denormalizer = $this->getDenormalizerForDummyCollection();
+
+        $dummyCollection = $denormalizer->denormalize(
+            [
+                'children' => [
+                    'bar' => 'first',
+                ],
+            ],
+            DummyCollection::class,
+            'xml'
+        );
+
+        $this->assertInstanceOf(DummyCollection::class, $dummyCollection);
+        $this->assertIsArray($dummyCollection->children);
+        $this->assertCount(1, $dummyCollection->children);
+        $this->assertInstanceOf(DummyChild::class, $dummyCollection->children[0]);
+    }
+
+    public function testDenormalizeCollectionDecodedFromXmlWithTwoChildren()
+    {
+        $denormalizer = $this->getDenormalizerForDummyCollection();
+
+        $dummyCollection = $denormalizer->denormalize(
+            [
+                'children' => [
+                    ['bar' => 'first'],
+                    ['bar' => 'second'],
+                ],
+            ],
+            DummyCollection::class,
+            'xml'
+        );
+
+        $this->assertInstanceOf(DummyCollection::class, $dummyCollection);
+        $this->assertIsArray($dummyCollection->children);
+        $this->assertCount(2, $dummyCollection->children);
+        $this->assertInstanceOf(DummyChild::class, $dummyCollection->children[0]);
+        $this->assertInstanceOf(DummyChild::class, $dummyCollection->children[1]);
+    }
+
+    private function getDenormalizerForDummyCollection()
+    {
+        $extractor = $this->getMockBuilder(PhpDocExtractor::class)->getMock();
+        $extractor->method('getTypes')
+            ->will($this->onConsecutiveCalls(
+                [new Type('array', false, null, true, new Type('int'), new Type('object', false, DummyChild::class))],
+                null
+            ));
+
+        $denormalizer = new AbstractObjectNormalizerCollectionDummy(null, null, $extractor);
+        $arrayDenormalizer = new ArrayDenormalizerDummy();
+        $serializer = new SerializerCollectionDummy([$arrayDenormalizer, $denormalizer]);
+        $arrayDenormalizer->setSerializer($serializer);
+        $denormalizer->setSerializer($serializer);
+
+        return $denormalizer;
+    }
+
+    public function testDenormalizeStringCollectionDecodedFromXmlWithOneChild()
+    {
+        $denormalizer = $this->getDenormalizerForStringCollection();
+
+        // if an xml-node can have children which should be deserialized as string[]
+        // and only one child exists
+        $stringCollection = $denormalizer->denormalize(['children' => 'foo'], StringCollection::class, 'xml');
+
+        $this->assertInstanceOf(StringCollection::class, $stringCollection);
+        $this->assertIsArray($stringCollection->children);
+        $this->assertCount(1, $stringCollection->children);
+        $this->assertEquals('foo', $stringCollection->children[0]);
+    }
+
+    public function testDenormalizeStringCollectionDecodedFromXmlWithTwoChildren()
+    {
+        $denormalizer = $this->getDenormalizerForStringCollection();
+
+        // if an xml-node can have children which should be deserialized as string[]
+        // and only one child exists
+        $stringCollection = $denormalizer->denormalize(['children' => ['foo', 'bar']], StringCollection::class, 'xml');
+
+        $this->assertInstanceOf(StringCollection::class, $stringCollection);
+        $this->assertIsArray($stringCollection->children);
+        $this->assertCount(2, $stringCollection->children);
+        $this->assertEquals('foo', $stringCollection->children[0]);
+        $this->assertEquals('bar', $stringCollection->children[1]);
+    }
+
+    public function testDenormalizeNotSerializableObjectToPopulate()
+    {
+        $normalizer = new AbstractObjectNormalizerDummy();
+        $normalizedData = $normalizer->denormalize(['foo' => 'foo'], Dummy::class, null, [AbstractObjectNormalizer::OBJECT_TO_POPULATE => new NotSerializable()]);
+
+        $this->assertSame('foo', $normalizedData->foo);
+    }
+
+    private function getDenormalizerForStringCollection()
+    {
+        $extractor = $this->getMockBuilder(PhpDocExtractor::class)->getMock();
+        $extractor->method('getTypes')
+            ->will($this->onConsecutiveCalls(
+                [new Type('array', false, null, true, new Type('int'), new Type('string'))],
+                null
+            ));
+
+        $denormalizer = new AbstractObjectNormalizerCollectionDummy(null, null, $extractor);
+        $arrayDenormalizer = new ArrayDenormalizerDummy();
+        $serializer = new SerializerCollectionDummy([$arrayDenormalizer, $denormalizer]);
+        $arrayDenormalizer->setSerializer($serializer);
+        $denormalizer->setSerializer($serializer);
+
+        return $denormalizer;
+    }
+
+    /**
+     * Test that additional attributes throw an exception if no metadata factory is specified.
+     */
+    public function testExtraAttributesException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\LogicException');
+        $this->expectExceptionMessage('A class metadata factory must be provided in the constructor when setting "allow_extra_attributes" to false.');
+        $normalizer = new ObjectNormalizer();
+
+        $normalizer->denormalize([], \stdClass::class, 'xml', [
+            'allow_extra_attributes' => false,
+        ]);
+    }
+}
+
+class AbstractObjectNormalizerDummy extends AbstractObjectNormalizer
+{
+    protected function extractAttributes($object, $format = null, array $context = [])
+    {
+    }
+
+    protected function getAttributeValue($object, $attribute, $format = null, array $context = [])
+    {
+    }
+
+    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = [])
+    {
+        $object->$attribute = $value;
+    }
+
+    protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = [])
+    {
+        return \in_array($attribute, ['foo', 'baz']);
+    }
+
+    public function instantiateObject(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, $format = null)
+    {
+        return parent::instantiateObject($data, $class, $context, $reflectionClass, $allowedAttributes, $format);
+    }
+}
+
+class Dummy
+{
+    public $foo;
+    public $bar;
+    public $baz;
+}
+
+class AbstractObjectNormalizerWithMetadata extends AbstractObjectNormalizer
+{
+    public function __construct()
+    {
+        parent::__construct(new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader())));
+    }
+
+    protected function extractAttributes($object, $format = null, array $context = [])
+    {
+    }
+
+    protected function getAttributeValue($object, $attribute, $format = null, array $context = [])
+    {
+    }
+
+    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = [])
+    {
+        $object->$attribute = $value;
+    }
+}
+
+class StringCollection
+{
+    /** @var string[] */
+    public $children;
+}
+
+class DummyCollection
+{
+    /** @var DummyChild[] */
+    public $children;
+}
+
+class DummyChild
+{
+    public $bar;
+}
+
+class SerializerCollectionDummy implements SerializerInterface, DenormalizerInterface
+{
+    private $normalizers;
+
+    /**
+     * @param DenormalizerInterface[] $normalizers
+     */
+    public function __construct($normalizers)
+    {
+        $this->normalizers = $normalizers;
+    }
+
+    public function serialize($data, $format, array $context = [])
+    {
+    }
+
+    public function deserialize($data, $type, $format, array $context = [])
+    {
+    }
+
+    public function denormalize($data, $type, $format = null, array $context = [])
+    {
+        foreach ($this->normalizers as $normalizer) {
+            if ($normalizer instanceof DenormalizerInterface && $normalizer->supportsDenormalization($data, $type, $format, $context)) {
+                return $normalizer->denormalize($data, $type, $format, $context);
+            }
+        }
+
+        return null;
+    }
+
+    public function supportsDenormalization($data, $type, $format = null)
+    {
+        return true;
+    }
+}
+
+class AbstractObjectNormalizerCollectionDummy extends AbstractObjectNormalizer
+{
+    protected function extractAttributes($object, $format = null, array $context = [])
+    {
+    }
+
+    protected function getAttributeValue($object, $attribute, $format = null, array $context = [])
+    {
+    }
+
+    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = [])
+    {
+        $object->$attribute = $value;
+    }
+
+    protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = [])
+    {
+        return true;
+    }
+
+    public function instantiateObject(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, $format = null)
+    {
+        return parent::instantiateObject($data, $class, $context, $reflectionClass, $allowedAttributes, $format);
+    }
+
+    public function serialize($data, $format, array $context = [])
+    {
+    }
+
+    public function deserialize($data, $type, $format, array $context = [])
+    {
+    }
+}
+
+class ArrayDenormalizerDummy implements DenormalizerInterface, SerializerAwareInterface
+{
+    /**
+     * @var SerializerInterface|DenormalizerInterface
+     */
+    private $serializer;
+
+    /**
+     * {@inheritdoc}
+     *
+     * @throws NotNormalizableValueException
+     */
+    public function denormalize($data, $type, $format = null, array $context = [])
+    {
+        $serializer = $this->serializer;
+        $type = substr($type, 0, -2);
+
+        foreach ($data as $key => $value) {
+            $data[$key] = $serializer->denormalize($value, $type, $format, $context);
+        }
+
+        return $data;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsDenormalization($data, $type, $format = null, array $context = [])
+    {
+        return '[]' === substr($type, -2)
+            && $this->serializer->supportsDenormalization($data, substr($type, 0, -2), $format, $context);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setSerializer(SerializerInterface $serializer)
+    {
+        $this->serializer = $serializer;
+    }
+}
+
+class NotSerializable
+{
+    public function __sleep()
+    {
+        if (class_exists(\Error::class)) {
+            throw new \Error('not serializable');
+        }
+
+        throw new \Exception('not serializable');
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/ArrayDenormalizerTest.php

@@ -0,0 +1,124 @@
+<?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\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Normalizer\ArrayDenormalizer;
+use Symfony\Component\Serializer\SerializerInterface;
+
+class ArrayDenormalizerTest extends TestCase
+{
+    /**
+     * @var ArrayDenormalizer
+     */
+    private $denormalizer;
+
+    /**
+     * @var SerializerInterface|MockObject
+     */
+    private $serializer;
+
+    protected function setUp()
+    {
+        $this->serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')->getMock();
+        $this->denormalizer = new ArrayDenormalizer();
+        $this->denormalizer->setSerializer($this->serializer);
+    }
+
+    public function testDenormalize()
+    {
+        $this->serializer->expects($this->exactly(2))
+            ->method('denormalize')
+            ->withConsecutive(
+                [['foo' => 'one', 'bar' => 'two']],
+                [['foo' => 'three', 'bar' => 'four']]
+            )
+            ->willReturnOnConsecutiveCalls(
+                new ArrayDummy('one', 'two'),
+                new ArrayDummy('three', 'four')
+            );
+
+        $result = $this->denormalizer->denormalize(
+            [
+                ['foo' => 'one', 'bar' => 'two'],
+                ['foo' => 'three', 'bar' => 'four'],
+            ],
+            __NAMESPACE__.'\ArrayDummy[]'
+        );
+
+        $this->assertEquals(
+            [
+                new ArrayDummy('one', 'two'),
+                new ArrayDummy('three', 'four'),
+            ],
+            $result
+        );
+    }
+
+    public function testSupportsValidArray()
+    {
+        $this->serializer->expects($this->once())
+            ->method('supportsDenormalization')
+            ->with($this->anything(), ArrayDummy::class, $this->anything())
+            ->willReturn(true);
+
+        $this->assertTrue(
+            $this->denormalizer->supportsDenormalization(
+                [
+                    ['foo' => 'one', 'bar' => 'two'],
+                    ['foo' => 'three', 'bar' => 'four'],
+                ],
+                __NAMESPACE__.'\ArrayDummy[]'
+            )
+        );
+    }
+
+    public function testSupportsInvalidArray()
+    {
+        $this->serializer->expects($this->any())
+            ->method('supportsDenormalization')
+            ->willReturn(false);
+
+        $this->assertFalse(
+            $this->denormalizer->supportsDenormalization(
+                [
+                    ['foo' => 'one', 'bar' => 'two'],
+                    ['foo' => 'three', 'bar' => 'four'],
+                ],
+                __NAMESPACE__.'\InvalidClass[]'
+            )
+        );
+    }
+
+    public function testSupportsNoArray()
+    {
+        $this->assertFalse(
+            $this->denormalizer->supportsDenormalization(
+                ['foo' => 'one', 'bar' => 'two'],
+                ArrayDummy::class
+            )
+        );
+    }
+}
+
+class ArrayDummy
+{
+    public $foo;
+    public $bar;
+
+    public function __construct($foo, $bar)
+    {
+        $this->foo = $foo;
+        $this->bar = $bar;
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/CustomNormalizerTest.php

@@ -0,0 +1,83 @@
+<?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\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Normalizer\CustomNormalizer;
+use Symfony\Component\Serializer\Serializer;
+use Symfony\Component\Serializer\Tests\Fixtures\ScalarDummy;
+
+class CustomNormalizerTest extends TestCase
+{
+    /**
+     * @var CustomNormalizer
+     */
+    private $normalizer;
+
+    protected function setUp()
+    {
+        $this->normalizer = new CustomNormalizer();
+        $this->normalizer->setSerializer(new Serializer());
+    }
+
+    public function testInterface()
+    {
+        $this->assertInstanceOf('Symfony\Component\Serializer\Normalizer\NormalizerInterface', $this->normalizer);
+        $this->assertInstanceOf('Symfony\Component\Serializer\Normalizer\DenormalizerInterface', $this->normalizer);
+        $this->assertInstanceOf('Symfony\Component\Serializer\SerializerAwareInterface', $this->normalizer);
+    }
+
+    public function testSerialize()
+    {
+        $obj = new ScalarDummy();
+        $obj->foo = 'foo';
+        $obj->xmlFoo = 'xml';
+        $this->assertEquals('foo', $this->normalizer->normalize($obj, 'json'));
+        $this->assertEquals('xml', $this->normalizer->normalize($obj, 'xml'));
+    }
+
+    public function testDeserialize()
+    {
+        $obj = $this->normalizer->denormalize('foo', \get_class(new ScalarDummy()), 'xml');
+        $this->assertEquals('foo', $obj->xmlFoo);
+        $this->assertNull($obj->foo);
+
+        $obj = $this->normalizer->denormalize('foo', \get_class(new ScalarDummy()), 'json');
+        $this->assertEquals('foo', $obj->foo);
+        $this->assertNull($obj->xmlFoo);
+    }
+
+    public function testDenormalizeWithObjectToPopulateUsesProvidedObject()
+    {
+        $expected = new ScalarDummy();
+        $obj = $this->normalizer->denormalize('foo', ScalarDummy::class, 'json', [
+            'object_to_populate' => $expected,
+        ]);
+
+        $this->assertSame($expected, $obj);
+        $this->assertEquals('foo', $obj->foo);
+        $this->assertNull($obj->xmlFoo);
+    }
+
+    public function testSupportsNormalization()
+    {
+        $this->assertTrue($this->normalizer->supportsNormalization(new ScalarDummy()));
+        $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+    }
+
+    public function testSupportsDenormalization()
+    {
+        $this->assertTrue($this->normalizer->supportsDenormalization([], 'Symfony\Component\Serializer\Tests\Fixtures\ScalarDummy'));
+        $this->assertFalse($this->normalizer->supportsDenormalization([], 'stdClass'));
+        $this->assertTrue($this->normalizer->supportsDenormalization([], 'Symfony\Component\Serializer\Tests\Fixtures\DenormalizableDummy'));
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/DateIntervalNormalizerTest.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace Symfony\Component\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Normalizer\DateIntervalNormalizer;
+
+/**
+ * @author Jérôme Parmentier <jerome@prmntr.me>
+ */
+class DateIntervalNormalizerTest extends TestCase
+{
+    /**
+     * @var DateIntervalNormalizer
+     */
+    private $normalizer;
+
+    protected function setUp()
+    {
+        $this->normalizer = new DateIntervalNormalizer();
+    }
+
+    public function dataProviderISO()
+    {
+        $data = [
+            ['P%YY%MM%DDT%HH%IM%SS', 'P00Y00M00DT00H00M00S', 'PT0S'],
+            ['P%yY%mM%dDT%hH%iM%sS', 'P0Y0M0DT0H0M0S', 'PT0S'],
+            ['P%yY%mM%dDT%hH%iM%sS', 'P10Y2M3DT16H5M6S', 'P10Y2M3DT16H5M6S'],
+            ['P%yY%mM%dDT%hH%iM', 'P10Y2M3DT16H5M', 'P10Y2M3DT16H5M'],
+            ['P%yY%mM%dDT%hH', 'P10Y2M3DT16H', 'P10Y2M3DT16H'],
+            ['P%yY%mM%dD', 'P10Y2M3D', 'P10Y2M3DT0H'],
+            ['%RP%yY%mM%dD', '-P10Y2M3D', '-P10Y2M3DT0H'],
+            ['%RP%yY%mM%dD', '+P10Y2M3D', '+P10Y2M3DT0H'],
+            ['%RP%yY%mM%dD', '+P10Y2M3D', 'P10Y2M3DT0H'],
+            ['%rP%yY%mM%dD', '-P10Y2M3D', '-P10Y2M3DT0H'],
+            ['%rP%yY%mM%dD', 'P10Y2M3D', 'P10Y2M3DT0H'],
+        ];
+
+        return $data;
+    }
+
+    public function testSupportsNormalization()
+    {
+        $this->assertTrue($this->normalizer->supportsNormalization(new \DateInterval('P00Y00M00DT00H00M00S')));
+        $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+    }
+
+    public function testNormalize()
+    {
+        $this->assertEquals('P0Y0M0DT0H0M0S', $this->normalizer->normalize(new \DateInterval('PT0S')));
+    }
+
+    /**
+     * @dataProvider dataProviderISO
+     */
+    public function testNormalizeUsingFormatPassedInContext($format, $output, $input)
+    {
+        $this->assertEquals($output, $this->normalizer->normalize($this->getInterval($input), null, [DateIntervalNormalizer::FORMAT_KEY => $format]));
+    }
+
+    /**
+     * @dataProvider dataProviderISO
+     */
+    public function testNormalizeUsingFormatPassedInConstructor($format, $output, $input)
+    {
+        $this->assertEquals($output, (new DateIntervalNormalizer($format))->normalize($this->getInterval($input)));
+    }
+
+    public function testNormalizeInvalidObjectThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\InvalidArgumentException');
+        $this->expectExceptionMessage('The object must be an instance of "\DateInterval".');
+        $this->normalizer->normalize(new \stdClass());
+    }
+
+    public function testSupportsDenormalization()
+    {
+        $this->assertTrue($this->normalizer->supportsDenormalization('P00Y00M00DT00H00M00S', \DateInterval::class));
+        $this->assertFalse($this->normalizer->supportsDenormalization('foo', 'Bar'));
+    }
+
+    public function testDenormalize()
+    {
+        $this->assertDateIntervalEquals(new \DateInterval('P00Y00M00DT00H00M00S'), $this->normalizer->denormalize('P00Y00M00DT00H00M00S', \DateInterval::class));
+    }
+
+    /**
+     * @dataProvider dataProviderISO
+     */
+    public function testDenormalizeUsingFormatPassedInContext($format, $input, $output)
+    {
+        $this->assertDateIntervalEquals($this->getInterval($output), $this->normalizer->denormalize($input, \DateInterval::class, null, [DateIntervalNormalizer::FORMAT_KEY => $format]));
+    }
+
+    /**
+     * @dataProvider dataProviderISO
+     */
+    public function testDenormalizeUsingFormatPassedInConstructor($format, $input, $output)
+    {
+        $this->assertDateIntervalEquals($this->getInterval($output), (new DateIntervalNormalizer($format))->denormalize($input, \DateInterval::class));
+    }
+
+    public function testDenormalizeExpectsString()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\InvalidArgumentException');
+        $this->normalizer->denormalize(1234, \DateInterval::class);
+    }
+
+    public function testDenormalizeNonISO8601IntervalStringThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+        $this->expectExceptionMessage('Expected a valid ISO 8601 interval string.');
+        $this->normalizer->denormalize('10 years 2 months 3 days', \DateInterval::class, null);
+    }
+
+    public function testDenormalizeInvalidDataThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+        $this->normalizer->denormalize('invalid interval', \DateInterval::class);
+    }
+
+    public function testDenormalizeFormatMismatchThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+        $this->normalizer->denormalize('P00Y00M00DT00H00M00S', \DateInterval::class, null, [DateIntervalNormalizer::FORMAT_KEY => 'P%yY%mM%dD']);
+    }
+
+    private function assertDateIntervalEquals(\DateInterval $expected, \DateInterval $actual)
+    {
+        $this->assertEquals($expected->format('%RP%yY%mM%dDT%hH%iM%sS'), $actual->format('%RP%yY%mM%dDT%hH%iM%sS'));
+    }
+
+    private function getInterval($data)
+    {
+        if ('-' === $data[0]) {
+            $interval = new \DateInterval(substr($data, 1));
+            $interval->invert = 1;
+
+            return $interval;
+        }
+
+        if ('+' === $data[0]) {
+            return new \DateInterval(substr($data, 1));
+        }
+
+        return new \DateInterval($data);
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/DateTimeNormalizerTest.php

@@ -0,0 +1,261 @@
+<?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\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class DateTimeNormalizerTest extends TestCase
+{
+    /**
+     * @var DateTimeNormalizer
+     */
+    private $normalizer;
+
+    protected function setUp()
+    {
+        $this->normalizer = new DateTimeNormalizer();
+    }
+
+    public function testSupportsNormalization()
+    {
+        $this->assertTrue($this->normalizer->supportsNormalization(new \DateTime()));
+        $this->assertTrue($this->normalizer->supportsNormalization(new \DateTimeImmutable()));
+        $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+    }
+
+    public function testNormalize()
+    {
+        $this->assertEquals('2016-01-01T00:00:00+00:00', $this->normalizer->normalize(new \DateTime('2016/01/01', new \DateTimeZone('UTC'))));
+        $this->assertEquals('2016-01-01T00:00:00+00:00', $this->normalizer->normalize(new \DateTimeImmutable('2016/01/01', new \DateTimeZone('UTC'))));
+    }
+
+    public function testNormalizeUsingFormatPassedInContext()
+    {
+        $this->assertEquals('2016', $this->normalizer->normalize(new \DateTime('2016/01/01'), null, [DateTimeNormalizer::FORMAT_KEY => 'Y']));
+    }
+
+    public function testNormalizeUsingFormatPassedInConstructor()
+    {
+        $this->assertEquals('16', (new DateTimeNormalizer('y'))->normalize(new \DateTime('2016/01/01', new \DateTimeZone('UTC'))));
+    }
+
+    public function testNormalizeUsingTimeZonePassedInConstructor()
+    {
+        $normalizer = new DateTimeNormalizer(\DateTime::RFC3339, new \DateTimeZone('Japan'));
+
+        $this->assertSame('2016-12-01T00:00:00+09:00', $normalizer->normalize(new \DateTime('2016/12/01', new \DateTimeZone('Japan'))));
+        $this->assertSame('2016-12-01T09:00:00+09:00', $normalizer->normalize(new \DateTime('2016/12/01', new \DateTimeZone('UTC'))));
+    }
+
+    /**
+     * @dataProvider normalizeUsingTimeZonePassedInContextProvider
+     */
+    public function testNormalizeUsingTimeZonePassedInContext($expected, $input, $timezone)
+    {
+        $this->assertSame($expected, $this->normalizer->normalize($input, null, [
+            DateTimeNormalizer::TIMEZONE_KEY => $timezone,
+        ]));
+    }
+
+    public function normalizeUsingTimeZonePassedInContextProvider()
+    {
+        yield ['2016-12-01T00:00:00+00:00', new \DateTime('2016/12/01', new \DateTimeZone('UTC')), null];
+        yield ['2016-12-01T00:00:00+09:00', new \DateTime('2016/12/01', new \DateTimeZone('Japan')), new \DateTimeZone('Japan')];
+        yield ['2016-12-01T09:00:00+09:00', new \DateTime('2016/12/01', new \DateTimeZone('UTC')), new \DateTimeZone('Japan')];
+        yield ['2016-12-01T09:00:00+09:00', new \DateTimeImmutable('2016/12/01', new \DateTimeZone('UTC')), new \DateTimeZone('Japan')];
+    }
+
+    /**
+     * @dataProvider normalizeUsingTimeZonePassedInContextAndExpectedFormatWithMicrosecondsProvider
+     */
+    public function testNormalizeUsingTimeZonePassedInContextAndFormattedWithMicroseconds($expected, $expectedFormat, $input, $timezone)
+    {
+        $this->assertSame(
+            $expected,
+            $this->normalizer->normalize(
+                $input,
+                null,
+                [
+                    DateTimeNormalizer::TIMEZONE_KEY => $timezone,
+                    DateTimeNormalizer::FORMAT_KEY => $expectedFormat,
+                ]
+            )
+        );
+    }
+
+    public function normalizeUsingTimeZonePassedInContextAndExpectedFormatWithMicrosecondsProvider()
+    {
+        yield [
+            '2018-12-01T18:03:06.067634',
+            'Y-m-d\TH:i:s.u',
+            \DateTime::createFromFormat(
+                'Y-m-d\TH:i:s.u',
+                '2018-12-01T18:03:06.067634',
+                new \DateTimeZone('UTC')
+            ),
+            null,
+        ];
+
+        yield [
+            '2018-12-01T18:03:06.067634',
+            'Y-m-d\TH:i:s.u',
+            \DateTime::createFromFormat(
+                'Y-m-d\TH:i:s.u',
+                '2018-12-01T18:03:06.067634',
+                new \DateTimeZone('UTC')
+            ),
+            new \DateTimeZone('UTC'),
+        ];
+
+        yield [
+            '2018-12-01T19:03:06.067634+01:00',
+            'Y-m-d\TH:i:s.uP',
+            \DateTimeImmutable::createFromFormat(
+                'Y-m-d\TH:i:s.u',
+                '2018-12-01T18:03:06.067634',
+                new \DateTimeZone('UTC')
+            ),
+            new \DateTimeZone('Europe/Rome'),
+        ];
+
+        yield [
+            '2018-12-01T20:03:06.067634+02:00',
+            'Y-m-d\TH:i:s.uP',
+            \DateTime::createFromFormat(
+                'Y-m-d\TH:i:s.u',
+                '2018-12-01T18:03:06.067634',
+                new \DateTimeZone('UTC')
+            ),
+            new \DateTimeZone('Europe/Kiev'),
+        ];
+
+        yield [
+            '2018-12-01T19:03:06.067634',
+            'Y-m-d\TH:i:s.u',
+            \DateTime::createFromFormat(
+                'Y-m-d\TH:i:s.u',
+                '2018-12-01T18:03:06.067634',
+                new \DateTimeZone('UTC')
+            ),
+            new \DateTimeZone('Europe/Berlin'),
+        ];
+    }
+
+    public function testNormalizeInvalidObjectThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\InvalidArgumentException');
+        $this->expectExceptionMessage('The object must implement the "\DateTimeInterface".');
+        $this->normalizer->normalize(new \stdClass());
+    }
+
+    public function testSupportsDenormalization()
+    {
+        $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', \DateTimeInterface::class));
+        $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', \DateTime::class));
+        $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', \DateTimeImmutable::class));
+        $this->assertFalse($this->normalizer->supportsDenormalization('foo', 'Bar'));
+    }
+
+    public function testDenormalize()
+    {
+        $this->assertEquals(new \DateTimeImmutable('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTimeInterface::class));
+        $this->assertEquals(new \DateTimeImmutable('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTimeImmutable::class));
+        $this->assertEquals(new \DateTime('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTime::class));
+    }
+
+    public function testDenormalizeUsingTimezonePassedInConstructor()
+    {
+        $timezone = new \DateTimeZone('Japan');
+        $expected = new \DateTime('2016/12/01 17:35:00', $timezone);
+        $normalizer = new DateTimeNormalizer(null, $timezone);
+
+        $this->assertEquals($expected, $normalizer->denormalize('2016.12.01 17:35:00', \DateTime::class, null, [
+            DateTimeNormalizer::FORMAT_KEY => 'Y.m.d H:i:s',
+        ]));
+    }
+
+    public function testDenormalizeUsingFormatPassedInContext()
+    {
+        $this->assertEquals(new \DateTimeImmutable('2016/01/01'), $this->normalizer->denormalize('2016.01.01', \DateTimeInterface::class, null, [DateTimeNormalizer::FORMAT_KEY => 'Y.m.d|']));
+        $this->assertEquals(new \DateTimeImmutable('2016/01/01'), $this->normalizer->denormalize('2016.01.01', \DateTimeImmutable::class, null, [DateTimeNormalizer::FORMAT_KEY => 'Y.m.d|']));
+        $this->assertEquals(new \DateTime('2016/01/01'), $this->normalizer->denormalize('2016.01.01', \DateTime::class, null, [DateTimeNormalizer::FORMAT_KEY => 'Y.m.d|']));
+    }
+
+    /**
+     * @dataProvider denormalizeUsingTimezonePassedInContextProvider
+     */
+    public function testDenormalizeUsingTimezonePassedInContext($input, $expected, $timezone, $format = null)
+    {
+        $actual = $this->normalizer->denormalize($input, \DateTimeInterface::class, null, [
+            DateTimeNormalizer::TIMEZONE_KEY => $timezone,
+            DateTimeNormalizer::FORMAT_KEY => $format,
+        ]);
+
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function denormalizeUsingTimezonePassedInContextProvider()
+    {
+        yield 'with timezone' => [
+            '2016/12/01 17:35:00',
+            new \DateTimeImmutable('2016/12/01 17:35:00', new \DateTimeZone('Japan')),
+            new \DateTimeZone('Japan'),
+        ];
+        yield 'with timezone as string' => [
+            '2016/12/01 17:35:00',
+            new \DateTimeImmutable('2016/12/01 17:35:00', new \DateTimeZone('Japan')),
+            'Japan',
+        ];
+        yield 'with format without timezone information' => [
+            '2016.12.01 17:35:00',
+            new \DateTimeImmutable('2016/12/01 17:35:00', new \DateTimeZone('Japan')),
+            new \DateTimeZone('Japan'),
+            'Y.m.d H:i:s',
+        ];
+        yield 'ignored with format with timezone information' => [
+            '2016-12-01T17:35:00Z',
+            new \DateTimeImmutable('2016/12/01 17:35:00', new \DateTimeZone('UTC')),
+            'Europe/Paris',
+            \DateTime::RFC3339,
+        ];
+    }
+
+    public function testDenormalizeInvalidDataThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+        $this->normalizer->denormalize('invalid date', \DateTimeInterface::class);
+    }
+
+    public function testDenormalizeNullThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+        $this->expectExceptionMessage('The data is either an empty string or null, you should pass a string that can be parsed with the passed format or a valid DateTime string.');
+        $this->normalizer->denormalize(null, \DateTimeInterface::class);
+    }
+
+    public function testDenormalizeEmptyStringThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+        $this->expectExceptionMessage('The data is either an empty string or null, you should pass a string that can be parsed with the passed format or a valid DateTime string.');
+        $this->normalizer->denormalize('', \DateTimeInterface::class);
+    }
+
+    public function testDenormalizeFormatMismatchThrowsException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+        $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTimeInterface::class, null, [DateTimeNormalizer::FORMAT_KEY => 'Y-m-d|']);
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/GetSetMethodNormalizerTest.php

@@ -0,0 +1,815 @@
+<?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\Serializer\Tests\Normalizer;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
+use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
+use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
+use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Symfony\Component\Serializer\Serializer;
+use Symfony\Component\Serializer\SerializerInterface;
+use Symfony\Component\Serializer\Tests\Fixtures\CircularReferenceDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\GroupDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\MaxDepthDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\SiblingHolder;
+
+class GetSetMethodNormalizerTest extends TestCase
+{
+    /**
+     * @var GetSetMethodNormalizer
+     */
+    private $normalizer;
+    /**
+     * @var SerializerInterface
+     */
+    private $serializer;
+
+    protected function setUp()
+    {
+        $this->serializer = $this->getMockBuilder(SerializerNormalizer::class)->getMock();
+        $this->normalizer = new GetSetMethodNormalizer();
+        $this->normalizer->setSerializer($this->serializer);
+    }
+
+    public function testInterface()
+    {
+        $this->assertInstanceOf('Symfony\Component\Serializer\Normalizer\NormalizerInterface', $this->normalizer);
+        $this->assertInstanceOf('Symfony\Component\Serializer\Normalizer\DenormalizerInterface', $this->normalizer);
+    }
+
+    public function testNormalize()
+    {
+        $obj = new GetSetDummy();
+        $object = new \stdClass();
+        $obj->setFoo('foo');
+        $obj->setBar('bar');
+        $obj->setBaz(true);
+        $obj->setCamelCase('camelcase');
+        $obj->setObject($object);
+
+        $this->serializer
+            ->expects($this->once())
+            ->method('normalize')
+            ->with($object, 'any')
+            ->willReturn('string_object')
+        ;
+
+        $this->assertEquals(
+            [
+                'foo' => 'foo',
+                'bar' => 'bar',
+                'baz' => true,
+                'fooBar' => 'foobar',
+                'camelCase' => 'camelcase',
+                'object' => 'string_object',
+            ],
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function testDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => 'foo', 'bar' => 'bar', 'baz' => true, 'fooBar' => 'foobar'],
+            GetSetDummy::class,
+            'any'
+        );
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+        $this->assertTrue($obj->isBaz());
+    }
+
+    public function testIgnoredAttributesInContext()
+    {
+        $ignoredAttributes = ['foo', 'bar', 'baz', 'object'];
+        $this->normalizer->setIgnoredAttributes($ignoredAttributes);
+        $obj = new GetSetDummy();
+        $obj->setFoo('foo');
+        $obj->setBar('bar');
+        $obj->setCamelCase(true);
+        $this->assertEquals(
+            [
+                'fooBar' => 'foobar',
+                'camelCase' => true,
+            ],
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function testDenormalizeWithObject()
+    {
+        $data = new \stdClass();
+        $data->foo = 'foo';
+        $data->bar = 'bar';
+        $data->fooBar = 'foobar';
+        $obj = $this->normalizer->denormalize($data, GetSetDummy::class, 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testDenormalizeNull()
+    {
+        $this->assertEquals(new GetSetDummy(), $this->normalizer->denormalize(null, GetSetDummy::class));
+    }
+
+    public function testConstructorDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => 'foo', 'bar' => 'bar', 'baz' => true, 'fooBar' => 'foobar'],
+            GetConstructorDummy::class, 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+        $this->assertTrue($obj->isBaz());
+    }
+
+    public function testConstructorDenormalizeWithNullArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => 'foo', 'bar' => null, 'baz' => true],
+            GetConstructorDummy::class, 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertNull($obj->getBar());
+        $this->assertTrue($obj->isBaz());
+    }
+
+    public function testConstructorDenormalizeWithMissingOptionalArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => 'test', 'baz' => [1, 2, 3]],
+            GetConstructorOptionalArgsDummy::class, 'any');
+        $this->assertEquals('test', $obj->getFoo());
+        $this->assertEquals([], $obj->getBar());
+        $this->assertEquals([1, 2, 3], $obj->getBaz());
+    }
+
+    public function testConstructorDenormalizeWithOptionalDefaultArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['bar' => 'test'],
+            GetConstructorArgsWithDefaultValueDummy::class, 'any');
+        $this->assertEquals([], $obj->getFoo());
+        $this->assertEquals('test', $obj->getBar());
+    }
+
+    /**
+     * @requires PHP 5.6
+     */
+    public function testConstructorDenormalizeWithVariadicArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => [1, 2, 3]],
+            'Symfony\Component\Serializer\Tests\Fixtures\VariadicConstructorArgsDummy', 'any');
+        $this->assertEquals([1, 2, 3], $obj->getFoo());
+    }
+
+    /**
+     * @requires PHP 5.6
+     */
+    public function testConstructorDenormalizeWithMissingVariadicArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            [],
+            'Symfony\Component\Serializer\Tests\Fixtures\VariadicConstructorArgsDummy', 'any');
+        $this->assertEquals([], $obj->getFoo());
+    }
+
+    public function testConstructorWithObjectDenormalize()
+    {
+        $data = new \stdClass();
+        $data->foo = 'foo';
+        $data->bar = 'bar';
+        $data->baz = true;
+        $data->fooBar = 'foobar';
+        $obj = $this->normalizer->denormalize($data, GetConstructorDummy::class, 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testConstructorWArgWithPrivateMutator()
+    {
+        $obj = $this->normalizer->denormalize(['foo' => 'bar'], ObjectConstructorArgsWithPrivateMutatorDummy::class, 'any');
+        $this->assertEquals('bar', $obj->getFoo());
+    }
+
+    public function testGroupsNormalize()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new GetSetMethodNormalizer($classMetadataFactory);
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFoo('foo');
+        $obj->setBar('bar');
+        $obj->setFooBar('fooBar');
+        $obj->setSymfony('symfony');
+        $obj->setKevin('kevin');
+        $obj->setCoopTilleuls('coopTilleuls');
+
+        $this->assertEquals([
+            'bar' => 'bar',
+        ], $this->normalizer->normalize($obj, null, [GetSetMethodNormalizer::GROUPS => ['c']]));
+
+        $this->assertEquals([
+            'symfony' => 'symfony',
+            'foo' => 'foo',
+            'fooBar' => 'fooBar',
+            'bar' => 'bar',
+            'kevin' => 'kevin',
+            'coopTilleuls' => 'coopTilleuls',
+        ], $this->normalizer->normalize($obj, null, [GetSetMethodNormalizer::GROUPS => ['a', 'c']]));
+    }
+
+    public function testGroupsDenormalize()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new GetSetMethodNormalizer($classMetadataFactory);
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFoo('foo');
+
+        $toNormalize = ['foo' => 'foo', 'bar' => 'bar'];
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            [GetSetMethodNormalizer::GROUPS => ['a']]
+        );
+        $this->assertEquals($obj, $normalized);
+
+        $obj->setBar('bar');
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            [GetSetMethodNormalizer::GROUPS => ['a', 'b']]
+        );
+        $this->assertEquals($obj, $normalized);
+    }
+
+    public function testGroupsNormalizeWithNameConverter()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new GetSetMethodNormalizer($classMetadataFactory, new CamelCaseToSnakeCaseNameConverter());
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFooBar('@dunglas');
+        $obj->setSymfony('@coopTilleuls');
+        $obj->setCoopTilleuls('les-tilleuls.coop');
+
+        $this->assertEquals(
+            [
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+            ],
+            $this->normalizer->normalize($obj, null, [GetSetMethodNormalizer::GROUPS => ['name_converter']])
+        );
+    }
+
+    public function testGroupsDenormalizeWithNameConverter()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new GetSetMethodNormalizer($classMetadataFactory, new CamelCaseToSnakeCaseNameConverter());
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFooBar('@dunglas');
+        $obj->setSymfony('@coopTilleuls');
+
+        $this->assertEquals(
+            $obj,
+            $this->normalizer->denormalize([
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+                'coop_tilleuls' => 'les-tilleuls.coop',
+            ], 'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy', null, [GetSetMethodNormalizer::GROUPS => ['name_converter']])
+        );
+    }
+
+    /**
+     * @dataProvider provideCallbacks
+     */
+    public function testCallbacks($callbacks, $value, $result, $message)
+    {
+        $this->normalizer->setCallbacks($callbacks);
+
+        $obj = new GetConstructorDummy('', $value, true);
+
+        $this->assertEquals(
+            $result,
+            $this->normalizer->normalize($obj, 'any'),
+            $message
+        );
+    }
+
+    public function testUncallableCallbacks()
+    {
+        $this->expectException('InvalidArgumentException');
+        $this->normalizer->setCallbacks(['bar' => null]);
+
+        $obj = new GetConstructorDummy('baz', 'quux', true);
+
+        $this->normalizer->normalize($obj, 'any');
+    }
+
+    public function testIgnoredAttributes()
+    {
+        $this->normalizer->setIgnoredAttributes(['foo', 'bar', 'baz', 'camelCase', 'object']);
+
+        $obj = new GetSetDummy();
+        $obj->setFoo('foo');
+        $obj->setBar('bar');
+        $obj->setBaz(true);
+
+        $this->assertEquals(
+            ['fooBar' => 'foobar'],
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function provideCallbacks()
+    {
+        return [
+            [
+                [
+                    'bar' => function ($bar) {
+                        return 'baz';
+                    },
+                ],
+                'baz',
+                ['foo' => '', 'bar' => 'baz', 'baz' => true],
+                'Change a string',
+            ],
+            [
+                [
+                    'bar' => function ($bar) {
+                    },
+                ],
+                'baz',
+                ['foo' => '', 'bar' => null, 'baz' => true],
+                'Null an item',
+            ],
+            [
+                [
+                    'bar' => function ($bar) {
+                        return $bar->format('d-m-Y H:i:s');
+                    },
+                ],
+                new \DateTime('2011-09-10 06:30:00'),
+                ['foo' => '', 'bar' => '10-09-2011 06:30:00', 'baz' => true],
+                'Format a date',
+            ],
+            [
+                [
+                    'bar' => function ($bars) {
+                        $foos = '';
+                        foreach ($bars as $bar) {
+                            $foos .= $bar->getFoo();
+                        }
+
+                        return $foos;
+                    },
+                ],
+                [new GetConstructorDummy('baz', '', false), new GetConstructorDummy('quux', '', false)],
+                ['foo' => '', 'bar' => 'bazquux', 'baz' => true],
+                'Collect a property',
+            ],
+            [
+                [
+                    'bar' => function ($bars) {
+                        return \count($bars);
+                    },
+                ],
+                [new GetConstructorDummy('baz', '', false), new GetConstructorDummy('quux', '', false)],
+                ['foo' => '', 'bar' => 2, 'baz' => true],
+                'Count a property',
+            ],
+        ];
+    }
+
+    public function testUnableToNormalizeObjectAttribute()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\LogicException');
+        $this->expectExceptionMessage('Cannot normalize attribute "object" because the injected serializer is not a normalizer');
+        $serializer = $this->getMockBuilder('Symfony\Component\Serializer\SerializerInterface')->getMock();
+        $this->normalizer->setSerializer($serializer);
+
+        $obj = new GetSetDummy();
+        $object = new \stdClass();
+        $obj->setObject($object);
+
+        $this->normalizer->normalize($obj, 'any');
+    }
+
+    public function testUnableToNormalizeCircularReference()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\CircularReferenceException');
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceLimit(2);
+
+        $obj = new CircularReferenceDummy();
+
+        $this->normalizer->normalize($obj);
+    }
+
+    public function testSiblingReference()
+    {
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+
+        $siblingHolder = new SiblingHolder();
+
+        $expected = [
+            'sibling0' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
+            'sibling1' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
+            'sibling2' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
+        ];
+        $this->assertEquals($expected, $this->normalizer->normalize($siblingHolder));
+    }
+
+    public function testCircularReferenceHandler()
+    {
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceHandler(function ($obj) {
+            return \get_class($obj);
+        });
+
+        $obj = new CircularReferenceDummy();
+
+        $expected = ['me' => 'Symfony\Component\Serializer\Tests\Fixtures\CircularReferenceDummy'];
+        $this->assertEquals($expected, $this->normalizer->normalize($obj));
+    }
+
+    public function testObjectToPopulate()
+    {
+        $dummy = new GetSetDummy();
+        $dummy->setFoo('foo');
+
+        $obj = $this->normalizer->denormalize(
+            ['bar' => 'bar'],
+            GetSetDummy::class,
+            null,
+            [GetSetMethodNormalizer::OBJECT_TO_POPULATE => $dummy]
+        );
+
+        $this->assertEquals($dummy, $obj);
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testDenormalizeNonExistingAttribute()
+    {
+        $this->assertEquals(
+            new GetSetDummy(),
+            $this->normalizer->denormalize(['non_existing' => true], GetSetDummy::class)
+        );
+    }
+
+    public function testDenormalizeShouldNotSetStaticAttribute()
+    {
+        $obj = $this->normalizer->denormalize(['staticObject' => true], GetSetDummy::class);
+
+        $this->assertEquals(new GetSetDummy(), $obj);
+        $this->assertNull(GetSetDummy::getStaticObject());
+    }
+
+    public function testNoTraversableSupport()
+    {
+        $this->assertFalse($this->normalizer->supportsNormalization(new \ArrayObject()));
+    }
+
+    public function testNoStaticGetSetSupport()
+    {
+        $this->assertFalse($this->normalizer->supportsNormalization(new ObjectWithJustStaticSetterDummy()));
+    }
+
+    public function testPrivateSetter()
+    {
+        $obj = $this->normalizer->denormalize(['foo' => 'foobar'], ObjectWithPrivateSetterDummy::class);
+        $this->assertEquals('bar', $obj->getFoo());
+    }
+
+    public function testHasGetterDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(['foo' => true], ObjectWithHasGetterDummy::class);
+        $this->assertTrue($obj->hasFoo());
+    }
+
+    public function testHasGetterNormalize()
+    {
+        $obj = new ObjectWithHasGetterDummy();
+        $obj->setFoo(true);
+
+        $this->assertEquals(
+            ['foo' => true],
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function testMaxDepth()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new GetSetMethodNormalizer($classMetadataFactory);
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+
+        $level1 = new MaxDepthDummy();
+        $level1->bar = 'level1';
+
+        $level2 = new MaxDepthDummy();
+        $level2->bar = 'level2';
+        $level1->child = $level2;
+
+        $level3 = new MaxDepthDummy();
+        $level3->bar = 'level3';
+        $level2->child = $level3;
+
+        $level4 = new MaxDepthDummy();
+        $level4->bar = 'level4';
+        $level3->child = $level4;
+
+        $result = $serializer->normalize($level1, null, [GetSetMethodNormalizer::ENABLE_MAX_DEPTH => true]);
+
+        $expected = [
+            'bar' => 'level1',
+            'child' => [
+                    'bar' => 'level2',
+                    'child' => [
+                            'bar' => 'level3',
+                            'child' => [
+                                    'child' => null,
+                                ],
+                        ],
+                ],
+            ];
+
+        $this->assertEquals($expected, $result);
+    }
+}
+
+class GetSetDummy
+{
+    protected $foo;
+    private $bar;
+    private $baz;
+    protected $camelCase;
+    protected $object;
+    private static $staticObject;
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    public function setFoo($foo)
+    {
+        $this->foo = $foo;
+    }
+
+    public function getBar()
+    {
+        return $this->bar;
+    }
+
+    public function setBar($bar)
+    {
+        $this->bar = $bar;
+    }
+
+    public function isBaz()
+    {
+        return $this->baz;
+    }
+
+    public function setBaz($baz)
+    {
+        $this->baz = $baz;
+    }
+
+    public function getFooBar()
+    {
+        return $this->foo.$this->bar;
+    }
+
+    public function getCamelCase()
+    {
+        return $this->camelCase;
+    }
+
+    public function setCamelCase($camelCase)
+    {
+        $this->camelCase = $camelCase;
+    }
+
+    public function otherMethod()
+    {
+        throw new \RuntimeException('Dummy::otherMethod() should not be called');
+    }
+
+    public function setObject($object)
+    {
+        $this->object = $object;
+    }
+
+    public function getObject()
+    {
+        return $this->object;
+    }
+
+    public static function getStaticObject()
+    {
+        return self::$staticObject;
+    }
+
+    public static function setStaticObject($object)
+    {
+        self::$staticObject = $object;
+    }
+
+    protected function getPrivate()
+    {
+        throw new \RuntimeException('Dummy::getPrivate() should not be called');
+    }
+}
+
+class GetConstructorDummy
+{
+    protected $foo;
+    private $bar;
+    private $baz;
+
+    public function __construct($foo, $bar, $baz)
+    {
+        $this->foo = $foo;
+        $this->bar = $bar;
+        $this->baz = $baz;
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    public function getBar()
+    {
+        return $this->bar;
+    }
+
+    public function isBaz()
+    {
+        return $this->baz;
+    }
+
+    public function otherMethod()
+    {
+        throw new \RuntimeException('Dummy::otherMethod() should not be called');
+    }
+}
+
+abstract class SerializerNormalizer implements SerializerInterface, NormalizerInterface
+{
+}
+
+class GetConstructorOptionalArgsDummy
+{
+    protected $foo;
+    private $bar;
+    private $baz;
+
+    public function __construct($foo, $bar = [], $baz = [])
+    {
+        $this->foo = $foo;
+        $this->bar = $bar;
+        $this->baz = $baz;
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    public function getBar()
+    {
+        return $this->bar;
+    }
+
+    public function getBaz()
+    {
+        return $this->baz;
+    }
+
+    public function otherMethod()
+    {
+        throw new \RuntimeException('Dummy::otherMethod() should not be called');
+    }
+}
+
+class GetConstructorArgsWithDefaultValueDummy
+{
+    protected $foo;
+    protected $bar;
+
+    public function __construct($foo = [], $bar = null)
+    {
+        $this->foo = $foo;
+        $this->bar = $bar;
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    public function getBar()
+    {
+        return $this->bar;
+    }
+
+    public function otherMethod()
+    {
+        throw new \RuntimeException('Dummy::otherMethod() should not be called');
+    }
+}
+
+class ObjectConstructorArgsWithPrivateMutatorDummy
+{
+    private $foo;
+
+    public function __construct($foo)
+    {
+        $this->setFoo($foo);
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    private function setFoo($foo)
+    {
+        $this->foo = $foo;
+    }
+}
+
+class ObjectWithPrivateSetterDummy
+{
+    private $foo = 'bar';
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    private function setFoo($foo)
+    {
+    }
+}
+
+class ObjectWithJustStaticSetterDummy
+{
+    private static $foo = 'bar';
+
+    public static function getFoo()
+    {
+        return self::$foo;
+    }
+
+    public static function setFoo($foo)
+    {
+        self::$foo = $foo;
+    }
+}
+
+class ObjectWithHasGetterDummy
+{
+    private $foo;
+
+    public function setFoo($foo)
+    {
+        $this->foo = $foo;
+    }
+
+    public function hasFoo()
+    {
+        return $this->foo;
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/JsonSerializableNormalizerTest.php

@@ -0,0 +1,92 @@
+<?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\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Normalizer\JsonSerializableNormalizer;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Symfony\Component\Serializer\SerializerInterface;
+use Symfony\Component\Serializer\Tests\Fixtures\JsonSerializableDummy;
+
+/**
+ * @author Fred Cox <mcfedr@gmail.com>
+ */
+class JsonSerializableNormalizerTest extends TestCase
+{
+    /**
+     * @var JsonSerializableNormalizer
+     */
+    private $normalizer;
+
+    /**
+     * @var MockObject|SerializerInterface
+     */
+    private $serializer;
+
+    protected function setUp()
+    {
+        $this->serializer = $this->getMockBuilder(JsonSerializerNormalizer::class)->getMock();
+        $this->normalizer = new JsonSerializableNormalizer();
+        $this->normalizer->setSerializer($this->serializer);
+    }
+
+    public function testSupportNormalization()
+    {
+        $this->assertTrue($this->normalizer->supportsNormalization(new JsonSerializableDummy()));
+        $this->assertFalse($this->normalizer->supportsNormalization(new \stdClass()));
+    }
+
+    public function testNormalize()
+    {
+        $this->serializer
+            ->expects($this->once())
+            ->method('normalize')
+            ->willReturnCallback(function ($data) {
+                $this->assertSame(['foo' => 'a', 'bar' => 'b', 'baz' => 'c'], array_diff_key($data, ['qux' => '']));
+
+                return 'string_object';
+            })
+        ;
+
+        $this->assertEquals('string_object', $this->normalizer->normalize(new JsonSerializableDummy()));
+    }
+
+    public function testCircularNormalize()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\CircularReferenceException');
+        $this->normalizer->setCircularReferenceLimit(1);
+
+        $this->serializer
+            ->expects($this->once())
+            ->method('normalize')
+            ->willReturnCallback(function ($data, $format, $context) {
+                $this->normalizer->normalize($data['qux'], $format, $context);
+
+                return 'string_object';
+            })
+        ;
+
+        $this->assertEquals('string_object', $this->normalizer->normalize(new JsonSerializableDummy()));
+    }
+
+    public function testInvalidDataThrowException()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\InvalidArgumentException');
+        $this->expectExceptionMessage('The object must implement "JsonSerializable".');
+        $this->normalizer->normalize(new \stdClass());
+    }
+}
+
+abstract class JsonSerializerNormalizer implements SerializerInterface, NormalizerInterface
+{
+}

vendor/symfony/serializer/Tests/Normalizer/ObjectToPopulateTraitTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Symfony\Component\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Normalizer\ObjectToPopulateTrait;
+use Symfony\Component\Serializer\Tests\Fixtures\ProxyDummy;
+
+class ObjectToPopulateTraitTest extends TestCase
+{
+    use ObjectToPopulateTrait;
+
+    public function testExtractObjectToPopulateReturnsNullWhenKeyIsMissing()
+    {
+        $object = $this->extractObjectToPopulate(ProxyDummy::class, []);
+
+        $this->assertNull($object);
+    }
+
+    public function testExtractObjectToPopulateReturnsNullWhenNonObjectIsProvided()
+    {
+        $object = $this->extractObjectToPopulate(ProxyDummy::class, [
+            'object_to_populate' => 'not an object',
+        ]);
+
+        $this->assertNull($object);
+    }
+
+    public function testExtractObjectToPopulateReturnsNullWhenTheClassIsNotAnInstanceOfTheProvidedClass()
+    {
+        $object = $this->extractObjectToPopulate(ProxyDummy::class, [
+            'object_to_populate' => new \stdClass(),
+        ]);
+
+        $this->assertNull($object);
+    }
+
+    public function testExtractObjectToPopulateReturnsObjectWhenEverythingChecksOut()
+    {
+        $expected = new ProxyDummy();
+        $object = $this->extractObjectToPopulate(ProxyDummy::class, [
+            'object_to_populate' => $expected,
+        ]);
+
+        $this->assertSame($expected, $object);
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/PropertyNormalizerTest.php

@@ -0,0 +1,519 @@
+<?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\Serializer\Tests\Normalizer;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
+use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
+use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
+use Symfony\Component\Serializer\Normalizer\PropertyNormalizer;
+use Symfony\Component\Serializer\Serializer;
+use Symfony\Component\Serializer\SerializerInterface;
+use Symfony\Component\Serializer\Tests\Fixtures\GroupDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\GroupDummyChild;
+use Symfony\Component\Serializer\Tests\Fixtures\MaxDepthDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Php74Dummy;
+use Symfony\Component\Serializer\Tests\Fixtures\PropertyCircularReferenceDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\PropertySiblingHolder;
+
+class PropertyNormalizerTest extends TestCase
+{
+    /**
+     * @var PropertyNormalizer
+     */
+    private $normalizer;
+    /**
+     * @var SerializerInterface
+     */
+    private $serializer;
+
+    protected function setUp()
+    {
+        $this->serializer = $this->getMockBuilder('Symfony\Component\Serializer\SerializerInterface')->getMock();
+        $this->normalizer = new PropertyNormalizer();
+        $this->normalizer->setSerializer($this->serializer);
+    }
+
+    public function testNormalize()
+    {
+        $obj = new PropertyDummy();
+        $obj->foo = 'foo';
+        $obj->setBar('bar');
+        $obj->setCamelCase('camelcase');
+        $this->assertEquals(
+            ['foo' => 'foo', 'bar' => 'bar', 'camelCase' => 'camelcase'],
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    /**
+     * @requires PHP 7.4
+     */
+    public function testNormalizeObjectWithUninitializedProperties()
+    {
+        $obj = new Php74Dummy();
+        $this->assertEquals(
+            ['initializedProperty' => 'defaultValue'],
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function testDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => 'foo', 'bar' => 'bar'],
+            PropertyDummy::class,
+            'any'
+        );
+        $this->assertEquals('foo', $obj->foo);
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testNormalizeWithParentClass()
+    {
+        $group = new GroupDummyChild();
+        $group->setBaz('baz');
+        $group->setFoo('foo');
+        $group->setBar('bar');
+        $group->setKevin('Kevin');
+        $group->setCoopTilleuls('coop');
+        $this->assertEquals(
+            ['foo' => 'foo', 'bar' => 'bar', 'kevin' => 'Kevin', 'coopTilleuls' => 'coop', 'fooBar' => null, 'symfony' => null, 'baz' => 'baz'],
+            $this->normalizer->normalize($group, 'any')
+        );
+    }
+
+    public function testDenormalizeWithParentClass()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => 'foo', 'bar' => 'bar', 'kevin' => 'Kevin', 'baz' => 'baz'],
+            GroupDummyChild::class,
+            'any'
+        );
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+        $this->assertEquals('Kevin', $obj->getKevin());
+        $this->assertEquals('baz', $obj->getBaz());
+        $this->assertNull($obj->getSymfony());
+    }
+
+    public function testConstructorDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => 'foo', 'bar' => 'bar'],
+            PropertyConstructorDummy::class,
+            'any'
+        );
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testConstructorDenormalizeWithNullArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            ['foo' => null, 'bar' => 'bar'],
+            PropertyConstructorDummy::class, '
+            any'
+        );
+        $this->assertNull($obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    /**
+     * @dataProvider provideCallbacks
+     */
+    public function testCallbacks($callbacks, $value, $result, $message)
+    {
+        $this->normalizer->setCallbacks($callbacks);
+
+        $obj = new PropertyConstructorDummy('', $value);
+
+        $this->assertEquals(
+            $result,
+            $this->normalizer->normalize($obj, 'any'),
+            $message
+        );
+    }
+
+    public function testUncallableCallbacks()
+    {
+        $this->expectException('InvalidArgumentException');
+        $this->normalizer->setCallbacks(['bar' => null]);
+
+        $obj = new PropertyConstructorDummy('baz', 'quux');
+
+        $this->normalizer->normalize($obj, 'any');
+    }
+
+    public function testIgnoredAttributes()
+    {
+        $this->normalizer->setIgnoredAttributes(['foo', 'bar', 'camelCase']);
+
+        $obj = new PropertyDummy();
+        $obj->foo = 'foo';
+        $obj->setBar('bar');
+
+        $this->assertEquals(
+            [],
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function testGroupsNormalize()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new PropertyNormalizer($classMetadataFactory);
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFoo('foo');
+        $obj->setBar('bar');
+        $obj->setFooBar('fooBar');
+        $obj->setSymfony('symfony');
+        $obj->setKevin('kevin');
+        $obj->setCoopTilleuls('coopTilleuls');
+
+        $this->assertEquals([
+            'bar' => 'bar',
+        ], $this->normalizer->normalize($obj, null, [PropertyNormalizer::GROUPS => ['c']]));
+
+        // The PropertyNormalizer is also able to hydrate properties from parent classes
+        $this->assertEquals([
+            'symfony' => 'symfony',
+            'foo' => 'foo',
+            'fooBar' => 'fooBar',
+            'bar' => 'bar',
+            'kevin' => 'kevin',
+            'coopTilleuls' => 'coopTilleuls',
+        ], $this->normalizer->normalize($obj, null, [PropertyNormalizer::GROUPS => ['a', 'c']]));
+    }
+
+    public function testGroupsDenormalize()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new PropertyNormalizer($classMetadataFactory);
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFoo('foo');
+
+        $toNormalize = ['foo' => 'foo', 'bar' => 'bar'];
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            [PropertyNormalizer::GROUPS => ['a']]
+        );
+        $this->assertEquals($obj, $normalized);
+
+        $obj->setBar('bar');
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            [PropertyNormalizer::GROUPS => ['a', 'b']]
+        );
+        $this->assertEquals($obj, $normalized);
+    }
+
+    public function testGroupsNormalizeWithNameConverter()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new PropertyNormalizer($classMetadataFactory, new CamelCaseToSnakeCaseNameConverter());
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFooBar('@dunglas');
+        $obj->setSymfony('@coopTilleuls');
+        $obj->setCoopTilleuls('les-tilleuls.coop');
+
+        $this->assertEquals(
+            [
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+            ],
+            $this->normalizer->normalize($obj, null, [PropertyNormalizer::GROUPS => ['name_converter']])
+        );
+    }
+
+    public function testGroupsDenormalizeWithNameConverter()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new PropertyNormalizer($classMetadataFactory, new CamelCaseToSnakeCaseNameConverter());
+        $this->normalizer->setSerializer($this->serializer);
+
+        $obj = new GroupDummy();
+        $obj->setFooBar('@dunglas');
+        $obj->setSymfony('@coopTilleuls');
+
+        $this->assertEquals(
+            $obj,
+            $this->normalizer->denormalize([
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+                'coop_tilleuls' => 'les-tilleuls.coop',
+            ], 'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy', null, [PropertyNormalizer::GROUPS => ['name_converter']])
+        );
+    }
+
+    public function provideCallbacks()
+    {
+        return [
+            [
+                [
+                    'bar' => function ($bar) {
+                        return 'baz';
+                    },
+                ],
+                'baz',
+                ['foo' => '', 'bar' => 'baz'],
+                'Change a string',
+            ],
+            [
+                [
+                    'bar' => function ($bar) {
+                        return;
+                    },
+                ],
+                'baz',
+                ['foo' => '', 'bar' => null],
+                'Null an item',
+            ],
+            [
+                [
+                    'bar' => function ($bar) {
+                        return $bar->format('d-m-Y H:i:s');
+                    },
+                ],
+                new \DateTime('2011-09-10 06:30:00'),
+                ['foo' => '', 'bar' => '10-09-2011 06:30:00'],
+                'Format a date',
+            ],
+            [
+                [
+                    'bar' => function ($bars) {
+                        $foos = '';
+                        foreach ($bars as $bar) {
+                            $foos .= $bar->getFoo();
+                        }
+
+                        return $foos;
+                    },
+                ],
+                [new PropertyConstructorDummy('baz', ''), new PropertyConstructorDummy('quux', '')],
+                ['foo' => '', 'bar' => 'bazquux'],
+                'Collect a property',
+            ],
+            [
+                [
+                    'bar' => function ($bars) {
+                        return \count($bars);
+                    },
+                ],
+                [new PropertyConstructorDummy('baz', ''), new PropertyConstructorDummy('quux', '')],
+                ['foo' => '', 'bar' => 2],
+                'Count a property',
+            ],
+        ];
+    }
+
+    public function testUnableToNormalizeCircularReference()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\CircularReferenceException');
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceLimit(2);
+
+        $obj = new PropertyCircularReferenceDummy();
+
+        $this->normalizer->normalize($obj);
+    }
+
+    public function testSiblingReference()
+    {
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+
+        $siblingHolder = new PropertySiblingHolder();
+
+        $expected = [
+            'sibling0' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
+            'sibling1' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
+            'sibling2' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
+        ];
+        $this->assertEquals($expected, $this->normalizer->normalize($siblingHolder));
+    }
+
+    public function testCircularReferenceHandler()
+    {
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceHandler(function ($obj) {
+            return \get_class($obj);
+        });
+
+        $obj = new PropertyCircularReferenceDummy();
+
+        $expected = ['me' => 'Symfony\Component\Serializer\Tests\Fixtures\PropertyCircularReferenceDummy'];
+        $this->assertEquals($expected, $this->normalizer->normalize($obj));
+    }
+
+    public function testDenormalizeNonExistingAttribute()
+    {
+        $this->assertEquals(
+            new PropertyDummy(),
+            $this->normalizer->denormalize(['non_existing' => true], PropertyDummy::class)
+        );
+    }
+
+    public function testDenormalizeShouldIgnoreStaticProperty()
+    {
+        $obj = $this->normalizer->denormalize(['outOfScope' => true], PropertyDummy::class);
+
+        $this->assertEquals(new PropertyDummy(), $obj);
+        $this->assertEquals('out_of_scope', PropertyDummy::$outOfScope);
+    }
+
+    public function testUnableToNormalizeObjectAttribute()
+    {
+        $this->expectException('Symfony\Component\Serializer\Exception\LogicException');
+        $this->expectExceptionMessage('Cannot normalize attribute "bar" because the injected serializer is not a normalizer');
+        $serializer = $this->getMockBuilder('Symfony\Component\Serializer\SerializerInterface')->getMock();
+        $this->normalizer->setSerializer($serializer);
+
+        $obj = new PropertyDummy();
+        $object = new \stdClass();
+        $obj->setBar($object);
+
+        $this->normalizer->normalize($obj, 'any');
+    }
+
+    public function testNoTraversableSupport()
+    {
+        $this->assertFalse($this->normalizer->supportsNormalization(new \ArrayObject()));
+    }
+
+    public function testNoStaticPropertySupport()
+    {
+        $this->assertFalse($this->normalizer->supportsNormalization(new StaticPropertyDummy()));
+    }
+
+    public function testMaxDepth()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->normalizer = new PropertyNormalizer($classMetadataFactory);
+        $serializer = new Serializer([$this->normalizer]);
+        $this->normalizer->setSerializer($serializer);
+
+        $level1 = new MaxDepthDummy();
+        $level1->foo = 'level1';
+
+        $level2 = new MaxDepthDummy();
+        $level2->foo = 'level2';
+        $level1->child = $level2;
+
+        $level3 = new MaxDepthDummy();
+        $level3->foo = 'level3';
+        $level2->child = $level3;
+
+        $result = $serializer->normalize($level1, null, [PropertyNormalizer::ENABLE_MAX_DEPTH => true]);
+
+        $expected = [
+            'foo' => 'level1',
+            'child' => [
+                    'foo' => 'level2',
+                    'child' => [
+                            'child' => null,
+                            'bar' => null,
+                        ],
+                    'bar' => null,
+                ],
+            'bar' => null,
+        ];
+
+        $this->assertEquals($expected, $result);
+    }
+
+    public function testInheritedPropertiesSupport()
+    {
+        $this->assertTrue($this->normalizer->supportsNormalization(new PropertyChildDummy()));
+    }
+}
+
+class PropertyDummy
+{
+    public static $outOfScope = 'out_of_scope';
+    public $foo;
+    private $bar;
+    protected $camelCase;
+
+    public function getBar()
+    {
+        return $this->bar;
+    }
+
+    public function setBar($bar)
+    {
+        $this->bar = $bar;
+    }
+
+    public function getCamelCase()
+    {
+        return $this->camelCase;
+    }
+
+    public function setCamelCase($camelCase)
+    {
+        $this->camelCase = $camelCase;
+    }
+}
+
+class PropertyConstructorDummy
+{
+    protected $foo;
+    private $bar;
+
+    public function __construct($foo, $bar)
+    {
+        $this->foo = $foo;
+        $this->bar = $bar;
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    public function getBar()
+    {
+        return $this->bar;
+    }
+}
+
+class StaticPropertyDummy
+{
+    private static $property = 'value';
+}
+
+class PropertyParentDummy
+{
+    private $foo = 'bar';
+}
+
+class PropertyChildDummy extends PropertyParentDummy
+{
+}

vendor/symfony/serializer/Tests/Normalizer/TestDenormalizer.php

@@ -0,0 +1,37 @@
+<?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\Serializer\Tests\Normalizer;
+
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+/**
+ * Provides a test Normalizer which only implements the DenormalizerInterface.
+ *
+ * @author Lin Clark <lin@lin-clark.com>
+ */
+class TestDenormalizer implements DenormalizerInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function denormalize($data, $type, $format = null, array $context = [])
+    {
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsDenormalization($data, $type, $format = null)
+    {
+        return true;
+    }
+}

vendor/symfony/serializer/Tests/Normalizer/TestNormalizer.php

@@ -0,0 +1,37 @@
+<?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\Serializer\Tests\Normalizer;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+/**
+ * Provides a test Normalizer which only implements the NormalizerInterface.
+ *
+ * @author Lin Clark <lin@lin-clark.com>
+ */
+class TestNormalizer implements NormalizerInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function normalize($object, $format = null, array $context = [])
+    {
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsNormalization($data, $format = null)
+    {
+        return true;
+    }
+}