9.5/_container_test_8php_source.html

<?php

namespace ‪TYPO3\CMS\Extbase\Tests\Unit\Object\Container;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */

use Psr\Log\LoggerInterface;

use ‪TYPO3\CMS\Core\Log\Logger;

use ‪TYPO3\CMS\Extbase\Object\Container\Container;

use ‪TYPO3\CMS\Extbase\Object\Exception;

use ‪TYPO3\CMS\Extbase\Object\Exception\CannotBuildObjectException;

use ‪TYPO3\CMS\Extbase\Reflection\Exception\UnknownClassException;

use ‪TYPO3\CMS\Extbase\Tests\Unit\Object\Container\Fixtures\ArgumentTestClassForPublicPropertyInjection;

use ‪TYPO3\CMS\Extbase\Tests\Unit\Object\Container\Fixtures\ProtectedPropertyInjectClass;

use ‪TYPO3\CMS\Extbase\Tests\Unit\Object\Container\Fixtures\PublicPropertyInjectClass;

use TYPO3\TestingFramework\Core\Unit\UnitTestCase;


class ‪ContainerTest extends UnitTestCase

{

    protected ‪$resetSingletonInstances = true;


    protected ‪$subject;


    protected ‪$logger;


    protected function ‪setUp()

    {

        $this->logger = $this->getMockBuilder(Logger::class)

            ->setMethods(['notice'])

            ->disableOriginalConstructor()

            ->getMock();


        $this->subject = $this->getMockBuilder(Container::class)

            ->setMethods(['getLogger'])

            ->getMock();

        $this->subject->expects($this->any())->method('getLogger')->will($this->returnValue($this->logger));

    }


    public function ‪getInstanceReturnsInstanceOfSimpleClass()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_c');

        $this->assertInstanceOf('t3lib_object_tests_c', $object);

    }


    public function ‪getInstanceReturnsInstanceOfSimpleNamespacedClass()

    {

        $object = $this->subject->getInstance(\‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\NamespacedClass::class);

        $this->assertInstanceOf(\‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\NamespacedClass::class, $object);

    }


    public function ‪getInstanceReturnsInstanceOfAClassWithConstructorInjection()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_b');

        $this->assertInstanceOf('t3lib_object_tests_b', $object);

        $this->assertInstanceOf('t3lib_object_tests_c', $object->c);

    }


    public function ‪getInstanceReturnsInstanceOfAClassWithTwoLevelDependency()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_a');

        $this->assertInstanceOf('t3lib_object_tests_a', $object);

        $this->assertInstanceOf('t3lib_object_tests_c', $object->b->c);

    }


    public function ‪getInstanceReturnsInstanceOfAClassWithMixedSimpleTypeAndConstructorInjection()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_amixed_array');

        $this->assertInstanceOf('t3lib_object_tests_amixed_array', $object);

        $this->assertEquals(['some' => 'default'], $object->myvalue);

    }


    public function ‪getInstanceReturnsInstanceOfAClassWithMixedSimpleTypeAndConstructorInjectionWithNullDefaultValue()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_amixed_null');

        $this->assertInstanceOf('t3lib_object_tests_amixed_null', $object);

        $this->assertNull($object->myvalue);

    }


    public function ‪getInstanceThrowsExceptionWhenTryingToInstanciateASingletonWithConstructorParameters()

    {

        $this->expectException(Exception::class);

        $this->expectExceptionCode(1292858051);

        $this->subject->getInstance('t3lib_object_tests_amixed_array_singleton', ['somevalue']);

    }


    public function ‪getInstanceReturnsInstanceOfAClassWithConstructorInjectionAndDefaultConstructorParameters()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_amixed_array');

        $this->assertInstanceOf('t3lib_object_tests_b', $object->b);

        $this->assertInstanceOf('t3lib_object_tests_c', $object->c);

        $this->assertEquals(['some' => 'default'], $object->myvalue);

    }


    public function ‪getInstancePassesGivenParameterToTheNewObject()

    {

        $mockObject = $this->createMock('t3lib_object_tests_c');

        $object = $this->subject->getInstance('t3lib_object_tests_a', [$mockObject]);

        $this->assertInstanceOf('t3lib_object_tests_a', $object);

        $this->assertSame($mockObject, $object->c);

    }


    public function ‪getInstanceReturnsAFreshInstanceIfObjectIsNoSingleton()

    {

        $object1 = $this->subject->getInstance('t3lib_object_tests_a');

        $object2 = $this->subject->getInstance('t3lib_object_tests_a');

        $this->assertNotSame($object1, $object2);

    }


    public function ‪getInstanceReturnsSameInstanceInstanceIfObjectIsSingleton()

    {

        $object1 = $this->subject->getInstance('t3lib_object_tests_singleton');

        $object2 = $this->subject->getInstance('t3lib_object_tests_singleton');

        $this->assertSame($object1, $object2);

    }


    public function ‪getInstanceThrowsExceptionIfPrototypeObjectsWiredViaConstructorInjectionContainCyclicDependencies()

    {

        $this->expectException(CannotBuildObjectException::class);

        $this->expectExceptionCode(1295611406);

        $this->subject->getInstance('t3lib_object_tests_cyclic1WithSetterDependency');

    }


    public function ‪getInstanceThrowsExceptionIfPrototypeObjectsWiredViaSetterInjectionContainCyclicDependencies()

    {

        $this->expectException(CannotBuildObjectException::class);

        $this->expectExceptionCode(1295611406);

        $this->subject->getInstance('t3lib_object_tests_cyclic1');

    }


    public function ‪getInstanceThrowsExceptionIfClassWasNotFound()

    {

        $this->expectException(UnknownClassException::class);

        $this->expectExceptionCode(1278450972);

        $this->subject->getInstance('nonextistingclass_bla');

    }


    public function ‪getInstanceInitializesObjects()

    {

        $instance = $this->subject->getInstance('t3lib_object_tests_initializable');

        $this->assertTrue($instance->isInitialized());

    }


    public function ‪getEmptyObjectReturnsInstanceOfSimpleClass()

    {

        $object = $this->subject->getEmptyObject('t3lib_object_tests_c');

        $this->assertInstanceOf('t3lib_object_tests_c', $object);

    }


    public function ‪getEmptyObjectReturnsInstanceOfClassImplementingSerializable()

    {

        $object = $this->subject->getEmptyObject('t3lib_object_tests_serializable');

        $this->assertInstanceOf('t3lib_object_tests_serializable', $object);

    }


    public function ‪getEmptyObjectInitializesObjects()

    {

        $object = $this->subject->getEmptyObject('t3lib_object_tests_initializable');

        $this->assertTrue($object->isInitialized());

    }


    public function ‪test_canGetChildClass()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_b_child');

        $this->assertInstanceOf('t3lib_object_tests_b_child', $object);

    }


    public function ‪test_canInjectInterfaceInClass()

    {

        $this->subject->registerImplementation('t3lib_object_tests_someinterface', 't3lib_object_tests_someimplementation');

        $object = $this->subject->getInstance('t3lib_object_tests_needsinterface');

        $this->assertInstanceOf('t3lib_object_tests_needsinterface', $object);

        $this->assertInstanceOf('t3lib_object_tests_someinterface', $object->dependency);

        $this->assertInstanceOf('t3lib_object_tests_someimplementation', $object->dependency);

    }


    public function ‪test_canBuildCyclicDependenciesOfSingletonsWithSetter()

    {

        $object = $this->subject->getInstance('t3lib_object_tests_resolveablecyclic1');

        $this->assertInstanceOf('t3lib_object_tests_resolveablecyclic1', $object);

        $this->assertInstanceOf('t3lib_object_tests_resolveablecyclic1', $object->o2->o3->o1);

    }


    public function ‪singletonWhichRequiresPrototypeViaSetterInjectionWorksAndAddsDebugMessage()

    {

        $this->logger->expects($this->once())->method('notice')->with('The singleton "t3lib_object_singletonNeedsPrototype" needs a prototype in "injectDependency". This is often a bad code smell; often you rather want to inject a singleton.');

        $object = $this->subject->getInstance('t3lib_object_singletonNeedsPrototype');

        $this->assertInstanceOf('t3lib_object_prototype', $object->dependency);

    }


    public function ‪singletonWhichRequiresSingletonViaSetterInjectionWorks()

    {

        $this->logger->expects($this->never())->method('notice');

        $object = $this->subject->getInstance('t3lib_object_singletonNeedsSingleton');

        $this->assertInstanceOf('t3lib_object_singleton', $object->dependency);

    }


    public function ‪prototypeWhichRequiresPrototypeViaSetterInjectionWorks()

    {

        $this->logger->expects($this->never())->method('notice');

        $object = $this->subject->getInstance('t3lib_object_prototypeNeedsPrototype');

        $this->assertInstanceOf('t3lib_object_prototype', $object->dependency);

    }


    public function ‪prototypeWhichRequiresSingletonViaSetterInjectionWorks()

    {

        $this->logger->expects($this->never())->method('notice');

        $object = $this->subject->getInstance('t3lib_object_prototypeNeedsSingleton');

        $this->assertInstanceOf('t3lib_object_singleton', $object->dependency);

    }


    public function ‪singletonWhichRequiresPrototypeViaConstructorInjectionWorksAndAddsDebugMessage()

    {

        $this->logger->expects($this->once())->method('notice')->with('The singleton "t3lib_object_singletonNeedsPrototypeInConstructor" needs a prototype in the constructor. This is often a bad code smell; often you rather want to inject a singleton.');

        $object = $this->subject->getInstance('t3lib_object_singletonNeedsPrototypeInConstructor');

        $this->assertInstanceOf('t3lib_object_prototype', $object->dependency);

    }


    public function ‪singletonWhichRequiresSingletonViaConstructorInjectionWorks()

    {

        $this->logger->expects($this->never())->method('notice');

        $object = $this->subject->getInstance('t3lib_object_singletonNeedsSingletonInConstructor');

        $this->assertInstanceOf('t3lib_object_singleton', $object->dependency);

    }


    public function ‪prototypeWhichRequiresPrototypeViaConstructorInjectionWorks()

    {

        $this->logger->expects($this->never())->method('notice');

        $object = $this->subject->getInstance('t3lib_object_prototypeNeedsPrototypeInConstructor');

        $this->assertInstanceOf('t3lib_object_prototype', $object->dependency);

    }


    public function ‪prototypeWhichRequiresSingletonViaConstructorInjectionWorks()

    {

        $this->logger->expects($this->never())->method('notice');

        $object = $this->subject->getInstance('t3lib_object_prototypeNeedsSingletonInConstructor');

        $this->assertInstanceOf('t3lib_object_singleton', $object->dependency);

    }


    public function ‪isSingletonReturnsTrueForSingletonInstancesAndFalseForPrototypes()

    {

        $this->assertTrue($this->subject->isSingleton(Container::class));

        $this->assertFalse($this->subject->isSingleton(\‪TYPO3\CMS\‪Extbase\Core\Bootstrap::class));

    }


    public function ‪isPrototypeReturnsFalseForSingletonInstancesAndTrueForPrototypes()

    {

        $this->assertFalse($this->subject->isPrototype(Container::class));

        $this->assertTrue($this->subject->isPrototype(\‪TYPO3\CMS\‪Extbase\Core\Bootstrap::class));

    }


    /************************************************

     * Test regarding constructor argument injection

     ************************************************/


    public function ‪getInstanceGivesSimpleConstructorArgumentToClassInstance()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\SimpleTypeConstructorArgument::class,

            [true]

        );

        $this->assertTrue($object->foo);

    }


    public function ‪getInstanceDoesNotInfluenceSimpleTypeConstructorArgumentIfNotGiven()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\SimpleTypeConstructorArgument::class

        );

        $this->assertFalse($object->foo);

    }


    public function ‪getInstanceGivesExistingConstructorArgumentToClassInstance()

    {

        $argumentTestClass = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgument::class,

            [$argumentTestClass]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgument::class,

            $object

        );

        $this->assertSame($argumentTestClass, $object->argumentTestClass);

    }


    public function ‪getInstanceInjectsNewInstanceOfClassToClassIfArgumentIsMandatory()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgument::class

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgument::class,

            $object

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClass

        );

    }


    public function ‪getInstanceDoesNotInjectAnOptionalArgumentIfNotGiven()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\OptionalConstructorArgument::class

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\OptionalConstructorArgument::class,

            $object

        );

        $this->assertNull($object->argumentTestClass);

    }


    public function ‪getInstanceDoesNotInjectAnOptionalArgumentIfGivenArgumentIsNull()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\OptionalConstructorArgument::class,

            [null]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\OptionalConstructorArgument::class,

            $object

        );

        $this->assertNull($object->argumentTestClass);

    }


    public function ‪getInstanceGivesExistingConstructorArgumentToClassInstanceIfArgumentIsGiven()

    {

        $argumentTestClass = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\OptionalConstructorArgument::class,

            [$argumentTestClass]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\OptionalConstructorArgument::class,

            $object

        );

        $this->assertSame($argumentTestClass, $object->argumentTestClass);

    }


    public function ‪getInstanceGivesTwoArgumentsToClassConstructor()

    {

        $firstArgument = new ‪Fixtures\ArgumentTestClass();

        $secondArgument = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class,

            [$firstArgument, $secondArgument]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class,

            $object

        );

        $this->assertSame(

            $firstArgument,

            $object->argumentTestClass

        );

        $this->assertSame(

            $secondArgument,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceInjectsTwoMandatoryArguments()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class,

            $object

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClass

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClassTwo

        );

        $this->assertNotSame(

            $object->argumentTestClass,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceInjectsSecondMandatoryArgumentIfFirstIsGiven()

    {

        $firstArgument = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class,

            [$firstArgument]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class,

            $object

        );

        $this->assertSame(

            $firstArgument,

            $object->argumentTestClass

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClassTwo

        );

        $this->assertNotSame(

            $object->argumentTestClass,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceInjectsFirstMandatoryArgumentIfSecondIsGiven()

    {

        $secondArgument = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class,

            [null, $secondArgument]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\MandatoryConstructorArgumentTwo::class,

            $object

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClass

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClassTwo

        );

        $this->assertSame(

            $secondArgument,

            $object->argumentTestClassTwo

        );

        $this->assertNotSame(

            $object->argumentTestClass,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceGivesTwoArgumentsToClassConstructorIfSecondIsOptional()

    {

        $firstArgument = new ‪Fixtures\ArgumentTestClass();

        $secondArgument = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            [$firstArgument, $secondArgument]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            $object

        );

        $this->assertSame(

            $firstArgument,

            $object->argumentTestClass

        );

        $this->assertSame(

            $secondArgument,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceInjectsFirstMandatoryArgumentIfSecondIsOptionalAndNoneAreGiven()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            $object

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClass

        );

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceInjectsFirstMandatoryArgumentIfSecondIsOptionalAndBothAreGivenAsNull()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            [null, null]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            $object

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClass

        );

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceGivesFirstArgumentToConstructorIfSecondIsOptionalAndFirstIsGiven()

    {

        $firstArgument = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            [$firstArgument]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            $object

        );

        $this->assertSame(

            $firstArgument,

            $object->argumentTestClass

        );

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceGivesFirstArgumentToConstructorIfSecondIsOptionalFirstIsGivenAndSecondIsGivenNull()

    {

        $firstArgument = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            [$firstArgument, null]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsSecondOptional::class,

            $object

        );

        $this->assertSame(

            $firstArgument,

            $object->argumentTestClass

        );

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceOnFirstOptionalAndSecondMandatoryInjectsSecondArgumentIfFirstIsGivenAsNull()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            [null]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            $object

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceOnFirstOptionalAndSecondMandatoryGivesTwoGivenArgumentsToConstructor()

    {

        $first = new ‪Fixtures\ArgumentTestClass();

        $second = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            [$first, $second]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            $object

        );

        $this->assertSame(

            $first,

            $object->argumentTestClass

        );

        $this->assertSame(

            $second,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceOnFirstOptionalAndSecondMandatoryInjectsSecondArgumentIfFirstIsGiven()

    {

        $first = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            [$first]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            $object

        );

        $this->assertSame(

            $first,

            $object->argumentTestClass

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClassTwo

        );

        $this->assertNotSame(

            $object->argumentTestClass,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceOnFirstOptionalAndSecondMandatoryGivesSecondArgumentAsIsIfFirstIsGivenAsNullAndSecondIsGiven()

    {

        $second = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            [null, $second]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            $object

        );

        $this->assertSame(

            $second,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceOnFirstOptionalAndSecondMandatoryInjectsSecondArgumentIfFirstIsGivenAsNullAndSecondIsNull()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            [null, null]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsFirstOptional::class,

            $object

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\ArgumentTestClass::class,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceOnTwoOptionalGivesTwoGivenArgumentsToConstructor()

    {

        $first = new ‪Fixtures\ArgumentTestClass();

        $second = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            [$first, $second]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            $object

        );

        $this->assertSame(

            $first,

            $object->argumentTestClass

        );

        $this->assertSame(

            $second,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceOnTwoOptionalGivesNoArgumentsToConstructorIfArgumentsAreNull()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            [null, null]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            $object

        );

        $this->assertNull($object->argumentTestClass);

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceOnTwoOptionalGivesNoArgumentsToConstructorIfNoneAreGiven()

    {

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            $object

        );

        $this->assertNull($object->argumentTestClass);

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceOnTwoOptionalGivesOneArgumentToConstructorIfFirstIsObjectAndSecondIsNotGiven()

    {

        $first = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            [$first]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            $object

        );

        $this->assertSame(

            $first,

            $object->argumentTestClass

        );

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceOnTwoOptionalGivesOneArgumentToConstructorIfFirstIsObjectAndSecondIsNull()

    {

        $first = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            [$first, null]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            $object

        );

        $this->assertSame(

            $first,

            $object->argumentTestClass

        );

        $this->assertNull($object->argumentTestClassTwo);

    }


    public function ‪getInstanceOnTwoOptionalGivesOneArgumentToConstructorIfFirstIsNullAndSecondIsObject()

    {

        $second = new ‪Fixtures\ArgumentTestClass();

        $object = $this->subject->getInstance(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            [null, $second]

        );

        $this->assertInstanceOf(

            \‪TYPO3\CMS\‪Extbase\Tests\Unit\Object\‪Container\Fixtures\TwoConstructorArgumentsBothOptional::class,

            $object

        );

        $this->assertNull($object->argumentTestClass);

        $this->assertSame(

            $second,

            $object->argumentTestClassTwo

        );

    }


    public function ‪getInstanceInjectsPublicProperties()

    {

        $container = new ‪Container();

        $object = $container->getInstance(PublicPropertyInjectClass::class);

        self::assertInstanceOf(ArgumentTestClassForPublicPropertyInjection::class, $object->foo);

    }


    public function ‪getInstanceInjectsProtectedProperties()

    {

        $container = new ‪Container();

        $object = $container->getInstance(ProtectedPropertyInjectClass::class);

        self::assertInstanceOf(ArgumentTestClassForPublicPropertyInjection::class, $object->getFoo());

    }

}