From ec35d4886cd4a381d74aca619a71ac94b191b89a Mon Sep 17 00:00:00 2001
From: Mathieu De Zutter <mathieu@dezutter.org>
Date: Thu, 6 Nov 2014 07:16:20 +0100
Subject: [PATCH 01/19] Don't load detached proxies when merging them.

Ticket DDC-1392 fixed an issue where uninitialized proxies could not be merged
because the merge routine couldn't get the identifier from them. The soution
was to initialize the proxy.
Ticket DDC-1734 fixed the merging of *unserialized* uninitialized proxies by
resetting their internals, so these proxies were able to initialize, as required
by the fix for DDC-1392.

Somehow, in the meanwhile, the fix for DDC-1392 is not needed anymore:
reverting the patch will not break the associated test (but it does break the
test for DDC-1734). This means it is not needed anymore to initialize the proxy
when merging.

Uninitialized proxies that get merged should not be loaded at all.  Since they
are not initialized, the entity data for sure hasn't changed, so it can be
safely ignored. Actually, the only thing the data is needed for while merging,
is to copy it into the managed entity, but that one is already supposed to be
up to date. By not initializing the proxy, a potential database roundtrip is
saved, and the fix for DDC-1734 is not needed anymore.

Besides optimizing the merge, this patch also solves an issue with merging.
Currently, when a detached uninitialized proxy is merged while there is already a
corresponding managed entity (proxy or not), the ORM returns a blank entity
instead of returning the already managed entity. This patch makes sure that
already existing managed entities are re-used.
---
 lib/Doctrine/ORM/UnitOfWork.php               | 171 ++++++++++--------
 .../MergeUninitializedProxyTest.php           | 169 +++++++++++++++++
 2 files changed, 265 insertions(+), 75 deletions(-)
 create mode 100644 tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php

diff --git a/lib/Doctrine/ORM/UnitOfWork.php b/lib/Doctrine/ORM/UnitOfWork.php
index bd64684a3..b38074cab 100644
--- a/lib/Doctrine/ORM/UnitOfWork.php
+++ b/lib/Doctrine/ORM/UnitOfWork.php
@@ -1809,11 +1809,6 @@ class UnitOfWork implements PropertyChangedListener
         $managedCopy = $entity;
 
         if ($this->getEntityState($entity, self::STATE_DETACHED) !== self::STATE_MANAGED) {
-            if ($entity instanceof Proxy && ! $entity->__isInitialized()) {
-                $this->em->getProxyFactory()->resetUninitializedProxy($entity);
-                $entity->__load();
-            }
-
             // Try to look the entity up in the identity map.
             $id = $class->getIdentifierValues($entity);
 
@@ -1873,76 +1868,8 @@ class UnitOfWork implements PropertyChangedListener
 
             $visited[$oid] = $managedCopy; // mark visited
 
-            // Merge state of $entity into existing (managed) entity
-            foreach ($class->reflClass->getProperties() as $prop) {
-                $name = $prop->name;
-                $prop->setAccessible(true);
-                if ( ! isset($class->associationMappings[$name])) {
-                    if ( ! $class->isIdentifier($name)) {
-                        $prop->setValue($managedCopy, $prop->getValue($entity));
-                    }
-                } else {
-                    $assoc2 = $class->associationMappings[$name];
-                    if ($assoc2['type'] & ClassMetadata::TO_ONE) {
-                        $other = $prop->getValue($entity);
-                        if ($other === null) {
-                            $prop->setValue($managedCopy, null);
-                        } else if ($other instanceof Proxy && !$other->__isInitialized__) {
-                            // do not merge fields marked lazy that have not been fetched.
-                            continue;
-                        } else if ( ! $assoc2['isCascadeMerge']) {
-                            if ($this->getEntityState($other) === self::STATE_DETACHED) {
-                                $targetClass = $this->em->getClassMetadata($assoc2['targetEntity']);
-                                $relatedId = $targetClass->getIdentifierValues($other);
-
-                                if ($targetClass->subClasses) {
-                                    $other = $this->em->find($targetClass->name, $relatedId);
-                                } else {
-                                    $other = $this->em->getProxyFactory()->getProxy($assoc2['targetEntity'], $relatedId);
-                                    $this->registerManaged($other, $relatedId, array());
-                                }
-                            }
-
-                            $prop->setValue($managedCopy, $other);
-                        }
-                    } else {
-                        $mergeCol = $prop->getValue($entity);
-                        if ($mergeCol instanceof PersistentCollection && !$mergeCol->isInitialized()) {
-                            // do not merge fields marked lazy that have not been fetched.
-                            // keep the lazy persistent collection of the managed copy.
-                            continue;
-                        }
-
-                        $managedCol = $prop->getValue($managedCopy);
-                        if (!$managedCol) {
-                            $managedCol = new PersistentCollection($this->em,
-                                $this->em->getClassMetadata($assoc2['targetEntity']),
-                                new ArrayCollection
-                            );
-                            $managedCol->setOwner($managedCopy, $assoc2);
-                            $prop->setValue($managedCopy, $managedCol);
-                            $this->originalEntityData[$oid][$name] = $managedCol;
-                        }
-                        if ($assoc2['isCascadeMerge']) {
-                            $managedCol->initialize();
-
-                            // clear and set dirty a managed collection if its not also the same collection to merge from.
-                            if (!$managedCol->isEmpty() && $managedCol !== $mergeCol) {
-                                $managedCol->unwrap()->clear();
-                                $managedCol->setDirty(true);
-
-                                if ($assoc2['isOwningSide'] && $assoc2['type'] == ClassMetadata::MANY_TO_MANY && $class->isChangeTrackingNotify()) {
-                                    $this->scheduleForDirtyCheck($managedCopy);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                if ($class->isChangeTrackingNotify()) {
-                    // Just treat all properties as changed, there is no other choice.
-                    $this->propertyChanged($managedCopy, $name, null, $prop->getValue($managedCopy));
-                }
+            if (!($entity instanceof Proxy && ! $entity->__isInitialized())) {
+                $this->mergeEntityStateIntoManagedCopy($entity, $managedCopy);
             }
 
             if ($class->isChangeTrackingDeferredExplicit()) {
@@ -3393,6 +3320,100 @@ class UnitOfWork implements PropertyChangedListener
         return $id1 === $id2 || implode(' ', $id1) === implode(' ', $id2);
     }
 
+    /**
+     * @param object $entity
+     * @param object $managedCopy
+     * @throws ORMException
+     * @throws OptimisticLockException
+     * @throws TransactionRequiredException
+     * @internal param ClassMetadata $class
+     */
+    private function mergeEntityStateIntoManagedCopy($entity, $managedCopy)
+    {
+        $class = $this->em->getClassMetadata(get_class($entity));
+
+        foreach ($class->reflClass->getProperties() as $prop) {
+            $name = $prop->name;
+            $prop->setAccessible(true);
+            if (!isset($class->associationMappings[$name])) {
+                if (!$class->isIdentifier($name)) {
+                    $prop->setValue($managedCopy, $prop->getValue($entity));
+                }
+            } else {
+                $assoc2 = $class->associationMappings[$name];
+                if ($assoc2['type'] & ClassMetadata::TO_ONE) {
+                    $other = $prop->getValue($entity);
+                    if ($other === null) {
+                        $prop->setValue($managedCopy, null);
+                    } else {
+                        if ($other instanceof Proxy && !$other->__isInitialized()) {
+                            // do not merge fields marked lazy that have not been fetched.
+                            return;
+                        }
+                        if (!$assoc2['isCascadeMerge']) {
+                            if ($this->getEntityState($other) === self::STATE_DETACHED) {
+                                $targetClass = $this->em->getClassMetadata($assoc2['targetEntity']);
+                                $relatedId = $targetClass->getIdentifierValues($other);
+
+                                if ($targetClass->subClasses) {
+                                    $other = $this->em->find($targetClass->name, $relatedId);
+                                } else {
+                                    $other = $this->em->getProxyFactory()->getProxy(
+                                        $assoc2['targetEntity'],
+                                        $relatedId
+                                    );
+                                    $this->registerManaged($other, $relatedId, array());
+                                }
+                            }
+
+                            $prop->setValue($managedCopy, $other);
+                        }
+                    }
+                } else {
+                    $mergeCol = $prop->getValue($entity);
+                    if ($mergeCol instanceof PersistentCollection && !$mergeCol->isInitialized()) {
+                        // do not merge fields marked lazy that have not been fetched.
+                        // keep the lazy persistent collection of the managed copy.
+                        return;
+                    }
+
+                    $managedCol = $prop->getValue($managedCopy);
+                    if (!$managedCol) {
+                        $managedCol = new PersistentCollection(
+                            $this->em,
+                            $this->em->getClassMetadata($assoc2['targetEntity']),
+                            new ArrayCollection
+                        );
+                        $managedCol->setOwner($managedCopy, $assoc2);
+                        $prop->setValue($managedCopy, $managedCol);
+                        $oid = spl_object_hash($entity);
+                        $this->originalEntityData[$oid][$name] = $managedCol;
+                    }
+                    if ($assoc2['isCascadeMerge']) {
+                        $managedCol->initialize();
+
+                        // clear and set dirty a managed collection if its not also the same collection to merge from.
+                        if (!$managedCol->isEmpty() && $managedCol !== $mergeCol) {
+                            $managedCol->unwrap()->clear();
+                            $managedCol->setDirty(true);
+
+                            if ($assoc2['isOwningSide'] && $assoc2['type'] == ClassMetadata::MANY_TO_MANY && $class->isChangeTrackingNotify(
+                                )
+                            ) {
+                                $this->scheduleForDirtyCheck($managedCopy);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if ($class->isChangeTrackingNotify()) {
+                // Just treat all properties as changed, there is no other choice.
+                $this->propertyChanged($managedCopy, $name, null, $prop->getValue($managedCopy));
+            }
+        }
+    }
+
     /**
      * This method called by hydrators, and indicates that hydrator totally completed current hydration cycle.
      * Unit of work able to fire deferred events, related to loading events here.
diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
new file mode 100644
index 000000000..fbf11d3d4
--- /dev/null
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -0,0 +1,169 @@
+<?php
+
+
+namespace Doctrine\Tests\ORM\Functional;
+
+
+use Doctrine\ORM\Tools\ToolsException;
+
+class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase {
+
+    protected function setUp()
+    {
+        parent::setUp();
+
+        try {
+            $this->_schemaTool->createSchema(array(
+                    $this->_em->getClassMetadata(__NAMESPACE__ . '\MUPFile'),
+                    $this->_em->getClassMetadata(__NAMESPACE__ . '\MUPPicture'),
+                ));
+        } catch (ToolsException $ignored) {
+        }
+    }
+
+    public function testMergeUnserializedIntoEntity() {
+
+        $file = new MUPFile;
+
+        $picture = new MUPPicture;
+        $picture->file = $file;
+
+        $em = $this->_em;
+        $em->persist($picture);
+        $em->flush();
+        $em->clear();
+
+        $fileId = $file->fileId;
+        $pictureId = $picture->pictureId;
+
+        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
+        $serializedPicture = serialize($picture);
+
+        $em->clear();
+
+        $file = $em->find(__NAMESPACE__ . '\MUPFile', $fileId);
+        $picture = unserialize($serializedPicture);
+        $picture = $em->merge($picture);
+
+        $this->assertEquals($file, $picture->file, "Unserialized proxy was not merged into managed entity");
+    }
+
+    public function testMergeDetachedIntoEntity() {
+
+        $file = new MUPFile;
+
+        $picture = new MUPPicture;
+        $picture->file = $file;
+
+        $em = $this->_em;
+        $em->persist($picture);
+        $em->flush();
+        $em->clear();
+
+        $fileId = $file->fileId;
+        $pictureId = $picture->pictureId;
+
+        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
+
+        $em->clear();
+
+        $file = $em->find(__NAMESPACE__ . '\MUPFile', $fileId);
+        $picture = $em->merge($picture);
+
+        $this->assertEquals($file, $picture->file, "Detached proxy was not merged into managed entity");
+    }
+
+    public function testMergeUnserializedIntoProxy() {
+
+        $file = new MUPFile;
+
+        $picture = new MUPPicture;
+        $picture->file = $file;
+
+        $picture2 = new MUPPicture;
+        $picture2->file = $file;
+
+        $em = $this->_em;
+        $em->persist($picture);
+        $em->persist($picture2);
+        $em->flush();
+        $em->clear();
+
+        $pictureId = $picture->pictureId;
+        $picture2Id = $picture2->pictureId;
+
+        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
+        $serializedPicture = serialize($picture);
+
+        $em->clear();
+
+        $picture2 = $em->find(__NAMESPACE__ . '\MUPPicture', $picture2Id);
+        $picture = unserialize($serializedPicture);
+        $picture = $em->merge($picture);
+
+        $this->assertEquals($picture2->file, $picture->file, "Unserialized proxy was not merged into managed proxy");
+    }
+
+    public function testMergeDetachedIntoProxy() {
+
+        $file = new MUPFile;
+
+        $picture = new MUPPicture;
+        $picture->file = $file;
+
+        $picture2 = new MUPPicture;
+        $picture2->file = $file;
+
+        $em = $this->_em;
+        $em->persist($picture);
+        $em->persist($picture2);
+        $em->flush();
+        $em->clear();
+
+        $pictureId = $picture->pictureId;
+        $picture2Id = $picture2->pictureId;
+
+        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
+
+        $em->clear();
+
+        $picture2 = $em->find(__NAMESPACE__ . '\MUPPicture', $picture2Id);
+        $picture = $em->merge($picture);
+
+        $this->assertEquals($picture2->file, $picture->file, "Detached proxy was not merged into managed proxy");
+    }
+
+}
+
+/**
+ * @Entity
+ */
+class MUPPicture
+{
+    /**
+     * @Column(name="picture_id", type="integer")
+     * @Id @GeneratedValue
+     */
+    public $pictureId;
+
+    /**
+     * @ManyToOne(targetEntity="MUPFile", cascade={"persist", "merge"})
+     * @JoinColumn(name="file_id", referencedColumnName="file_id")
+     */
+    public $file;
+
+}
+
+/**
+ * @Entity
+ */
+class MUPFile
+{
+    /**
+     * @Column(name="file_id", type="integer")
+     * @Id
+     * @GeneratedValue(strategy="AUTO")
+     */
+    public $fileId;
+
+}

From 318b23097b6a3fe776ba0356bf74a248b69c01ba Mon Sep 17 00:00:00 2001
From: Mathieu De Zutter <mathieu@dezutter.org>
Date: Wed, 12 Nov 2014 17:03:31 +0100
Subject: [PATCH 02/19] Don't load uninitialized proxies after merging.

Previous patch avoided initialization of proxies before merging, mainly to
fix a bug with merging. However, later on, doctrine tries again to load
the proxy. This is unnecessary and thus has been removed. This way, a
round trip to the database is saved.
---
 lib/Doctrine/ORM/UnitOfWork.php                |  4 ----
 .../Functional/MergeUninitializedProxyTest.php | 18 ++++++++++++++++++
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/lib/Doctrine/ORM/UnitOfWork.php b/lib/Doctrine/ORM/UnitOfWork.php
index b38074cab..5fe435ec4 100644
--- a/lib/Doctrine/ORM/UnitOfWork.php
+++ b/lib/Doctrine/ORM/UnitOfWork.php
@@ -1848,10 +1848,6 @@ class UnitOfWork implements PropertyChangedListener
                     $class->setIdentifierValues($managedCopy, $id);
 
                     $this->persistNew($class, $managedCopy);
-                } else {
-                    if ($managedCopy instanceof Proxy && ! $managedCopy->__isInitialized__) {
-                        $managedCopy->__load();
-                    }
                 }
             }
 
diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index fbf11d3d4..43981fcc1 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -4,6 +4,7 @@
 namespace Doctrine\Tests\ORM\Functional;
 
 
+use Doctrine\ORM\Proxy\Proxy;
 use Doctrine\ORM\Tools\ToolsException;
 
 class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase {
@@ -43,6 +44,7 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         $file = $em->find(__NAMESPACE__ . '\MUPFile', $fileId);
         $picture = unserialize($serializedPicture);
+
         $picture = $em->merge($picture);
 
         $this->assertEquals($file, $picture->file, "Unserialized proxy was not merged into managed entity");
@@ -68,6 +70,7 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $em->clear();
 
         $file = $em->find(__NAMESPACE__ . '\MUPFile', $fileId);
+
         $picture = $em->merge($picture);
 
         $this->assertEquals($file, $picture->file, "Detached proxy was not merged into managed entity");
@@ -98,9 +101,17 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $em->clear();
 
         $picture2 = $em->find(__NAMESPACE__ . '\MUPPicture', $picture2Id);
+        $this->assertFalse($picture->file->__isInitialized());
         $picture = unserialize($serializedPicture);
+
+        $this->assertTrue($picture->file instanceof Proxy);
+        $this->assertFalse($picture->file->__isInitialized());
+
         $picture = $em->merge($picture);
 
+        $this->assertTrue($picture->file instanceof Proxy);
+        $this->assertFalse($picture->file->__isInitialized(), 'Proxy has been initialized during merge.');
+
         $this->assertEquals($picture2->file, $picture->file, "Unserialized proxy was not merged into managed proxy");
     }
 
@@ -128,8 +139,15 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $em->clear();
 
         $picture2 = $em->find(__NAMESPACE__ . '\MUPPicture', $picture2Id);
+
+        $this->assertTrue($picture->file instanceof Proxy);
+        $this->assertFalse($picture->file->__isInitialized());
+
         $picture = $em->merge($picture);
 
+        $this->assertTrue($picture->file instanceof Proxy);
+        $this->assertFalse($picture->file->__isInitialized(), 'Proxy has been initialized during merge.');
+
         $this->assertEquals($picture2->file, $picture->file, "Detached proxy was not merged into managed proxy");
     }
 

From dde09872df4f442f3a2a4c9ce6053badb8b49012 Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 21:09:53 +0100
Subject: [PATCH 03/19] #1172 - writing a more concise test case about merging
 detached proxies

---
 .../ORM/Functional/MergeUninitializedProxyTest.php | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index 43981fcc1..ae5fa5f5a 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -22,6 +22,18 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         }
     }
 
+    public function testMergeUnserializedUnInitializedProxy()
+    {
+        $detachedUninitialized = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+
+        $this->_em->clear();
+
+        $this->assertSame(
+            $this->_em->getReference(MUPFile::CLASSNAME, 123),
+            $this->_em->merge(unserialize(serialize($detachedUninitialized)))
+        );
+    }
+
     public function testMergeUnserializedIntoEntity() {
 
         $file = new MUPFile;
@@ -177,6 +189,8 @@ class MUPPicture
  */
 class MUPFile
 {
+    const CLASSNAME = __CLASS__;
+
     /**
      * @Column(name="file_id", type="integer")
      * @Id

From 0329ac50740d577816660b3f478cffdd72b48459 Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 21:14:13 +0100
Subject: [PATCH 04/19] #1172 - covering also detached proxies - merging
 operations should not initialize either proxy

---
 .../MergeUninitializedProxyTest.php           | 23 +++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index ae5fa5f5a..d0b8036cb 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -22,16 +22,35 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         }
     }
 
+    public function testMergeDetachedUnInitializedProxy()
+    {
+        $detachedUninitialized = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+
+        $this->_em->clear();
+
+        $managed = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+
+        $this->assertSame($managed, $this->_em->merge($detachedUninitialized));
+
+        $this->assertFalse($managed->__isInitialized());
+        $this->assertFalse($detachedUninitialized->__isInitialized());
+    }
+
     public function testMergeUnserializedUnInitializedProxy()
     {
         $detachedUninitialized = $this->_em->getReference(MUPFile::CLASSNAME, 123);
 
         $this->_em->clear();
 
+        $managed = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+
         $this->assertSame(
-            $this->_em->getReference(MUPFile::CLASSNAME, 123),
-            $this->_em->merge(unserialize(serialize($detachedUninitialized)))
+            $managed,
+            $this->_em->merge(unserialize(serialize($this->_em->merge($detachedUninitialized))))
         );
+
+        $this->assertFalse($managed->__isInitialized());
+        $this->assertFalse($detachedUninitialized->__isInitialized());
     }
 
     public function testMergeUnserializedIntoEntity() {

From a18f258b4d1a3ae2987d7182284d4ce583bbbdcd Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 21:15:39 +0100
Subject: [PATCH 05/19] #1172 - covering merging of managed proxies

---
 .../Tests/ORM/Functional/MergeUninitializedProxyTest.php | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index d0b8036cb..f5661c98e 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -53,6 +53,15 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($detachedUninitialized->__isInitialized());
     }
 
+    public function testMergeManagedProxy()
+    {
+        $managed = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+
+        $this->assertSame($managed, $this->_em->merge($managed));
+
+        $this->assertFalse($managed->__isInitialized());
+    }
+
     public function testMergeUnserializedIntoEntity() {
 
         $file = new MUPFile;

From 3df119f4feee3c93f758ddce1e01850f1dc6c58a Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 21:23:47 +0100
Subject: [PATCH 06/19] #1172 - when merging an initialized proxy, the managed
 proxy must be initialized before merging

---
 .../MergeUninitializedProxyTest.php           | 33 ++++++++++++++-----
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index f5661c98e..cf3b4c713 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -62,6 +62,27 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($managed->__isInitialized());
     }
 
+    public function testMergeInitializedProxy()
+    {
+        $file = new MUPFile();
+
+        $this->_em->persist($file);
+        $this->_em->flush();
+        $this->_em->clear();
+
+        $initialized = $this->_em->getReference(MUPFile::CLASSNAME, $file->fileId);
+
+        $initialized->__load();
+
+        $this->_em->clear();
+
+        $managed = $this->_em->getReference(MUPFile::CLASSNAME, $file->fileId);
+
+        $this->assertSame($managed, $this->_em->merge($initialized));
+
+        $this->assertTrue($managed->__isInitialized());
+    }
+
     public function testMergeUnserializedIntoEntity() {
 
         $file = new MUPFile;
@@ -212,18 +233,14 @@ class MUPPicture
 
 }
 
-/**
- * @Entity
- */
+/** @Entity */
 class MUPFile
 {
     const CLASSNAME = __CLASS__;
 
-    /**
-     * @Column(name="file_id", type="integer")
-     * @Id
-     * @GeneratedValue(strategy="AUTO")
-     */
+    /** @Column(name="file_id", type="integer") @Id @GeneratedValue(strategy="AUTO") */
     public $fileId;
 
+    /** @Column(type="string", nullable=true) */
+    private $contents;
 }

From 4ed0a6ce53ac369892f4bd5cfa5023236985f2bd Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 21:25:25 +0100
Subject: [PATCH 07/19] #1172 - removing redundant tests

---
 .../MergeUninitializedProxyTest.php           | 49 -------------------
 1 file changed, 49 deletions(-)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index cf3b4c713..eb033ca5a 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -62,55 +62,6 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($managed->__isInitialized());
     }
 
-    public function testMergeInitializedProxy()
-    {
-        $file = new MUPFile();
-
-        $this->_em->persist($file);
-        $this->_em->flush();
-        $this->_em->clear();
-
-        $initialized = $this->_em->getReference(MUPFile::CLASSNAME, $file->fileId);
-
-        $initialized->__load();
-
-        $this->_em->clear();
-
-        $managed = $this->_em->getReference(MUPFile::CLASSNAME, $file->fileId);
-
-        $this->assertSame($managed, $this->_em->merge($initialized));
-
-        $this->assertTrue($managed->__isInitialized());
-    }
-
-    public function testMergeUnserializedIntoEntity() {
-
-        $file = new MUPFile;
-
-        $picture = new MUPPicture;
-        $picture->file = $file;
-
-        $em = $this->_em;
-        $em->persist($picture);
-        $em->flush();
-        $em->clear();
-
-        $fileId = $file->fileId;
-        $pictureId = $picture->pictureId;
-
-        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
-        $serializedPicture = serialize($picture);
-
-        $em->clear();
-
-        $file = $em->find(__NAMESPACE__ . '\MUPFile', $fileId);
-        $picture = unserialize($serializedPicture);
-
-        $picture = $em->merge($picture);
-
-        $this->assertEquals($file, $picture->file, "Unserialized proxy was not merged into managed entity");
-    }
-
     public function testMergeDetachedIntoEntity() {
 
         $file = new MUPFile;

From d1e7960f9918779b169cfa3688cebebfb28014ab Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:12:42 +0100
Subject: [PATCH 08/19] #1172 - tests to verify that proxies keep distinct
 entity manager instances even across merging operations

---
 .../MergeUninitializedProxyTest.php           | 88 +++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index eb033ca5a..d86c28fa3 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -4,8 +4,14 @@
 namespace Doctrine\Tests\ORM\Functional;
 
 
+use Doctrine\DBAL\Logging\DebugStack;
+use Doctrine\DBAL\Logging\SQLLogger;
+use Doctrine\ORM\Configuration;
+use Doctrine\ORM\EntityManager;
 use Doctrine\ORM\Proxy\Proxy;
+use Doctrine\ORM\Tools\SchemaTool;
 use Doctrine\ORM\Tools\ToolsException;
+use Doctrine\Tests\TestUtil;
 
 class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase {
 
@@ -62,6 +68,57 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($managed->__isInitialized());
     }
 
+    public function testMergingProxyFromDifferentEntityManagerDoesNotReplaceInitializer()
+    {
+        $em1 = $this->createEntityManager($logger1 = new DebugStack());
+        $em2 = $this->createEntityManager($logger2 = new DebugStack());
+
+        $file1 = new MUPFile();
+
+        $em1->persist($file1);
+        $em1->flush();
+        $em1->clear();
+
+        $queryCount1 = count($logger1->queries);
+        $queryCount2 = count($logger1->queries);
+
+        $proxy1 = $em1->getReference(MUPFile::CLASSNAME, $file1->fileId);
+        $proxy2 = $em2->getReference(MUPFile::CLASSNAME, $file1->fileId);
+        $merged2  = $em2->merge($proxy1);
+
+        $this->assertNotSame($proxy1, $merged2);
+        $this->assertSame($proxy2, $merged2);
+
+        $this->assertFalse($proxy1->__isInitialized());
+        $this->assertFalse($proxy2->__isInitialized());
+
+        $proxy1->__load();
+
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger1->queries,
+            'Loading the first proxy was done through the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount2,
+            $logger2->queries,
+            'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
+        );
+
+        $proxy2->__load();
+
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger1->queries,
+            'Loading the second proxy does not affect the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount2 + 1,
+            $logger2->queries,
+            'Loading of the second proxy instance was done through the second entity manager'
+        );
+    }
+
     public function testMergeDetachedIntoEntity() {
 
         $file = new MUPFile;
@@ -163,6 +220,37 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertEquals($picture2->file, $picture->file, "Detached proxy was not merged into managed proxy");
     }
 
+    /**
+     * @param SQLLogger $logger
+     *
+     * @return EntityManager
+     */
+    private function createEntityManager(SQLLogger $logger)
+    {
+        $config = new Configuration();
+
+        $config->setProxyDir(realpath(__DIR__ . '/../../Proxies/../..'));
+        $config->setProxyNamespace('Doctrine\Tests\Proxies');
+        $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(
+            array(realpath(__DIR__ . '/../../Models/Cache')),
+            true
+        ));
+
+        $connection = TestUtil::getConnection();
+
+        $connection->getConfiguration()->setSQLLogger($logger);
+
+        $entityManager = EntityManager::create($connection, $config);
+
+        try {
+            (new SchemaTool($entityManager))
+                ->createSchema([$this->_em->getClassMetadata(MUPFile::CLASSNAME)]);
+        } catch (ToolsException $ignored) {
+            // tables were already created
+        }
+
+        return $entityManager;
+    }
 }
 
 /**

From b7566dc65b64e56b513fed49eab4fc3099101a3d Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:20:58 +0100
Subject: [PATCH 09/19] #1172 - correcting test: all connections should have a
 saved file instance

---
 .../ORM/Functional/MergeUninitializedProxyTest.php | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index d86c28fa3..e9851e425 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -68,23 +68,27 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($managed->__isInitialized());
     }
 
-    public function testMergingProxyFromDifferentEntityManagerDoesNotReplaceInitializer()
+    public function testMergingProxyFromDifferentEntityManagerWithExistingManagedInstanceDoesNotReplaceInitializer()
     {
         $em1 = $this->createEntityManager($logger1 = new DebugStack());
         $em2 = $this->createEntityManager($logger2 = new DebugStack());
 
         $file1 = new MUPFile();
+        $file2 = new MUPFile();
 
         $em1->persist($file1);
+        $em2->persist($file2);
         $em1->flush();
+        $em2->flush();
         $em1->clear();
+        $em2->clear();
 
         $queryCount1 = count($logger1->queries);
-        $queryCount2 = count($logger1->queries);
+        $queryCount2 = count($logger2->queries);
 
-        $proxy1 = $em1->getReference(MUPFile::CLASSNAME, $file1->fileId);
-        $proxy2 = $em2->getReference(MUPFile::CLASSNAME, $file1->fileId);
-        $merged2  = $em2->merge($proxy1);
+        $proxy1  = $em1->getReference(MUPFile::CLASSNAME, $file1->fileId);
+        $proxy2  = $em2->getReference(MUPFile::CLASSNAME, $file1->fileId);
+        $merged2 = $em2->merge($proxy1);
 
         $this->assertNotSame($proxy1, $merged2);
         $this->assertSame($proxy2, $merged2);

From de4e9803897a26c49980e8f14ed4dd6a317666d8 Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:25:00 +0100
Subject: [PATCH 10/19] #1172 - covering merging of unmanaged, un-initialized
 proxies bound to a different entity manager

---
 .../MergeUninitializedProxyTest.php           | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index e9851e425..2467a3cae 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -123,6 +123,57 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         );
     }
 
+    public function testMergingUnInitializedProxyDoesNotInitializeIt()
+    {
+        $em1 = $this->createEntityManager($logger1 = new DebugStack());
+        $em2 = $this->createEntityManager($logger2 = new DebugStack());
+
+        $file1 = new MUPFile();
+        $file2 = new MUPFile();
+
+        $em1->persist($file1);
+        $em2->persist($file2);
+        $em1->flush();
+        $em2->flush();
+        $em1->clear();
+        $em2->clear();
+
+        $queryCount1 = count($logger1->queries);
+        $queryCount2 = count($logger1->queries);
+
+        $unManagedProxy = $em1->getReference(MUPFile::CLASSNAME, $file1->fileId);
+        $mergedInstance = $em2->merge($unManagedProxy);
+
+        $this->assertNotInstanceOf('Doctrine\Common\Proxy\Proxy', $mergedInstance);
+        $this->assertNotSame($unManagedProxy, $mergedInstance);
+        $this->assertFalse($unManagedProxy->__isInitialized());
+
+        $this->assertCount(
+            $queryCount1,
+            $logger1->queries,
+            'Loading the merged instance affected only the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger2->queries,
+            'Loading the merged instance was done via the second entity manager'
+        );
+
+        $unManagedProxy->__load();
+
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger1->queries,
+            'Loading the first proxy was done through the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount2 + 1,
+            $logger2->queries,
+            'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
+        );
+
+    }
+
     public function testMergeDetachedIntoEntity() {
 
         $file = new MUPFile;

From 438feccd5568b7f523ef2bc096bcf98c3ed86220 Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:25:41 +0100
Subject: [PATCH 11/19] #1172 - removing redundant test logic

---
 .../MergeUninitializedProxyTest.php           | 102 ------------------
 1 file changed, 102 deletions(-)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index 2467a3cae..faae9df80 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -171,108 +171,6 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
             $logger2->queries,
             'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
         );
-
-    }
-
-    public function testMergeDetachedIntoEntity() {
-
-        $file = new MUPFile;
-
-        $picture = new MUPPicture;
-        $picture->file = $file;
-
-        $em = $this->_em;
-        $em->persist($picture);
-        $em->flush();
-        $em->clear();
-
-        $fileId = $file->fileId;
-        $pictureId = $picture->pictureId;
-
-        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
-
-        $em->clear();
-
-        $file = $em->find(__NAMESPACE__ . '\MUPFile', $fileId);
-
-        $picture = $em->merge($picture);
-
-        $this->assertEquals($file, $picture->file, "Detached proxy was not merged into managed entity");
-    }
-
-    public function testMergeUnserializedIntoProxy() {
-
-        $file = new MUPFile;
-
-        $picture = new MUPPicture;
-        $picture->file = $file;
-
-        $picture2 = new MUPPicture;
-        $picture2->file = $file;
-
-        $em = $this->_em;
-        $em->persist($picture);
-        $em->persist($picture2);
-        $em->flush();
-        $em->clear();
-
-        $pictureId = $picture->pictureId;
-        $picture2Id = $picture2->pictureId;
-
-        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
-        $serializedPicture = serialize($picture);
-
-        $em->clear();
-
-        $picture2 = $em->find(__NAMESPACE__ . '\MUPPicture', $picture2Id);
-        $this->assertFalse($picture->file->__isInitialized());
-        $picture = unserialize($serializedPicture);
-
-        $this->assertTrue($picture->file instanceof Proxy);
-        $this->assertFalse($picture->file->__isInitialized());
-
-        $picture = $em->merge($picture);
-
-        $this->assertTrue($picture->file instanceof Proxy);
-        $this->assertFalse($picture->file->__isInitialized(), 'Proxy has been initialized during merge.');
-
-        $this->assertEquals($picture2->file, $picture->file, "Unserialized proxy was not merged into managed proxy");
-    }
-
-    public function testMergeDetachedIntoProxy() {
-
-        $file = new MUPFile;
-
-        $picture = new MUPPicture;
-        $picture->file = $file;
-
-        $picture2 = new MUPPicture;
-        $picture2->file = $file;
-
-        $em = $this->_em;
-        $em->persist($picture);
-        $em->persist($picture2);
-        $em->flush();
-        $em->clear();
-
-        $pictureId = $picture->pictureId;
-        $picture2Id = $picture2->pictureId;
-
-        $picture = $em->find(__NAMESPACE__ . '\MUPPicture', $pictureId);
-
-        $em->clear();
-
-        $picture2 = $em->find(__NAMESPACE__ . '\MUPPicture', $picture2Id);
-
-        $this->assertTrue($picture->file instanceof Proxy);
-        $this->assertFalse($picture->file->__isInitialized());
-
-        $picture = $em->merge($picture);
-
-        $this->assertTrue($picture->file instanceof Proxy);
-        $this->assertFalse($picture->file->__isInitialized(), 'Proxy has been initialized during merge.');
-
-        $this->assertEquals($picture2->file, $picture->file, "Detached proxy was not merged into managed proxy");
     }
 
     /**

From 70840131ffa6c45540714e46b7f875747cd416da Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:36:30 +0100
Subject: [PATCH 12/19] #1172 - moved `MergeUninitializedProxyTest` tests into
 `EntityManagerTest`

---
 .../Doctrine/Tests/ORM/EntityManagerTest.php  | 192 ++++++++++++++++++
 1 file changed, 192 insertions(+)

diff --git a/tests/Doctrine/Tests/ORM/EntityManagerTest.php b/tests/Doctrine/Tests/ORM/EntityManagerTest.php
index 37a444a60..a412bb309 100644
--- a/tests/Doctrine/Tests/ORM/EntityManagerTest.php
+++ b/tests/Doctrine/Tests/ORM/EntityManagerTest.php
@@ -2,6 +2,15 @@
 
 namespace Doctrine\Tests\ORM;
 
+use Doctrine\DBAL\Logging\DebugStack;
+use Doctrine\DBAL\Logging\SQLLogger;
+use Doctrine\ORM\Configuration;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\Tools\SchemaTool;
+use Doctrine\ORM\Tools\ToolsException;
+use Doctrine\Tests\Models\Generic\DateTimeModel;
+use Doctrine\Tests\TestUtil;
+
 class EntityManagerTest extends \Doctrine\Tests\OrmTestCase
 {
     private $_em;
@@ -195,4 +204,187 @@ class EntityManagerTest extends \Doctrine\Tests\OrmTestCase
         $this->assertSame($this->_em, $em);
         return 'callback';
     }
+
+    public function testMergeDetachedUnInitializedProxy()
+    {
+        $em = $this->createEntityManager();
+
+        $detachedUninitialized = $em->getReference(DateTimeModel::CLASSNAME, 123);
+
+        $em->clear();
+
+        $managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
+
+        $this->assertSame($managed, $em->merge($detachedUninitialized));
+
+        $this->assertFalse($managed->__isInitialized());
+        $this->assertFalse($detachedUninitialized->__isInitialized());
+    }
+
+    public function testMergeUnserializedUnInitializedProxy()
+    {
+        $em = $this->createEntityManager();
+
+        $detachedUninitialized = $em->getReference(DateTimeModel::CLASSNAME, 123);
+
+        $em->clear();
+
+        $managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
+
+        $this->assertSame(
+            $managed,
+            $em->merge(unserialize(serialize($em->merge($detachedUninitialized))))
+        );
+
+        $this->assertFalse($managed->__isInitialized());
+        $this->assertFalse($detachedUninitialized->__isInitialized());
+    }
+
+    public function testMergeManagedProxy()
+    {
+        $em = $this->createEntityManager();
+
+        $managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
+
+        $this->assertSame($managed, $em->merge($managed));
+
+        $this->assertFalse($managed->__isInitialized());
+    }
+
+    public function testMergingProxyFromDifferentEntityManagerWithExistingManagedInstanceDoesNotReplaceInitializer()
+    {
+        $em1 = $this->createEntityManager($logger1 = new DebugStack());
+        $em2 = $this->createEntityManager($logger2 = new DebugStack());
+
+        $entity1 = new DateTimeModel();
+        $entity2 = new DateTimeModel();
+
+        $em1->persist($entity1);
+        $em2->persist($entity2);
+        $em1->flush();
+        $em2->flush();
+        $em1->clear();
+        $em2->clear();
+
+        $queryCount1 = count($logger1->queries);
+        $queryCount2 = count($logger2->queries);
+
+        $proxy1  = $em1->getReference(DateTimeModel::CLASSNAME, $entity1->id);
+        $proxy2  = $em2->getReference(DateTimeModel::CLASSNAME, $entity1->id);
+        $merged2 = $em2->merge($proxy1);
+
+        $this->assertNotSame($proxy1, $merged2);
+        $this->assertSame($proxy2, $merged2);
+
+        $this->assertFalse($proxy1->__isInitialized());
+        $this->assertFalse($proxy2->__isInitialized());
+
+        $proxy1->__load();
+
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger1->queries,
+            'Loading the first proxy was done through the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount2,
+            $logger2->queries,
+            'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
+        );
+
+        $proxy2->__load();
+
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger1->queries,
+            'Loading the second proxy does not affect the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount2 + 1,
+            $logger2->queries,
+            'Loading of the second proxy instance was done through the second entity manager'
+        );
+    }
+
+    public function testMergingUnInitializedProxyDoesNotInitializeIt()
+    {
+        $em1 = $this->createEntityManager($logger1 = new DebugStack());
+        $em2 = $this->createEntityManager($logger2 = new DebugStack());
+
+        $entity1 = new DateTimeModel();
+        $entity2 = new DateTimeModel();
+
+        $em1->persist($entity1);
+        $em2->persist($entity2);
+        $em1->flush();
+        $em2->flush();
+        $em1->clear();
+        $em2->clear();
+
+        $queryCount1 = count($logger1->queries);
+        $queryCount2 = count($logger1->queries);
+
+        $unManagedProxy = $em1->getReference(DateTimeModel::CLASSNAME, $entity1->id);
+        $mergedInstance = $em2->merge($unManagedProxy);
+
+        $this->assertNotInstanceOf('Doctrine\Common\Proxy\Proxy', $mergedInstance);
+        $this->assertNotSame($unManagedProxy, $mergedInstance);
+        $this->assertFalse($unManagedProxy->__isInitialized());
+
+        $this->assertCount(
+            $queryCount1,
+            $logger1->queries,
+            'Loading the merged instance affected only the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger2->queries,
+            'Loading the merged instance was done via the second entity manager'
+        );
+
+        $unManagedProxy->__load();
+
+        $this->assertCount(
+            $queryCount1 + 1,
+            $logger1->queries,
+            'Loading the first proxy was done through the first entity manager'
+        );
+        $this->assertCount(
+            $queryCount2 + 1,
+            $logger2->queries,
+            'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
+        );
+    }
+
+    /**
+     * @param SQLLogger $logger
+     *
+     * @return \Doctrine\ORM\EntityManager
+     */
+    private function createEntityManager(SQLLogger $logger = null)
+    {
+        $config = new Configuration();
+
+        $config->setProxyDir(realpath(__DIR__ . '/../Proxies/../..'));
+        $config->setProxyNamespace('Doctrine\Tests\Proxies');
+        $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(
+            array(realpath(__DIR__ . '/../Models/Cache')),
+            true
+        ));
+
+        $connection = TestUtil::getConnection();
+
+        $connection->getConfiguration()->setSQLLogger($logger);
+
+        $entityManager = EntityManager::create($connection, $config);
+
+        try {
+            (new SchemaTool($entityManager))
+                ->createSchema([$entityManager->getClassMetadata(DateTimeModel::CLASSNAME)]);
+        } catch (ToolsException $ignored) {
+            // tables were already created
+        }
+
+        return $entityManager;
+    }
 }

From 3769cd11199618fd5668458828b41b8419a1757d Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:37:38 +0100
Subject: [PATCH 13/19] #1172 - adding required `@group` annotations for newly
 introduced tests

---
 tests/Doctrine/Tests/Models/Generic/DateTimeModel.php | 2 ++
 tests/Doctrine/Tests/ORM/EntityManagerTest.php        | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/tests/Doctrine/Tests/Models/Generic/DateTimeModel.php b/tests/Doctrine/Tests/Models/Generic/DateTimeModel.php
index 3298a8850..92ebe5e5d 100644
--- a/tests/Doctrine/Tests/Models/Generic/DateTimeModel.php
+++ b/tests/Doctrine/Tests/Models/Generic/DateTimeModel.php
@@ -8,6 +8,8 @@ namespace Doctrine\Tests\Models\Generic;
  */
 class DateTimeModel
 {
+    const CLASSNAME = __CLASS__;
+
     /**
      * @Id @Column(type="integer")
      * @GeneratedValue
diff --git a/tests/Doctrine/Tests/ORM/EntityManagerTest.php b/tests/Doctrine/Tests/ORM/EntityManagerTest.php
index a412bb309..c24867555 100644
--- a/tests/Doctrine/Tests/ORM/EntityManagerTest.php
+++ b/tests/Doctrine/Tests/ORM/EntityManagerTest.php
@@ -205,6 +205,12 @@ class EntityManagerTest extends \Doctrine\Tests\OrmTestCase
         return 'callback';
     }
 
+    /**
+     * @group DDC-1392
+     * @group DDC-1734
+     * @group DDC-3368
+     * @group #1172
+     */
     public function testMergeDetachedUnInitializedProxy()
     {
         $em = $this->createEntityManager();

From 94724b7a56b684b81a15b944959f35be3e685888 Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:43:03 +0100
Subject: [PATCH 14/19] #1172 - reverted: moving `MergeUninitializedProxyTest`
 tests into `EntityManagerTest` (invalid, as they are functional tests)

---
 .../Doctrine/Tests/ORM/EntityManagerTest.php  | 198 ------------------
 1 file changed, 198 deletions(-)

diff --git a/tests/Doctrine/Tests/ORM/EntityManagerTest.php b/tests/Doctrine/Tests/ORM/EntityManagerTest.php
index c24867555..37a444a60 100644
--- a/tests/Doctrine/Tests/ORM/EntityManagerTest.php
+++ b/tests/Doctrine/Tests/ORM/EntityManagerTest.php
@@ -2,15 +2,6 @@
 
 namespace Doctrine\Tests\ORM;
 
-use Doctrine\DBAL\Logging\DebugStack;
-use Doctrine\DBAL\Logging\SQLLogger;
-use Doctrine\ORM\Configuration;
-use Doctrine\ORM\EntityManager;
-use Doctrine\ORM\Tools\SchemaTool;
-use Doctrine\ORM\Tools\ToolsException;
-use Doctrine\Tests\Models\Generic\DateTimeModel;
-use Doctrine\Tests\TestUtil;
-
 class EntityManagerTest extends \Doctrine\Tests\OrmTestCase
 {
     private $_em;
@@ -204,193 +195,4 @@ class EntityManagerTest extends \Doctrine\Tests\OrmTestCase
         $this->assertSame($this->_em, $em);
         return 'callback';
     }
-
-    /**
-     * @group DDC-1392
-     * @group DDC-1734
-     * @group DDC-3368
-     * @group #1172
-     */
-    public function testMergeDetachedUnInitializedProxy()
-    {
-        $em = $this->createEntityManager();
-
-        $detachedUninitialized = $em->getReference(DateTimeModel::CLASSNAME, 123);
-
-        $em->clear();
-
-        $managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
-
-        $this->assertSame($managed, $em->merge($detachedUninitialized));
-
-        $this->assertFalse($managed->__isInitialized());
-        $this->assertFalse($detachedUninitialized->__isInitialized());
-    }
-
-    public function testMergeUnserializedUnInitializedProxy()
-    {
-        $em = $this->createEntityManager();
-
-        $detachedUninitialized = $em->getReference(DateTimeModel::CLASSNAME, 123);
-
-        $em->clear();
-
-        $managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
-
-        $this->assertSame(
-            $managed,
-            $em->merge(unserialize(serialize($em->merge($detachedUninitialized))))
-        );
-
-        $this->assertFalse($managed->__isInitialized());
-        $this->assertFalse($detachedUninitialized->__isInitialized());
-    }
-
-    public function testMergeManagedProxy()
-    {
-        $em = $this->createEntityManager();
-
-        $managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
-
-        $this->assertSame($managed, $em->merge($managed));
-
-        $this->assertFalse($managed->__isInitialized());
-    }
-
-    public function testMergingProxyFromDifferentEntityManagerWithExistingManagedInstanceDoesNotReplaceInitializer()
-    {
-        $em1 = $this->createEntityManager($logger1 = new DebugStack());
-        $em2 = $this->createEntityManager($logger2 = new DebugStack());
-
-        $entity1 = new DateTimeModel();
-        $entity2 = new DateTimeModel();
-
-        $em1->persist($entity1);
-        $em2->persist($entity2);
-        $em1->flush();
-        $em2->flush();
-        $em1->clear();
-        $em2->clear();
-
-        $queryCount1 = count($logger1->queries);
-        $queryCount2 = count($logger2->queries);
-
-        $proxy1  = $em1->getReference(DateTimeModel::CLASSNAME, $entity1->id);
-        $proxy2  = $em2->getReference(DateTimeModel::CLASSNAME, $entity1->id);
-        $merged2 = $em2->merge($proxy1);
-
-        $this->assertNotSame($proxy1, $merged2);
-        $this->assertSame($proxy2, $merged2);
-
-        $this->assertFalse($proxy1->__isInitialized());
-        $this->assertFalse($proxy2->__isInitialized());
-
-        $proxy1->__load();
-
-        $this->assertCount(
-            $queryCount1 + 1,
-            $logger1->queries,
-            'Loading the first proxy was done through the first entity manager'
-        );
-        $this->assertCount(
-            $queryCount2,
-            $logger2->queries,
-            'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
-        );
-
-        $proxy2->__load();
-
-        $this->assertCount(
-            $queryCount1 + 1,
-            $logger1->queries,
-            'Loading the second proxy does not affect the first entity manager'
-        );
-        $this->assertCount(
-            $queryCount2 + 1,
-            $logger2->queries,
-            'Loading of the second proxy instance was done through the second entity manager'
-        );
-    }
-
-    public function testMergingUnInitializedProxyDoesNotInitializeIt()
-    {
-        $em1 = $this->createEntityManager($logger1 = new DebugStack());
-        $em2 = $this->createEntityManager($logger2 = new DebugStack());
-
-        $entity1 = new DateTimeModel();
-        $entity2 = new DateTimeModel();
-
-        $em1->persist($entity1);
-        $em2->persist($entity2);
-        $em1->flush();
-        $em2->flush();
-        $em1->clear();
-        $em2->clear();
-
-        $queryCount1 = count($logger1->queries);
-        $queryCount2 = count($logger1->queries);
-
-        $unManagedProxy = $em1->getReference(DateTimeModel::CLASSNAME, $entity1->id);
-        $mergedInstance = $em2->merge($unManagedProxy);
-
-        $this->assertNotInstanceOf('Doctrine\Common\Proxy\Proxy', $mergedInstance);
-        $this->assertNotSame($unManagedProxy, $mergedInstance);
-        $this->assertFalse($unManagedProxy->__isInitialized());
-
-        $this->assertCount(
-            $queryCount1,
-            $logger1->queries,
-            'Loading the merged instance affected only the first entity manager'
-        );
-        $this->assertCount(
-            $queryCount1 + 1,
-            $logger2->queries,
-            'Loading the merged instance was done via the second entity manager'
-        );
-
-        $unManagedProxy->__load();
-
-        $this->assertCount(
-            $queryCount1 + 1,
-            $logger1->queries,
-            'Loading the first proxy was done through the first entity manager'
-        );
-        $this->assertCount(
-            $queryCount2 + 1,
-            $logger2->queries,
-            'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
-        );
-    }
-
-    /**
-     * @param SQLLogger $logger
-     *
-     * @return \Doctrine\ORM\EntityManager
-     */
-    private function createEntityManager(SQLLogger $logger = null)
-    {
-        $config = new Configuration();
-
-        $config->setProxyDir(realpath(__DIR__ . '/../Proxies/../..'));
-        $config->setProxyNamespace('Doctrine\Tests\Proxies');
-        $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(
-            array(realpath(__DIR__ . '/../Models/Cache')),
-            true
-        ));
-
-        $connection = TestUtil::getConnection();
-
-        $connection->getConfiguration()->setSQLLogger($logger);
-
-        $entityManager = EntityManager::create($connection, $config);
-
-        try {
-            (new SchemaTool($entityManager))
-                ->createSchema([$entityManager->getClassMetadata(DateTimeModel::CLASSNAME)]);
-        } catch (ToolsException $ignored) {
-            // tables were already created
-        }
-
-        return $entityManager;
-    }
 }

From cd3fc6e6ea5d905e4a77a40cace2b86e0b419cd9 Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:43:52 +0100
Subject: [PATCH 15/19] #1172 - adding required `@group` annotations for newly
 introduced tests

---
 .../MergeUninitializedProxyTest.php           | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index faae9df80..a3aa9f2c2 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -28,6 +28,12 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         }
     }
 
+    /**
+     * @group DDC-1392
+     * @group DDC-1734
+     * @group DDC-3368
+     * @group #1172
+     */
     public function testMergeDetachedUnInitializedProxy()
     {
         $detachedUninitialized = $this->_em->getReference(MUPFile::CLASSNAME, 123);
@@ -42,6 +48,12 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($detachedUninitialized->__isInitialized());
     }
 
+    /**
+     * @group DDC-1392
+     * @group DDC-1734
+     * @group DDC-3368
+     * @group #1172
+     */
     public function testMergeUnserializedUnInitializedProxy()
     {
         $detachedUninitialized = $this->_em->getReference(MUPFile::CLASSNAME, 123);
@@ -59,6 +71,12 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($detachedUninitialized->__isInitialized());
     }
 
+    /**
+     * @group DDC-1392
+     * @group DDC-1734
+     * @group DDC-3368
+     * @group #1172
+     */
     public function testMergeManagedProxy()
     {
         $managed = $this->_em->getReference(MUPFile::CLASSNAME, 123);
@@ -68,6 +86,12 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $this->assertFalse($managed->__isInitialized());
     }
 
+    /**
+     * @group DDC-1392
+     * @group DDC-1734
+     * @group DDC-3368
+     * @group #1172
+     */
     public function testMergingProxyFromDifferentEntityManagerWithExistingManagedInstanceDoesNotReplaceInitializer()
     {
         $em1 = $this->createEntityManager($logger1 = new DebugStack());
@@ -123,6 +147,12 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         );
     }
 
+    /**
+     * @group DDC-1392
+     * @group DDC-1734
+     * @group DDC-3368
+     * @group #1172
+     */
     public function testMergingUnInitializedProxyDoesNotInitializeIt()
     {
         $em1 = $this->createEntityManager($logger1 = new DebugStack());

From 937113e23493c02444feb3948871a3f6bfacf45e Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:46:31 +0100
Subject: [PATCH 16/19] #1172 - simplified logic, re-using existing generic
 model

---
 .../MergeUninitializedProxyTest.php           | 74 ++++++-------------
 1 file changed, 22 insertions(+), 52 deletions(-)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
index a3aa9f2c2..987c3bbe8 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
@@ -8,22 +8,23 @@ use Doctrine\DBAL\Logging\DebugStack;
 use Doctrine\DBAL\Logging\SQLLogger;
 use Doctrine\ORM\Configuration;
 use Doctrine\ORM\EntityManager;
-use Doctrine\ORM\Proxy\Proxy;
 use Doctrine\ORM\Tools\SchemaTool;
 use Doctrine\ORM\Tools\ToolsException;
+use Doctrine\Tests\Models\Generic\DateTimeModel;
+use Doctrine\Tests\OrmFunctionalTestCase;
 use Doctrine\Tests\TestUtil;
 
-class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase {
-
+class MergeUninitializedProxyTest extends OrmFunctionalTestCase
+{
+    /**
+     * {@inheritDoc}
+     */
     protected function setUp()
     {
         parent::setUp();
 
         try {
-            $this->_schemaTool->createSchema(array(
-                    $this->_em->getClassMetadata(__NAMESPACE__ . '\MUPFile'),
-                    $this->_em->getClassMetadata(__NAMESPACE__ . '\MUPPicture'),
-                ));
+            $this->_schemaTool->createSchema(array($this->_em->getClassMetadata(DateTimeModel::CLASSNAME)));
         } catch (ToolsException $ignored) {
         }
     }
@@ -36,11 +37,11 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
      */
     public function testMergeDetachedUnInitializedProxy()
     {
-        $detachedUninitialized = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+        $detachedUninitialized = $this->_em->getReference(DateTimeModel::CLASSNAME, 123);
 
         $this->_em->clear();
 
-        $managed = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+        $managed = $this->_em->getReference(DateTimeModel::CLASSNAME, 123);
 
         $this->assertSame($managed, $this->_em->merge($detachedUninitialized));
 
@@ -56,11 +57,11 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
      */
     public function testMergeUnserializedUnInitializedProxy()
     {
-        $detachedUninitialized = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+        $detachedUninitialized = $this->_em->getReference(DateTimeModel::CLASSNAME, 123);
 
         $this->_em->clear();
 
-        $managed = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+        $managed = $this->_em->getReference(DateTimeModel::CLASSNAME, 123);
 
         $this->assertSame(
             $managed,
@@ -79,7 +80,7 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
      */
     public function testMergeManagedProxy()
     {
-        $managed = $this->_em->getReference(MUPFile::CLASSNAME, 123);
+        $managed = $this->_em->getReference(DateTimeModel::CLASSNAME, 123);
 
         $this->assertSame($managed, $this->_em->merge($managed));
 
@@ -97,8 +98,8 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $em1 = $this->createEntityManager($logger1 = new DebugStack());
         $em2 = $this->createEntityManager($logger2 = new DebugStack());
 
-        $file1 = new MUPFile();
-        $file2 = new MUPFile();
+        $file1 = new DateTimeModel();
+        $file2 = new DateTimeModel();
 
         $em1->persist($file1);
         $em2->persist($file2);
@@ -110,8 +111,8 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $queryCount1 = count($logger1->queries);
         $queryCount2 = count($logger2->queries);
 
-        $proxy1  = $em1->getReference(MUPFile::CLASSNAME, $file1->fileId);
-        $proxy2  = $em2->getReference(MUPFile::CLASSNAME, $file1->fileId);
+        $proxy1  = $em1->getReference(DateTimeModel::CLASSNAME, $file1->id);
+        $proxy2  = $em2->getReference(DateTimeModel::CLASSNAME, $file1->id);
         $merged2 = $em2->merge($proxy1);
 
         $this->assertNotSame($proxy1, $merged2);
@@ -158,8 +159,8 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $em1 = $this->createEntityManager($logger1 = new DebugStack());
         $em2 = $this->createEntityManager($logger2 = new DebugStack());
 
-        $file1 = new MUPFile();
-        $file2 = new MUPFile();
+        $file1 = new DateTimeModel();
+        $file2 = new DateTimeModel();
 
         $em1->persist($file1);
         $em2->persist($file2);
@@ -171,7 +172,7 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         $queryCount1 = count($logger1->queries);
         $queryCount2 = count($logger1->queries);
 
-        $unManagedProxy = $em1->getReference(MUPFile::CLASSNAME, $file1->fileId);
+        $unManagedProxy = $em1->getReference(DateTimeModel::CLASSNAME, $file1->id);
         $mergedInstance = $em2->merge($unManagedProxy);
 
         $this->assertNotInstanceOf('Doctrine\Common\Proxy\Proxy', $mergedInstance);
@@ -212,7 +213,7 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
     {
         $config = new Configuration();
 
-        $config->setProxyDir(realpath(__DIR__ . '/../../Proxies/../..'));
+        $config->setProxyDir(realpath(__DIR__ . '/../../Proxies'));
         $config->setProxyNamespace('Doctrine\Tests\Proxies');
         $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(
             array(realpath(__DIR__ . '/../../Models/Cache')),
@@ -227,7 +228,7 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
 
         try {
             (new SchemaTool($entityManager))
-                ->createSchema([$this->_em->getClassMetadata(MUPFile::CLASSNAME)]);
+                ->createSchema([$this->_em->getClassMetadata(DateTimeModel::CLASSNAME)]);
         } catch (ToolsException $ignored) {
             // tables were already created
         }
@@ -235,34 +236,3 @@ class MergeUninitializedProxyTest extends \Doctrine\Tests\OrmFunctionalTestCase
         return $entityManager;
     }
 }
-
-/**
- * @Entity
- */
-class MUPPicture
-{
-    /**
-     * @Column(name="picture_id", type="integer")
-     * @Id @GeneratedValue
-     */
-    public $pictureId;
-
-    /**
-     * @ManyToOne(targetEntity="MUPFile", cascade={"persist", "merge"})
-     * @JoinColumn(name="file_id", referencedColumnName="file_id")
-     */
-    public $file;
-
-}
-
-/** @Entity */
-class MUPFile
-{
-    const CLASSNAME = __CLASS__;
-
-    /** @Column(name="file_id", type="integer") @Id @GeneratedValue(strategy="AUTO") */
-    public $fileId;
-
-    /** @Column(type="string", nullable=true) */
-    private $contents;
-}

From 42c9ff026ec5096109cece0830ea0e8ca4543df9 Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:47:00 +0100
Subject: [PATCH 17/19] #1172 - renaming test class for clarity

---
 .../{MergeUninitializedProxyTest.php => MergeProxiesTest.php}   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename tests/Doctrine/Tests/ORM/Functional/{MergeUninitializedProxyTest.php => MergeProxiesTest.php} (99%)

diff --git a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php b/tests/Doctrine/Tests/ORM/Functional/MergeProxiesTest.php
similarity index 99%
rename from tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
rename to tests/Doctrine/Tests/ORM/Functional/MergeProxiesTest.php
index 987c3bbe8..68b9627e0 100644
--- a/tests/Doctrine/Tests/ORM/Functional/MergeUninitializedProxyTest.php
+++ b/tests/Doctrine/Tests/ORM/Functional/MergeProxiesTest.php
@@ -14,7 +14,7 @@ use Doctrine\Tests\Models\Generic\DateTimeModel;
 use Doctrine\Tests\OrmFunctionalTestCase;
 use Doctrine\Tests\TestUtil;
 
-class MergeUninitializedProxyTest extends OrmFunctionalTestCase
+class MergeProxiesTest extends OrmFunctionalTestCase
 {
     /**
      * {@inheritDoc}

From 45e733eb607032374e1519cb7d9437456d2d077c Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:50:52 +0100
Subject: [PATCH 18/19] #1172 - adding `@method` annotation to simplify static
 introspection

---
 lib/Doctrine/ORM/EntityManagerInterface.php | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/Doctrine/ORM/EntityManagerInterface.php b/lib/Doctrine/ORM/EntityManagerInterface.php
index 280ffb3c4..016cfd4ec 100644
--- a/lib/Doctrine/ORM/EntityManagerInterface.php
+++ b/lib/Doctrine/ORM/EntityManagerInterface.php
@@ -26,7 +26,9 @@ use Doctrine\ORM\Query\ResultSetMapping;
  * EntityManager interface
  *
  * @since   2.4
- * @author  Lars Strojny <lars@strojny.net
+ * @author  Lars Strojny <lars@strojny.net>
+ *
+ * @method Mapping\ClassMetadata getClassMetadata($className)
  */
 interface EntityManagerInterface extends ObjectManager
 {

From 57ce6ccfcf276034458b37e15009156e7d6a729e Mon Sep 17 00:00:00 2001
From: Marco Pivetta <ocramius@gmail.com>
Date: Fri, 16 Jan 2015 22:54:30 +0100
Subject: [PATCH 19/19] #1172 - fixed minor CS issues (spacing)

---
 lib/Doctrine/ORM/UnitOfWork.php | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/lib/Doctrine/ORM/UnitOfWork.php b/lib/Doctrine/ORM/UnitOfWork.php
index 5fe435ec4..5c2eb7bc0 100644
--- a/lib/Doctrine/ORM/UnitOfWork.php
+++ b/lib/Doctrine/ORM/UnitOfWork.php
@@ -3319,10 +3319,10 @@ class UnitOfWork implements PropertyChangedListener
     /**
      * @param object $entity
      * @param object $managedCopy
+     *
      * @throws ORMException
      * @throws OptimisticLockException
      * @throws TransactionRequiredException
-     * @internal param ClassMetadata $class
      */
     private function mergeEntityStateIntoManagedCopy($entity, $managedCopy)
     {
@@ -3330,13 +3330,16 @@ class UnitOfWork implements PropertyChangedListener
 
         foreach ($class->reflClass->getProperties() as $prop) {
             $name = $prop->name;
+
             $prop->setAccessible(true);
-            if (!isset($class->associationMappings[$name])) {
-                if (!$class->isIdentifier($name)) {
+
+            if ( ! isset($class->associationMappings[$name])) {
+                if ( ! $class->isIdentifier($name)) {
                     $prop->setValue($managedCopy, $prop->getValue($entity));
                 }
             } else {
                 $assoc2 = $class->associationMappings[$name];
+
                 if ($assoc2['type'] & ClassMetadata::TO_ONE) {
                     $other = $prop->getValue($entity);
                     if ($other === null) {
@@ -3346,10 +3349,11 @@ class UnitOfWork implements PropertyChangedListener
                             // do not merge fields marked lazy that have not been fetched.
                             return;
                         }
-                        if (!$assoc2['isCascadeMerge']) {
+
+                        if ( ! $assoc2['isCascadeMerge']) {
                             if ($this->getEntityState($other) === self::STATE_DETACHED) {
                                 $targetClass = $this->em->getClassMetadata($assoc2['targetEntity']);
-                                $relatedId = $targetClass->getIdentifierValues($other);
+                                $relatedId   = $targetClass->getIdentifierValues($other);
 
                                 if ($targetClass->subClasses) {
                                     $other = $this->em->find($targetClass->name, $relatedId);
@@ -3367,14 +3371,16 @@ class UnitOfWork implements PropertyChangedListener
                     }
                 } else {
                     $mergeCol = $prop->getValue($entity);
-                    if ($mergeCol instanceof PersistentCollection && !$mergeCol->isInitialized()) {
+
+                    if ($mergeCol instanceof PersistentCollection && ! $mergeCol->isInitialized()) {
                         // do not merge fields marked lazy that have not been fetched.
                         // keep the lazy persistent collection of the managed copy.
                         return;
                     }
 
                     $managedCol = $prop->getValue($managedCopy);
-                    if (!$managedCol) {
+
+                    if ( ! $managedCol) {
                         $managedCol = new PersistentCollection(
                             $this->em,
                             $this->em->getClassMetadata($assoc2['targetEntity']),
@@ -3382,19 +3388,21 @@ class UnitOfWork implements PropertyChangedListener
                         );
                         $managedCol->setOwner($managedCopy, $assoc2);
                         $prop->setValue($managedCopy, $managedCol);
-                        $oid = spl_object_hash($entity);
-                        $this->originalEntityData[$oid][$name] = $managedCol;
+
+                        $this->originalEntityData[spl_object_hash($entity)][$name] = $managedCol;
                     }
+
                     if ($assoc2['isCascadeMerge']) {
                         $managedCol->initialize();
 
                         // clear and set dirty a managed collection if its not also the same collection to merge from.
-                        if (!$managedCol->isEmpty() && $managedCol !== $mergeCol) {
+                        if ( ! $managedCol->isEmpty() && $managedCol !== $mergeCol) {
                             $managedCol->unwrap()->clear();
                             $managedCol->setDirty(true);
 
-                            if ($assoc2['isOwningSide'] && $assoc2['type'] == ClassMetadata::MANY_TO_MANY && $class->isChangeTrackingNotify(
-                                )
+                            if ($assoc2['isOwningSide']
+                                && $assoc2['type'] == ClassMetadata::MANY_TO_MANY
+                                && $class->isChangeTrackingNotify()
                             ) {
                                 $this->scheduleForDirtyCheck($managedCopy);
                             }