openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/kernel/AbstractBrokerSerializationTest.java - openjpa - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.openjpa.kernel;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.HashMap;
 import java.util.Map;
 import javax.persistence.EntityManager;

 import org.apache.openjpa.event.AbstractLifecycleListener;
 import org.apache.openjpa.event.AbstractTransactionListener;
 import org.apache.openjpa.event.LifecycleEvent;
 import org.apache.openjpa.event.TransactionEvent;
 import org.apache.openjpa.persistence.InvalidStateException;
 import org.apache.openjpa.persistence.JPAFacadeHelper;
 import org.apache.openjpa.persistence.OpenJPAEntityManager;
 import org.apache.openjpa.persistence.OpenJPAEntityManagerFactory;
 import org.apache.openjpa.persistence.jdbc.JDBCFetchPlan;
 import org.apache.openjpa.persistence.jdbc.JoinSyntax;
 import org.apache.openjpa.persistence.test.SingleEMFTestCase;

 /*
  * To test:
  *  - managed transactions
  *  - converting non-enhanced classes to enhanced subclasses
  *    (maybe an ugly ThreadLocal, maybe through PCData?)
  */
 public abstract class AbstractBrokerSerializationTest<T>
     extends SingleEMFTestCase {

     private static LifeListener deserializedLifeListener;
     private static int testGlobalRefreshCount = 0;

     private static TxListener deserializedTxListener;
     private static int testGlobalBeginCount = 0;


     private Object id;

     public void setUp() {
         testGlobalRefreshCount = 0;
         deserializedLifeListener = null;
         testGlobalBeginCount = 0;
         deserializedTxListener = null;

         setUp(getManagedType(), getSecondaryType(), CLEAR_TABLES,
             "openjpa.EntityManagerFactoryPool", "true");

         T e = newManagedInstance();
         OpenJPAEntityManager em = emf.createEntityManager();
         em.getTransaction().begin();
         em.persist(e);
         em.getTransaction().commit();
         id = em.getObjectId(e);
         em.close();
     }

     @Override
     public void tearDown() throws Exception {
         super.tearDown();
         testGlobalRefreshCount = 0;
         deserializedLifeListener = null;
         testGlobalBeginCount = 0;
         deserializedTxListener = null;
     }

     public void testEmptyBrokerSerialization() {
         OpenJPAEntityManager em = emf.createEntityManager();
         OpenJPAEntityManager em2 = deserializeEM(serialize(em));

         assertTrue(em != em2);
         assertTrue(
             JPAFacadeHelper.toBroker(em) != JPAFacadeHelper.toBroker(em2));
         assertSame(em.getEntityManagerFactory(), em2.getEntityManagerFactory());

         assertSame(em2, JPAFacadeHelper.toBroker(em2)
             .getUserObject(JPAFacadeHelper.EM_KEY));

         em.close();
         assertTrue(em2.isOpen());
         em2.close();
     }

     public void testNontransactionalBrokerSerialization() {
         OpenJPAEntityManager em = emf.createEntityManager();
         T e = em.find(getManagedType(), id);
         OpenJPAEntityManager em2 = deserializeEM(serialize(em));

         assertFalse(em2.getTransaction().isActive());

         assertFalse(em2.contains(e));
         assertEquals(1*graphSize(), em2.getManagedObjects().size());
         T e2 = em2.find(getManagedType(), id);
         assertEquals(em.getObjectId(e), em2.getObjectId(e2));

         em.close();
         em2.close();
     }

     public void testUnflushedOptimisticTxBrokerSerialization() {
         OpenJPAEntityManager em = emf.createEntityManager();
         T e = em.find(getManagedType(), id);
         OpenJPAEntityManager em2 = null;
         OpenJPAEntityManager em3 = null;
         try {
             em.getTransaction().begin();
             modifyInstance(e);
             T newe = newManagedInstance();
             em.persist(newe);
             em2 = deserializeEM(serialize(em));

             assertTrue(em2.getTransaction().isActive());

             assertFalse(em2.contains(e));
             T e2 = em2.find(getManagedType(), id);
             assertEquals(em.getObjectId(e), em2.getObjectId(e2));

             assertEquals("modified", getModifiedValue(e2));

             em.getTransaction().rollback();
             assertTrue(em2.getTransaction().isActive());
             em2.getTransaction().commit();

             em3 = emf.createEntityManager();
             T e3 = em3.find(getManagedType(), id);
             assertEquals(getModifiedValue(e2), getModifiedValue(e3));
             assertTrue(1 < ((Number) em3.createQuery("select count(o) from "
                 + getManagedType().getName() + " o").getSingleResult())
                 .intValue());
         } finally {
             close(em);
             close(em2);
             close(em3);
         }
     }

     public void testFlushedOptimisticTxBrokerSerialization() {
         OpenJPAEntityManager em = emf.createEntityManager();
         T e = em.find(getManagedType(), id);
         em.getTransaction().begin();
         modifyInstance(e);
         em.flush();
         try {
             serialize(em);
         } catch (InvalidStateException ise) {
             // expected
             assertTrue(ise.getMessage().contains("flushed"));
         } finally {
             em.getTransaction().rollback();
             em.close();
         }
     }

     public void testConnectedOptimisticTxBrokerSerialization() {
         Map m = new HashMap();
         m.put("openjpa.ConnectionRetainMode", "always");
         OpenJPAEntityManager em = emf.createEntityManager(m);
         try {
             serialize(em);
         } catch (InvalidStateException ise) {
             // expected
             assertTrue(ise.getMessage().contains("connected"));
         } finally {
             em.close();
         }
     }

     public void testEmptyPessimisticTxBrokerSerialization() {
         Map m = new HashMap();
         m.put("openjpa.Optimistic", "false");
         OpenJPAEntityManager em = emf.createEntityManager(m);
         em.getTransaction().begin();
         try {
             serialize(em);
             fail("should not be able to serialize");
         } catch (InvalidStateException ise) {
             // expected
             assertTrue(ise.getMessage().contains("datastore (pessimistic)"));
         } finally {
             em.getTransaction().rollback();
             em.close();
         }
     }

     public void testNonEmptyPessimisticTxBrokerSerialization() {
         Map m = new HashMap();
         m.put("openjpa.Optimistic", "false");
         OpenJPAEntityManager em = emf.createEntityManager(m);
         T e = em.find(getManagedType(), id);
         em.getTransaction().begin();
         try {
             serialize(em);
             fail("should not be able to serialize");
         } catch (InvalidStateException ise) {
             // expected
             assertTrue(ise.getMessage().contains("datastore (pessimistic)"));
         } finally {
             em.getTransaction().rollback();
             em.close();
         }
     }

     public void testFetchConfigurationMutations() {
         OpenJPAEntityManager em = emf.createEntityManager();
         JDBCFetchPlan plan = (JDBCFetchPlan) em.getFetchPlan();

         assertNotEquals(17, plan.getLockTimeout());
         assertNotEquals(JoinSyntax.TRADITIONAL, plan.getJoinSyntax());

         plan.setLockTimeout(17);
         plan.setJoinSyntax(JoinSyntax.TRADITIONAL);

         OpenJPAEntityManager em2 = deserializeEM(serialize(em));
         JDBCFetchPlan plan2 = (JDBCFetchPlan) em2.getFetchPlan();
         assertEquals(17, plan2.getLockTimeout());
         assertEquals(JoinSyntax.TRADITIONAL, plan2.getJoinSyntax());
     }

     public void testInMemorySavepointsWithNewInstances() {
         emf.close();
         OpenJPAEntityManagerFactory emf = createEMF(
             getManagedType(), getSecondaryType(),
             "openjpa.EntityManagerFactoryPool", "true",
             "openjpa.SavepointManager", "in-mem");
         OpenJPAEntityManager em = emf.createEntityManager();
         OpenJPAEntityManager em2 = null;
         try {
             em.getTransaction().begin();
             T t = newManagedInstance();
             Object orig = getModifiedValue(t);
             em.persist(t);
             Object id = em.getObjectId(t);
             em.setSavepoint("foo");
             modifyInstance(t);
             assertNotEquals(orig, getModifiedValue(t));

             em2 = deserializeEM(serialize(em));
             T t2 = em2.find(getManagedType(), id);
             assertNotEquals(orig, getModifiedValue(t2));

             em.rollbackToSavepoint("foo");
             assertEquals(orig, getModifiedValue(t));

             em2.rollbackToSavepoint("foo");
             assertEquals(orig, getModifiedValue(t2));
         } finally {
             close(em);
             close(em2);
         }
     }

     public void testInMemorySavepointsWithModifiedInstances() {
         emf.close();
         OpenJPAEntityManagerFactory emf = createEMF(
             getManagedType(), getSecondaryType(),
             "openjpa.EntityManagerFactoryPool", "true",
             "openjpa.SavepointManager", "in-mem");
         OpenJPAEntityManager em = emf.createEntityManager();
         OpenJPAEntityManager em2 = null;
         try {
             em.getTransaction().begin();
             T t = em.find(getManagedType(), id);
             Object orig = getModifiedValue(t);
             em.setSavepoint("foo");
             modifyInstance(t);
             assertNotEquals(orig, getModifiedValue(t));

             em2 = deserializeEM(serialize(em));
             T t2 = em2.find(getManagedType(), id);
             assertNotEquals(orig, getModifiedValue(t2));

             em.rollbackToSavepoint("foo");
             assertEquals(orig, getModifiedValue(t));

             em2.rollbackToSavepoint("foo");
             assertEquals(orig, getModifiedValue(t2));
         } finally {
             close(em);
             close(em2);
         }
     }

     public void testEventManagers() {
         TxListener txListener = new TxListener();
         emf.addTransactionListener(txListener);
         LifeListener lifeListener = new LifeListener();
         emf.addLifecycleListener(lifeListener, null);

         OpenJPAEntityManager em = emf.createEntityManager();
         T t = em.find(getManagedType(), id);
         assertEquals(0, lifeListener.refreshCount);
         em.refresh(t);
         assertEquals(1*graphSize(), lifeListener.refreshCount);
         em.getTransaction().begin();
         em.getTransaction().commit();
         em.getTransaction().begin();
         em.getTransaction().commit();
         assertEquals(2, txListener.beginCount);

         OpenJPAEntityManager em2 = deserializeEM(serialize(em));
         assertNotNull(deserializedLifeListener);
         assertEquals(1* graphSize(),
             deserializedLifeListener.refreshCount);
         assertNotSame(lifeListener, deserializedLifeListener);
         T t2 = em2.find(getManagedType(), id);
         em2.refresh(t2);
         assertEquals(2* graphSize(),
             deserializedLifeListener.refreshCount);

         // if this is 3*refreshMultiplier(), that means that there are
         // extra registered listeners
         assertEquals(2* graphSize(), testGlobalRefreshCount);


         assertNotNull(deserializedTxListener);
         assertEquals(2, deserializedTxListener.beginCount);
         assertNotSame(txListener, deserializedTxListener);
         em2.getTransaction().begin();
         em2.getTransaction().rollback();
         assertEquals(3, deserializedTxListener.beginCount);

         // if this is 4, that means that there are extra registered listeners
         assertEquals(3, testGlobalBeginCount);
     }

     byte[] serialize(Object o) {
         try {
             ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos);
             oos.writeObject(o);
             oos.flush();
             return baos.toByteArray();
         } catch (IOException ioe) {
             throw new RuntimeException(ioe);
         }
     }

     OpenJPAEntityManager deserializeEM(byte[] bytes) {
         return (OpenJPAEntityManager) deserialize(bytes);
     }

     private Object deserialize(byte[] bytes) {
         try {
             ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
             ObjectInputStream ois = new ObjectInputStream(bais);
             return ois.readObject();
         } catch (IOException ioe) {
             throw new RuntimeException(ioe);
         } catch (ClassNotFoundException e) {
             throw new RuntimeException(e);
         }
     }

     void close(EntityManager em) {
         if (em != null && em.isOpen() && em.getTransaction().isActive())
             em.getTransaction().rollback();
         if (em != null && em.isOpen())
             em.close();
     }

     protected abstract Class<T> getManagedType();

     protected abstract T newManagedInstance();

     protected abstract void modifyInstance(T t);

     protected abstract Object getModifiedValue(T t);

     /**
      * The number of instances in the graph created
      * by {@link #newManagedInstance()} of type T.
      */
     protected int graphSize() {
         return 1;
     }

     /**
      * An additional type that must be available in this PC. May be null.
      */
     protected Class getSecondaryType() {
         return null;
     }

     private static class TxListener
         extends AbstractTransactionListener
         implements Serializable {

         private int beginCount = 0;

         public TxListener() {

         }

         @Override
         public void afterBegin(TransactionEvent event) {
             beginCount++;
             testGlobalBeginCount++;
         }

         private void readObject(ObjectInputStream in)
             throws ClassNotFoundException, IOException {
             in.defaultReadObject();
             deserializedTxListener = this;
         }
     }

     private static class LifeListener
         extends AbstractLifecycleListener
         implements Serializable {

         private int refreshCount = 0;

         @Override
         public void afterRefresh(LifecycleEvent event) {
             refreshCount++;
             testGlobalRefreshCount++;
         }

         private void readObject(ObjectInputStream in)
             throws ClassNotFoundException, IOException {
             in.defaultReadObject();
             deserializedLifeListener = this;
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.openjpa.kernel;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.io.Serializable;
	import java.util.HashMap;
	import java.util.Map;
	import javax.persistence.EntityManager;

	import org.apache.openjpa.event.AbstractLifecycleListener;
	import org.apache.openjpa.event.AbstractTransactionListener;
	import org.apache.openjpa.event.LifecycleEvent;
	import org.apache.openjpa.event.TransactionEvent;
	import org.apache.openjpa.persistence.InvalidStateException;
	import org.apache.openjpa.persistence.JPAFacadeHelper;
	import org.apache.openjpa.persistence.OpenJPAEntityManager;
	import org.apache.openjpa.persistence.OpenJPAEntityManagerFactory;
	import org.apache.openjpa.persistence.jdbc.JDBCFetchPlan;
	import org.apache.openjpa.persistence.jdbc.JoinSyntax;
	import org.apache.openjpa.persistence.test.SingleEMFTestCase;

	/*
	* To test:
	* - managed transactions
	* - converting non-enhanced classes to enhanced subclasses
	* (maybe an ugly ThreadLocal, maybe through PCData?)
	*/
	public abstract class AbstractBrokerSerializationTest<T>
	extends SingleEMFTestCase {

	private static LifeListener deserializedLifeListener;
	private static int testGlobalRefreshCount = 0;

	private static TxListener deserializedTxListener;
	private static int testGlobalBeginCount = 0;


	private Object id;

	public void setUp() {
	testGlobalRefreshCount = 0;
	deserializedLifeListener = null;
	testGlobalBeginCount = 0;
	deserializedTxListener = null;

	setUp(getManagedType(), getSecondaryType(), CLEAR_TABLES,
	"openjpa.EntityManagerFactoryPool", "true");

	T e = newManagedInstance();
	OpenJPAEntityManager em = emf.createEntityManager();
	em.getTransaction().begin();
	em.persist(e);
	em.getTransaction().commit();
	id = em.getObjectId(e);
	em.close();
	}

	@Override
	public void tearDown() throws Exception {
	super.tearDown();
	testGlobalRefreshCount = 0;
	deserializedLifeListener = null;
	testGlobalBeginCount = 0;
	deserializedTxListener = null;
	}

	public void testEmptyBrokerSerialization() {
	OpenJPAEntityManager em = emf.createEntityManager();
	OpenJPAEntityManager em2 = deserializeEM(serialize(em));

	assertTrue(em != em2);
	assertTrue(
	JPAFacadeHelper.toBroker(em) != JPAFacadeHelper.toBroker(em2));
	assertSame(em.getEntityManagerFactory(), em2.getEntityManagerFactory());

	assertSame(em2, JPAFacadeHelper.toBroker(em2)
	.getUserObject(JPAFacadeHelper.EM_KEY));

	em.close();
	assertTrue(em2.isOpen());
	em2.close();
	}

	public void testNontransactionalBrokerSerialization() {
	OpenJPAEntityManager em = emf.createEntityManager();
	T e = em.find(getManagedType(), id);
	OpenJPAEntityManager em2 = deserializeEM(serialize(em));

	assertFalse(em2.getTransaction().isActive());

	assertFalse(em2.contains(e));
	assertEquals(1*graphSize(), em2.getManagedObjects().size());
	T e2 = em2.find(getManagedType(), id);
	assertEquals(em.getObjectId(e), em2.getObjectId(e2));

	em.close();
	em2.close();
	}

	public void testUnflushedOptimisticTxBrokerSerialization() {
	OpenJPAEntityManager em = emf.createEntityManager();
	T e = em.find(getManagedType(), id);
	OpenJPAEntityManager em2 = null;
	OpenJPAEntityManager em3 = null;
	try {
	em.getTransaction().begin();
	modifyInstance(e);
	T newe = newManagedInstance();
	em.persist(newe);
	em2 = deserializeEM(serialize(em));

	assertTrue(em2.getTransaction().isActive());

	assertFalse(em2.contains(e));
	T e2 = em2.find(getManagedType(), id);
	assertEquals(em.getObjectId(e), em2.getObjectId(e2));

	assertEquals("modified", getModifiedValue(e2));

	em.getTransaction().rollback();
	assertTrue(em2.getTransaction().isActive());
	em2.getTransaction().commit();

	em3 = emf.createEntityManager();
	T e3 = em3.find(getManagedType(), id);
	assertEquals(getModifiedValue(e2), getModifiedValue(e3));
	assertTrue(1 < ((Number) em3.createQuery("select count(o) from "
	+ getManagedType().getName() + " o").getSingleResult())
	.intValue());
	} finally {
	close(em);
	close(em2);
	close(em3);
	}
	}

	public void testFlushedOptimisticTxBrokerSerialization() {
	OpenJPAEntityManager em = emf.createEntityManager();
	T e = em.find(getManagedType(), id);
	em.getTransaction().begin();
	modifyInstance(e);
	em.flush();
	try {
	serialize(em);
	} catch (InvalidStateException ise) {
	// expected
	assertTrue(ise.getMessage().contains("flushed"));
	} finally {
	em.getTransaction().rollback();
	em.close();
	}
	}

	public void testConnectedOptimisticTxBrokerSerialization() {
	Map m = new HashMap();
	m.put("openjpa.ConnectionRetainMode", "always");
	OpenJPAEntityManager em = emf.createEntityManager(m);
	try {
	serialize(em);
	} catch (InvalidStateException ise) {
	// expected
	assertTrue(ise.getMessage().contains("connected"));
	} finally {
	em.close();
	}
	}

	public void testEmptyPessimisticTxBrokerSerialization() {
	Map m = new HashMap();
	m.put("openjpa.Optimistic", "false");
	OpenJPAEntityManager em = emf.createEntityManager(m);
	em.getTransaction().begin();
	try {
	serialize(em);
	fail("should not be able to serialize");
	} catch (InvalidStateException ise) {
	// expected
	assertTrue(ise.getMessage().contains("datastore (pessimistic)"));
	} finally {
	em.getTransaction().rollback();
	em.close();
	}
	}

	public void testNonEmptyPessimisticTxBrokerSerialization() {
	Map m = new HashMap();
	m.put("openjpa.Optimistic", "false");
	OpenJPAEntityManager em = emf.createEntityManager(m);
	T e = em.find(getManagedType(), id);
	em.getTransaction().begin();
	try {
	serialize(em);
	fail("should not be able to serialize");
	} catch (InvalidStateException ise) {
	// expected
	assertTrue(ise.getMessage().contains("datastore (pessimistic)"));
	} finally {
	em.getTransaction().rollback();
	em.close();
	}
	}

	public void testFetchConfigurationMutations() {
	OpenJPAEntityManager em = emf.createEntityManager();
	JDBCFetchPlan plan = (JDBCFetchPlan) em.getFetchPlan();

	assertNotEquals(17, plan.getLockTimeout());
	assertNotEquals(JoinSyntax.TRADITIONAL, plan.getJoinSyntax());

	plan.setLockTimeout(17);
	plan.setJoinSyntax(JoinSyntax.TRADITIONAL);

	OpenJPAEntityManager em2 = deserializeEM(serialize(em));
	JDBCFetchPlan plan2 = (JDBCFetchPlan) em2.getFetchPlan();
	assertEquals(17, plan2.getLockTimeout());
	assertEquals(JoinSyntax.TRADITIONAL, plan2.getJoinSyntax());
	}

	public void testInMemorySavepointsWithNewInstances() {
	emf.close();
	OpenJPAEntityManagerFactory emf = createEMF(
	getManagedType(), getSecondaryType(),
	"openjpa.EntityManagerFactoryPool", "true",
	"openjpa.SavepointManager", "in-mem");
	OpenJPAEntityManager em = emf.createEntityManager();
	OpenJPAEntityManager em2 = null;
	try {
	em.getTransaction().begin();
	T t = newManagedInstance();
	Object orig = getModifiedValue(t);
	em.persist(t);
	Object id = em.getObjectId(t);
	em.setSavepoint("foo");
	modifyInstance(t);
	assertNotEquals(orig, getModifiedValue(t));

	em2 = deserializeEM(serialize(em));
	T t2 = em2.find(getManagedType(), id);
	assertNotEquals(orig, getModifiedValue(t2));

	em.rollbackToSavepoint("foo");
	assertEquals(orig, getModifiedValue(t));

	em2.rollbackToSavepoint("foo");
	assertEquals(orig, getModifiedValue(t2));
	} finally {
	close(em);
	close(em2);
	}
	}

	public void testInMemorySavepointsWithModifiedInstances() {
	emf.close();
	OpenJPAEntityManagerFactory emf = createEMF(
	getManagedType(), getSecondaryType(),
	"openjpa.EntityManagerFactoryPool", "true",
	"openjpa.SavepointManager", "in-mem");
	OpenJPAEntityManager em = emf.createEntityManager();
	OpenJPAEntityManager em2 = null;
	try {
	em.getTransaction().begin();
	T t = em.find(getManagedType(), id);
	Object orig = getModifiedValue(t);
	em.setSavepoint("foo");
	modifyInstance(t);
	assertNotEquals(orig, getModifiedValue(t));

	em2 = deserializeEM(serialize(em));
	T t2 = em2.find(getManagedType(), id);
	assertNotEquals(orig, getModifiedValue(t2));

	em.rollbackToSavepoint("foo");
	assertEquals(orig, getModifiedValue(t));

	em2.rollbackToSavepoint("foo");
	assertEquals(orig, getModifiedValue(t2));
	} finally {
	close(em);
	close(em2);
	}
	}

	public void testEventManagers() {
	TxListener txListener = new TxListener();
	emf.addTransactionListener(txListener);
	LifeListener lifeListener = new LifeListener();
	emf.addLifecycleListener(lifeListener, null);

	OpenJPAEntityManager em = emf.createEntityManager();
	T t = em.find(getManagedType(), id);
	assertEquals(0, lifeListener.refreshCount);
	em.refresh(t);
	assertEquals(1*graphSize(), lifeListener.refreshCount);
	em.getTransaction().begin();
	em.getTransaction().commit();
	em.getTransaction().begin();
	em.getTransaction().commit();
	assertEquals(2, txListener.beginCount);

	OpenJPAEntityManager em2 = deserializeEM(serialize(em));
	assertNotNull(deserializedLifeListener);
	assertEquals(1* graphSize(),
	deserializedLifeListener.refreshCount);
	assertNotSame(lifeListener, deserializedLifeListener);
	T t2 = em2.find(getManagedType(), id);
	em2.refresh(t2);
	assertEquals(2* graphSize(),
	deserializedLifeListener.refreshCount);

	// if this is 3*refreshMultiplier(), that means that there are
	// extra registered listeners
	assertEquals(2* graphSize(), testGlobalRefreshCount);


	assertNotNull(deserializedTxListener);
	assertEquals(2, deserializedTxListener.beginCount);
	assertNotSame(txListener, deserializedTxListener);
	em2.getTransaction().begin();
	em2.getTransaction().rollback();
	assertEquals(3, deserializedTxListener.beginCount);

	// if this is 4, that means that there are extra registered listeners
	assertEquals(3, testGlobalBeginCount);
	}

	byte[] serialize(Object o) {
	try {
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	ObjectOutputStream oos = new ObjectOutputStream(baos);
	oos.writeObject(o);
	oos.flush();
	return baos.toByteArray();
	} catch (IOException ioe) {
	throw new RuntimeException(ioe);
	}
	}

	OpenJPAEntityManager deserializeEM(byte[] bytes) {
	return (OpenJPAEntityManager) deserialize(bytes);
	}

	private Object deserialize(byte[] bytes) {
	try {
	ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
	ObjectInputStream ois = new ObjectInputStream(bais);
	return ois.readObject();
	} catch (IOException ioe) {
	throw new RuntimeException(ioe);
	} catch (ClassNotFoundException e) {
	throw new RuntimeException(e);
	}
	}

	void close(EntityManager em) {
	if (em != null && em.isOpen() && em.getTransaction().isActive())
	em.getTransaction().rollback();
	if (em != null && em.isOpen())
	em.close();
	}

	protected abstract Class<T> getManagedType();

	protected abstract T newManagedInstance();

	protected abstract void modifyInstance(T t);

	protected abstract Object getModifiedValue(T t);

	/**
	* The number of instances in the graph created
	* by {@link #newManagedInstance()} of type T.
	*/
	protected int graphSize() {
	return 1;
	}

	/**
	* An additional type that must be available in this PC. May be null.
	*/
	protected Class getSecondaryType() {
	return null;
	}

	private static class TxListener
	extends AbstractTransactionListener
	implements Serializable {

	private int beginCount = 0;

	public TxListener() {

	}

	@Override
	public void afterBegin(TransactionEvent event) {
	beginCount++;
	testGlobalBeginCount++;
	}

	private void readObject(ObjectInputStream in)
	throws ClassNotFoundException, IOException {
	in.defaultReadObject();
	deserializedTxListener = this;
	}
	}

	private static class LifeListener
	extends AbstractLifecycleListener
	implements Serializable {

	private int refreshCount = 0;

	@Override
	public void afterRefresh(LifecycleEvent event) {
	refreshCount++;
	testGlobalRefreshCount++;
	}

	private void readObject(ObjectInputStream in)
	throws ClassNotFoundException, IOException {
	in.defaultReadObject();
	deserializedLifeListener = this;
	}
	}
	}