--- /dev/null
+<?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\DependencyInjection\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\DependencyInjection\Scope;
+use Symfony\Component\DependencyInjection\Container;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
+use Symfony\Component\DependencyInjection\Exception\InactiveScopeException;
+
+class ContainerTest extends TestCase
+{
+ public function testConstructor()
+ {
+ $sc = new Container();
+ $this->assertSame($sc, $sc->get('service_container'), '__construct() automatically registers itself as a service');
+
+ $sc = new Container(new ParameterBag(array('foo' => 'bar')));
+ $this->assertEquals(array('foo' => 'bar'), $sc->getParameterBag()->all(), '__construct() takes an array of parameters as its first argument');
+ }
+
+ /**
+ * @dataProvider dataForTestCamelize
+ */
+ public function testCamelize($id, $expected)
+ {
+ $this->assertEquals($expected, Container::camelize($id), sprintf('Container::camelize("%s")', $id));
+ }
+
+ public function dataForTestCamelize()
+ {
+ return array(
+ array('foo_bar', 'FooBar'),
+ array('foo.bar', 'Foo_Bar'),
+ array('foo.bar_baz', 'Foo_BarBaz'),
+ array('foo._bar', 'Foo_Bar'),
+ array('foo_.bar', 'Foo_Bar'),
+ array('_foo', 'Foo'),
+ array('.foo', '_Foo'),
+ array('foo_', 'Foo'),
+ array('foo.', 'Foo_'),
+ array('foo\bar', 'Foo_Bar'),
+ );
+ }
+
+ /**
+ * @dataProvider dataForTestUnderscore
+ */
+ public function testUnderscore($id, $expected)
+ {
+ $this->assertEquals($expected, Container::underscore($id), sprintf('Container::underscore("%s")', $id));
+ }
+
+ public function dataForTestUnderscore()
+ {
+ return array(
+ array('FooBar', 'foo_bar'),
+ array('Foo_Bar', 'foo.bar'),
+ array('Foo_BarBaz', 'foo.bar_baz'),
+ array('FooBar_BazQux', 'foo_bar.baz_qux'),
+ array('_Foo', '.foo'),
+ array('Foo_', 'foo.'),
+ );
+ }
+
+ public function testCompile()
+ {
+ $sc = new Container(new ParameterBag(array('foo' => 'bar')));
+ $this->assertFalse($sc->getParameterBag()->isResolved(), '->compile() resolves the parameter bag');
+ $sc->compile();
+ $this->assertTrue($sc->getParameterBag()->isResolved(), '->compile() resolves the parameter bag');
+ $this->assertInstanceOf('Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag', $sc->getParameterBag(), '->compile() changes the parameter bag to a FrozenParameterBag instance');
+ $this->assertEquals(array('foo' => 'bar'), $sc->getParameterBag()->all(), '->compile() copies the current parameters to the new parameter bag');
+ }
+
+ public function testIsFrozen()
+ {
+ $sc = new Container(new ParameterBag(array('foo' => 'bar')));
+ $this->assertFalse($sc->isFrozen(), '->isFrozen() returns false if the parameters are not frozen');
+ $sc->compile();
+ $this->assertTrue($sc->isFrozen(), '->isFrozen() returns true if the parameters are frozen');
+ }
+
+ public function testGetParameterBag()
+ {
+ $sc = new Container();
+ $this->assertEquals(array(), $sc->getParameterBag()->all(), '->getParameterBag() returns an empty array if no parameter has been defined');
+ }
+
+ public function testGetSetParameter()
+ {
+ $sc = new Container(new ParameterBag(array('foo' => 'bar')));
+ $sc->setParameter('bar', 'foo');
+ $this->assertEquals('foo', $sc->getParameter('bar'), '->setParameter() sets the value of a new parameter');
+
+ $sc->setParameter('foo', 'baz');
+ $this->assertEquals('baz', $sc->getParameter('foo'), '->setParameter() overrides previously set parameter');
+
+ $sc->setParameter('Foo', 'baz1');
+ $this->assertEquals('baz1', $sc->getParameter('foo'), '->setParameter() converts the key to lowercase');
+ $this->assertEquals('baz1', $sc->getParameter('FOO'), '->getParameter() converts the key to lowercase');
+
+ try {
+ $sc->getParameter('baba');
+ $this->fail('->getParameter() thrown an \InvalidArgumentException if the key does not exist');
+ } catch (\Exception $e) {
+ $this->assertInstanceOf('\InvalidArgumentException', $e, '->getParameter() thrown an \InvalidArgumentException if the key does not exist');
+ $this->assertEquals('You have requested a non-existent parameter "baba".', $e->getMessage(), '->getParameter() thrown an \InvalidArgumentException if the key does not exist');
+ }
+ }
+
+ public function testGetServiceIds()
+ {
+ $sc = new Container();
+ $sc->set('foo', $obj = new \stdClass());
+ $sc->set('bar', $obj = new \stdClass());
+ $this->assertEquals(array('service_container', 'foo', 'bar'), $sc->getServiceIds(), '->getServiceIds() returns all defined service ids');
+
+ $sc = new ProjectServiceContainer();
+ $sc->set('foo', $obj = new \stdClass());
+ $this->assertEquals(array('scoped', 'scoped_foo', 'scoped_synchronized_foo', 'inactive', 'bar', 'foo_bar', 'foo.baz', 'circular', 'throw_exception', 'throws_exception_on_service_configuration', 'service_container', 'foo'), $sc->getServiceIds(), '->getServiceIds() returns defined service ids by getXXXService() methods, followed by service ids defined by set()');
+ }
+
+ public function testSet()
+ {
+ $sc = new Container();
+ $sc->set('foo', $foo = new \stdClass());
+ $this->assertSame($foo, $sc->get('foo'), '->set() sets a service');
+ }
+
+ public function testSetWithNullResetTheService()
+ {
+ $sc = new Container();
+ $sc->set('foo', null);
+ $this->assertFalse($sc->has('foo'), '->set() with null service resets the service');
+ }
+
+ /**
+ * @expectedException \InvalidArgumentException
+ * @group legacy
+ */
+ public function testSetDoesNotAllowPrototypeScope()
+ {
+ $c = new Container();
+ $c->set('foo', new \stdClass(), Container::SCOPE_PROTOTYPE);
+ }
+
+ /**
+ * @expectedException \RuntimeException
+ * @group legacy
+ */
+ public function testSetDoesNotAllowInactiveScope()
+ {
+ $c = new Container();
+ $c->addScope(new Scope('foo'));
+ $c->set('foo', new \stdClass(), 'foo');
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testSetAlsoSetsScopedService()
+ {
+ $c = new Container();
+ $c->addScope(new Scope('foo'));
+ $c->enterScope('foo');
+ $c->set('foo', $foo = new \stdClass(), 'foo');
+
+ $scoped = $this->getField($c, 'scopedServices');
+ $this->assertTrue(isset($scoped['foo']['foo']), '->set() sets a scoped service');
+ $this->assertSame($foo, $scoped['foo']['foo'], '->set() sets a scoped service');
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testSetAlsoCallsSynchronizeService()
+ {
+ $c = new ProjectServiceContainer();
+ $c->addScope(new Scope('foo'));
+ $c->enterScope('foo');
+ $c->set('scoped_synchronized_foo', $bar = new \stdClass(), 'foo');
+ $this->assertTrue($c->synchronized, '->set() calls synchronize*Service() if it is defined for the service');
+ }
+
+ public function testSetReplacesAlias()
+ {
+ $c = new ProjectServiceContainer();
+
+ $c->set('alias', $foo = new \stdClass());
+ $this->assertSame($foo, $c->get('alias'), '->set() replaces an existing alias');
+ }
+
+ public function testGet()
+ {
+ $sc = new ProjectServiceContainer();
+ $sc->set('foo', $foo = new \stdClass());
+ $this->assertSame($foo, $sc->get('foo'), '->get() returns the service for the given id');
+ $this->assertSame($foo, $sc->get('Foo'), '->get() returns the service for the given id, and converts id to lowercase');
+ $this->assertSame($sc->__bar, $sc->get('bar'), '->get() returns the service for the given id');
+ $this->assertSame($sc->__foo_bar, $sc->get('foo_bar'), '->get() returns the service if a get*Method() is defined');
+ $this->assertSame($sc->__foo_baz, $sc->get('foo.baz'), '->get() returns the service if a get*Method() is defined');
+ $this->assertSame($sc->__foo_baz, $sc->get('foo\\baz'), '->get() returns the service if a get*Method() is defined');
+
+ $sc->set('bar', $bar = new \stdClass());
+ $this->assertSame($bar, $sc->get('bar'), '->get() prefers to return a service defined with set() than one defined with a getXXXMethod()');
+
+ try {
+ $sc->get('');
+ $this->fail('->get() throws a \InvalidArgumentException exception if the service is empty');
+ } catch (\Exception $e) {
+ $this->assertInstanceOf('Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException', $e, '->get() throws a ServiceNotFoundException exception if the service is empty');
+ }
+ $this->assertNull($sc->get('', ContainerInterface::NULL_ON_INVALID_REFERENCE), '->get() returns null if the service is empty');
+ }
+
+ public function testGetThrowServiceNotFoundException()
+ {
+ $sc = new ProjectServiceContainer();
+ $sc->set('foo', $foo = new \stdClass());
+ $sc->set('baz', $foo = new \stdClass());
+
+ try {
+ $sc->get('foo1');
+ $this->fail('->get() throws an Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException if the key does not exist');
+ } catch (\Exception $e) {
+ $this->assertInstanceOf('Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException', $e, '->get() throws an Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException if the key does not exist');
+ $this->assertEquals('You have requested a non-existent service "foo1". Did you mean this: "foo"?', $e->getMessage(), '->get() throws an Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException with some advices');
+ }
+
+ try {
+ $sc->get('bag');
+ $this->fail('->get() throws an Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException if the key does not exist');
+ } catch (\Exception $e) {
+ $this->assertInstanceOf('Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException', $e, '->get() throws an Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException if the key does not exist');
+ $this->assertEquals('You have requested a non-existent service "bag". Did you mean one of these: "bar", "baz"?', $e->getMessage(), '->get() throws an Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException with some advices');
+ }
+ }
+
+ public function testGetCircularReference()
+ {
+ $sc = new ProjectServiceContainer();
+ try {
+ $sc->get('circular');
+ $this->fail('->get() throws a ServiceCircularReferenceException if it contains circular reference');
+ } catch (\Exception $e) {
+ $this->assertInstanceOf('\Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException', $e, '->get() throws a ServiceCircularReferenceException if it contains circular reference');
+ $this->assertStringStartsWith('Circular reference detected for service "circular"', $e->getMessage(), '->get() throws a \LogicException if it contains circular reference');
+ }
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testGetReturnsNullOnInactiveScope()
+ {
+ $sc = new ProjectServiceContainer();
+ $this->assertNull($sc->get('inactive', ContainerInterface::NULL_ON_INVALID_REFERENCE));
+ }
+
+ /**
+ * @expectedException \Symfony\Component\DependencyInjection\Exception\RuntimeException
+ * @expectedExceptionMessage You have requested a synthetic service ("request"). The DIC does not know how to construct this service.
+ */
+ public function testGetSyntheticServiceAlwaysThrows()
+ {
+ require_once __DIR__.'/Fixtures/php/services9.php';
+
+ $container = new \ProjectServiceContainer();
+ $container->get('request', ContainerInterface::NULL_ON_INVALID_REFERENCE);
+ }
+
+ public function testHas()
+ {
+ $sc = new ProjectServiceContainer();
+ $sc->set('foo', new \stdClass());
+ $this->assertFalse($sc->has('foo1'), '->has() returns false if the service does not exist');
+ $this->assertTrue($sc->has('foo'), '->has() returns true if the service exists');
+ $this->assertTrue($sc->has('bar'), '->has() returns true if a get*Method() is defined');
+ $this->assertTrue($sc->has('foo_bar'), '->has() returns true if a get*Method() is defined');
+ $this->assertTrue($sc->has('foo.baz'), '->has() returns true if a get*Method() is defined');
+ $this->assertTrue($sc->has('foo\\baz'), '->has() returns true if a get*Method() is defined');
+ }
+
+ public function testInitialized()
+ {
+ $sc = new ProjectServiceContainer();
+ $sc->set('foo', new \stdClass());
+ $this->assertTrue($sc->initialized('foo'), '->initialized() returns true if service is loaded');
+ $this->assertFalse($sc->initialized('foo1'), '->initialized() returns false if service is not loaded');
+ $this->assertFalse($sc->initialized('bar'), '->initialized() returns false if a service is defined, but not currently loaded');
+ $this->assertFalse($sc->initialized('alias'), '->initialized() returns false if an aliased service is not initialized');
+
+ $sc->set('bar', new \stdClass());
+ $this->assertTrue($sc->initialized('alias'), '->initialized() returns true for alias if aliased service is initialized');
+ }
+
+ public function testReset()
+ {
+ $c = new Container();
+ $c->set('bar', new \stdClass());
+
+ $c->reset();
+
+ $this->assertNull($c->get('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE));
+ }
+
+ /**
+ * @expectedException \Symfony\Component\DependencyInjection\Exception\LogicException
+ * @expectedExceptionMessage Resetting the container is not allowed when a scope is active.
+ * @group legacy
+ */
+ public function testCannotResetInActiveScope()
+ {
+ $c = new Container();
+ $c->addScope(new Scope('foo'));
+ $c->set('bar', new \stdClass());
+
+ $c->enterScope('foo');
+
+ $c->reset();
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testResetAfterLeavingScope()
+ {
+ $c = new Container();
+ $c->addScope(new Scope('foo'));
+ $c->set('bar', new \stdClass());
+
+ $c->enterScope('foo');
+ $c->leaveScope('foo');
+
+ $c->reset();
+
+ $this->assertNull($c->get('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE));
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testEnterLeaveCurrentScope()
+ {
+ $container = new ProjectServiceContainer();
+ $container->addScope(new Scope('foo'));
+
+ $container->enterScope('foo');
+ $container->set('foo', new \stdClass(), 'foo');
+ $scoped1 = $container->get('scoped');
+ $scopedFoo1 = $container->get('scoped_foo');
+
+ $container->enterScope('foo');
+ $container->set('foo', new \stdClass(), 'foo');
+ $scoped2 = $container->get('scoped');
+ $scoped3 = $container->get('SCOPED');
+ $scopedFoo2 = $container->get('scoped_foo');
+
+ $container->set('foo', null, 'foo');
+ $container->leaveScope('foo');
+ $scoped4 = $container->get('scoped');
+ $scopedFoo3 = $container->get('scoped_foo');
+
+ $this->assertNotSame($scoped1, $scoped2);
+ $this->assertSame($scoped2, $scoped3);
+ $this->assertSame($scoped1, $scoped4);
+ $this->assertNotSame($scopedFoo1, $scopedFoo2);
+ $this->assertSame($scopedFoo1, $scopedFoo3);
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testEnterLeaveScopeWithChildScopes()
+ {
+ $container = new Container();
+ $container->addScope(new Scope('foo'));
+ $container->addScope(new Scope('bar', 'foo'));
+
+ $this->assertFalse($container->isScopeActive('foo'));
+
+ $container->enterScope('foo');
+ $container->enterScope('bar');
+
+ $this->assertTrue($container->isScopeActive('foo'));
+ $this->assertFalse($container->has('a'));
+
+ $a = new \stdClass();
+ $container->set('a', $a, 'bar');
+
+ $scoped = $this->getField($container, 'scopedServices');
+ $this->assertTrue(isset($scoped['bar']['a']));
+ $this->assertSame($a, $scoped['bar']['a']);
+ $this->assertTrue($container->has('a'));
+
+ $container->leaveScope('foo');
+
+ $scoped = $this->getField($container, 'scopedServices');
+ $this->assertFalse(isset($scoped['bar']));
+ $this->assertFalse($container->isScopeActive('foo'));
+ $this->assertFalse($container->has('a'));
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testEnterScopeRecursivelyWithInactiveChildScopes()
+ {
+ $container = new Container();
+ $container->addScope(new Scope('foo'));
+ $container->addScope(new Scope('bar', 'foo'));
+
+ $this->assertFalse($container->isScopeActive('foo'));
+
+ $container->enterScope('foo');
+
+ $this->assertTrue($container->isScopeActive('foo'));
+ $this->assertFalse($container->isScopeActive('bar'));
+ $this->assertFalse($container->has('a'));
+
+ $a = new \stdClass();
+ $container->set('a', $a, 'foo');
+
+ $scoped = $this->getField($container, 'scopedServices');
+ $this->assertTrue(isset($scoped['foo']['a']));
+ $this->assertSame($a, $scoped['foo']['a']);
+ $this->assertTrue($container->has('a'));
+
+ $container->enterScope('foo');
+
+ $scoped = $this->getField($container, 'scopedServices');
+ $this->assertFalse(isset($scoped['a']));
+ $this->assertTrue($container->isScopeActive('foo'));
+ $this->assertFalse($container->isScopeActive('bar'));
+ $this->assertFalse($container->has('a'));
+
+ $container->enterScope('bar');
+
+ $this->assertTrue($container->isScopeActive('bar'));
+
+ $container->leaveScope('foo');
+
+ $this->assertTrue($container->isScopeActive('foo'));
+ $this->assertFalse($container->isScopeActive('bar'));
+ $this->assertTrue($container->has('a'));
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testEnterChildScopeRecursively()
+ {
+ $container = new Container();
+ $container->addScope(new Scope('foo'));
+ $container->addScope(new Scope('bar', 'foo'));
+
+ $container->enterScope('foo');
+ $container->enterScope('bar');
+
+ $this->assertTrue($container->isScopeActive('bar'));
+ $this->assertFalse($container->has('a'));
+
+ $a = new \stdClass();
+ $container->set('a', $a, 'bar');
+
+ $scoped = $this->getField($container, 'scopedServices');
+ $this->assertTrue(isset($scoped['bar']['a']));
+ $this->assertSame($a, $scoped['bar']['a']);
+ $this->assertTrue($container->has('a'));
+
+ $container->enterScope('bar');
+
+ $scoped = $this->getField($container, 'scopedServices');
+ $this->assertFalse(isset($scoped['a']));
+ $this->assertTrue($container->isScopeActive('foo'));
+ $this->assertTrue($container->isScopeActive('bar'));
+ $this->assertFalse($container->has('a'));
+
+ $container->leaveScope('bar');
+
+ $this->assertTrue($container->isScopeActive('foo'));
+ $this->assertTrue($container->isScopeActive('bar'));
+ $this->assertTrue($container->has('a'));
+ }
+
+ /**
+ * @expectedException \InvalidArgumentException
+ * @group legacy
+ */
+ public function testEnterScopeNotAdded()
+ {
+ $container = new Container();
+ $container->enterScope('foo');
+ }
+
+ /**
+ * @expectedException \RuntimeException
+ * @group legacy
+ */
+ public function testEnterScopeDoesNotAllowInactiveParentScope()
+ {
+ $container = new Container();
+ $container->addScope(new Scope('foo'));
+ $container->addScope(new Scope('bar', 'foo'));
+ $container->enterScope('bar');
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testLeaveScopeNotActive()
+ {
+ $container = new Container();
+ $container->addScope(new Scope('foo'));
+
+ try {
+ $container->leaveScope('foo');
+ $this->fail('->leaveScope() throws a \LogicException if the scope is not active yet');
+ } catch (\Exception $e) {
+ $this->assertInstanceOf('\LogicException', $e, '->leaveScope() throws a \LogicException if the scope is not active yet');
+ $this->assertEquals('The scope "foo" is not active.', $e->getMessage(), '->leaveScope() throws a \LogicException if the scope is not active yet');
+ }
+
+ try {
+ $container->leaveScope('bar');
+ $this->fail('->leaveScope() throws a \LogicException if the scope does not exist');
+ } catch (\Exception $e) {
+ $this->assertInstanceOf('\LogicException', $e, '->leaveScope() throws a \LogicException if the scope does not exist');
+ $this->assertEquals('The scope "bar" is not active.', $e->getMessage(), '->leaveScope() throws a \LogicException if the scope does not exist');
+ }
+ }
+
+ /**
+ * @expectedException \InvalidArgumentException
+ * @dataProvider getLegacyBuiltInScopes
+ * @group legacy
+ */
+ public function testAddScopeDoesNotAllowBuiltInScopes($scope)
+ {
+ $container = new Container();
+ $container->addScope(new Scope($scope));
+ }
+
+ /**
+ * @expectedException \InvalidArgumentException
+ * @group legacy
+ */
+ public function testAddScopeDoesNotAllowExistingScope()
+ {
+ $container = new Container();
+ $container->addScope(new Scope('foo'));
+ $container->addScope(new Scope('foo'));
+ }
+
+ /**
+ * @expectedException \InvalidArgumentException
+ * @dataProvider getLegacyInvalidParentScopes
+ * @group legacy
+ */
+ public function testAddScopeDoesNotAllowInvalidParentScope($scope)
+ {
+ $c = new Container();
+ $c->addScope(new Scope('foo', $scope));
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testAddScope()
+ {
+ $c = new Container();
+ $c->addScope(new Scope('foo'));
+ $c->addScope(new Scope('bar', 'foo'));
+
+ $this->assertSame(array('foo' => 'container', 'bar' => 'foo'), $this->getField($c, 'scopes'));
+ $this->assertSame(array('foo' => array('bar'), 'bar' => array()), $this->getField($c, 'scopeChildren'));
+
+ $c->addScope(new Scope('baz', 'bar'));
+
+ $this->assertSame(array('foo' => 'container', 'bar' => 'foo', 'baz' => 'bar'), $this->getField($c, 'scopes'));
+ $this->assertSame(array('foo' => array('bar', 'baz'), 'bar' => array('baz'), 'baz' => array()), $this->getField($c, 'scopeChildren'));
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testHasScope()
+ {
+ $c = new Container();
+
+ $this->assertFalse($c->hasScope('foo'));
+ $c->addScope(new Scope('foo'));
+ $this->assertTrue($c->hasScope('foo'));
+ }
+
+ /**
+ * @expectedException \Exception
+ * @expectedExceptionMessage Something went terribly wrong!
+ */
+ public function testGetThrowsException()
+ {
+ $c = new ProjectServiceContainer();
+
+ try {
+ $c->get('throw_exception');
+ } catch (\Exception $e) {
+ // Do nothing.
+ }
+
+ // Retry, to make sure that get*Service() will be called.
+ $c->get('throw_exception');
+ }
+
+ public function testGetThrowsExceptionOnServiceConfiguration()
+ {
+ $c = new ProjectServiceContainer();
+
+ try {
+ $c->get('throws_exception_on_service_configuration');
+ } catch (\Exception $e) {
+ // Do nothing.
+ }
+
+ $this->assertFalse($c->initialized('throws_exception_on_service_configuration'));
+
+ // Retry, to make sure that get*Service() will be called.
+ try {
+ $c->get('throws_exception_on_service_configuration');
+ } catch (\Exception $e) {
+ // Do nothing.
+ }
+ $this->assertFalse($c->initialized('throws_exception_on_service_configuration'));
+ }
+
+ /**
+ * @group legacy
+ */
+ public function testIsScopeActive()
+ {
+ $c = new Container();
+
+ $this->assertFalse($c->isScopeActive('foo'));
+ $c->addScope(new Scope('foo'));
+
+ $this->assertFalse($c->isScopeActive('foo'));
+ $c->enterScope('foo');
+
+ $this->assertTrue($c->isScopeActive('foo'));
+ $c->leaveScope('foo');
+
+ $this->assertFalse($c->isScopeActive('foo'));
+ }
+
+ public function getLegacyInvalidParentScopes()
+ {
+ return array(
+ array(ContainerInterface::SCOPE_PROTOTYPE),
+ array('bar'),
+ );
+ }
+
+ public function getLegacyBuiltInScopes()
+ {
+ return array(
+ array(ContainerInterface::SCOPE_CONTAINER),
+ array(ContainerInterface::SCOPE_PROTOTYPE),
+ );
+ }
+
+ protected function getField($obj, $field)
+ {
+ $reflection = new \ReflectionProperty($obj, $field);
+ $reflection->setAccessible(true);
+
+ return $reflection->getValue($obj);
+ }
+
+ public function testAlias()
+ {
+ $c = new ProjectServiceContainer();
+
+ $this->assertTrue($c->has('alias'));
+ $this->assertSame($c->get('alias'), $c->get('bar'));
+ }
+
+ public function testThatCloningIsNotSupported()
+ {
+ $class = new \ReflectionClass('Symfony\Component\DependencyInjection\Container');
+ $clone = $class->getMethod('__clone');
+ if (PHP_VERSION_ID >= 50400) {
+ $this->assertFalse($class->isCloneable());
+ }
+ $this->assertTrue($clone->isPrivate());
+ }
+}
+
+class ProjectServiceContainer extends Container
+{
+ public $__bar;
+ public $__foo_bar;
+ public $__foo_baz;
+ public $synchronized;
+
+ public function __construct()
+ {
+ parent::__construct();
+
+ $this->__bar = new \stdClass();
+ $this->__foo_bar = new \stdClass();
+ $this->__foo_baz = new \stdClass();
+ $this->synchronized = false;
+ $this->aliases = array('alias' => 'bar');
+ }
+
+ protected function getScopedService()
+ {
+ if (!$this->isScopeActive('foo')) {
+ throw new \RuntimeException('Invalid call');
+ }
+
+ return $this->services['scoped'] = $this->scopedServices['foo']['scoped'] = new \stdClass();
+ }
+
+ protected function getScopedFooService()
+ {
+ if (!$this->isScopeActive('foo')) {
+ throw new \RuntimeException('invalid call');
+ }
+
+ return $this->services['scoped_foo'] = $this->scopedServices['foo']['scoped_foo'] = new \stdClass();
+ }
+
+ protected function getScopedSynchronizedFooService()
+ {
+ if (!$this->isScopeActive('foo')) {
+ throw new \RuntimeException('invalid call');
+ }
+
+ return $this->services['scoped_bar'] = $this->scopedServices['foo']['scoped_bar'] = new \stdClass();
+ }
+
+ protected function synchronizeFooService()
+ {
+ // Typically get the service to pass it to a setter
+ $this->get('foo');
+ }
+
+ protected function synchronizeScopedSynchronizedFooService()
+ {
+ $this->synchronized = true;
+ }
+
+ protected function getInactiveService()
+ {
+ throw new InactiveScopeException('request', 'request');
+ }
+
+ protected function getBarService()
+ {
+ return $this->__bar;
+ }
+
+ protected function getFooBarService()
+ {
+ return $this->__foo_bar;
+ }
+
+ protected function getFoo_BazService()
+ {
+ return $this->__foo_baz;
+ }
+
+ protected function getCircularService()
+ {
+ return $this->get('circular');
+ }
+
+ protected function getThrowExceptionService()
+ {
+ throw new \Exception('Something went terribly wrong!');
+ }
+
+ protected function getThrowsExceptionOnServiceConfigurationService()
+ {
+ $this->services['throws_exception_on_service_configuration'] = $instance = new \stdClass();
+
+ throw new \Exception('Something was terribly wrong while trying to configure the service!');
+ }
+}
projects / yaffs-website / blobdiff