/* | |
* 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.persistence.kernel; | |
import org.apache.openjpa.persistence.kernel.common.apps.ModRuntimeTest1; | |
import org.apache.openjpa.persistence.kernel.common.apps.ModRuntimeTest2; | |
import org.apache.openjpa.persistence.kernel.common.apps.PersistenceAware; | |
import org.apache.openjpa.enhance.PersistenceCapable; | |
import org.apache.openjpa.persistence.OpenJPAEntityManager; | |
import org.apache.openjpa.persistence.OpenJPAPersistence; | |
import org.apache.openjpa.persistence.RestoreStateType; | |
public class TestTransition2 extends BaseKernelTest { | |
private boolean supportsPessimistic = true; | |
private int _id = 0; | |
/** | |
* Creates a new instance of TestTransitions | |
*/ | |
public TestTransition2() { | |
} | |
public TestTransition2(String name) { | |
super(name); | |
} | |
public void setUp() throws Exception { | |
try { | |
OpenJPAEntityManager pm = getPM(false, false); | |
supportsPessimistic = !pm.getOptimistic(); | |
pm.close(); | |
} | |
catch (Exception e) { | |
supportsPessimistic = false; | |
} | |
OpenJPAEntityManager pm = getPM(); | |
startTx(pm); | |
ModRuntimeTest2 b = createTest2(); | |
pm.persist(b); | |
_id = b.getId(); | |
endTx(pm); | |
endEm(pm); | |
} | |
/** | |
* Tests basic jdo flag transitions from transient to | |
* persistent-transactional and back to transient after rollback. | |
*/ | |
public void testFlagTransitions1() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
assertTransient(b); | |
assertTransient(b.getSelfOneOne()); | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
pm.persist(b); | |
assertPersistent(b, true, true, false, true); | |
rollbackTx(pm); | |
assertTransient(b); | |
assertTransient(b.getSelfOneOne()); | |
endEm(pm); | |
} | |
/** | |
* Tests basic jdo flag transitions from transient to | |
* persistent-transactional to persistent-nontransactional after commit. | |
*/ | |
public void testFlagTransitions2() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
assertTransient(b); | |
assertTransient(b.getSelfOneOne()); | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
pm.persist(b); | |
assertPersistent(b, true, true, false, true); | |
endTx(pm); | |
assertPersistent(b, false, false, false, false); | |
assertPersistent(b.getSelfOneOne(), false, false, false, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic jdo flag transitions when finding a transactional instance by | |
* id, then committing. | |
*/ | |
public void testFlagTransitions3() throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertPersistent(b, true, false, false, false); | |
assertPersistent(b.getSelfOneOne(), true, false, false, false); | |
endTx(pm); | |
assertPersistent(b, false, false, false, false); | |
assertPersistent(b.getSelfOneOne(), false, false, false, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic jdo flag transitions when finding a transactional | |
* instance by id, then rolling back. | |
*/ | |
public void testFlagTransitions4() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertPersistent(b, true, false, false, false); | |
assertPersistent(b.getSelfOneOne(), true, false, false, false); | |
rollbackTx(pm); | |
//pm.getTransaction().rollback(); | |
assertPersistent(b, false, false, false, false); | |
assertPersistent(b.getSelfOneOne(), false, false, false, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic jdo flag transitions when finding a non-transactional | |
* instance by id. | |
*/ | |
public void testFlagTransitions5() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertPersistent(b, false, false, false, false); | |
assertPersistent(b.getSelfOneOne(), false, false, false, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic jdo flag transitions from persistent-transactional | |
* to transient after delete and commit. | |
*/ | |
public void testFlagTransitions6() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
ModRuntimeTest1 parent = b.getSelfOneOne(); | |
pm.remove(b); | |
assertPersistent(b, true, false, true, true); | |
assertPersistent(parent, true, false, false, false); | |
endTx(pm); | |
assertTransient(b); | |
assertPersistent(parent, false, false, false, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic jdo flag transitions from persistent-transactional | |
* to persistent-nontransactional after delete and rollback. | |
*/ | |
public void testFlagTransitions7() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
ModRuntimeTest1 parent = b.getSelfOneOne(); | |
pm.remove(b); | |
assertPersistent(b, true, false, true, true); | |
assertPersistent(parent, true, false, false, false); | |
rollbackTx(pm); | |
assertPersistent(b, false, false, false, false); | |
assertPersistent(parent, false, false, false, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional and back to transient after rollback. | |
*/ | |
public void testStateTransitions1() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
pm.persist(b); | |
pm.persist(b.getSelfOneOne()); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional to persistent-nontransactional after commit. | |
*/ | |
public void testStateTransitions2() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
pm.persist(b); | |
assertTest2Orig(b); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then committing. | |
*/ | |
public void testStateTransitions3() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then committing. | |
*/ | |
public void testStateTransitions3a() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then rolling back. | |
*/ | |
public void testStateTransitions4() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then rolling back. | |
*/ | |
public void testStateTransitions4a() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to transient after delete and commit. | |
*/ | |
public void testStateTransitions5() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
ModRuntimeTest1 parent = b.getSelfOneOne(); | |
assertNotNull("parent is null", parent); | |
pm.remove(b); | |
endTx(pm); | |
// parent should be valid | |
assertEquals("PARENT", parent.getStringField()); | |
// 'b' should be cleared | |
assertNull(b.getStringField()); | |
assertEquals(0, b.getIntField()); | |
assertNull(b.getSelfOneOne()); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to persistent-nontransactional after delete and rollback. | |
*/ | |
public void testStateTransitions6() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
pm.remove(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional and back to transient after rollback. | |
*/ | |
public void testOptStateTransitions1() | |
throws Exception { | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(true, false); | |
startTx(pm); | |
pm.persist(b); | |
pm.persist(b.getSelfOneOne()); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional to persistent-nontransactional after commit. | |
*/ | |
public void testOptStateTransitions2() | |
throws Exception { | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(true, false); | |
startTx(pm); | |
pm.persist(b); | |
assertTest2Orig(b); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then committing. | |
*/ | |
public void testOptStateTransitions3() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, false); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then rolling back. | |
*/ | |
public void testOptStateTransitions4() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to transient after delete and commit. | |
*/ | |
public void testOptStateTransitions5() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
ModRuntimeTest1 parent = b.getSelfOneOne(); | |
assertNotNull("parent is null", parent); | |
pm.remove(b); | |
endTx(pm); | |
// parent should be valid | |
assertEquals("PARENT", parent.getStringField()); | |
// 'b' should be cleared | |
assertNull(b.getStringField()); | |
assertEquals(0, b.getIntField()); | |
assertNull(b.getSelfOneOne()); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to persistent-nontransactional after delete and rollback. | |
*/ | |
public void testOptStateTransitions6() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, false); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
pm.remove(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional and back to transient after rollback. | |
*/ | |
public void testOptRetainStateTransitions1() | |
throws Exception { | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(true, true); | |
startTx(pm); | |
pm.persist(b); | |
pm.persist(b.getSelfOneOne()); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional to persistent-nontransactional after commit. | |
*/ | |
public void testOptRetainStateTransitions2() | |
throws Exception { | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(true, true); | |
startTx(pm); | |
pm.persist(b); | |
assertTest2Orig(b); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, true); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then committing. | |
*/ | |
public void testOptRetainStateTransitions3() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, true); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, true); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then rolling back. | |
*/ | |
public void testOptRetainStateTransitions4() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, true); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to transient after delete and commit. | |
*/ | |
public void testOptRetainStateTransitions5() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, true); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
ModRuntimeTest1 parent = b.getSelfOneOne(); | |
assertNotNull("parent is null", parent); | |
pm.remove(b); | |
endTx(pm); | |
// parent should be valid | |
assertEquals("PARENT", parent.getStringField()); | |
// 'b' should be cleared | |
assertNull(b.getStringField()); | |
assertEquals(0, b.getIntField()); | |
assertNull(b.getSelfOneOne()); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to persistent-nontransactional after delete and rollback. | |
*/ | |
public void testOptRetainStateTransitions6() | |
throws Exception { | |
OpenJPAEntityManager pm = getPM(true, true); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
pm.remove(b); | |
rollbackTx(pm); | |
if (pm.getRestoreState() != RestoreStateType.NONE) | |
assertTest2Orig(b); | |
else | |
assertNull(b.getStringField()); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional and back to transient after rollback. | |
*/ | |
public void testRetainStateTransitions1() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(false, true); | |
startTx(pm); | |
pm.persist(b); | |
pm.persist(b.getSelfOneOne()); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* persistent-transactional to persistent-nontransactional after commit. | |
*/ | |
public void testRetainStateTransitions2() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(false, true); | |
startTx(pm); | |
pm.persist(b); | |
assertTest2Orig(b); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, true); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then committing. | |
*/ | |
public void testRetainStateTransitions3() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, true); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, true); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions when finding a transactional | |
* instance by id, then rolling back. | |
*/ | |
public void testRetainStateTransitions4() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, true); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
assertTest2Orig(b); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to transient after delete and commit. | |
*/ | |
public void testRetainStateTransitions5() throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, true); | |
startTx(pm); | |
ModRuntimeTest2 b = (ModRuntimeTest2) pm.find(ModRuntimeTest2.class, | |
_id); | |
ModRuntimeTest1 parent = b.getSelfOneOne(); | |
assertNotNull("parent is null", parent); | |
pm.remove(b); | |
endTx(pm); | |
// parent should be valid | |
assertEquals("PARENT", parent.getStringField()); | |
// 'b' should be cleared | |
assertNull(b.getStringField()); | |
assertEquals(0, b.getIntField()); | |
assertNull(b.getSelfOneOne()); | |
} | |
/** | |
* Tests basic state transitions from persistent-transactional | |
* to persistent-nontransactional after delete and rollback. | |
*/ | |
public void testRetainStateTransitions6() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
OpenJPAEntityManager pm = getPM(false, true); | |
startTx(pm); | |
ModRuntimeTest2 b = | |
(ModRuntimeTest2) pm.find(ModRuntimeTest2.class, _id); | |
pm.remove(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* transient-dirty and back to transient after rollback. | |
*/ | |
public void testTransientStateTransitions1() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
pm.transactional(b, true); | |
pm.transactional(b.getSelfOneOne(), true); | |
changeTest2(b); | |
rollbackTx(pm); | |
assertTest2Orig(b); | |
endEm(pm); | |
} | |
/** | |
* Tests basic state transitions from transient to | |
* transient-transactional and stick on commit. | |
*/ | |
public void testTransientStateTransitions2() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
pm.transactional(b, true); | |
pm.transactional(b.getSelfOneOne(), true); | |
changeTest2(b); | |
endTx(pm); | |
assertTest2Changed(b, false); | |
endEm(pm); | |
} | |
/** | |
* Tests state transitions from PClean to transient. | |
*/ | |
public void testTransientStateTransitions3() | |
throws Exception { | |
if (!supportsPessimistic) | |
return; | |
ModRuntimeTest2 b = createTest2(); | |
OpenJPAEntityManager pm = getPM(false, false); | |
startTx(pm); | |
pm.persist(b); | |
int oid = b.getId(); | |
endTx(pm); | |
endEm(pm); | |
pm = getPM(false, false); | |
//FIXME jthomas | |
b = (ModRuntimeTest2) pm.find(ModRuntimeTest2.class, oid); | |
pm.retrieve(b); | |
//FIXME jthomas | |
endEm(pm); | |
// note that at this point, parent is not transient, just retrieved. | |
assertNotNull("b is null", b.getSelfOneOne()); | |
} | |
private ModRuntimeTest2 createTest2() { | |
return createTest2("NAME", 50); | |
} | |
private ModRuntimeTest2 createTest2(String str, int i) { | |
return createTest2(new ModRuntimeTest2(str, i)); | |
} | |
private ModRuntimeTest2 createTest2(ModRuntimeTest2 b) { | |
ModRuntimeTest1 parent = new ModRuntimeTest1("PARENT", 70); | |
b.setSelfOneOne(parent); | |
return b; | |
} | |
private void changeTest2(ModRuntimeTest2 b) { | |
PersistenceAware.setModTransString(b, "999"); | |
b.setStringField("CHANGED"); | |
b.setIntField(1000); | |
b.getSelfOneOne().setStringField("PCHANGED"); | |
b.setSelfOneOne(null); | |
} | |
private void assertTest2Changed(ModRuntimeTest2 b, boolean retainValues) { | |
if (retainValues) | |
assertEquals("999", PersistenceAware.getModTransString(b)); | |
assertEquals("CHANGED", b.getStringField()); | |
assertEquals(1000, b.getIntField()); | |
assertNull(b.getSelfOneOne()); | |
} | |
private void assertTest2Orig(ModRuntimeTest2 b) { | |
assertEquals("NAME", b.getStringField()); | |
assertEquals(50, b.getIntField()); | |
assertNotNull(b.getSelfOneOne()); | |
assertEquals("PARENT", b.getSelfOneOne().getStringField()); | |
assertEquals( | |
"transactional field 'transString' was not the " | |
+ "same as it was originally. Ensure that " | |
+ "openjpa.kernel.PersistenceAware is enhanced. " | |
+ | |
"It is persistence-aware, so will not be enhanced by commands " | |
+ "like jdoc $(find test -name '*.jdo').", null, | |
PersistenceAware.getModTransString(b)); | |
} | |
/** | |
* Assert that the given object is persistent. | |
*/ | |
public void assertTransient(Object a) { | |
OpenJPAEntityManager pm = currentEntityManager(); | |
assertTrue(!pm.isPersistent(a)); | |
assertTrue(!pm.isTransactional(a)); | |
assertTrue(!pm.isNewlyPersistent(a)); | |
assertTrue(!pm.isDirty(a)); | |
assertTrue(!pm.isRemoved(a)); | |
assertNull(pm.getObjectId(a)); | |
assertNull(OpenJPAPersistence.getEntityManager(a)); | |
endEm(pm); | |
} | |
/** | |
* Assert that the given object is persistent and is in the given state. | |
*/ | |
public void assertPersistent(Object a, boolean isTrans, boolean isNew, | |
boolean isDeleted, boolean isDirty) { | |
OpenJPAEntityManager pm = | |
(OpenJPAEntityManager) currentEntityManager(); | |
assertTrue(pm.isPersistent(a)); | |
PersistenceCapable xman = (PersistenceCapable) a; | |
assertEquals(isTrans, pm.isTransactional(a)); | |
assertEquals(isNew, pm.isNewlyPersistent(a)); | |
assertEquals(isDeleted, pm.isRemoved(a)); | |
assertEquals(isDirty || isNew || isDeleted, pm.isDirty(a)); | |
assertNotNull(pm.getObjectId(a)); | |
assertNotNull(OpenJPAPersistence.getEntityManager(a)); | |
endEm(pm); | |
} | |
} |