Actualización

vendor/symfony/dependency-injection/Tests/Fixtures/containers/CustomContainer.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Symfony\Component\DependencyInjection\Tests\Fixtures\containers;
+
+use Symfony\Component\DependencyInjection\Container;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
+
+class CustomContainer extends Container
+{
+    public function getBarService()
+    {
+    }
+
+    public function getFoobarService()
+    {
+    }
+}

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container10.php

@@ -0,0 +1,15 @@
+<?php
+
+require_once __DIR__.'/../includes/classes.php';
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass')->
+    addArgument(new Reference('bar'))
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container11.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass')->
+    addArgument(new Definition('BarClass', [new Definition('BazClass')]))
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container12.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass\\Foo')->
+    addArgument('foo<>&bar')->
+    addTag('foo"bar\\bar', ['foo' => 'foo"barřž€'])
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container13.php

@@ -0,0 +1,18 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+$container->
+    register('foo', 'FooClass')->
+    addArgument(new Reference('bar'))
+    ->setPublic(true)
+;
+$container->
+    register('bar', 'BarClass')
+    ->setPublic(true)
+;
+$container->compile();
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container14.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Container14;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/*
+ * This file is included in Tests\Dumper\GraphvizDumperTest::testDumpWithFrozenCustomClassContainer
+ * and Tests\Dumper\XmlDumperTest::testCompiledContainerCanBeDumped.
+ */
+if (!class_exists('Container14\ProjectServiceContainer')) {
+    class ProjectServiceContainer extends ContainerBuilder
+    {
+    }
+}
+
+return new ProjectServiceContainer();

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container15.php

@@ -0,0 +1,12 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', 'FooClass\\Foo')
+    ->setDecoratedService('bar', 'bar.woozy')
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container16.php

@@ -0,0 +1,12 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', 'FooClass\\Foo')
+    ->setDecoratedService('bar')
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container17.php

@@ -0,0 +1,11 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', '%foo.class%')
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container19.php

@@ -0,0 +1,27 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+require_once __DIR__.'/../includes/classes.php';
+
+$container = new ContainerBuilder();
+
+$container->setParameter('env(FOO)', 'Bar\FaooClass');
+$container->setParameter('foo', '%env(FOO)%');
+
+$container
+    ->register('service_from_anonymous_factory', '%foo%')
+    ->setFactory([new Definition('%foo%'), 'getInstance'])
+    ->setPublic(true)
+;
+
+$anonymousServiceWithFactory = new Definition('Bar\FooClass');
+$anonymousServiceWithFactory->setFactory('Bar\FooClass::getInstance');
+$container
+    ->register('service_with_method_call_and_factory', 'Bar\FooClass')
+    ->addMethodCall('setBar', [$anonymousServiceWithFactory])
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container21.php

@@ -0,0 +1,21 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+$container = new ContainerBuilder();
+
+$bar = new Definition('Bar');
+$bar->setConfigurator([new Definition('Baz'), 'configureBar']);
+
+$fooFactory = new Definition('FooFactory');
+$fooFactory->setFactory([new Definition('Foobar'), 'createFooFactory']);
+
+$container
+    ->register('foo', 'Foo')
+    ->setFactory([$fooFactory, 'createFoo'])
+    ->setConfigurator([$bar, 'configureFoo'])
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container24.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+
+$container
+    ->register('foo', 'Foo')
+    ->setAutowired(true)
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container33.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Symfony\Component\DependencyInjection\Tests\Fixtures\Container33;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+
+$container->register(\Foo\Foo::class)->setPublic(true);
+$container->register(\Bar\Foo::class)->setPublic(true);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container8.php

@@ -0,0 +1,25 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
+
+$container = new ContainerBuilder(new ParameterBag([
+    'foo' => '%baz%',
+    'baz' => 'bar',
+    'bar' => 'foo is %%foo bar',
+    'escape' => '@escapeme',
+    'values' => [true, false, null, 0, 1000.3, 'true', 'false', 'null'],
+    'null string' => 'null',
+    'string of digits' => '123',
+    'string of digits prefixed with minus character' => '-123',
+    'true string' => 'true',
+    'false string' => 'false',
+    'binary number string' => '0b0110',
+    'numeric string' => '-1.2E2',
+    'hexadecimal number string' => '0xFF',
+    'float string' => '10100.1',
+    'positive float string' => '+10100.1',
+    'negative float string' => '-10100.1',
+]));
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container9.php

@@ -0,0 +1,176 @@
+<?php
+
+require_once __DIR__.'/../includes/classes.php';
+require_once __DIR__.'/../includes/foo.php';
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Parameter;
+use Symfony\Component\ExpressionLanguage\Expression;
+
+$container = new ContainerBuilder();
+$container
+    ->register('foo', '\Bar\FooClass')
+    ->addTag('foo', ['foo' => 'foo'])
+    ->addTag('foo', ['bar' => 'bar', 'baz' => 'baz'])
+    ->setFactory(['Bar\\FooClass', 'getInstance'])
+    ->setArguments(['foo', new Reference('foo.baz'), ['%foo%' => 'foo is %foo%', 'foobar' => '%foo%'], true, new Reference('service_container')])
+    ->setProperties(['foo' => 'bar', 'moo' => new Reference('foo.baz'), 'qux' => ['%foo%' => 'foo is %foo%', 'foobar' => '%foo%']])
+    ->addMethodCall('setBar', [new Reference('bar')])
+    ->addMethodCall('initialize')
+    ->setConfigurator('sc_configure')
+    ->setPublic(true)
+;
+$container
+    ->register('foo.baz', '%baz_class%')
+    ->setFactory(['%baz_class%', 'getInstance'])
+    ->setConfigurator(['%baz_class%', 'configureStatic1'])
+    ->setPublic(true)
+;
+$container
+    ->register('bar', 'Bar\FooClass')
+    ->setArguments(['foo', new Reference('foo.baz'), new Parameter('foo_bar')])
+    ->setConfigurator([new Reference('foo.baz'), 'configure'])
+    ->setPublic(true)
+;
+$container
+    ->register('foo_bar', '%foo_class%')
+    ->addArgument(new Reference('deprecated_service'))
+    ->setShared(false)
+    ->setPublic(true)
+;
+$container->getParameterBag()->clear();
+$container->getParameterBag()->add([
+    'baz_class' => 'BazClass',
+    'foo_class' => 'Bar\FooClass',
+    'foo' => 'bar',
+]);
+$container
+    ->register('method_call1', 'Bar\FooClass')
+    ->setFile(realpath(__DIR__.'/../includes/foo.php'))
+    ->addMethodCall('setBar', [new Reference('foo')])
+    ->addMethodCall('setBar', [new Reference('foo2', ContainerInterface::NULL_ON_INVALID_REFERENCE)])
+    ->addMethodCall('setBar', [new Reference('foo3', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)])
+    ->addMethodCall('setBar', [new Reference('foobaz', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)])
+    ->addMethodCall('setBar', [new Expression('service("foo").foo() ~ (container.hasParameter("foo") ? parameter("foo") : "default")')])
+    ->setPublic(true)
+;
+$container
+    ->register('foo_with_inline', 'Foo')
+    ->addMethodCall('setBar', [new Reference('inlined')])
+    ->setPublic(true)
+;
+$container
+    ->register('inlined', 'Bar')
+    ->setProperty('pub', 'pub')
+    ->addMethodCall('setBaz', [new Reference('baz')])
+    ->setPublic(false)
+;
+$container
+    ->register('baz', 'Baz')
+    ->addMethodCall('setFoo', [new Reference('foo_with_inline')])
+    ->setPublic(true)
+;
+$container
+    ->register('request', 'Request')
+    ->setSynthetic(true)
+    ->setPublic(true)
+;
+$container
+    ->register('configurator_service', 'ConfClass')
+    ->setPublic(false)
+    ->addMethodCall('setFoo', [new Reference('baz')])
+;
+$container
+    ->register('configured_service', 'stdClass')
+    ->setConfigurator([new Reference('configurator_service'), 'configureStdClass'])
+    ->setPublic(true)
+;
+$container
+    ->register('configurator_service_simple', 'ConfClass')
+    ->addArgument('bar')
+    ->setPublic(false)
+;
+$container
+    ->register('configured_service_simple', 'stdClass')
+    ->setConfigurator([new Reference('configurator_service_simple'), 'configureStdClass'])
+    ->setPublic(true)
+;
+$container
+    ->register('decorated', 'stdClass')
+    ->setPublic(true)
+;
+$container
+    ->register('decorator_service', 'stdClass')
+    ->setDecoratedService('decorated')
+    ->setPublic(true)
+;
+$container
+    ->register('decorator_service_with_name', 'stdClass')
+    ->setDecoratedService('decorated', 'decorated.pif-pouf')
+    ->setPublic(true)
+;
+$container
+    ->register('deprecated_service', 'stdClass')
+    ->setDeprecated(true)
+    ->setPublic(true)
+;
+$container
+    ->register('new_factory', 'FactoryClass')
+    ->setProperty('foo', 'bar')
+    ->setPublic(false)
+;
+$container
+    ->register('factory_service', 'Bar')
+    ->setFactory([new Reference('foo.baz'), 'getInstance'])
+    ->setPublic(true)
+;
+$container
+    ->register('new_factory_service', 'FooBarBaz')
+    ->setProperty('foo', 'bar')
+    ->setFactory([new Reference('new_factory'), 'getInstance'])
+    ->setPublic(true)
+;
+$container
+    ->register('service_from_static_method', 'Bar\FooClass')
+    ->setFactory(['Bar\FooClass', 'getInstance'])
+    ->setPublic(true)
+;
+$container
+    ->register('factory_simple', 'SimpleFactoryClass')
+    ->addArgument('foo')
+    ->setDeprecated(true)
+    ->setPublic(false)
+;
+$container
+    ->register('factory_service_simple', 'Bar')
+    ->setFactory([new Reference('factory_simple'), 'getInstance'])
+    ->setPublic(true)
+;
+$container
+    ->register('lazy_context', 'LazyContext')
+    ->setArguments([new IteratorArgument(['k1' => new Reference('foo.baz'), 'k2' => new Reference('service_container')]), new IteratorArgument([])])
+    ->setPublic(true)
+;
+$container
+    ->register('lazy_context_ignore_invalid_ref', 'LazyContext')
+    ->setArguments([new IteratorArgument([new Reference('foo.baz'), new Reference('invalid', ContainerInterface::IGNORE_ON_INVALID_REFERENCE)]), new IteratorArgument([])])
+    ->setPublic(true)
+;
+$container
+    ->register('tagged_iterator_foo', 'Bar')
+    ->addTag('foo')
+    ->setPublic(false)
+;
+$container
+    ->register('tagged_iterator', 'Bar')
+    ->addArgument(new TaggedIteratorArgument('foo'))
+    ->setPublic(true)
+;
+$container->setAlias('alias_for_foo', 'foo')->setPublic(true);
+$container->setAlias('alias_for_alias', 'alias_for_foo')->setPublic(true);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_abstract.php

@@ -0,0 +1,13 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+$container = new ContainerBuilder();
+
+$container
+    ->register('foo', 'Foo')
+    ->setAbstract(true)
+    ->setPublic(true)
+;
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_almost_circular.php

@@ -0,0 +1,176 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Tests\Fixtures\FooForCircularWithAddCalls;
+
+$public = 'public' === $visibility;
+$container = new ContainerBuilder();
+
+// same visibility for deps
+
+$container->register('foo', FooCircular::class)->setPublic(true)
+   ->addArgument(new Reference('bar'));
+
+$container->register('bar', BarCircular::class)->setPublic($public)
+    ->addMethodCall('addFoobar', [new Reference('foobar')]);
+
+$container->register('foobar', FoobarCircular::class)->setPublic($public)
+    ->addArgument(new Reference('foo'));
+
+// mixed visibility for deps
+
+$container->register('foo2', FooCircular::class)->setPublic(true)
+   ->addArgument(new Reference('bar2'));
+
+$container->register('bar2', BarCircular::class)->setPublic(!$public)
+    ->addMethodCall('addFoobar', [new Reference('foobar2')]);
+
+$container->register('foobar2', FoobarCircular::class)->setPublic($public)
+    ->addArgument(new Reference('foo2'));
+
+// simple inline setter with internal reference
+
+$container->register('bar3', BarCircular::class)->setPublic(true)
+    ->addMethodCall('addFoobar', [new Reference('foobar3'), new Reference('foobar3')]);
+
+$container->register('foobar3', FoobarCircular::class)->setPublic($public);
+
+// loop with non-shared dep
+
+$container->register('foo4', 'stdClass')->setPublic($public)
+    ->setShared(false)
+    ->setProperty('foobar', new Reference('foobar4'));
+
+$container->register('foobar4', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('foo4'));
+
+// loop on the constructor of a setter-injected dep with property
+
+$container->register('foo5', 'stdClass')->setPublic(true)
+    ->setProperty('bar', new Reference('bar5'));
+
+$container->register('bar5', 'stdClass')->setPublic($public)
+    ->addArgument(new Reference('foo5'))
+    ->setProperty('foo', new Reference('foo5'));
+
+// doctrine-like event system + some extra
+
+$container->register('manager', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('connection'));
+
+$container->register('logger', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('connection'))
+    ->setProperty('handler', (new Definition('stdClass'))->addArgument(new Reference('manager')))
+;
+$container->register('connection', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('dispatcher'))
+    ->addArgument(new Reference('config'));
+
+$container->register('config', 'stdClass')->setPublic(false)
+    ->setProperty('logger', new Reference('logger'));
+
+$container->register('dispatcher', 'stdClass')->setPublic($public)
+    ->setLazy($public)
+    ->setProperty('subscriber', new Reference('subscriber'));
+
+$container->register('subscriber', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('manager'));
+
+// doctrine-like event system + some extra (bis)
+
+$container->register('manager2', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('connection2'));
+
+$container->register('logger2', 'stdClass')->setPublic(false)
+    ->addArgument(new Reference('connection2'))
+    ->setProperty('handler2', (new Definition('stdClass'))->addArgument(new Reference('manager2')))
+;
+$container->register('connection2', 'stdClass')->setPublic(true)
+    ->addArgument(new Reference('dispatcher2'))
+    ->addArgument(new Reference('config2'));
+
+$container->register('config2', 'stdClass')->setPublic(false)
+    ->setProperty('logger2', new Reference('logger2'));
+
+$container->register('dispatcher2', 'stdClass')->setPublic($public)
+    ->setLazy($public)
+    ->setProperty('subscriber2', new Reference('subscriber2'));
+
+$container->register('subscriber2', 'stdClass')->setPublic(false)
+    ->addArgument(new Reference('manager2'));
+
+// doctrine-like event system with listener
+
+$container->register('manager3', 'stdClass')
+    ->setLazy(true)
+    ->setPublic(true)
+    ->addArgument(new Reference('connection3'));
+
+$container->register('connection3', 'stdClass')
+    ->setPublic($public)
+    ->setProperty('listener', [new Reference('listener3')]);
+
+$container->register('listener3', 'stdClass')
+    ->setPublic(true)
+    ->setProperty('manager', new Reference('manager3'));
+
+// doctrine-like event system with small differences
+
+$container->register('manager4', 'stdClass')
+    ->setLazy(true)
+    ->addArgument(new Reference('connection4'));
+
+$container->register('connection4', 'stdClass')
+    ->setPublic($public)
+    ->setProperty('listener', [new Reference('listener4')]);
+
+$container->register('listener4', 'stdClass')
+    ->setPublic(true)
+    ->addArgument(new Reference('manager4'));
+
+// private service involved in a loop
+
+$container->register('foo6', 'stdClass')
+    ->setPublic(true)
+    ->setProperty('bar6', new Reference('bar6'));
+
+$container->register('bar6', 'stdClass')
+    ->setPublic(false)
+    ->addArgument(new Reference('foo6'));
+
+$container->register('baz6', 'stdClass')
+    ->setPublic(true)
+    ->setProperty('bar6', new Reference('bar6'));
+
+// provided by Christian Schiffler
+
+$container
+    ->register('root', 'stdClass')
+    ->setArguments([new Reference('level2'), new Reference('multiuse1')])
+    ->setPublic(true);
+
+$container
+    ->register('level2', FooForCircularWithAddCalls::class)
+    ->addMethodCall('call', [new Reference('level3')]);
+
+$container->register('multiuse1', 'stdClass');
+
+$container
+    ->register('level3', 'stdClass')
+    ->addArgument(new Reference('level4'));
+
+$container
+    ->register('level4', 'stdClass')
+    ->setArguments([new Reference('multiuse1'), new Reference('level5')]);
+
+$container
+    ->register('level5', 'stdClass')
+    ->addArgument(new Reference('level6'));
+
+$container
+    ->register('level6', FooForCircularWithAddCalls::class)
+    ->addMethodCall('call', [new Reference('level5')]);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_env_in_id.php

@@ -0,0 +1,22 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+
+$container->setParameter('env(BAR)', 'bar');
+
+$container->register('foo', 'stdClass')->setPublic(true)
+   ->addArgument(new Reference('bar_%env(BAR)%'))
+   ->addArgument(['baz_%env(BAR)%' => new Reference('baz_%env(BAR)%')]);
+
+$container->register('bar', 'stdClass')->setPublic(true)
+   ->addArgument(new Reference('bar_%env(BAR)%'));
+
+$container->register('bar_%env(BAR)%', 'stdClass')->setPublic(false);
+$container->register('baz_%env(BAR)%', 'stdClass')->setPublic(false);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_inline_requires.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Symfony\Tests\InlineRequires;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Tests\Fixtures\includes\HotPath;
+use Symfony\Component\DependencyInjection\Tests\Fixtures\ParentNotExists;
+
+$container = new ContainerBuilder();
+
+$container->register(HotPath\C1::class)->addTag('container.hot_path')->setPublic(true);
+$container->register(HotPath\C2::class)->addArgument(new Reference(HotPath\C3::class))->setPublic(true);
+$container->register(HotPath\C3::class);
+$container->register(ParentNotExists::class)->setPublic(true);
+
+return $container;

vendor/symfony/dependency-injection/Tests/Fixtures/containers/container_uninitialized_ref.php

@@ -0,0 +1,49 @@
+<?php
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+$container = new ContainerBuilder();
+
+$container
+    ->register('foo1', 'stdClass')
+    ->setPublic(true)
+;
+
+$container
+    ->register('foo2', 'stdClass')
+    ->setPublic(false)
+;
+
+$container
+    ->register('foo3', 'stdClass')
+    ->setPublic(false)
+;
+
+$container
+    ->register('baz', 'stdClass')
+    ->setProperty('foo3', new Reference('foo3'))
+    ->setPublic(true)
+;
+
+$container
+    ->register('bar', 'stdClass')
+    ->setProperty('foo1', new Reference('foo1', $container::IGNORE_ON_UNINITIALIZED_REFERENCE))
+    ->setProperty('foo2', new Reference('foo2', $container::IGNORE_ON_UNINITIALIZED_REFERENCE))
+    ->setProperty('foo3', new Reference('foo3', $container::IGNORE_ON_UNINITIALIZED_REFERENCE))
+    ->setProperty('closures', [
+        new ServiceClosureArgument(new Reference('foo1', $container::IGNORE_ON_UNINITIALIZED_REFERENCE)),
+        new ServiceClosureArgument(new Reference('foo2', $container::IGNORE_ON_UNINITIALIZED_REFERENCE)),
+        new ServiceClosureArgument(new Reference('foo3', $container::IGNORE_ON_UNINITIALIZED_REFERENCE)),
+    ])
+    ->setProperty('iter', new IteratorArgument([
+        'foo1' => new Reference('foo1', $container::IGNORE_ON_UNINITIALIZED_REFERENCE),
+        'foo2' => new Reference('foo2', $container::IGNORE_ON_UNINITIALIZED_REFERENCE),
+        'foo3' => new Reference('foo3', $container::IGNORE_ON_UNINITIALIZED_REFERENCE),
+    ]))
+    ->setPublic(true)
+;
+
+return $container;