jpa/eclipselink.jpa.test/src/it/java/org/eclipse/persistence/testing/tests/jpa/xml/advanced/AdvancedJunitTest.java - eclipselink - Git at Google

 /*
  * Copyright (c) 1998, 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:
 //     Oracle - initial API and implementation from Oracle TopLink
 package org.eclipse.persistence.testing.tests.jpa.xml.advanced;

 import jakarta.persistence.EntityManager;
 import jakarta.persistence.RollbackException;

 import junit.framework.*;

 import org.eclipse.persistence.descriptors.ClassDescriptor;
 import org.eclipse.persistence.internal.sessions.RepeatableWriteUnitOfWork;
 import org.eclipse.persistence.jpa.JpaEntityManager;
 import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
 import org.eclipse.persistence.testing.models.jpa.xml.advanced.AdvancedTableCreator;

 import org.eclipse.persistence.testing.models.jpa.xml.advanced.Address;
 import org.eclipse.persistence.testing.models.jpa.xml.advanced.CacheAuditor;
 import org.eclipse.persistence.testing.models.jpa.xml.advanced.Employee;
 import org.eclipse.persistence.testing.models.jpa.xml.advanced.Man;
 import org.eclipse.persistence.testing.models.jpa.xml.advanced.Woman;
 import org.eclipse.persistence.testing.models.jpa.xml.advanced.PartnerLink;
 import org.eclipse.persistence.testing.models.jpa.xml.advanced.LargeProject;
 import org.eclipse.persistence.testing.tests.jpa.TestingProperties;

 public class AdvancedJunitTest extends JUnitTestCase {
     String m_persistenceUnit = "default";

     public AdvancedJunitTest() {
         super();
     }

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

     public AdvancedJunitTest(String name, String persistenceUnit) {
         super(name);

         m_persistenceUnit = persistenceUnit;
     }


     public static Test suite() {
         String ormTesting = TestingProperties.getProperty(TestingProperties.ORM_TESTING, TestingProperties.JPA_ORM_TESTING);
         final String persistenceUnit = ormTesting.equals(TestingProperties.JPA_ORM_TESTING)? "default" : "extended-advanced";
         TestSuite suite = new TestSuite("AdvancedJunitTest - " + persistenceUnit);

         suite.addTest(new AdvancedJunitTest("testSetup", persistenceUnit));
         suite.addTest(new AdvancedJunitTest("testEL254937", persistenceUnit));
         suite.addTest(new AdvancedJunitTest("testGF1894", persistenceUnit));
         suite.addTest(new AdvancedJunitTest("testManAndWoman", persistenceUnit));
         if (persistenceUnit.equals("extended-advanced")) {
             suite.addTest(new AdvancedJunitTest("testForRedirectorsAndInterceptors", persistenceUnit));
             suite.addTest(new AdvancedJunitTest("testForExceptionsFromInterceptors", persistenceUnit));
             suite.addTest(new AdvancedJunitTest("testCacheAccessCount", persistenceUnit));
             suite.addTest(new AdvancedJunitTest("testCacheAccessAppendLock", persistenceUnit));
         }

         return suite;
     }

     /**
      * The setup is done as a test, both to record its failure, and to allow execution in the server.
      */
     public void testSetup() {
         new AdvancedTableCreator().replaceTables(JUnitTestCase.getServerSession(m_persistenceUnit));

         clearCache(m_persistenceUnit);
     }

     /*public static EntityManager createEntityManager() {
         if (persistenceUnit==null){
             String ormTesting = TestingProperties.getProperty(TestingProperties.ORM_TESTING, TestingProperties.JPA_ORM_TESTING);
             persistenceUnit = ormTesting.equals(TestingProperties.JPA_ORM_TESTING)? "default" : "extended-advanced";
         }
     }*/

     public void testEL254937(){
         EntityManager em = createEntityManager(m_persistenceUnit);
         beginTransaction(em);
         LargeProject lp1 = new LargeProject();
         lp1.setName("one");
         em.persist(lp1);
         commitTransaction(em);
         em = createEntityManager(m_persistenceUnit);
         beginTransaction(em);
         em.remove(em.find(LargeProject.class, lp1.getId()));
         em.flush();
         JpaEntityManager eclipselinkEm = (JpaEntityManager)em.getDelegate();
         RepeatableWriteUnitOfWork uow =
             (RepeatableWriteUnitOfWork)eclipselinkEm.getActiveSession();
         //duplicate the beforeCompletion call
         uow.issueSQLbeforeCompletion();
         //commit the transaction
         uow.setShouldTerminateTransaction(true);
         uow.commitTransaction();
         //duplicate the AfterCompletion call.  This should merge, removing the LargeProject from the shared cache
         uow.mergeClonesAfterCompletion();
         em = createEntityManager(m_persistenceUnit);
         LargeProject cachedLargeProject = em.find(LargeProject.class, lp1.getId());
         closeEntityManager(em);
         assertTrue("Entity removed during flush was not removed from the shared cache on commit", cachedLargeProject==null);
     }

     public void testGF1894() {
         EntityManager em = createEntityManager(m_persistenceUnit);
         beginTransaction(em);
         Employee emp = new Employee("Guy", "Pelletier");

         Address address = new Address();
         address.setCity("College Town");

         emp.setAddress(address);

         try {
             Employee empClone = em.merge(emp);
             assertNotNull("The id field for the merged new employee object was not generated.", empClone.getId());
             commitTransaction(em);

             Employee empFromDB = em.find(Employee.class, empClone.getId());
             assertNotNull("The version locking field for the merged new employee object was not updated after commit.", empFromDB.getVersion());

             beginTransaction(em);
             Employee empClone2 = em.merge(empFromDB);
             assertTrue("The id field on a existing merged employee object was modified on a subsequent merge.", empFromDB.getId().equals(empClone2.getId()));
             commitTransaction(em);
         } catch (jakarta.persistence.OptimisticLockException e) {
             fail("An optimistic locking exception was caught on the merge of a new object. An insert should of occurred instead.");
         }

         closeEntityManager(em);
     }


     public void testManAndWoman() {
         EntityManager em = createEntityManager(m_persistenceUnit);
         beginTransaction(em);

         try {
             PartnerLink pLink1 = new PartnerLink();
             pLink1.setMan(new Man());
             em.persist(pLink1);

             PartnerLink pLink2 = new PartnerLink();
             pLink2.setWoman(new Woman());
             em.persist(pLink2);

             PartnerLink pLink3 = new PartnerLink();
             pLink3.setMan(new Man());
             pLink3.setWoman(new Woman());
             em.persist(pLink3);

             commitTransaction(em);

         } catch (RuntimeException e) {
             if (isTransactionActive(em)){
                 rollbackTransaction(em);
             }

             closeEntityManager(em);
             fail("An exception was caught: [" + e.getMessage() + "]");
         }

         closeEntityManager(em);
     }

     public void testForRedirectorsAndInterceptors() {
         ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
         assertTrue("CacheInterceptor was not set on decriptor", descriptor.getCacheInterceptorClassName() != null);
         assertTrue("All queries default redirector was not set on decriptor", descriptor.getDefaultQueryRedirector() != null);
         assertTrue("Read All queries default redirector was not set on decriptor", descriptor.getDefaultReadAllQueryRedirector() != null);
         assertTrue("Read Object queries default redirector was not set on decriptor", descriptor.getDefaultReadObjectQueryRedirector() != null);
         assertTrue("Report queries default redirector was not set on decriptor", descriptor.getDefaultReportQueryRedirector() != null);
         assertTrue("Insert queries default redirector was not set on decriptor", descriptor.getDefaultInsertObjectQueryRedirector() != null);
         assertTrue("Update queries default redirector was not set on decriptor", descriptor.getDefaultUpdateObjectQueryRedirector() != null);
         assertTrue("Delete queries default redirector was not set on decriptor", descriptor.getDefaultDeleteObjectQueryRedirector() != null);
     }
     public void testForExceptionsFromInterceptors() {
         ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
         CacheAuditor interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
         interceptor.setShouldThrow(true);
         EntityManager em = createEntityManager(m_persistenceUnit);
         beginTransaction(em);

         try {
             Address addr = new Address();
             addr.setCity("WhaHa");
             addr.setProvince("NFLD");
             em.persist(addr);
             commitTransaction(em);
             beginTransaction(em);
             em.remove(addr);
             commitTransaction(em);
             fail("There was no Optimistic Lock Exception");
         } catch (RollbackException e) {
             assertTrue("Not caused by OptimisticLockException", (e.getCause() instanceof jakarta.persistence.OptimisticLockException));

         }finally{
             interceptor.setShouldThrow(false);
             if (isTransactionActive(em)){
                 rollbackTransaction(em);
             }

             closeEntityManager(em);
         }
     }

     public void testCacheAccessAppendLock() {
         ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
         EntityManager em = createEntityManager(m_persistenceUnit);
         beginTransaction(em);
         Employee emp = new Employee();
         em.persist(emp);
         Address address = new Address("SomeStreet", "SomeCity", "SomeProvince", "SomeCountry", "S0M1O1");
         em.persist(address);
         Address address2 = new Address("SomeStreet2", "SomeCity2", "SomeProvince2", "SomeCountry2", "S0M2O2");
         em.persist(address2);
         emp.setAddress(address);
         commitTransaction(em);
         closeEntityManager(em);
         em = createEntityManager(m_persistenceUnit);
         CacheAuditor interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
         interceptor.resetAccessCount();
         try{
             emp = em.find(Employee.class, emp.getId());
             address2 = em.find(Address.class, address2.getId());
             interceptor.remove(address2.getId(), address2);
             beginTransaction(em);
             emp.setAddress(address2);
             commitTransaction(em);
             assertTrue("AppendLock identified as merge", interceptor.getLastAcquireNoWait() != null && !interceptor.getLastAcquireNoWait());
         }finally{
             interceptor.resetAccessCount();
             closeEntityManager(em);
         }
     }

     public void testCacheAccessCount() {
         ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
         EntityManager em = createEntityManager(m_persistenceUnit);
         beginTransaction(em);
         Employee emp = new Employee();
         em.persist(emp);
         Address address = new Address("SomeStreet", "SomeCity", "SomeProvince", "SomeCountry", "S0M1O1");
         em.persist(address);
         emp.setAddress(address);
         commitTransaction(em);
         closeEntityManager(em);
         clearCache(m_persistenceUnit);
         em = createEntityManager(m_persistenceUnit);
         CacheAuditor interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
         interceptor.resetAccessCount();
         try{
             em.find(Address.class, (int) System.currentTimeMillis());
             assertTrue("To many calls to cache for missing Entity", interceptor.getAccessCount() == 1);
         }finally{
             interceptor.resetAccessCount();
             closeEntityManager(em);
         }
         clearCache(m_persistenceUnit);
         interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
         em = createEntityManager(m_persistenceUnit);
         descriptor.setShouldLockForClone(false);
         try{
             Employee localEmp = em.find(Employee.class, emp.getId());
             localEmp.getAddress().getCity();
             assertTrue("To many calls to cache for loading relationship ", interceptor.getAccessCount() == 1);
         }finally{
             interceptor.resetAccessCount();
             descriptor.setShouldLockForClone(true);
             closeEntityManager(em);
         }
     }
 }
	/*
	* Copyright (c) 1998, 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:
	// Oracle - initial API and implementation from Oracle TopLink
	package org.eclipse.persistence.testing.tests.jpa.xml.advanced;

	import jakarta.persistence.EntityManager;
	import jakarta.persistence.RollbackException;

	import junit.framework.*;

	import org.eclipse.persistence.descriptors.ClassDescriptor;
	import org.eclipse.persistence.internal.sessions.RepeatableWriteUnitOfWork;
	import org.eclipse.persistence.jpa.JpaEntityManager;
	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
	import org.eclipse.persistence.testing.models.jpa.xml.advanced.AdvancedTableCreator;

	import org.eclipse.persistence.testing.models.jpa.xml.advanced.Address;
	import org.eclipse.persistence.testing.models.jpa.xml.advanced.CacheAuditor;
	import org.eclipse.persistence.testing.models.jpa.xml.advanced.Employee;
	import org.eclipse.persistence.testing.models.jpa.xml.advanced.Man;
	import org.eclipse.persistence.testing.models.jpa.xml.advanced.Woman;
	import org.eclipse.persistence.testing.models.jpa.xml.advanced.PartnerLink;
	import org.eclipse.persistence.testing.models.jpa.xml.advanced.LargeProject;
	import org.eclipse.persistence.testing.tests.jpa.TestingProperties;

	public class AdvancedJunitTest extends JUnitTestCase {
	String m_persistenceUnit = "default";

	public AdvancedJunitTest() {
	super();
	}

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

	public AdvancedJunitTest(String name, String persistenceUnit) {
	super(name);

	m_persistenceUnit = persistenceUnit;
	}


	public static Test suite() {
	String ormTesting = TestingProperties.getProperty(TestingProperties.ORM_TESTING, TestingProperties.JPA_ORM_TESTING);
	final String persistenceUnit = ormTesting.equals(TestingProperties.JPA_ORM_TESTING)? "default" : "extended-advanced";
	TestSuite suite = new TestSuite("AdvancedJunitTest - " + persistenceUnit);

	suite.addTest(new AdvancedJunitTest("testSetup", persistenceUnit));
	suite.addTest(new AdvancedJunitTest("testEL254937", persistenceUnit));
	suite.addTest(new AdvancedJunitTest("testGF1894", persistenceUnit));
	suite.addTest(new AdvancedJunitTest("testManAndWoman", persistenceUnit));
	if (persistenceUnit.equals("extended-advanced")) {
	suite.addTest(new AdvancedJunitTest("testForRedirectorsAndInterceptors", persistenceUnit));
	suite.addTest(new AdvancedJunitTest("testForExceptionsFromInterceptors", persistenceUnit));
	suite.addTest(new AdvancedJunitTest("testCacheAccessCount", persistenceUnit));
	suite.addTest(new AdvancedJunitTest("testCacheAccessAppendLock", persistenceUnit));
	}

	return suite;
	}

	/**
	* The setup is done as a test, both to record its failure, and to allow execution in the server.
	*/
	public void testSetup() {
	new AdvancedTableCreator().replaceTables(JUnitTestCase.getServerSession(m_persistenceUnit));

	clearCache(m_persistenceUnit);
	}

	/*public static EntityManager createEntityManager() {
	if (persistenceUnit==null){
	String ormTesting = TestingProperties.getProperty(TestingProperties.ORM_TESTING, TestingProperties.JPA_ORM_TESTING);
	persistenceUnit = ormTesting.equals(TestingProperties.JPA_ORM_TESTING)? "default" : "extended-advanced";
	}
	}*/

	public void testEL254937(){
	EntityManager em = createEntityManager(m_persistenceUnit);
	beginTransaction(em);
	LargeProject lp1 = new LargeProject();
	lp1.setName("one");
	em.persist(lp1);
	commitTransaction(em);
	em = createEntityManager(m_persistenceUnit);
	beginTransaction(em);
	em.remove(em.find(LargeProject.class, lp1.getId()));
	em.flush();
	JpaEntityManager eclipselinkEm = (JpaEntityManager)em.getDelegate();
	RepeatableWriteUnitOfWork uow =
	(RepeatableWriteUnitOfWork)eclipselinkEm.getActiveSession();
	//duplicate the beforeCompletion call
	uow.issueSQLbeforeCompletion();
	//commit the transaction
	uow.setShouldTerminateTransaction(true);
	uow.commitTransaction();
	//duplicate the AfterCompletion call. This should merge, removing the LargeProject from the shared cache
	uow.mergeClonesAfterCompletion();
	em = createEntityManager(m_persistenceUnit);
	LargeProject cachedLargeProject = em.find(LargeProject.class, lp1.getId());
	closeEntityManager(em);
	assertTrue("Entity removed during flush was not removed from the shared cache on commit", cachedLargeProject==null);
	}

	public void testGF1894() {
	EntityManager em = createEntityManager(m_persistenceUnit);
	beginTransaction(em);
	Employee emp = new Employee("Guy", "Pelletier");

	Address address = new Address();
	address.setCity("College Town");

	emp.setAddress(address);

	try {
	Employee empClone = em.merge(emp);
	assertNotNull("The id field for the merged new employee object was not generated.", empClone.getId());
	commitTransaction(em);

	Employee empFromDB = em.find(Employee.class, empClone.getId());
	assertNotNull("The version locking field for the merged new employee object was not updated after commit.", empFromDB.getVersion());

	beginTransaction(em);
	Employee empClone2 = em.merge(empFromDB);
	assertTrue("The id field on a existing merged employee object was modified on a subsequent merge.", empFromDB.getId().equals(empClone2.getId()));
	commitTransaction(em);
	} catch (jakarta.persistence.OptimisticLockException e) {
	fail("An optimistic locking exception was caught on the merge of a new object. An insert should of occurred instead.");
	}

	closeEntityManager(em);
	}



	public void testManAndWoman() {
	EntityManager em = createEntityManager(m_persistenceUnit);
	beginTransaction(em);

	try {
	PartnerLink pLink1 = new PartnerLink();
	pLink1.setMan(new Man());
	em.persist(pLink1);

	PartnerLink pLink2 = new PartnerLink();
	pLink2.setWoman(new Woman());
	em.persist(pLink2);

	PartnerLink pLink3 = new PartnerLink();
	pLink3.setMan(new Man());
	pLink3.setWoman(new Woman());
	em.persist(pLink3);

	commitTransaction(em);

	} catch (RuntimeException e) {
	if (isTransactionActive(em)){
	rollbackTransaction(em);
	}

	closeEntityManager(em);
	fail("An exception was caught: [" + e.getMessage() + "]");
	}

	closeEntityManager(em);
	}

	public void testForRedirectorsAndInterceptors() {
	ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
	assertTrue("CacheInterceptor was not set on decriptor", descriptor.getCacheInterceptorClassName() != null);
	assertTrue("All queries default redirector was not set on decriptor", descriptor.getDefaultQueryRedirector() != null);
	assertTrue("Read All queries default redirector was not set on decriptor", descriptor.getDefaultReadAllQueryRedirector() != null);
	assertTrue("Read Object queries default redirector was not set on decriptor", descriptor.getDefaultReadObjectQueryRedirector() != null);
	assertTrue("Report queries default redirector was not set on decriptor", descriptor.getDefaultReportQueryRedirector() != null);
	assertTrue("Insert queries default redirector was not set on decriptor", descriptor.getDefaultInsertObjectQueryRedirector() != null);
	assertTrue("Update queries default redirector was not set on decriptor", descriptor.getDefaultUpdateObjectQueryRedirector() != null);
	assertTrue("Delete queries default redirector was not set on decriptor", descriptor.getDefaultDeleteObjectQueryRedirector() != null);
	}
	public void testForExceptionsFromInterceptors() {
	ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
	CacheAuditor interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
	interceptor.setShouldThrow(true);
	EntityManager em = createEntityManager(m_persistenceUnit);
	beginTransaction(em);

	try {
	Address addr = new Address();
	addr.setCity("WhaHa");
	addr.setProvince("NFLD");
	em.persist(addr);
	commitTransaction(em);
	beginTransaction(em);
	em.remove(addr);
	commitTransaction(em);
	fail("There was no Optimistic Lock Exception");
	} catch (RollbackException e) {
	assertTrue("Not caused by OptimisticLockException", (e.getCause() instanceof jakarta.persistence.OptimisticLockException));

	}finally{
	interceptor.setShouldThrow(false);
	if (isTransactionActive(em)){
	rollbackTransaction(em);
	}

	closeEntityManager(em);
	}
	}

	public void testCacheAccessAppendLock() {
	ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
	EntityManager em = createEntityManager(m_persistenceUnit);
	beginTransaction(em);
	Employee emp = new Employee();
	em.persist(emp);
	Address address = new Address("SomeStreet", "SomeCity", "SomeProvince", "SomeCountry", "S0M1O1");
	em.persist(address);
	Address address2 = new Address("SomeStreet2", "SomeCity2", "SomeProvince2", "SomeCountry2", "S0M2O2");
	em.persist(address2);
	emp.setAddress(address);
	commitTransaction(em);
	closeEntityManager(em);
	em = createEntityManager(m_persistenceUnit);
	CacheAuditor interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
	interceptor.resetAccessCount();
	try{
	emp = em.find(Employee.class, emp.getId());
	address2 = em.find(Address.class, address2.getId());
	interceptor.remove(address2.getId(), address2);
	beginTransaction(em);
	emp.setAddress(address2);
	commitTransaction(em);
	assertTrue("AppendLock identified as merge", interceptor.getLastAcquireNoWait() != null && !interceptor.getLastAcquireNoWait());
	}finally{
	interceptor.resetAccessCount();
	closeEntityManager(em);
	}
	}

	public void testCacheAccessCount() {
	ClassDescriptor descriptor = getServerSession(m_persistenceUnit).getDescriptor(Address.class);
	EntityManager em = createEntityManager(m_persistenceUnit);
	beginTransaction(em);
	Employee emp = new Employee();
	em.persist(emp);
	Address address = new Address("SomeStreet", "SomeCity", "SomeProvince", "SomeCountry", "S0M1O1");
	em.persist(address);
	emp.setAddress(address);
	commitTransaction(em);
	closeEntityManager(em);
	clearCache(m_persistenceUnit);
	em = createEntityManager(m_persistenceUnit);
	CacheAuditor interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
	interceptor.resetAccessCount();
	try{
	em.find(Address.class, (int) System.currentTimeMillis());
	assertTrue("To many calls to cache for missing Entity", interceptor.getAccessCount() == 1);
	}finally{
	interceptor.resetAccessCount();
	closeEntityManager(em);
	}
	clearCache(m_persistenceUnit);
	interceptor = (CacheAuditor) getServerSession(m_persistenceUnit).getIdentityMapAccessorInstance().getIdentityMap(descriptor);
	em = createEntityManager(m_persistenceUnit);
	descriptor.setShouldLockForClone(false);
	try{
	Employee localEmp = em.find(Employee.class, emp.getId());
	localEmp.getAddress().getCity();
	assertTrue("To many calls to cache for loading relationship ", interceptor.getAccessCount() == 1);
	}finally{
	interceptor.resetAccessCount();
	descriptor.setShouldLockForClone(true);
	closeEntityManager(em);
	}
	}
	}