Update Composer, update everything

vendor/symfony/serializer/Tests/Annotation/GroupsTest.php

@@ -0,0 +1,59 @@
+<?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\Annotation;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Annotation\Groups;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class GroupsTest extends TestCase
+{
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     */
+    public function testEmptyGroupsParameter()
+    {
+        new Groups(array('value' => array()));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     */
+    public function testNotAnArrayGroupsParameter()
+    {
+        new Groups(array('value' => 12));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     */
+    public function testInvalidGroupsParameter()
+    {
+        new Groups(array('value' => array('a', 1, new \stdClass())));
+    }
+
+    public function testGroupsParameters()
+    {
+        $validData = array('a', 'b');
+
+        $groups = new Groups(array('value' => $validData));
+        $this->assertEquals($validData, $groups->getGroups());
+    }
+
+    public function testSingleGroup()
+    {
+        $groups = new Groups(array('value' => 'a'));
+        $this->assertEquals(array('a'), $groups->getGroups());
+    }
+}

vendor/symfony/serializer/Tests/Annotation/MaxDepthTest.php

@@ -0,0 +1,57 @@
+<?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\Annotation;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Annotation\MaxDepth;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class MaxDepthTest extends TestCase
+{
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Parameter of annotation "Symfony\Component\Serializer\Annotation\MaxDepth" should be set.
+     */
+    public function testNotSetMaxDepthParameter()
+    {
+        new MaxDepth(array());
+    }
+
+    public function provideInvalidValues()
+    {
+        return array(
+            array(''),
+            array('foo'),
+            array('1'),
+            array(0),
+        );
+    }
+
+    /**
+     * @dataProvider provideInvalidValues
+     *
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     * @expectedExceptionMessage Parameter of annotation "Symfony\Component\Serializer\Annotation\MaxDepth" must be a positive integer.
+     */
+    public function testNotAnIntMaxDepthParameter($value)
+    {
+        new MaxDepth(array('value' => $value));
+    }
+
+    public function testMaxDepthParameters()
+    {
+        $maxDepth = new MaxDepth(array('value' => 3));
+        $this->assertEquals(3, $maxDepth->getMaxDepth());
+    }
+}

vendor/symfony/serializer/Tests/DependencyInjection/SerializerPassTest.php

@@ -0,0 +1,75 @@
+<?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\DependencyInjection;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\Serializer\DependencyInjection\SerializerPass;
+
+/**
+ * Tests for the SerializerPass class.
+ *
+ * @author Javier Lopez <f12loalf@gmail.com>
+ */
+class SerializerPassTest extends TestCase
+{
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage You must tag at least one service as "serializer.normalizer" to use the "serializer" service
+     */
+    public function testThrowExceptionWhenNoNormalizers()
+    {
+        $container = new ContainerBuilder();
+        $container->register('serializer');
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage You must tag at least one service as "serializer.encoder" to use the "serializer" service
+     */
+    public function testThrowExceptionWhenNoEncoders()
+    {
+        $container = new ContainerBuilder();
+        $container->register('serializer')
+            ->addArgument(array())
+            ->addArgument(array());
+        $container->register('normalizer')->addTag('serializer.normalizer');
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+    }
+
+    public function testServicesAreOrderedAccordingToPriority()
+    {
+        $container = new ContainerBuilder();
+
+        $definition = $container->register('serializer')->setArguments(array(null, null));
+        $container->register('n2')->addTag('serializer.normalizer', array('priority' => 100))->addTag('serializer.encoder', array('priority' => 100));
+        $container->register('n1')->addTag('serializer.normalizer', array('priority' => 200))->addTag('serializer.encoder', array('priority' => 200));
+        $container->register('n3')->addTag('serializer.normalizer')->addTag('serializer.encoder');
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $expected = array(
+            new Reference('n1'),
+            new Reference('n2'),
+            new Reference('n3'),
+        );
+        $this->assertEquals($expected, $definition->getArgument(0));
+        $this->assertEquals($expected, $definition->getArgument(1));
+    }
+}

vendor/symfony/serializer/Tests/Encoder/ChainDecoderTest.php

@@ -0,0 +1,80 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\ChainDecoder;
+
+class ChainDecoderTest extends TestCase
+{
+    const FORMAT_1 = 'format1';
+    const FORMAT_2 = 'format2';
+    const FORMAT_3 = 'format3';
+
+    private $chainDecoder;
+    private $decoder1;
+    private $decoder2;
+
+    protected function setUp()
+    {
+        $this->decoder1 = $this
+            ->getMockBuilder('Symfony\Component\Serializer\Encoder\DecoderInterface')
+            ->getMock();
+
+        $this->decoder1
+            ->method('supportsDecoding')
+            ->will($this->returnValueMap(array(
+                array(self::FORMAT_1, array(), true),
+                array(self::FORMAT_2, array(), false),
+                array(self::FORMAT_3, array(), false),
+                array(self::FORMAT_3, array('foo' => 'bar'), true),
+            )));
+
+        $this->decoder2 = $this
+            ->getMockBuilder('Symfony\Component\Serializer\Encoder\DecoderInterface')
+            ->getMock();
+
+        $this->decoder2
+            ->method('supportsDecoding')
+            ->will($this->returnValueMap(array(
+                array(self::FORMAT_1, array(), false),
+                array(self::FORMAT_2, array(), true),
+                array(self::FORMAT_3, array(), false),
+            )));
+
+        $this->chainDecoder = new ChainDecoder(array($this->decoder1, $this->decoder2));
+    }
+
+    public function testSupportsDecoding()
+    {
+        $this->assertTrue($this->chainDecoder->supportsDecoding(self::FORMAT_1));
+        $this->assertTrue($this->chainDecoder->supportsDecoding(self::FORMAT_2));
+        $this->assertFalse($this->chainDecoder->supportsDecoding(self::FORMAT_3));
+        $this->assertTrue($this->chainDecoder->supportsDecoding(self::FORMAT_3, array('foo' => 'bar')));
+    }
+
+    public function testDecode()
+    {
+        $this->decoder1->expects($this->never())->method('decode');
+        $this->decoder2->expects($this->once())->method('decode');
+
+        $this->chainDecoder->decode('string_to_decode', self::FORMAT_2);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\RuntimeException
+     */
+    public function testDecodeUnsupportedFormat()
+    {
+        $this->chainDecoder->decode('string_to_decode', self::FORMAT_3);
+    }
+}

vendor/symfony/serializer/Tests/Encoder/ChainEncoderTest.php

@@ -0,0 +1,137 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\ChainEncoder;
+use Symfony\Component\Serializer\Encoder\EncoderInterface;
+use Symfony\Component\Serializer\Encoder\NormalizationAwareInterface;
+
+class ChainEncoderTest extends TestCase
+{
+    const FORMAT_1 = 'format1';
+    const FORMAT_2 = 'format2';
+    const FORMAT_3 = 'format3';
+
+    private $chainEncoder;
+    private $encoder1;
+    private $encoder2;
+
+    protected function setUp()
+    {
+        $this->encoder1 = $this
+            ->getMockBuilder('Symfony\Component\Serializer\Encoder\EncoderInterface')
+            ->getMock();
+
+        $this->encoder1
+            ->method('supportsEncoding')
+            ->will($this->returnValueMap(array(
+                array(self::FORMAT_1, array(), true),
+                array(self::FORMAT_2, array(), false),
+                array(self::FORMAT_3, array(), false),
+                array(self::FORMAT_3, array('foo' => 'bar'), true),
+            )));
+
+        $this->encoder2 = $this
+            ->getMockBuilder('Symfony\Component\Serializer\Encoder\EncoderInterface')
+            ->getMock();
+
+        $this->encoder2
+            ->method('supportsEncoding')
+            ->will($this->returnValueMap(array(
+                array(self::FORMAT_1, array(), false),
+                array(self::FORMAT_2, array(), true),
+                array(self::FORMAT_3, array(), false),
+            )));
+
+        $this->chainEncoder = new ChainEncoder(array($this->encoder1, $this->encoder2));
+    }
+
+    public function testSupportsEncoding()
+    {
+        $this->assertTrue($this->chainEncoder->supportsEncoding(self::FORMAT_1));
+        $this->assertTrue($this->chainEncoder->supportsEncoding(self::FORMAT_2));
+        $this->assertFalse($this->chainEncoder->supportsEncoding(self::FORMAT_3));
+        $this->assertTrue($this->chainEncoder->supportsEncoding(self::FORMAT_3, array('foo' => 'bar')));
+    }
+
+    public function testEncode()
+    {
+        $this->encoder1->expects($this->never())->method('encode');
+        $this->encoder2->expects($this->once())->method('encode');
+
+        $this->chainEncoder->encode(array('foo' => 123), self::FORMAT_2);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\RuntimeException
+     */
+    public function testEncodeUnsupportedFormat()
+    {
+        $this->chainEncoder->encode(array('foo' => 123), self::FORMAT_3);
+    }
+
+    public function testNeedsNormalizationBasic()
+    {
+        $this->assertTrue($this->chainEncoder->needsNormalization(self::FORMAT_1));
+        $this->assertTrue($this->chainEncoder->needsNormalization(self::FORMAT_2));
+    }
+
+    /**
+     * @dataProvider booleanProvider
+     */
+    public function testNeedsNormalizationChainNormalizationAware($bool)
+    {
+        $chainEncoder = $this
+            ->getMockBuilder('Symfony\Component\Serializer\Tests\Encoder\ChainNormalizationAwareEncoder')
+            ->getMock();
+
+        $chainEncoder->method('supportsEncoding')->willReturn(true);
+        $chainEncoder->method('needsNormalization')->willReturn($bool);
+
+        $sut = new ChainEncoder(array($chainEncoder));
+
+        $this->assertEquals($bool, $sut->needsNormalization(self::FORMAT_1));
+    }
+
+    public function testNeedsNormalizationNormalizationAware()
+    {
+        $encoder = new NormalizationAwareEncoder();
+        $sut = new ChainEncoder(array($encoder));
+
+        $this->assertFalse($sut->needsNormalization(self::FORMAT_1));
+    }
+
+    public function booleanProvider()
+    {
+        return array(
+            array(true),
+            array(false),
+        );
+    }
+}
+
+class ChainNormalizationAwareEncoder extends ChainEncoder implements NormalizationAwareInterface
+{
+}
+
+class NormalizationAwareEncoder implements EncoderInterface, NormalizationAwareInterface
+{
+    public function supportsEncoding($format)
+    {
+        return true;
+    }
+
+    public function encode($data, $format, array $context = array())
+    {
+    }
+}

vendor/symfony/serializer/Tests/Encoder/CsvEncoderTest.php

@@ -0,0 +1,294 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\CsvEncoder;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class CsvEncoderTest extends TestCase
+{
+    /**
+     * @var CsvEncoder
+     */
+    private $encoder;
+
+    protected function setUp()
+    {
+        $this->encoder = new CsvEncoder();
+    }
+
+    public function testSupportEncoding()
+    {
+        $this->assertTrue($this->encoder->supportsEncoding('csv'));
+        $this->assertFalse($this->encoder->supportsEncoding('foo'));
+    }
+
+    public function testEncode()
+    {
+        $value = array('foo' => 'hello', 'bar' => 'hey ho');
+
+        $this->assertEquals(<<<'CSV'
+foo,bar
+hello,"hey ho"
+
+CSV
+    , $this->encoder->encode($value, 'csv'));
+    }
+
+    public function testEncodeCollection()
+    {
+        $value = array(
+            array('foo' => 'hello', 'bar' => 'hey ho'),
+            array('foo' => 'hi', 'bar' => 'let\'s go'),
+        );
+
+        $this->assertEquals(<<<'CSV'
+foo,bar
+hello,"hey ho"
+hi,"let's go"
+
+CSV
+    , $this->encoder->encode($value, 'csv'));
+    }
+
+    public function testEncodePlainIndexedArray()
+    {
+        $this->assertEquals(<<<'CSV'
+0,1,2
+a,b,c
+
+CSV
+            , $this->encoder->encode(array('a', 'b', 'c'), 'csv'));
+    }
+
+    public function testEncodeNonArray()
+    {
+        $this->assertEquals(<<<'CSV'
+0
+foo
+
+CSV
+            , $this->encoder->encode('foo', 'csv'));
+    }
+
+    public function testEncodeNestedArrays()
+    {
+        $value = array('foo' => 'hello', 'bar' => array(
+            array('id' => 'yo', 1 => 'wesh'),
+            array('baz' => 'Halo', 'foo' => 'olá'),
+        ));
+
+        $this->assertEquals(<<<'CSV'
+foo,bar.0.id,bar.0.1,bar.1.baz,bar.1.foo
+hello,yo,wesh,Halo,olá
+
+CSV
+    , $this->encoder->encode($value, 'csv'));
+    }
+
+    public function testEncodeCustomSettings()
+    {
+        $this->encoder = new CsvEncoder(';', "'", '|', '-');
+
+        $value = array('a' => 'he\'llo', 'c' => array('d' => 'foo'));
+
+        $this->assertEquals(<<<'CSV'
+a;c-d
+'he''llo';foo
+
+CSV
+    , $this->encoder->encode($value, 'csv'));
+    }
+
+    public function testEncodeCustomSettingsPassedInContext()
+    {
+        $value = array('a' => 'he\'llo', 'c' => array('d' => 'foo'));
+
+        $this->assertSame(<<<'CSV'
+a;c-d
+'he''llo';foo
+
+CSV
+        , $this->encoder->encode($value, 'csv', array(
+            CsvEncoder::DELIMITER_KEY => ';',
+            CsvEncoder::ENCLOSURE_KEY => "'",
+            CsvEncoder::ESCAPE_CHAR_KEY => '|',
+            CsvEncoder::KEY_SEPARATOR_KEY => '-',
+        )));
+    }
+
+    public function testEncodeEmptyArray()
+    {
+        $this->assertEquals("\n\n", $this->encoder->encode(array(), 'csv'));
+        $this->assertEquals("\n\n", $this->encoder->encode(array(array()), 'csv'));
+    }
+
+    public function testEncodeVariableStructure()
+    {
+        $value = array(
+            array('a' => array('foo', 'bar')),
+            array('a' => array(), 'b' => 'baz'),
+            array('a' => array('bar', 'foo'), 'c' => 'pong'),
+        );
+        $csv = <<<CSV
+a.0,a.1,c,b
+foo,bar,,
+,,,baz
+bar,foo,pong,
+
+CSV;
+
+        $this->assertEquals($csv, $this->encoder->encode($value, 'csv'));
+    }
+
+    public function testEncodeCustomHeaders()
+    {
+        $context = array(
+            CsvEncoder::HEADERS_KEY => array(
+                'b',
+                'c',
+            ),
+        );
+        $value = array(
+            array('a' => 'foo', 'b' => 'bar'),
+        );
+        $csv = <<<CSV
+b,c,a
+bar,,foo
+
+CSV;
+
+        $this->assertEquals($csv, $this->encoder->encode($value, 'csv', $context));
+    }
+
+    public function testSupportsDecoding()
+    {
+        $this->assertTrue($this->encoder->supportsDecoding('csv'));
+        $this->assertFalse($this->encoder->supportsDecoding('foo'));
+    }
+
+    public function testDecode()
+    {
+        $expected = array('foo' => 'a', 'bar' => 'b');
+
+        $this->assertEquals($expected, $this->encoder->decode(<<<'CSV'
+foo,bar
+a,b
+CSV
+        , 'csv'));
+    }
+
+    public function testDecodeCollection()
+    {
+        $expected = array(
+            array('foo' => 'a', 'bar' => 'b'),
+            array('foo' => 'c', 'bar' => 'd'),
+            array('foo' => 'f'),
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode(<<<'CSV'
+foo,bar
+a,b
+c,d
+f
+
+CSV
+        , 'csv'));
+    }
+
+    public function testDecodeToManyRelation()
+    {
+        $expected = array(
+            array('foo' => 'bar', 'relations' => array(array('a' => 'b'), array('a' => 'b'))),
+            array('foo' => 'bat', 'relations' => array(array('a' => 'b'), array('a' => ''))),
+            array('foo' => 'bat', 'relations' => array(array('a' => 'b'))),
+            array('foo' => 'baz', 'relations' => array(array('a' => 'c'), array('a' => 'c'))),
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode(<<<'CSV'
+foo,relations.0.a,relations.1.a
+bar,b,b
+bat,b,
+bat,b
+baz,c,c
+CSV
+            , 'csv'));
+    }
+
+    public function testDecodeNestedArrays()
+    {
+        $expected = array(
+            array('foo' => 'a', 'bar' => array('baz' => array('bat' => 'b'))),
+            array('foo' => 'c', 'bar' => array('baz' => array('bat' => 'd'))),
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode(<<<'CSV'
+foo,bar.baz.bat
+a,b
+c,d
+CSV
+        , 'csv'));
+    }
+
+    public function testDecodeCustomSettings()
+    {
+        $this->encoder = new CsvEncoder(';', "'", '|', '-');
+
+        $expected = array('a' => 'hell\'o', 'bar' => array('baz' => 'b'));
+        $this->assertEquals($expected, $this->encoder->decode(<<<'CSV'
+a;bar-baz
+'hell''o';b;c
+CSV
+        , 'csv'));
+    }
+
+    public function testDecodeCustomSettingsPassedInContext()
+    {
+        $expected = array('a' => 'hell\'o', 'bar' => array('baz' => 'b'));
+        $this->assertEquals($expected, $this->encoder->decode(<<<'CSV'
+a;bar-baz
+'hell''o';b;c
+CSV
+        , 'csv', array(
+            CsvEncoder::DELIMITER_KEY => ';',
+            CsvEncoder::ENCLOSURE_KEY => "'",
+            CsvEncoder::ESCAPE_CHAR_KEY => '|',
+            CsvEncoder::KEY_SEPARATOR_KEY => '-',
+        )));
+    }
+
+    public function testDecodeMalformedCollection()
+    {
+        $expected = array(
+            array('foo' => 'a', 'bar' => 'b'),
+            array('foo' => 'c', 'bar' => 'd'),
+            array('foo' => 'f'),
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode(<<<'CSV'
+foo,bar
+a,b,e
+c,d,g,h
+f
+
+CSV
+            , 'csv'));
+    }
+
+    public function testDecodeEmptyArray()
+    {
+        $this->assertEquals(array(), $this->encoder->decode('', 'csv'));
+    }
+}

vendor/symfony/serializer/Tests/Encoder/JsonDecodeTest.php

@@ -0,0 +1,75 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\JsonDecode;
+use Symfony\Component\Serializer\Encoder\JsonEncoder;
+
+class JsonDecodeTest extends TestCase
+{
+    /** @var \Symfony\Component\Serializer\Encoder\JsonDecode */
+    private $decode;
+
+    protected function setUp()
+    {
+        $this->decode = new JsonDecode();
+    }
+
+    public function testSupportsDecoding()
+    {
+        $this->assertTrue($this->decode->supportsDecoding(JsonEncoder::FORMAT));
+        $this->assertFalse($this->decode->supportsDecoding('foobar'));
+    }
+
+    /**
+     * @dataProvider decodeProvider
+     */
+    public function testDecode($toDecode, $expected, $context)
+    {
+        $this->assertEquals(
+            $expected,
+            $this->decode->decode($toDecode, JsonEncoder::FORMAT, $context)
+        );
+    }
+
+    public function decodeProvider()
+    {
+        $stdClass = new \stdClass();
+        $stdClass->foo = 'bar';
+
+        $assoc = array('foo' => 'bar');
+
+        return array(
+            array('{"foo": "bar"}', $stdClass, array()),
+            array('{"foo": "bar"}', $assoc, array('json_decode_associative' => true)),
+        );
+    }
+
+    /**
+     * @requires function json_last_error_msg
+     * @dataProvider decodeProviderException
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDecodeWithException($value)
+    {
+        $this->decode->decode($value, JsonEncoder::FORMAT);
+    }
+
+    public function decodeProviderException()
+    {
+        return array(
+            array("{'foo': 'bar'}"),
+            array('kaboom!'),
+        );
+    }
+}

vendor/symfony/serializer/Tests/Encoder/JsonEncodeTest.php

@@ -0,0 +1,60 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\JsonEncode;
+use Symfony\Component\Serializer\Encoder\JsonEncoder;
+
+class JsonEncodeTest extends TestCase
+{
+    private $encoder;
+
+    protected function setUp()
+    {
+        $this->encode = new JsonEncode();
+    }
+
+    public function testSupportsEncoding()
+    {
+        $this->assertTrue($this->encode->supportsEncoding(JsonEncoder::FORMAT));
+        $this->assertFalse($this->encode->supportsEncoding('foobar'));
+    }
+
+    /**
+     * @dataProvider encodeProvider
+     */
+    public function testEncode($toEncode, $expected, $context)
+    {
+        $this->assertEquals(
+            $expected,
+            $this->encode->encode($toEncode, JsonEncoder::FORMAT, $context)
+        );
+    }
+
+    public function encodeProvider()
+    {
+        return array(
+            array(array(), '[]', array()),
+            array(array(), '{}', array('json_encode_options' => JSON_FORCE_OBJECT)),
+        );
+    }
+
+    /**
+     * @requires function json_last_error_msg
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testEncodeWithError()
+    {
+        $this->encode->encode("\xB1\x31", JsonEncoder::FORMAT);
+    }
+}

vendor/symfony/serializer/Tests/Encoder/JsonEncoderTest.php

@@ -0,0 +1,121 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\JsonEncoder;
+use Symfony\Component\Serializer\Normalizer\CustomNormalizer;
+use Symfony\Component\Serializer\Serializer;
+
+class JsonEncoderTest extends TestCase
+{
+    private $encoder;
+    private $serializer;
+
+    protected function setUp()
+    {
+        $this->encoder = new JsonEncoder();
+        $this->serializer = new Serializer(array(new CustomNormalizer()), array('json' => new JsonEncoder()));
+    }
+
+    public function testEncodeScalar()
+    {
+        $obj = new \stdClass();
+        $obj->foo = 'foo';
+
+        $expected = '{"foo":"foo"}';
+
+        $this->assertEquals($expected, $this->encoder->encode($obj, 'json'));
+    }
+
+    public function testComplexObject()
+    {
+        $obj = $this->getObject();
+
+        $expected = $this->getJsonSource();
+
+        $this->assertEquals($expected, $this->encoder->encode($obj, 'json'));
+    }
+
+    public function testOptions()
+    {
+        $context = array('json_encode_options' => JSON_NUMERIC_CHECK);
+
+        $arr = array();
+        $arr['foo'] = '3';
+
+        $expected = '{"foo":3}';
+
+        $this->assertEquals($expected, $this->serializer->serialize($arr, 'json', $context));
+
+        $arr = array();
+        $arr['foo'] = '3';
+
+        $expected = '{"foo":"3"}';
+
+        $this->assertEquals($expected, $this->serializer->serialize($arr, 'json'), 'Context should not be persistent');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testEncodeNotUtf8WithoutPartialOnError()
+    {
+        $arr = array(
+            'utf8' => 'Hello World!',
+            'notUtf8' => "\xb0\xd0\xb5\xd0",
+        );
+
+        $this->encoder->encode($arr, 'json');
+    }
+
+    public function testEncodeNotUtf8WithPartialOnError()
+    {
+        $context = array('json_encode_options' => JSON_PARTIAL_OUTPUT_ON_ERROR);
+
+        $arr = array(
+            'utf8' => 'Hello World!',
+            'notUtf8' => "\xb0\xd0\xb5\xd0",
+        );
+
+        $result = $this->encoder->encode($arr, 'json', $context);
+        $jsonLastError = json_last_error();
+
+        $this->assertSame(JSON_ERROR_UTF8, $jsonLastError);
+        $this->assertEquals('{"utf8":"Hello World!","notUtf8":null}', $result);
+
+        $this->assertEquals('0', $this->serializer->serialize(NAN, 'json', $context));
+    }
+
+    public function testDecodeFalseString()
+    {
+        $result = $this->encoder->decode('false', 'json');
+        $this->assertSame(JSON_ERROR_NONE, json_last_error());
+        $this->assertFalse($result);
+    }
+
+    protected function getJsonSource()
+    {
+        return '{"foo":"foo","bar":["a","b"],"baz":{"key":"val","key2":"val","A B":"bar","item":[{"title":"title1"},{"title":"title2"}],"Barry":{"FooBar":{"Baz":"Ed","@id":1}}},"qux":"1"}';
+    }
+
+    protected function getObject()
+    {
+        $obj = new \stdClass();
+        $obj->foo = 'foo';
+        $obj->bar = array('a', 'b');
+        $obj->baz = array('key' => 'val', 'key2' => 'val', 'A B' => 'bar', 'item' => array(array('title' => 'title1'), array('title' => 'title2')), 'Barry' => array('FooBar' => array('Baz' => 'Ed', '@id' => 1)));
+        $obj->qux = '1';
+
+        return $obj;
+    }
+}

vendor/symfony/serializer/Tests/Encoder/XmlEncoderTest.php

@@ -0,0 +1,733 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\XmlEncoder;
+use Symfony\Component\Serializer\Normalizer\CustomNormalizer;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Symfony\Component\Serializer\Serializer;
+use Symfony\Component\Serializer\Tests\Fixtures\Dummy;
+use Symfony\Component\Serializer\Tests\Fixtures\NormalizableTraversableDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\ScalarDummy;
+
+class XmlEncoderTest extends TestCase
+{
+    /**
+     * @var XmlEncoder
+     */
+    private $encoder;
+
+    private $exampleDateTimeString = '2017-02-19T15:16:08+0300';
+
+    protected function setUp()
+    {
+        $this->encoder = new XmlEncoder();
+        $serializer = new Serializer(array(new CustomNormalizer()), array('xml' => new XmlEncoder()));
+        $this->encoder->setSerializer($serializer);
+    }
+
+    public function testEncodeScalar()
+    {
+        $obj = new ScalarDummy();
+        $obj->xmlFoo = 'foo';
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response>foo</response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
+    }
+
+    public function testSetRootNodeName()
+    {
+        $obj = new ScalarDummy();
+        $obj->xmlFoo = 'foo';
+
+        $this->encoder->setRootNodeName('test');
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<test>foo</test>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
+    }
+
+    /**
+     * @expectedException        \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     * @expectedExceptionMessage Document types are not allowed.
+     */
+    public function testDocTypeIsNotAllowed()
+    {
+        $this->encoder->decode('<?xml version="1.0"?><!DOCTYPE foo><foo></foo>', 'foo');
+    }
+
+    public function testAttributes()
+    {
+        $obj = new ScalarDummy();
+        $obj->xmlFoo = array(
+            'foo-bar' => array(
+                '@id' => 1,
+                '@name' => 'Bar',
+            ),
+            'Foo' => array(
+                'Bar' => 'Test',
+                '@Type' => 'test',
+            ),
+            'föo_bär' => 'a',
+            'Bar' => array(1, 2, 3),
+            'a' => 'b',
+        );
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response>'.
+            '<foo-bar id="1" name="Bar"/>'.
+            '<Foo Type="test"><Bar>Test</Bar></Foo>'.
+            '<föo_bär>a</föo_bär>'.
+            '<Bar>1</Bar>'.
+            '<Bar>2</Bar>'.
+            '<Bar>3</Bar>'.
+            '<a>b</a>'.
+            '</response>'."\n";
+        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
+    }
+
+    public function testElementNameValid()
+    {
+        $obj = new ScalarDummy();
+        $obj->xmlFoo = array(
+            'foo-bar' => 'a',
+            'foo_bar' => 'a',
+            'föo_bär' => 'a',
+        );
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response>'.
+            '<foo-bar>a</foo-bar>'.
+            '<foo_bar>a</foo_bar>'.
+            '<föo_bär>a</föo_bär>'.
+            '</response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
+    }
+
+    public function testEncodeSimpleXML()
+    {
+        $xml = simplexml_load_string('<firstname>Peter</firstname>');
+        $array = array('person' => $xml);
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response><person><firstname>Peter</firstname></person></response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
+    }
+
+    public function testEncodeXmlAttributes()
+    {
+        $xml = simplexml_load_string('<firstname>Peter</firstname>');
+        $array = array('person' => $xml);
+
+        $expected = '<?xml version="1.1" encoding="utf-8" standalone="yes"?>'."\n".
+            '<response><person><firstname>Peter</firstname></person></response>'."\n";
+
+        $context = array(
+            'xml_version' => '1.1',
+            'xml_encoding' => 'utf-8',
+            'xml_standalone' => true,
+        );
+
+        $this->assertSame($expected, $this->encoder->encode($array, 'xml', $context));
+    }
+
+    public function testEncodeRemovingEmptyTags()
+    {
+        $array = array('person' => array('firstname' => 'Peter', 'lastname' => null));
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response><person><firstname>Peter</firstname></person></response>'."\n";
+
+        $context = array('remove_empty_tags' => true);
+
+        $this->assertSame($expected, $this->encoder->encode($array, 'xml', $context));
+    }
+
+    public function testEncodeNotRemovingEmptyTags()
+    {
+        $array = array('person' => array('firstname' => 'Peter', 'lastname' => null));
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response><person><firstname>Peter</firstname><lastname/></person></response>'."\n";
+
+        $this->assertSame($expected, $this->encoder->encode($array, 'xml'));
+    }
+
+    public function testContext()
+    {
+        $array = array('person' => array('name' => 'George Abitbol'));
+        $expected = <<<'XML'
+<?xml version="1.0"?>
+<response>
+  <person>
+    <name>George Abitbol</name>
+  </person>
+</response>
+
+XML;
+
+        $context = array(
+            'xml_format_output' => true,
+        );
+
+        $this->assertSame($expected, $this->encoder->encode($array, 'xml', $context));
+    }
+
+    public function testEncodeScalarRootAttributes()
+    {
+        $array = array(
+            '#' => 'Paul',
+            '@gender' => 'm',
+        );
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response gender="m">Paul</response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
+    }
+
+    public function testEncodeRootAttributes()
+    {
+        $array = array(
+            'firstname' => 'Paul',
+            '@gender' => 'm',
+        );
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response gender="m"><firstname>Paul</firstname></response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
+    }
+
+    public function testEncodeCdataWrapping()
+    {
+        $array = array(
+            'firstname' => 'Paul <or Me>',
+        );
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response><firstname><![CDATA[Paul <or Me>]]></firstname></response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
+    }
+
+    public function testEncodeScalarWithAttribute()
+    {
+        $array = array(
+            'person' => array('@gender' => 'M', '#' => 'Peter'),
+        );
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<response><person gender="M">Peter</person></response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
+    }
+
+    public function testDecodeScalar()
+    {
+        $source = '<?xml version="1.0"?>'."\n".
+            '<response>foo</response>'."\n";
+
+        $this->assertEquals('foo', $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeBigDigitAttributes()
+    {
+        $source = <<<XML
+<?xml version="1.0"?>
+<document index="182077241760011681341821060401202210011000045913000000017100">Name</document>
+XML;
+
+        $this->assertSame(array('@index' => 182077241760011681341821060401202210011000045913000000017100, '#' => 'Name'), $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeNegativeIntAttribute()
+    {
+        $source = <<<XML
+<?xml version="1.0"?>
+<document index="-1234">Name</document>
+XML;
+
+        $this->assertSame(array('@index' => -1234, '#' => 'Name'), $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeFloatAttribute()
+    {
+        $source = <<<XML
+<?xml version="1.0"?>
+<document index="-12.11">Name</document>
+XML;
+
+        $this->assertSame(array('@index' => -12.11, '#' => 'Name'), $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeNegativeFloatAttribute()
+    {
+        $source = <<<XML
+<?xml version="1.0"?>
+<document index="-12.11">Name</document>
+XML;
+
+        $this->assertSame(array('@index' => -12.11, '#' => 'Name'), $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testNoTypeCastAttribute()
+    {
+        $source = <<<XML
+<?xml version="1.0"?>
+<document a="018" b="-12.11">
+    <node a="018" b="-12.11"/>
+</document>
+XML;
+
+        $data = $this->encoder->decode($source, 'xml', array('xml_type_cast_attributes' => false));
+        $expected = array(
+            '@a' => '018',
+            '@b' => '-12.11',
+            'node' => array(
+                '@a' => '018',
+                '@b' => '-12.11',
+                '#' => '',
+            ),
+        );
+        $this->assertSame($expected, $data);
+    }
+
+    public function testEncode()
+    {
+        $source = $this->getXmlSource();
+        $obj = $this->getObject();
+
+        $this->assertEquals($source, $this->encoder->encode($obj, 'xml'));
+    }
+
+    public function testEncodeWithNamespace()
+    {
+        $source = $this->getNamespacedXmlSource();
+        $array = $this->getNamespacedArray();
+
+        $this->assertEquals($source, $this->encoder->encode($array, 'xml'));
+    }
+
+    public function testEncodeSerializerXmlRootNodeNameOption()
+    {
+        $options = array('xml_root_node_name' => 'test');
+        $this->encoder = new XmlEncoder();
+        $serializer = new Serializer(array(), array('xml' => new XmlEncoder()));
+        $this->encoder->setSerializer($serializer);
+
+        $array = array(
+            'person' => array('@gender' => 'M', '#' => 'Peter'),
+        );
+
+        $expected = '<?xml version="1.0"?>'."\n".
+            '<test><person gender="M">Peter</person></test>'."\n";
+
+        $this->assertEquals($expected, $serializer->serialize($array, 'xml', $options));
+    }
+
+    public function testEncodeTraversableWhenNormalizable()
+    {
+        $this->encoder = new XmlEncoder();
+        $serializer = new Serializer(array(new CustomNormalizer()), array('xml' => new XmlEncoder()));
+        $this->encoder->setSerializer($serializer);
+
+        $expected = <<<'XML'
+<?xml version="1.0"?>
+<response><foo>normalizedFoo</foo><bar>normalizedBar</bar></response>
+
+XML;
+
+        $this->assertEquals($expected, $serializer->serialize(new NormalizableTraversableDummy(), 'xml'));
+    }
+
+    public function testDecode()
+    {
+        $source = $this->getXmlSource();
+        $obj = $this->getObject();
+
+        $this->assertEquals(get_object_vars($obj), $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeCdataWrapping()
+    {
+        $expected = array(
+            'firstname' => 'Paul <or Me>',
+        );
+
+        $xml = '<?xml version="1.0"?>'."\n".
+            '<response><firstname><![CDATA[Paul <or Me>]]></firstname></response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->decode($xml, 'xml'));
+    }
+
+    public function testDecodeCdataWrappingAndWhitespace()
+    {
+        $expected = array(
+            'firstname' => 'Paul <or Me>',
+        );
+
+        $xml = '<?xml version="1.0"?>'."\n".
+            '<response><firstname>'."\n".
+                '<![CDATA[Paul <or Me>]]></firstname></response>'."\n";
+
+        $this->assertEquals($expected, $this->encoder->decode($xml, 'xml'));
+    }
+
+    public function testDecodeWithNamespace()
+    {
+        $source = $this->getNamespacedXmlSource();
+        $array = $this->getNamespacedArray();
+
+        $this->assertEquals($array, $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeScalarWithAttribute()
+    {
+        $source = '<?xml version="1.0"?>'."\n".
+            '<response><person gender="M">Peter</person></response>'."\n";
+
+        $expected = array(
+            'person' => array('@gender' => 'M', '#' => 'Peter'),
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeScalarRootAttributes()
+    {
+        $source = '<?xml version="1.0"?>'."\n".
+            '<person gender="M">Peter</person>'."\n";
+
+        $expected = array(
+            '#' => 'Peter',
+            '@gender' => 'M',
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeRootAttributes()
+    {
+        $source = '<?xml version="1.0"?>'."\n".
+            '<person gender="M"><firstname>Peter</firstname><lastname>Mac Calloway</lastname></person>'."\n";
+
+        $expected = array(
+            'firstname' => 'Peter',
+            'lastname' => 'Mac Calloway',
+            '@gender' => 'M',
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeArray()
+    {
+        $source = '<?xml version="1.0"?>'."\n".
+            '<response>'.
+            '<people>'.
+            '<person><firstname>Benjamin</firstname><lastname>Alexandre</lastname></person>'.
+            '<person><firstname>Damien</firstname><lastname>Clay</lastname></person>'.
+            '</people>'.
+            '</response>'."\n";
+
+        $expected = array(
+            'people' => array('person' => array(
+                array('firstname' => 'Benjamin', 'lastname' => 'Alexandre'),
+                array('firstname' => 'Damien', 'lastname' => 'Clay'),
+            )),
+        );
+
+        $this->assertEquals($expected, $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeXMLWithProcessInstruction()
+    {
+        $source = <<<'XML'
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="/xsl/xmlverbatimwrapper.xsl"?>
+    <?display table-view?>
+    <?sort alpha-ascending?>
+    <response>
+        <foo>foo</foo>
+        <?textinfo whitespace is allowed ?>
+        <bar>a</bar>
+        <bar>b</bar>
+        <baz>
+            <key>val</key>
+            <key2>val</key2>
+            <item key="A B">bar</item>
+            <item>
+                <title>title1</title>
+            </item>
+            <?item ignore-title ?>
+            <item>
+                <title>title2</title>
+            </item>
+            <Barry>
+                <FooBar id="1">
+                    <Baz>Ed</Baz>
+                </FooBar>
+            </Barry>
+        </baz>
+        <qux>1</qux>
+    </response>
+    <?instruction <value> ?>
+XML;
+        $obj = $this->getObject();
+
+        $this->assertEquals(get_object_vars($obj), $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeIgnoreWhiteSpace()
+    {
+        $source = <<<'XML'
+<?xml version="1.0"?>
+<people>
+    <person>
+        <firstname>Benjamin</firstname>
+        <lastname>Alexandre</lastname>
+    </person>
+    <person>
+        <firstname>Damien</firstname>
+        <lastname>Clay</lastname>
+    </person>
+</people>
+XML;
+        $expected = array('person' => array(
+            array('firstname' => 'Benjamin', 'lastname' => 'Alexandre'),
+            array('firstname' => 'Damien', 'lastname' => 'Clay'),
+        ));
+
+        $this->assertEquals($expected, $this->encoder->decode($source, 'xml'));
+    }
+
+    public function testDecodeWithoutItemHash()
+    {
+        $obj = new ScalarDummy();
+        $obj->xmlFoo = array(
+            'foo-bar' => array(
+                '@key' => 'value',
+                'item' => array('@key' => 'key', 'key-val' => 'val'),
+            ),
+            'Foo' => array(
+                'Bar' => 'Test',
+                '@Type' => 'test',
+            ),
+            'föo_bär' => 'a',
+            'Bar' => array(1, 2, 3),
+            'a' => 'b',
+        );
+        $expected = array(
+            'foo-bar' => array(
+                '@key' => 'value',
+                'key' => array('@key' => 'key', 'key-val' => 'val'),
+            ),
+            'Foo' => array(
+                'Bar' => 'Test',
+                '@Type' => 'test',
+            ),
+            'föo_bär' => 'a',
+            'Bar' => array(1, 2, 3),
+            'a' => 'b',
+        );
+        $xml = $this->encoder->encode($obj, 'xml');
+        $this->assertEquals($expected, $this->encoder->decode($xml, 'xml'));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDecodeInvalidXml()
+    {
+        $this->encoder->decode('<?xml version="1.0"?><invalid><xml>', 'xml');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testPreventsComplexExternalEntities()
+    {
+        $this->encoder->decode('<?xml version="1.0"?><!DOCTYPE scan[<!ENTITY test SYSTEM "php://filter/read=convert.base64-encode/resource=XmlEncoderTest.php">]><scan>&test;</scan>', 'xml');
+    }
+
+    public function testDecodeEmptyXml()
+    {
+        if (method_exists($this, 'expectException')) {
+            $this->expectException('Symfony\Component\Serializer\Exception\UnexpectedValueException');
+            $this->expectExceptionMessage('Invalid XML data, it can not be empty.');
+        } else {
+            $this->setExpectedException('Symfony\Component\Serializer\Exception\UnexpectedValueException', 'Invalid XML data, it can not be empty.');
+        }
+        $this->encoder->decode(' ', 'xml');
+    }
+
+    protected function getXmlSource()
+    {
+        return '<?xml version="1.0"?>'."\n".
+            '<response>'.
+            '<foo>foo</foo>'.
+            '<bar>a</bar><bar>b</bar>'.
+            '<baz><key>val</key><key2>val</key2><item key="A B">bar</item>'.
+            '<item><title>title1</title></item><item><title>title2</title></item>'.
+            '<Barry><FooBar id="1"><Baz>Ed</Baz></FooBar></Barry></baz>'.
+            '<qux>1</qux>'.
+            '</response>'."\n";
+    }
+
+    protected function getNamespacedXmlSource()
+    {
+        return '<?xml version="1.0"?>'."\n".
+            '<response xmlns="http://www.w3.org/2005/Atom" xmlns:app="http://www.w3.org/2007/app" xmlns:media="http://search.yahoo.com/mrss/" xmlns:gd="http://schemas.google.com/g/2005" xmlns:yt="http://gdata.youtube.com/schemas/2007">'.
+            '<qux>1</qux>'.
+            '<app:foo>foo</app:foo>'.
+            '<yt:bar>a</yt:bar><yt:bar>b</yt:bar>'.
+            '<media:baz><media:key>val</media:key><media:key2>val</media:key2><item key="A B">bar</item>'.
+            '<item><title>title1</title></item><item><title>title2</title></item>'.
+            '<Barry size="large"><FooBar gd:id="1"><Baz>Ed</Baz></FooBar></Barry></media:baz>'.
+            '</response>'."\n";
+    }
+
+    protected function getNamespacedArray()
+    {
+        return array(
+            '@xmlns' => 'http://www.w3.org/2005/Atom',
+            '@xmlns:app' => 'http://www.w3.org/2007/app',
+            '@xmlns:media' => 'http://search.yahoo.com/mrss/',
+            '@xmlns:gd' => 'http://schemas.google.com/g/2005',
+            '@xmlns:yt' => 'http://gdata.youtube.com/schemas/2007',
+            'qux' => '1',
+            'app:foo' => 'foo',
+            'yt:bar' => array('a', 'b'),
+            'media:baz' => array(
+                'media:key' => 'val',
+                'media:key2' => 'val',
+                'A B' => 'bar',
+                'item' => array(
+                    array(
+                        'title' => 'title1',
+                    ),
+                    array(
+                        'title' => 'title2',
+                    ),
+                ),
+                'Barry' => array(
+                    '@size' => 'large',
+                    'FooBar' => array(
+                        'Baz' => 'Ed',
+                        '@gd:id' => 1,
+                    ),
+                ),
+            ),
+        );
+    }
+
+    protected function getObject()
+    {
+        $obj = new Dummy();
+        $obj->foo = 'foo';
+        $obj->bar = array('a', 'b');
+        $obj->baz = array('key' => 'val', 'key2' => 'val', 'A B' => 'bar', 'item' => array(array('title' => 'title1'), array('title' => 'title2')), 'Barry' => array('FooBar' => array('Baz' => 'Ed', '@id' => 1)));
+        $obj->qux = '1';
+
+        return $obj;
+    }
+
+    public function testEncodeXmlWithBoolValue()
+    {
+        $expectedXml = <<<'XML'
+<?xml version="1.0"?>
+<response><foo>1</foo><bar>0</bar></response>
+
+XML;
+
+        $actualXml = $this->encoder->encode(array('foo' => true, 'bar' => false), 'xml');
+
+        $this->assertEquals($expectedXml, $actualXml);
+    }
+
+    public function testEncodeXmlWithDateTimeObjectValue()
+    {
+        $xmlEncoder = $this->createXmlEncoderWithDateTimeNormalizer();
+
+        $actualXml = $xmlEncoder->encode(array('dateTime' => new \DateTime($this->exampleDateTimeString)), 'xml');
+
+        $this->assertEquals($this->createXmlWithDateTime(), $actualXml);
+    }
+
+    public function testEncodeXmlWithDateTimeObjectField()
+    {
+        $xmlEncoder = $this->createXmlEncoderWithDateTimeNormalizer();
+
+        $actualXml = $xmlEncoder->encode(array('foo' => array('@dateTime' => new \DateTime($this->exampleDateTimeString))), 'xml');
+
+        $this->assertEquals($this->createXmlWithDateTimeField(), $actualXml);
+    }
+
+    /**
+     * @return XmlEncoder
+     */
+    private function createXmlEncoderWithDateTimeNormalizer()
+    {
+        $encoder = new XmlEncoder();
+        $serializer = new Serializer(array($this->createMockDateTimeNormalizer()), array('xml' => new XmlEncoder()));
+        $encoder->setSerializer($serializer);
+
+        return $encoder;
+    }
+
+    /**
+     * @return \PHPUnit_Framework_MockObject_MockObject|NormalizerInterface
+     */
+    private function createMockDateTimeNormalizer()
+    {
+        $mock = $this->getMockBuilder('\Symfony\Component\Serializer\Normalizer\CustomNormalizer')->getMock();
+
+        $mock
+            ->expects($this->once())
+            ->method('normalize')
+            ->with(new \DateTime($this->exampleDateTimeString), 'xml', array())
+            ->willReturn($this->exampleDateTimeString);
+
+        $mock
+            ->expects($this->once())
+            ->method('supportsNormalization')
+            ->with(new \DateTime($this->exampleDateTimeString), 'xml')
+            ->willReturn(true);
+
+        return $mock;
+    }
+
+    /**
+     * @return string
+     */
+    private function createXmlWithDateTime()
+    {
+        return sprintf('<?xml version="1.0"?>
+<response><dateTime>%s</dateTime></response>
+', $this->exampleDateTimeString);
+    }
+
+    /**
+     * @return string
+     */
+    private function createXmlWithDateTimeField()
+    {
+        return sprintf('<?xml version="1.0"?>
+<response><foo dateTime="%s"/></response>
+', $this->exampleDateTimeString);
+    }
+}

vendor/symfony/serializer/Tests/Encoder/YamlEncoderTest.php

@@ -0,0 +1,71 @@
+<?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\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\YamlEncoder;
+use Symfony\Component\Yaml\Dumper;
+use Symfony\Component\Yaml\Parser;
+use Symfony\Component\Yaml\Yaml;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class YamlEncoderTest extends TestCase
+{
+    public function testEncode()
+    {
+        $encoder = new YamlEncoder();
+
+        $this->assertEquals('foo', $encoder->encode('foo', 'yaml'));
+        $this->assertEquals('{ foo: 1 }', $encoder->encode(array('foo' => 1), 'yaml'));
+    }
+
+    public function testSupportsEncoding()
+    {
+        $encoder = new YamlEncoder();
+
+        $this->assertTrue($encoder->supportsEncoding('yaml'));
+        $this->assertFalse($encoder->supportsEncoding('json'));
+    }
+
+    public function testDecode()
+    {
+        $encoder = new YamlEncoder();
+
+        $this->assertEquals('foo', $encoder->decode('foo', 'yaml'));
+        $this->assertEquals(array('foo' => 1), $encoder->decode('{ foo: 1 }', 'yaml'));
+    }
+
+    public function testSupportsDecoding()
+    {
+        $encoder = new YamlEncoder();
+
+        $this->assertTrue($encoder->supportsDecoding('yaml'));
+        $this->assertFalse($encoder->supportsDecoding('json'));
+    }
+
+    public function testContext()
+    {
+        $encoder = new YamlEncoder(new Dumper(), new Parser(), array('yaml_inline' => 1, 'yaml_indent' => 4, 'yaml_flags' => Yaml::DUMP_OBJECT | Yaml::PARSE_OBJECT));
+
+        $obj = new \stdClass();
+        $obj->bar = 2;
+
+        $legacyTag = "    foo: !php/object:O:8:\"stdClass\":1:{s:3:\"bar\";i:2;}\n";
+        $spacedTag = "    foo: !php/object 'O:8:\"stdClass\":1:{s:3:\"bar\";i:2;}'\n";
+        $this->assertThat($encoder->encode(array('foo' => $obj), 'yaml'), $this->logicalOr($this->equalTo($legacyTag), $this->equalTo($spacedTag)));
+        $this->assertEquals('  { foo: null }', $encoder->encode(array('foo' => $obj), 'yaml', array('yaml_inline' => 0, 'yaml_indent' => 2, 'yaml_flags' => 0)));
+        $this->assertEquals(array('foo' => $obj), $encoder->decode("foo: !php/object 'O:8:\"stdClass\":1:{s:3:\"bar\";i:2;}'", 'yaml'));
+        $this->assertEquals(array('foo' => null), $encoder->decode("foo: !php/object 'O:8:\"stdClass\":1:{s:3:\"bar\";i:2;}'", 'yaml', array('yaml_flags' => 0)));
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/AbstractNormalizerDummy.php

@@ -0,0 +1,60 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
+
+/**
+ * Provides a dummy Normalizer which extends the AbstractNormalizer.
+ *
+ * @author Konstantin S. M. Möllers <ksm.moellers@gmail.com>
+ */
+class AbstractNormalizerDummy extends AbstractNormalizer
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getAllowedAttributes($classOrObject, array $context, $attributesAsString = false)
+    {
+        return parent::getAllowedAttributes($classOrObject, $context, $attributesAsString);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function normalize($object, $format = null, array $context = array())
+    {
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsNormalization($data, $format = null)
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function denormalize($data, $class, $format = null, array $context = array())
+    {
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsDenormalization($data, $type, $format = null)
+    {
+        return true;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/CircularReferenceDummy.php

@@ -0,0 +1,23 @@
+<?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\Fixtures;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class CircularReferenceDummy
+{
+    public function getMe()
+    {
+        return $this;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/DenormalizableDummy.php

@@ -0,0 +1,22 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Normalizer\DenormalizableInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+class DenormalizableDummy implements DenormalizableInterface
+{
+    public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
+    {
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/Dummy.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Serializer\Tests\Fixtures;
+
+use Symfony\Component\Serializer\Normalizer\DenormalizableInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizableInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+class Dummy implements NormalizableInterface, DenormalizableInterface
+{
+    public $foo;
+    public $bar;
+    public $baz;
+    public $qux;
+
+    public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array())
+    {
+        return array(
+            'foo' => $this->foo,
+            'bar' => $this->bar,
+            'baz' => $this->baz,
+            'qux' => $this->qux,
+        );
+    }
+
+    public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
+    {
+        $this->foo = $data['foo'];
+        $this->bar = $data['bar'];
+        $this->baz = $data['baz'];
+        $this->qux = $data['qux'];
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/GroupDummy.php

@@ -0,0 +1,80 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Annotation\Groups;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class GroupDummy extends GroupDummyParent implements GroupDummyInterface
+{
+    /**
+     * @Groups({"a"})
+     */
+    private $foo;
+    /**
+     * @Groups({"b", "c", "name_converter"})
+     */
+    protected $bar;
+    private $fooBar;
+    private $symfony;
+
+    /**
+     * @Groups({"b"})
+     */
+    public function setBar($bar)
+    {
+        $this->bar = $bar;
+    }
+
+    /**
+     * @Groups({"c"})
+     */
+    public function getBar()
+    {
+        return $this->bar;
+    }
+
+    public function setFoo($foo)
+    {
+        $this->foo = $foo;
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    public function setFooBar($fooBar)
+    {
+        $this->fooBar = $fooBar;
+    }
+
+    /**
+     * @Groups({"a", "b", "name_converter"})
+     */
+    public function isFooBar()
+    {
+        return $this->fooBar;
+    }
+
+    public function setSymfony($symfony)
+    {
+        $this->symfony = $symfony;
+    }
+
+    public function getSymfony()
+    {
+        return $this->symfony;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/GroupDummyChild.php

@@ -0,0 +1,33 @@
+<?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\Fixtures;
+
+class GroupDummyChild extends GroupDummy
+{
+    private $baz;
+
+    /**
+     * @return mixed
+     */
+    public function getBaz()
+    {
+        return $this->baz;
+    }
+
+    /**
+     * @param mixed $baz
+     */
+    public function setBaz($baz)
+    {
+        $this->baz = $baz;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/GroupDummyInterface.php

@@ -0,0 +1,25 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Annotation\Groups;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+interface GroupDummyInterface
+{
+    /**
+     * @Groups({"a", "name_converter"})
+     */
+    public function getSymfony();
+}

vendor/symfony/serializer/Tests/Fixtures/GroupDummyParent.php

@@ -0,0 +1,49 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Annotation\Groups;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class GroupDummyParent
+{
+    /**
+     * @Groups({"a"})
+     */
+    private $kevin;
+    private $coopTilleuls;
+
+    public function setKevin($kevin)
+    {
+        $this->kevin = $kevin;
+    }
+
+    public function getKevin()
+    {
+        return $this->kevin;
+    }
+
+    public function setCoopTilleuls($coopTilleuls)
+    {
+        $this->coopTilleuls = $coopTilleuls;
+    }
+
+    /**
+     * @Groups({"a", "b"})
+     */
+    public function getCoopTilleuls()
+    {
+        return $this->coopTilleuls;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/JsonSerializableDummy.php

@@ -0,0 +1,25 @@
+<?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\Fixtures;
+
+class JsonSerializableDummy implements \JsonSerializable
+{
+    public function jsonSerialize()
+    {
+        return array(
+            'foo' => 'a',
+            'bar' => 'b',
+            'baz' => 'c',
+            'qux' => $this,
+        );
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/MaxDepthDummy.php

@@ -0,0 +1,45 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Annotation\MaxDepth;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class MaxDepthDummy
+{
+    /**
+     * @MaxDepth(2)
+     */
+    public $foo;
+
+    public $bar;
+
+    /**
+     * @var self
+     */
+    public $child;
+
+    /**
+     * @MaxDepth(3)
+     */
+    public function getBar()
+    {
+        return $this->bar;
+    }
+
+    public function getChild()
+    {
+        return $this->child;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/NormalizableTraversableDummy.php

@@ -0,0 +1,36 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Normalizer\DenormalizableInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizableInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+class NormalizableTraversableDummy extends TraversableDummy implements NormalizableInterface, DenormalizableInterface
+{
+    public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array())
+    {
+        return array(
+            'foo' => 'normalizedFoo',
+            'bar' => 'normalizedBar',
+        );
+    }
+
+    public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
+    {
+        return array(
+            'foo' => 'denormalizedFoo',
+            'bar' => 'denormalizedBar',
+        );
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/NullableConstructorArgumentDummy.php

@@ -0,0 +1,32 @@
+<?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\Fixtures;
+
+class NullableConstructorArgumentDummy
+{
+    private $foo;
+
+    public function __construct(?\stdClass $foo)
+    {
+        $this->foo = $foo;
+    }
+
+    public function setFoo($foo)
+    {
+        $this->foo = 'this setter should not be called when using the constructor argument';
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/PropertyCircularReferenceDummy.php

@@ -0,0 +1,25 @@
+<?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\Fixtures;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class PropertyCircularReferenceDummy
+{
+    public $me;
+
+    public function __construct()
+    {
+        $this->me = $this;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/PropertySiblingHolder.php

@@ -0,0 +1,39 @@
+<?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\Fixtures;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class PropertySiblingHolder
+{
+    public $sibling0;
+    public $sibling1;
+    public $sibling2;
+
+    public function __construct()
+    {
+        $sibling = new PropertySibling();
+
+        $this->sibling0 = $sibling;
+        $this->sibling1 = $sibling;
+        $this->sibling2 = $sibling;
+    }
+}
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class PropertySibling
+{
+    public $coopTilleuls = 'Les-Tilleuls.coop';
+}

vendor/symfony/serializer/Tests/Fixtures/ProxyDummy.php

@@ -0,0 +1,19 @@
+<?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\Fixtures;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class ProxyDummy extends ToBeProxyfiedDummy
+{
+}

vendor/symfony/serializer/Tests/Fixtures/ScalarDummy.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\Fixtures;
+
+use Symfony\Component\Serializer\Normalizer\DenormalizableInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizableInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+class ScalarDummy implements NormalizableInterface, DenormalizableInterface
+{
+    public $foo;
+    public $xmlFoo;
+
+    public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array())
+    {
+        return 'xml' === $format ? $this->xmlFoo : $this->foo;
+    }
+
+    public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array())
+    {
+        if ('xml' === $format) {
+            $this->xmlFoo = $data;
+        } else {
+            $this->foo = $data;
+        }
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/SiblingHolder.php

@@ -0,0 +1,57 @@
+<?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\Fixtures;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class SiblingHolder
+{
+    private $sibling0;
+    private $sibling1;
+    private $sibling2;
+
+    public function __construct()
+    {
+        $sibling = new Sibling();
+
+        $this->sibling0 = $sibling;
+        $this->sibling1 = $sibling;
+        $this->sibling2 = $sibling;
+    }
+
+    public function getSibling0()
+    {
+        return $this->sibling0;
+    }
+
+    public function getSibling1()
+    {
+        return $this->sibling1;
+    }
+
+    public function getSibling2()
+    {
+        return $this->sibling2;
+    }
+}
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class Sibling
+{
+    public function getCoopTilleuls()
+    {
+        return 'Les-Tilleuls.coop';
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/StaticConstructorDummy.php

@@ -0,0 +1,31 @@
+<?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\Fixtures;
+
+class StaticConstructorDummy
+{
+    public $foo;
+    public $bar;
+    public $quz;
+
+    public static function create($foo)
+    {
+        $dummy = new self();
+        $dummy->quz = $foo;
+
+        return $dummy;
+    }
+
+    private function __construct()
+    {
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/StaticConstructorNormalizer.php

@@ -0,0 +1,32 @@
+<?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\Fixtures;
+
+use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
+
+/**
+ * @author Guilhem N. <egetick@gmail.com>
+ */
+class StaticConstructorNormalizer extends ObjectNormalizer
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function getConstructor(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes)
+    {
+        if (is_a($class, StaticConstructorDummy::class, true)) {
+            return new \ReflectionMethod($class, 'create');
+        }
+
+        return parent::getConstructor($data, $class, $context, $reflectionClass, $allowedAttributes);
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/ToBeProxyfiedDummy.php

@@ -0,0 +1,30 @@
+<?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\Fixtures;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class ToBeProxyfiedDummy
+{
+    private $foo;
+
+    public function setFoo($foo)
+    {
+        $this->foo = $foo;
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/TraversableDummy.php

@@ -0,0 +1,23 @@
+<?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\Fixtures;
+
+class TraversableDummy implements \IteratorAggregate
+{
+    public $foo = 'foo';
+    public $bar = 'bar';
+
+    public function getIterator()
+    {
+        return new \ArrayIterator(get_object_vars($this));
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/VariadicConstructorArgsDummy.php

@@ -0,0 +1,27 @@
+<?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\Fixtures;
+
+class VariadicConstructorArgsDummy
+{
+    private $foo;
+
+    public function __construct(...$foo)
+    {
+        $this->foo = $foo;
+    }
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+}

vendor/symfony/serializer/Tests/Fixtures/invalid-mapping.yml

@@ -0,0 +1 @@
+foo

vendor/symfony/serializer/Tests/Fixtures/serialization.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" ?>
+
+<serializer xmlns="http://symfony.com/schema/dic/serializer-mapping"
+                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                    xsi:schemaLocation="http://symfony.com/schema/dic/serializer-mapping http://symfony.com/schema/dic/serializer-mapping/serializer-mapping-1.0.xsd">
+
+    <class name="Symfony\Component\Serializer\Tests\Fixtures\GroupDummy">
+        <attribute name="foo">
+            <group>group1</group>
+            <group>group2</group>
+        </attribute>
+
+        <attribute name="bar">
+            <group>group2</group>
+        </attribute>
+    </class>
+
+    <class name="Symfony\Component\Serializer\Tests\Fixtures\MaxDepthDummy">
+        <attribute name="foo" max-depth="2" />
+        <attribute name="bar" max-depth="3" />
+    </class>
+
+</serializer>

vendor/symfony/serializer/Tests/Fixtures/serialization.yml

@@ -0,0 +1,12 @@
+'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy':
+  attributes:
+    foo:
+      groups: ['group1', 'group2']
+    bar:
+      groups: ['group2']
+'Symfony\Component\Serializer\Tests\Fixtures\MaxDepthDummy':
+  attributes:
+    foo:
+      max_depth: 2
+    bar:
+      max_depth: 3

vendor/symfony/serializer/Tests/Fixtures/test.txt

@@ -0,0 +1 @@
+Kévin Dunglas

vendor/symfony/serializer/Tests/Mapping/AttributeMetadataTest.php

@@ -0,0 +1,79 @@
+<?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\Mapping;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Mapping\AttributeMetadata;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class AttributeMetadataTest extends TestCase
+{
+    public function testInterface()
+    {
+        $attributeMetadata = new AttributeMetadata('name');
+        $this->assertInstanceOf('Symfony\Component\Serializer\Mapping\AttributeMetadataInterface', $attributeMetadata);
+    }
+
+    public function testGetName()
+    {
+        $attributeMetadata = new AttributeMetadata('name');
+        $this->assertEquals('name', $attributeMetadata->getName());
+    }
+
+    public function testGroups()
+    {
+        $attributeMetadata = new AttributeMetadata('group');
+        $attributeMetadata->addGroup('a');
+        $attributeMetadata->addGroup('a');
+        $attributeMetadata->addGroup('b');
+
+        $this->assertEquals(array('a', 'b'), $attributeMetadata->getGroups());
+    }
+
+    public function testMaxDepth()
+    {
+        $attributeMetadata = new AttributeMetadata('name');
+        $attributeMetadata->setMaxDepth(69);
+
+        $this->assertEquals(69, $attributeMetadata->getMaxDepth());
+    }
+
+    public function testMerge()
+    {
+        $attributeMetadata1 = new AttributeMetadata('a1');
+        $attributeMetadata1->addGroup('a');
+        $attributeMetadata1->addGroup('b');
+
+        $attributeMetadata2 = new AttributeMetadata('a2');
+        $attributeMetadata2->addGroup('a');
+        $attributeMetadata2->addGroup('c');
+        $attributeMetadata2->setMaxDepth(2);
+
+        $attributeMetadata1->merge($attributeMetadata2);
+
+        $this->assertEquals(array('a', 'b', 'c'), $attributeMetadata1->getGroups());
+        $this->assertEquals(2, $attributeMetadata1->getMaxDepth());
+    }
+
+    public function testSerialize()
+    {
+        $attributeMetadata = new AttributeMetadata('attribute');
+        $attributeMetadata->addGroup('a');
+        $attributeMetadata->addGroup('b');
+        $attributeMetadata->setMaxDepth(3);
+
+        $serialized = serialize($attributeMetadata);
+        $this->assertEquals($attributeMetadata, unserialize($serialized));
+    }
+}

vendor/symfony/serializer/Tests/Mapping/ClassMetadataTest.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\Mapping;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Mapping\ClassMetadata;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class ClassMetadataTest extends TestCase
+{
+    public function testInterface()
+    {
+        $classMetadata = new ClassMetadata('name');
+        $this->assertInstanceOf('Symfony\Component\Serializer\Mapping\ClassMetadataInterface', $classMetadata);
+    }
+
+    public function testAttributeMetadata()
+    {
+        $classMetadata = new ClassMetadata('c');
+
+        $a1 = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\AttributeMetadataInterface')->getMock();
+        $a1->method('getName')->willReturn('a1');
+
+        $a2 = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\AttributeMetadataInterface')->getMock();
+        $a2->method('getName')->willReturn('a2');
+
+        $classMetadata->addAttributeMetadata($a1);
+        $classMetadata->addAttributeMetadata($a2);
+
+        $this->assertEquals(array('a1' => $a1, 'a2' => $a2), $classMetadata->getAttributesMetadata());
+    }
+
+    public function testMerge()
+    {
+        $classMetadata1 = new ClassMetadata('c1');
+        $classMetadata2 = new ClassMetadata('c2');
+
+        $ac1 = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\AttributeMetadataInterface')->getMock();
+        $ac1->method('getName')->willReturn('a1');
+        $ac1->method('getGroups')->willReturn(array('a', 'b'));
+
+        $ac2 = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\AttributeMetadataInterface')->getMock();
+        $ac2->method('getName')->willReturn('a1');
+        $ac2->method('getGroups')->willReturn(array('b', 'c'));
+
+        $classMetadata1->addAttributeMetadata($ac1);
+        $classMetadata2->addAttributeMetadata($ac2);
+
+        $classMetadata1->merge($classMetadata2);
+
+        $ac1->method('getGroups')->willReturn('a', 'b', 'c');
+
+        $this->assertEquals(array('a1' => $ac1), $classMetadata2->getAttributesMetadata());
+    }
+
+    public function testSerialize()
+    {
+        $classMetadata = new ClassMetadata('a');
+
+        $a1 = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\AttributeMetadataInterface')->getMock();
+        $a1->method('getName')->willReturn('b1');
+
+        $a2 = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\AttributeMetadataInterface')->getMock();
+        $a2->method('getName')->willReturn('b2');
+
+        $classMetadata->addAttributeMetadata($a1);
+        $classMetadata->addAttributeMetadata($a2);
+
+        $serialized = serialize($classMetadata);
+        $this->assertEquals($classMetadata, unserialize($serialized));
+    }
+}

vendor/symfony/serializer/Tests/Mapping/Factory/CacheMetadataFactoryTest.php

@@ -0,0 +1,68 @@
+<?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\Mapping\Factory;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Serializer\Mapping\ClassMetadata;
+use Symfony\Component\Serializer\Mapping\Factory\CacheClassMetadataFactory;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
+use Symfony\Component\Serializer\Tests\Fixtures\Dummy;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class CacheMetadataFactoryTest extends TestCase
+{
+    public function testGetMetadataFor()
+    {
+        $metadata = new ClassMetadata(Dummy::class);
+
+        $decorated = $this->getMockBuilder(ClassMetadataFactoryInterface::class)->getMock();
+        $decorated
+            ->expects($this->once())
+            ->method('getMetadataFor')
+            ->will($this->returnValue($metadata))
+        ;
+
+        $factory = new CacheClassMetadataFactory($decorated, new ArrayAdapter());
+
+        $this->assertEquals($metadata, $factory->getMetadataFor(Dummy::class));
+        // The second call should retrieve the value from the cache
+        $this->assertEquals($metadata, $factory->getMetadataFor(Dummy::class));
+    }
+
+    public function testHasMetadataFor()
+    {
+        $decorated = $this->getMockBuilder(ClassMetadataFactoryInterface::class)->getMock();
+        $decorated
+            ->expects($this->once())
+            ->method('hasMetadataFor')
+            ->will($this->returnValue(true))
+        ;
+
+        $factory = new CacheClassMetadataFactory($decorated, new ArrayAdapter());
+
+        $this->assertTrue($factory->hasMetadataFor(Dummy::class));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     */
+    public function testInvalidClassThrowsException()
+    {
+        $decorated = $this->getMockBuilder(ClassMetadataFactoryInterface::class)->getMock();
+        $factory = new CacheClassMetadataFactory($decorated, new ArrayAdapter());
+
+        $factory->getMetadataFor('Not\Exist');
+    }
+}

vendor/symfony/serializer/Tests/Mapping/Factory/ClassMetadataFactoryTest.php

@@ -0,0 +1,79 @@
+<?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\Mapping\Factory;
+
+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\Mapping\Loader\LoaderChain;
+use Symfony\Component\Serializer\Tests\Mapping\TestClassMetadataFactory;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class ClassMetadataFactoryTest extends TestCase
+{
+    public function testInterface()
+    {
+        $classMetadata = new ClassMetadataFactory(new LoaderChain(array()));
+        $this->assertInstanceOf('Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface', $classMetadata);
+    }
+
+    public function testGetMetadataFor()
+    {
+        $factory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $classMetadata = $factory->getMetadataFor('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+
+        $this->assertEquals(TestClassMetadataFactory::createClassMetadata(true, true), $classMetadata);
+    }
+
+    public function testHasMetadataFor()
+    {
+        $factory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $this->assertTrue($factory->hasMetadataFor('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy'));
+        $this->assertTrue($factory->hasMetadataFor('Symfony\Component\Serializer\Tests\Fixtures\GroupDummyParent'));
+        $this->assertTrue($factory->hasMetadataFor('Symfony\Component\Serializer\Tests\Fixtures\GroupDummyInterface'));
+        $this->assertFalse($factory->hasMetadataFor('Dunglas\Entity'));
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testCacheExists()
+    {
+        $cache = $this->getMockBuilder('Doctrine\Common\Cache\Cache')->getMock();
+        $cache
+            ->expects($this->once())
+            ->method('fetch')
+            ->will($this->returnValue('foo'))
+        ;
+
+        $factory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()), $cache);
+        $this->assertEquals('foo', $factory->getMetadataFor('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy'));
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testCacheNotExists()
+    {
+        $cache = $this->getMockBuilder('Doctrine\Common\Cache\Cache')->getMock();
+        $cache->method('fetch')->will($this->returnValue(false));
+        $cache->method('save');
+
+        $factory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()), $cache);
+        $metadata = $factory->getMetadataFor('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+
+        $this->assertEquals(TestClassMetadataFactory::createClassMetadata(true, true), $metadata);
+    }
+}

vendor/symfony/serializer/Tests/Mapping/Loader/AnnotationLoaderTest.php

@@ -0,0 +1,77 @@
+<?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\Mapping\Loader;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Mapping\ClassMetadata;
+use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
+use Symfony\Component\Serializer\Tests\Mapping\TestClassMetadataFactory;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class AnnotationLoaderTest extends TestCase
+{
+    /**
+     * @var AnnotationLoader
+     */
+    private $loader;
+
+    protected function setUp()
+    {
+        $this->loader = new AnnotationLoader(new AnnotationReader());
+    }
+
+    public function testInterface()
+    {
+        $this->assertInstanceOf('Symfony\Component\Serializer\Mapping\Loader\LoaderInterface', $this->loader);
+    }
+
+    public function testLoadClassMetadataReturnsTrueIfSuccessful()
+    {
+        $classMetadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+
+        $this->assertTrue($this->loader->loadClassMetadata($classMetadata));
+    }
+
+    public function testLoadGroups()
+    {
+        $classMetadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+        $this->loader->loadClassMetadata($classMetadata);
+
+        $this->assertEquals(TestClassMetadataFactory::createClassMetadata(), $classMetadata);
+    }
+
+    public function testLoadMaxDepth()
+    {
+        $classMetadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\MaxDepthDummy');
+        $this->loader->loadClassMetadata($classMetadata);
+
+        $attributesMetadata = $classMetadata->getAttributesMetadata();
+        $this->assertEquals(2, $attributesMetadata['foo']->getMaxDepth());
+        $this->assertEquals(3, $attributesMetadata['bar']->getMaxDepth());
+    }
+
+    public function testLoadClassMetadataAndMerge()
+    {
+        $classMetadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+        $parentClassMetadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummyParent');
+
+        $this->loader->loadClassMetadata($parentClassMetadata);
+        $classMetadata->merge($parentClassMetadata);
+
+        $this->loader->loadClassMetadata($classMetadata);
+
+        $this->assertEquals(TestClassMetadataFactory::createClassMetadata(true), $classMetadata);
+    }
+}

vendor/symfony/serializer/Tests/Mapping/Loader/XmlFileLoaderTest.php

@@ -0,0 +1,65 @@
+<?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\Mapping\Loader;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Mapping\ClassMetadata;
+use Symfony\Component\Serializer\Mapping\Loader\XmlFileLoader;
+use Symfony\Component\Serializer\Tests\Mapping\TestClassMetadataFactory;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class XmlFileLoaderTest extends TestCase
+{
+    /**
+     * @var XmlFileLoader
+     */
+    private $loader;
+    /**
+     * @var ClassMetadata
+     */
+    private $metadata;
+
+    protected function setUp()
+    {
+        $this->loader = new XmlFileLoader(__DIR__.'/../../Fixtures/serialization.xml');
+        $this->metadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+    }
+
+    public function testInterface()
+    {
+        $this->assertInstanceOf('Symfony\Component\Serializer\Mapping\Loader\LoaderInterface', $this->loader);
+    }
+
+    public function testLoadClassMetadataReturnsTrueIfSuccessful()
+    {
+        $this->assertTrue($this->loader->loadClassMetadata($this->metadata));
+    }
+
+    public function testLoadClassMetadata()
+    {
+        $this->loader->loadClassMetadata($this->metadata);
+
+        $this->assertEquals(TestClassMetadataFactory::createXmlCLassMetadata(), $this->metadata);
+    }
+
+    public function testMaxDepth()
+    {
+        $classMetadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\MaxDepthDummy');
+        $this->loader->loadClassMetadata($classMetadata);
+
+        $attributesMetadata = $classMetadata->getAttributesMetadata();
+        $this->assertEquals(2, $attributesMetadata['foo']->getMaxDepth());
+        $this->assertEquals(3, $attributesMetadata['bar']->getMaxDepth());
+    }
+}

vendor/symfony/serializer/Tests/Mapping/Loader/YamlFileLoaderTest.php

@@ -0,0 +1,80 @@
+<?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\Mapping\Loader;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Mapping\ClassMetadata;
+use Symfony\Component\Serializer\Mapping\Loader\YamlFileLoader;
+use Symfony\Component\Serializer\Tests\Mapping\TestClassMetadataFactory;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class YamlFileLoaderTest extends TestCase
+{
+    /**
+     * @var YamlFileLoader
+     */
+    private $loader;
+    /**
+     * @var ClassMetadata
+     */
+    private $metadata;
+
+    protected function setUp()
+    {
+        $this->loader = new YamlFileLoader(__DIR__.'/../../Fixtures/serialization.yml');
+        $this->metadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+    }
+
+    public function testInterface()
+    {
+        $this->assertInstanceOf('Symfony\Component\Serializer\Mapping\Loader\LoaderInterface', $this->loader);
+    }
+
+    public function testLoadClassMetadataReturnsTrueIfSuccessful()
+    {
+        $this->assertTrue($this->loader->loadClassMetadata($this->metadata));
+    }
+
+    public function testLoadClassMetadataReturnsFalseWhenEmpty()
+    {
+        $loader = new YamlFileLoader(__DIR__.'/../../Fixtures/empty-mapping.yml');
+        $this->assertFalse($loader->loadClassMetadata($this->metadata));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\MappingException
+     */
+    public function testLoadClassMetadataReturnsThrowsInvalidMapping()
+    {
+        $loader = new YamlFileLoader(__DIR__.'/../../Fixtures/invalid-mapping.yml');
+        $loader->loadClassMetadata($this->metadata);
+    }
+
+    public function testLoadClassMetadata()
+    {
+        $this->loader->loadClassMetadata($this->metadata);
+
+        $this->assertEquals(TestClassMetadataFactory::createXmlCLassMetadata(), $this->metadata);
+    }
+
+    public function testMaxDepth()
+    {
+        $classMetadata = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\MaxDepthDummy');
+        $this->loader->loadClassMetadata($classMetadata);
+
+        $attributesMetadata = $classMetadata->getAttributesMetadata();
+        $this->assertEquals(2, $attributesMetadata['foo']->getMaxDepth());
+        $this->assertEquals(3, $attributesMetadata['bar']->getMaxDepth());
+    }
+}

vendor/symfony/serializer/Tests/Mapping/TestClassMetadataFactory.php

@@ -0,0 +1,82 @@
+<?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\Mapping;
+
+use Symfony\Component\Serializer\Mapping\AttributeMetadata;
+use Symfony\Component\Serializer\Mapping\ClassMetadata;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class TestClassMetadataFactory
+{
+    public static function createClassMetadata($withParent = false, $withInterface = false)
+    {
+        $expected = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+
+        $foo = new AttributeMetadata('foo');
+        $foo->addGroup('a');
+        $expected->addAttributeMetadata($foo);
+
+        $bar = new AttributeMetadata('bar');
+        $bar->addGroup('b');
+        $bar->addGroup('c');
+        $bar->addGroup('name_converter');
+        $expected->addAttributeMetadata($bar);
+
+        $fooBar = new AttributeMetadata('fooBar');
+        $fooBar->addGroup('a');
+        $fooBar->addGroup('b');
+        $fooBar->addGroup('name_converter');
+        $expected->addAttributeMetadata($fooBar);
+
+        $symfony = new AttributeMetadata('symfony');
+        $expected->addAttributeMetadata($symfony);
+
+        if ($withParent) {
+            $kevin = new AttributeMetadata('kevin');
+            $kevin->addGroup('a');
+            $expected->addAttributeMetadata($kevin);
+
+            $coopTilleuls = new AttributeMetadata('coopTilleuls');
+            $coopTilleuls->addGroup('a');
+            $coopTilleuls->addGroup('b');
+            $expected->addAttributeMetadata($coopTilleuls);
+        }
+
+        if ($withInterface) {
+            $symfony->addGroup('a');
+            $symfony->addGroup('name_converter');
+        }
+
+        // load reflection class so that the comparison passes
+        $expected->getReflectionClass();
+
+        return $expected;
+    }
+
+    public static function createXmlCLassMetadata()
+    {
+        $expected = new ClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\GroupDummy');
+
+        $foo = new AttributeMetadata('foo');
+        $foo->addGroup('group1');
+        $foo->addGroup('group2');
+        $expected->addAttributeMetadata($foo);
+
+        $bar = new AttributeMetadata('bar');
+        $bar->addGroup('group2');
+        $expected->addAttributeMetadata($bar);
+
+        return $expected;
+    }
+}

vendor/symfony/serializer/Tests/NameConverter/CamelCaseToSnakeCaseNameConverterTest.php

@@ -0,0 +1,57 @@
+<?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\NameConverter;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class CamelCaseToSnakeCaseNameConverterTest extends TestCase
+{
+    public function testInterface()
+    {
+        $attributeMetadata = new CamelCaseToSnakeCaseNameConverter();
+        $this->assertInstanceOf('Symfony\Component\Serializer\NameConverter\NameConverterInterface', $attributeMetadata);
+    }
+
+    /**
+     * @dataProvider attributeProvider
+     */
+    public function testNormalize($underscored, $camelCased, $useLowerCamelCase)
+    {
+        $nameConverter = new CamelCaseToSnakeCaseNameConverter(null, $useLowerCamelCase);
+        $this->assertEquals($nameConverter->normalize($camelCased), $underscored);
+    }
+
+    /**
+     * @dataProvider attributeProvider
+     */
+    public function testDenormalize($underscored, $camelCased, $useLowerCamelCase)
+    {
+        $nameConverter = new CamelCaseToSnakeCaseNameConverter(null, $useLowerCamelCase);
+        $this->assertEquals($nameConverter->denormalize($underscored), $camelCased);
+    }
+
+    public function attributeProvider()
+    {
+        return array(
+            array('coop_tilleuls', 'coopTilleuls', true),
+            array('_kevin_dunglas', '_kevinDunglas', true),
+            array('this_is_a_test', 'thisIsATest', true),
+            array('coop_tilleuls', 'CoopTilleuls', false),
+            array('_kevin_dunglas', '_kevinDunglas', false),
+            array('this_is_a_test', 'ThisIsATest', false),
+        );
+    }
+}

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

@@ -0,0 +1,131 @@
+<?php
+
+namespace Symfony\Component\Serializer\Tests\Normalizer;
+
+use PHPUnit\Framework\TestCase;
+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\Tests\Fixtures\AbstractNormalizerDummy;
+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;
+
+/**
+ * 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|\PHPUnit_Framework_MockObject_MockObject
+     */
+    private $classMetadata;
+
+    protected function setUp()
+    {
+        $loader = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\Loader\LoaderChain')->setConstructorArgs(array(array()))->getMock();
+        $this->classMetadata = $this->getMockBuilder('Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory')->setConstructorArgs(array($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', array(AbstractNormalizer::GROUPS => array('test')), true);
+        $this->assertEquals(array('a2', 'a4'), $result);
+
+        $result = $this->normalizer->getAllowedAttributes('c', array(AbstractNormalizer::GROUPS => array('other')), true);
+        $this->assertEquals(array('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', array(AbstractNormalizer::GROUPS => array('test')), false);
+        $this->assertEquals(array($a2, $a4), $result);
+
+        $result = $this->normalizer->getAllowedAttributes('c', array(AbstractNormalizer::GROUPS => array('other')), false);
+        $this->assertEquals(array($a3, $a4), $result);
+    }
+
+    public function testObjectToPopulateWithProxy()
+    {
+        $proxyDummy = new ProxyDummy();
+
+        $context = array(AbstractNormalizer::OBJECT_TO_POPULATE => $proxyDummy);
+
+        $normalizer = new ObjectNormalizer();
+        $normalizer->denormalize(array('foo' => 'bar'), 'Symfony\Component\Serializer\Tests\Fixtures\ToBeProxyfiedDummy', null, $context);
+
+        $this->assertSame('bar', $proxyDummy->getFoo());
+    }
+
+    public function testObjectWithStaticConstructor()
+    {
+        $normalizer = new StaticConstructorNormalizer();
+        $dummy = $normalizer->denormalize(array('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(array('foo' => null), NullableConstructorArgumentDummy::class);
+
+        $this->assertNull($dummy->getFoo());
+    }
+}

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

@@ -0,0 +1,340 @@
+<?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(array('foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'), __NAMESPACE__.'\Dummy');
+
+        $this->assertSame('foo', $normalizedData->foo);
+        $this->assertNull($normalizedData->bar);
+        $this->assertSame('baz', $normalizedData->baz);
+    }
+
+    public function testInstantiateObjectDenormalizer()
+    {
+        $data = array('foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz');
+        $class = __NAMESPACE__.'\Dummy';
+        $context = array();
+
+        $normalizer = new AbstractObjectNormalizerDummy();
+
+        $this->assertInstanceOf(__NAMESPACE__.'\Dummy', $normalizer->instantiateObject($data, $class, $context, new \ReflectionClass($class), array()));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\ExtraAttributesException
+     * @expectedExceptionMessage Extra attributes are not allowed ("fooFoo", "fooBar" are unknown).
+     */
+    public function testDenormalizeWithExtraAttributes()
+    {
+        $factory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+        $normalizer = new AbstractObjectNormalizerDummy($factory);
+        $normalizer->denormalize(
+            array('fooFoo' => 'foo', 'fooBar' => 'bar'),
+            __NAMESPACE__.'\Dummy',
+            'any',
+            array('allow_extra_attributes' => false)
+        );
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\ExtraAttributesException
+     * @expectedExceptionMessage Extra attributes are not allowed ("fooFoo", "fooBar" are unknown).
+     */
+    public function testDenormalizeWithExtraAttributesAndNoGroupsWithMetadataFactory()
+    {
+        $normalizer = new AbstractObjectNormalizerWithMetadata();
+        $normalizer->denormalize(
+            array('fooFoo' => 'foo', 'fooBar' => 'bar', 'bar' => 'bar'),
+            Dummy::class,
+            'any',
+            array('allow_extra_attributes' => false)
+        );
+    }
+
+    public function testDenormalizeCollectionDecodedFromXmlWithOneChild()
+    {
+        $denormalizer = $this->getDenormalizerForDummyCollection();
+
+        $dummyCollection = $denormalizer->denormalize(
+            array(
+                'children' => array(
+                    'bar' => 'first',
+                ),
+            ),
+            DummyCollection::class,
+            'xml'
+        );
+
+        $this->assertInstanceOf(DummyCollection::class, $dummyCollection);
+        $this->assertInternalType('array', $dummyCollection->children);
+        $this->assertCount(1, $dummyCollection->children);
+        $this->assertInstanceOf(DummyChild::class, $dummyCollection->children[0]);
+    }
+
+    public function testDenormalizeCollectionDecodedFromXmlWithTwoChildren()
+    {
+        $denormalizer = $this->getDenormalizerForDummyCollection();
+
+        $dummyCollection = $denormalizer->denormalize(
+            array(
+                'children' => array(
+                    array('bar' => 'first'),
+                    array('bar' => 'second'),
+                ),
+            ),
+            DummyCollection::class,
+            'xml'
+        );
+
+        $this->assertInstanceOf(DummyCollection::class, $dummyCollection);
+        $this->assertInternalType('array', $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(
+                array(
+                    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(array($arrayDenormalizer, $denormalizer));
+        $arrayDenormalizer->setSerializer($serializer);
+        $denormalizer->setSerializer($serializer);
+
+        return $denormalizer;
+    }
+
+    /**
+     * Test that additional attributes throw an exception if no metadata factory is specified.
+     *
+     * @expectedException \Symfony\Component\Serializer\Exception\LogicException
+     * @expectedExceptionMessage A class metadata factory must be provided in the constructor when setting "allow_extra_attributes" to false.
+     */
+    public function testExtraAttributesException()
+    {
+        $normalizer = new ObjectNormalizer();
+
+        $normalizer->denormalize(array(), \stdClass::class, 'xml', array(
+            'allow_extra_attributes' => false,
+        ));
+    }
+}
+
+class AbstractObjectNormalizerDummy extends AbstractObjectNormalizer
+{
+    protected function extractAttributes($object, $format = null, array $context = array())
+    {
+    }
+
+    protected function getAttributeValue($object, $attribute, $format = null, array $context = array())
+    {
+    }
+
+    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = array())
+    {
+        $object->$attribute = $value;
+    }
+
+    protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = array())
+    {
+        return \in_array($attribute, array('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 = array())
+    {
+    }
+
+    protected function getAttributeValue($object, $attribute, $format = null, array $context = array())
+    {
+    }
+
+    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = array())
+    {
+        $object->$attribute = $value;
+    }
+}
+
+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 = array())
+    {
+    }
+
+    public function deserialize($data, $type, $format, array $context = array())
+    {
+    }
+
+    public function denormalize($data, $type, $format = null, array $context = array())
+    {
+        foreach ($this->normalizers as $normalizer) {
+            if ($normalizer instanceof DenormalizerInterface && $normalizer->supportsDenormalization($data, $type, $format, $context)) {
+                return $normalizer->denormalize($data, $type, $format, $context);
+            }
+        }
+    }
+
+    public function supportsDenormalization($data, $type, $format = null)
+    {
+        return true;
+    }
+}
+
+class AbstractObjectNormalizerCollectionDummy extends AbstractObjectNormalizer
+{
+    protected function extractAttributes($object, $format = null, array $context = array())
+    {
+    }
+
+    protected function getAttributeValue($object, $attribute, $format = null, array $context = array())
+    {
+    }
+
+    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = array())
+    {
+        $object->$attribute = $value;
+    }
+
+    protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = array())
+    {
+        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 = array())
+    {
+    }
+
+    public function deserialize($data, $type, $format, array $context = array())
+    {
+    }
+}
+
+class ArrayDenormalizerDummy implements DenormalizerInterface, SerializerAwareInterface
+{
+    /**
+     * @var SerializerInterface|DenormalizerInterface
+     */
+    private $serializer;
+
+    /**
+     * {@inheritdoc}
+     *
+     * @throws NotNormalizableValueException
+     */
+    public function denormalize($data, $class, $format = null, array $context = array())
+    {
+        $serializer = $this->serializer;
+        $class = substr($class, 0, -2);
+
+        foreach ($data as $key => $value) {
+            $data[$key] = $serializer->denormalize($value, $class, $format, $context);
+        }
+
+        return $data;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsDenormalization($data, $type, $format = null, array $context = array())
+    {
+        return '[]' === substr($type, -2)
+            && $this->serializer->supportsDenormalization($data, substr($type, 0, -2), $format, $context);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setSerializer(SerializerInterface $serializer)
+    {
+        $this->serializer = $serializer;
+    }
+}

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

@@ -0,0 +1,122 @@
+<?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\ArrayDenormalizer;
+use Symfony\Component\Serializer\SerializerInterface;
+
+class ArrayDenormalizerTest extends TestCase
+{
+    /**
+     * @var ArrayDenormalizer
+     */
+    private $denormalizer;
+
+    /**
+     * @var SerializerInterface|\PHPUnit_Framework_MockObject_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->at(0))
+            ->method('denormalize')
+            ->with(array('foo' => 'one', 'bar' => 'two'))
+            ->will($this->returnValue(new ArrayDummy('one', 'two')));
+
+        $this->serializer->expects($this->at(1))
+            ->method('denormalize')
+            ->with(array('foo' => 'three', 'bar' => 'four'))
+            ->will($this->returnValue(new ArrayDummy('three', 'four')));
+
+        $result = $this->denormalizer->denormalize(
+            array(
+                array('foo' => 'one', 'bar' => 'two'),
+                array('foo' => 'three', 'bar' => 'four'),
+            ),
+            __NAMESPACE__.'\ArrayDummy[]'
+        );
+
+        $this->assertEquals(
+            array(
+                new ArrayDummy('one', 'two'),
+                new ArrayDummy('three', 'four'),
+            ),
+            $result
+        );
+    }
+
+    public function testSupportsValidArray()
+    {
+        $this->serializer->expects($this->once())
+            ->method('supportsDenormalization')
+            ->with($this->anything(), __NAMESPACE__.'\ArrayDummy', $this->anything())
+            ->will($this->returnValue(true));
+
+        $this->assertTrue(
+            $this->denormalizer->supportsDenormalization(
+                array(
+                    array('foo' => 'one', 'bar' => 'two'),
+                    array('foo' => 'three', 'bar' => 'four'),
+                ),
+                __NAMESPACE__.'\ArrayDummy[]'
+            )
+        );
+    }
+
+    public function testSupportsInvalidArray()
+    {
+        $this->serializer->expects($this->any())
+            ->method('supportsDenormalization')
+            ->will($this->returnValue(false));
+
+        $this->assertFalse(
+            $this->denormalizer->supportsDenormalization(
+                array(
+                    array('foo' => 'one', 'bar' => 'two'),
+                    array('foo' => 'three', 'bar' => 'four'),
+                ),
+                __NAMESPACE__.'\InvalidClass[]'
+            )
+        );
+    }
+
+    public function testSupportsNoArray()
+    {
+        $this->assertFalse(
+            $this->denormalizer->supportsDenormalization(
+                array('foo' => 'one', 'bar' => 'two'),
+                __NAMESPACE__.'\ArrayDummy'
+            )
+        );
+    }
+}
+
+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', array(
+            '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(array(), 'Symfony\Component\Serializer\Tests\Fixtures\ScalarDummy'));
+        $this->assertFalse($this->normalizer->supportsDenormalization(array(), 'stdClass'));
+        $this->assertTrue($this->normalizer->supportsDenormalization(array(), 'Symfony\Component\Serializer\Tests\Fixtures\DenormalizableDummy'));
+    }
+}

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

@@ -0,0 +1,137 @@
+<?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 = array(
+            array('P%YY%MM%DDT%HH%IM%SS', 'P00Y00M00DT00H00M00S', 'PT0S'),
+            array('P%yY%mM%dDT%hH%iM%sS', 'P0Y0M0DT0H0M0S', 'PT0S'),
+            array('P%yY%mM%dDT%hH%iM%sS', 'P10Y2M3DT16H5M6S', 'P10Y2M3DT16H5M6S'),
+            array('P%yY%mM%dDT%hH%iM', 'P10Y2M3DT16H5M', 'P10Y2M3DT16H5M'),
+            array('P%yY%mM%dDT%hH', 'P10Y2M3DT16H', 'P10Y2M3DT16H'),
+            array('P%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(new \DateInterval($input), null, array(DateIntervalNormalizer::FORMAT_KEY => $format)));
+    }
+
+    /**
+     * @dataProvider dataProviderISO
+     */
+    public function testNormalizeUsingFormatPassedInConstructor($format, $output, $input)
+    {
+        $this->assertEquals($output, (new DateIntervalNormalizer($format))->normalize(new \DateInterval($input)));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     * @expectedExceptionMessage The object must be an instance of "\DateInterval".
+     */
+    public function testNormalizeInvalidObjectThrowsException()
+    {
+        $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(new \DateInterval($output), $this->normalizer->denormalize($input, \DateInterval::class, null, array(DateIntervalNormalizer::FORMAT_KEY => $format)));
+    }
+
+    /**
+     * @dataProvider dataProviderISO
+     */
+    public function testDenormalizeUsingFormatPassedInConstructor($format, $input, $output)
+    {
+        $this->assertDateIntervalEquals(new \DateInterval($output), (new DateIntervalNormalizer($format))->denormalize($input, \DateInterval::class));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     */
+    public function testDenormalizeExpectsString()
+    {
+        $this->normalizer->denormalize(1234, \DateInterval::class);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     * @expectedExceptionMessage Expected a valid ISO 8601 interval string.
+     */
+    public function testDenormalizeNonISO8601IntervalStringThrowsException()
+    {
+        $this->normalizer->denormalize('10 years 2 months 3 days', \DateInterval::class, null);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDenormalizeInvalidDataThrowsException()
+    {
+        $this->normalizer->denormalize('invalid interval', \DateInterval::class);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDenormalizeFormatMismatchThrowsException()
+    {
+        $this->normalizer->denormalize('P00Y00M00DT00H00M00S', \DateInterval::class, null, array(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'));
+    }
+}

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

@@ -0,0 +1,195 @@
+<?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, array(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, array(
+            DateTimeNormalizer::TIMEZONE_KEY => $timezone,
+        )));
+    }
+
+    public function normalizeUsingTimeZonePassedInContextProvider()
+    {
+        yield array('2016-12-01T00:00:00+00:00', new \DateTime('2016/12/01', new \DateTimeZone('UTC')), null);
+        yield array('2016-12-01T00:00:00+09:00', new \DateTime('2016/12/01', new \DateTimeZone('Japan')), new \DateTimeZone('Japan'));
+        yield array('2016-12-01T09:00:00+09:00', new \DateTime('2016/12/01', new \DateTimeZone('UTC')), new \DateTimeZone('Japan'));
+        yield array('2016-12-01T09:00:00+09:00', new \DateTimeImmutable('2016/12/01', new \DateTimeZone('UTC')), new \DateTimeZone('Japan'));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     * @expectedExceptionMessage The object must implement the "\DateTimeInterface".
+     */
+    public function testNormalizeInvalidObjectThrowsException()
+    {
+        $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, array(
+            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, array(DateTimeNormalizer::FORMAT_KEY => 'Y.m.d|')));
+        $this->assertEquals(new \DateTimeImmutable('2016/01/01'), $this->normalizer->denormalize('2016.01.01', \DateTimeImmutable::class, null, array(DateTimeNormalizer::FORMAT_KEY => 'Y.m.d|')));
+        $this->assertEquals(new \DateTime('2016/01/01'), $this->normalizer->denormalize('2016.01.01', \DateTime::class, null, array(DateTimeNormalizer::FORMAT_KEY => 'Y.m.d|')));
+    }
+
+    /**
+     * @dataProvider denormalizeUsingTimezonePassedInContextProvider
+     */
+    public function testDenormalizeUsingTimezonePassedInContext($input, $expected, $timezone, $format = null)
+    {
+        $actual = $this->normalizer->denormalize($input, \DateTimeInterface::class, null, array(
+            DateTimeNormalizer::TIMEZONE_KEY => $timezone,
+            DateTimeNormalizer::FORMAT_KEY => $format,
+        ));
+
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function denormalizeUsingTimezonePassedInContextProvider()
+    {
+        yield 'with timezone' => array(
+            '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' => array(
+            '2016/12/01 17:35:00',
+            new \DateTimeImmutable('2016/12/01 17:35:00', new \DateTimeZone('Japan')),
+            'Japan',
+        );
+        yield 'with format without timezone information' => array(
+            '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' => array(
+            '2016-12-01T17:35:00Z',
+            new \DateTimeImmutable('2016/12/01 17:35:00', new \DateTimeZone('UTC')),
+            'Europe/Paris',
+            \DateTime::RFC3339,
+        );
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDenormalizeInvalidDataThrowsException()
+    {
+        $this->normalizer->denormalize('invalid date', \DateTimeInterface::class);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     * @expectedExceptionMessage 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.
+     */
+    public function testDenormalizeNullThrowsException()
+    {
+        $this->normalizer->denormalize(null, \DateTimeInterface::class);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     * @expectedExceptionMessage 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.
+     */
+    public function testDenormalizeEmptyStringThrowsException()
+    {
+        $this->normalizer->denormalize('', \DateTimeInterface::class);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDenormalizeFormatMismatchThrowsException()
+    {
+        $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTimeInterface::class, null, array(DateTimeNormalizer::FORMAT_KEY => 'Y-m-d|'));
+    }
+}

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

@@ -0,0 +1,841 @@
+<?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(__NAMESPACE__.'\SerializerNormalizer')->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')
+            ->will($this->returnValue('string_object'))
+        ;
+
+        $this->assertEquals(
+            array(
+                '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(
+            array('foo' => 'foo', 'bar' => 'bar', 'baz' => true, 'fooBar' => 'foobar'),
+            __NAMESPACE__.'\GetSetDummy',
+            'any'
+        );
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+        $this->assertTrue($obj->isBaz());
+    }
+
+    public function testDenormalizeWithObject()
+    {
+        $data = new \stdClass();
+        $data->foo = 'foo';
+        $data->bar = 'bar';
+        $data->fooBar = 'foobar';
+        $obj = $this->normalizer->denormalize($data, __NAMESPACE__.'\GetSetDummy', 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testDenormalizeNull()
+    {
+        $this->assertEquals(new GetSetDummy(), $this->normalizer->denormalize(null, __NAMESPACE__.'\GetSetDummy'));
+    }
+
+    public function testConstructorDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(
+            array('foo' => 'foo', 'bar' => 'bar', 'baz' => true, 'fooBar' => 'foobar'),
+            __NAMESPACE__.'\GetConstructorDummy', 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+        $this->assertTrue($obj->isBaz());
+    }
+
+    public function testConstructorDenormalizeWithNullArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            array('foo' => 'foo', 'bar' => null, 'baz' => true),
+            __NAMESPACE__.'\GetConstructorDummy', 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertNull($obj->getBar());
+        $this->assertTrue($obj->isBaz());
+    }
+
+    public function testConstructorDenormalizeWithMissingOptionalArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            array('foo' => 'test', 'baz' => array(1, 2, 3)),
+            __NAMESPACE__.'\GetConstructorOptionalArgsDummy', 'any');
+        $this->assertEquals('test', $obj->getFoo());
+        $this->assertEquals(array(), $obj->getBar());
+        $this->assertEquals(array(1, 2, 3), $obj->getBaz());
+    }
+
+    public function testConstructorDenormalizeWithOptionalDefaultArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            array('bar' => 'test'),
+            __NAMESPACE__.'\GetConstructorArgsWithDefaultValueDummy', 'any');
+        $this->assertEquals(array(), $obj->getFoo());
+        $this->assertEquals('test', $obj->getBar());
+    }
+
+    /**
+     * @requires PHP 5.6
+     */
+    public function testConstructorDenormalizeWithVariadicArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            array('foo' => array(1, 2, 3)),
+            'Symfony\Component\Serializer\Tests\Fixtures\VariadicConstructorArgsDummy', 'any');
+        $this->assertEquals(array(1, 2, 3), $obj->getFoo());
+    }
+
+    /**
+     * @requires PHP 5.6
+     */
+    public function testConstructorDenormalizeWithMissingVariadicArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            array(),
+            'Symfony\Component\Serializer\Tests\Fixtures\VariadicConstructorArgsDummy', 'any');
+        $this->assertEquals(array(), $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, __NAMESPACE__.'\GetConstructorDummy', 'any');
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testConstructorWArgWithPrivateMutator()
+    {
+        $obj = $this->normalizer->denormalize(array('foo' => 'bar'), __NAMESPACE__.'\ObjectConstructorArgsWithPrivateMutatorDummy', '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(array(
+            'bar' => 'bar',
+        ), $this->normalizer->normalize($obj, null, array(GetSetMethodNormalizer::GROUPS => array('c'))));
+
+        $this->assertEquals(array(
+            'symfony' => 'symfony',
+            'foo' => 'foo',
+            'fooBar' => 'fooBar',
+            'bar' => 'bar',
+            'kevin' => 'kevin',
+            'coopTilleuls' => 'coopTilleuls',
+        ), $this->normalizer->normalize($obj, null, array(GetSetMethodNormalizer::GROUPS => array('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 = array('foo' => 'foo', 'bar' => 'bar');
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            array(GetSetMethodNormalizer::GROUPS => array('a'))
+        );
+        $this->assertEquals($obj, $normalized);
+
+        $obj->setBar('bar');
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            array(GetSetMethodNormalizer::GROUPS => array('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(
+            array(
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+            ),
+            $this->normalizer->normalize($obj, null, array(GetSetMethodNormalizer::GROUPS => array('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(array(
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+                'coop_tilleuls' => 'les-tilleuls.coop',
+            ), 'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy', null, array(GetSetMethodNormalizer::GROUPS => array('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
+        );
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testUncallableCallbacks()
+    {
+        $this->normalizer->setCallbacks(array('bar' => null));
+
+        $obj = new GetConstructorDummy('baz', 'quux', true);
+
+        $this->normalizer->normalize($obj, 'any');
+    }
+
+    public function testIgnoredAttributes()
+    {
+        $this->normalizer->setIgnoredAttributes(array('foo', 'bar', 'baz', 'camelCase', 'object'));
+
+        $obj = new GetSetDummy();
+        $obj->setFoo('foo');
+        $obj->setBar('bar');
+        $obj->setBaz(true);
+
+        $this->assertEquals(
+            array('fooBar' => 'foobar'),
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function provideCallbacks()
+    {
+        return array(
+            array(
+                array(
+                    'bar' => function ($bar) {
+                        return 'baz';
+                    },
+                ),
+                'baz',
+                array('foo' => '', 'bar' => 'baz', 'baz' => true),
+                'Change a string',
+            ),
+            array(
+                array(
+                    'bar' => function ($bar) {
+                    },
+                ),
+                'baz',
+                array('foo' => '', 'bar' => null, 'baz' => true),
+                'Null an item',
+            ),
+            array(
+                array(
+                    'bar' => function ($bar) {
+                        return $bar->format('d-m-Y H:i:s');
+                    },
+                ),
+                new \DateTime('2011-09-10 06:30:00'),
+                array('foo' => '', 'bar' => '10-09-2011 06:30:00', 'baz' => true),
+                'Format a date',
+            ),
+            array(
+                array(
+                    'bar' => function ($bars) {
+                        $foos = '';
+                        foreach ($bars as $bar) {
+                            $foos .= $bar->getFoo();
+                        }
+
+                        return $foos;
+                    },
+                ),
+                array(new GetConstructorDummy('baz', '', false), new GetConstructorDummy('quux', '', false)),
+                array('foo' => '', 'bar' => 'bazquux', 'baz' => true),
+                'Collect a property',
+            ),
+            array(
+                array(
+                    'bar' => function ($bars) {
+                        return \count($bars);
+                    },
+                ),
+                array(new GetConstructorDummy('baz', '', false), new GetConstructorDummy('quux', '', false)),
+                array('foo' => '', 'bar' => 2, 'baz' => true),
+                'Count a property',
+            ),
+        );
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\LogicException
+     * @expectedExceptionMessage Cannot normalize attribute "object" because the injected serializer is not a normalizer
+     */
+    public function testUnableToNormalizeObjectAttribute()
+    {
+        $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');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\CircularReferenceException
+     */
+    public function testUnableToNormalizeCircularReference()
+    {
+        $serializer = new Serializer(array($this->normalizer));
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceLimit(2);
+
+        $obj = new CircularReferenceDummy();
+
+        $this->normalizer->normalize($obj);
+    }
+
+    public function testSiblingReference()
+    {
+        $serializer = new Serializer(array($this->normalizer));
+        $this->normalizer->setSerializer($serializer);
+
+        $siblingHolder = new SiblingHolder();
+
+        $expected = array(
+            'sibling0' => array('coopTilleuls' => 'Les-Tilleuls.coop'),
+            'sibling1' => array('coopTilleuls' => 'Les-Tilleuls.coop'),
+            'sibling2' => array('coopTilleuls' => 'Les-Tilleuls.coop'),
+        );
+        $this->assertEquals($expected, $this->normalizer->normalize($siblingHolder));
+    }
+
+    public function testCircularReferenceHandler()
+    {
+        $serializer = new Serializer(array($this->normalizer));
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceHandler(function ($obj) {
+            return \get_class($obj);
+        });
+
+        $obj = new CircularReferenceDummy();
+
+        $expected = array('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(
+            array('bar' => 'bar'),
+            __NAMESPACE__.'\GetSetDummy',
+            null,
+            array(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(array('non_existing' => true), __NAMESPACE__.'\GetSetDummy')
+        );
+    }
+
+    public function testDenormalizeShouldNotSetStaticAttribute()
+    {
+        $obj = $this->normalizer->denormalize(array('staticObject' => true), __NAMESPACE__.'\GetSetDummy');
+
+        $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(array('foo' => 'foobar'), __NAMESPACE__.'\ObjectWithPrivateSetterDummy');
+        $this->assertEquals('bar', $obj->getFoo());
+    }
+
+    public function testHasGetterDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(array('foo' => true), ObjectWithHasGetterDummy::class);
+        $this->assertTrue($obj->hasFoo());
+    }
+
+    public function testHasGetterNormalize()
+    {
+        $obj = new ObjectWithHasGetterDummy();
+        $obj->setFoo(true);
+
+        $this->assertEquals(
+            array('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(array($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, array(GetSetMethodNormalizer::ENABLE_MAX_DEPTH => true));
+
+        $expected = array(
+            'bar' => 'level1',
+            'child' => array(
+                    'bar' => 'level2',
+                    'child' => array(
+                            'bar' => 'level3',
+                            'child' => array(
+                                    '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 = array(), $baz = array())
+    {
+        $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 = array(), $bar)
+    {
+        $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 GetCamelizedDummy
+{
+    private $kevinDunglas;
+    private $fooBar;
+    private $bar_foo;
+
+    public function __construct($kevinDunglas = null)
+    {
+        $this->kevinDunglas = $kevinDunglas;
+    }
+
+    public function getKevinDunglas()
+    {
+        return $this->kevinDunglas;
+    }
+
+    public function setFooBar($fooBar)
+    {
+        $this->fooBar = $fooBar;
+    }
+
+    public function getFooBar()
+    {
+        return $this->fooBar;
+    }
+
+    public function setBar_foo($bar_foo)
+    {
+        $this->bar_foo = $bar_foo;
+    }
+
+    public function getBar_foo()
+    {
+        return $this->bar_foo;
+    }
+}
+
+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,95 @@
+<?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\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 \PHPUnit_Framework_MockObject_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')
+            ->will($this->returnCallback(function ($data) {
+                $this->assertArraySubset(array('foo' => 'a', 'bar' => 'b', 'baz' => 'c'), $data);
+
+                return 'string_object';
+            }))
+        ;
+
+        $this->assertEquals('string_object', $this->normalizer->normalize(new JsonSerializableDummy()));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\CircularReferenceException
+     */
+    public function testCircularNormalize()
+    {
+        $this->normalizer->setCircularReferenceLimit(1);
+
+        $this->serializer
+            ->expects($this->once())
+            ->method('normalize')
+            ->will($this->returnCallback(function ($data, $format, $context) {
+                $this->normalizer->normalize($data['qux'], $format, $context);
+
+                return 'string_object';
+            }))
+        ;
+
+        $this->assertEquals('string_object', $this->normalizer->normalize(new JsonSerializableDummy()));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\InvalidArgumentException
+     * @expectedExceptionMessage The object must implement "JsonSerializable".
+     */
+    public function testInvalidDataThrowException()
+    {
+        $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, array());
+
+        $this->assertNull($object);
+    }
+
+    public function testExtractObjectToPopulateReturnsNullWhenNonObjectIsProvided()
+    {
+        $object = $this->extractObjectToPopulate(ProxyDummy::class, array(
+            'object_to_populate' => 'not an object',
+        ));
+
+        $this->assertNull($object);
+    }
+
+    public function testExtractObjectToPopulateReturnsNullWhenTheClassIsNotAnInstanceOfTheProvidedClass()
+    {
+        $object = $this->extractObjectToPopulate(ProxyDummy::class, array(
+            'object_to_populate' => new \stdClass(),
+        ));
+
+        $this->assertNull($object);
+    }
+
+    public function testExtractObjectToPopulateReturnsObjectWhenEverythingChecksOut()
+    {
+        $expected = new ProxyDummy();
+        $object = $this->extractObjectToPopulate(ProxyDummy::class, array(
+            'object_to_populate' => $expected,
+        ));
+
+        $this->assertSame($expected, $object);
+    }
+}

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

@@ -0,0 +1,524 @@
+<?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\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(
+            array('foo' => 'foo', 'bar' => 'bar', 'camelCase' => 'camelcase'),
+            $this->normalizer->normalize($obj, 'any')
+        );
+    }
+
+    public function testDenormalize()
+    {
+        $obj = $this->normalizer->denormalize(
+            array('foo' => 'foo', 'bar' => 'bar'),
+            __NAMESPACE__.'\PropertyDummy',
+            '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(
+            array('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(
+            array('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(
+            array('foo' => 'foo', 'bar' => 'bar'),
+            __NAMESPACE__.'\PropertyConstructorDummy',
+            'any'
+        );
+        $this->assertEquals('foo', $obj->getFoo());
+        $this->assertEquals('bar', $obj->getBar());
+    }
+
+    public function testConstructorDenormalizeWithNullArgument()
+    {
+        $obj = $this->normalizer->denormalize(
+            array('foo' => null, 'bar' => 'bar'),
+            __NAMESPACE__.'\PropertyConstructorDummy', '
+            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
+        );
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testUncallableCallbacks()
+    {
+        $this->normalizer->setCallbacks(array('bar' => null));
+
+        $obj = new PropertyConstructorDummy('baz', 'quux');
+
+        $this->normalizer->normalize($obj, 'any');
+    }
+
+    public function testIgnoredAttributes()
+    {
+        $this->normalizer->setIgnoredAttributes(array('foo', 'bar', 'camelCase'));
+
+        $obj = new PropertyDummy();
+        $obj->foo = 'foo';
+        $obj->setBar('bar');
+
+        $this->assertEquals(
+            array(),
+            $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(array(
+            'bar' => 'bar',
+        ), $this->normalizer->normalize($obj, null, array(PropertyNormalizer::GROUPS => array('c'))));
+
+        // The PropertyNormalizer is also able to hydrate properties from parent classes
+        $this->assertEquals(array(
+            'symfony' => 'symfony',
+            'foo' => 'foo',
+            'fooBar' => 'fooBar',
+            'bar' => 'bar',
+            'kevin' => 'kevin',
+            'coopTilleuls' => 'coopTilleuls',
+        ), $this->normalizer->normalize($obj, null, array(PropertyNormalizer::GROUPS => array('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 = array('foo' => 'foo', 'bar' => 'bar');
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            array(PropertyNormalizer::GROUPS => array('a'))
+        );
+        $this->assertEquals($obj, $normalized);
+
+        $obj->setBar('bar');
+
+        $normalized = $this->normalizer->denormalize(
+            $toNormalize,
+            'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy',
+            null,
+            array(PropertyNormalizer::GROUPS => array('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(
+            array(
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+            ),
+            $this->normalizer->normalize($obj, null, array(PropertyNormalizer::GROUPS => array('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(array(
+                'bar' => null,
+                'foo_bar' => '@dunglas',
+                'symfony' => '@coopTilleuls',
+                'coop_tilleuls' => 'les-tilleuls.coop',
+            ), 'Symfony\Component\Serializer\Tests\Fixtures\GroupDummy', null, array(PropertyNormalizer::GROUPS => array('name_converter')))
+        );
+    }
+
+    public function provideCallbacks()
+    {
+        return array(
+            array(
+                array(
+                    'bar' => function ($bar) {
+                        return 'baz';
+                    },
+                ),
+                'baz',
+                array('foo' => '', 'bar' => 'baz'),
+                'Change a string',
+            ),
+            array(
+                array(
+                    'bar' => function ($bar) {
+                        return;
+                    },
+                ),
+                'baz',
+                array('foo' => '', 'bar' => null),
+                'Null an item',
+            ),
+            array(
+                array(
+                    'bar' => function ($bar) {
+                        return $bar->format('d-m-Y H:i:s');
+                    },
+                ),
+                new \DateTime('2011-09-10 06:30:00'),
+                array('foo' => '', 'bar' => '10-09-2011 06:30:00'),
+                'Format a date',
+            ),
+            array(
+                array(
+                    'bar' => function ($bars) {
+                        $foos = '';
+                        foreach ($bars as $bar) {
+                            $foos .= $bar->getFoo();
+                        }
+
+                        return $foos;
+                    },
+                ),
+                array(new PropertyConstructorDummy('baz', ''), new PropertyConstructorDummy('quux', '')),
+                array('foo' => '', 'bar' => 'bazquux'),
+                'Collect a property',
+            ),
+            array(
+                array(
+                    'bar' => function ($bars) {
+                        return \count($bars);
+                    },
+                ),
+                array(new PropertyConstructorDummy('baz', ''), new PropertyConstructorDummy('quux', '')),
+                array('foo' => '', 'bar' => 2),
+                'Count a property',
+            ),
+        );
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\CircularReferenceException
+     */
+    public function testUnableToNormalizeCircularReference()
+    {
+        $serializer = new Serializer(array($this->normalizer));
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceLimit(2);
+
+        $obj = new PropertyCircularReferenceDummy();
+
+        $this->normalizer->normalize($obj);
+    }
+
+    public function testSiblingReference()
+    {
+        $serializer = new Serializer(array($this->normalizer));
+        $this->normalizer->setSerializer($serializer);
+
+        $siblingHolder = new PropertySiblingHolder();
+
+        $expected = array(
+            'sibling0' => array('coopTilleuls' => 'Les-Tilleuls.coop'),
+            'sibling1' => array('coopTilleuls' => 'Les-Tilleuls.coop'),
+            'sibling2' => array('coopTilleuls' => 'Les-Tilleuls.coop'),
+        );
+        $this->assertEquals($expected, $this->normalizer->normalize($siblingHolder));
+    }
+
+    public function testCircularReferenceHandler()
+    {
+        $serializer = new Serializer(array($this->normalizer));
+        $this->normalizer->setSerializer($serializer);
+        $this->normalizer->setCircularReferenceHandler(function ($obj) {
+            return \get_class($obj);
+        });
+
+        $obj = new PropertyCircularReferenceDummy();
+
+        $expected = array('me' => 'Symfony\Component\Serializer\Tests\Fixtures\PropertyCircularReferenceDummy');
+        $this->assertEquals($expected, $this->normalizer->normalize($obj));
+    }
+
+    public function testDenormalizeNonExistingAttribute()
+    {
+        $this->assertEquals(
+            new PropertyDummy(),
+            $this->normalizer->denormalize(array('non_existing' => true), __NAMESPACE__.'\PropertyDummy')
+        );
+    }
+
+    public function testDenormalizeShouldIgnoreStaticProperty()
+    {
+        $obj = $this->normalizer->denormalize(array('outOfScope' => true), __NAMESPACE__.'\PropertyDummy');
+
+        $this->assertEquals(new PropertyDummy(), $obj);
+        $this->assertEquals('out_of_scope', PropertyDummy::$outOfScope);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\LogicException
+     * @expectedExceptionMessage Cannot normalize attribute "bar" because the injected serializer is not a normalizer
+     */
+    public function testUnableToNormalizeObjectAttribute()
+    {
+        $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(array($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, array(PropertyNormalizer::ENABLE_MAX_DEPTH => true));
+
+        $expected = array(
+            'foo' => 'level1',
+            'child' => array(
+                    'foo' => 'level2',
+                    'child' => array(
+                            '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 PropertyCamelizedDummy
+{
+    private $kevinDunglas;
+    public $fooBar;
+    public $bar_foo;
+
+    public function __construct($kevinDunglas = null)
+    {
+        $this->kevinDunglas = $kevinDunglas;
+    }
+}
+
+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, $class, $format = null, array $context = array())
+    {
+    }
+
+    /**
+     * {@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 = array())
+    {
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsNormalization($data, $format = null)
+    {
+        return true;
+    }
+}

vendor/symfony/serializer/Tests/SerializerTest.php

@@ -0,0 +1,413 @@
+<?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;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Encoder\JsonEncoder;
+use Symfony\Component\Serializer\Normalizer\ArrayDenormalizer;
+use Symfony\Component\Serializer\Normalizer\CustomNormalizer;
+use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
+use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
+use Symfony\Component\Serializer\Normalizer\PropertyNormalizer;
+use Symfony\Component\Serializer\Serializer;
+use Symfony\Component\Serializer\Tests\Fixtures\NormalizableTraversableDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\TraversableDummy;
+use Symfony\Component\Serializer\Tests\Normalizer\TestDenormalizer;
+use Symfony\Component\Serializer\Tests\Normalizer\TestNormalizer;
+
+class SerializerTest extends TestCase
+{
+    public function testInterface()
+    {
+        $serializer = new Serializer();
+
+        $this->assertInstanceOf('Symfony\Component\Serializer\SerializerInterface', $serializer);
+        $this->assertInstanceOf('Symfony\Component\Serializer\Normalizer\NormalizerInterface', $serializer);
+        $this->assertInstanceOf('Symfony\Component\Serializer\Normalizer\DenormalizerInterface', $serializer);
+        $this->assertInstanceOf('Symfony\Component\Serializer\Encoder\EncoderInterface', $serializer);
+        $this->assertInstanceOf('Symfony\Component\Serializer\Encoder\DecoderInterface', $serializer);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testNormalizeNoMatch()
+    {
+        $serializer = new Serializer(array($this->getMockBuilder('Symfony\Component\Serializer\Normalizer\CustomNormalizer')->getMock()));
+        $serializer->normalize(new \stdClass(), 'xml');
+    }
+
+    public function testNormalizeTraversable()
+    {
+        $serializer = new Serializer(array(), array('json' => new JsonEncoder()));
+        $result = $serializer->serialize(new TraversableDummy(), 'json');
+        $this->assertEquals('{"foo":"foo","bar":"bar"}', $result);
+    }
+
+    public function testNormalizeGivesPriorityToInterfaceOverTraversable()
+    {
+        $serializer = new Serializer(array(new CustomNormalizer()), array('json' => new JsonEncoder()));
+        $result = $serializer->serialize(new NormalizableTraversableDummy(), 'json');
+        $this->assertEquals('{"foo":"normalizedFoo","bar":"normalizedBar"}', $result);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testNormalizeOnDenormalizer()
+    {
+        $serializer = new Serializer(array(new TestDenormalizer()), array());
+        $this->assertTrue($serializer->normalize(new \stdClass(), 'json'));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDenormalizeNoMatch()
+    {
+        $serializer = new Serializer(array($this->getMockBuilder('Symfony\Component\Serializer\Normalizer\CustomNormalizer')->getMock()));
+        $serializer->denormalize('foo', 'stdClass');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDenormalizeOnNormalizer()
+    {
+        $serializer = new Serializer(array(new TestNormalizer()), array());
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $this->assertTrue($serializer->denormalize(json_encode($data), 'stdClass', 'json'));
+    }
+
+    public function testCustomNormalizerCanNormalizeCollectionsAndScalar()
+    {
+        $serializer = new Serializer(array(new TestNormalizer()), array());
+        $this->assertNull($serializer->normalize(array('a', 'b')));
+        $this->assertNull($serializer->normalize(new \ArrayObject(array('c', 'd'))));
+        $this->assertNull($serializer->normalize(array()));
+        $this->assertNull($serializer->normalize('test'));
+    }
+
+    public function testNormalizeWithSupportOnData()
+    {
+        $normalizer1 = $this->getMockBuilder('Symfony\Component\Serializer\Normalizer\NormalizerInterface')->getMock();
+        $normalizer1->method('supportsNormalization')
+            ->willReturnCallback(function ($data, $format) {
+                return isset($data->test);
+            });
+        $normalizer1->method('normalize')->willReturn('test1');
+
+        $normalizer2 = $this->getMockBuilder('Symfony\Component\Serializer\Normalizer\NormalizerInterface')->getMock();
+        $normalizer2->method('supportsNormalization')
+            ->willReturn(true);
+        $normalizer2->method('normalize')->willReturn('test2');
+
+        $serializer = new Serializer(array($normalizer1, $normalizer2));
+
+        $data = new \stdClass();
+        $data->test = true;
+        $this->assertEquals('test1', $serializer->normalize($data));
+
+        $this->assertEquals('test2', $serializer->normalize(new \stdClass()));
+    }
+
+    public function testDenormalizeWithSupportOnData()
+    {
+        $denormalizer1 = $this->getMockBuilder('Symfony\Component\Serializer\Normalizer\DenormalizerInterface')->getMock();
+        $denormalizer1->method('supportsDenormalization')
+            ->willReturnCallback(function ($data, $type, $format) {
+                return isset($data['test1']);
+            });
+        $denormalizer1->method('denormalize')->willReturn('test1');
+
+        $denormalizer2 = $this->getMockBuilder('Symfony\Component\Serializer\Normalizer\DenormalizerInterface')->getMock();
+        $denormalizer2->method('supportsDenormalization')
+            ->willReturn(true);
+        $denormalizer2->method('denormalize')->willReturn('test2');
+
+        $serializer = new Serializer(array($denormalizer1, $denormalizer2));
+
+        $this->assertEquals('test1', $serializer->denormalize(array('test1' => true), 'test'));
+
+        $this->assertEquals('test2', $serializer->denormalize(array(), 'test'));
+    }
+
+    public function testSerialize()
+    {
+        $serializer = new Serializer(array(new GetSetMethodNormalizer()), array('json' => new JsonEncoder()));
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $result = $serializer->serialize(Model::fromArray($data), 'json');
+        $this->assertEquals(json_encode($data), $result);
+    }
+
+    public function testSerializeScalar()
+    {
+        $serializer = new Serializer(array(), array('json' => new JsonEncoder()));
+        $result = $serializer->serialize('foo', 'json');
+        $this->assertEquals('"foo"', $result);
+    }
+
+    public function testSerializeArrayOfScalars()
+    {
+        $serializer = new Serializer(array(), array('json' => new JsonEncoder()));
+        $data = array('foo', array(5, 3));
+        $result = $serializer->serialize($data, 'json');
+        $this->assertEquals(json_encode($data), $result);
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testSerializeNoEncoder()
+    {
+        $serializer = new Serializer(array(), array());
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $serializer->serialize($data, 'json');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\LogicException
+     */
+    public function testSerializeNoNormalizer()
+    {
+        $serializer = new Serializer(array(), array('json' => new JsonEncoder()));
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $serializer->serialize(Model::fromArray($data), 'json');
+    }
+
+    public function testDeserialize()
+    {
+        $serializer = new Serializer(array(new GetSetMethodNormalizer()), array('json' => new JsonEncoder()));
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $result = $serializer->deserialize(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json');
+        $this->assertEquals($data, $result->toArray());
+    }
+
+    public function testDeserializeUseCache()
+    {
+        $serializer = new Serializer(array(new GetSetMethodNormalizer()), array('json' => new JsonEncoder()));
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $serializer->deserialize(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json');
+        $data = array('title' => 'bar', 'numbers' => array(2, 8));
+        $result = $serializer->deserialize(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json');
+        $this->assertEquals($data, $result->toArray());
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\LogicException
+     */
+    public function testDeserializeNoNormalizer()
+    {
+        $serializer = new Serializer(array(), array('json' => new JsonEncoder()));
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $serializer->deserialize(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDeserializeWrongNormalizer()
+    {
+        $serializer = new Serializer(array(new CustomNormalizer()), array('json' => new JsonEncoder()));
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $serializer->deserialize(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json');
+    }
+
+    /**
+     * @expectedException \Symfony\Component\Serializer\Exception\UnexpectedValueException
+     */
+    public function testDeserializeNoEncoder()
+    {
+        $serializer = new Serializer(array(), array());
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $serializer->deserialize(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json');
+    }
+
+    public function testDeserializeSupported()
+    {
+        $serializer = new Serializer(array(new GetSetMethodNormalizer()), array());
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $this->assertTrue($serializer->supportsDenormalization(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json'));
+    }
+
+    public function testDeserializeNotSupported()
+    {
+        $serializer = new Serializer(array(new GetSetMethodNormalizer()), array());
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $this->assertFalse($serializer->supportsDenormalization(json_encode($data), 'stdClass', 'json'));
+    }
+
+    public function testDeserializeNotSupportedMissing()
+    {
+        $serializer = new Serializer(array(), array());
+        $data = array('title' => 'foo', 'numbers' => array(5, 3));
+        $this->assertFalse($serializer->supportsDenormalization(json_encode($data), '\Symfony\Component\Serializer\Tests\Model', 'json'));
+    }
+
+    public function testEncode()
+    {
+        $serializer = new Serializer(array(), array('json' => new JsonEncoder()));
+        $data = array('foo', array(5, 3));
+        $result = $serializer->encode($data, 'json');
+        $this->assertEquals(json_encode($data), $result);
+    }
+
+    public function testDecode()
+    {
+        $serializer = new Serializer(array(), array('json' => new JsonEncoder()));
+        $data = array('foo', array(5, 3));
+        $result = $serializer->decode(json_encode($data), 'json');
+        $this->assertEquals($data, $result);
+    }
+
+    public function testSupportsArrayDeserialization()
+    {
+        $serializer = new Serializer(
+            array(
+                new GetSetMethodNormalizer(),
+                new PropertyNormalizer(),
+                new ObjectNormalizer(),
+                new CustomNormalizer(),
+                new ArrayDenormalizer(),
+            ),
+            array(
+                'json' => new JsonEncoder(),
+            )
+        );
+
+        $this->assertTrue(
+            $serializer->supportsDenormalization(array(), __NAMESPACE__.'\Model[]', 'json')
+        );
+    }
+
+    public function testDeserializeArray()
+    {
+        $jsonData = '[{"title":"foo","numbers":[5,3]},{"title":"bar","numbers":[2,8]}]';
+
+        $expectedData = array(
+            Model::fromArray(array('title' => 'foo', 'numbers' => array(5, 3))),
+            Model::fromArray(array('title' => 'bar', 'numbers' => array(2, 8))),
+        );
+
+        $serializer = new Serializer(
+            array(
+                new GetSetMethodNormalizer(),
+                new ArrayDenormalizer(),
+            ),
+            array(
+                'json' => new JsonEncoder(),
+            )
+        );
+
+        $this->assertEquals(
+            $expectedData,
+            $serializer->deserialize($jsonData, __NAMESPACE__.'\Model[]', 'json')
+        );
+    }
+
+    public function testNormalizerAware()
+    {
+        $normalizerAware = $this->getMockBuilder(NormalizerAwareInterface::class)->getMock();
+        $normalizerAware->expects($this->once())
+            ->method('setNormalizer')
+            ->with($this->isInstanceOf(NormalizerInterface::class));
+
+        new Serializer(array($normalizerAware));
+    }
+
+    public function testDenormalizerAware()
+    {
+        $denormalizerAware = $this->getMockBuilder(DenormalizerAwareInterface::class)->getMock();
+        $denormalizerAware->expects($this->once())
+            ->method('setDenormalizer')
+            ->with($this->isInstanceOf(DenormalizerInterface::class));
+
+        new Serializer(array($denormalizerAware));
+    }
+
+    public function testDeserializeObjectConstructorWithObjectTypeHint()
+    {
+        $jsonData = '{"bar":{"value":"baz"}}';
+
+        $serializer = new Serializer(array(new ObjectNormalizer()), array('json' => new JsonEncoder()));
+
+        $this->assertEquals(new Foo(new Bar('baz')), $serializer->deserialize($jsonData, Foo::class, 'json'));
+    }
+}
+
+class Model
+{
+    private $title;
+    private $numbers;
+
+    public static function fromArray($array)
+    {
+        $model = new self();
+        if (isset($array['title'])) {
+            $model->setTitle($array['title']);
+        }
+        if (isset($array['numbers'])) {
+            $model->setNumbers($array['numbers']);
+        }
+
+        return $model;
+    }
+
+    public function getTitle()
+    {
+        return $this->title;
+    }
+
+    public function setTitle($title)
+    {
+        $this->title = $title;
+    }
+
+    public function getNumbers()
+    {
+        return $this->numbers;
+    }
+
+    public function setNumbers($numbers)
+    {
+        $this->numbers = $numbers;
+    }
+
+    public function toArray()
+    {
+        return array('title' => $this->title, 'numbers' => $this->numbers);
+    }
+}
+
+class Foo
+{
+    private $bar;
+
+    public function __construct(Bar $bar)
+    {
+        $this->bar = $bar;
+    }
+}
+
+class Bar
+{
+    private $value;
+
+    public function __construct($value)
+    {
+        $this->value = $value;
+    }
+}