/*
 * Copyright (c) 2011, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     05/19/2010-2.1 ailitchev - Bug 244124 - Add Nested FetchGroup
package org.eclipse.persistence.testing.tests.jpa.fetchgroups;

import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jakarta.persistence.EntityManager;
import jakarta.persistence.Query;
import jakarta.persistence.TypedQuery;

import junit.framework.TestSuite;

import org.eclipse.persistence.config.CacheUsage;
import org.eclipse.persistence.config.QueryHints;
import org.eclipse.persistence.indirection.IndirectList;
import org.eclipse.persistence.internal.descriptors.InstanceVariableAttributeAccessor;
import org.eclipse.persistence.internal.helper.Helper;
import org.eclipse.persistence.internal.helper.IdentityHashSet;
import org.eclipse.persistence.internal.helper.SerializationHelper;
import org.eclipse.persistence.internal.jpa.EntityManagerImpl;
import org.eclipse.persistence.internal.queries.AttributeItem;
import org.eclipse.persistence.internal.queries.EntityFetchGroup;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.jpa.JpaEntityManager;
import org.eclipse.persistence.mappings.OneToOneMapping;
import org.eclipse.persistence.queries.AttributeGroup;
import org.eclipse.persistence.queries.FetchGroup;
import org.eclipse.persistence.sessions.CopyGroup;
import org.eclipse.persistence.sessions.server.ServerSession;
import org.eclipse.persistence.testing.models.jpa.advanced.Address;
import org.eclipse.persistence.testing.models.jpa.advanced.Department;
import org.eclipse.persistence.testing.models.jpa.advanced.Employee;
import org.eclipse.persistence.testing.models.jpa.advanced.EmploymentPeriod;
import org.eclipse.persistence.testing.models.jpa.advanced.PhoneNumber;
import org.eclipse.persistence.testing.models.jpa.advanced.Project;

import org.junit.Test;

/**
 * Simple tests to verify the functionality of {@link FetchGroup} when the
 * entities are detached through serialization.
 *
 * @author dclarke
 * @since EclipseLink 2.1
 */
public class SimpleSerializeFetchGroupTests extends BaseFetchGroupTests {

    public SimpleSerializeFetchGroupTests() {
        super();
    }

    public SimpleSerializeFetchGroupTests(String name) {
        super(name);
    }

    public static junit.framework.Test suite() {
        TestSuite suite = new TestSuite();
        suite.setName("SimpleSerializeFetchGroupTests");

        suite.addTest(new SimpleSerializeFetchGroupTests("testSetup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("verifyWriteReplaceOnFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("verifyAddAttributeInDetachedEntityFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("singleResultEmptyFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("resultListEmptyFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("resultListPeriodFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("managerFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("managerFetchGroupWithJoinFetch"));
        suite.addTest(new SimpleSerializeFetchGroupTests("employeeNamesFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("joinFetchEmployeeAddressWithDynamicFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("joinFetchEmployeeAddressPhoneWithDynamicFetchGroup"));
        suite.addTest(new SimpleSerializeFetchGroupTests("verifyFetchedRelationshipAttributes"));
        suite.addTest(new SimpleSerializeFetchGroupTests("attrAndVHContainSameObjectAfterGetRealAttributeValue"));
        if (!isJPA10()) {
            suite.addTest(new SimpleSerializeFetchGroupTests("findMinimalFetchGroup"));
            suite.addTest(new SimpleSerializeFetchGroupTests("findEmptyFetchGroup_setUnfetchedSalary"));
            suite.addTest(new SimpleSerializeFetchGroupTests("verifyUnfetchedAttributes"));
            suite.addTest(new SimpleSerializeFetchGroupTests("simpleSerializeAndMerge"));
            suite.addTest(new SimpleSerializeFetchGroupTests("partialMerge"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyGroupObjectGraph"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyGroupMerge"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyGroupMerge2"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyWithPk"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyWithPkUseFullGroup"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyWithoutPk"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyWithoutPkUseFullGroup"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyNoCascade"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyCascadePrivateParts"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyCascadeAllParts"));
            suite.addTest(new SimpleSerializeFetchGroupTests("copyEmbedded"));
        }

        return suite;
    }

    @Test
    public void verifyWriteReplaceOnFetchGroup() throws Exception {
        EntityFetchGroup fg = new EntityFetchGroup(new String[]{"basic", "a"});
        //fg.addAttribute("basic");
        //fg.addAttribute("a.b");

        //assertTrue(fg.getClass() == FetchGroup.class);

        FetchGroup serFG = serialize(fg);

        assertNotNull(serFG);
        assertTrue(serFG.getClass() == EntityFetchGroup.class);
        assertTrue(serFG.hasItems());

        AttributeItem basicFI = serFG.getItem("basic");

        assertNotNull(basicFI);
        //assertTrue(basicFI instanceof DetachedFetchItem);

        AttributeItem aFI = serFG.getItem("a");

        assertNotNull(aFI);
        //assertTrue(aFI instanceof DetachedFetchItem);
        // serialized EntityFetchGroup is always flat - doesn't have nested groups.
        assertNull(aFI.getGroup());
        /*assertNotNull(aFI.getGroup());
        assertTrue(aFI.getGroup() instanceof EntityFetchGroup);
        EntityFetchGroup aEFG = (EntityFetchGroup) aFI.getGroup();
        assertNull(aEFG.getParent());
        assertTrue(aEFG.hasItems());

        AttributeItem bFI = aEFG.getItem("b");

        assertNotNull(bFI);
        //assertTrue(bFI instanceof DetachedFetchItem);
        assertNull(bFI.getGroup());*/
    }

    @Test
    public void findMinimalFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        int minId = minimumEmployeeId(em);

        assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

        Map<String, Object> properties = new HashMap<String, Object>();

        FetchGroup fg = new FetchGroup();
        fg.addAttribute("id");
        fg.addAttribute("version");

        properties.put(QueryHints.FETCH_GROUP, fg);

        Employee emp = em.find(Employee.class, minId, properties);

        assertNotNull(emp);
        assertFetched(emp, fg);
        assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

        assertFetchedAttribute(emp, "id");
        assertFetchedAttribute(emp, "version");
        assertNotFetchedAttribute(emp, "firstName");
        assertNotFetchedAttribute(emp, "lastName");
        assertNotFetchedAttribute(emp, "gender");
        assertNotFetchedAttribute(emp, "salary");
        assertNotFetchedAttribute(emp, "startTime");
        assertNotFetchedAttribute(emp, "endTime");
        assertNotFetchedAttribute(emp, "period");
        assertNotFetchedAttribute(emp, "address");
        assertNotFetchedAttribute(emp, "manager");
        assertNotFetchedAttribute(emp, "phoneNumbers");
        assertNotFetchedAttribute(emp, "projects");

        assertTrue(getFetchGroup(emp).getClass() == EntityFetchGroup.class);
        Employee serEmp = serialize(emp);

        assertNotNull(serEmp);
        assertFetchedAttribute(serEmp, "id");
        assertFetchedAttribute(serEmp, "version");
        assertNotFetchedAttribute(serEmp, "firstName");
        assertNotFetchedAttribute(serEmp, "lastName");
        assertNotFetchedAttribute(serEmp, "gender");
        assertNotFetchedAttribute(serEmp, "salary");
        assertNotFetchedAttribute(serEmp, "startTime");
        assertNotFetchedAttribute(serEmp, "endTime");
        assertNotFetchedAttribute(serEmp, "period");
        assertNotFetchedAttribute(serEmp, "address");
        assertNotFetchedAttribute(serEmp, "manager");
        assertNotFetchedAttribute(serEmp, "phoneNumbers");
        assertNotFetchedAttribute(serEmp, "projects");

        assertTrue(getFetchGroup(serEmp) instanceof EntityFetchGroup);

        serEmp.setFirstName("Doug");
        assertFetchedAttribute(serEmp, "firstName");
    }

    @Test
    public void findEmptyFetchGroup_setUnfetchedSalary() throws Exception {
        EntityManager em = createEntityManager();
        int minId = minimumEmployeeId(em);
        try {
            beginTransaction(em);

            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            Map<String, Object> properties = new HashMap<String, Object>();
            FetchGroup emptyFG = new FetchGroup();
            properties.put(QueryHints.FETCH_GROUP, emptyFG);

            Employee emp = em.find(Employee.class, minId, properties);

            assertNotNull(emp);
            assertFetched(emp, emptyFG);
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // Check Basics
            assertFetchedAttribute(emp, "id");
            assertFetchedAttribute(emp, "version");
            assertNotFetchedAttribute(emp, "firstName");
            assertNotFetchedAttribute(emp, "lastName");
            assertNotFetchedAttribute(emp, "gender");
            assertNotFetchedAttribute(emp, "salary");
            assertNotFetchedAttribute(emp, "startTime");
            assertNotFetchedAttribute(emp, "endTime");
            if (emp.getPeriod() != null) {
                assertFetchedAttribute(emp.getPeriod(), "startDate");
                assertFetchedAttribute(emp.getPeriod(), "endDate");
            }
            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // Check Relationships
            assertNotFetchedAttribute(emp, "address");
            assertNotFetchedAttribute(emp, "manager");
            assertNotFetchedAttribute(emp, "phoneNumbers");
            assertNotFetchedAttribute(emp, "projects");

            emp.setSalary(1);

            assertFetchedAttribute(emp, "salary");

            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp);

            emp.getAddress();

            assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp.getAddress());

            emp.getPhoneNumbers().size();

            assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
            }
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    /**
     * Verify that attributes added to detached EntityFetchGroup are added using
     * DetachedFetchItem
     */
    @Test
    public void verifyAddAttributeInDetachedEntityFetchGroup() {
        EntityFetchGroup detFG = new EntityFetchGroup(new String[]{"basic", "a"});

        //detFG.addAttribute("basic");
        //detFG.addAttribute("a.b");

        //assertNull(detFG.getParent());
        assertEquals(2, detFG.getItems().size());

        AttributeItem basicItem = detFG.getItem("basic");
        assertNotNull(basicItem);
        assertEquals("basic", basicItem.getAttributeName());
        //assertTrue(basicItem instanceof DetachedFetchItem);
        assertNull(basicItem.getGroup());
        assertSame(detFG, basicItem.getParent());
        //assertFalse(basicItem.useDefaultFetchGroup());

        AttributeItem aItem = detFG.getItem("a");
        assertNotNull(aItem);
        assertEquals("a", aItem.getAttributeName());
        //assertTrue(aItem instanceof DetachedFetchItem);
        // serialized EntityFetchGroup is always flat - doesn't have nested groups.
        //assertNull(aItem.getGroup());
        assertNull(aItem.getGroup());
        assertSame(detFG, aItem.getParent());
        //assertFalse(aItem.useDefaultFetchGroup());
        //assertTrue(aItem.getGroup() instanceof EntityFetchGroup);

        //EntityFetchGroup aFG = (EntityFetchGroup) aItem.getGroup();

        //assertEquals(1, aFG.getItems().size());

        //AttributeItem bItem = aFG.getItem("b");
        //assertNotNull(bItem);
        //assertEquals("b", bItem.getAttributeName());
        //assertTrue(bItem instanceof DetachedFetchItem);
        //assertNull(bItem.getGroup());
        //assertSame(aFG, bItem.getParent());
        //assertFalse(bItem.useDefaultFetchGroup());
    }

    @Test
    public void singleResultEmptyFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
            query.setParameter("ID", minimumEmployeeId(em));
            FetchGroup emptyFG = new FetchGroup();
            query.setHint(QueryHints.FETCH_GROUP, emptyFG);

            Employee emp = (Employee) query.getSingleResult();

            assertNotNull(emp);
            assertFetched(emp, emptyFG);
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // Check Basics
            assertFetchedAttribute(emp, "id");
            assertFetchedAttribute(emp, "version");
            assertNotFetchedAttribute(emp, "firstName");
            assertNotFetchedAttribute(emp, "lastName");
            assertNotFetchedAttribute(emp, "gender");
            assertNotFetchedAttribute(emp, "salary");
            assertNotFetchedAttribute(emp, "startTime");
            assertNotFetchedAttribute(emp, "endTime");
            if (emp.getPeriod() != null) {
                assertFetchedAttribute(emp.getPeriod(), "startDate");
                assertFetchedAttribute(emp.getPeriod(), "endDate");
            }

            // Check Relationships
            assertNotFetchedAttribute(emp, "address");
            assertNotFetchedAttribute(emp, "manager");
            assertNotFetchedAttribute(emp, "phoneNumbers");
            assertNotFetchedAttribute(emp, "projects");

            emp.getSalary();

            assertFetchedAttribute(emp, "salary");

            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp);

            emp.getAddress();

            assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp.getAddress());

            emp.getPhoneNumbers().size();

            assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
            }
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    /**
     *
     */
    @Test
    public void resultListEmptyFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
            query.setParameter("ID", minimumEmployeeId(em));
            FetchGroup emptyFG = new FetchGroup();
            query.setHint(QueryHints.FETCH_GROUP, emptyFG);

            List<Employee> emps = query.getResultList();

            assertNotNull(emps);
            assertEquals(1, emps.size());

            Employee emp = emps.get(0);

            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertFetched(emp, emptyFG);

            // Check Basics
            assertFetchedAttribute(emp, "id");
            assertFetchedAttribute(emp, "version");
            assertNotFetchedAttribute(emp, "firstName");
            assertNotFetchedAttribute(emp, "lastName");
            assertNotFetchedAttribute(emp, "gender");
            assertNotFetchedAttribute(emp, "salary");
            assertNotFetchedAttribute(emp, "startTime");
            assertNotFetchedAttribute(emp, "endTime");
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            if (emp.getPeriod() != null) {
                assertFetchedAttribute(emp.getPeriod(), "startDate");
                assertFetchedAttribute(emp.getPeriod(), "endDate");
            }

            // Check Relationships
            assertNotFetchedAttribute(emp, "address");
            assertNotFetchedAttribute(emp, "manager");
            assertNotFetchedAttribute(emp, "phoneNumbers");
            assertNotFetchedAttribute(emp, "projects");

            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            emp.getSalary();

            assertFetchedAttribute(emp, "salary");
            assertNoFetchGroup(emp);
            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            assertNoFetchGroup(emp.getAddress());

            assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
            }
            assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    /**
     *
     */
    @Test
    public void resultListPeriodFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
            query.setParameter("ID", minimumEmployeeId(em));
            FetchGroup fg = new FetchGroup();
            fg.addAttribute("period");
            query.setHint(QueryHints.FETCH_GROUP, fg);

            List<Employee> emps = query.getResultList();

            assertNotNull(emps);
            assertEquals(1, emps.size());

            Employee emp = emps.get(0);

            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertFetched(emp, fg);

            // Check Basics
            assertFetchedAttribute(emp, "id");
            assertFetchedAttribute(emp, "version");
            assertNotFetchedAttribute(emp, "firstName");
            assertNotFetchedAttribute(emp, "lastName");
            assertNotFetchedAttribute(emp, "gender");
            assertNotFetchedAttribute(emp, "salary");
            assertNotFetchedAttribute(emp, "startTime");
            assertNotFetchedAttribute(emp, "endTime");
            if (emp.getPeriod() != null) {
                assertFetchedAttribute(emp.getPeriod(), "startDate");
                assertFetchedAttribute(emp.getPeriod(), "endDate");
            }

            // Check Relationships
            assertNotFetchedAttribute(emp, "address");
            assertNotFetchedAttribute(emp, "manager");
            assertNotFetchedAttribute(emp, "phoneNumbers");
            assertNotFetchedAttribute(emp, "projects");

            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            emp.getSalary();

            assertFetchedAttribute(emp, "salary");
            assertNoFetchGroup(emp);

            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            assertNoFetchGroup(emp.getAddress());

            assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
            }
            assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    @Override
    @Test
    public void managerFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            // Use q query since find will only use default fetch group
            //Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
            //query.setParameter("ID", minimumEmployeeId(em));

            // Complex where clause used to avoid triggering employees and their departments:
            //   Don't include employees who are managers themselves - otherwise if first selected as employee, then as e.manager the full read will be triggered;
            //   Don't include managers with departments - because there is no fetch group on e.manager its (non-null) department will trigger an extra sql
            Query query = em.createQuery("SELECT e FROM Employee e WHERE e.manager IS NOT NULL AND NOT EXISTS(SELECT e2 FROM Employee e2 WHERE e2.manager = e) AND e.manager.department IS NULL");

            FetchGroup managerFG = new FetchGroup();
            managerFG.addAttribute("manager");

            query.setHint(QueryHints.FETCH_GROUP, managerFG);

            assertNotNull(getFetchGroup(query));
            assertSame(managerFG, getFetchGroup(query));

            Employee emp = (Employee) query.getSingleResult();

            assertFetched(emp, managerFG);
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // manager (if not null) hasn't been instantiated yet.
            int nSqlToAdd = 0;
            if (emp.getManager() != null) {
                assertFetchedAttribute(emp, "manager");
                // additional sql to select the manager
                nSqlToAdd++;
            }

            assertEquals(1 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            emp.getLastName();

            assertEquals(2 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp);

            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
                phone.getAreaCode();
            }

            assertEquals(3 + nSqlToAdd, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    @Test
    public void managerFetchGroupWithJoinFetch() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            //int minId = minimumEmployeeId(em);
            //assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // Use q query since find will only use default fetch group
            //Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
            //query.setParameter("ID", minId);

            // Complex where clause used to avoid triggering employees and their departments:
            //   Don't include employees who are managers themselves - otherwise if first selected as employee, then as e.manager the full read will be triggered;
            //   Don't include managers with departments - because there is no fetch group on e.manager its (non-null) department will trigger an extra sql
            Query query = em.createQuery("SELECT e FROM Employee e WHERE e.manager IS NOT NULL AND NOT EXISTS(SELECT e2 FROM Employee e2 WHERE e2.manager = e) AND e.manager.department IS NULL");

            FetchGroup managerFG = new FetchGroup();
            managerFG.addAttribute("manager");

            query.setHint(QueryHints.FETCH_GROUP, managerFG);
            query.setHint(QueryHints.LEFT_FETCH, "e.manager");

            assertNotNull(getFetchGroup(query));
            assertSame(managerFG, getFetchGroup(query));

            Employee emp = (Employee) query.getSingleResult();

            assertFetched(emp, managerFG);
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // manager has been already instantiated by the query.
            emp.getManager();
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // instantiates the whiole object
            emp.getLastName();

            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp);

            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
                phone.getAreaCode();
            }

            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    @Override
    @Test
    public void employeeNamesFetchGroup() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            int minId = minimumEmployeeId(em);
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // Use q query since find will only use default fetch group
            Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = :ID");
            query.setParameter("ID", minId);
            FetchGroup namesFG = new FetchGroup();
            namesFG.addAttribute("firstName");
            namesFG.addAttribute("lastName");

            query.setHint(QueryHints.FETCH_GROUP, namesFG);

            assertNotNull(getFetchGroup(query));
            assertSame(namesFG, getFetchGroup(query));

            Employee emp = (Employee) query.getSingleResult();

            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertFetched(emp, namesFG);

            emp.getId();
            emp.getFirstName();
            emp.getLastName();
            emp.getVersion();

            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertFetched(emp, namesFG);

            emp.getGender();
            emp.getSalary();

            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            assertNoFetchGroup(emp);

            for (PhoneNumber phone : emp.getPhoneNumbers()) {
                assertNoFetchGroup(phone);
                phone.getAreaCode();
            }
            assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            if (emp.getManager() != null) {
                assertEquals(5, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
                assertNoFetchGroup(emp.getManager());
            } else {
                // If manager_id field is null then getManager() does not trigger an sql.
                assertEquals(4, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            }
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    @Override
    @Test
    public void joinFetchEmployeeAddressWithDynamicFetchGroup() {
        EntityManager em = createEntityManager();

        Query query = em.createQuery("SELECT e FROM Employee e JOIN FETCH e.address");

        FetchGroup fetchGroup = new FetchGroup("names");
        fetchGroup.addAttribute("firstName");
        fetchGroup.addAttribute("lastName");
        query.setHint(QueryHints.FETCH_GROUP, fetchGroup);

        List<Employee> emps = query.getResultList();

        assertNotNull(emps);
    }

    @Override
    @Test
    public void joinFetchEmployeeAddressPhoneWithDynamicFetchGroup() {
        EntityManager em = createEntityManager();

        Query query = em.createQuery("SELECT e FROM Employee e JOIN FETCH e.address WHERE e.id IN (SELECT p.id FROM PhoneNumber p)");

        FetchGroup fetchGroup = new FetchGroup("names");
        fetchGroup.addAttribute("firstName");
        fetchGroup.addAttribute("lastName");
        query.setHint(QueryHints.FETCH_GROUP, fetchGroup);

        List<Employee> emps = query.getResultList();

        assertNotNull(emps);
    }

    @Test
    public void verifyUnfetchedAttributes() throws Exception {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

            TypedQuery<Employee> q = em.createQuery("SELECT e FROM Employee e WHERE e.id IN (SELECT MIN(p.id) FROM PhoneNumber p)", Employee.class);
            FetchGroup fg = new FetchGroup("Employee.empty");
            q.setHint(QueryHints.FETCH_GROUP, fg);
            Employee emp = q.getSingleResult();

            assertNotNull(emp);
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            // This check using the mapping returns a default (empty) IndirectList
            /*OneToManyMapping phoneMapping = (OneToManyMapping) employeeDescriptor.getMappingForAttributeName("phoneNumbers");
            IndirectList phones = (IndirectList) phoneMapping.getAttributeValueFromObject(emp);
            assertNotNull(phones);
            assertTrue(phones.isInstantiated());
            assertEquals(0, phones.size());
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());*/

            IndirectList phonesIL = (IndirectList) emp.getPhoneNumbers();
            assertFalse(phonesIL.isInstantiated());
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());

            assertTrue(emp.getPhoneNumbers().size() > 0);
            assertEquals(3, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
    }

    @Test
    public void verifyFetchedRelationshipAttributes() throws Exception {
        EntityManager em = createEntityManager();

        FetchGroup fg = new FetchGroup("Employee.relationships");
        fg.addAttribute("address");
        fg.addAttribute("phoneNumbers");
        fg.addAttribute("manager");
        fg.addAttribute("projects");

        Map<String, Object> hints = new HashMap<String, Object>();
        hints.put(QueryHints.FETCH_GROUP, fg);

        Employee emp = minimumEmployee(em, hints);

        assertNotNull(emp);

    }

    @Test
    public void simpleSerializeAndMerge() throws Exception {
        EntityManager em = createEntityManager();
        int id = minEmployeeIdWithAddressAndPhones(em);
        HashMap<String, PhoneNumber> phonesOriginal = new HashMap();
        // save the original Employee for clean up
        Employee empOriginal = em.find(Employee.class, id);
        for(PhoneNumber phone : empOriginal.getPhoneNumbers()) {
            phonesOriginal.put(phone.getType(), phone);
        }
        closeEntityManager(em);
        clearCache();
        int newSalary = empOriginal.getSalary() * 2;
        if(newSalary == 0) {
            newSalary = 100;
        }

        em = createEntityManager();
        beginTransaction(em);
        Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = "+id);
        FetchGroup fetchGroup = new FetchGroup("names");
        fetchGroup.addAttribute("firstName");
        fetchGroup.addAttribute("lastName");
        fetchGroup.addAttribute("address.country");
        fetchGroup.addAttribute("phoneNumbers.areaCode");
        fetchGroup.addAttribute("phoneNumbers.owner.id");
        fetchGroup.setShouldLoad(true);
        query.setHint(QueryHints.FETCH_GROUP, fetchGroup);
        Employee emp = (Employee)query.getSingleResult();

        Employee empSerialized;
        Employee empDeserialized;
        Employee empMerged;
        try {
            empSerialized = serialize(emp);

            assertFetched(empSerialized, fetchGroup);
            empSerialized.setFirstName("newFirstName");
            empSerialized.setLastName("newLastName");

            // salary is not in the original fetchGroup
            empSerialized.setSalary(newSalary);
            FetchGroup extendedFetchGroup = fetchGroup.clone();
            extendedFetchGroup.addAttribute("salary");
            assertFetched(empSerialized, extendedFetchGroup);

            empSerialized.getAddress().setCountry("newCountry");
            assertFetched(empSerialized.getAddress(), fetchGroup.getGroup("address"));
            // address.city is not in the original fetchGroup
            empSerialized.getAddress().setCity("newCity");
            extendedFetchGroup.addAttribute("address.city");
            assertFetched(empSerialized.getAddress(), extendedFetchGroup.getGroup("address"));

            // phoneNumbers.number is not in the original fetchGroup
            extendedFetchGroup.addAttribute("phoneNumbers.number");
            for(PhoneNumber phone : empSerialized.getPhoneNumbers()) {
                phone.setAreaCode("000");
                assertFetched(phone, fetchGroup.getGroup("phoneNumbers"));
                // phoneNumbers.number is not in the original fetchGroup
                phone.setNumber("0000000");
                assertFetched(phone, extendedFetchGroup.getGroup("phoneNumbers"));
            }

            empDeserialized = serialize(empSerialized);
            assertFetched(empDeserialized, extendedFetchGroup);
            assertFetched(empDeserialized.getAddress(), extendedFetchGroup.getGroup("address"));
            for(PhoneNumber phone : empDeserialized.getPhoneNumbers()) {
                assertFetched(phone, extendedFetchGroup.getGroup("phoneNumbers"));
            }

            empMerged = em.merge(empDeserialized);

            // verify merged in em
            assertEquals("newFirstName", empMerged.getFirstName());
            assertEquals("newLastName", empMerged.getLastName());
            assertEquals(newSalary, empMerged.getSalary());
            assertEquals("newCountry", empMerged.getAddress().getCountry());
            assertEquals("newCity", empMerged.getAddress().getCity());
            for(PhoneNumber phone : empSerialized.getPhoneNumbers()) {
                assertEquals("000", phone.getAreaCode());
                assertEquals("0000000", phone.getNumber());
            }

            // verify that the attributes outside of the fetch group not nullified.
            assertEquals(empOriginal.getGender(), empMerged.getGender());
            if(empOriginal.getDepartment() != null) {
                assertEquals(empOriginal.getDepartment().getId(), empMerged.getDepartment().getId());
            }
            if(empOriginal.getPeriod() != null) {
                assertEquals(empOriginal.getPeriod().getStartDate(), empMerged.getPeriod().getStartDate());
                assertEquals(empOriginal.getPeriod().getEndDate(), empMerged.getPeriod().getEndDate());
            }
            assertEquals(empOriginal.getPayScale(), empMerged.getPayScale());
            assertEquals(empOriginal.getStartTime(), empMerged.getStartTime());
            assertEquals(empOriginal.getEndTime(), empMerged.getEndTime());
            commitTransaction(em);
        } finally {
            if(isTransactionActive(em)) {
               rollbackTransaction(em);
            }
        }

        // verify merged in the shared cache - clear em cache, query using cache only.
        em.clear();
        Map<String, Object> hints = new HashMap<String, Object>(2);
        hints.put(QueryHints.CACHE_USAGE, CacheUsage.CheckCacheOnly);
        //hints.put(QueryHints.FETCH_GROUP, fetchGroup);
        Employee empShared = em.find(Employee.class, id, hints);
        assertEquals("newFirstName", empShared.getFirstName());
        assertEquals("newLastName", empShared.getLastName());
        assertEquals(newSalary, empShared.getSalary());
        assertEquals("newCountry", empShared.getAddress().getCountry());
        assertEquals("newCity", empShared.getAddress().getCity());
        for(PhoneNumber phone : empShared.getPhoneNumbers()) {
            assertEquals("000", phone.getAreaCode());
            assertEquals("0000000", phone.getNumber());
        }

        // verify merged in shared the db - clear both em and shared caches.
        // Must read through the old EntityManager - the changes haven't been committed in the db.
        clearCache();
        em.clear();
        Employee empDb = em.find(Employee.class, id);
        assertEquals("newFirstName", empDb.getFirstName());
        assertEquals("newLastName", empDb.getLastName());
        assertEquals(newSalary, empDb.getSalary());
        assertEquals("newCountry", empDb.getAddress().getCountry());
        assertEquals("newCity", empDb.getAddress().getCity());
        for(PhoneNumber phone : empDb.getPhoneNumbers()) {
            assertEquals("000", phone.getAreaCode());
            assertEquals("0000000", phone.getNumber());
        }

        // clean up
        beginTransaction(em);
        try {
            empDb.setFirstName(empOriginal.getFirstName());
            empDb.setLastName(empOriginal.getLastName());
            empDb.setSalary(empOriginal.getSalary());
            empDb.getAddress().setCountry(empOriginal.getAddress().getCountry());
            empDb.getAddress().setCity(empOriginal.getAddress().getCity());
            for(PhoneNumber phone : empDb.getPhoneNumbers()) {
                PhoneNumber phoneOriginal = phonesOriginal.get(phone.getType());
                phone.setAreaCode(phoneOriginal.getAreaCode());
                phone.setNumber(phoneOriginal.getNumber());
            }
            commitTransaction(em);
        } finally {
            if(isTransactionActive(em)) {
                rollbackTransaction(em);
             }
            closeEntityManager(em);
        }
    }
    /*public void simpleSerializeAndMerge() throws Exception {
        EntityManager em = createEntityManager();
        int id = minimumEmployeeId(em);
        // save the original Employee for clean up
        Employee empOriginal = em.find(Employee.class, id);
        closeEntityManager(em);
        clearCache();
        int newSalary = empOriginal.getSalary() * 2;
        if(newSalary == 0) {
            newSalary = 100;
        }

        em = createEntityManager();
        Query query = em.createQuery("SELECT e FROM Employee e WHERE e.id = "+id);
        FetchGroup fetchGroup = new FetchGroup("names");
        fetchGroup.addAttribute("firstName");
        fetchGroup.addAttribute("lastName");
        query.setHint(QueryHints.FETCH_GROUP, fetchGroup);
        Employee emp = (Employee)query.getSingleResult();

        Employee empSerialized;
        Employee empDeserialized;
        Employee empMerged;
        beginTransaction(em);
        try {
            empSerialized = serialize(emp);
            empSerialized.setFirstName("newFirstName");
            empSerialized.setLastName("newLastName");
            empSerialized.setSalary(newSalary);
            empDeserialized = serialize(empSerialized);
            empMerged = em.merge(empDeserialized);

            // verify merged in em
            assertEquals("newFirstName", empMerged.getFirstName());
            assertEquals("newLastName", empMerged.getLastName());
            assertEquals(newSalary, empMerged.getSalary());
            commitTransaction(em);
        } finally {
            if(isTransactionActive(em)) {
               rollbackTransaction(em);
            }
        }

        // verify merged in the shared cache - clear em cache, query using cache only.
        em.clear();
        HashMap hints = new HashMap(2);
        hints.put(QueryHints.CACHE_USAGE, CacheUsage.CheckCacheOnly);
        hints.put(QueryHints.FETCH_GROUP, fetchGroup);
        Employee empShared = em.find(Employee.class, id, hints);
        assertEquals("newFirstName", empShared.getFirstName());
        assertEquals("newLastName", empShared.getLastName());
        assertEquals(newSalary, empShared.getSalary());

        // verify merged in shared the db - clear both em and shared caches.
        // Must read through the old EntityManager - the changes haven't been committed in the db.
        clearCache();
        em.clear();
        Employee empDb = em.find(Employee.class, id);
        assertEquals("newFirstName", empDb.getFirstName());
        assertEquals("newLastName", empDb.getLastName());
        assertEquals(newSalary, empDb.getSalary());

        beginTransaction(em);
        try {
            empDb.setFirstName(empOriginal.getFirstName());
            empDb.setLastName(empOriginal.getLastName());
            empDb.setSalary(empOriginal.getSalary());
            commitTransaction(em);
        } finally {
            if(isTransactionActive(em)) {
                rollbackTransaction(em);
             }
            closeEntityManager(em);
        }
    }*/

    public void partialMerge() throws Exception {
        EntityManager em = createEntityManager();
        // Search for an Employee with an Address and Phone Numbers
        try {
            beginTransaction(em);
            TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e WHERE e.address IS NOT NULL AND e.id IN (SELECT MIN(p.id) FROM PhoneNumber p)", Employee.class);

            // Load only its names and phone Numbers
            FetchGroup fetchGroup = new FetchGroup();
            fetchGroup.addAttribute("firstName");
            fetchGroup.addAttribute("lastName");
            FetchGroup phonesFG = phoneDescriptor.getFetchGroupManager().createFullFetchGroup();
            // that ensures the owner is not instantiated
            phonesFG.addAttribute("owner.id");
            phonesFG.removeAttribute("status");
            phonesFG.setShouldLoad(true);
            fetchGroup.addAttribute("phoneNumbers", phonesFG);

            // Make sure the FetchGroup also forces the relationships to be loaded
            fetchGroup.setShouldLoad(true);
            query.setHint(QueryHints.FETCH_GROUP, fetchGroup);

            Employee emp = query.getSingleResult();

            // Detach Employee through Serialization
            Employee detachedEmp = serialize(emp);

            // Modify the detached Employee inverting the names, adding a phone number, and setting the salary
            detachedEmp.setFirstName(emp.getLastName());
            detachedEmp.setLastName(emp.getFirstName());
            detachedEmp.addPhoneNumber(new PhoneNumber("TEST", "999", "999999"));
            // NOte that salary was not part of the original FetchGroupdetachedEmp.setSalary(1);
            detachedEmp.setSalary(1);

            // Merge the detached employee
            em.merge(detachedEmp);
            // Flush the changes to the database
            em.flush();
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void copyGroupObjectGraph() {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);
            TypedQuery<Department> query = em.createQuery("SELECT d FROM ADV_DEPT d WHERE d.id IN (SELECT MIN(dd.id) FROM ADV_DEPT dd)", Department.class);
            Department dept = query.getSingleResult();

            CopyGroup group = new CopyGroup();
            group.addAttribute("name");
            group.addAttribute("employees", new CopyGroup());
            group.getGroup("employees").addAttribute("name");
            group.getGroup("employees").addAttribute("department", new CopyGroup());
            group.getGroup("employees").getGroup("department").addAttribute("name");
            Department deptCopy = (Department) em.unwrap(JpaEntityManager.class).copy(dept, group);

            String reportCG = group.toString();
            assertNotNull(reportCG);
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }


    public void copyGroupMerge() {
        // Search for an Employee with an Address and Phone Numbers
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);
            TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e WHERE e.id IN (SELECT MIN(ee.id) FROM Employee ee)", Employee.class);
            Employee emp = query.getSingleResult();
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            System.out.println(">>> Employee retrieved");

            // Copy only its names and phone Numbers
            AttributeGroup group = new CopyGroup();
            group.addAttribute("firstName");
            group.addAttribute("lastName");
            group.addAttribute("address");

            Employee empCopy = (Employee) em.unwrap(JpaEntityManager.class).copy(emp, group);
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            System.out.println(">>> Employee copied");

            // Modify the detached Employee inverting the names, adding a phone number, and setting the salary
            empCopy.setFirstName(emp.getLastName());
            empCopy.setLastName(emp.getFirstName());

            // Note that salary was not part of the original FetchGroup
            //empCopy.setSalary(1);

            // Merge the detached employee
            em.merge(empCopy);
            System.out.println(">>> Sparse merge complete");

            // Flush the changes to the database
            em.flush();
            System.out.println(">>> Flush complete");
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void copyGroupMerge2() {
        // Search for an Employee with an Address and Phone Numbers
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);
            TypedQuery<Employee> query = em.createQuery("SELECT e FROM Employee e", Employee.class);
            query.setHint(QueryHints.BATCH, "e.address");
            List<Employee> employees = query.getResultList();
            assertEquals(1, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            System.out.println(">>> Employees retrieved");

            // Copy only its names and phone Numbers
            AttributeGroup group = new CopyGroup();
            group.addAttribute("firstName");
            group.addAttribute("lastName");
            group.addAttribute("address");

            List<Employee> employeesCopy = (List<Employee>) em.unwrap(JpaEntityManager.class).copy(employees, group);
            assertEquals(2, getQuerySQLTracker(em).getTotalSQLSELECTCalls());
            System.out.println(">>> Employees copied");

            for(Employee empCopy : employeesCopy) {
                // Modify the detached Employee inverting the names, adding a phone number, and setting the salary
                String firstName = empCopy.getFirstName();
                String lastName = empCopy.getLastName();
                empCopy.setFirstName(lastName);
                empCopy.setLastName(firstName);

                // Note that salary was not part of the original FetchGroup
                //empCopy.setSalary(1);

                // Merge the detached employee
                em.merge(empCopy);
            }
            System.out.println(">>> Sparse merge complete");

            // Flush the changes to the database
            em.flush();
            System.out.println(">>> Flush complete");

        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }


    @Test
    public void copyWithPk() {
        copyWithOrWithoutPk(false, false);
    }

    @Test
    public void copyWithPkUseFullGroup() {
        copyWithOrWithoutPk(false, true);
    }

    @Test
    public void copyWithoutPk() {
        copyWithOrWithoutPk(true, false);
    }

    @Test
    public void copyWithoutPkUseFullGroup() {
        copyWithOrWithoutPk(true, true);
    }

    void copyWithOrWithoutPk(boolean noPk, boolean useFullGroup) {
        CopyGroup group = new CopyGroup();
        if(noPk) {
            // setShouldResetPrimaryKey set to true means that:
            //  pk would not be copied - unless explicitly specified in the group;
            //  copy would not have a fetch group
            group.setShouldResetPrimaryKey(true);
            // setShouldResetVersion set to true means that
            // version would not be copied - unless explicitly specified in the group;
            group.setShouldResetVersion(true);
        }
        group.cascadeTree(); // Copy only the attributes specified
        // note that
        // default value shouldResetPrimaryKey==false causes pk to copied, too;
        // default value shouldResetVersion==false causes version to be copied, too.
        group.addAttribute("firstName");
        group.addAttribute("lastName");
        group.addAttribute("gender");
        group.addAttribute("period");
        group.addAttribute("salary");

        if(useFullGroup) {
            // copy group contains all the attributes defined in Address class
            CopyGroup address = addressDescriptor.getFetchGroupManager().createFullFetchGroup().toCopyGroup();
            // attribute "employees" removed from the group
            address.removeAttribute("employees");
            if(noPk) {
                // pk attribute "ID" removed from the group - not that it's necessary to explicitly remove it:
                // setShouldResetPrimaryKey(true) would not remove explicitly specified in the group pk.
                address.removeAttribute("ID");
                // note that default value shouldResetPrimaryKey==false would have resulted in copying the pk (that would be equivalent of adding the removed "ID" attribute back to the group).
                address.setShouldResetPrimaryKey(true);
                address.setShouldResetVersion(true);
            }
            group.addAttribute("address", address);

            // copy group contains all the attributes defined in PhoneNumber class
            CopyGroup phones = phoneDescriptor.getFetchGroupManager().createFullFetchGroup().toCopyGroup();
            if(noPk) {
                // the only goal of setting shouldResetPrimaryKey to true here is to avoid a FetchGroup being assigned to phone's copy.
                // Note that because both pk components ("owner" and "type") are part of the copy group they  still will be copied:
                // the phone's copy will have the same type as original and it's owner will be original's owner's copy.
                phones.setShouldResetPrimaryKey(true);
            }
            if(!noPk) {
                // to avoid instantiating the whole owner
                phones.addAttribute("owner.id");
            }
            group.addAttribute("phoneNumbers", phones);
        } else {
            // implicitly created sub CopyGroups address and phoneNumbers will have the same shouldReset flags values as their master CopyGroup.

            group.addAttribute("address.country");
            group.addAttribute("address.province");
            group.addAttribute("address.street");
            group.addAttribute("address.postalCode");
            group.addAttribute("address.city");

            if(noPk) {
                group.addAttribute("phoneNumbers.owner");
            } else {
                // to avoid instantiating the whole owner
                group.addAttribute("phoneNumbers.owner.id");
            }
            group.addAttribute("phoneNumbers.type");
            group.addAttribute("phoneNumbers.id");
            group.addAttribute("phoneNumbers.areaCode");
            group.addAttribute("phoneNumbers.number");
        }

        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);
            Employee emp = minimumEmployee(em);
            Employee empCopy = (Employee) em.unwrap(JpaEntityManager.class).copy(emp, group);

            if(noPk) {
                assertNoFetchGroup(empCopy);
                assertNoFetchGroup(empCopy.getAddress());
                for(PhoneNumber phoneCopy : empCopy.getPhoneNumbers()) {
                    assertNoFetchGroup(phoneCopy);
                }
                // Persist the employee copy
                em.persist(empCopy);
            } else {
                FetchGroup fetchGroup = group.toFetchGroup();
                // the following call adds pk and version, verifies that all attribute names correct.
                employeeDescriptor.getFetchGroupManager().prepareAndVerify(fetchGroup);
                // copyEmp, its address and phones each should have an EntityFetchGroup corresponding to the respective copyGroup.
                assertFetched(empCopy, fetchGroup);

                EntityFetchGroup addressEntityFetchGroup = addressDescriptor.getFetchGroupManager().getEntityFetchGroup(fetchGroup.getGroup("address"));
                if(addressEntityFetchGroup == null) {
                    assertNoFetchGroup(empCopy.getAddress());
                } else {
                    assertFetched(empCopy.getAddress(), addressEntityFetchGroup);
                }

                EntityFetchGroup phonesEntityFetchGroup = phoneDescriptor.getFetchGroupManager().getEntityFetchGroup(fetchGroup.getGroup("phoneNumbers"));
                for(PhoneNumber phoneCopy : empCopy.getPhoneNumbers()) {
                    if(phonesEntityFetchGroup == null) {
                        assertNoFetchGroup(phoneCopy);
                    } else {
                        assertFetched(phoneCopy, phonesEntityFetchGroup);
                    }
                }

                // to cause updates let's change something:
                //   in Employee table
                empCopy.setFirstName((empCopy.getFirstName() != null ? empCopy.getFirstName() : "") + "_NEW");
                //   in Salary table
                empCopy.setSalary(empCopy.getSalary() * 2 + 1);
                //   in Address
                empCopy.getAddress().setCountry((empCopy.getAddress().getCountry() != null ? empCopy.getAddress().getCountry() : "") + "_NEW");
                //   in each Phone
                for(PhoneNumber phoneCopy : empCopy.getPhoneNumbers()) {
                    if(phoneCopy.getAreaCode() != null && phoneCopy.getAreaCode().equals("000")) {
                        phoneCopy.setAreaCode("111");
                    } else {
                        phoneCopy.setAreaCode("000");
                    }
                }
                em.merge(empCopy);
            }

            // Insert a new row into Employee, Salary, Address, and a row for each Phone
            int nExpectedInsertsOrUpdates = 3 + empCopy.getPhoneNumbers().size();
            int nExpectedInserts, nExpectedUpdates;
            if(noPk) {
                nExpectedInserts = nExpectedInsertsOrUpdates;
                // table sequence might have been updated
                nExpectedUpdates = getQuerySQLTracker(em).getTotalSQLUPDATECalls();
            } else {
                nExpectedInserts = 0;
                nExpectedUpdates = nExpectedInsertsOrUpdates;
            }

            // Flush the changes to the database
            em.flush();

            assertEquals(nExpectedInserts, getQuerySQLTracker(em).getTotalSQLINSERTCalls());
            assertEquals(nExpectedUpdates, getQuerySQLTracker(em).getTotalSQLUPDATECalls());
        } finally {
            if(isTransactionActive(em)) {
                rollbackTransaction(em);
            }
        }
    }

    @Test
    public void copyNoCascade() {
        copyCascade(CopyGroup.NO_CASCADE);
    }

    @Test
    public void copyCascadePrivateParts() {
        copyCascade(CopyGroup.CASCADE_PRIVATE_PARTS);
    }

    @Test
    public void copyCascadeAllParts() {
        copyCascade(CopyGroup.CASCADE_ALL_PARTS);
    }

    void copyCascade(int cascadeDepth) {
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);
            Query query = em.createQuery("SELECT e FROM Employee e");
            List<Employee> employees = query.getResultList();

            CopyGroup group = new CopyGroup();
            if(cascadeDepth == CopyGroup.NO_CASCADE) {
                group.dontCascade();
            } else if(cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS) {
                // default cascade depth setting
                group.cascadePrivateParts();
            } else if(cascadeDepth == CopyGroup.CASCADE_ALL_PARTS) {
                group.cascadeAllParts();
            } else {
                fail("Invalid cascadeDepth = " + cascadeDepth);
            }
            group.setShouldResetPrimaryKey(true);

            List<Employee> employeesCopy;
            if(cascadeDepth == CopyGroup.NO_CASCADE || cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS) {
                // In this case the objects should be copied one by one - each one using a new CopyGroup.
                // That ensures most referenced object are original ones (not copies) -
                // the only exception is privately owned objects in CASCADE_PRIVATE_PARTS case.
                employeesCopy = new ArrayList(employees.size());
                for(Employee emp : employees) {
                    CopyGroup groupClone = group.clone();
                    employeesCopy.add((Employee)em.unwrap(JpaEntityManager.class).copy(emp, groupClone));
                }
            } else {
                // cascadeDepth == CopyGroup.CASCADE_ALL_PARTS
                // In this case all objects should be copied using a single CopyGroup.
                // That ensures identities of the copies:
                // for instance if several employees referenced the same project,
                // then all copies of these employees will reference the single copy of the project.
                employeesCopy = (List)em.unwrap(JpaEntityManager.class).copy(employees, group);
            }

            // IdentityHashSets will be used to verify copy identities
            IdentityHashSet originalEmployees = new IdentityHashSet();
            IdentityHashSet copyEmployees = new IdentityHashSet();
            IdentityHashSet originalAddresses = new IdentityHashSet();
            IdentityHashSet copyAddresses = new IdentityHashSet();
            IdentityHashSet originalProjects = new IdentityHashSet();
            IdentityHashSet copyProjects = new IdentityHashSet();
            IdentityHashSet originalPhones = new IdentityHashSet();
            IdentityHashSet copyPhones = new IdentityHashSet();

            int size = employees.size();
            for(int i=0; i < size; i++) {
                Employee emp = employees.get(i);
                Employee empCopy = employeesCopy.get(i);
                if(cascadeDepth == CopyGroup.CASCADE_ALL_PARTS) {
                    originalEmployees.add(emp);
                    copyEmployees.add(empCopy);
                } else {
                    // cascadeDepth == CopyGroup.NO_CASCADE || cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS
                    // In this case all Employees referenced by empCopyes are originals (manager and managed employees).
                    // Therefore if we add here each emp and empCopy to originalEmployees and copyEmployees respectively
                    // then copyEmployees will always contain all original managers and managed + plus all copies.
                    // Therefore in this case originalEmployees and copyEmployees will contain only references (managers and managed employees).
                }

                if(emp.getAddress() == null) {
                    assertTrue("emp.getAddress() == null, but empCopy.getAddress() != null", empCopy.getAddress() == null);
                } else {
                    originalAddresses.add(emp.getAddress());
                    copyAddresses.add(empCopy.getAddress());
                    if(cascadeDepth == CopyGroup.NO_CASCADE || cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS) {
                        assertTrue("address has been copied", emp.getAddress() == empCopy.getAddress());
                    } else {
                        // cascadeDepth == CopyGroup.CASCADE_ALL_PARTS
                        assertFalse("address has not been copied", emp.getAddress() == empCopy.getAddress());
                    }
                }

                boolean same;
                for(Project project : emp.getProjects()) {
                    originalProjects.add(project);
                    same = false;
                    for(Project projectCopy : empCopy.getProjects()) {
                        copyProjects.add(projectCopy);
                        if(!same && project == projectCopy) {
                            same = true;
                        }
                    }
                    if(cascadeDepth == CopyGroup.NO_CASCADE || cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS) {
                        assertTrue("project has been copied", same);
                    } else {
                        // cascadeDepth == CopyGroup.CASCADE_ALL_PARTS
                        assertFalse("project has not been copied", same);
                    }
                }

                for(Employee managedEmp : emp.getManagedEmployees()) {
                    originalEmployees.add(managedEmp);
                    same = false;
                    for(Employee managedEmpCopy : empCopy.getManagedEmployees()) {
                        copyEmployees.add(managedEmpCopy);
                        if(!same && managedEmp == managedEmpCopy) {
                            same = true;
                        }
                    }
                    if(cascadeDepth == CopyGroup.NO_CASCADE || cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS) {
                        assertTrue("managedEmployee has been copied", same);
                    } else {
                        // cascadeDepth == CopyGroup.CASCADE_ALL_PARTS
                        assertFalse("managedEmployee has not been copied", same);
                    }
                }

                if(emp.getManager() == null) {
                    assertTrue("emp.getManager() == null, but empCopy.getManager() != null", empCopy.getManager() == null);
                } else {
                    originalEmployees.add(emp.getManager());
                    copyEmployees.add(empCopy.getManager());
                    if(cascadeDepth == CopyGroup.NO_CASCADE || cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS) {
                        assertTrue("manager has been copied", emp.getManager() == empCopy.getManager());
                    } else {
                        // cascadeDepth == CopyGroup.CASCADE_ALL_PARTS
                        assertFalse("manager has not been copied", emp.getManager() == empCopy.getManager());
                    }
                }

                // phoneNumbers is privately owned
                for(PhoneNumber phone : emp.getPhoneNumbers()) {
                    originalPhones.add(phone);
                    same = false;
                    for(PhoneNumber phoneCopy : empCopy.getPhoneNumbers()) {
                        copyPhones.add(phoneCopy);
                        if(!same && phone == phoneCopy) {
                            same = true;
                        }
                    }
                    if(cascadeDepth == CopyGroup.NO_CASCADE) {
                        assertTrue("phone has been copied", same);
                    } else {
                        // cascadeDepth == CopyGroup.CASCADE_ALL_PARTS || cascadeDepth == CopyGroup.CASCADE_PRIVATE_PARTS
                        assertFalse("phone has not been copied", same);
                    }
                }
            }

            assertTrue("copyEmployees.size() == " + copyEmployees.size() + "; was expected " + originalEmployees.size(), originalEmployees.size() == copyEmployees.size());
            assertTrue("copyAddresses.size() == " + copyAddresses.size() + "; was expected " + originalAddresses.size(), originalAddresses.size() == copyAddresses.size());
            assertTrue("copyProjects.size() == " + copyProjects.size() + "; was expected " + originalProjects.size(), originalProjects.size() == copyProjects.size());
            assertTrue("copyPhones.size() == " + copyPhones.size() + "; was expected " + originalPhones.size(), originalPhones.size() == copyPhones.size());
        } finally {
            if(isTransactionActive(em)) {
                rollbackTransaction(em);
            }
        }
    }

    @Test
    public void attrAndVHContainSameObjectAfterGetRealAttributeValue() throws Exception {
        String errorMsg = "";
        EntityManager em = createEntityManager();
        try {
            beginTransaction(em);

             Query query = em.createQuery("SELECT e FROM Employee e WHERE e.address IS NOT NULL and e.manager IS NOT NULL");
             List<Employee> employees = query.getResultList();

             OneToOneMapping addressMapping = (OneToOneMapping)employeeDescriptor.getMappingForAttributeName("address");
             OneToOneMapping managerMapping = (OneToOneMapping)employeeDescriptor.getMappingForAttributeName("manager");

             InstanceVariableAttributeAccessor addressAccessor = new InstanceVariableAttributeAccessor();
             addressAccessor.setAttributeName("m_address");
             addressAccessor.initializeAttributes(Employee.class);

             InstanceVariableAttributeAccessor managerAccessor = new InstanceVariableAttributeAccessor();
             managerAccessor.setAttributeName("manager");
             managerAccessor.initializeAttributes(Employee.class);

             AbstractSession session = (AbstractSession)((EntityManagerImpl)em.getDelegate()).getActiveSession();

             for(Employee emp : employees) {
                 String localErrorMsg = "";
                 Address addressVH = (Address)addressMapping.getRealAttributeValueFromObject(emp, session);
                 Address addressAttr = (Address)addressAccessor.getAttributeValueFromObject(emp);
                 if(addressVH != addressAttr) {
                     localErrorMsg += "\n\taddressVH = " + addressVH + " != addressAttr = " + addressAttr;
                 }
                 Employee managerVH = (Employee)managerMapping.getRealAttributeValueFromObject(emp, session);
                 Employee managerAttr = (Employee)managerAccessor.getAttributeValueFromObject(emp);
                 if(managerVH != managerAttr) {
                     localErrorMsg += "\n\tmanagerVH = " + managerVH + " != managerAttr = " + managerAttr;
                 }
                 if(localErrorMsg.length() > 0) {
                     localErrorMsg = emp.toString() + localErrorMsg + "\n";
                     errorMsg += localErrorMsg;
                 }
             }
        } finally {
            if (isTransactionActive(em)){
                rollbackTransaction(em);
            }
            closeEntityManager(em);
        }
        if(errorMsg.length() > 0) {
            errorMsg = '\n' + errorMsg;
            fail(errorMsg);
        }
    }

    @Test
    public void copyEmbedded() {
        Employee emp = new Employee();
        emp.setPeriod(new EmploymentPeriod(Helper.dateFromYearMonthDate(1993, 0, 1), Helper.dateFromYearMonthDate(1996, 11, 31)));

        CopyGroup group = new CopyGroup();
        group.addAttribute("period");

        EntityManager em = createEntityManager();
        Employee empCopy = (Employee) em.unwrap(ServerSession.class).copy(emp, group);

        assertTrue("!emp.getPeriod().equals(empCopy.getPeriod())", emp.getPeriod().equals(empCopy.getPeriod()));
        assertHasFetchGroup(empCopy);
    }

    private <T> T serialize(Serializable entity) throws IOException, ClassNotFoundException {
        byte[] bytes = SerializationHelper.serialize(entity);
        ObjectInputStream inStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
        return (T) inStream.readObject();
    }
}