Actualización

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/AddCacheWarmerPassTest.php

@@ -0,0 +1,99 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\AddCacheWarmerPass;
+
+class AddCacheWarmerPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testThatCacheWarmersAreProcessedInPriorityOrder()
+    {
+        $services = array(
+            'my_cache_warmer_service1' => array(0 => array('priority' => 100)),
+            'my_cache_warmer_service2' => array(0 => array('priority' => 200)),
+            'my_cache_warmer_service3' => array(),
+        );
+
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('findTaggedServiceIds', 'getDefinition', 'hasDefinition')
+        );
+
+        $container->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue($services));
+        $container->expects($this->atLeastOnce())
+            ->method('getDefinition')
+            ->with('cache_warmer')
+            ->will($this->returnValue($definition));
+        $container->expects($this->atLeastOnce())
+            ->method('hasDefinition')
+            ->with('cache_warmer')
+            ->will($this->returnValue(true));
+
+        $definition->expects($this->once())
+            ->method('replaceArgument')
+            ->with(0, array(
+                new Reference('my_cache_warmer_service2'),
+                new Reference('my_cache_warmer_service1'),
+                new Reference('my_cache_warmer_service3'),
+            ));
+
+        $addCacheWarmerPass = new AddCacheWarmerPass();
+        $addCacheWarmerPass->process($container);
+    }
+
+    public function testThatCompilerPassIsIgnoredIfThereIsNoCacheWarmerDefinition()
+    {
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'findTaggedServiceIds', 'getDefinition')
+        );
+
+        $container->expects($this->never())->method('findTaggedServiceIds');
+        $container->expects($this->never())->method('getDefinition');
+        $container->expects($this->atLeastOnce())
+            ->method('hasDefinition')
+            ->with('cache_warmer')
+            ->will($this->returnValue(false));
+        $definition->expects($this->never())->method('replaceArgument');
+
+        $addCacheWarmerPass = new AddCacheWarmerPass();
+        $addCacheWarmerPass->process($container);
+    }
+
+    public function testThatCacheWarmersMightBeNotDefined()
+    {
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'findTaggedServiceIds', 'getDefinition')
+        );
+
+        $container->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue(array()));
+        $container->expects($this->never())->method('getDefinition');
+        $container->expects($this->atLeastOnce())
+            ->method('hasDefinition')
+            ->with('cache_warmer')
+            ->will($this->returnValue(true));
+
+        $definition->expects($this->never())->method('replaceArgument');
+
+        $addCacheWarmerPass = new AddCacheWarmerPass();
+        $addCacheWarmerPass->process($container);
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/AddConsoleCommandPassTest.php

@@ -0,0 +1,119 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\AddConsoleCommandPass;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\HttpKernel\Bundle\Bundle;
+
+class AddConsoleCommandPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcess()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddConsoleCommandPass());
+        $container->setParameter('my-command.class', 'Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\MyCommand');
+
+        $definition = new Definition('%my-command.class%');
+        $definition->addTag('console.command');
+        $container->setDefinition('my-command', $definition);
+
+        $container->compile();
+
+        $alias = 'console.command.symfony_bundle_frameworkbundle_tests_dependencyinjection_compiler_mycommand';
+        $this->assertTrue($container->hasAlias($alias));
+        $this->assertSame('my-command', (string) $container->getAlias($alias));
+
+        $this->assertTrue($container->hasParameter('console.command.ids'));
+        $this->assertSame(array('my-command'), $container->getParameter('console.command.ids'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The service "my-command" tagged "console.command" must be public.
+     */
+    public function testProcessThrowAnExceptionIfTheServiceIsNotPublic()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddConsoleCommandPass());
+
+        $definition = new Definition('Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\MyCommand');
+        $definition->addTag('console.command');
+        $definition->setPublic(false);
+        $container->setDefinition('my-command', $definition);
+
+        $container->compile();
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The service "my-command" tagged "console.command" must not be abstract.
+     */
+    public function testProcessThrowAnExceptionIfTheServiceIsAbstract()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddConsoleCommandPass());
+
+        $definition = new Definition('Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\MyCommand');
+        $definition->addTag('console.command');
+        $definition->setAbstract(true);
+        $container->setDefinition('my-command', $definition);
+
+        $container->compile();
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The service "my-command" tagged "console.command" must be a subclass of "Symfony\Component\Console\Command\Command".
+     */
+    public function testProcessThrowAnExceptionIfTheServiceIsNotASubclassOfCommand()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddConsoleCommandPass());
+
+        $definition = new Definition('SplObjectStorage');
+        $definition->addTag('console.command');
+        $container->setDefinition('my-command', $definition);
+
+        $container->compile();
+    }
+
+    public function testHttpKernelRegisterCommandsIngoreCommandAsAService()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddConsoleCommandPass());
+        $definition = new Definition('Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\MyCommand');
+        $definition->addTag('console.command');
+        $container->setDefinition('my-command', $definition);
+        $container->compile();
+
+        $application = $this->getMock('Symfony\Component\Console\Application');
+        // Never called, because it's the
+        // Symfony\Bundle\FrameworkBundle\Console\Application that register
+        // commands as a service
+        $application->expects($this->never())->method('add');
+
+        $bundle = new ExtensionPresentBundle();
+        $bundle->setContainer($container);
+        $bundle->registerCommands($application);
+    }
+}
+
+class MyCommand extends Command
+{
+}
+
+class ExtensionPresentBundle extends Bundle
+{
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/AddConstraintValidatorsPassTest.php

@@ -0,0 +1,87 @@
+<?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.
+ */
+
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\AddConstraintValidatorsPass;
+
+class AddConstraintValidatorsPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testThatConstraintValidatorServicesAreProcessed()
+    {
+        $services = array(
+            'my_constraint_validator_service1' => array(0 => array('alias' => 'my_constraint_validator_alias1')),
+            'my_constraint_validator_service2' => array(),
+        );
+
+        $validatorFactoryDefinition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('findTaggedServiceIds', 'getDefinition', 'hasDefinition')
+        );
+
+        $validatorDefinition1 = $this->getMock('Symfony\Component\DependencyInjection\Definition', array('getClass'));
+        $validatorDefinition2 = $this->getMock('Symfony\Component\DependencyInjection\Definition', array('getClass'));
+
+        $validatorDefinition1->expects($this->atLeastOnce())
+            ->method('getClass')
+            ->willReturn('My\Fully\Qualified\Class\Named\Validator1');
+        $validatorDefinition2->expects($this->atLeastOnce())
+            ->method('getClass')
+            ->willReturn('My\Fully\Qualified\Class\Named\Validator2');
+
+        $container->expects($this->any())
+            ->method('getDefinition')
+            ->with($this->anything())
+            ->will($this->returnValueMap(array(
+                array('my_constraint_validator_service1', $validatorDefinition1),
+                array('my_constraint_validator_service2', $validatorDefinition2),
+                array('validator.validator_factory', $validatorFactoryDefinition),
+            )));
+
+        $container->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue($services));
+        $container->expects($this->atLeastOnce())
+            ->method('hasDefinition')
+            ->with('validator.validator_factory')
+            ->will($this->returnValue(true));
+
+        $validatorFactoryDefinition->expects($this->once())
+            ->method('replaceArgument')
+            ->with(1, array(
+                'My\Fully\Qualified\Class\Named\Validator1' => 'my_constraint_validator_service1',
+                'my_constraint_validator_alias1' => 'my_constraint_validator_service1',
+                'My\Fully\Qualified\Class\Named\Validator2' => 'my_constraint_validator_service2',
+            ));
+
+        $addConstraintValidatorsPass = new AddConstraintValidatorsPass();
+        $addConstraintValidatorsPass->process($container);
+    }
+
+    public function testThatCompilerPassIsIgnoredIfThereIsNoConstraintValidatorFactoryDefinition()
+    {
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'findTaggedServiceIds', 'getDefinition')
+        );
+
+        $container->expects($this->never())->method('findTaggedServiceIds');
+        $container->expects($this->never())->method('getDefinition');
+        $container->expects($this->atLeastOnce())
+            ->method('hasDefinition')
+            ->with('validator.validator_factory')
+            ->will($this->returnValue(false));
+        $definition->expects($this->never())->method('replaceArgument');
+
+        $addConstraintValidatorsPass = new AddConstraintValidatorsPass();
+        $addConstraintValidatorsPass->process($container);
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/AddExpressionLanguageProvidersPassTest.php

@@ -0,0 +1,102 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\AddExpressionLanguageProvidersPass;
+
+class AddExpressionLanguageProvidersPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcessForRouter()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddExpressionLanguageProvidersPass());
+
+        $definition = new Definition('Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\TestProvider');
+        $definition->addTag('routing.expression_language_provider');
+        $container->setDefinition('some_routing_provider', $definition);
+
+        $container->register('router', '\stdClass');
+        $container->compile();
+
+        $router = $container->getDefinition('router');
+        $calls = $router->getMethodCalls();
+        $this->assertCount(1, $calls);
+        $this->assertEquals('addExpressionLanguageProvider', $calls[0][0]);
+        $this->assertEquals(new Reference('some_routing_provider'), $calls[0][1][0]);
+    }
+
+    public function testProcessForRouterAlias()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddExpressionLanguageProvidersPass());
+
+        $definition = new Definition('Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\TestProvider');
+        $definition->addTag('routing.expression_language_provider');
+        $container->setDefinition('some_routing_provider', $definition);
+
+        $container->register('my_router', '\stdClass');
+        $container->setAlias('router', 'my_router');
+        $container->compile();
+
+        $router = $container->getDefinition('my_router');
+        $calls = $router->getMethodCalls();
+        $this->assertCount(1, $calls);
+        $this->assertEquals('addExpressionLanguageProvider', $calls[0][0]);
+        $this->assertEquals(new Reference('some_routing_provider'), $calls[0][1][0]);
+    }
+
+    public function testProcessForSecurity()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddExpressionLanguageProvidersPass());
+
+        $definition = new Definition('Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\TestProvider');
+        $definition->addTag('security.expression_language_provider');
+        $container->setDefinition('some_security_provider', $definition);
+
+        $container->register('security.access.expression_voter', '\stdClass');
+        $container->compile();
+
+        $router = $container->getDefinition('security.access.expression_voter');
+        $calls = $router->getMethodCalls();
+        $this->assertCount(1, $calls);
+        $this->assertEquals('addExpressionLanguageProvider', $calls[0][0]);
+        $this->assertEquals(new Reference('some_security_provider'), $calls[0][1][0]);
+    }
+
+    public function testProcessForSecurityAlias()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new AddExpressionLanguageProvidersPass());
+
+        $definition = new Definition('Symfony\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler\TestProvider');
+        $definition->addTag('security.expression_language_provider');
+        $container->setDefinition('some_security_provider', $definition);
+
+        $container->register('my_security.access.expression_voter', '\stdClass');
+        $container->setAlias('security.access.expression_voter', 'my_security.access.expression_voter');
+        $container->compile();
+
+        $router = $container->getDefinition('my_security.access.expression_voter');
+        $calls = $router->getMethodCalls();
+        $this->assertCount(1, $calls);
+        $this->assertEquals('addExpressionLanguageProvider', $calls[0][0]);
+        $this->assertEquals(new Reference('some_security_provider'), $calls[0][1][0]);
+    }
+}
+
+class TestProvider
+{
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/ConfigCachePassTest.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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\ConfigCachePass;
+
+class ConfigCachePassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testThatCheckersAreProcessedInPriorityOrder()
+    {
+        $services = array(
+            'checker_2' => array(0 => array('priority' => 100)),
+            'checker_1' => array(0 => array('priority' => 200)),
+            'checker_3' => array(),
+        );
+
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('findTaggedServiceIds', 'getDefinition', 'hasDefinition')
+        );
+
+        $container->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue($services));
+        $container->expects($this->atLeastOnce())
+            ->method('getDefinition')
+            ->with('config_cache_factory')
+            ->will($this->returnValue($definition));
+
+        $definition->expects($this->once())
+            ->method('replaceArgument')
+            ->with(0, array(
+                    new Reference('checker_1'),
+                    new Reference('checker_2'),
+                    new Reference('checker_3'),
+                ));
+
+        $pass = new ConfigCachePass();
+        $pass->process($container);
+    }
+
+    public function testThatCheckersCanBeMissing()
+    {
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('findTaggedServiceIds')
+        );
+
+        $container->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue(array()));
+
+        $pass = new ConfigCachePass();
+        $pass->process($container);
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/FormPassTest.php

@@ -0,0 +1,192 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\FormPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\Form\AbstractType;
+
+/**
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class FormPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testDoNothingIfFormExtensionNotLoaded()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new FormPass());
+
+        $container->compile();
+
+        $this->assertFalse($container->hasDefinition('form.extension'));
+    }
+
+    public function testAddTaggedTypes()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new FormPass());
+
+        $extDefinition = new Definition('Symfony\Component\Form\Extension\DependencyInjection\DependencyInjectionExtension');
+        $extDefinition->setArguments(array(
+            new Reference('service_container'),
+            array(),
+            array(),
+            array(),
+        ));
+
+        $container->setDefinition('form.extension', $extDefinition);
+        $container->register('my.type1', __CLASS__.'_Type1')->addTag('form.type');
+        $container->register('my.type2', __CLASS__.'_Type2')->addTag('form.type');
+
+        $container->compile();
+
+        $extDefinition = $container->getDefinition('form.extension');
+
+        $this->assertEquals(array(
+            __CLASS__.'_Type1' => 'my.type1',
+            __CLASS__.'_Type2' => 'my.type2',
+        ), $extDefinition->getArgument(1));
+    }
+
+    public function testAddTaggedTypeExtensions()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new FormPass());
+
+        $extDefinition = new Definition('Symfony\Component\Form\Extension\DependencyInjection\DependencyInjectionExtension', array(
+            new Reference('service_container'),
+            array(),
+            array(),
+            array(),
+        ));
+
+        $container->setDefinition('form.extension', $extDefinition);
+        $container->register('my.type_extension1', 'stdClass')
+            ->addTag('form.type_extension', array('extended_type' => 'type1'));
+        $container->register('my.type_extension2', 'stdClass')
+            ->addTag('form.type_extension', array('extended_type' => 'type1'));
+        $container->register('my.type_extension3', 'stdClass')
+            ->addTag('form.type_extension', array('extended_type' => 'type2'));
+
+        $container->compile();
+
+        $extDefinition = $container->getDefinition('form.extension');
+
+        $this->assertSame(array(
+            'type1' => array(
+                'my.type_extension1',
+                'my.type_extension2',
+            ),
+            'type2' => array(
+                'my.type_extension3',
+            ),
+        ), $extDefinition->getArgument(2));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage extended-type attribute, none was configured for the "my.type_extension" service
+     */
+    public function testAddTaggedFormTypeExtensionWithoutExtendedTypeAttribute()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new FormPass());
+
+        $extDefinition = new Definition('Symfony\Component\Form\Extension\DependencyInjection\DependencyInjectionExtension', array(
+            new Reference('service_container'),
+            array(),
+            array(),
+            array(),
+        ));
+
+        $container->setDefinition('form.extension', $extDefinition);
+        $container->register('my.type_extension', 'stdClass')
+            ->addTag('form.type_extension');
+
+        $container->compile();
+    }
+
+    public function testAddTaggedGuessers()
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new FormPass());
+
+        $extDefinition = new Definition('Symfony\Component\Form\Extension\DependencyInjection\DependencyInjectionExtension');
+        $extDefinition->setArguments(array(
+            new Reference('service_container'),
+            array(),
+            array(),
+            array(),
+        ));
+
+        $definition1 = new Definition('stdClass');
+        $definition1->addTag('form.type_guesser');
+        $definition2 = new Definition('stdClass');
+        $definition2->addTag('form.type_guesser');
+
+        $container->setDefinition('form.extension', $extDefinition);
+        $container->setDefinition('my.guesser1', $definition1);
+        $container->setDefinition('my.guesser2', $definition2);
+
+        $container->compile();
+
+        $extDefinition = $container->getDefinition('form.extension');
+
+        $this->assertSame(array(
+            'my.guesser1',
+            'my.guesser2',
+        ), $extDefinition->getArgument(3));
+    }
+
+    /**
+     * @dataProvider privateTaggedServicesProvider
+     */
+    public function testPrivateTaggedServices($id, $tagName, $expectedExceptionMessage)
+    {
+        $container = new ContainerBuilder();
+        $container->addCompilerPass(new FormPass());
+
+        $extDefinition = new Definition('Symfony\Component\Form\Extension\DependencyInjection\DependencyInjectionExtension');
+        $extDefinition->setArguments(array(
+            new Reference('service_container'),
+            array(),
+            array(),
+            array(),
+        ));
+
+        $container->setDefinition('form.extension', $extDefinition);
+        $container->register($id, 'stdClass')->setPublic(false)->addTag($tagName);
+
+        $this->setExpectedException('\InvalidArgumentException', $expectedExceptionMessage);
+
+        $container->compile();
+    }
+
+    public function privateTaggedServicesProvider()
+    {
+        return array(
+            array('my.type', 'form.type', 'The service "my.type" must be public as form types are lazy-loaded'),
+            array('my.type_extension', 'form.type_extension', 'The service "my.type_extension" must be public as form type extensions are lazy-loaded'),
+            array('my.guesser', 'form.type_guesser', 'The service "my.guesser" must be public as form type guessers are lazy-loaded'),
+        );
+    }
+}
+
+class FormPassTest_Type1 extends AbstractType
+{
+}
+
+class FormPassTest_Type2 extends AbstractType
+{
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/LoggingTranslatorPassTest.php

@@ -0,0 +1,86 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\LoggingTranslatorPass;
+
+class LoggingTranslatorPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcess()
+    {
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $parameterBag = $this->getMock('Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface');
+
+        $container->expects($this->exactly(2))
+            ->method('hasAlias')
+            ->will($this->returnValue(true));
+
+        $container->expects($this->once())
+            ->method('getParameter')
+            ->will($this->returnValue(true));
+
+        $container->expects($this->once())
+            ->method('getAlias')
+            ->will($this->returnValue('translation.default'));
+
+        $container->expects($this->exactly(3))
+            ->method('getDefinition')
+            ->will($this->returnValue($definition));
+
+        $container->expects($this->once())
+            ->method('hasParameter')
+            ->with('translator.logging')
+            ->will($this->returnValue(true));
+
+        $definition->expects($this->once())
+            ->method('getClass')
+            ->will($this->returnValue('Symfony\Bundle\FrameworkBundle\Translation\Translator'));
+
+        $parameterBag->expects($this->once())
+            ->method('resolveValue')
+            ->will($this->returnValue("Symfony\Bundle\FrameworkBundle\Translation\Translator"));
+
+        $container->expects($this->once())
+            ->method('getParameterBag')
+            ->will($this->returnValue($parameterBag));
+
+        $pass = new LoggingTranslatorPass();
+        $pass->process($container);
+    }
+
+    public function testThatCompilerPassIsIgnoredIfThereIsNotLoggerDefinition()
+    {
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $container->expects($this->once())
+            ->method('hasAlias')
+            ->will($this->returnValue(false));
+
+        $pass = new LoggingTranslatorPass();
+        $pass->process($container);
+    }
+
+    public function testThatCompilerPassIsIgnoredIfThereIsNotTranslatorDefinition()
+    {
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
+        $container->expects($this->at(0))
+            ->method('hasAlias')
+            ->will($this->returnValue(true));
+
+        $container->expects($this->at(0))
+            ->method('hasAlias')
+            ->will($this->returnValue(false));
+
+        $pass = new LoggingTranslatorPass();
+        $pass->process($container);
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/ProfilerPassTest.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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\ProfilerPass;
+
+class ProfilerPassTest extends \PHPUnit_Framework_TestCase
+{
+    private $profilerDefinition;
+
+    protected function setUp()
+    {
+        $this->profilerDefinition = new Definition('ProfilerClass');
+    }
+
+    /**
+     * Tests that collectors that specify a template but no "id" will throw
+     * an exception (both are needed if the template is specified).
+     *
+     * Thus, a fully-valid tag looks something like this:
+     *
+     *     <tag name="data_collector" template="YourBundle:Collector:templatename" id="your_collector_name" />
+     */
+    public function testTemplateNoIdThrowsException()
+    {
+        // one service, with a template key, but no id
+        $services = array(
+            'my_collector_service' => array(0 => array('template' => 'foo')),
+        );
+
+        $builder = $this->createContainerMock($services);
+
+        $this->setExpectedException('InvalidArgumentException');
+
+        $profilerPass = new ProfilerPass();
+        $profilerPass->process($builder);
+    }
+
+    public function testValidCollector()
+    {
+        // one service, with a template key, but no id
+        $services = array(
+            'my_collector_service' => array(0 => array('template' => 'foo', 'id' => 'my_collector')),
+        );
+
+        $container = $this->createContainerMock($services);
+
+        // fake the getDefinition() to return a Profiler definition
+        $container->expects($this->atLeastOnce())
+            ->method('getDefinition');
+
+        // assert that the data_collector.templates parameter should be set
+        $container->expects($this->once())
+            ->method('setParameter')
+            ->with('data_collector.templates', array('my_collector_service' => array('my_collector', 'foo')));
+
+        $profilerPass = new ProfilerPass();
+        $profilerPass->process($container);
+
+        // grab the method calls off of the "profiler" definition
+        $methodCalls = $this->profilerDefinition->getMethodCalls();
+        $this->assertCount(1, $methodCalls);
+        $this->assertEquals('add', $methodCalls[0][0]); // grab the method part of the first call
+    }
+
+    private function createContainerMock($services)
+    {
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'getDefinition', 'findTaggedServiceIds', 'setParameter')
+        );
+        $container->expects($this->any())
+            ->method('hasDefinition')
+            ->with($this->equalTo('profiler'))
+            ->will($this->returnValue(true));
+        $container->expects($this->any())
+            ->method('getDefinition')
+            ->will($this->returnValue($this->profilerDefinition));
+        $container->expects($this->atLeastOnce())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue($services));
+
+        return $container;
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/PropertyInfoPassTest.php

@@ -0,0 +1,72 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\PropertyInfoPass;
+use Symfony\Component\DependencyInjection\Reference;
+
+class PropertyInfoPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testServicesAreOrderedAccordingToPriority()
+    {
+        $services = array(
+            'n3' => array('tag' => array()),
+            'n1' => array('tag' => array('priority' => 200)),
+            'n2' => array('tag' => array('priority' => 100)),
+        );
+
+        $expected = array(
+            new Reference('n1'),
+            new Reference('n2'),
+            new Reference('n3'),
+        );
+
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder', array('findTaggedServiceIds'));
+
+        $container->expects($this->any())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue($services));
+
+        $propertyInfoPass = new PropertyInfoPass();
+
+        $method = new \ReflectionMethod(
+            'Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\PropertyInfoPass',
+            'findAndSortTaggedServices'
+        );
+        $method->setAccessible(true);
+
+        $actual = $method->invoke($propertyInfoPass, 'tag', $container);
+
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function testReturningEmptyArrayWhenNoService()
+    {
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder', array('findTaggedServiceIds'));
+
+        $container->expects($this->any())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue(array()));
+
+        $propertyInfoPass = new PropertyInfoPass();
+
+        $method = new \ReflectionMethod(
+            'Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\PropertyInfoPass',
+            'findAndSortTaggedServices'
+        );
+        $method->setAccessible(true);
+
+        $actual = $method->invoke($propertyInfoPass, 'tag', $container);
+
+        $this->assertEquals(array(), $actual);
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/SerializerPassTest.php

@@ -0,0 +1,106 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\SerializerPass;
+
+/**
+ * Tests for the SerializerPass class.
+ *
+ * @author Javier Lopez <f12loalf@gmail.com>
+ */
+class SerializerPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testThrowExceptionWhenNoNormalizers()
+    {
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder', array('hasDefinition', 'findTaggedServiceIds'));
+
+        $container->expects($this->once())
+            ->method('hasDefinition')
+            ->with('serializer')
+            ->will($this->returnValue(true));
+
+        $container->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with('serializer.normalizer')
+            ->will($this->returnValue(array()));
+
+        $this->setExpectedException('RuntimeException');
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+    }
+
+    public function testThrowExceptionWhenNoEncoders()
+    {
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'findTaggedServiceIds', 'getDefinition')
+        );
+
+        $container->expects($this->once())
+            ->method('hasDefinition')
+            ->with('serializer')
+            ->will($this->returnValue(true));
+
+        $container->expects($this->any())
+            ->method('findTaggedServiceIds')
+            ->will($this->onConsecutiveCalls(
+                    array('n' => array('serializer.normalizer')),
+                    array()
+              ));
+
+        $container->expects($this->once())
+            ->method('getDefinition')
+            ->will($this->returnValue($definition));
+
+        $this->setExpectedException('RuntimeException');
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+    }
+
+    public function testServicesAreOrderedAccordingToPriority()
+    {
+        $services = array(
+            'n3' => array('tag' => array()),
+            'n1' => array('tag' => array('priority' => 200)),
+            'n2' => array('tag' => array('priority' => 100)),
+        );
+
+        $expected = array(
+           new Reference('n1'),
+           new Reference('n2'),
+           new Reference('n3'),
+       );
+
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder', array('findTaggedServiceIds'));
+
+        $container->expects($this->any())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue($services));
+
+        $serializerPass = new SerializerPass();
+
+        $method = new \ReflectionMethod(
+          'Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\SerializerPass',
+          'findAndSortTaggedServices'
+        );
+        $method->setAccessible(true);
+
+        $actual = $method->invoke($serializerPass, 'tag', $container);
+
+        $this->assertEquals($expected, $actual);
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/TranslatorPassTest.php

@@ -0,0 +1,48 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\TranslatorPass;
+
+class TranslatorPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testValidCollector()
+    {
+        $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
+        $definition->expects($this->at(0))
+            ->method('addMethodCall')
+            ->with('addLoader', array('xliff', new Reference('xliff')));
+        $definition->expects($this->at(1))
+            ->method('addMethodCall')
+            ->with('addLoader', array('xlf', new Reference('xliff')));
+
+        $container = $this->getMock(
+            'Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('hasDefinition', 'getDefinition', 'findTaggedServiceIds', 'findDefinition')
+        );
+        $container->expects($this->any())
+            ->method('hasDefinition')
+            ->will($this->returnValue(true));
+        $container->expects($this->once())
+            ->method('getDefinition')
+            ->will($this->returnValue($definition));
+        $container->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->will($this->returnValue(array('xliff' => array(array('alias' => 'xliff', 'legacy-alias' => 'xlf')))));
+        $container->expects($this->once())
+            ->method('findDefinition')
+            ->will($this->returnValue($this->getMock('Symfony\Component\DependencyInjection\Definition')));
+        $pass = new TranslatorPass();
+        $pass->process($container);
+    }
+}

vendor/symfony/framework-bundle/Tests/DependencyInjection/Compiler/UnusedTagsPassTest.php

@@ -0,0 +1,52 @@
+<?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\Bundle\FrameworkBundle\Tests\DependencyInjection\Compiler;
+
+use Symfony\Bundle\FrameworkBundle\DependencyInjection\Compiler\UnusedTagsPass;
+
+class UnusedTagsPassTest extends \PHPUnit_Framework_TestCase
+{
+    public function testProcess()
+    {
+        $pass = new UnusedTagsPass();
+
+        $formatter = $this->getMock('Symfony\Component\DependencyInjection\Compiler\LoggingFormatter');
+        $formatter
+            ->expects($this->at(0))
+            ->method('format')
+            ->with($pass, 'Tag "kenrel.event_subscriber" was defined on service(s) "foo", "bar", but was never used. Did you mean "kernel.event_subscriber"?')
+        ;
+
+        $compiler = $this->getMock('Symfony\Component\DependencyInjection\Compiler\Compiler');
+        $compiler->expects($this->once())->method('getLoggingFormatter')->will($this->returnValue($formatter));
+
+        $container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder',
+            array('findTaggedServiceIds', 'getCompiler', 'findUnusedTags', 'findTags')
+        );
+        $container->expects($this->once())->method('getCompiler')->will($this->returnValue($compiler));
+        $container->expects($this->once())
+            ->method('findTags')
+            ->will($this->returnValue(array('kenrel.event_subscriber')));
+        $container->expects($this->once())
+            ->method('findUnusedTags')
+            ->will($this->returnValue(array('kenrel.event_subscriber', 'form.type')));
+        $container->expects($this->once())
+            ->method('findTaggedServiceIds')
+            ->with('kenrel.event_subscriber')
+            ->will($this->returnValue(array(
+                'foo' => array(),
+                'bar' => array(),
+            )));
+
+        $pass->process($container);
+    }
+}