summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorChristian Campo2008-02-29 06:34:15 (EST)
committerChristian Campo2008-02-29 06:34:15 (EST)
commit177263cae4c132f2b8344cbd437a2fb4735cb8ca (patch)
treeab02b93465a902ac6b123ad4a5f9b38e5a62fb77
parent0ee9a2391dd730242573b0be8256382f9fcba662 (diff)
downloadorg.eclipse.riena-177263cae4c132f2b8344cbd437a2fb4735cb8ca.zip
org.eclipse.riena-177263cae4c132f2b8344cbd437a2fb4735cb8ca.tar.gz
org.eclipse.riena-177263cae4c132f2b8344cbd437a2fb4735cb8ca.tar.bz2
testcases for new project objecttransaction
-rw-r--r--org.eclipse.riena.tests/META-INF/MANIFEST.MF3
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/context/ContextProxyTest.java184
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/ObjectTransactionTest.java1008
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Addresse.java115
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/GenericOID.java74
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IAddresse.java38
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IVertrag.java38
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Kunde.java187
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Vertrag.java91
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/ObjectTransactionListTest.java1023
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Addresse.java114
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/GenericOID.java74
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Kunde.java188
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Vertrag.java94
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionVariousTest.java51
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionWithoutTransactionTest.java811
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Addresse.java100
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/GenericOID.java74
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Kunde.java177
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Vertrag.java83
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionDisallowRegisterTest.java49
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionTest.java1031
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionVariousTest.java891
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/StateMachineTest.java21
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Addresse.java113
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/GenericOID.java74
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Kunde.java188
-rw-r--r--org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Vertrag.java94
28 files changed, 6987 insertions, 1 deletions
diff --git a/org.eclipse.riena.tests/META-INF/MANIFEST.MF b/org.eclipse.riena.tests/META-INF/MANIFEST.MF
index 390bcdc..53c84aa 100644
--- a/org.eclipse.riena.tests/META-INF/MANIFEST.MF
+++ b/org.eclipse.riena.tests/META-INF/MANIFEST.MF
@@ -14,7 +14,8 @@ Require-Bundle: org.eclipse.core.runtime,
org.eclipse.riena.sample.app.common,
org.eclipse.riena.communication.core,
org.eclipse.riena.security.server,
- org.eclipse.riena.exceptionmanager
+ org.eclipse.riena.exceptionmanager,
+ org.eclipse.riena.objecttransaction;bundle-version="1.0.0"
Bundle-ActivationPolicy: lazy
Eclipse-RegisterBuddy: org.eclipse.riena.security.common
Export-Package: org.eclipse.riena.security.authorizationservice,
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/context/ContextProxyTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/context/ContextProxyTest.java
new file mode 100644
index 0000000..c12d827
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/context/ContextProxyTest.java
@@ -0,0 +1,184 @@
+/****************************************************************
+ * *
+ * Copyright (c) 2004-2005 compeople AG *
+ * All rights reserved. The use of this program and the *
+ * accompanying materials are subject to license terms. *
+ * *
+ ****************************************************************/
+package org.eclipse.riena.objecttransaction.context;
+
+import junit.framework.TestCase;
+
+/**
+ * TestCase for the ContextProxy
+ * @author SST
+ */
+
+public class ContextProxyTest extends TestCase {
+
+ private IContext activatedContext;
+ private IContext passivatedContext;
+
+ /**
+ * Test the management of a context an a non context carrier
+ *
+ */
+ public void testContextManagementOnNotContextCarrier() {
+
+ IContextCarrier contextCarrier = new BasicContextCarrier( null );
+
+ IContext context1 = new ContextProxyTestContext();
+ IContext context2 = new ContextProxyTestContext();
+ assertFalse( context1.equals( context2 ) );
+
+ ContextProxyTestNonContextCarrier nonContextCarrier = new ContextProxyTestNonContextCarrier();
+
+ //test creating proxy on null and setting
+ IContextProxyTestInterface nonContextCarrierProxy = ContextProxy.cover( (IContextProxyTestInterface) nonContextCarrier, contextCarrier );
+
+ activatedContext = null;
+ passivatedContext = null;
+ assertNull( contextCarrier.getContext() );
+ contextCarrier.setContext( context1 );
+ assertNull( activatedContext );
+ assertNull( passivatedContext );
+ nonContextCarrierProxy.doSomething();
+ assertEquals( context1, activatedContext );
+ assertEquals( context1, passivatedContext );
+
+ activatedContext = null;
+ passivatedContext = null;
+ contextCarrier.setContext( context2 );
+ assertEquals( context2, contextCarrier.getContext() );
+ assertNull( activatedContext );
+ assertNull( passivatedContext );
+ nonContextCarrierProxy.doSomething();
+ assertEquals( context2, activatedContext );
+ assertEquals( context2, passivatedContext );
+
+ //test creating proxy on a context
+ activatedContext = null;
+ passivatedContext = null;
+
+ contextCarrier.setContext( context1 );
+
+ nonContextCarrierProxy = ContextProxy.cover( (IContextProxyTestInterface) nonContextCarrier, contextCarrier );
+ assertEquals( context1, contextCarrier.getContext() );
+ assertNull( activatedContext );
+ assertNull( passivatedContext );
+ nonContextCarrierProxy.doSomething();
+ assertEquals( context1, activatedContext );
+ assertEquals( context1, passivatedContext );
+
+ }
+
+ /**
+ * Test the management of the context with the contextProxy,
+ * when creating the proxy on an object implementing IContextCarrier
+ */
+ public void testContextManagementOnContextCarrier() {
+
+ IContext context1 = new ContextProxyTestContext();
+ IContext context2 = new ContextProxyTestContext();
+ assertFalse( context1.equals( context2 ) );
+
+ ContextProxyTestContextCarrier contextCarrier = new ContextProxyTestContextCarrier();
+
+ //test creating proxy on null and setting
+ IContextProxyTestInterfaceCarrier contextCarrierProxy = ContextProxy.cover( (IContextProxyTestInterfaceCarrier) contextCarrier );
+
+ activatedContext = null;
+ passivatedContext = null;
+ assertNull( contextCarrierProxy.getContext() );
+ contextCarrierProxy.setContext( context1 );
+ assertEquals( context1, contextCarrierProxy.getContext() );
+ contextCarrierProxy.setContext( context2 );
+ assertEquals( context2, contextCarrierProxy.getContext() );
+ contextCarrierProxy.doSomething();
+ assertEquals( context2, activatedContext );
+ assertEquals( context2, passivatedContext );
+
+ contextCarrierProxy.setContext( context1 );
+ contextCarrierProxy.doSomething();
+ assertEquals( context1, activatedContext );
+ assertEquals( context1, passivatedContext );
+
+ }
+
+ private interface IContextProxyTestInterface {
+ /**
+ * A dummy method
+ */
+ void doSomething();
+ }
+
+ private interface IContextProxyTestInterfaceCarrier extends IContextCarrier {
+ /**
+ * A dummy method
+ */
+ void doSomething();
+ }
+
+ private static class ContextProxyTestNonContextCarrier implements IContextProxyTestInterface {
+ /**
+ * @see de.compeople.scp.objecttransaction.context.ContextProxyTest.IContextProxyTestInterface#doSomething()
+ */
+ public void doSomething() {
+ return;
+ }
+ }
+
+ private static class ContextProxyTestContextCarrier implements IContextProxyTestInterfaceCarrier {
+
+ private IContext context;
+
+ /**
+ * @see de.compeople.scp.objecttransaction.context.ContextProxyTest.IContextProxyTestInterface#doSomething()
+ */
+ public void doSomething() {
+ return;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.context.IContextCarrier#getContext()
+ */
+ public IContext getContext() {
+ return context;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.context.IContextCarrier#setContext(de.compeople.scp.objecttransaction.context.IContext)
+ */
+ public void setContext( IContext pContext ) {
+ context = pContext;
+ }
+
+ }
+
+ private class ContextProxyTestContext implements IContext {
+
+ /**
+ * @see de.compeople.scp.objecttransaction.context.IContext#activate()
+ */
+ public void activate() {
+ activatedContext = this;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.context.IContext#isActivated()
+ */
+ public boolean isActivated() {
+ return this.equals( activatedContext );
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.context.IContext#passivate()
+ */
+ public void passivate() {
+ passivatedContext = this;
+
+ }
+
+ }
+
+}
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/ObjectTransactionTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/ObjectTransactionTest.java
new file mode 100644
index 0000000..96edc6f
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/ObjectTransactionTest.java
@@ -0,0 +1,1008 @@
+package org.eclipse.riena.objecttransaction.interf;
+
+import org.eclipse.riena.internal.objecttransaction.impl.ObjectTransactionImpl;
+import org.eclipse.riena.objecttransaction.IObjectTransaction;
+import org.eclipse.riena.objecttransaction.IObjectTransactionExtract;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.ObjectTransactionFactoryAccessor;
+import org.eclipse.riena.objecttransaction.interf.value.Addresse;
+import org.eclipse.riena.objecttransaction.interf.value.IAddresse;
+import org.eclipse.riena.objecttransaction.interf.value.Kunde;
+import org.eclipse.riena.objecttransaction.interf.value.Vertrag;
+import org.eclipse.riena.objecttransaction.state.State;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class ObjectTransactionTest extends RienaTestCase {
+
+ public void setUp() throws Exception {
+ super.setUp();
+ // this.setTraceOn(false);
+ // trainModules("META-INF/hivetestmodule.xml");
+ // replay();
+ }
+
+ public void tearDown() throws Exception {
+ // verify();
+ super.tearDown();
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+ objectTransaction.setCleanModus(false);
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleExistingKundeAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllClean() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ // test within clean modus
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ objectTransaction.setCleanModus(false);
+
+ // test after clean modus was left
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllClean", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNewChangingAddresse() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ objectTransaction.registerAsDeleted((ITransactedObject) kunde.getAddresse());
+ addresse = new Addresse(true);
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ showStatus("testSimpleExistingKundeAllNewChangingAddresse", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSetAndGet() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=miller", kunde.getNachname().equals("Miller"));
+
+ showStatus("testSimpleWithNewKundeAndSetAndGet", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransaction subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit subObjectTransaction", subObjectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit objectTransaction", objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithNewAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted((ITransactedObject) kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress subObjectTransaction",
+ subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted((ITransactedObject) kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit objectTransaction",
+ objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraege() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraege objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege1() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag(v1);
+ objectTransaction.registerAsDeleted(v1);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege1 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege2() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag("0815");
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege3() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+
+ kunde.removeVertrag("0815");
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag 0815 gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRoot() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ IAddresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.commitToObjects();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRootWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+ objectTransaction.commitToObjects();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testImport() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ // simulating a Kunde from the database
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ // making changes to the object
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ // extracting recorded changes
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // create new objecttransaction
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ // simulate of reloading the same data from the database as before
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+
+ assertTrue("vorname=john", kunde2.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Miller"));
+
+ // apply the changes from the other objecttransaction's extract
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ // ---> properties have changed
+ assertTrue("vorname=john", kunde2.getVorname().equals("jane"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Stewart"));
+ }
+
+ /**
+ *
+ */
+ public void testImport2() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ // simulating a Kunde from the database
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ // making changes to the object
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ kunde.removeVertrag("0815");
+
+ // extracting recorded changes
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // create new objecttransaction
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ // simulate of reloading the same data from the database as before
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+
+ assertTrue("vorname=john", kunde2.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Miller"));
+
+ v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde2.addVertrag(v1);
+
+ v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde2.addVertrag(v2);
+
+ // apply the changes from the other objecttransaction's extract
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ // ---> properties have changed
+ assertTrue("vorname=john", kunde2.getVorname().equals("jane"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Stewart"));
+ assertTrue("vertrag 0815 must return null", kunde2.getVertrag("0815") == null);
+ kunde2.removeVertrag("0816");
+ }
+
+ /**
+ *
+ */
+ public void testSimpleCheckVersion() {
+ ObjectTransactionImpl objectTransaction = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ assertTrue("addresse ist nicht CLEAN", objectTransaction.isState(addresse, State.CLEAN));
+ objectTransaction.setCleanModus(false);
+
+ assertTrue("kunde hat nicht version 1", kunde.getVersion().equals("1"));
+ assertTrue("addresse hat nicht version 1", addresse.getVersion().equals("1"));
+
+ addresse.setPlz("70000");
+ objectTransaction.setVersionUpdate(addresse, "1.1");
+ assertTrue("addresse hat nicht version 1.1", addresse.getVersion().equals("1.1"));
+ assertTrue("addresse ist nicht MODIFIED", objectTransaction.isState(addresse, State.MODIFIED));
+
+ showStatus("testSimpleCheckVersion", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testUpdateVersion() {
+ ObjectTransactionImpl objectTransaction = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ kunde.setVorname("jim");
+ assertTrue("kunde ist nicht MODIFIED", objectTransaction.isState(kunde, State.MODIFIED));
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // simulate remote system with new objecttransaction
+ ObjectTransactionImpl objectTransaction2 = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+ assertTrue("kunde2 ist nicht CLEAN", objectTransaction2.isState(kunde2, State.CLEAN));
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ assertTrue("kunde2 ist nicht MODIFIED", objectTransaction2.isState(kunde2, State.MODIFIED));
+ objectTransaction2.commitToObjects();
+ assertTrue("kunde2 ist nicht CLEAN", objectTransaction2.isState(kunde2, State.CLEAN));
+ objectTransaction2.setVersionUpdate(kunde2, "2");
+ assertTrue("kunde2 ist nicht MODIFIED", objectTransaction2.isState(kunde2, State.MODIFIED));
+ extract = objectTransaction2.exportExtract();
+
+ // back on my localsystem
+ objectTransaction.commitToObjects();
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ objectTransaction.importExtract(extract);
+ assertTrue("kunde ist nicht MODIFIED", objectTransaction.isState(kunde, State.MODIFIED));
+
+ showStatus("testUpdateVersion", objectTransaction);
+ }
+
+ private void showStatus(String testName, IObjectTransaction objectTransaction) {
+ System.out.println("testname >>>>>" + testName + "<<<<<");
+ System.out.println(objectTransaction);
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Addresse.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Addresse.java
new file mode 100644
index 0000000..5974198
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Addresse.java
@@ -0,0 +1,115 @@
+package org.eclipse.riena.objecttransaction.interf.value;
+
+import java.security.SecureRandom;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+
+/**
+ * Sample class for "UTAddresse"
+ *
+ * @author Christian Campo
+ */
+public class Addresse extends AbstractTransactedObject implements IAddresse {
+
+ private String plz;
+ private String ort;
+ private String strasse;
+ private static SecureRandom random = new SecureRandom();
+
+ @SuppressWarnings("unused")
+ private Addresse() {
+ super();
+ if (getCurrentObjectTransaction().isCleanModus()) {
+ getCurrentObjectTransaction().register(this);
+ } else {
+ throw new InvalidTransactionFailure("cannot instantiate Adresse with private method if not in clean state");
+ }
+ }
+
+ /**
+ * @param dummy
+ */
+ public Addresse(boolean dummy) {
+ super(new GenericOID("addresse", "primkey", Integer.valueOf(nextRandomInt())), "1");
+ if (getCurrentObjectTransaction().isCleanModus()) {
+ getCurrentObjectTransaction().register(this);
+ } else {
+ getCurrentObjectTransaction().registerNew(this);
+ }
+ }
+
+ /**
+ * @param primKey
+ */
+ public Addresse(Integer primKey) {
+ super(new GenericOID("addresse", "primkey", primKey), "1");
+ if (getCurrentObjectTransaction().isCleanModus()) {
+ getCurrentObjectTransaction().register(this);
+ } else {
+ getCurrentObjectTransaction().registerNew(this);
+ }
+ }
+
+ /**
+ * @return Returns the ort.
+ */
+ public String getOrt() {
+ return (String) getCurrentObjectTransaction().getReference(this, "ort", ort);
+ }
+
+ /**
+ * @param ort
+ * The ort to set.
+ */
+ public void setOrt(String ort) {
+ // changeEvent
+ if (getCurrentObjectTransaction().isCleanModus()) {
+ this.ort = ort;
+ }
+ getCurrentObjectTransaction().setReference(this, "ort", ort);
+ }
+
+ /**
+ * @return Returns the plz.
+ */
+ public String getPlz() {
+ return (String) getCurrentObjectTransaction().getReference(this, "plz", plz);
+ }
+
+ /**
+ * @param plz
+ * The plz to set.
+ */
+ public void setPlz(String plz) {
+ // changeEvent
+ if (getCurrentObjectTransaction().isCleanModus()) {
+ this.plz = plz;
+ }
+ getCurrentObjectTransaction().setReference(this, "plz", plz);
+ }
+
+ /**
+ * @return Returns the strasse.
+ */
+ public String getStrasse() {
+ return (String) getCurrentObjectTransaction().getReference(this, "strasse", strasse);
+ }
+
+ /**
+ * @param strasse
+ * The strasse to set.
+ */
+ public void setStrasse(String strasse) {
+ // changeEvent
+ if (getCurrentObjectTransaction().isCleanModus()) {
+ this.strasse = strasse;
+ }
+ getCurrentObjectTransaction().setReference(this, "strasse", strasse);
+ }
+
+ private static int nextRandomInt() {
+ return random.nextInt();
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/GenericOID.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/GenericOID.java
new file mode 100644
index 0000000..0906008
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/GenericOID.java
@@ -0,0 +1,74 @@
+package org.eclipse.riena.objecttransaction.interf.value;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.riena.objecttransaction.IObjectId;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class GenericOID implements IObjectId {
+ private String type;
+ private String primName;
+ private Object primValue;
+
+ /**
+ * @param type
+ * @param primName
+ * @param primValue
+ */
+ public GenericOID( String type, String primName, Object primValue ) {
+ super();
+ this.type = type;
+ this.primName = primName;
+ this.primValue = primValue;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getType()
+ */
+ public String getType() {
+ return type;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getProperties()
+ */
+ protected Map<String,Object> getProperties() {
+ HashMap<String,Object> map = new HashMap<String,Object>();
+ map.put( primName, primValue );
+ return map;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#equals(de.compeople.scp.objecttransaction.IObjectId)
+ */
+ public boolean equals( Object oid ) {
+ if ( oid instanceof GenericOID ) {
+ GenericOID gOID = (GenericOID) oid;
+ if ( gOID.type.equals( type ) && gOID.primName.equals( primName ) && gOID.primValue.equals( primValue ) ) {
+ return true;
+ }
+ }
+ return super.equals( oid );
+ }
+
+ public int hashCode() {
+ try {
+ if ( primValue instanceof Integer ) {
+ return ( (Integer) primValue ).intValue();
+ }
+ return Integer.parseInt( (String) primValue );
+ } catch ( NumberFormatException e ) {
+ return super.hashCode();
+ }
+ }
+
+ public String toString() {
+ return "type:" + type + " primName:" + primName + " primValue:" + primValue;
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IAddresse.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IAddresse.java
new file mode 100644
index 0000000..628b47a
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IAddresse.java
@@ -0,0 +1,38 @@
+package org.eclipse.riena.objecttransaction.interf.value;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public interface IAddresse {
+ /**
+ * @return Returns the ort.
+ */
+ String getOrt();
+
+ /**
+ * @param ort The ort to set.
+ */
+ void setOrt( String ort );
+
+ /**
+ * @return Returns the plz.
+ */
+ String getPlz();
+
+ /**
+ * @param plz The plz to set.
+ */
+ void setPlz( String plz );
+
+ /**
+ * @return Returns the strasse.
+ */
+ String getStrasse();
+
+ /**
+ * @param strasse The strasse to set.
+ */
+ void setStrasse( String strasse );
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IVertrag.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IVertrag.java
new file mode 100644
index 0000000..e5bc913
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/IVertrag.java
@@ -0,0 +1,38 @@
+package org.eclipse.riena.objecttransaction.interf.value;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public interface IVertrag {
+ /**
+ * @return Returns the vertragsNummer.
+ */
+ String getVertragsNummer();
+
+ /**
+ * @param vertragsNummer The vertragsNummer to set.
+ */
+ void setVertragsNummer( String vertragsNummer );
+
+ /**
+ * @return Returns the vertragsBeschreibung.
+ */
+ String getVertragsBeschreibung();
+
+ /**
+ * @param vertragsBeschreibung The vertragsBeschreibung to set.
+ */
+ void setVertragsBeschreibung( String vertragsBeschreibung );
+
+ /**
+ * @return Returns the vertragsSumme.
+ */
+ Long getVertragsSumme();
+
+ /**
+ * @param vertragsSumme The vertragsSumme to set.
+ */
+ void setVertragsSumme( Long vertragsSumme );
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Kunde.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Kunde.java
new file mode 100644
index 0000000..07a2d06
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Kunde.java
@@ -0,0 +1,187 @@
+package org.eclipse.riena.objecttransaction.interf.value;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+
+/**
+ * Sample class for "Kunde"
+ *
+ * @author Christian Campo
+ */
+public class Kunde extends AbstractTransactedObject {
+
+ private String vorname;
+ private String nachname;
+ private String kundennr;
+ private IAddresse addresse;
+ private HashSet<Vertrag> vertraege;
+
+ /** constructor called by webservices only for clean objects * */
+ @SuppressWarnings("unused")
+ private Kunde() {
+ super();
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ getCurrentObjectTransaction().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Kunde with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param kundennr
+ */
+ public Kunde( String kundennr ) {
+ super( new GenericOID( "kunde", "kundennrpk", kundennr ), "1" );
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ getCurrentObjectTransaction().register( this );
+ } else {
+ getCurrentObjectTransaction().registerNew( this );
+ }
+ setKundennr( kundennr );
+ vertraege = new HashSet<Vertrag>();
+ }
+
+ /**
+ * @return Returns the kundennr.
+ */
+ public String getKundennr() {
+ return (String) getCurrentObjectTransaction().getReference( this, "kundennr", kundennr );
+ }
+
+ /**
+ * @param kundennr The kundennr to set.
+ */
+ public void setKundennr( String kundennr ) {
+ if ( ( (GenericOID) getObjectId() ).getProperties().get( "primkey" ) != null ) {
+ throw new UnsupportedOperationException( "cannot change kundennr (once it is set)" );
+ }
+ // changeEvent
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ this.kundennr = kundennr;
+ } else {
+ getCurrentObjectTransaction().setReference( this, "kundennr", kundennr );
+ }
+ }
+
+ /**
+ * @return Returns the nachname.
+ */
+ public String getNachname() {
+ return (String) getCurrentObjectTransaction().getReference( this, "nachname", nachname );
+ }
+
+ /**
+ * @param nachname The nachname to set.
+ */
+ public void setNachname( String nachname ) {
+ // changeEvent
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ this.nachname = nachname;
+ } else {
+ getCurrentObjectTransaction().setReference( this, "nachname", nachname );
+ }
+ }
+
+ /**
+ * @return Returns the vorname.
+ */
+ public String getVorname() {
+ return (String) getCurrentObjectTransaction().getReference( this, "vorname", vorname );
+ }
+
+ /**
+ * @param vorname The vorname to set.
+ */
+ public void setVorname( String vorname ) {
+ // changeEvent
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ this.vorname = vorname;
+ } else {
+ getCurrentObjectTransaction().setReference( this, "vorname", vorname );
+ }
+ }
+
+ /**
+ * @return Returns the addresse.
+ */
+ public IAddresse getAddresse() {
+ return (IAddresse) getCurrentObjectTransaction().getReference( this, "addresse", (ITransactedObject) addresse );
+ }
+
+ /**
+ * @param addresse The addresse to set.
+ */
+ public void setAddresse( IAddresse addresse ) {
+ // changeEvent
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ this.addresse = addresse;
+ } else {
+ getCurrentObjectTransaction().setReference( this, "addresse", (ITransactedObject) addresse );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void addVertrag( Vertrag vertrag ) {
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ vertraege.add( vertrag );
+ } else {
+ getCurrentObjectTransaction().addReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ */
+ public void removeVertrag( String vertragsNummer ) {
+ Vertrag tempVertrag = getVertrag( vertragsNummer );
+ // changeEvent
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ vertraege.remove( getVertrag( vertragsNummer ) );
+ } else {
+ getCurrentObjectTransaction().removeReference( this, "vertrag", tempVertrag );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void removeVertrag( Vertrag vertrag ) {
+ // changeEvent
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ vertraege.remove( vertrag );
+ } else {
+ getCurrentObjectTransaction().removeReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ * @return
+ */
+ public Vertrag getVertrag( String vertragsNummer ) {
+ Vertrag[] tempVertraege = listVertrag();
+ for ( int i = 0; i < tempVertraege.length; i++ ) {
+ if ( tempVertraege[i].getVertragsNummer().equals( vertragsNummer ) ) {
+ return tempVertraege[i];
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @return
+ */
+ public Vertrag[] listVertrag() {
+ Set<Vertrag> vertraegeSet = getCurrentObjectTransaction().listReference( this, "vertrag", vertraege );
+ if ( vertraegeSet.size() == 0 ) {
+ return new Vertrag[0];
+ }
+ return vertraegeSet.toArray( new Vertrag[vertraegeSet.size()] );
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Vertrag.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Vertrag.java
new file mode 100644
index 0000000..411c7d2
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/interf/value/Vertrag.java
@@ -0,0 +1,91 @@
+package org.eclipse.riena.objecttransaction.interf.value;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class Vertrag extends AbstractTransactedObject implements IVertrag {
+
+ private String vertragsNummer;
+ private String vertragsBeschreibung;
+ private Long vertragsSumme;
+
+ @SuppressWarnings("unused")
+ private Vertrag() {
+ super();
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ getCurrentObjectTransaction().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Vertrag with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param vertragsnummer
+ */
+ public Vertrag( String vertragsnummer ) {
+ super( new GenericOID( "vertrag", "vertragsnr", vertragsnummer ), "1" );
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ getCurrentObjectTransaction().register( this );
+ } else {
+ getCurrentObjectTransaction().registerNew( this );
+ }
+ setVertragsNummer( vertragsnummer );
+ }
+
+ /**
+ * @return Returns the vertragsNummer.
+ */
+ public String getVertragsNummer() {
+ return (String) getCurrentObjectTransaction().getReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @param vertragsNummer The vertragsNummer to set.
+ */
+ public void setVertragsNummer( String vertragsNummer ) {
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ this.vertragsNummer = vertragsNummer;
+ }
+ getCurrentObjectTransaction().setReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @return Returns the vertragsBeschreibung.
+ */
+ public String getVertragsBeschreibung() {
+ return (String) getCurrentObjectTransaction().getReference( this, "vertragsBeschreibung", vertragsBeschreibung );
+ }
+
+ /**
+ * @param vertragsBeschreibung The vertragsBeschreibung to set.
+ */
+ public void setVertragsBeschreibung( String vertragsBeschreibung ) {
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ this.vertragsBeschreibung = vertragsBeschreibung;
+ }
+ getCurrentObjectTransaction().setReference( this, "vertragsBeschreibung", vertragsBeschreibung );
+ }
+
+ /**
+ * @return Returns the vertragsSumme.
+ */
+ public Long getVertragsSumme() {
+ return (Long) getCurrentObjectTransaction().getReference( this, "vertragsSumme", vertragsSumme );
+ }
+
+ /**
+ * @param vertragsSumme The vertragsSumme to set.
+ */
+ public void setVertragsSumme( Long vertragsSumme ) {
+ if ( getCurrentObjectTransaction().isCleanModus() ) {
+ this.vertragsSumme = vertragsSumme;
+ }
+ getCurrentObjectTransaction().setReference( this, "vertragsSumme", vertragsSumme );
+
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/ObjectTransactionListTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/ObjectTransactionListTest.java
new file mode 100644
index 0000000..9b3e751
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/ObjectTransactionListTest.java
@@ -0,0 +1,1023 @@
+package org.eclipse.riena.objecttransaction.list;
+
+import org.eclipse.riena.internal.objecttransaction.impl.ObjectTransactionImpl;
+import org.eclipse.riena.objecttransaction.IObjectTransaction;
+import org.eclipse.riena.objecttransaction.IObjectTransactionExtract;
+import org.eclipse.riena.objecttransaction.ObjectTransactionFactoryAccessor;
+import org.eclipse.riena.objecttransaction.list.value.Addresse;
+import org.eclipse.riena.objecttransaction.list.value.Kunde;
+import org.eclipse.riena.objecttransaction.list.value.Vertrag;
+import org.eclipse.riena.objecttransaction.state.State;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class ObjectTransactionListTest extends RienaTestCase {
+
+ public void setUp() throws Exception {
+ super.setUp();
+ // this.setTraceOn(false);
+ // trainModules("META-INF/hivetestmodule.xml");
+ // replay();
+ }
+
+ public void tearDown() throws Exception {
+ // verify();
+ super.tearDown();
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+ objectTransaction.setCleanModus(false);
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleExistingKundeAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllClean() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ // test within clean modus
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ objectTransaction.setCleanModus(false);
+
+ // test after clean modus was left
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllClean", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNewChangingAddresse() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ objectTransaction.registerAsDeleted(kunde.getAddresse());
+ addresse = new Addresse(true);
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ showStatus("testSimpleExistingKundeAllNewChangingAddresse", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSetAndGet() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=miller", kunde.getNachname().equals("Miller"));
+
+ showStatus("testSimpleWithNewKundeAndSetAndGet", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransaction subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit subObjectTransaction", subObjectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit objectTransaction", objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithNewAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted(kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress subObjectTransaction",
+ subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted(kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit objectTransaction",
+ objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraege() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraege objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege1() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 2);
+
+ kunde.removeVertrag(v1);
+ objectTransaction.registerAsDeleted(v1);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege1 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege2() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag("0815");
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege3() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 2);
+ objectTransaction.setCleanModus(false);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 2);
+
+ kunde.removeVertrag("0815");
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag 0815 gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRoot() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ assertTrue("anzahl verträge ist nicht 2", kunde.listVertrag().length == 2);
+ assertTrue("reihenfolge: erste Vertrag ist nicht 0815", kunde.listVertrag()[0] == v1);
+ assertTrue("reihenfolge: zweiter Vertrag ist nicht 0816", kunde.listVertrag()[1] == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.commitToObjects();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRootWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+ assertTrue("reihenfolge: erste Vertrag ist nicht 0816", kunde.listVertrag()[0] == v2);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+ objectTransaction.commitToObjects();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testImport() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ // simulating a Kunde from the database
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ // making changes to the object
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ // extracting recorded changes
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // create new objecttransaction
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ // simulate of reloading the same data from the database as before
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+
+ assertTrue("vorname=john", kunde2.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Miller"));
+
+ // apply the changes from the other objecttransaction's extract
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ // ---> properties have changed
+ assertTrue("vorname=john", kunde2.getVorname().equals("jane"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Stewart"));
+ }
+
+ /**
+ *
+ */
+ public void testImport2() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ // simulating a Kunde from the database
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 2);
+
+ // making changes to the object
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("reihenfolge: erste Vertrag ist nicht 0815", kunde.listVertrag()[0] == v1);
+ assertTrue("reihenfolge: zweiter Vertrag ist nicht 0816", kunde.listVertrag()[1] == v2);
+
+ kunde.removeVertrag("0815");
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde.listVertrag().length == 1);
+
+ assertTrue("reihenfolge: erste Vertrag ist nicht 0816", kunde.listVertrag()[0] == v2);
+
+ // extracting recorded changes
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // create new objecttransaction
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ // simulate of reloading the same data from the database as before
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+
+ assertTrue("vorname=john", kunde2.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Miller"));
+
+ v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde2.addVertrag(v1);
+
+ v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde2.addVertrag(v2);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde2.listVertrag().length == 2);
+ assertTrue("reihenfolge: erste Vertrag ist nicht 0815", kunde2.listVertrag()[0] == v1);
+ assertTrue("reihenfolge: zweiter Vertrag ist nicht 0816", kunde2.listVertrag()[1] == v2);
+
+ // apply the changes from the other objecttransaction's extract
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ // ---> properties have changed
+ assertTrue("vorname=john", kunde2.getVorname().equals("jane"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Stewart"));
+ assertTrue("vertrag 0815 must return null", kunde2.getVertrag("0815") == null);
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde2.listVertrag().length == 1);
+ assertTrue("reihenfolge: erste Vertrag ist nicht 0816", kunde2.listVertrag()[0] == v2);
+ kunde.removeVertrag("0816");
+ assertTrue("anzahl verträge bei kunde ist falsch", kunde2.listVertrag().length == 0);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleCheckVersion() {
+ ObjectTransactionImpl objectTransaction = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ assertTrue("addresse ist nicht CLEAN", objectTransaction.isState(addresse, State.CLEAN));
+ objectTransaction.setCleanModus(false);
+
+ assertTrue("kunde hat nicht version 1", kunde.getVersion().equals("1"));
+ assertTrue("addresse hat nicht version 1", addresse.getVersion().equals("1"));
+
+ addresse.setPlz("70000");
+ objectTransaction.setVersionUpdate(addresse, "1.1");
+ assertTrue("addresse hat nicht version 1.1", addresse.getVersion().equals("1.1"));
+ assertTrue("addresse ist nicht MODIFIED", objectTransaction.isState(addresse, State.MODIFIED));
+
+ showStatus("testSimpleCheckVersion", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testUpdateVersion() {
+ ObjectTransactionImpl objectTransaction = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ kunde.setVorname("jim");
+ assertTrue("kunde ist nicht MODIFIED", objectTransaction.isState(kunde, State.MODIFIED));
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // simulate remote system with new objecttransaction
+ ObjectTransactionImpl objectTransaction2 = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+ assertTrue("kunde2 ist nicht CLEAN", objectTransaction2.isState(kunde2, State.CLEAN));
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ assertTrue("kunde2 ist nicht MODIFIED", objectTransaction2.isState(kunde2, State.MODIFIED));
+ objectTransaction2.commitToObjects();
+ assertTrue("kunde2 ist nicht CLEAN", objectTransaction2.isState(kunde2, State.CLEAN));
+ objectTransaction2.setVersionUpdate(kunde2, "2");
+ assertTrue("kunde2 ist nicht MODIFIED", objectTransaction2.isState(kunde2, State.MODIFIED));
+ extract = objectTransaction2.exportExtract();
+
+ // back on my localsystem
+ objectTransaction.commitToObjects();
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ objectTransaction.importExtract(extract);
+ assertTrue("kunde ist nicht MODIFIED", objectTransaction.isState(kunde, State.MODIFIED));
+
+ showStatus("testUpdateVersion", objectTransaction);
+ }
+
+ private void showStatus(String testName, IObjectTransaction objectTransaction) {
+ System.out.println("testname >>>>>" + testName + "<<<<<");
+ System.out.println(objectTransaction);
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Addresse.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Addresse.java
new file mode 100644
index 0000000..cf78007
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Addresse.java
@@ -0,0 +1,114 @@
+package org.eclipse.riena.objecttransaction.list.value;
+
+import java.security.SecureRandom;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * Sample class for "UTAddresse"
+ *
+ * @author Christian Campo
+ */
+public class Addresse extends AbstractTransactedObject implements ITransactedObject {
+
+ private String plz;
+ private String ort;
+ private String strasse;
+ private static SecureRandom random = new SecureRandom();
+
+ @SuppressWarnings("unused")
+ private Addresse() {
+ super();
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Adresse with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param dummy
+ */
+ public Addresse( boolean dummy ) {
+ super( new GenericOID( "addresse", "primkey", Integer.valueOf( nextRandomInt() ) ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ }
+
+ /**
+ * @param primKey
+ */
+ public Addresse( Integer primKey ) {
+ super( new GenericOID( "addresse", "primkey", primKey ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ }
+
+ /**
+ * @return Returns the ort.
+ */
+ public String getOrt() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "ort", ort );
+ }
+
+ /**
+ * @param ort The ort to set.
+ */
+ public void setOrt( String ort ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.ort = ort;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "ort", ort );
+ }
+
+ /**
+ * @return Returns the plz.
+ */
+ public String getPlz() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "plz", plz );
+ }
+
+ /**
+ * @param plz The plz to set.
+ */
+ public void setPlz( String plz ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.plz = plz;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "plz", plz );
+ }
+
+ /**
+ * @return Returns the strasse.
+ */
+ public String getStrasse() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "strasse", strasse );
+ }
+
+ /**
+ * @param strasse The strasse to set.
+ */
+ public void setStrasse( String strasse ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.strasse = strasse;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "strasse", strasse );
+ }
+
+ private static int nextRandomInt() {
+ return random.nextInt();
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/GenericOID.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/GenericOID.java
new file mode 100644
index 0000000..92e8bf6
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/GenericOID.java
@@ -0,0 +1,74 @@
+package org.eclipse.riena.objecttransaction.list.value;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.riena.objecttransaction.IObjectId;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class GenericOID implements IObjectId {
+ private String type;
+ private String primName;
+ private Object primValue;
+
+ /**
+ * @param type
+ * @param primName
+ * @param primValue
+ */
+ public GenericOID( String type, String primName, Object primValue ) {
+ super();
+ this.type = type;
+ this.primName = primName;
+ this.primValue = primValue;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getType()
+ */
+ public String getType() {
+ return type;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getProperties()
+ */
+ protected Map<String,Object> getProperties() {
+ HashMap<String,Object> map = new HashMap<String,Object>();
+ map.put( primName, primValue );
+ return map;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#equals(de.compeople.scp.objecttransaction.IObjectId)
+ */
+ public boolean equals( Object oid ) {
+ if ( oid instanceof GenericOID ) {
+ GenericOID gOID = (GenericOID) oid;
+ if ( gOID.type.equals( type ) && gOID.primName.equals( primName ) && gOID.primValue.equals( primValue ) ) {
+ return true;
+ }
+ }
+ return super.equals( oid );
+ }
+
+ public int hashCode() {
+ try {
+ if ( primValue instanceof Integer ) {
+ return ( (Integer) primValue ).intValue();
+ }
+ return Integer.parseInt( (String) primValue );
+ } catch ( NumberFormatException e ) {
+ return super.hashCode();
+ }
+ }
+
+ public String toString() {
+ return "type:" + type + " primName:" + primName + " primValue:" + primValue;
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Kunde.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Kunde.java
new file mode 100644
index 0000000..2b8b892
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Kunde.java
@@ -0,0 +1,188 @@
+package org.eclipse.riena.objecttransaction.list.value;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * Sample class for "Kunde"
+ *
+ * @author Christian Campo
+ */
+public class Kunde extends AbstractTransactedObject implements ITransactedObject {
+
+ private String vorname;
+ private String nachname;
+ private String kundennr;
+ private Addresse addresse;
+ private HashSet<Vertrag> vertraege;
+
+ /** constructor called by webservices only for clean objects * */
+ @SuppressWarnings("unused")
+ private Kunde() {
+ super();
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Kunde with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param kundennr
+ */
+ public Kunde( String kundennr ) {
+ super( new GenericOID( "kunde", "kundennrpk", kundennr ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ setKundennr( kundennr );
+ vertraege = new HashSet<Vertrag>();
+ }
+
+ /**
+ * @return Returns the kundennr.
+ */
+ public String getKundennr() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "kundennr", kundennr );
+ }
+
+ /**
+ * @param kundennr The kundennr to set.
+ */
+ public void setKundennr( String kundennr ) {
+ if ( ( (GenericOID) getObjectId() ).getProperties().get( "primkey" ) != null ) {
+ throw new UnsupportedOperationException( "cannot change kundennr (once it is set)" );
+ }
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.kundennr = kundennr;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "kundennr", kundennr );
+ }
+ }
+
+ /**
+ * @return Returns the nachname.
+ */
+ public String getNachname() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "nachname", nachname );
+ }
+
+ /**
+ * @param nachname The nachname to set.
+ */
+ public void setNachname( String nachname ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.nachname = nachname;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "nachname", nachname );
+ }
+ }
+
+ /**
+ * @return Returns the vorname.
+ */
+ public String getVorname() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vorname", vorname );
+ }
+
+ /**
+ * @param vorname The vorname to set.
+ */
+ public void setVorname( String vorname ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vorname = vorname;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vorname", vorname );
+ }
+ }
+
+ /**
+ * @return Returns the addresse.
+ */
+ public Addresse getAddresse() {
+ return (Addresse) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "addresse", addresse );
+ }
+
+ /**
+ * @param addresse The addresse to set.
+ */
+ public void setAddresse( Addresse addresse ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.addresse = addresse;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "addresse", addresse );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void addVertrag( Vertrag vertrag ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.add( vertrag );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().addReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ */
+ public void removeVertrag( String vertragsNummer ) {
+ Vertrag tempVertrag = getVertrag( vertragsNummer );
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.remove( getVertrag( vertragsNummer ) );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().removeReference( this, "vertrag", tempVertrag );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void removeVertrag( Vertrag vertrag ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.remove( vertrag );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().removeReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ * @return
+ */
+ public Vertrag getVertrag( String vertragsNummer ) {
+ Vertrag[] tempVertraege = listVertrag();
+ for ( int i = 0; i < tempVertraege.length; i++ ) {
+ if ( tempVertraege[i].getVertragsNummer().equals( vertragsNummer ) ) {
+ return tempVertraege[i];
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @return
+ */
+ public Vertrag[] listVertrag() {
+ Set<Vertrag> vertraegeSet = ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().listReference( this, "vertrag", vertraege );
+ if ( vertraegeSet.size() == 0 ) {
+ return new Vertrag[0];
+ }
+ return vertraegeSet.toArray( new Vertrag[vertraegeSet.size()] );
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Vertrag.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Vertrag.java
new file mode 100644
index 0000000..f1950a1
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/list/value/Vertrag.java
@@ -0,0 +1,94 @@
+package org.eclipse.riena.objecttransaction.list.value;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class Vertrag extends AbstractTransactedObject implements ITransactedObject {
+
+ private String vertragsNummer;
+ private String vertragsBeschreibung;
+ private Long vertragsSumme;
+
+ @SuppressWarnings("unused")
+ private Vertrag() {
+ super();
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Vertrag with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param vertragsnummer
+ */
+ public Vertrag( String vertragsnummer ) {
+ super( new GenericOID( "vertrag", "vertragsnr", vertragsnummer ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ setVertragsNummer( vertragsnummer );
+ }
+
+ /**
+ * @return Returns the vertragsNummer.
+ */
+ public String getVertragsNummer() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @param vertragsNummer The vertragsNummer to set.
+ */
+ public void setVertragsNummer( String vertragsNummer ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsNummer = vertragsNummer;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @return Returns the vertragsBeschreibung.
+ */
+ public String getVertragsBeschreibung() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsBeschreibung",
+ vertragsBeschreibung );
+ }
+
+ /**
+ * @param vertragsBeschreibung The vertragsBeschreibung to set.
+ */
+ public void setVertragsBeschreibung( String vertragsBeschreibung ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsBeschreibung = vertragsBeschreibung;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsBeschreibung", vertragsBeschreibung );
+ }
+
+ /**
+ * @return Returns the vertragsSumme.
+ */
+ public Long getVertragsSumme() {
+ return (Long) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsSumme", vertragsSumme );
+ }
+
+ /**
+ * @param vertragsSumme The vertragsSumme to set.
+ */
+ public void setVertragsSumme( Long vertragsSumme ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsSumme = vertragsSumme;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsSumme", vertragsSumme );
+
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionVariousTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionVariousTest.java
new file mode 100644
index 0000000..4b06bf8
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionVariousTest.java
@@ -0,0 +1,51 @@
+package org.eclipse.riena.objecttransaction.noreg;
+
+import org.eclipse.riena.objecttransaction.IObjectTransaction;
+import org.eclipse.riena.objecttransaction.ObjectTransactionFactoryAccessor;
+import org.eclipse.riena.objecttransaction.noreg.value.Kunde;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class ObjectTransactionVariousTest extends RienaTestCase {
+
+ public void setUp() throws Exception {
+ super.setUp();
+ // this.setTraceOn(true);
+ // trainModules("META-INF/hivetestmodule.xml");
+ // replay();
+ }
+
+ public void tearDown() throws Exception {
+ // verify();
+ super.tearDown();
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testPreRegisteredWithNoObjectId() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ // tests that you can register object with ObjectID null and that you
+ // can switch the
+ // cleanmodus to false
+ kunde.setObjectId(null);
+ objectTransaction.register(kunde);
+ objectTransaction.setCleanModus(false);
+ objectTransaction.importExtract(objectTransaction.exportExtract());
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionWithoutTransactionTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionWithoutTransactionTest.java
new file mode 100644
index 0000000..ed5f02c
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/ObjectTransactionWithoutTransactionTest.java
@@ -0,0 +1,811 @@
+package org.eclipse.riena.objecttransaction.noreg;
+
+import org.eclipse.riena.objecttransaction.IObjectTransaction;
+import org.eclipse.riena.objecttransaction.ObjectTransactionFactoryAccessor;
+import org.eclipse.riena.objecttransaction.noreg.value.Addresse;
+import org.eclipse.riena.objecttransaction.noreg.value.Kunde;
+import org.eclipse.riena.objecttransaction.noreg.value.Vertrag;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * Tests that you can use transacted objects in clean modus without doing any
+ * registration
+ *
+ * @author Christian Campo
+ */
+public class ObjectTransactionWithoutTransactionTest extends RienaTestCase {
+
+ public void setUp() throws Exception {
+ super.setUp();
+ // this.setTraceOn(false);
+ // trainModules("META-INF/hivetestmodule.xml");
+ // replay();
+ }
+
+ public void tearDown() throws Exception {
+ // verify();
+ super.tearDown();
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleExistingKundeAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllClean() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ // test within clean modus
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ // test after clean modus was left
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllClean", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNewChangingAddresse() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ objectTransaction.registerAsDeleted(kunde.getAddresse());
+ addresse = new Addresse(true);
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ showStatus("testSimpleExistingKundeAllNewChangingAddresse", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSetAndGet() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=miller", kunde.getNachname().equals("Miller"));
+
+ showStatus("testSimpleWithNewKundeAndSetAndGet", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransaction subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit subObjectTransaction", subObjectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit objectTransaction", objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithNewAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted(kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress subObjectTransaction",
+ subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted(kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit objectTransaction",
+ objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraege() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraege objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege1() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag(v1);
+ objectTransaction.registerAsDeleted(v1);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege1 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege2() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag("0815");
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege3() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag("0815");
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag 0815 gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRoot() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.commitToObjects();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRootWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.setCleanModus(true);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+ objectTransaction.commitToObjects();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ private void showStatus(String testName, IObjectTransaction objectTransaction) {
+ System.out.println("testname >>>>>" + testName + "<<<<<");
+ System.out.println(objectTransaction);
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Addresse.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Addresse.java
new file mode 100644
index 0000000..b8d6a92
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Addresse.java
@@ -0,0 +1,100 @@
+package org.eclipse.riena.objecttransaction.noreg.value;
+
+import java.security.SecureRandom;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * Sample class for "UTAddresse"
+ *
+ * @author Christian Campo
+ */
+public class Addresse extends AbstractTransactedObject implements ITransactedObject {
+
+ private String plz;
+ private String ort;
+ private String strasse;
+ private static SecureRandom random = new SecureRandom();
+
+ @SuppressWarnings("unused")
+ private Addresse() {
+ super();
+ }
+
+ /**
+ *
+ */
+ /**
+ * @param dummy
+ */
+ public Addresse( boolean dummy ) {
+ super( new GenericOID( "addresse", "primkey", Integer.valueOf( nextRandomInt() ) ), "1" );
+ }
+
+ /**
+ * @param primKey
+ */
+ public Addresse( Integer primKey ) {
+ super( new GenericOID( "addresse", "primkey", primKey ), "1" );
+ }
+
+ /**
+ * @return Returns the ort.
+ */
+ public String getOrt() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "ort", ort );
+ }
+
+ /**
+ * @param ort The ort to set.
+ */
+ public void setOrt( String ort ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.ort = ort;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "ort", ort );
+ }
+
+ /**
+ * @return Returns the plz.
+ */
+ public String getPlz() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "plz", plz );
+ }
+
+ /**
+ * @param plz The plz to set.
+ */
+ public void setPlz( String plz ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.plz = plz;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "plz", plz );
+ }
+
+ /**
+ * @return Returns the strasse.
+ */
+ public String getStrasse() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "strasse", strasse );
+ }
+
+ /**
+ * @param strasse The strasse to set.
+ */
+ public void setStrasse( String strasse ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.strasse = strasse;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "strasse", strasse );
+ }
+
+ private static int nextRandomInt() {
+ return random.nextInt();
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/GenericOID.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/GenericOID.java
new file mode 100644
index 0000000..27c5fd8
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/GenericOID.java
@@ -0,0 +1,74 @@
+package org.eclipse.riena.objecttransaction.noreg.value;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.riena.objecttransaction.IObjectId;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class GenericOID implements IObjectId {
+ private String type;
+ private String primName;
+ private Object primValue;
+
+ /**
+ * @param type
+ * @param primName
+ * @param primValue
+ */
+ public GenericOID( String type, String primName, Object primValue ) {
+ super();
+ this.type = type;
+ this.primName = primName;
+ this.primValue = primValue;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getType()
+ */
+ public String getType() {
+ return type;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getProperties()
+ */
+ protected Map<String,Object> getProperties() {
+ HashMap<String,Object> map = new HashMap<String,Object>();
+ map.put( primName, primValue );
+ return map;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#equals(de.compeople.scp.objecttransaction.IObjectId)
+ */
+ public boolean equals( Object oid ) {
+ if ( oid instanceof GenericOID ) {
+ GenericOID gOID = (GenericOID) oid;
+ if ( gOID.type.equals( type ) && gOID.primName.equals( primName ) && gOID.primValue.equals( primValue ) ) {
+ return true;
+ }
+ }
+ return super.equals( oid );
+ }
+
+ public int hashCode() {
+ try {
+ if ( primValue instanceof Integer ) {
+ return ( (Integer) primValue ).intValue();
+ }
+ return Integer.parseInt( (String) primValue );
+ } catch ( NumberFormatException e ) {
+ return super.hashCode();
+ }
+ }
+
+ public String toString() {
+ return "type:" + type + " primName:" + primName + " primValue:" + primValue;
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Kunde.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Kunde.java
new file mode 100644
index 0000000..c57f206
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Kunde.java
@@ -0,0 +1,177 @@
+package org.eclipse.riena.objecttransaction.noreg.value;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * Sample class for "Kunde"
+ *
+ * @author Christian Campo
+ */
+public class Kunde extends AbstractTransactedObject implements ITransactedObject {
+
+ private String vorname;
+ private String nachname;
+ private String kundennr;
+ private Addresse addresse;
+ private HashSet<Vertrag> vertraege;
+
+ /** constructor called by webservices only for clean objects * */
+ @SuppressWarnings("unused")
+ private Kunde() {
+ super();
+ }
+
+ /**
+ * @param kundennr
+ */
+ public Kunde( String kundennr ) {
+ super( new GenericOID( "kunde", "kundennrpk", kundennr ), "1" );
+ setKundennr( kundennr );
+ vertraege = new HashSet<Vertrag>();
+ }
+
+ /**
+ * @return Returns the kundennr.
+ */
+ public String getKundennr() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "kundennr", kundennr );
+ }
+
+ /**
+ * @param kundennr The kundennr to set.
+ */
+ public void setKundennr( String kundennr ) {
+ if ( ( (GenericOID) getObjectId() ).getProperties().get( "primkey" ) != null ) {
+ throw new UnsupportedOperationException( "cannot change kundennr (once it is set)" );
+ }
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.kundennr = kundennr;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "kundennr", kundennr );
+ }
+ }
+
+ /**
+ * @return Returns the nachname.
+ */
+ public String getNachname() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "nachname", nachname );
+ }
+
+ /**
+ * @param nachname The nachname to set.
+ */
+ public void setNachname( String nachname ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.nachname = nachname;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "nachname", nachname );
+ }
+ }
+
+ /**
+ * @return Returns the vorname.
+ */
+ public String getVorname() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vorname", vorname );
+ }
+
+ /**
+ * @param vorname The vorname to set.
+ */
+ public void setVorname( String vorname ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vorname = vorname;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vorname", vorname );
+ }
+ }
+
+ /**
+ * @return Returns the addresse.
+ */
+ public Addresse getAddresse() {
+ return (Addresse) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "addresse", addresse );
+ }
+
+ /**
+ * @param addresse The addresse to set.
+ */
+ public void setAddresse( Addresse addresse ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.addresse = addresse;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "addresse", addresse );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void addVertrag( Vertrag vertrag ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.add( vertrag );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().addReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ */
+ public void removeVertrag( String vertragsNummer ) {
+ Vertrag tempVertrag = getVertrag( vertragsNummer );
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.remove( getVertrag( vertragsNummer ) );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().removeReference( this, "vertrag", tempVertrag );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void removeVertrag( Vertrag vertrag ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.remove( vertrag );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().removeReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ * @return
+ */
+ public Vertrag getVertrag( String vertragsNummer ) {
+ Vertrag[] tempVertraege = listVertrag();
+ for ( int i = 0; i < tempVertraege.length; i++ ) {
+ if ( tempVertraege[i].getVertragsNummer().equals( vertragsNummer ) ) {
+ return tempVertraege[i];
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @return
+ */
+ public Vertrag[] listVertrag() {
+ Set<Vertrag> vertraegeSet = ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().listReference( this, "vertrag", vertraege );
+ if ( vertraegeSet.size() == 0 ) {
+ return new Vertrag[0];
+ }
+ return vertraegeSet.toArray( new Vertrag[vertraegeSet.size()] );
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Vertrag.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Vertrag.java
new file mode 100644
index 0000000..1a7a7e6
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/noreg/value/Vertrag.java
@@ -0,0 +1,83 @@
+package org.eclipse.riena.objecttransaction.noreg.value;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class Vertrag extends AbstractTransactedObject implements ITransactedObject {
+
+ private String vertragsNummer;
+ private String vertragsBeschreibung;
+ private Long vertragsSumme;
+
+ @SuppressWarnings("unused")
+ private Vertrag() {
+ super();
+ }
+
+ /**
+ * @param vertragsnummer
+ */
+ public Vertrag( String vertragsnummer ) {
+ super( new GenericOID( "vertrag", "vertragsnr", vertragsnummer ), "1" );
+ setVertragsNummer( vertragsnummer );
+ }
+
+ /**
+ * @return Returns the vertragsNummer.
+ */
+ public String getVertragsNummer() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @param vertragsNummer The vertragsNummer to set.
+ */
+ public void setVertragsNummer( String vertragsNummer ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsNummer = vertragsNummer;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @return Returns the vertragsBeschreibung.
+ */
+ public String getVertragsBeschreibung() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsBeschreibung",
+ vertragsBeschreibung );
+ }
+
+ /**
+ * @param vertragsBeschreibung The vertragsBeschreibung to set.
+ */
+ public void setVertragsBeschreibung( String vertragsBeschreibung ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsBeschreibung = vertragsBeschreibung;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsBeschreibung", vertragsBeschreibung );
+ }
+
+ /**
+ * @return Returns the vertragsSumme.
+ */
+ public Long getVertragsSumme() {
+ return (Long) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsSumme", vertragsSumme );
+ }
+
+ /**
+ * @param vertragsSumme The vertragsSumme to set.
+ */
+ public void setVertragsSumme( Long vertragsSumme ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsSumme = vertragsSumme;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsSumme", vertragsSumme );
+
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionDisallowRegisterTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionDisallowRegisterTest.java
new file mode 100644
index 0000000..82e3ce2
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionDisallowRegisterTest.java
@@ -0,0 +1,49 @@
+package org.eclipse.riena.objecttransaction.simple;
+
+import org.eclipse.riena.objecttransaction.IObjectTransaction;
+import org.eclipse.riena.objecttransaction.ObjectTransactionFactoryAccessor;
+import org.eclipse.riena.objecttransaction.simple.value.Addresse;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class ObjectTransactionDisallowRegisterTest extends RienaTestCase {
+
+ public void setUp() throws Exception {
+ super.setUp();
+ // this.setTraceOn(false);
+ // trainModules("META-INF/hivetestmodule.xml");
+ // replay();
+ }
+
+ public void tearDown() throws Exception {
+ // verify();
+ super.tearDown();
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllowRegister() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.allowRegister(false);
+
+ Addresse addresse = new Addresse(true);
+ assertTrue("kunde must not be registered", !objectTransaction.isRegistered(addresse));
+
+ objectTransaction.allowRegister(true);
+ addresse = new Addresse(true);
+ assertTrue("kunde must be registered", objectTransaction.isRegistered(addresse));
+
+ showStatus("testSimpleAllNew", objectTransaction);
+ }
+
+ private void showStatus(String testName, IObjectTransaction objectTransaction) {
+ System.out.println("testname >>>>>" + testName + "<<<<<");
+ System.out.println(objectTransaction);
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionTest.java
new file mode 100644
index 0000000..2bb745e
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionTest.java
@@ -0,0 +1,1031 @@
+package org.eclipse.riena.objecttransaction.simple;
+
+import org.eclipse.riena.internal.objecttransaction.impl.ObjectTransactionImpl;
+import org.eclipse.riena.objecttransaction.IObjectTransaction;
+import org.eclipse.riena.objecttransaction.IObjectTransactionExtract;
+import org.eclipse.riena.objecttransaction.ObjectTransactionFactoryAccessor;
+import org.eclipse.riena.objecttransaction.simple.value.Addresse;
+import org.eclipse.riena.objecttransaction.simple.value.Kunde;
+import org.eclipse.riena.objecttransaction.simple.value.Vertrag;
+import org.eclipse.riena.objecttransaction.state.State;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class ObjectTransactionTest extends RienaTestCase {
+
+ public void setUp() throws Exception {
+ super.setUp();
+ // this.setTraceOn(false);
+ // trainModules("META-INF/hivetestmodule.xml");
+ // replay();
+ }
+
+ public void tearDown() throws Exception {
+ // verify();
+ super.tearDown();
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNew() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+ objectTransaction.setCleanModus(false);
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleExistingKundeAllNew", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleAllClean() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ // test within clean modus
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ objectTransaction.setCleanModus(false);
+
+ // test after clean modus was left
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleAllClean", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleExistingKundeAllNewChangingAddresse() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ objectTransaction.registerAsDeleted(kunde.getAddresse());
+ addresse = new Addresse(true);
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ kunde.setAddresse(addresse);
+
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+
+ showStatus("testSimpleExistingKundeAllNewChangingAddresse", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSetAndGet() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=miller", kunde.getNachname().equals("Miller"));
+
+ showStatus("testSimpleWithNewKundeAndSetAndGet", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransaction subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit subObjectTransaction", subObjectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionAndCommit objectTransaction", objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithNewAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithNewAddress subObjectTransaction", subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddress() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted(kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress objectTransaction", objectTransaction);
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddress subObjectTransaction",
+ subObjectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("kundenr=4711", kunde.getKundennr().equals("4711"));
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ subObjectTransaction.toString();
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ addresse = new Addresse(true);
+ subObjectTransaction.registerAsDeleted(kunde.getAddresse());
+
+ addresse.setOrt("München");
+ addresse.setPlz("80000");
+ addresse.setStrasse("Leopoldstrasse");
+ kunde.setAddresse(addresse);
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ subObjectTransaction.commit();
+
+ assertTrue("vorname=jane", kunde.getVorname().equals("jane"));
+ assertTrue("nachname=Stewart", kunde.getNachname().equals("Stewart"));
+
+ assertTrue("ort in addresse ist nicht München", addresse.getOrt().equals("München"));
+ assertTrue("plz in addresse ist nicht 80000", addresse.getPlz().equals("80000"));
+ assertTrue("strasse ist nicht Leopoldstrasse", addresse.getStrasse().equals("Leopoldstrasse"));
+
+ showStatus("testSimpleWithNewKundeAndSubTransactionWithChangedAddressAndCommit objectTransaction",
+ objectTransaction);
+
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraege() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraege objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege1() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag(v1);
+ objectTransaction.registerAsDeleted(v1);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege1 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege2() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ kunde.removeVertrag("0815");
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewAndRemoveVertraege3() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+
+ kunde.removeVertrag("0815");
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag 0815 gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndNewAndRemoveVertraege2 objectTransaction", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0816") == null);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ showStatus("testSimpleWithExistingKundeUndNewVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction objectTransaction", objectTransaction);
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransaction subObjectTransaction",
+ subObjectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRoot() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0815") == v1);
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ subObjectTransaction.commit();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ objectTransaction.commitToObjects();
+
+ assertTrue("falscher oder keine Vertrag beim Kunden gefunden", kunde.getVertrag("0816") == v2);
+ assertTrue("nicht existierender Vertrag gefunden", kunde.getVertrag("0815") == null);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitRootWithList() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+ kunde.removeVertrag(v1);
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ subObjectTransaction.registerAsDeleted(v1);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+ objectTransaction.commitToObjects();
+ assertTrue("Es gibt nicht 1 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 1);
+
+ showStatus("testSimpleWithExistingKundeUndRemoveVertraegeInSubTransactionAndCommitWithList objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testSimpleWithExistingKundeUndAddVertragInSubTransactionAndCommit() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ IObjectTransaction subObjectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createSubObjectTransaction(objectTransaction);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ assertTrue("Es gibt nicht 2 Verträge sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ subObjectTransaction.commit();
+ assertTrue("Es gibt nicht 2 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+ objectTransaction.commitToObjects();
+ assertTrue("Es gibt nicht 2 Vertrag sondern :" + kunde.listVertrag().length, kunde.listVertrag().length == 2);
+
+ showStatus("testSimpleWithExistingKundeUndAddVertragInSubTransactionAndCommit objectTransaction",
+ objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testImport() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ // simulating a Kunde from the database
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ // making changes to the object
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ // extracting recorded changes
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // create new objecttransaction
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ // simulate of reloading the same data from the database as before
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+
+ assertTrue("vorname=john", kunde2.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Miller"));
+
+ // apply the changes from the other objecttransaction's extract
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ // ---> properties have changed
+ assertTrue("vorname=john", kunde2.getVorname().equals("jane"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Stewart"));
+ }
+
+ /**
+ *
+ */
+ public void testImport2() {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ // simulating a Kunde from the database
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("vorname=john", kunde.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde.getNachname().equals("Miller"));
+
+ Vertrag v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde.addVertrag(v1);
+
+ Vertrag v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde.addVertrag(v2);
+
+ // making changes to the object
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("jane");
+ kunde.setNachname("Stewart");
+
+ kunde.removeVertrag("0815");
+
+ // extracting recorded changes
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // create new objecttransaction
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ // simulate of reloading the same data from the database as before
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+
+ assertTrue("vorname=john", kunde2.getVorname().equals("john"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Miller"));
+
+ v1 = new Vertrag("0815");
+ v1.setVertragsBeschreibung("mein erster Vertrag");
+ kunde2.addVertrag(v1);
+
+ v2 = new Vertrag("0816");
+ v2.setVertragsBeschreibung("noch ein Vertrag");
+ kunde2.addVertrag(v2);
+
+ // apply the changes from the other objecttransaction extract
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ // ---> properties have changed
+ assertTrue("vorname=john", kunde2.getVorname().equals("jane"));
+ assertTrue("nachname=Miller", kunde2.getNachname().equals("Stewart"));
+ assertTrue("vertrag 0815 must return null", kunde2.getVertrag("0815") == null);
+ kunde2.removeVertrag("0816");
+ }
+
+ /**
+ *
+ */
+ public void testSimpleCheckVersion() {
+ ObjectTransactionImpl objectTransaction = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertTrue("nachname ist nicht Miller", kunde.getNachname().equals("Miller"));
+ assertTrue("vorname ist nicht john", kunde.getVorname().equals("john"));
+ assertTrue("kundenr ist nicht 4711", kunde.getKundennr().equals("4711"));
+ Addresse addresse = new Addresse(true);
+ kunde.setAddresse(addresse);
+ assertTrue("address ist nicht gesetzt", kunde.getAddresse() != null);
+ addresse.setOrt("Frankfurt");
+ addresse.setPlz("60000");
+ addresse.setStrasse("Münchnerstr.");
+ assertTrue("ort in addresse ist nicht Frankfurt", addresse.getOrt().equals("Frankfurt"));
+ assertTrue("plz in addresse ist nicht 60000", addresse.getPlz().equals("60000"));
+ assertTrue("strasse ist nicht Münchnerstr.", addresse.getStrasse().equals("Münchnerstr."));
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ assertTrue("addresse ist nicht CLEAN", objectTransaction.isState(addresse, State.CLEAN));
+ objectTransaction.setCleanModus(false);
+
+ assertTrue("kunde hat nicht version 1", kunde.getVersion().equals("1"));
+ assertTrue("addresse hat nicht version 1", addresse.getVersion().equals("1"));
+
+ addresse.setPlz("70000");
+ objectTransaction.setVersionUpdate(addresse, "1.1");
+ assertTrue("addresse hat nicht version 1.1", addresse.getVersion().equals("1.1"));
+ assertTrue("addresse ist nicht MODIFIED", objectTransaction.isState(addresse, State.MODIFIED));
+
+ showStatus("testSimpleCheckVersion", objectTransaction);
+ }
+
+ /**
+ *
+ */
+ public void testUpdateVersion() {
+ ObjectTransactionImpl objectTransaction = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ kunde.setVorname("jim");
+ assertTrue("kunde ist nicht MODIFIED", objectTransaction.isState(kunde, State.MODIFIED));
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ // simulate remote system with new objecttransaction
+ ObjectTransactionImpl objectTransaction2 = (ObjectTransactionImpl) ObjectTransactionFactoryAccessor
+ .fetchObjectTransactionFactory().createObjectTransaction();
+ objectTransaction2.setCleanModus(true);
+ Kunde kunde2 = new Kunde("4711");
+ kunde2.setVorname("john");
+ kunde2.setNachname("Miller");
+ assertTrue("kunde2 ist nicht CLEAN", objectTransaction2.isState(kunde2, State.CLEAN));
+ objectTransaction2.setCleanModus(false);
+ objectTransaction2.importExtract(extract);
+ assertTrue("kunde2 ist nicht MODIFIED", objectTransaction2.isState(kunde2, State.MODIFIED));
+ objectTransaction2.commitToObjects();
+ assertTrue("kunde2 ist nicht CLEAN", objectTransaction2.isState(kunde2, State.CLEAN));
+ objectTransaction2.setVersionUpdate(kunde2, "2");
+ assertTrue("kunde2 ist nicht MODIFIED", objectTransaction2.isState(kunde2, State.MODIFIED));
+ extract = objectTransaction2.exportExtract();
+
+ // back on my localsystem
+ objectTransaction.commitToObjects();
+ assertTrue("kunde ist nicht CLEAN", objectTransaction.isState(kunde, State.CLEAN));
+ objectTransaction.importExtract(extract);
+ assertTrue("kunde ist nicht MODIFIED", objectTransaction.isState(kunde, State.MODIFIED));
+
+ showStatus("testUpdateVersion", objectTransaction);
+ }
+
+ private void showStatus(String testName, IObjectTransaction objectTransaction) {
+ System.out.println("testname >>>>>" + testName + "<<<<<");
+ System.out.println(objectTransaction);
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionVariousTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionVariousTest.java
new file mode 100644
index 0000000..6f5adec
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/ObjectTransactionVariousTest.java
@@ -0,0 +1,891 @@
+package org.eclipse.riena.objecttransaction.simple;
+
+import org.eclipse.core.runtime.AssertionFailedException;
+import org.eclipse.riena.objecttransaction.IObjectTransaction;
+import org.eclipse.riena.objecttransaction.IObjectTransactionExtract;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+import org.eclipse.riena.objecttransaction.ObjectTransactionFactoryAccessor;
+import org.eclipse.riena.objecttransaction.delta.TransactionDelta;
+import org.eclipse.riena.objecttransaction.simple.value.Addresse;
+import org.eclipse.riena.objecttransaction.simple.value.Kunde;
+import org.eclipse.riena.objecttransaction.simple.value.Vertrag;
+import org.eclipse.riena.objecttransaction.state.State;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class ObjectTransactionVariousTest extends RienaTestCase {
+
+ public void setUp() throws Exception {
+ super.setUp();
+ ClassLoader loader = Thread.currentThread().getContextClassLoader();
+ loader.setDefaultAssertionStatus(true);
+
+ // this.setTraceOn(true);
+ // trainModules("META-INF/hivetestmodule.xml");
+ // replay();
+ }
+
+ public void tearDown() throws Exception {
+ // verify();
+ super.tearDown();
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testNullValueAndCommitToObjects() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ assertEquals("john", kunde.getVorname());
+ // objectTransaction.setCleanModus( false );
+ assertEquals("john", kunde.getVorname());
+ kunde.setVorname(null);
+ // System.out.println( kunde.getVorname() );
+ assertNull(kunde.getVorname());
+ objectTransaction.commitToObjects();
+ assertNull(kunde.getVorname());
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testRegisterAsDeletedWithCommitToObjects() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ objectTransaction.setCleanModus(false);
+
+ objectTransaction.registerAsDeleted(kunde);
+
+ objectTransaction.commitToObjects();
+
+ assertFalse("kunde must not be registered", objectTransaction.isRegistered(kunde));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExtractIsImmutable() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ objectTransaction.setCleanModus(false);
+
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("must only be changes for one object ", deltas.length == 1);
+
+ assertTrue("must have only 2 changes ", deltas[0].getChanges().size() == 2);
+
+ kunde.setAddresse(new Addresse(true));
+
+ assertTrue("extract changed:: must only be changes for one object ", deltas.length == 1);
+
+ assertTrue("extract changed:: must have only 2 changes ", deltas[0].getChanges().size() == 2);
+
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified1() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse adresse = new Addresse(false);
+ kunde.setAddresse(adresse);
+
+ objectTransaction.setCleanModus(false);
+ adresse.setOrt("frankfurt");
+ adresse.setStrasse("gutleutstrasse");
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only one transaction delta", deltas.length == 1);
+ assertTrue("single delta should reference adresse", deltas[0].getObjectId() == adresse.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState() == State.MODIFIED);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified2() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse adresse = new Addresse(false);
+ objectTransaction.setCleanModus(false);
+
+ kunde.setAddresse(adresse);
+
+ adresse.setOrt("frankfurt");
+ adresse.setStrasse("gutleutstrasse");
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only two transaction delta", deltas.length == 2);
+ // sequence of objects in delta[0] and delta[1] is random. therefore we
+ // check that one is adresse and the other is kunde
+ // and that there are not equal
+ assertTrue("single delta should reference adresse",
+ (deltas[0].getObjectId() == adresse.getObjectId() || deltas[1].getObjectId() == adresse.getObjectId()));
+ assertTrue("delta status must be both be modified", (deltas[0].getState().equals(State.MODIFIED) && deltas[1]
+ .getState().equals(State.MODIFIED)));
+ assertTrue("single delta should reference kunde", (deltas[0].getObjectId() == kunde.getObjectId() || deltas[1]
+ .getObjectId() == kunde.getObjectId()));
+ assertTrue("single delta should reference different objects", (deltas[0].getObjectId() != deltas[1]
+ .getObjectId()));
+
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified3() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse adresse = new Addresse(false);
+ adresse.setOrt("frankfurt");
+ adresse.setStrasse("gutleutstrasse");
+ objectTransaction.setCleanModus(false);
+ kunde.setAddresse(adresse);
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only two transaction delta", deltas.length == 2);
+ assertTrue("single delta should reference kunde", deltas[0].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ assertTrue("single delta should reference adresse", deltas[1].getObjectId() == adresse.getObjectId());
+ assertTrue("delta status must be modified", deltas[1].getState().equals(State.CLEAN));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified4() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Addresse adresse = new Addresse(false);
+ kunde.setAddresse(adresse);
+
+ adresse.setOrt("frankfurt");
+ adresse.setStrasse("gutleutstrasse");
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only one transaction delta", deltas.length == 1);
+ assertTrue("single delta should reference kunde", deltas[0].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified5() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ objectTransaction.setCleanModus(false);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.addVertrag(v2);
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only two transaction delta", deltas.length == 2);
+ assertTrue("single delta should reference v2", deltas[0].getObjectId() == v2.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.CREATED));
+ assertTrue("single delta should reference kunde", deltas[1].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[1].getState().equals(State.MODIFIED));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified6() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ objectTransaction.setCleanModus(false);
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.addVertrag(v2);
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only three transaction delta", deltas.length == 3);
+ assertTrue("single delta should reference v1", deltas[0].getObjectId() == v2.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.CREATED));
+ assertTrue("single delta should reference v2", deltas[1].getObjectId() == v1.getObjectId());
+ assertTrue("delta status must be modified", deltas[1].getState().equals(State.CREATED));
+ assertTrue("single delta should reference kunde", deltas[2].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[2].getState().equals(State.MODIFIED));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified7() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only one transaction delta", deltas.length == 1);
+ assertTrue("single delta should reference kunde", deltas[0].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified8() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ objectTransaction.setCleanModus(false);
+ kunde.addVertrag(v2);
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only two transaction delta", deltas.length == 2);
+ assertTrue("single delta should reference kunde", deltas[0].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ assertTrue("single delta should reference v2", deltas[1].getObjectId() == v2.getObjectId());
+ assertTrue("delta status must be modified", deltas[1].getState().equals(State.CLEAN));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified9() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ objectTransaction.setCleanModus(false);
+ kunde.addVertrag(v1);
+ kunde.addVertrag(v2);
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only three transaction delta", deltas.length == 3);
+ assertTrue("single delta should reference kunde", deltas[0].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ assertTrue("single delta should reference v1", deltas[1].getObjectId() == v1.getObjectId());
+ assertTrue("delta status must be modified", deltas[1].getState().equals(State.CLEAN));
+ assertTrue("single delta should reference v2", deltas[2].getObjectId() == v2.getObjectId());
+ assertTrue("delta status must be modified", deltas[2].getState().equals(State.CLEAN));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified10() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Vertrag v1 = new Vertrag("123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only two transaction delta", deltas.length == 2);
+ assertTrue("single delta should reference v1", deltas[0].getObjectId() == v2.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ assertTrue("single delta should reference adresse", deltas[1].getObjectId() == v1.getObjectId());
+ assertTrue("delta status must be modified", deltas[1].getState() == State.MODIFIED);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified11() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only one transaction delta", deltas.length == 1);
+ assertTrue("single delta should reference kunde", deltas[0].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified12() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ extract.addCleanTransactedObject(v1);
+ TransactionDelta[] deltas = extract.getDeltas();
+ assertTrue("should be only one transaction delta", deltas.length == 2);
+ assertTrue("single delta should reference kunde", deltas[0].getObjectId() == kunde.getObjectId());
+ assertTrue("delta status must be modified", deltas[0].getState().equals(State.MODIFIED));
+ assertTrue("single delta should reference kunde", deltas[1].getObjectId() == v1.getObjectId());
+ assertTrue("delta status must be modified", deltas[1].getState().equals(State.CLEAN));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testExportModified13() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+ try {
+ extract.addCleanTransactedObject(kunde);
+ fail();
+ } catch (AssertionFailedException e) {
+ // ok(); expected exception TODO check if we should add that to
+ // RienaTestCase
+ }
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testImportModified1() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction2.register(kunde);
+ objectTransaction2.importOnlyModifedObjectsFromExtract(extract);
+ assertTrue("kunde must be registered", objectTransaction2.isRegistered(kunde));
+ assertTrue("v1 must not be registered", (!objectTransaction2.isRegistered(v1)));
+ assertTrue("v2 must not be registered", (!objectTransaction2.isRegistered(v2)));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testImportModified2() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction2.register(kunde);
+ objectTransaction2.register(v2);
+ objectTransaction2.importOnlyModifedObjectsFromExtract(extract);
+ assertTrue("kunde must be registered", objectTransaction2.isRegistered(kunde));
+ assertTrue("v1 must not be registered", (!objectTransaction2.isRegistered(v1)));
+ assertTrue("v2 must be registered", objectTransaction2.isRegistered(v2));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testImportModified3() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ kunde.addVertrag(v2);
+ objectTransaction.setCleanModus(false);
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction2.register(kunde);
+ objectTransaction2.register(v2);
+ objectTransaction2.register(v1);
+ objectTransaction2.importOnlyModifedObjectsFromExtract(extract);
+ assertTrue("kunde must be registered", objectTransaction2.isRegistered(kunde));
+ assertTrue("v1 must be registered", objectTransaction2.isRegistered(v1));
+ assertTrue("v2 must be registered", objectTransaction2.isRegistered(v2));
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testImportModified4() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ objectTransaction.setCleanModus(false);
+ kunde.addVertrag(v2);
+
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction2.register(kunde);
+ try {
+ objectTransaction2.importOnlyModifedObjectsFromExtract(extract);
+ fail();
+ } catch (InvalidTransactionFailure e) {
+ // ok(); expected behaviour TODO
+ }
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testImportModified5() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+
+ Vertrag v1 = new Vertrag("123");
+ v1.setVertragsBeschreibung("vertrag nummer 123");
+ kunde.addVertrag(v1);
+ Vertrag v2 = new Vertrag("456");
+ v2.setVertragsBeschreibung("vertrag nummer 456");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+ kunde.addVertrag(v2);
+ Addresse adresse = new Addresse(true);
+ objectTransaction.setCleanModus(false);
+ kunde.setAddresse(adresse);
+
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction objectTransaction2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction2.register(kunde);
+ try {
+ objectTransaction2.importOnlyModifedObjectsFromExtract(extract);
+ fail();
+ } catch (InvalidTransactionFailure e) {
+ // ok(); expected behaviour TODO
+ }
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testCheckNullValue1() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ kunde.setVorname("john");
+ kunde.setNachname("Miller");
+
+ Addresse adresse = new Addresse(true);
+ kunde.setAddresse(adresse);
+ objectTransaction.setCleanModus(false);
+
+ kunde.setAddresse(null);
+ assertTrue("adresse must be null", kunde.getAddresse() == null);
+ kunde.setVorname(null);
+ assertTrue("vorname must be null", kunde.getVorname() == null);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddDeleteImportExport() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ objectTransaction.registerAsDeleted(kunde);
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ ot2.importExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddDeleteImportExport2() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ objectTransaction.registerAsDeleted(kunde);
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ ot2.importExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddDeleteImportExport3() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ objectTransaction.registerAsDeleted(kunde);
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ ot2.importOnlyModifedObjectsFromExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddDeleteImportExport4() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ Vertrag v1 = new Vertrag("11");
+ Vertrag v2 = new Vertrag("12");
+ kunde.addVertrag(v1);
+ kunde.addVertrag(v2);
+ objectTransaction.registerAsDeleted(kunde);
+ objectTransaction.registerAsDeleted(v1);
+ objectTransaction.registerAsDeleted(v2);
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ ot2.importOnlyModifedObjectsFromExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddRemoveImportExportWithNewObjects() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ Addresse adresse = new Addresse(true);
+ kunde.setAddresse(adresse);
+ kunde.setAddresse(null);
+ objectTransaction.registerAsDeleted(adresse);
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ new Kunde("4711");
+ ot2.importExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddRemoveImportExportWithExistingObjects() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ objectTransaction.setCleanModus(false);
+ Addresse adresse = new Addresse(true);
+ kunde.setAddresse(adresse);
+ kunde.setAddresse(null);
+ objectTransaction.registerAsDeleted(adresse);
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ new Kunde("4711");
+ ot2.importExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddRemoveImportExportWithExistingObjectsOneToNRelation() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ objectTransaction.setCleanModus(true);
+
+ Kunde kunde = new Kunde("4711");
+ objectTransaction.setCleanModus(false);
+ Vertrag v1 = new Vertrag("11");
+ kunde.addVertrag(v1);
+ kunde.removeVertrag(v1);
+ objectTransaction.registerAsDeleted(v1);
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ ot2.setCleanModus(true);
+ new Kunde("4711");
+ ot2.setCleanModus(false);
+ ot2.importExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testAddRemoveImportExportWithNewObjectsOneToNRelation() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ Kunde kunde = new Kunde("4711");
+ Vertrag v1 = new Vertrag("11");
+ kunde.addVertrag(v1);
+ kunde.removeVertrag(v1);
+ objectTransaction.registerAsDeleted(v1);
+ objectTransaction.registerAsDeleted(kunde);
+ IObjectTransactionExtract extract = objectTransaction.exportExtract();
+
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ ot2.importExtract(extract);
+ }
+
+ /**
+ * @throws Exception
+ */
+ public void testComplex() throws Exception {
+ // simulierter client
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setNachname("müller");
+ objectTransaction.setCleanModus(false);
+ objectTransaction.registerAsDeleted(kunde);
+ IObjectTransactionExtract extract = objectTransaction.exportOnlyModifedObjectsToExtract();
+
+ // simulierter server
+ IObjectTransaction ot2 = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+ ot2.setCleanModus(true);
+ new Kunde("4711");
+ ot2.setCleanModus(false);
+ ot2.importExtract(extract);
+ ot2.commitToObjects();
+ IObjectTransactionExtract extract2 = ot2.exportExtract();
+
+ // back to client
+ objectTransaction.commitToObjects();
+ objectTransaction.importExtract(extract2);
+ }
+
+ /**
+ * Tested ob SubSubTransaction gehen oder eine Exception erzeugen
+ *
+ * @throws Exception
+ */
+ public void testSubSubTransaction() throws Exception {
+ IObjectTransaction objectTransaction = ObjectTransactionFactoryAccessor.fetchObjectTransactionFactory()
+ .createObjectTransaction();
+
+ objectTransaction.setCleanModus(true);
+ Kunde kunde = new Kunde("4711");
+ kunde.setNachname("müller");
+ objectTransaction.setCleanModus(false);
+
+ IObjectTransaction subOT = objectTransaction.createSubObjectTransaction();
+ Vertrag v1 = new Vertrag("4711");
+ kunde.addVertrag(v1);
+
+ IObjectTransaction subSubOT = subOT.createSubObjectTransaction();
+ Vertrag v2 = new Vertrag("1015");
+ kunde.addVertrag(v2);
+
+ Kunde kunde2 = new Kunde("4712");
+ kunde2.setNachname("campo");
+
+ subSubOT.commit();
+ subOT.commit();
+ objectTransaction.commitToObjects();
+ kunde2.setNachname("Campo");
+ kunde.setNachname("Schramm");
+ v1.setVertragsBeschreibung("xxx");
+ v2.setVertragsBeschreibung("yyyy");
+
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/StateMachineTest.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/StateMachineTest.java
new file mode 100644
index 0000000..9fef161
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/StateMachineTest.java
@@ -0,0 +1,21 @@
+package org.eclipse.riena.objecttransaction.simple;
+
+import org.eclipse.riena.objecttransaction.state.State;
+import org.eclipse.riena.objecttransaction.state.StateMachine;
+import org.eclipse.riena.tests.RienaTestCase;
+
+/**
+ * TestCase that tests (a little) of the StateMachine
+ *
+ * @author Christian Campo
+ */
+public class StateMachineTest extends RienaTestCase {
+
+ /**
+ *
+ */
+ public void testSimpleStateMaschine() {
+ assertTrue("expect modified state", StateMachine.mergeStates(State.CLEAN, State.MODIFIED) == State.MODIFIED);
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Addresse.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Addresse.java
new file mode 100644
index 0000000..b15b6d7
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Addresse.java
@@ -0,0 +1,113 @@
+package org.eclipse.riena.objecttransaction.simple.value;
+
+import java.security.SecureRandom;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * Sample class for "UTAddresse"
+ *
+ * @author Christian Campo
+ */
+public class Addresse extends AbstractTransactedObject implements ITransactedObject {
+
+ private String plz;
+ private String ort;
+ private String strasse;
+ private static SecureRandom random = new SecureRandom();
+
+ @SuppressWarnings("unused")
+ private Addresse() {
+ super();
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Adresse with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param dummy
+ */
+ public Addresse( boolean dummy ) {
+ super( new GenericOID( "addresse", "primkey", Integer.valueOf( nextRandomInt() ) ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ }
+
+ /**
+ * @param primKey
+ */
+ public Addresse( Integer primKey ) {
+ super( new GenericOID( "addresse", "primkey", primKey ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ }
+
+ /**
+ * @return Returns the ort.
+ */
+ public String getOrt() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "ort", ort );
+ }
+
+ /**
+ * @param ort The ort to set.
+ */
+ public void setOrt( String ort ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.ort = ort;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "ort", ort );
+ }
+
+ /**
+ * @return Returns the plz.
+ */
+ public String getPlz() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "plz", plz );
+ }
+
+ /**
+ * @param plz The plz to set.
+ */
+ public void setPlz( String plz ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.plz = plz;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "plz", plz );
+ }
+
+ /**
+ * @return Returns the strasse.
+ */
+ public String getStrasse() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "strasse", strasse );
+ }
+
+ /**
+ * @param strasse The strasse to set.
+ */
+ public void setStrasse( String strasse ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.strasse = strasse;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "strasse", strasse );
+ }
+
+ private static int nextRandomInt() {
+ return random.nextInt();
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/GenericOID.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/GenericOID.java
new file mode 100644
index 0000000..7c96459
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/GenericOID.java
@@ -0,0 +1,74 @@
+package org.eclipse.riena.objecttransaction.simple.value;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.riena.objecttransaction.IObjectId;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class GenericOID implements IObjectId {
+ private String type;
+ private String primName;
+ private Object primValue;
+
+ /**
+ * @param type
+ * @param primName
+ * @param primValue
+ */
+ public GenericOID( String type, String primName, Object primValue ) {
+ super();
+ this.type = type;
+ this.primName = primName;
+ this.primValue = primValue;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getType()
+ */
+ public String getType() {
+ return type;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#getProperties()
+ */
+ protected Map<String,Object> getProperties() {
+ HashMap<String,Object> map = new HashMap<String,Object>();
+ map.put( primName, primValue );
+ return map;
+ }
+
+ /**
+ * @see de.compeople.scp.objecttransaction.IObjectId#equals(de.compeople.scp.objecttransaction.IObjectId)
+ */
+ public boolean equals( Object oid ) {
+ if ( oid instanceof GenericOID ) {
+ GenericOID gOID = (GenericOID) oid;
+ if ( gOID.type.equals( type ) && gOID.primName.equals( primName ) && gOID.primValue.equals( primValue ) ) {
+ return true;
+ }
+ }
+ return super.equals( oid );
+ }
+
+ public int hashCode() {
+ try {
+ if ( primValue instanceof Integer ) {
+ return ( (Integer) primValue ).intValue();
+ }
+ return Integer.parseInt( (String) primValue );
+ } catch ( NumberFormatException e ) {
+ return super.hashCode();
+ }
+ }
+
+ public String toString() {
+ return "type:" + type + " primName:" + primName + " primValue:" + primValue;
+ }
+
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Kunde.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Kunde.java
new file mode 100644
index 0000000..14064f1
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Kunde.java
@@ -0,0 +1,188 @@
+package org.eclipse.riena.objecttransaction.simple.value;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * Sample class for "Kunde"
+ *
+ * @author Christian Campo
+ */
+public class Kunde extends AbstractTransactedObject implements ITransactedObject {
+
+ private String vorname;
+ private String nachname;
+ private String kundennr;
+ private Addresse addresse;
+ private HashSet<Vertrag> vertraege;
+
+ /** constructor called by webservices only for clean objects * */
+ @SuppressWarnings("unused")
+ private Kunde() {
+ super();
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Kunde with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param kundennr
+ */
+ public Kunde( String kundennr ) {
+ super( new GenericOID( "kunde", "kundennrpk", kundennr ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ setKundennr( kundennr );
+ vertraege = new HashSet<Vertrag>();
+ }
+
+ /**
+ * @return Returns the kundennr.
+ */
+ public String getKundennr() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "kundennr", kundennr );
+ }
+
+ /**
+ * @param kundennr The kundennr to set.
+ */
+ public void setKundennr( String kundennr ) {
+ if ( ( (GenericOID) getObjectId() ).getProperties().get( "primkey" ) != null ) {
+ throw new UnsupportedOperationException( "cannot change kundennr (once it is set)" );
+ }
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.kundennr = kundennr;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "kundennr", kundennr );
+ }
+ }
+
+ /**
+ * @return Returns the nachname.
+ */
+ public String getNachname() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "nachname", nachname );
+ }
+
+ /**
+ * @param nachname The nachname to set.
+ */
+ public void setNachname( String nachname ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.nachname = nachname;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "nachname", nachname );
+ }
+ }
+
+ /**
+ * @return Returns the vorname.
+ */
+ public String getVorname() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vorname", vorname );
+ }
+
+ /**
+ * @param vorname The vorname to set.
+ */
+ public void setVorname( String vorname ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vorname = vorname;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vorname", vorname );
+ }
+ }
+
+ /**
+ * @return Returns the addresse.
+ */
+ public Addresse getAddresse() {
+ return (Addresse) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "addresse", addresse );
+ }
+
+ /**
+ * @param addresse The addresse to set.
+ */
+ public void setAddresse( Addresse addresse ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.addresse = addresse;
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "addresse", addresse );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void addVertrag( Vertrag vertrag ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.add( vertrag );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().addReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ */
+ public void removeVertrag( String vertragsNummer ) {
+ Vertrag tempVertrag = getVertrag( vertragsNummer );
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.remove( getVertrag( vertragsNummer ) );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().removeReference( this, "vertrag", tempVertrag );
+ }
+ }
+
+ /**
+ * @param vertrag
+ */
+ public void removeVertrag( Vertrag vertrag ) {
+ // changeEvent
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ vertraege.remove( vertrag );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().removeReference( this, "vertrag", vertrag );
+ }
+ }
+
+ /**
+ * @param vertragsNummer
+ * @return
+ */
+ public Vertrag getVertrag( String vertragsNummer ) {
+ Vertrag[] tempVertraege = listVertrag();
+ for ( int i = 0; i < tempVertraege.length; i++ ) {
+ if ( tempVertraege[i].getVertragsNummer().equals( vertragsNummer ) ) {
+ return tempVertraege[i];
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @return
+ */
+ public Vertrag[] listVertrag() {
+ Set<?> vertraegeSet = ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().listReference( this, "vertrag", vertraege );
+ if ( vertraegeSet.size() == 0 ) {
+ return new Vertrag[0];
+ }
+ return vertraegeSet.toArray( new Vertrag[vertraegeSet.size()] );
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Vertrag.java b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Vertrag.java
new file mode 100644
index 0000000..4455d61
--- /dev/null
+++ b/org.eclipse.riena.tests/src/org/eclipse/riena/objecttransaction/simple/value/Vertrag.java
@@ -0,0 +1,94 @@
+package org.eclipse.riena.objecttransaction.simple.value;
+
+import org.eclipse.riena.objecttransaction.AbstractTransactedObject;
+import org.eclipse.riena.objecttransaction.ITransactedObject;
+import org.eclipse.riena.objecttransaction.InvalidTransactionFailure;
+import org.eclipse.riena.objecttransaction.ObjectTransactionManagerAccessor;
+
+/**
+ * TODO Fehlender Klassen-Kommentar
+ *
+ * @author Christian Campo
+ */
+public class Vertrag extends AbstractTransactedObject implements ITransactedObject {
+
+ private String vertragsNummer;
+ private String vertragsBeschreibung;
+ private Long vertragsSumme;
+
+ @SuppressWarnings("unused")
+ private Vertrag() {
+ super();
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ throw new InvalidTransactionFailure( "cannot instantiate Vertrag with private method if not in clean state" );
+ }
+ }
+
+ /**
+ * @param vertragsnummer
+ */
+ public Vertrag( String vertragsnummer ) {
+ super( new GenericOID( "vertrag", "vertragsnr", vertragsnummer ), "1" );
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().register( this );
+ } else {
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().registerNew( this );
+ }
+ setVertragsNummer( vertragsnummer );
+ }
+
+ /**
+ * @return Returns the vertragsNummer.
+ */
+ public String getVertragsNummer() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @param vertragsNummer The vertragsNummer to set.
+ */
+ public void setVertragsNummer( String vertragsNummer ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsNummer = vertragsNummer;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsNummer", vertragsNummer );
+ }
+
+ /**
+ * @return Returns the vertragsBeschreibung.
+ */
+ public String getVertragsBeschreibung() {
+ return (String) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsBeschreibung",
+ vertragsBeschreibung );
+ }
+
+ /**
+ * @param vertragsBeschreibung The vertragsBeschreibung to set.
+ */
+ public void setVertragsBeschreibung( String vertragsBeschreibung ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsBeschreibung = vertragsBeschreibung;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsBeschreibung", vertragsBeschreibung );
+ }
+
+ /**
+ * @return Returns the vertragsSumme.
+ */
+ public Long getVertragsSumme() {
+ return (Long) ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().getReference( this, "vertragsSumme", vertragsSumme );
+ }
+
+ /**
+ * @param vertragsSumme The vertragsSumme to set.
+ */
+ public void setVertragsSumme( Long vertragsSumme ) {
+ if ( ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().isCleanModus() ) {
+ this.vertragsSumme = vertragsSumme;
+ }
+ ObjectTransactionManagerAccessor.fetchObjectTransactionManager().getCurrent().setReference( this, "vertragsSumme", vertragsSumme );
+
+ }
+} \ No newline at end of file