PersistentCollectionTest - Code Metrics - Inspection of "#6613 #6614 correct handling of new elements added..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#6616)

by Marco

created 2017-08-11 19:14 UTC

PersistentCollectionTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	248
Duplicated Lines	34.27 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
wmc	13
lcom	1
cbo	10
dl	85
loc	248
rs	10
c	4
b	0
f	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	8	1
A	setUpPersistentCollection()	0	7	1
A	testCanBePutInLazyLoadingMode()	0	7	1
A	testCurrentInitializesCollection()	0	5	1
A	testKeyInitializesCollection()	0	5	1
A	testNextInitializesCollection()	0	5	1
A	testNonObjects()	0	18	1
A	testRemovingElementsAlsoRemovesKeys()	10	10	1
A	testClearWillAlsoClearKeys()	0	6	1
A	testClearWillAlsoResetKeyPositions()	10	10	1
B	testWillDeDuplicateNewItemsThatWerePreviouslyPersistedInDirtyCollectionAfterInitialization()	0	38	1
B	testWillKeepNewItemsInDirtyCollectionAfterInitialization()	29	29	1
B	testWillNotMarkCollectionAsDirtyAfterInitializationIfNoElementsWereAdded()	36	36	1

How to fix Duplicated Code

<?php

namespace Doctrine\Tests\ORM;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\PersistentCollection;
use Doctrine\ORM\UnitOfWork;
use Doctrine\Tests\Mocks\ConnectionMock;
use Doctrine\Tests\Mocks\DriverMock;
use Doctrine\Tests\Mocks\EntityManagerMock;
use Doctrine\Tests\Models\ECommerce\ECommerceCart;
use Doctrine\Tests\Models\ECommerce\ECommerceProduct;
use Doctrine\Tests\OrmTestCase;

/**
 * Tests the lazy-loading capabilities of the PersistentCollection and the initialization of collections.
 * @author Giorgio Sironi <[email protected]>
 * @author Austin Morris <[email protected]>
 */
class PersistentCollectionTest extends OrmTestCase
{
    /**
     * @var PersistentCollection
     */
    protected $collection;

    /**
     * @var EntityManagerMock
     */
    private $_emMock;

    protected function setUp()
    {
        parent::setUp();

        $this->_emMock = EntityManagerMock::create(new ConnectionMock([], new DriverMock()));

        $this->setUpPersistentCollection();
    }

    /**
     * Set up the PersistentCollection used for collection initialization tests.
     */
    public function setUpPersistentCollection()
    {
        $classMetaData = $this->_emMock->getClassMetadata(ECommerceCart::class);
        $this->collection = new PersistentCollection($this->_emMock, $classMetaData, new ArrayCollection);
        $this->collection->setInitialized(false);
        $this->collection->setOwner(new ECommerceCart(), $classMetaData->getAssociationMapping('products'));
    }

    public function testCanBePutInLazyLoadingMode()
    {
        $class = $this->_emMock->getClassMetadata(ECommerceProduct::class);
        $collection = new PersistentCollection($this->_emMock, $class, new ArrayCollection);
        $collection->setInitialized(false);
        $this->assertFalse($collection->isInitialized());
    }

    /**
     * Test that PersistentCollection::current() initializes the collection.
     */
    public function testCurrentInitializesCollection()
    {
        $this->collection->current();
        $this->assertTrue($this->collection->isInitialized());
    }

    /**
     * Test that PersistentCollection::key() initializes the collection.
     */
    public function testKeyInitializesCollection()
    {
        $this->collection->key();
        $this->assertTrue($this->collection->isInitialized());
    }

    /**
     * Test that PersistentCollection::next() initializes the collection.
     */
    public function testNextInitializesCollection()
    {
        $this->collection->next();
        $this->assertTrue($this->collection->isInitialized());
    }

    /**
     * @group DDC-3382
     */
    public function testNonObjects()
    {
        $this->assertEmpty($this->collection);

        $this->collection->add("dummy");

        $this->assertNotEmpty($this->collection);

        $product = new ECommerceProduct();

        $this->collection->set(1, $product);
        $this->collection->set(2, "dummy");
        $this->collection->set(3, null);

        $this->assertSame($product, $this->collection->get(1));
        $this->assertSame("dummy", $this->collection->get(2));
        $this->assertSame(null, $this->collection->get(3));
    }

    /**
     * @group 6110
     */
    public function testRemovingElementsAlsoRemovesKeys()
    {
        $dummy = new \stdClass();

        $this->collection->add($dummy);
        $this->assertEquals([0], array_keys($this->collection->toArray()));

        $this->collection->removeElement($dummy);
        $this->assertEquals([], array_keys($this->collection->toArray()));
    }

    /**
     * @group 6110
     */
    public function testClearWillAlsoClearKeys()
    {
        $this->collection->add(new \stdClass());
        $this->collection->clear();
        $this->assertEquals([], array_keys($this->collection->toArray()));
    }

    /**
     * @group 6110
     */
    public function testClearWillAlsoResetKeyPositions()
    {
        $dummy = new \stdClass();

        $this->collection->add($dummy);
        $this->collection->removeElement($dummy);
        $this->collection->clear();
        $this->collection->add($dummy);
        $this->assertEquals([0], array_keys($this->collection->toArray()));
    }

    /**
     * @group 6613
     * @group 6614
     * @group 6616
     */
    public function testWillKeepNewItemsInDirtyCollectionAfterInitialization()
    {
        /* @var $unitOfWork UnitOfWork|\PHPUnit_Framework_MockObject_MockObject */
        $unitOfWork = $this->createMock(UnitOfWork::class);

        $this->_emMock->setUnitOfWork($unitOfWork);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $newElement       = new \stdClass();
        $persistedElement = new \stdClass();

        $this->collection->add($newElement);

        self::assertFalse($this->collection->isInitialized());
        self::assertTrue($this->collection->isDirty());

        $unitOfWork
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects(self::once())
            ->method('loadCollection')
            ->with($this->collection)
            ->willReturnCallback(function (PersistentCollection $persistentCollection) use ($persistedElement) {
                $persistentCollection->unwrap()->add($persistedElement);
            });

        $this->collection->initialize();

        self::assertSame([$persistedElement, $newElement], $this->collection->toArray());
        self::assertTrue($this->collection->isInitialized());
        self::assertTrue($this->collection->isDirty());
    }

    /**
     * @group 6613
     * @group 6614
     * @group 6616
     */
    public function testWillDeDuplicateNewItemsThatWerePreviouslyPersistedInDirtyCollectionAfterInitialization()
    {
        /* @var $unitOfWork UnitOfWork|\PHPUnit_Framework_MockObject_MockObject */
        $unitOfWork = $this->createMock(UnitOfWork::class);

        $this->_emMock->setUnitOfWork($unitOfWork);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $newElement                    = new \stdClass();
        $newElementThatIsAlsoPersisted = new \stdClass();
        $persistedElement              = new \stdClass();

        $this->collection->add($newElementThatIsAlsoPersisted);
        $this->collection->add($newElement);

        self::assertFalse($this->collection->isInitialized());
        self::assertTrue($this->collection->isDirty());

        $unitOfWork
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects(self::once())
            ->method('loadCollection')
            ->with($this->collection)
            ->willReturnCallback(function (PersistentCollection $persistentCollection) use (
                $persistedElement,
                $newElementThatIsAlsoPersisted
            ) {
                $persistentCollection->unwrap()->add($newElementThatIsAlsoPersisted);
                $persistentCollection->unwrap()->add($persistedElement);
            });

        $this->collection->initialize();

        self::assertSame(
            [$newElementThatIsAlsoPersisted, $persistedElement, $newElement],
            $this->collection->toArray()
        );
        self::assertTrue($this->collection->isInitialized());
        self::assertTrue($this->collection->isDirty());
    }

    /**
     * @group 6613
     * @group 6614
     * @group 6616
     */
    public function testWillNotMarkCollectionAsDirtyAfterInitializationIfNoElementsWereAdded()
    {
        /* @var $unitOfWork UnitOfWork|\PHPUnit_Framework_MockObject_MockObject */
        $unitOfWork = $this->createMock(UnitOfWork::class);

        $this->_emMock->setUnitOfWork($unitOfWork);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $newElementThatIsAlsoPersisted = new \stdClass();
        $persistedElement              = new \stdClass();

        $this->collection->add($newElementThatIsAlsoPersisted);

        self::assertFalse($this->collection->isInitialized());
        self::assertTrue($this->collection->isDirty());

        $unitOfWork
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects(self::once())
            ->method('loadCollection')
            ->with($this->collection)
            ->willReturnCallback(function (PersistentCollection $persistentCollection) use (
                $persistedElement,
                $newElementThatIsAlsoPersisted
            ) {
                $persistentCollection->unwrap()->add($newElementThatIsAlsoPersisted);
                $persistentCollection->unwrap()->add($persistedElement);
            });

        $this->collection->initialize();

        self::assertSame(
            [$newElementThatIsAlsoPersisted, $persistedElement],
            $this->collection->toArray()
        );
        self::assertTrue($this->collection->isInitialized());
        self::assertFalse($this->collection->isDirty());
    }
}


Pull Request — master (#6616)

PersistentCollectionTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

13 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

1		<?php
2
3		namespace Doctrine\Tests\ORM;
4
5		use Doctrine\Common\Collections\ArrayCollection;
6		use Doctrine\Common\Collections\Collection;
7		use Doctrine\ORM\PersistentCollection;
8		use Doctrine\ORM\UnitOfWork;
9		use Doctrine\Tests\Mocks\ConnectionMock;
10		use Doctrine\Tests\Mocks\DriverMock;
11		use Doctrine\Tests\Mocks\EntityManagerMock;
12		use Doctrine\Tests\Models\ECommerce\ECommerceCart;
13		use Doctrine\Tests\Models\ECommerce\ECommerceProduct;
14		use Doctrine\Tests\OrmTestCase;
15
16		/**
17		* Tests the lazy-loading capabilities of the PersistentCollection and the initialization of collections.
18		* @author Giorgio Sironi <[email protected]>
19		* @author Austin Morris <[email protected]>
20		*/
21		class PersistentCollectionTest extends OrmTestCase
22		{
23		/**
24		* @var PersistentCollection
25		*/
26		protected $collection;
27
28		/**
29		* @var EntityManagerMock
30		*/
31		private $_emMock;
32
33		protected function setUp()
34		{
35		parent::setUp();
36
37		$this->_emMock = EntityManagerMock::create(new ConnectionMock([], new DriverMock()));
38
39		$this->setUpPersistentCollection();
40		}
41
42		/**
43		* Set up the PersistentCollection used for collection initialization tests.
44		*/
45		public function setUpPersistentCollection()
46		{
47		$classMetaData = $this->_emMock->getClassMetadata(ECommerceCart::class);
48		$this->collection = new PersistentCollection($this->_emMock, $classMetaData, new ArrayCollection);
49		$this->collection->setInitialized(false);
50		$this->collection->setOwner(new ECommerceCart(), $classMetaData->getAssociationMapping('products'));
51		}
52
53		public function testCanBePutInLazyLoadingMode()
54		{
55		$class = $this->_emMock->getClassMetadata(ECommerceProduct::class);
56		$collection = new PersistentCollection($this->_emMock, $class, new ArrayCollection);
57		$collection->setInitialized(false);
58		$this->assertFalse($collection->isInitialized());
59		}
60
61		/**
62		* Test that PersistentCollection::current() initializes the collection.
63		*/
64		public function testCurrentInitializesCollection()
65		{
66		$this->collection->current();
67		$this->assertTrue($this->collection->isInitialized());
68		}
69
70		/**
71		* Test that PersistentCollection::key() initializes the collection.
72		*/
73		public function testKeyInitializesCollection()
74		{
75		$this->collection->key();
76		$this->assertTrue($this->collection->isInitialized());
77		}
78
79		/**
80		* Test that PersistentCollection::next() initializes the collection.
81		*/
82		public function testNextInitializesCollection()
83		{
84		$this->collection->next();
85		$this->assertTrue($this->collection->isInitialized());
86		}
87
88		/**
89		* @group DDC-3382
90		*/
91		public function testNonObjects()
92		{
93		$this->assertEmpty($this->collection);
94
95		$this->collection->add("dummy");
96
97		$this->assertNotEmpty($this->collection);
98
99		$product = new ECommerceProduct();
100
101		$this->collection->set(1, $product);
102		$this->collection->set(2, "dummy");
103		$this->collection->set(3, null);
104
105		$this->assertSame($product, $this->collection->get(1));
106		$this->assertSame("dummy", $this->collection->get(2));
107		$this->assertSame(null, $this->collection->get(3));
108		}
109
110		/**
111		* @group 6110
112		*/
113	View Code Duplication	public function testRemovingElementsAlsoRemovesKeys()
114		{
115		$dummy = new \stdClass();
116
117		$this->collection->add($dummy);
118		$this->assertEquals([0], array_keys($this->collection->toArray()));
119
120		$this->collection->removeElement($dummy);
121		$this->assertEquals([], array_keys($this->collection->toArray()));
122		}
123
124		/**
125		* @group 6110
126		*/
127		public function testClearWillAlsoClearKeys()
128		{
129		$this->collection->add(new \stdClass());
130		$this->collection->clear();
131		$this->assertEquals([], array_keys($this->collection->toArray()));
132		}
133
134		/**
135		* @group 6110
136		*/
137	View Code Duplication	public function testClearWillAlsoResetKeyPositions()
138		{
139		$dummy = new \stdClass();
140
141		$this->collection->add($dummy);
142		$this->collection->removeElement($dummy);
143		$this->collection->clear();
144		$this->collection->add($dummy);
145		$this->assertEquals([0], array_keys($this->collection->toArray()));
146		}
147
148		/**
149		* @group 6613
150		* @group 6614
151		* @group 6616
152		*/
153	View Code Duplication	public function testWillKeepNewItemsInDirtyCollectionAfterInitialization()
154		{
155		/* @var $unitOfWork UnitOfWork\|\PHPUnit_Framework_MockObject_MockObject */
156		$unitOfWork = $this->createMock(UnitOfWork::class);
157
158		$this->_emMock->setUnitOfWork($unitOfWork);
		0 ignored issues – show Bug introduced 2017-08-11 17:22 UTC by Report Bug Copy Issue Report It seems like `$unitOfWork` defined by `$this->createMock(\Doctr...\ORM\UnitOfWork::class)` on line `156` can also be of type `object<PHPUnit_Framework_MockObject_MockObject>`; however, `Doctrine\Tests\Mocks\Ent...erMock::setUnitOfWork()` does only seem to accept `object<Doctrine\ORM\UnitOfWork>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
159
160		$newElement = new \stdClass();
161		$persistedElement = new \stdClass();
162
163		$this->collection->add($newElement);
164
165		self::assertFalse($this->collection->isInitialized());
166		self::assertTrue($this->collection->isDirty());
167
168		$unitOfWork
		0 ignored issues – show Bug introduced 2017-08-11 17:22 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Doctrine\ORM\UnitOfWork`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
169		->expects(self::once())
170		->method('loadCollection')
171		->with($this->collection)
172		->willReturnCallback(function (PersistentCollection $persistentCollection) use ($persistedElement) {
173		$persistentCollection->unwrap()->add($persistedElement);
174		});
175
176		$this->collection->initialize();
177
178		self::assertSame([$persistedElement, $newElement], $this->collection->toArray());
179		self::assertTrue($this->collection->isInitialized());
180		self::assertTrue($this->collection->isDirty());
181		}
182
183		/**
184		* @group 6613
185		* @group 6614
186		* @group 6616
187		*/
188		public function testWillDeDuplicateNewItemsThatWerePreviouslyPersistedInDirtyCollectionAfterInitialization()
189		{
190		/* @var $unitOfWork UnitOfWork\|\PHPUnit_Framework_MockObject_MockObject */
191		$unitOfWork = $this->createMock(UnitOfWork::class);
192
193		$this->_emMock->setUnitOfWork($unitOfWork);
		0 ignored issues – show Bug introduced 2017-08-11 17:22 UTC by Report Bug Copy Issue Report It seems like `$unitOfWork` defined by `$this->createMock(\Doctr...\ORM\UnitOfWork::class)` on line `191` can also be of type `object<PHPUnit_Framework_MockObject_MockObject>`; however, `Doctrine\Tests\Mocks\Ent...erMock::setUnitOfWork()` does only seem to accept `object<Doctrine\ORM\UnitOfWork>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
194
195		$newElement = new \stdClass();
196		$newElementThatIsAlsoPersisted = new \stdClass();
197		$persistedElement = new \stdClass();
198
199		$this->collection->add($newElementThatIsAlsoPersisted);
200		$this->collection->add($newElement);
201
202		self::assertFalse($this->collection->isInitialized());
203		self::assertTrue($this->collection->isDirty());
204
205		$unitOfWork
		0 ignored issues – show Bug introduced 2017-08-11 17:22 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Doctrine\ORM\UnitOfWork`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
206		->expects(self::once())
207		->method('loadCollection')
208		->with($this->collection)
209		->willReturnCallback(function (PersistentCollection $persistentCollection) use (
210		$persistedElement,
211		$newElementThatIsAlsoPersisted
212		) {
213		$persistentCollection->unwrap()->add($newElementThatIsAlsoPersisted);
214		$persistentCollection->unwrap()->add($persistedElement);
215		});
216
217		$this->collection->initialize();
218
219		self::assertSame(
220		[$newElementThatIsAlsoPersisted, $persistedElement, $newElement],
221		$this->collection->toArray()
222		);
223		self::assertTrue($this->collection->isInitialized());
224		self::assertTrue($this->collection->isDirty());
225		}
226
227		/**
228		* @group 6613
229		* @group 6614
230		* @group 6616
231		*/
232	View Code Duplication	public function testWillNotMarkCollectionAsDirtyAfterInitializationIfNoElementsWereAdded()
233		{
234		/* @var $unitOfWork UnitOfWork\|\PHPUnit_Framework_MockObject_MockObject */
235		$unitOfWork = $this->createMock(UnitOfWork::class);
236
237		$this->_emMock->setUnitOfWork($unitOfWork);
		0 ignored issues – show Bug introduced 2017-08-11 21:36 UTC by Report Bug Copy Issue Report It seems like `$unitOfWork` defined by `$this->createMock(\Doctr...\ORM\UnitOfWork::class)` on line `235` can also be of type `object<PHPUnit_Framework_MockObject_MockObject>`; however, `Doctrine\Tests\Mocks\Ent...erMock::setUnitOfWork()` does only seem to accept `object<Doctrine\ORM\UnitOfWork>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
238
239		$newElementThatIsAlsoPersisted = new \stdClass();
240		$persistedElement = new \stdClass();
241
242		$this->collection->add($newElementThatIsAlsoPersisted);
243
244		self::assertFalse($this->collection->isInitialized());
245		self::assertTrue($this->collection->isDirty());
246
247		$unitOfWork
		0 ignored issues – show Bug introduced 2017-08-11 21:36 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Doctrine\ORM\UnitOfWork`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
248		->expects(self::once())
249		->method('loadCollection')
250		->with($this->collection)
251		->willReturnCallback(function (PersistentCollection $persistentCollection) use (
252		$persistedElement,
253		$newElementThatIsAlsoPersisted
254		) {
255		$persistentCollection->unwrap()->add($newElementThatIsAlsoPersisted);
256		$persistentCollection->unwrap()->add($persistedElement);
257		});
258
259		$this->collection->initialize();
260
261		self::assertSame(
262		[$newElementThatIsAlsoPersisted, $persistedElement],
263		$this->collection->toArray()
264		);
265		self::assertTrue($this->collection->isInitialized());
266		self::assertFalse($this->collection->isDirty());
267		}
268		}
269

doctrine / orm

Pull Request — master (#6616)

PersistentCollectionTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

13 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like