/**
* Copyright (C) 2001-2004 France Telecom R&D
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.objectweb.speedo.runtime.basic;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import javax.jdo.JDOException;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.JDOHelper;
import javax.jdo.listener.AttachLifecycleListener;
import javax.jdo.listener.ClearLifecycleListener;
import javax.jdo.listener.CreateLifecycleListener;
import javax.jdo.listener.DeleteLifecycleListener;
import javax.jdo.listener.DetachLifecycleListener;
import javax.jdo.listener.DirtyLifecycleListener;
import javax.jdo.listener.InstanceLifecycleEvent;
import javax.jdo.listener.InstanceLifecycleListener;
import javax.jdo.listener.LoadLifecycleListener;
import javax.jdo.listener.StoreLifecycleListener;
import javax.jdo.spi.JDOImplHelper;
import junit.framework.Assert;
import org.objectweb.speedo.SpeedoTestHelper;
import org.objectweb.speedo.api.ExceptionHelper;
import org.objectweb.speedo.pobjects.basic.BasicA;
import org.objectweb.speedo.pobjects.basic.BasicType;
import org.objectweb.speedo.pobjects.basic.Product;
import org.objectweb.util.monolog.api.BasicLevel;
/**
*
* @author S.Chassande-Barrioz
*/
public class TestBasicA extends SpeedoTestHelper {
public TestBasicA(String s) {
super(s);
}
protected String getLoggerName() {
return LOG_NAME + ".rt.basic.TestBasicA";
}
public void testgetPMF() {
assertTrue("Not the same PMF",
pmf == JDOHelper.getPersistenceManagerFactory(getPMFProperties()));
}
public void testCreateInTxAndRemoveInTx2PM() {
logger.log(BasicLevel.DEBUG, "testCreateInTxAndRemoveInTx2PM");
BasicA ba = new BasicA();
ba.writeF1("testCreateInTxAndRemoveInTx2PM");
ba.writeF2(2);
Locale l = new Locale("en"); //Examples: "en", "de_DE", "_GB", "en_US_WIN", "de__POSIX", "fr__MAC"
ba.setLocale(l);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
Object id = pm.getObjectId(ba);
Assert.assertNotNull("Null object identifier", id);
assertEquals(BasicA.CALLBACK_INIT, ba.getCheckJdoStore());
assertEquals(BasicA.CALLBACK_INIT, ba.getCheckJdoLoad());
assertEquals(BasicA.CALLBACK_INIT, ba.getCheckJdoClear());
assertEquals(BasicA.CALLBACK_INIT, ba.getCheckJdoDelete());
assertEquals("Bad locale language value", l.getLanguage(), ba.getLocale().getLanguage());
assertEquals("Bad locale country value", l.getCountry(), ba.getLocale().getCountry());
assertEquals("Bad locale variant value", l.getVariant(), ba.getLocale().getVariant());
pm.currentTransaction().commit();
assertEquals(BasicA.CALLBACK_INIT + 1, ba.getCheckJdoStore());
pm.close();
ba = null;
pm = pmf.getPersistenceManager();
pmf.getDataStoreCache().evictAll();
pm.currentTransaction().begin();
ba = (BasicA) pm.getObjectById(id, true);
Assert.assertNotNull("Object not found", ba);
Assert.assertEquals("Bad f1 value", "testCreateInTxAndRemoveInTx2PM", ba.readF1());
Assert.assertEquals("Bad f1 value", 2, ba.readF2());
assertEquals("Bad locale language value", l.getLanguage(), ba.getLocale().getLanguage());
assertEquals("Bad locale country value", l.getCountry(), ba.getLocale().getCountry());
assertEquals("Bad locale variant value", l.getVariant(), ba.getLocale().getVariant());
//assertEquals(BasicA.CALLBACK_INIT + 1, ba.getCheckJdoClear());
assertEquals(BasicA.CALLBACK_INIT, ba.getCheckJdoDelete());
pm.deletePersistent(ba);
assertEquals(BasicA.CALLBACK_INIT + 1, ba.getCheckJdoDelete());
pm.currentTransaction().commit();
try {
Object o = pm.getObjectById(id, true);
if (o != null)
fail("Removed object always availlable: " + o);
} catch (JDOUserException e) {
//OK
} catch (Exception e) {
e.printStackTrace();
fail("Bad exception thrown when an object does not exist: " + e);
}
pm.close();
}
public void testCreateAndRemoveInTx2PM() {
logger.log(BasicLevel.DEBUG, "testCreateAndRemoveInTx2PM");
BasicA ba = new BasicA();
ba.writeF1("testCreateAndRemoveInTx2PM");
ba.writeF2(2);
Locale l = new Locale("de", "de"); //Examples: "en", "de_DE", "_GB", "en_US_WIN", "de__POSIX", "fr__MAC"
ba.setLocale(l);
PersistenceManager pm = pmf.getPersistenceManager();
pm.makePersistent(ba);
Object id = pm.getObjectId(ba);
Assert.assertNotNull("Null object identifier", id);
pm.close();
ba = null;
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
ba = (BasicA) pm.getObjectById(id, true);
Assert.assertNotNull("Object not found", ba);
Assert.assertEquals("Bad f1 value", "testCreateAndRemoveInTx2PM", ba.readF1());
Assert.assertEquals("Bad f1 value", 2, ba.readF2());
assertEquals("Bad locale language value", l.getLanguage(), ba.getLocale().getLanguage());
assertEquals("Bad locale country value", l.getCountry(), ba.getLocale().getCountry());
assertEquals("Bad locale variant value", l.getVariant(), ba.getLocale().getVariant());
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testCreateAndRemoveInTx1PM() {
logger.log(BasicLevel.DEBUG, "testCreateAndRemoveInTx1PM");
BasicA ba = new BasicA();
ba.writeF1("testCreateAndRemoveInTx1PM");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.makePersistent(ba);
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testCreateAndRemoveInSameTx1PM() {
logger.log(BasicLevel.DEBUG, "testCreateAndRemoveInSameTx1PM");
BasicA ba = new BasicA();
ba.writeF1("testCreateAndRemoveInSameTx1PM");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
ba.writeF2(3);
pm.deletePersistent(ba);
try {
pm.currentTransaction().commit();
} catch (JDOException e) {
logger.log(BasicLevel.ERROR, "testCreateAndRemoveInSameTx1PM", ExceptionHelper.getNested(e));
fail("Jorm does not support export following by an unexport");
}
pm.close();
}
public void testCreateInTxAndRemoveInTx1PM() {
logger.log(BasicLevel.DEBUG, "testCreateInTxAndRemove1PM");
BasicA ba = new BasicA();
ba.writeF1("testCreateInTxAndRemove1PM");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
try {
pm.close();
} catch (JDOException e) {
logger.log(BasicLevel.ERROR, "testCreateInTxAndRemove1PM", ExceptionHelper.getNested(e));
fail("Speedo does not support the use of a PM after a transaction commit");
}
}
public void testTransientAfterTx() {
logger.log(BasicLevel.DEBUG, "testTransientAfterTx");
BasicA ba = new BasicA();
ba.writeF1("testTransient");
ba.writeF2(2);
Locale l = new Locale("GB"); //Examples: "en", "de_DE", "_GB", "en_US_WIN", "de__POSIX", "fr__MAC"
ba.setLocale(l);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
Object oid = pm.getObjectId(ba);
try {
pm.makeTransient(ba);
pm.close();
Assert.assertEquals("Bad f1 value", "testTransient", ba.readF1());
assertEquals("Bad locale language value", l.getLanguage(), ba.getLocale().getLanguage());
assertEquals("Bad locale country value", l.getCountry(), ba.getLocale().getCountry());
assertEquals("Bad locale variant value", l.getVariant(), ba.getLocale().getVariant());
ba = null;
} catch (JDOException e) {
logger.log(BasicLevel.ERROR, "testTransient", ExceptionHelper.getNested(e));
fail("Speedo does not support the makeTransient operation after a Tx");
} finally {
pm = pmf.getPersistenceManager();
ba = (BasicA) pm.getObjectById(oid, false);
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
}
public void testTransientNoTx() {
logger.log(BasicLevel.DEBUG, "testTransientNoTx");
BasicA ba = new BasicA();
ba.writeF1("testTransient");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
Object oid = pm.getObjectId(ba);
pm.close();
ba = null;
pm = pmf.getPersistenceManager();
try {
ba = (BasicA) pm.getObjectById(oid, false);
pm.makeTransient(ba);
pm.close();
Assert.assertEquals("Bad f1 value", "testTransient", ba.readF1());
ba = null;
} catch (JDOException e) {
logger.log(BasicLevel.ERROR, "testTransientNoTx", ExceptionHelper.getNested(e));
fail("Speedo does not support the makeTransient operation (notx)");
} finally {
pm = pmf.getPersistenceManager();
ba = (BasicA) pm.getObjectById(oid, false);
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
}
public void testImbricatedPM() {
logger.log(BasicLevel.DEBUG, "testImbricatedPM");
BasicA ba = new BasicA();
ba.writeF1("testImbricatedPM");
ba.writeF2(2);
PersistenceManager pm1 = pmf.getPersistenceManager();
PersistenceManager pm2 = pmf.getPersistenceManager();
Assert.assertTrue("Same persistence manager", pm1!=pm2);
pm2.makePersistent(ba);
pm2.close();
//touch the pm
pm1.getUserObject();
ba.readF1();
ba.readF2();
pm1.currentTransaction().begin();
pm1.deletePersistent(ba);
pm1.currentTransaction().commit();
try {
pm1.close();
} catch (JDOException e) {
logger.log(BasicLevel.ERROR, "testImbricatedPM", ExceptionHelper.getNested(e));
fail("Speedo does not support the use of a PM after a transaction commit");
}
}
public void testRollBackTxSamePM() {
logger.log(BasicLevel.DEBUG, "testRollBackTxSamePM");
BasicA ba = new BasicA();
ba.writeF1("testRollBack1");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
ba.writeF2(3);
Assert.assertEquals("Bad f2 value before roolback", 3, ba.readF2());
pm.currentTransaction().rollback();
Assert.assertEquals("Bad f2 value after roolback", 2, ba.readF2());
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testRollBack2() {
logger.log(BasicLevel.DEBUG, "testRollBack2");
BasicA ba = new BasicA();
ba.writeF1("testRollBack1");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
ba.writeF2(3);
Assert.assertEquals("Bad f2 value before roolback", 3, ba.readF2());
pm.currentTransaction().rollback();
Assert.assertEquals("Bad f2 value after roolback", 2, ba.readF2());
ba.writeF2(4);
Assert.assertEquals("Bad f2 value after roolback", 4, ba.readF2());
pm.close();
pm = pmf.getPersistenceManager();
Assert.assertEquals("Bad f2 value after roolback", 4, ba.readF2());
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testBasicType(long longval) {
logger.log(BasicLevel.DEBUG, "testBasicType" + longval);
BasicType bt = new BasicType();
bt.assign(longval);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(bt);
Object oid = pm.getObjectId(bt);
pm.currentTransaction().commit();
bt = null;
pmf.getDataStoreCache().evictAll();
pm.currentTransaction().begin();
bt = (BasicType) pm.getObjectById(oid, false);
Assert.assertNotNull("bt is null", bt);
bt.check(longval);
pm.deletePersistent(bt);
pm.currentTransaction().commit();
pm.close();
}
public void testBasicType35() {
testBasicType(35);
}
public void _testBasicType0() {
testBasicType(0);
}
public void testSerialization() {
logger.log(BasicLevel.DEBUG, "testSerialization");
BasicA ba = new BasicA();
ba.writeF1("testSerialization");
ba.writeF2(5);
Locale l = new Locale("en"); //Examples: "en", "de_DE", "_GB", "en_US_WIN", "de__POSIX", "fr__MAC"
ba.setLocale(l);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
Object oid = pm.getObjectId(ba);
pm.currentTransaction().commit();
pm.close();
File f = new File(new File(new File("output"),"test"), "testSerialization");
if (f.exists()) {
f.delete();
}
try {
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(f));
oos.writeObject(ba);
oos.close();
ba = null;
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream(f));
ba = (BasicA) ois.readObject();
ois.close();
ba.readF1_F2();
assertEquals("Bad locale language value", l.getLanguage(), ba.getLocale().getLanguage());
assertEquals("Bad locale country value", l.getCountry(), ba.getLocale().getCountry());
assertEquals("Bad locale variant value", l.getVariant(), ba.getLocale().getVariant());
} catch (Exception e) {
logger.log(BasicLevel.ERROR, "testSerialization fails: ", e);
fail(e.getMessage());
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(pm.getObjectById(oid, false));
pm.currentTransaction().commit();
pm.close();
}
}
public void testStaticFinder() {
logger.log(BasicLevel.DEBUG, "testStaticFinder");
ArrayList oids = new ArrayList();
PersistenceManager pm = pmf.getPersistenceManager();
for(int i =0; i<50; i++) {
BasicA ba = new BasicA();
ba.writeF1("testStaticFinder" + i);
ba.writeF2(i);
pm.makePersistent(ba);
oids.add(pm.getObjectId(ba));
}
pm.close();
try {
List l = BasicA.getAllBasicAId(pmf);
assertSameCollection("bad query result", oids, l);
} finally {
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
for (Iterator it = oids.iterator(); it.hasNext();) {
pm.deletePersistent(pm.getObjectById(it.next(), false));
}
pm.currentTransaction().commit();
pm.close();
}
}
public void testNonNullField() {
logger.log(BasicLevel.DEBUG, "testNonNullField");
BasicA ba = new BasicA();
ba.writeF1("testNonNullField");
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
ba.setNonullField(null);
try {
pm.currentTransaction().commit();
fail("no exception thrown when a null value try to be store for a persistent field marked as non null");
} catch (JDOUserException e) {
} catch (Exception e) {
logger.log(BasicLevel.ERROR, "Bad expected exception", e);
fail("Bad exception thrown when a null value try to be store for a persistent field marked as non null: " + e.getClass());
} finally {
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
}
public void testRefresh() {
logger.log(BasicLevel.DEBUG, "testRefresh");
BasicA ba = new BasicA();
ba.writeF1("testRefresh");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pm.refresh(ba);
int f2 = ba.readF2();
assertTrue("bad F2 value:" + f2, f2 < 4);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testRefreshDirty() {
logger.log(BasicLevel.DEBUG, "testRefreshDirty");
BasicA ba = new BasicA();
ba.writeF1("testRefreshDirty");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
ba.writeF2(4);
pm.refresh(ba);
int f2 = ba.readF2();
assertTrue("bad F2 value:" + f2, f2 < 4);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testPONEICompatible() {
logger.log(BasicLevel.DEBUG, "testPONEICompatible");
final String[] FIELD_NAMES = new String[]{
"locale",
"d",
"f2",
"privateField",
"protectedField",
"f1",
"myArrayOfchar",
"noModifierField",
"undeclaredField",
"l",
"d2",
"nonullField"
};
final Class[] FIELD_TYPES = new Class[]{
java.util.Locale.class,
java.util.Date.class,
Integer.TYPE,
Integer.TYPE,
Integer.TYPE,
java.lang.String.class,
char[].class,
Integer.TYPE,
java.lang.String.class,
Long.TYPE,
java.util.Date.class,
java.lang.String.class
};
assertTrue("Class not registered: ",
JDOImplHelper.getInstance().getRegisteredClasses().contains(BasicA.class));
final String[] fns = JDOImplHelper.getInstance().getFieldNames(BasicA.class);
assertNotNull("Null array of field names", fns);
assertEquals("Bad length of the array of field names", FIELD_NAMES.length, fns.length);
final Class[] fts = JDOImplHelper.getInstance().getFieldTypes(BasicA.class);
assertNotNull("Null array of field types", fts);
assertEquals("Bad length of the array of field types", FIELD_TYPES.length, fts.length);
final HashMap expected = new HashMap();
final HashMap found = new HashMap();
for(int i=0; i<FIELD_NAMES.length; i++) {
expected.put(FIELD_NAMES[i], FIELD_TYPES[i]);
found.put(fns[i], fts[i]);
}
assertEquals("Bad content", expected, found);
final Class superClass = JDOImplHelper.getInstance().getPersistenceCapableSuperclass(BasicA.class);
assertNull("Bad super class name", superClass);
BasicA ba = new BasicA();
ba.writeF1("testPONEICompatible");
ba.writeF2(23242);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
//Field access inside a transaction
pm.currentTransaction().begin();
assertEquals("Bad value on getter", new Integer(23242),
invokeStaticMethod(BasicA.class, "jdoGetf2",
new Class[]{BasicA.class},
new Object[]{ba}));
assertNull("Bad value on getter",
invokeStaticMethod(BasicA.class, "jdoSetf2",
new Class[]{BasicA.class, Integer.TYPE},
new Object[]{ba, new Integer(1)}));
assertEquals("Bad value on getter", new Integer(1),
invokeStaticMethod(BasicA.class, "jdoGetf2",
new Class[]{BasicA.class},
new Object[]{ba}));
pm.currentTransaction().commit();
//Field access outside a transaction
assertEquals("Bad value on getter", new Integer(1),
invokeStaticMethod(BasicA.class, "jdoGetf2",
new Class[]{BasicA.class},
new Object[]{ba}));
assertNull("Bad value on getter",
invokeStaticMethod(BasicA.class, "jdoSetf2",
new Class[]{BasicA.class, Integer.TYPE},
new Object[]{ba, new Integer(2)}));
assertEquals("Bad value on getter", new Integer(2),
invokeStaticMethod(BasicA.class, "jdoGetf2",
new Class[]{BasicA.class},
new Object[]{ba}));
pm.close();
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
// test delete and make an object persistent in the same transaction
public void testDeleteMakePersistent() {
long pIdentifier = 1;
PersistenceManager pm = pmf.getPersistenceManager();
try {
Product p = new Product(pIdentifier);
p.setCost("cost1");
p.setProductName("product1");
//make a product persistent
pm.currentTransaction().begin();
pm.makePersistent(p);
Object pId = pm.getObjectId(p);
Assert.assertNotNull("null object identifier", pId);
pm.currentTransaction().commit();
p = null;
p = (Product) pm.getObjectById(pId, true);
Assert.assertNotNull("null instance returned by getObjectById", p);
Assert.assertEquals("Bad product id", pIdentifier, p.getId());
//delete it
//and recreate a new one with the same id
pm.currentTransaction().begin();
pm.deletePersistent(p);
Product newP = new Product(pIdentifier);
newP.setCost("cost2");
newP.setProductName("product2");
pm.makePersistent(newP);
pm.currentTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
} finally {
if (pm.currentTransaction().isActive())
pm.currentTransaction().rollback();
pm.close();
}
pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.deletePersistent(pm.getObjectById(
pm.newObjectIdInstance(Product.class, "" + pIdentifier), false));
pm.currentTransaction().commit();
pm.close();
}
//test delete and make an object persistent in the same transaction
public void testDeleteRollback() {
logger.log(BasicLevel.DEBUG, "testDeleteRollBack");
BasicA ba = new BasicA();
ba.writeF1("testDeleteRollBack");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pm.deletePersistent(ba);
pm.currentTransaction().rollback();
pm.currentTransaction().begin();
assertTrue("The object should be persistent", JDOHelper.isPersistent(ba));
assertEquals("F2 should be 2", 2, ba.readF2());
pm.deletePersistent(ba);
pm.currentTransaction().commit();
pm.close();
}
public void testDeleteAndUse() {
logger.log(BasicLevel.DEBUG, "testRefreshDirty");
BasicA ba = new BasicA();
ba.writeF1("testRefreshDirty");
ba.writeF2(2);
PersistenceManager pm = pmf.getPersistenceManager();
pm.currentTransaction().begin();
pm.makePersistent(ba);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
pm.deletePersistent(ba);
assertEquals("bad F2 value after delete:", 2, ba.readF2());
ba.writeF2(3);
assertEquals("bad F2 value after delete and set:", 3, ba.readF2());
pm.currentTransaction().commit();
assertEquals("bad F2 value after commit:", 3, ba.readF2());
ba.writeF2(4);
assertEquals("bad F2 value after commit and set:", 4, ba.readF2());
pm.close();
assertEquals("bad F2 value after close:", 4, ba.readF2());
ba.writeF2(5);
assertEquals("bad F2 value after close and set:", 5, ba.readF2());
}
public void testInstanceLifecycleListener() {
final int PRE = 0;
final int POST = 1;
final InstanceLifecycleEvent[][] marks = new InstanceLifecycleEvent[8][2];
final int[] nbEvent = new int[1];
nbEvent[0] = 0;
InstanceLifecycleListener[] listeners = new InstanceLifecycleListener[8];
listeners[InstanceLifecycleEvent.ATTACH] = new AttachLifecycleListener() {
public void preAttach(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.ATTACH][PRE] = ev;
nbEvent[0] ++;
}
public void postAttach(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.ATTACH][POST] = ev;
nbEvent[0] ++;
}
};
listeners[InstanceLifecycleEvent.DETACH] = new DetachLifecycleListener() {
public void preDetach(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.DETACH][PRE] = ev;
nbEvent[0] ++;
}
public void postDetach(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.DETACH][POST] = ev;
nbEvent[0] ++;
}
};
listeners[InstanceLifecycleEvent.CREATE] = new CreateLifecycleListener() {
public void postCreate(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.CREATE][POST] = ev;
nbEvent[0] ++;
}
};
listeners[InstanceLifecycleEvent.DELETE] = new DeleteLifecycleListener() {
public void preDelete(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.DELETE][PRE] = ev;
nbEvent[0] ++;
}
public void postDelete(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.DELETE][POST] = ev;
nbEvent[0] ++;
}
};
listeners[InstanceLifecycleEvent.LOAD] = new LoadLifecycleListener() {
public void preLoad(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.LOAD][PRE] = ev;
nbEvent[0] ++;
}
public void postLoad(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.LOAD][POST] = ev;
nbEvent[0] ++;
}
};
listeners[InstanceLifecycleEvent.STORE] = new StoreLifecycleListener() {
public void preStore(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.STORE][PRE] = ev;
nbEvent[0] ++;
}
public void postStore(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.STORE][POST] = ev;
nbEvent[0] ++;
}
};
listeners[InstanceLifecycleEvent.DIRTY] = new DirtyLifecycleListener() {
public void preDirty(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.DIRTY][PRE] = ev;
nbEvent[0] ++;
}
public void postDirty(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.DIRTY][POST] = ev;
nbEvent[0] ++;
}
};
listeners[InstanceLifecycleEvent.CLEAR] = new ClearLifecycleListener() {
public void preClear(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.CLEAR][PRE] = ev;
nbEvent[0] ++;
}
public void postClear(InstanceLifecycleEvent ev) {
marks[InstanceLifecycleEvent.CLEAR][POST] = ev;
nbEvent[0] ++;
}
};
PersistenceManager pm = pmf.getPersistenceManager();
for (int i = 0; i < listeners.length; i++) {
pmf.addInstanceLifecycleListener(listeners[i], new Class[]{BasicA.class});
}
BasicA ba = new BasicA();
assertEquals("unexpect event on create ", 0, nbEvent[0]);
ba.writeF1("testInstanceLifecycleListener_1");
assertEquals("unexpect event on write ", 0, nbEvent[0]);
pm.currentTransaction().begin();
pm.makePersistent(ba);
assertEquals("Bad event number on make persistent: ", 1, nbEvent[0]);
ba.writeF1("testInstanceLifecycleListener_1");
assertEquals("Bad event number on make persistent after write: ", 3, nbEvent[0]);
assertNotNull("Not postCreate event", marks[InstanceLifecycleEvent.CREATE][POST]);
assertTrue("Bad source ", marks[InstanceLifecycleEvent.CREATE][POST].getSource() == ba);
clear(nbEvent, marks);
pm.currentTransaction().commit();
pm.currentTransaction().begin();
assertTrue("Bad event number on commit: " + nbEvent[0], 2 == nbEvent[0] | 3 ==nbEvent[0]);
assertNotNull("Not preStore event", marks[InstanceLifecycleEvent.STORE][PRE]);
assertTrue("Bad source on preStore", marks[InstanceLifecycleEvent.STORE][PRE].getSource() == ba);
assertNotNull("Not postStore event", marks[InstanceLifecycleEvent.STORE][POST]);
assertTrue("Bad source on postStore", marks[InstanceLifecycleEvent.STORE][POST].getSource() == ba);
pm.currentTransaction().commit();
pm.evict(ba);
pm.currentTransaction().begin();
clear(nbEvent, marks);
assertEquals("Bad f1 value" , "testInstanceLifecycleListener_1", ba.readF1());
assertTrue("Bad event number on load: ", 2 == nbEvent[0] || 1 == nbEvent[0]);
assertNotNull("Not postStore event", marks[InstanceLifecycleEvent.LOAD][POST]);
assertTrue("Bad source on postStore", marks[InstanceLifecycleEvent.LOAD][POST].getSource() == ba);
/*
nbEvent[0] = 0;
ba.writeF1("testInstanceLifecycleListener_2");
assertEquals("Bad event number on write: ", 2, nbEvent[0]);
assertNotNull("Not preStore event", marks[InstanceLifecycleEvent.DIRTY][PRE]);
assertTrue("Bad source on preStore", marks[InstanceLifecycleEvent.DIRTY][PRE].getSource() == ba);
assertNotNull("Not postStore event", marks[InstanceLifecycleEvent.DIRTY][POST]);
assertTrue("Bad source on postStore", marks[InstanceLifecycleEvent.DIRTY][POST].getSource() == ba);
*/
pm.currentTransaction().rollback();
pm.currentTransaction().begin();
clear(nbEvent, marks);
pm.deletePersistent(ba);
assertTrue("Bad event number on delete persistent: " + nbEvent[0], 2 == nbEvent[0] || 3 == nbEvent[0]);
assertNotNull("Not preStore event", marks[InstanceLifecycleEvent.DELETE][PRE]);
assertTrue("Bad source on preStore", marks[InstanceLifecycleEvent.DELETE][PRE].getSource() == ba);
assertNotNull("Not postStore event", marks[InstanceLifecycleEvent.DELETE][POST]);
assertTrue("Bad source on postStore", marks[InstanceLifecycleEvent.DELETE][POST].getSource() == ba);
pm.currentTransaction().commit();
pm.close();
for (int i = 0; i < listeners.length; i++) {
pmf.removeInstanceLifecycleListener(listeners[i]);
}
}
private void clear(int[] nbEvent, Object[][] marks) {
nbEvent[0] = 0;
for(int i=0; i<8; i++) {
marks[i][0] = null;
marks[i][1] = null;
}
}
private Object invokeStaticMethod(Class clazz,
String methodName,
Class[] paramTypes,
Object[] paramValues) {
try {
Method m = clazz.getMethod(methodName, paramTypes);
return m.invoke(null, paramValues);
} catch (Exception e) {
logger.log(BasicLevel.ERROR, "Exception during invocation:", e);
fail(e.getMessage());
return null;
}
}
}