New Temporal Tests project
- uses specific JDK with agent configured
- 96/96 tests pass
diff --git a/.gitignore b/.gitignore
index f762257..319506c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,3 @@
/Temporal Entity Example/classes
-/Temporal Tests
\ No newline at end of file
+/Temporal Tests/classes
\ No newline at end of file
diff --git a/Temporal Tests/.classpath b/Temporal Tests/.classpath
new file mode 100644
index 0000000..5f77a93
--- /dev/null
+++ b/Temporal Tests/.classpath
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jdk1.6.0_31 (EclipseLink 2.3.1 Agent)"/>
+ <classpathentry combineaccessrules="false" kind="src" path="/Temporal Entity Example"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/EclipseLink 2.3.1"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+ <classpathentry kind="output" path="classes"/>
+</classpath>
diff --git a/Temporal Tests/.project b/Temporal Tests/.project
new file mode 100644
index 0000000..f9d677e
--- /dev/null
+++ b/Temporal Tests/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>Temporal Tests</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/Temporal Tests/.settings/org.eclipse.jdt.core.prefs b/Temporal Tests/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..8000cd6
--- /dev/null
+++ b/Temporal Tests/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/Temporal Tests/Temporal AllTests.launch b/Temporal Tests/Temporal AllTests.launch
new file mode 100644
index 0000000..f5008a0
--- /dev/null
+++ b/Temporal Tests/Temporal AllTests.launch
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">
+<stringAttribute key="bad_container_name" value="\Temporal Tests\run-configs"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/Temporal Tests/src/tests/AllTests.java"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="1"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.ui.favoriteGroups">
+<listEntry value="org.eclipse.debug.ui.launchGroup.debug"/>
+<listEntry value="org.eclipse.debug.ui.launchGroup.run"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value=""/>
+<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
+<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
+<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="tests.AllTests"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="Temporal Tests"/>
+</launchConfiguration>
diff --git a/Temporal Tests/src/tests/AllTests.java b/Temporal Tests/src/tests/AllTests.java
new file mode 100644
index 0000000..1f0a617
--- /dev/null
+++ b/Temporal Tests/src/tests/AllTests.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({ tests.internal.AllTests.class,
+ FullPersonWithEditions.class,
+ FuturePersonTests.class,
+ DeleteTests.class,
+ ProxyWrapperUpdateTests.class,
+ //ModifyCurrentTests.class})
+ //DeleteContinuityTests.class,
+ MultipleEditionQueries.class,
+ DuplicateInsertOnCreateMerge.class,
+ tests.editionsets.AllTests.class})
+public class AllTests {
+}
diff --git a/Temporal Tests/src/tests/BaseTestCase.java b/Temporal Tests/src/tests/BaseTestCase.java
new file mode 100644
index 0000000..0b79af1
--- /dev/null
+++ b/Temporal Tests/src/tests/BaseTestCase.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+
+import org.eclipse.persistence.jpa.JpaHelper;
+import org.eclipse.persistence.sessions.server.Server;
+import org.eclipse.persistence.tools.schemaframework.SchemaManager;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.rules.TestName;
+
+import temporal.TemporalEntityManager;
+import temporal.persistence.TemporalSchemaManager;
+
+/**
+ *
+ * @author dclarke
+ * @Since EclipseLink 2.3.1
+ */
+public abstract class BaseTestCase {
+
+ private static EntityManagerFactory emf;
+
+ private TemporalEntityManager entityManager;
+
+ @Rule
+ public TestName testName = new TestName();
+
+ public EntityManagerFactory getEMF() {
+ if (emf == null) {
+ emf = Persistence.createEntityManagerFactory("example");
+
+ Server session = JpaHelper.getServerSession(emf);
+
+ SchemaManager sm = new TemporalSchemaManager(session);
+ // Cache SchemaManager so it can be verified in test cases
+ session.setProperty(SchemaManager.class.getName(), sm);
+ sm.replaceDefaultTables(false, true);
+ sm.replaceSequences();
+
+ // Populate test case example instances
+ TemporalEntityManager em = TemporalEntityManager.getInstance(emf.createEntityManager());
+ em.getTransaction().begin();
+ populate(em);
+ em.getTransaction().commit();
+ em.close();
+ System.out.println("\n--- CREATE EMF & POPULATE DONE ---\n");
+
+ closeEntityManager();
+ }
+ return emf;
+ }
+
+ public TemporalEntityManager getEntityManager() {
+ return getEntityManager(null);
+ }
+
+ public TemporalEntityManager getEntityManager(Long effectiveTime) {
+ if (this.entityManager == null || !this.entityManager.isOpen()) {
+ TemporalEntityManager em = TemporalEntityManager.getInstance(getEMF().createEntityManager());
+ em.setEffectiveTime(effectiveTime);
+ this.entityManager = em;
+ }
+ return this.entityManager;
+ }
+
+ public void populate(TemporalEntityManager em) {
+ }
+
+ @AfterClass
+ public static void closeEMF() {
+ if (emf != null && emf.isOpen()) {
+ emf.close();
+ }
+ emf = null;
+ }
+
+ @Before
+ public void logTestName() {
+ System.out.println("\n\nTEST: " + testName.getMethodName() + "\n");
+ }
+
+ /**
+ * After each test case ensure the {@link EntityManager} is closed and if a
+ * transaction is active roll it back first.
+ */
+ @After
+ public void closeEntityManager() {
+ if (this.entityManager != null && this.entityManager.isOpen()) {
+ if (this.entityManager.getTransaction().isActive()) {
+ this.entityManager.getTransaction().rollback();
+ }
+ this.entityManager.close();
+ }
+ this.entityManager = null;
+ if (emf != null && emf.isOpen()) {
+ JpaHelper.getServerSession(emf).getIdentityMapAccessor().initializeAllIdentityMaps();
+ }
+
+ }
+
+}
diff --git a/Temporal Tests/src/tests/CustomerScenarios.java b/Temporal Tests/src/tests/CustomerScenarios.java
new file mode 100644
index 0000000..ccf46f0
--- /dev/null
+++ b/Temporal Tests/src/tests/CustomerScenarios.java
@@ -0,0 +1,186 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ * dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+
+package tests;
+
+import static example.PersonModelExample.T1;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T3;
+import static example.PersonModelExample.T4;
+
+import java.util.List;
+
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.Phone;
+import model.entities.AddressEntity;
+import model.entities.PhoneEntity;
+
+import org.junit.Test;
+
+import temporal.TemporalEntityManager;
+
+/**
+ * TODO
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class CustomerScenarios extends BaseTestCase {
+
+ @Test
+ public void createPersonAndAddressNow() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+
+ Person p = em.newEntity(Person.class);
+ p.setName("Now");
+ Address a = new AddressEntity("now", "now", "now");
+ p.setAddress(a);
+
+ em.persist(p);
+
+ em.getTransaction().commit();
+ em.clear();
+ em.getEntityManagerFactory().getCache().evictAll();
+ System.out.println("\nREAD:\n");
+
+ Person readP = em.find(Person.class, p.getId());
+
+ Assert.assertEquals(p.getName(), readP.getName());
+ Assert.assertEquals("now", readP.getAddress().getCity());
+ }
+
+ @Test
+ public void createPersonAndAddressFuture() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ em.getTransaction().begin();
+
+ Person p = em.newEntity( Person.class);
+ p.setName("Future");
+ Address a = em.newEntity( Address.class);
+ a.setCity("t2");
+ p.setAddress(a);
+
+ em.persist(p);
+
+ em.getTransaction().commit();
+ em.clear();
+ em.getEntityManagerFactory().getCache().evictAll();
+ System.out.println("\nREAD:\n");
+
+ Person readP = em.createQuery("SELECT p FROM Person p WHERE p.cid = " + p.getId(), Person.class).getSingleResult();
+
+ Assert.assertEquals(p.getName(), readP.getName());
+ Assert.assertEquals("t2", readP.getAddress().getCity());
+ }
+
+ @Test
+ public void createPersonInFutureWithOldAddress() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+ Address a = new AddressEntity("now", "now", "now");
+ em.persist(a);
+ em.flush();
+
+ em.setEffectiveTime(T2);
+
+ Person p = em.newEntity( Person.class);
+ p.setName("Future");
+ p.setAddress(a);
+
+ em.persist(p);
+
+ em.getTransaction().commit();
+ em.clear();
+ em.getEntityManagerFactory().getCache().evictAll();
+ System.out.println("\nREAD:\n");
+
+ em.setEffectiveTime(T1);
+
+ List<Person> results = em.createQuery("SELECT p FROM Person p WHERE p.address.city = 'now'", Person.class).getResultList();
+ Assert.assertTrue(results.isEmpty());
+
+ em.setEffectiveTime(T2);
+ Person readP = em.createQuery("SELECT p FROM Person p JOIN FETCH p.address WHERE p.address.city = 'now'", Person.class).getSingleResult();
+
+ Assert.assertNotNull(readP);
+ Assert.assertNotNull(readP.getAddress());
+ Assert.assertEquals(p.getName(), readP.getName());
+ Assert.assertEquals("now", readP.getAddress().getCity());
+ }
+
+ @Test
+ public void createPersonInFutureWithOldPhone() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.getTransaction().begin();
+ Phone phone_BOT = new PhoneEntity("work", "000-000-0000");
+ em.persist(phone_BOT);
+ em.flush();
+
+ em.setEffectiveTime(T2);
+
+ Person p = em.newEntity( Person.class);
+ p.setName("Future");
+ em.persist(p);
+
+ em.setEffectiveTime(T3);
+
+ Phone phone_T3 = em.newEdition(phone_BOT);
+ phone_T3.setNumber("333-333-3333");
+ p.addPhone(phone_T3);
+ em.persist(phone_T3);
+ em.getTransaction().commit();
+ em.clear();
+ em.getEntityManagerFactory().getCache().evictAll();
+
+ System.out.println("\nREAD:\n");
+
+ em.setEffectiveTime(T1);
+ Person readP_T1 = em.find(Person.class, p.getId());
+ System.out.println("Read Person @ T1: " + readP_T1);
+
+ em.clear();
+ em.getEntityManagerFactory().getCache().evictAll();
+
+ em.setEffectiveTime(T2);
+ Person readP_T2 = em.find(Person.class, p.getId());
+ System.out.println("Read Person @ T2: " + readP_T2 + " Phone: " + readP_T2.getPhone("work"));
+ Phone readPhone_T2 = em.find(Phone.class, phone_BOT.getId());
+ System.out.println("Read Phone @ T2: " + readPhone_T2);
+
+ em.clear();
+ em.getEntityManagerFactory().getCache().evictAll();
+
+ em.setEffectiveTime(T3);
+ Person readP_T3 = em.find(Person.class, p.getId());
+ System.out.println("Read Person @ T3: " + readP_T3 + " Phone: " + readP_T3.getPhone("work"));
+
+ em.clear();
+ em.getEntityManagerFactory().getCache().evictAll();
+
+ em.setEffectiveTime(T4);
+ Person readP_T4 = em.find(Person.class, p.getId());
+ System.out.println("Read Person @ T4: " + readP_T4 + " Phone: " + readP_T4.getPhone("work"));
+
+ }
+
+ @Override
+ public void populate(TemporalEntityManager em) {
+ }
+
+}
diff --git a/Temporal Tests/src/tests/DeleteContinuityTests.java b/Temporal Tests/src/tests/DeleteContinuityTests.java
new file mode 100644
index 0000000..d5034ce
--- /dev/null
+++ b/Temporal Tests/src/tests/DeleteContinuityTests.java
@@ -0,0 +1,90 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+import model.Address;
+import model.Person;
+import model.Phone;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import temporal.TemporalEntityManager;
+import example.PersonModelExample;
+
+/**
+ * TODO
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class DeleteContinuityTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void test() {
+ getSample();
+ Assert.fail("NOT YET IMPLEMENTED");
+ }
+
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nFullPersonWithEditions.populate:START");
+
+ example.populateHobbies(em);
+ em.persist(example.fullPerson);
+ em.flush();
+
+ System.out.println("\n> Create T2 Edition");
+ em.setEffectiveTime(T2);
+
+ Person fpEdition = em.find(Person.class, example.fullPerson.getId());
+ Person personEditionT2 = em.newEdition(fpEdition);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(example.fullPerson.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(example.fullPerson.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ em.persist(personEditionT2.addHobby(example.hobbies.get("golf"), T2));
+ em.flush();
+
+ System.out.println("\n> Create T4 Edition");
+ em.setEffectiveTime(T4);
+
+ Person personEditionT4 = em.newEdition(personEditionT2);
+ personEditionT4.setName("James");
+ Address aT4 = em.newEdition(aT2);
+ aT4.setCity("San Francisco");
+ aT4.setState("CA");
+ personEditionT4.setAddress(aT4);
+ Phone pT4 = em.newEdition(pT2);
+ pT4.setNumber("444-444-4444");
+ personEditionT4.addPhone(pT4);
+ personEditionT4.removeHobby(example.hobbies.get(GOLF), T4, T4);
+ personEditionT4.addHobby(example.hobbies.get("running"), T4);
+ personEditionT4.addHobby(example.hobbies.get("skiing"), T4);
+ em.flush();
+
+ System.out.println("\nFullPersonWithEditions.populate::DONE");
+ }
+
+}
diff --git a/Temporal Tests/src/tests/DeleteTests.java b/Temporal Tests/src/tests/DeleteTests.java
new file mode 100644
index 0000000..51c0f43
--- /dev/null
+++ b/Temporal Tests/src/tests/DeleteTests.java
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.T1;
+
+import javax.persistence.EntityManager;
+
+import model.Person;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+import temporal.EditionWrapperHelper;
+import temporal.TemporalEntityManager;
+import example.PersonModelExample;
+
+/**
+ * Tests to verify delete use cases. In this temporal usage delete is equivalent
+ * to setting the end date to a point in time in the future. Then any queries
+ * after that time result in no edition being returned.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class DeleteTests extends BaseTestCase {
+
+ private static PersonModelExample examples = new PersonModelExample();
+
+ @Test
+ public void deleteCurrentSimple() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+ em.persist(examples.simplePerson);
+ em.getTransaction().commit();
+ closeEntityManager();
+
+ em = getEntityManager();
+
+ Assert.assertEquals(1, em.createQuery("SELECT COUNT(p) FROM Person p", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(a) FROM Address a", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(p) FROM Phone p", Number.class).getSingleResult().intValue());
+ Person p = em.createQuery("SELECT p FROM Person p", Person.class).getSingleResult();
+
+ Assert.assertNotNull(p);
+
+ em.getTransaction().begin();
+ em.remove(p);
+ em.getTransaction().commit();
+
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(p) FROM Person p", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(a) FROM Address a", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(p) FROM Phone p", Number.class).getSingleResult().intValue());
+ }
+
+ @Test
+ public void deleteCurrentSimpleAtT1() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+ em.persist(examples.simplePerson);
+ em.getTransaction().commit();
+ closeEntityManager();
+
+ em = getEntityManager();
+
+ Assert.assertEquals(1, em.createQuery("SELECT COUNT(p) FROM Person p", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(a) FROM Address a", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(p) FROM Phone p", Number.class).getSingleResult().intValue());
+ Person p = em.createQuery("SELECT p FROM Person p", Person.class).getSingleResult();
+
+ Assert.assertNotNull(p);
+
+ em.getTransaction().begin();
+
+ Person pWrapper = EditionWrapperHelper.wrap(em, p);
+ pWrapper.getEffectivity().setEnd(T1);
+
+ em.getTransaction().commit();
+
+ Assert.assertEquals(1, em.createQuery("SELECT COUNT(p) FROM Person p", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(a) FROM Address a", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(p) FROM Phone p", Number.class).getSingleResult().intValue());
+
+ em.setEffectiveTime( T1);
+
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(p) FROM Person p", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(a) FROM Address a", Number.class).getSingleResult().intValue());
+ Assert.assertEquals(0, em.createQuery("SELECT COUNT(p) FROM Phone p", Number.class).getSingleResult().intValue());
+ }
+
+ @After
+ public void deleteAll() {
+ EntityManager em = TemporalEntityManager.getInstance(getEMF().createEntityManager());
+ em.getTransaction().begin();
+ em.createQuery("DELETE FROM PersonHobby ph").executeUpdate();
+ em.createQuery("DELETE FROM Hobby h").executeUpdate();
+ em.createNativeQuery("DELETE FROM TADDRESS").executeUpdate();
+ em.createNativeQuery("DELETE FROM TPERSON_NNAMES").executeUpdate();
+ em.createNativeQuery("UPDATE TPERSON SET CID = NULL").executeUpdate();
+ em.createNativeQuery("DELETE FROM TPERSON").executeUpdate();
+ em.createNativeQuery("DELETE FROM TPHONE").executeUpdate();
+ em.getTransaction().commit();
+ em.close();
+ }
+}
diff --git a/Temporal Tests/src/tests/DuplicateInsertOnCreateMerge.java b/Temporal Tests/src/tests/DuplicateInsertOnCreateMerge.java
new file mode 100644
index 0000000..1e4ee41
--- /dev/null
+++ b/Temporal Tests/src/tests/DuplicateInsertOnCreateMerge.java
@@ -0,0 +1,131 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.RUN;
+import static example.PersonModelExample.SKI;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.Phone;
+
+import org.junit.Test;
+
+import temporal.TemporalEntityManager;
+import example.PersonModelExample;
+
+/**
+ * Test cases dealing with potential duplicate insert scenarios
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class DuplicateInsertOnCreateMerge extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nFullPersonWithEditions.populate:START");
+
+ example.populateHobbies(em);
+ em.persist(getSample());
+ em.flush();
+
+ System.out.println("\nFullPersonWithEditions.populate::DONE");
+ }
+
+ public Person createPersonEditionAtT2(TemporalEntityManager em) {
+ em.setEffectiveTime(T2);
+
+ Person fpEdition = em.find(Person.class, getSample().getId());
+ Person personEditionT2 = fpEdition;
+
+ if (personEditionT2.getEffectivity().getStart() != T2) {
+ personEditionT2 = em.newEdition(fpEdition);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(fpEdition.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone originalPhone = fpEdition.getPhone("Home");
+
+ Phone pT2 = em.newEdition(originalPhone);
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ em.persist(personEditionT2.addHobby(example.hobbies.get(GOLF), T2));
+ } else {
+ personEditionT2.getAddress();
+ personEditionT2.getPhones().size();
+ }
+ return personEditionT2;
+ }
+
+ @Test
+ public void createPersonAtT2AndMerge() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+ em.getTransaction().begin();
+
+ Person personEditionT2 = createPersonEditionAtT2(em);
+
+ Assert.assertNotNull(personEditionT2);
+ Assert.assertEquals(T2, personEditionT2.getEffectivity().getStart());
+ Assert.assertNotNull(personEditionT2.getPhone("Home"));
+
+ em.merge(personEditionT2);
+
+ em.getTransaction().commit();
+
+ em.clear();
+ personEditionT2 = em.find(Person.class, getSample().getId());
+
+ Assert.assertNotNull(personEditionT2);
+ Assert.assertEquals(T2, personEditionT2.getEffectivity().getStart());
+ Phone pT2 = personEditionT2.getPhone("Home");
+ Assert.assertNotNull(pT2);
+ }
+
+ @Test
+ public void createPersonAtT4AndMerge() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+ Person personEditionT2 = createPersonEditionAtT2(em);
+ Assert.assertNotNull(personEditionT2);
+ Assert.assertEquals(T2, personEditionT2.getEffectivity().getStart());
+ Assert.assertNotNull(personEditionT2.getPhone("Home"));
+
+ em.setEffectiveTime(T4);
+
+ Person personEditionT4 = em.newEdition(personEditionT2);
+ personEditionT4.setName("James");
+ Address aT4 = em.newEdition(personEditionT4.getAddress());
+ aT4.setCity("San Francisco");
+ aT4.setState("CA");
+ personEditionT4.setAddress(aT4);
+ Phone pT4 = em.newEdition(personEditionT4.getPhone("Home"));
+ pT4.setNumber("444-444-4444");
+ personEditionT4.addPhone(pT4);
+ personEditionT4.removeHobby(example.hobbies.get(GOLF), T4, T4);
+ em.persist(personEditionT4.addHobby(example.hobbies.get(RUN), T4));
+ em.persist(personEditionT4.addHobby(example.hobbies.get(SKI), T4));
+
+ em.merge(personEditionT4);
+ em.getTransaction().commit();
+ }
+}
diff --git a/Temporal Tests/src/tests/FullPersonWithEditions.java b/Temporal Tests/src/tests/FullPersonWithEditions.java
new file mode 100644
index 0000000..79ddb2b
--- /dev/null
+++ b/Temporal Tests/src/tests/FullPersonWithEditions.java
@@ -0,0 +1,801 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.RUN;
+import static example.PersonModelExample.SKI;
+import static example.PersonModelExample.T1;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T3;
+import static example.PersonModelExample.T4;
+import static example.PersonModelExample.T5;
+import static temporal.Effectivity.BOT;
+import static temporal.Effectivity.EOT;
+
+import java.sql.Date;
+import java.util.List;
+
+import javax.persistence.NoResultException;
+import javax.persistence.TypedQuery;
+
+import model.Address;
+import model.Person;
+import model.Phone;
+import model.entities.PhoneEntity;
+
+import org.eclipse.persistence.jpa.JpaHelper;
+import org.eclipse.persistence.sessions.CopyGroup;
+import org.junit.Assert;
+import org.junit.Test;
+
+import temporal.BaseEntity;
+import temporal.EditionSet;
+import temporal.TemporalEntityManager;
+import temporal.TemporalHelper;
+import example.PersonModelExample;
+
+/**
+ * This test case performs current and edition queries on a simple
+ * Person-Address-Phones model both illustrating and verifying query operations.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class FullPersonWithEditions extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @SuppressWarnings("deprecation")
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nFullPersonWithEditions.populate:START");
+
+ example.populateHobbies(em);
+ em.persist(example.fullPerson);
+ em.flush();
+
+ System.out.println("\n> Create T2 Edition");
+ em.setEffectiveTime(T2);
+
+ Person fpEdition = em.find(Person.class, example.fullPerson.getId());
+ Person personEditionT2 = em.newEdition(fpEdition);
+
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(example.fullPerson.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setDateOfBirth(new Date(75, 1, 5));
+
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(example.fullPerson.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ Phone pWT2 = em.newEntity(PhoneEntity.class);
+ pWT2.setType("Work");
+ pWT2.setNumber("333-333-3333");
+ personEditionT2.addPhone(pWT2);
+
+ em.persist(personEditionT2.addHobby(example.hobbies.get(GOLF), T2));
+
+ // Assert.assertEquals(personEditionT2.getPhones().size() - 1,
+ // fpEdition.getPhones().size());
+ // Assert.assertEquals(personEditionT2.getPersonHobbies().size() - 1,
+ // fpEdition.getPersonHobbies().size());
+
+ em.flush();
+
+ System.out.println("\n> Create T4 Edition");
+ em.setEffectiveTime(T4);
+
+ Person personEditionT4 = em.newEdition(personEditionT2);
+ personEditionT4.setName("James");
+ Address aT4 = em.newEdition(aT2);
+ aT4.setCity("San Francisco");
+ aT4.setState("CA");
+ personEditionT4.setAddress(aT4);
+
+ Phone pT4 = em.newEdition(pT2);
+ pT4.setNumber("444-444-4444");
+ personEditionT4.addPhone(pT4);
+ pWT2.getEffectivity().setEnd(T4);
+ Phone pCT4 = em.newEntity(PhoneEntity.class);
+ pCT4.setType("Cell");
+ pCT4.setNumber("555-555-55555");
+ personEditionT4.addPhone(pCT4);
+
+ personEditionT4.getPersonHobbies().get(GOLF).getEffectivity().setEnd(T4);
+
+ em.persist(personEditionT4.addHobby(example.hobbies.get(RUN), T4));
+ em.persist(personEditionT4.addHobby(example.hobbies.get(SKI), T4));
+
+ em.flush();
+
+ System.out.println("\nFullPersonWithEditions.populate::DONE");
+ }
+
+ @Test
+ public void queryAllCurrent() {
+ TemporalEntityManager em = getEntityManager();
+ List<Person> results = em.createQuery("SELECT p From Person p", Person.class).getResultList();
+
+ System.out.println("QUERY CURRENT:");
+ for (Person p : results) {
+ System.out.println("\t>" + p);
+ }
+
+ Assert.assertEquals(1, results.size());
+
+ Person currentperson = results.get(0);
+ Assert.assertSame(currentperson, currentperson.getContinuity());
+ Assert.assertEquals(getSample().getId(), currentperson.getId());
+ }
+
+ @Test
+ public void findCurrent() {
+ TemporalEntityManager em = getEntityManager();
+
+ Person current = em.find(Person.class, getSample().getId());
+
+ System.out.println("VERIFY CURRENT: " + current);
+
+ // Verify person
+ Assert.assertNotNull(current);
+ Assert.assertEquals(current, current.getContinuity());
+ Assert.assertEquals(getSample().getId(), current.getId());
+ Assert.assertEquals(getSample().getName(), current.getName());
+ Assert.assertTrue(current.getEffectivity().isCurrent());
+ Assert.assertFalse(current.getEffectivity().isFutureEdition());
+ Assert.assertEquals(current.getEffectivity().getStart(), BOT);
+ Assert.assertEquals(current.getEffectivity().getEnd(), T2);
+
+ // Address
+ Assert.assertNotNull(current.getAddress());
+ Assert.assertEquals(getSample().getAddress().getStreet(), current.getAddress().getStreet());
+ Assert.assertEquals(getSample().getAddress().getCity(), current.getAddress().getCity());
+ Assert.assertEquals(getSample().getAddress().getState(), current.getAddress().getState());
+ Assert.assertTrue(current.getAddress().getEffectivity().isCurrent());
+ Assert.assertFalse(current.getAddress().getEffectivity().isFutureEdition());
+ Assert.assertEquals(current.getAddress().getEffectivity().getStart(), BOT);
+ Assert.assertEquals(current.getAddress().getEffectivity().getEnd(), T2);
+
+ // Phone
+ Assert.assertEquals(1, current.getPhones().size());
+ Phone currentHome = current.getPhone("Home");
+ Assert.assertNotNull(currentHome);
+ Assert.assertEquals("111-111-1111", currentHome.getNumber());
+ Assert.assertSame(current, currentHome.getPerson());
+ }
+
+ @Test
+ public void queryAllCurrentJoinAddress() {
+ TemporalEntityManager em = getEntityManager();
+ List<Person> results = em.createQuery("SELECT p From Person p JOIN FETCH p.address", Person.class).getResultList();
+
+ System.out.println("QUERY CURRENT:");
+ for (Person p : results) {
+ System.out.println("\t>" + p);
+ }
+
+ Assert.assertEquals(1, results.size());
+
+ Person currentperson = results.get(0);
+ Assert.assertSame(currentperson, currentperson.getContinuity());
+ Assert.assertEquals(getSample().getId(), currentperson.getId());
+ }
+
+ @Test
+ public void querySampleCurrentPerson() {
+ TemporalEntityManager em = getEntityManager();
+
+ Person person = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+ Address address = person.getAddress();
+
+ Assert.assertNotNull(person);
+
+ System.out.println("FIND CURRENT: " + person);
+
+ Assert.assertEquals(getSample().getId(), person.getId());
+ Assert.assertSame(person, person.getContinuity());
+ Assert.assertNotNull(address);
+ Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());
+ }
+
+ @Test
+ public void querySampleCurrentPersonJoinAddress() {
+ TemporalEntityManager em = getEntityManager();
+
+ Person person = em.createQuery("SELECT p From Person p JOIN FETCH p.address WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+ Address address = person.getAddress();
+
+ Assert.assertNotNull(person);
+
+ System.out.println("FIND CURRENT: " + person);
+
+ Assert.assertEquals(getSample().getId(), person.getId());
+ Assert.assertEquals(person, person.getContinuity());
+ Assert.assertNotNull(address);
+ Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());
+ }
+
+ @Test
+ public void findSampleCurrentPerson() {
+ TemporalEntityManager em = getEntityManager();
+ Person person = em.find(Person.class, getSample().getId());
+
+ Assert.assertNotNull(person);
+
+ System.out.println("FIND CURRENT: " + person);
+
+ Assert.assertEquals(getSample().getId(), person.getId());
+ Assert.assertSame(person, person.getContinuity());
+ Assert.assertTrue(person.getEffectivity().isCurrent());
+ Assert.assertFalse(person.getEffectivity().isFutureEdition());
+ Assert.assertEquals(person.getEffectivity().getStart(), BOT);
+ Assert.assertEquals(person.getEffectivity().getEnd(), T2);
+
+ Assert.assertEquals(0, person.getPersonHobbies().size());
+
+ Assert.assertEquals(1, person.getPhones().size());
+
+ }
+
+ @Test
+ public void findFuturePersonEntityEditionT2() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ Person person = em.find(Person.class, getSample().getId());
+ Assert.assertNotNull(person);
+ System.out.println("FIND Future Edition: " + person);
+ Assert.assertEquals(1, person.getPersonHobbies().size());
+
+ Person continuity = person.getContinuity();
+
+ Assert.assertNotNull(continuity);
+ System.out.println("\tContinuity: " + continuity);
+ Assert.assertTrue("Not an edition entity", TemporalHelper.isEdition(em, person));
+ Assert.assertEquals(getSample().getId(), person.getContinuity().getId());
+
+ Assert.assertFalse(person.getEffectivity().isCurrent());
+ Assert.assertTrue(person.getEffectivity().isFutureEdition());
+ Assert.assertEquals(person.getEffectivity().getStart(), T2);
+ Assert.assertEquals(person.getEffectivity().getEnd(), T4);
+ Assert.assertNotSame(person, person.getContinuity());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtBOT() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(BOT);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ BOT: " + pEdition);
+
+ Assert.assertNotNull("No edition found at BOT", pEdition);
+ Assert.assertTrue(pEdition.getEffectivity().isCurrent());
+ Assert.assertFalse(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(BOT, pEdition.getEffectivity().getStart());
+ Assert.assertEquals(T2, pEdition.getEffectivity().getEnd());
+ Assert.assertNotNull("No Continuity found", pEdition.getContinuity());
+ Assert.assertEquals(0, pEdition.getPersonHobbies().size());
+
+ Address address = pEdition.getAddress();
+
+ Assert.assertNotNull(address);
+ Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());
+
+ Assert.assertEquals(1, pEdition.getPhones().size());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT1() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T1);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ T1: " + pEdition);
+
+ Assert.assertNotNull("No edition found at T1", pEdition);
+ Assert.assertTrue(pEdition.getEffectivity().isCurrent());
+ Assert.assertFalse(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(BOT, pEdition.getEffectivity().getStart());
+ Assert.assertEquals(T2, pEdition.getEffectivity().getEnd());
+ Assert.assertNotNull("No Continuity found", pEdition.getContinuity());
+
+ Assert.assertEquals(0, pEdition.getPersonHobbies().size());
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ Address address = pEdition.getAddress();
+
+ Assert.assertNotNull(address);
+ Assert.assertEquals(getSample().getAddress().getCity(), address.getCity());
+
+ Assert.assertEquals(1, pEdition.getPhones().size());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT2() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ T2: " + pEdition);
+
+ Assert.assertNotNull("No edition found at T2", pEdition);
+ Assert.assertFalse(pEdition.getEffectivity().isCurrent());
+ Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(T2, pEdition.getEffectivity().getStart());
+ Assert.assertEquals(T4, pEdition.getEffectivity().getEnd());
+ Assert.assertNotSame(pEdition, pEdition.getContinuity());
+
+ Assert.assertEquals(1, pEdition.getPersonHobbies().size());
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ Address address = pEdition.getAddress();
+
+ Assert.assertNotNull(address);
+ Assert.assertEquals("Toronto", address.getCity());
+
+ Assert.assertEquals(2, pEdition.getPhones().size());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT2JoinFetchAddress() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ Person pEdition = null;
+ try {
+ pEdition = em.createQuery("SELECT p From Person p JOIN FETCH p.address WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+ } catch (NoResultException e) {
+ Assert.fail("Join returned no result");
+ }
+ Address address = pEdition.getAddress();
+
+ System.out.println("QUERY EDITION @ T2: " + pEdition);
+ System.out.println("\t> " + address);
+
+ Assert.assertNotNull("No edition found", pEdition);
+ Assert.assertFalse(pEdition.getEffectivity().isCurrent());
+ Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(T2, pEdition.getEffectivity().getStart());
+ Assert.assertEquals(T4, pEdition.getEffectivity().getEnd());
+ Assert.assertNotNull("No Continuity found", pEdition.getContinuity());
+ Assert.assertNotNull(address);
+ Assert.assertEquals("Toronto", address.getCity());
+
+ Assert.assertEquals(1, pEdition.getPersonHobbies().size());
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ Assert.assertEquals(2, pEdition.getPhones().size());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT3() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T3);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ T3: " + pEdition);
+
+ Assert.assertNotNull("No edition found ", pEdition);
+ Assert.assertFalse(pEdition.getEffectivity().isCurrent());
+ Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(T2, pEdition.getEffectivity().getStart());
+ Assert.assertEquals(T4, pEdition.getEffectivity().getEnd());
+ Assert.assertNotSame(pEdition, pEdition.getContinuity());
+
+ Assert.assertEquals(1, pEdition.getPersonHobbies().size());
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ Address address = pEdition.getAddress();
+
+ Assert.assertNotNull(address);
+ Assert.assertEquals("Toronto", address.getCity());
+
+ Assert.assertEquals(2, pEdition.getPhones().size());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT4() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ T4: " + pEdition);
+
+ Assert.assertNotNull("No Person Edition Found", pEdition);
+ Assert.assertFalse(pEdition.getEffectivity().isCurrent());
+ Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
+ Assert.assertEquals(EOT, pEdition.getEffectivity().getEnd());
+ Assert.assertNotSame(pEdition, pEdition.getContinuity());
+
+ Assert.assertEquals(2, pEdition.getPersonHobbies().size());
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ Address address = pEdition.getAddress();
+
+ Assert.assertNotNull(address);
+
+ Assert.assertEquals(2, pEdition.getPhones().size());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT5() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T5);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ T5: " + pEdition);
+
+ Assert.assertNotNull("No edition found at T5", pEdition);
+ Assert.assertFalse(pEdition.getEffectivity().isCurrent());
+ Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
+ Assert.assertEquals(EOT, pEdition.getEffectivity().getEnd());
+ Assert.assertNotSame(pEdition, pEdition.getContinuity());
+ Assert.assertEquals(2, pEdition.getPersonHobbies().size());
+
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ Assert.assertEquals(2, pEdition.getPhones().size());
+ }
+
+ @Test
+ public void nativeQueryForAllEdition() {
+ TemporalEntityManager em = getEntityManager();
+
+ TypedQuery<Person> query = em.createNamedQuery("PersonEdition.all", Person.class);
+ query.setParameter("CID", getSample().getId());
+ List<Person> editions = query.getResultList();
+
+ Assert.assertFalse("No edition found", editions.isEmpty());
+
+ System.out.println("QUERY ALL EDITIONS:");
+ for (Person p : editions) {
+ System.out.println("\t" + p);
+ Assert.assertNotNull("No Continuity found", p.getContinuity());
+ }
+
+ Assert.assertEquals(3, editions.size());
+ }
+
+ // @Test
+ public void deleteAllAtT5() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T5);
+
+ Person p = em.find(Person.class, getSample().getId());
+
+ em.getTransaction().begin();
+
+ p.getEffectivity().setEnd(T5);
+ p.getAddress().getEffectivity().setEnd(T5);
+ for (Phone phone : p.getPhones().values()) {
+ phone.getEffectivity().setEnd(T5);
+ }
+
+ em.flush();
+
+ // TODO - validation
+ }
+
+ @Test
+ public void detachResultUsingCopyPolicy() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ TypedQuery<Person> query = em.createNamedQuery("PersonEdition.find", Person.class);
+ query.setParameter("ID", getSample().getId());
+
+ Person p = query.getSingleResult();
+
+ System.out.println("ORIGINAL: " + p + " HASHCODE: " + System.identityHashCode(p));
+ System.out.println("\t" + p.getAddress());
+
+ CopyGroup cg = new CopyGroup();
+ cg.cascadeAllParts();
+
+ Person pCopy = (Person) JpaHelper.getEntityManager(em).copy(p, cg);
+ System.out.println("COPY: " + pCopy + " HASHSCODE: " + System.identityHashCode(pCopy));
+ System.out.println("\t" + pCopy.getAddress());
+ }
+
+ @Test
+ public void modifyFutureEditionOfCurrentPersonAtT4() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ T4: " + pEdition);
+
+ Assert.assertNotNull("No Person Edition Found", pEdition);
+ Assert.assertFalse(pEdition.getEffectivity().isCurrent());
+ Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
+ Assert.assertNotSame(pEdition, pEdition.getContinuity());
+
+ Assert.assertEquals(2, pEdition.getPersonHobbies().size());
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ long currentVersion = pEdition.getVersion();
+
+ em.getTransaction().begin();
+ pEdition.setName(pEdition.getName().toUpperCase());
+ em.flush();
+
+ Assert.assertEquals(currentVersion + 1, pEdition.getVersion());
+ }
+
+ @Test
+ public void modifyFutureEditionOfCurrentPersonAtT4UsingMerge() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ Person pEdition = em.createQuery("SELECT p From Person p WHERE p.id = " + getSample().getId(), Person.class).getSingleResult();
+
+ System.out.println("QUERY EDITION @ T4: " + pEdition);
+
+ // Create new unregistered hobby and add.
+
+ Assert.assertNotNull("No Person Edition Found", pEdition);
+ Assert.assertFalse(pEdition.getEffectivity().isCurrent());
+ Assert.assertTrue(pEdition.getEffectivity().isFutureEdition());
+ Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
+ Assert.assertNotSame(pEdition, pEdition.getContinuity());
+
+ Assert.assertEquals(2, pEdition.getPersonHobbies().size());
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(SKI));
+ Assert.assertTrue(pEdition.getPersonHobbies().containsKey(RUN));
+ Assert.assertFalse(pEdition.getPersonHobbies().containsKey(GOLF));
+
+ long currentVersion = pEdition.getVersion();
+
+ em.getTransaction().begin();
+ pEdition.setName(pEdition.getName().toUpperCase());
+ em.flush();
+
+ Assert.assertEquals(currentVersion + 1, pEdition.getVersion());
+ }
+
+ /**
+ * Verify that the edition creation operation correctly copies values
+ * including mutable values and collections.
+ */
+ @Test
+ public void verifyCreateEditionCopying() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T5);
+ EditionSet es = em.getEditionSet();
+
+ Person pEdition = em.find(Person.class, getSample().getId());
+
+ Assert.assertNotNull(pEdition);
+ Assert.assertTrue(TemporalHelper.isEdition(em, pEdition));
+ Assert.assertEquals(T4, pEdition.getEffectivity().getStart());
+ Assert.assertNotNull(es);
+ Assert.assertTrue(es.getEntries().isEmpty());
+
+ Person pAtT5 = em.newEdition(pEdition);
+
+ Assert.assertNotNull(pAtT5);
+ Assert.assertTrue(TemporalHelper.isEdition(em, pEdition));
+ Assert.assertEquals(T5, pAtT5.getEffectivity().getStart());
+ Assert.assertFalse(es.getEntries().isEmpty());
+ Assert.assertEquals(1, es.getEntries().size());
+
+ // Verify collection/map cloning
+ Assert.assertNotSame(pEdition.getPhones(), pAtT5.getPhones());
+ Assert.assertNotSame(pEdition.getPersonHobbies(), pAtT5.getPersonHobbies());
+ Assert.assertNotSame(pEdition.getNicknames(), pAtT5.getNicknames());
+
+ // Mutable non-temporal values
+ Assert.assertSame(pEdition.getDateOfBirth(), pAtT5.getDateOfBirth());
+
+ // TODO: Validate mutable basic copying
+
+ }
+
+ @SuppressWarnings("deprecation")
+ @Test
+ public void testDateOfBirthNonTemporalStorage() {
+ TemporalEntityManager em = getEntityManager();
+
+ List<?> results = em.createNativeQuery("SELECT DATEOFBIRTH FROM TPERSON WHERE CID = 1 ORDER BY OID").getResultList();
+
+ Assert.assertNotNull(results);
+ Assert.assertEquals(3, results.size());
+ Assert.assertEquals(new Date(75, 1, 5), results.get(0));
+ Assert.assertNull(results.get(1));
+ Assert.assertNull(results.get(2));
+ }
+
+ /**
+ * Verify the query result and relationship to person
+ */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void queryCurrentHomePhone() {
+ TemporalEntityManager em = getEntityManager();
+
+ TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
+ Phone phone = query.getSingleResult();
+
+ Assert.assertNotNull(phone);
+ Assert.assertFalse(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
+ Assert.assertNotNull(phone.getContinuity());
+ Assert.assertEquals(phone, phone.getContinuity());
+ Assert.assertEquals(BOT, phone.getEffectivity().getStart());
+ Assert.assertEquals(T2, phone.getEffectivity().getEnd());
+
+ Assert.assertNotNull(phone.getPerson());
+ Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
+ }
+
+ /**
+ * Verify the query result and relationship to person
+ */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void queryHomePhoneAtBOT() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(BOT);
+
+ TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
+ Phone phone = query.getSingleResult();
+
+ Assert.assertNotNull(phone);
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
+ Assert.assertNotNull(phone.getContinuity());
+ Assert.assertEquals(BOT, phone.getEffectivity().getStart());
+ Assert.assertEquals(T2, phone.getEffectivity().getEnd());
+
+ Assert.assertNotNull(phone.getPerson());
+ Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
+ }
+
+ /**
+ * Verify the query result and relationship to person
+ */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void queryHomePhoneAtT1() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T1);
+
+ TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
+ Phone phone = query.getSingleResult();
+
+ Assert.assertNotNull(phone);
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
+ Assert.assertNotNull(phone.getContinuity());
+ Assert.assertEquals(BOT, phone.getEffectivity().getStart());
+ Assert.assertEquals(T2, phone.getEffectivity().getEnd());
+
+ Assert.assertNotNull(phone.getPerson());
+ Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
+ }
+
+ /**
+ * Verify the query result and relationship to person
+ */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void queryHomePhoneAtT2() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
+ Phone phone = query.getSingleResult();
+
+ Assert.assertNotNull(phone);
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
+ Assert.assertNotNull(phone.getContinuity());
+ Assert.assertEquals(T2, phone.getEffectivity().getStart());
+ Assert.assertEquals(T4, phone.getEffectivity().getEnd());
+
+ Assert.assertNotNull(phone.getPerson());
+ Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
+ }
+
+ /**
+ * Verify the query result and relationship to person
+ */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void queryHomePhoneAtT3() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T3);
+
+ TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
+ Phone phone = query.getSingleResult();
+
+ Assert.assertNotNull(phone);
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
+ Assert.assertNotNull(phone.getContinuity());
+ Assert.assertEquals(T2, phone.getEffectivity().getStart());
+ Assert.assertEquals(T4, phone.getEffectivity().getEnd());
+
+ Assert.assertNotNull(phone.getPerson());
+ Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
+ }
+
+ /**
+ * Verify the query result and relationship to person
+ */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void queryHomePhoneAtT4() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
+ Phone phone = query.getSingleResult();
+
+ Assert.assertNotNull(phone);
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
+ Assert.assertNotNull(phone.getContinuity());
+ Assert.assertEquals(T4, phone.getEffectivity().getStart());
+ Assert.assertEquals(EOT, phone.getEffectivity().getEnd());
+
+ Assert.assertNotNull(phone.getPerson());
+ Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
+ }
+
+ /**
+ * Verify the query result and relationship to person
+ */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void queryHomePhoneAtT5() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T5);
+
+ TypedQuery<Phone> query = em.createQuery("SELECT p FROM Phone p WHERE p.type = 'Home'", Phone.class);
+ Phone phone = query.getSingleResult();
+
+ Assert.assertNotNull(phone);
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class<BaseEntity>) phone.getClass()));
+ Assert.assertNotNull(phone.getContinuity());
+ Assert.assertEquals(T4, phone.getEffectivity().getStart());
+ Assert.assertEquals(EOT, phone.getEffectivity().getEnd());
+
+ Assert.assertNotNull(phone.getPerson());
+ Assert.assertEquals(phone.getEffectivity().getStart(), phone.getPerson().getEffectivity().getStart());
+ }
+}
diff --git a/Temporal Tests/src/tests/FuturePersonTests.java b/Temporal Tests/src/tests/FuturePersonTests.java
new file mode 100644
index 0000000..b590819
--- /dev/null
+++ b/Temporal Tests/src/tests/FuturePersonTests.java
@@ -0,0 +1,212 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.T1;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T3;
+import static example.PersonModelExample.T4;
+import static example.PersonModelExample.T5;
+import static example.PersonModelExample.T6;
+import static temporal.Effectivity.BOT;
+
+import java.util.List;
+
+import model.Person;
+import model.PersonHobby;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import temporal.TemporalEntityManager;
+import example.PersonModelExample;
+
+/**
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class FuturePersonTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.futurePerson;
+ }
+
+ @Override
+ public void populate(TemporalEntityManager em) {
+ example.populateHobbies(em);
+ for (PersonHobby ph : example.futurePerson.getPersonHobbies().values()) {
+ em.persist(ph);
+ }
+ em.persist(example.futurePerson);
+ }
+
+ @Test
+ public void queryAllCurrent() {
+ TemporalEntityManager em = getEntityManager();
+
+ List<Person> results = example.queryAllCurrent(em);
+
+ Assert.assertTrue(results.isEmpty());
+ }
+
+ @Test
+ public void queryPersonEditionAtBOT() {
+ TemporalEntityManager em = getEntityManager();
+ em.setProperty("EFF_TS", BOT);
+
+ List<Person> results = em.createQuery("SELECT p FROM Person p WHERE p.cid = " + getSample().getId(), Person.class).getResultList();
+
+ Assert.assertTrue("Editions found", results.isEmpty());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT1() {
+ TemporalEntityManager em = getEntityManager();
+ em.setProperty("EFF_TS", T1);
+
+ List<Person> results = em.createQuery("SELECT p FROM Person p WHERE p.cid = " + getSample().getId(), Person.class).getResultList();
+
+ Assert.assertTrue("Editions found", results.isEmpty());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT2() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ List<Person> results = em.createQuery("SELECT p FROM Person p WHERE p.cid = " + getSample().getId(), Person.class).getResultList();
+
+ System.out.println("QUERY EFFECTIVE @ T2:");
+ for (Person p : results) {
+ System.out.println("\t>" + p);
+ System.out.println("\t\t>" + p.getAddress());
+ System.out.println("\t\t>" + p.getPhones().values());
+ }
+
+ Assert.assertFalse("No Editions found", results.isEmpty());
+ Assert.assertEquals(1, results.size());
+
+ Person person = results.get(0);
+
+ Assert.assertSame(person, person.getContinuity());
+ Assert.assertFalse(person.getEffectivity().isCurrent());
+ Assert.assertTrue(person.getEffectivity().isFutureEdition());
+ Assert.assertEquals(getSample().getId(), person.getId());
+ Assert.assertEquals(getSample().getName(), person.getName());
+ Assert.assertNull(person.getAddress());
+ Assert.assertTrue(person.getPhones().isEmpty());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT3() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T3);
+
+ List<Person> results = em.createQuery("SELECT p FROM Person p WHERE p.cid = " + getSample().getId(), Person.class).getResultList();
+
+ System.out.println("QUERY EFFECTIVE @ T3:");
+ for (Person p : results) {
+ System.out.println("\t>" + p);
+ System.out.println("\t\t>" + p.getAddress());
+ System.out.println("\t\t>" + p.getPhones().values());
+ }
+
+ Assert.assertFalse("No Editions found", results.isEmpty());
+ Assert.assertEquals(1, results.size());
+
+ Person person = results.get(0);
+
+ Assert.assertSame(person, person.getContinuity());
+ Assert.assertFalse(person.getEffectivity().isCurrent());
+ Assert.assertTrue(person.getEffectivity().isFutureEdition());
+ Assert.assertEquals(getSample().getId(), person.getId());
+ Assert.assertEquals(getSample().getName(), person.getName());
+ Assert.assertNotNull(person.getAddress());
+ Assert.assertTrue(person.getPhones().isEmpty());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT4() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ List<Person> results = em.createQuery("SELECT p FROM Person p WHERE p.cid = " + getSample().getId(), Person.class).getResultList();
+
+ Assert.assertFalse("No PersonEdition Found", results.isEmpty());
+
+ System.out.println("QUERY EFFECTIVE @ T4:");
+ for (Person p : results) {
+ System.out.println("\t>" + p);
+ System.out.println("\t\t>" + p.getAddress());
+ System.out.println("\t\t>" + p.getPhones().values());
+ }
+
+ Assert.assertFalse("No Editions found", results.isEmpty());
+ Assert.assertEquals(1, results.size());
+
+ Person person = results.get(0);
+
+ Assert.assertSame(person, person.getContinuity());
+ Assert.assertFalse(person.getEffectivity().isCurrent());
+ Assert.assertTrue(person.getEffectivity().isFutureEdition());
+ Assert.assertEquals(getSample().getId(), person.getId());
+ Assert.assertEquals(getSample().getName(), person.getName());
+ Assert.assertNotNull(person.getAddress());
+ Assert.assertFalse(person.getPhones().isEmpty());
+ }
+
+ @Test
+ public void queryFutureEditionOfCurrentPersonAtT5() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T5);
+
+ List<Person> results = em.createQuery("SELECT p FROM Person p WHERE p.cid = " + getSample().getId(), Person.class).getResultList();
+
+ System.out.println("QUERY EFFECTIVE @ T5:");
+ for (Person p : results) {
+ System.out.println("\t>" + p);
+ System.out.println("\t\t>" + p.getAddress());
+ System.out.println("\t\t>" + p.getPhones().values());
+ }
+
+ Assert.assertFalse("No Editions found", results.isEmpty());
+ Assert.assertEquals(1, results.size());
+
+ Person person = results.get(0);
+
+ Assert.assertSame(person, person.getContinuity());
+ Assert.assertFalse(person.getEffectivity().isCurrent());
+ Assert.assertTrue(person.getEffectivity().isFutureEdition());
+ Assert.assertEquals(getSample().getId(), person.getId());
+ Assert.assertEquals(getSample().getName(), person.getName());
+ Assert.assertNotNull(person.getAddress());
+ Assert.assertFalse(person.getPhones().isEmpty());
+ }
+
+ @Test
+ public void verifyCreateNewEntityInFuture() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T6);
+
+ em.getTransaction().begin();
+
+ Person p = em.newEntity(Person.class);
+
+ Assert.assertNotNull(p);
+ Assert.assertNotNull(p.getEffectivity());
+
+ em.getTransaction().rollback();
+ }
+
+}
diff --git a/Temporal Tests/src/tests/ModifyCurrentTests.java b/Temporal Tests/src/tests/ModifyCurrentTests.java
new file mode 100644
index 0000000..a74559b
--- /dev/null
+++ b/Temporal Tests/src/tests/ModifyCurrentTests.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.RUN;
+import static example.PersonModelExample.SKI;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+import model.Address;
+import model.Person;
+import model.Phone;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import temporal.TemporalEntityManager;
+import example.PersonModelExample;
+
+/**
+ * Make changes to the current (continuity) require that all future editions
+ * which had the same value as the current be updated.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class ModifyCurrentTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void test() {
+ getSample();
+ Assert.fail("NOT YET IMPLEMENTED");
+ }
+
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nFullPersonWithEditions.populate:START");
+
+ example.populateHobbies(em);
+ em.persist(example.fullPerson);
+ em.flush();
+
+ System.out.println("\n> Create T2 Edition");
+ em.setEffectiveTime(T2);
+
+ Person fpEdition = em.find(Person.class, example.fullPerson.getId());
+ Person personEditionT2 = em.newEdition(fpEdition);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(example.fullPerson.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(example.fullPerson.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ em.persist(personEditionT2.addHobby(example.hobbies.get("golf"), T2));
+ em.flush();
+
+ System.out.println("\n> Create T4 Edition");
+ em.setEffectiveTime(T4);
+
+ Person personEditionT4 = em.newEdition(personEditionT2);
+ personEditionT4.setName("James");
+ Address aT4 = em.newEdition(aT2);
+ aT4.setCity("San Francisco");
+ aT4.setState("CA");
+ personEditionT4.setAddress(aT4);
+ Phone pT4 = em.newEdition(pT2);
+ pT4.setNumber("444-444-4444");
+ personEditionT4.addPhone(pT4);
+ personEditionT4.removeHobby(example.hobbies.get(GOLF), T4, T4);
+ em.persist(personEditionT4.addHobby(example.hobbies.get(RUN), T4));
+ em.persist(personEditionT4.addHobby(example.hobbies.get(SKI), T4));
+ em.flush();
+
+ System.out.println("\nFullPersonWithEditions.populate::DONE");
+ }
+
+}
diff --git a/Temporal Tests/src/tests/MultipleEditionQueries.java b/Temporal Tests/src/tests/MultipleEditionQueries.java
new file mode 100644
index 0000000..bef98d6
--- /dev/null
+++ b/Temporal Tests/src/tests/MultipleEditionQueries.java
@@ -0,0 +1,99 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.RUN;
+import static example.PersonModelExample.SKI;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+
+import java.util.List;
+
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.Phone;
+
+import org.junit.Test;
+
+import temporal.TemporalEntityManager;
+import example.PersonModelExample;
+
+/**
+ * TODO
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class MultipleEditionQueries extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void queryForAllPersonEditions() {
+ TemporalEntityManager em = getEntityManager();
+
+ List<Person> results = em.createQuery("SELECT p FROM PersonEditionView p ORDER BY p.effectivity.start", Person.class).getResultList();
+
+ Assert.assertNotNull(results);
+ Assert.assertEquals(3, results.size());
+ }
+
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nFullPersonWithEditions.populate:START");
+
+ example.populateHobbies(em);
+ em.persist(getSample());
+ em.flush();
+
+ System.out.println("\n> Create T2 Edition");
+ em.setEffectiveTime(T2);
+
+ Person fpEdition = em.find(Person.class, example.fullPerson.getId());
+ Person personEditionT2 = em.newEdition(fpEdition);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(example.fullPerson.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(example.fullPerson.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ em.persist(personEditionT2.addHobby(example.hobbies.get(GOLF), T2));
+ em.flush();
+
+ System.out.println("\n> Create T4 Edition");
+ em.setEffectiveTime(T4);
+
+ Person personEditionT4 = em.newEdition(personEditionT2);
+ personEditionT4.setName("James");
+ Address aT4 = em.newEdition(aT2);
+ aT4.setCity("San Francisco");
+ aT4.setState("CA");
+ personEditionT4.setAddress(aT4);
+ Phone pT4 = em.newEdition(pT2);
+ pT4.setNumber("444-444-4444");
+ personEditionT4.addPhone(pT4);
+ personEditionT4.removeHobby(example.hobbies.get(GOLF), T4, T4);
+ em.persist(personEditionT4.addHobby(example.hobbies.get(RUN), T4));
+ em.persist(personEditionT4.addHobby(example.hobbies.get(SKI), T4));
+ em.flush();
+
+ System.out.println("\nFullPersonWithEditions.populate::DONE");
+ }
+
+}
diff --git a/Temporal Tests/src/tests/ProxyWrapperUpdateTests.java b/Temporal Tests/src/tests/ProxyWrapperUpdateTests.java
new file mode 100644
index 0000000..0439fa5
--- /dev/null
+++ b/Temporal Tests/src/tests/ProxyWrapperUpdateTests.java
@@ -0,0 +1,165 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests;
+
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+
+import java.lang.reflect.Proxy;
+
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.Phone;
+import model.entities.AddressEntity;
+import model.entities.PersonEntity;
+import model.entities.PhoneEntity;
+
+import org.junit.Test;
+
+import temporal.EditionWrapperHelper;
+import temporal.TemporalEdition;
+import temporal.TemporalEntity;
+import temporal.TemporalEntityManager;
+import example.PersonModelExample;
+
+/**
+ * Tests that verify the update of editions
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class ProxyWrapperUpdateTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ @Test
+ public void createWrapperForCurrent() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(null);
+
+ try {
+ EditionWrapperHelper.wrap(em, new PersonEntity());
+ } catch (IllegalArgumentException e) {
+ return;
+ }
+ Assert.fail("IllegalArgumentException not thrown");
+ }
+
+ @Test
+ public void createWrapperForPersonEditionWithoutEffectiveTS() {
+ TemporalEntityManager em = getEntityManager();
+
+ try {
+ em.getTransaction().begin();
+ Person tempPerson = em.newEntity(Person.class);
+ em.persist(tempPerson);
+ em.flush();
+
+ EditionWrapperHelper.wrap(em, tempPerson);
+
+ } catch (IllegalArgumentException e) {
+ return;
+ }
+
+ Assert.fail("IllegalArgumentException expected");
+ }
+
+ @Test
+ public void createWrapperForPersonEdition() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ em.getTransaction().begin();
+ Person tempPerson = em.newEntity(Person.class);
+ em.persist(tempPerson);
+ em.flush();
+
+ TemporalEntity<Person> wrapper = EditionWrapperHelper.wrap(em, tempPerson);
+
+ Assert.assertNotNull(wrapper);
+ Assert.assertTrue(wrapper instanceof Person);
+ Assert.assertTrue(wrapper instanceof TemporalEdition);
+ }
+
+ @Test
+ public void createWrapperForAddressEdition() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ em.getTransaction().begin();
+ TemporalEntity<Address> wrapper = EditionWrapperHelper.wrap(em, em.newEntity(AddressEntity.class));
+
+ Assert.assertNotNull(wrapper);
+ Assert.assertTrue(wrapper instanceof Address);
+ Assert.assertTrue(wrapper instanceof TemporalEdition);
+
+ em.getTransaction().rollback();
+ }
+
+ @Test
+ public void createWrapperForPhoneEdition() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ em.getTransaction().begin();
+ TemporalEntity<Phone> wrapper = EditionWrapperHelper.wrap(em, em.newEntity(PhoneEntity.class));
+
+ Assert.assertNotNull(wrapper);
+ Assert.assertTrue(wrapper instanceof Phone);
+ Assert.assertTrue(wrapper instanceof TemporalEdition);
+ em.getTransaction().rollback();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void create2editionsUsingWrappers() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ Person editionAtT2 = em.find(Person.class, example.fullPerson.getId());
+
+ em.getTransaction().begin();
+ Person wrappedPerson = (Person) EditionWrapperHelper.wrap(em, editionAtT2);
+
+ Assert.assertTrue(Proxy.isProxyClass(wrappedPerson.getClass()));
+ Assert.assertTrue(Proxy.isProxyClass(wrappedPerson.getAddress().getClass()));
+ Assert.assertFalse(((TemporalEdition<Person>) wrappedPerson).hasChanges());
+
+ wrappedPerson.setName(editionAtT2.getName() + "@T2");
+
+ Assert.assertTrue(((TemporalEdition<Person>) wrappedPerson).hasChanges());
+
+ em.getTransaction().commit();
+ em.close();
+
+ em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ Person editionAtT4 = em.find(Person.class, example.fullPerson.getId());
+
+ em.getTransaction().begin();
+ wrappedPerson = (Person) EditionWrapperHelper.wrap(em, editionAtT4);
+
+ Assert.assertFalse(((TemporalEdition<Person>) wrappedPerson).hasChanges());
+
+ wrappedPerson.setName(editionAtT4.getName() + "@T4");
+
+ Assert.assertTrue(((TemporalEdition<Person>) wrappedPerson).hasChanges());
+
+ em.getTransaction().commit();
+ }
+
+ @Override
+ public void populate(TemporalEntityManager em) {
+ em.persist(example.fullPerson);
+ }
+}
diff --git a/Temporal Tests/src/tests/editionsets/AllTests.java b/Temporal Tests/src/tests/editionsets/AllTests.java
new file mode 100644
index 0000000..ed46d1d
--- /dev/null
+++ b/Temporal Tests/src/tests/editionsets/AllTests.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.editionsets;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({ EditionSetConfigTests.class,
+ CreateEditionSetTests.class,
+ ApplySimpleEditionSetTests.class,
+ MoveSingleEditionSetTests.class,
+ DeleteEditionSetTests.class,
+ PropagateChangesTests.class})
+public class AllTests {
+}
diff --git a/Temporal Tests/src/tests/editionsets/ApplySimpleEditionSetTests.java b/Temporal Tests/src/tests/editionsets/ApplySimpleEditionSetTests.java
new file mode 100644
index 0000000..3b8f3a4
--- /dev/null
+++ b/Temporal Tests/src/tests/editionsets/ApplySimpleEditionSetTests.java
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.editionsets;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.T2;
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.Phone;
+
+import org.junit.Test;
+
+import temporal.EditionSet;
+import temporal.EditionSetEntry;
+import temporal.EditionSetHelper;
+import temporal.TemporalEntityManager;
+import tests.BaseTestCase;
+import example.PersonModelExample;
+
+/**
+ * Tests applying a simple (no conflict) {@link EditionSet}
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class ApplySimpleEditionSetTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void verifyEditionSetAtT2() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.getTransaction().begin();
+
+ em.setEffectiveTime(T2);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+ Assert.assertEquals(T2, es.getEffective());
+ Assert.assertEquals(3, es.getEntries().size());
+
+ for (EditionSetEntry ese : es.getEntries()) {
+ Assert.assertNotNull(ese.getTemporal());
+ }
+
+ EditionSetHelper.apply(em, es);
+
+ em.flush();
+ }
+
+ /**
+ * Populate initial sample entity
+ */
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nEditionSetTests.populate:START");
+ example.populateHobbies(em);
+ em.persist(getSample());
+ em.flush();
+
+ populateT2Editions(em);
+ System.out.println("\nEditionSetTests.populate::DONE");
+ }
+
+ /**
+ * Create the edition at T2 if it has not already been created
+ */
+ public Person populateT2Editions(TemporalEntityManager em) {
+ em.setEffectiveTime(T2);
+ EditionSet editionSet = em.getEditionSet();
+ Assert.assertNotNull(editionSet);
+
+ Person personEditionT2 = em.find(Person.class, getSample().getId());
+
+ if (personEditionT2.getEffectivity().getStart() != T2) {
+ System.out.println("\nEditionSetTests.populateT2Edition:START");
+
+ editionSet.setDescription("EditionSetTests::Person@T2");
+ personEditionT2 = em.newEdition(personEditionT2);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(personEditionT2.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(personEditionT2.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ em.persist(personEditionT2.addHobby(example.hobbies.get(GOLF), T2));
+
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT2Edition::DONE");
+ }
+
+ return personEditionT2;
+ }
+
+}
diff --git a/Temporal Tests/src/tests/editionsets/CreateEditionSetTests.java b/Temporal Tests/src/tests/editionsets/CreateEditionSetTests.java
new file mode 100644
index 0000000..38ff8ec
--- /dev/null
+++ b/Temporal Tests/src/tests/editionsets/CreateEditionSetTests.java
@@ -0,0 +1,224 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.editionsets;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.RUN;
+import static example.PersonModelExample.SKI;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+import static example.PersonModelExample.T5;
+
+import java.util.List;
+
+import javax.persistence.Temporal;
+
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.PersonHobby;
+import model.Phone;
+
+import org.junit.Test;
+
+import temporal.EditionSet;
+import temporal.EditionSetEntry;
+import temporal.TemporalEntityManager;
+import temporal.TemporalHelper;
+import tests.BaseTestCase;
+import example.PersonModelExample;
+
+/**
+ * Tests verifying the {@link EditionSet} capabilities.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class CreateEditionSetTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void verifyEditionSetAtT2() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.getTransaction().begin();
+ populateT2Editions(em);
+
+ em.setEffectiveTime(T2);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+ Assert.assertEquals(T2, es.getEffective());
+ Assert.assertEquals(4, es.getEntries().size());
+
+ Assert.assertTrue(es.getEntries().get(0).getTemporal() instanceof Person);
+ Person p = (Person) es.getEntries().get(0).getTemporal();
+ Assert.assertEquals(T2, p.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(1).getTemporal() instanceof Address);
+ Address a = (Address) es.getEntries().get(1).getTemporal();
+ Assert.assertEquals(T2, a.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(2).getTemporal() instanceof Phone);
+ Phone phone = (Phone) es.getEntries().get(2).getTemporal();
+ Assert.assertEquals(T2, phone.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(3).getTemporal() instanceof PersonHobby);
+ PersonHobby ph = (PersonHobby) es.getEntries().get(3).getTemporal();
+ Assert.assertEquals(T2, ph.getEffectivity().getStart());
+ Assert.assertSame(p, ph.getPerson());
+ Assert.assertEquals(PersonModelExample.GOLF, ph.getName());
+ Assert.assertEquals(PersonModelExample.GOLF, ph.getHobby().getName());
+
+ Assert.assertEquals(1, p.getPersonHobbies().size());
+
+ }
+
+ @Test
+ public void verifyEditionSetAtT4() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+
+ populateT4Editions(em);
+
+ List<EditionSet> editionSets = em.createQuery("SELECT e FROM EditionSet e ORDER BY e.effective", EditionSet.class).getResultList();
+
+ Assert.assertNotNull(editionSets);
+ Assert.assertEquals("Incorrect number of EditionSets found.", 2, editionSets.size());
+
+ EditionSet t1 = editionSets.get(0);
+ Assert.assertNotNull(t1);
+ Assert.assertEquals(T2, t1.getEffective());
+
+ EditionSet t2 = editionSets.get(1);
+ Assert.assertNotNull(t2);
+ Assert.assertEquals(T4, t2.getEffective());
+ }
+
+ /**
+ * Verify that the addition of a {@link Temporal} value in a 1:M collection
+ * causes an EditionSetEntry to be created.
+ */
+ @Test
+ public void addHobbyAtT5WithInitializedEditionSet() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T5);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+
+ Person person = em.find(Person.class, getSample().getId());
+ Assert.assertNotNull(person);
+ Assert.assertTrue(TemporalHelper.isTemporalEntity(person));
+ Assert.assertEquals(T5, es.getEffective());
+
+ PersonHobby runHobby = em.newTemporal(PersonHobby.class);
+ runHobby.setHobby(example.hobbies.get(RUN));
+ person.addHobby(runHobby);
+
+ Assert.assertEquals(1, es.getEntries().size());
+
+ EditionSetEntry entry = es.getEntries().get(0);
+
+ Assert.assertTrue(entry.getTemporal() instanceof PersonHobby);
+ }
+
+ /**
+ * Populate initial sample entity
+ */
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nEditionSetTests.populate:START");
+ example.populateHobbies(em);
+ em.persist(getSample());
+ System.out.println("\nEditionSetTests.populate::DONE");
+ }
+
+ /**
+ * Create the edition at T2 if it has not already been created
+ */
+ public Person populateT2Editions(TemporalEntityManager em) {
+ em.setEffectiveTime(T2);
+ EditionSet editionSet = em.getEditionSet();
+ Assert.assertNotNull(editionSet);
+
+ Person personEditionT2 = em.find(Person.class, getSample().getId());
+
+ if (personEditionT2.getEffectivity().getStart() != T2) {
+ System.out.println("\nEditionSetTests.populateT2Edition:START");
+
+ editionSet.setDescription("EditionSetTests::Person@T2");
+ personEditionT2 = em.newEdition(personEditionT2);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(personEditionT2.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(personEditionT2.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+
+ PersonHobby golfHobby = em.newTemporal(PersonHobby.class);
+ golfHobby.setHobby(example.hobbies.get(GOLF));
+ personEditionT2.addHobby(golfHobby);
+
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT2Edition::DONE");
+ }
+
+ return personEditionT2;
+ }
+
+ public Person populateT4Editions(TemporalEntityManager em) {
+ populateT2Editions(em);
+
+ em.setEffectiveTime(T4);
+ EditionSet editionSet = em.getEditionSet();
+ Assert.assertNotNull(editionSet);
+
+ Person personEditionT4 = em.find(Person.class, getSample().getId());
+
+ if (personEditionT4 == null) {
+ System.out.println("\nEditionSetTests.populateT4Edition:START");
+ editionSet.setDescription("EditionSetTests::Person@T4");
+ personEditionT4 = em.newEdition(personEditionT4);
+ personEditionT4.setName("James");
+ Address aT4 = em.newEdition(personEditionT4.getAddress());
+ aT4.setCity("San Francisco");
+ aT4.setState("CA");
+ personEditionT4.setAddress(aT4);
+ Phone pT4 = em.newEdition(personEditionT4.getPhone("Home"));
+ pT4.setNumber("444-444-4444");
+ personEditionT4.addPhone(pT4);
+ personEditionT4.getPersonHobbies().get(GOLF).getEffectivity().setEnd(T4);
+
+ PersonHobby runHobby = em.newTemporal(PersonHobby.class);
+ runHobby.setHobby(example.hobbies.get(RUN));
+ personEditionT4.addHobby(runHobby);
+
+ PersonHobby skiHobby = em.newTemporal(PersonHobby.class);
+ skiHobby.setHobby(example.hobbies.get(SKI));
+ personEditionT4.addHobby(skiHobby);
+
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT4Edition:DONE");
+ }
+
+ return personEditionT4;
+ }
+}
diff --git a/Temporal Tests/src/tests/editionsets/DeleteEditionSetTests.java b/Temporal Tests/src/tests/editionsets/DeleteEditionSetTests.java
new file mode 100644
index 0000000..094d987
--- /dev/null
+++ b/Temporal Tests/src/tests/editionsets/DeleteEditionSetTests.java
@@ -0,0 +1,291 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.editionsets;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.RUN;
+import static example.PersonModelExample.SKI;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+import static example.PersonModelExample.T5;
+import static temporal.Effectivity.BOT;
+
+import java.util.List;
+
+import javax.persistence.Temporal;
+
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.PersonHobby;
+import model.Phone;
+
+import org.junit.Test;
+
+import temporal.EditionSet;
+import temporal.EditionSetEntry;
+import temporal.TemporalEntityManager;
+import temporal.TemporalHelper;
+import tests.BaseTestCase;
+import example.PersonModelExample;
+
+/**
+ * Tests verifying the {@link EditionSet} capabilities.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class DeleteEditionSetTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void verifyEditionSetAtT2() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.setEffectiveTime(T2);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+ Assert.assertEquals(T2, es.getEffective());
+ Assert.assertEquals(4, es.getEntries().size());
+
+ Assert.assertTrue(es.getEntries().get(0).getTemporal() instanceof Person);
+ Person p = (Person) es.getEntries().get(0).getTemporal();
+ Assert.assertEquals(T2, p.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(1).getTemporal() instanceof Address);
+ Address a = (Address) es.getEntries().get(1).getTemporal();
+ Assert.assertEquals(T2, a.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(2).getTemporal() instanceof Phone);
+ Phone phone = (Phone) es.getEntries().get(2).getTemporal();
+ Assert.assertEquals(T2, phone.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(3).getTemporal() instanceof PersonHobby);
+ PersonHobby ph = (PersonHobby) es.getEntries().get(3).getTemporal();
+ Assert.assertEquals(T2, ph.getEffectivity().getStart());
+ Assert.assertEquals(PersonModelExample.GOLF, ph.getName());
+ Assert.assertEquals(PersonModelExample.GOLF, ph.getHobby().getName());
+
+ //Assert.assertSame(p, ph.getPerson());
+
+ Assert.assertEquals(1, p.getPersonHobbies().size());
+
+ }
+
+ @Test
+ public void verifyEditionSetAtT4() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.setEffectiveTime(T4);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+ Assert.assertEquals(T4, es.getEffective());
+ Assert.assertEquals(5, es.getEntries().size());
+
+ Assert.assertTrue(es.getEntries().get(0).getTemporal() instanceof Person);
+ Person p = (Person) es.getEntries().get(0).getTemporal();
+ Assert.assertEquals(T4, p.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(1).getTemporal() instanceof Address);
+ Address a = (Address) es.getEntries().get(1).getTemporal();
+ Assert.assertEquals(T4, a.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(2).getTemporal() instanceof Phone);
+ Phone phone = (Phone) es.getEntries().get(2).getTemporal();
+ Assert.assertEquals(T4, phone.getEffectivity().getStart());
+
+ Assert.assertTrue(es.getEntries().get(3).getTemporal() instanceof PersonHobby);
+ PersonHobby ph = (PersonHobby) es.getEntries().get(3).getTemporal();
+ Assert.assertEquals(T4, ph.getEffectivity().getStart());
+ Assert.assertEquals(PersonModelExample.RUN, ph.getName());
+ Assert.assertEquals(PersonModelExample.RUN, ph.getHobby().getName());
+ //Assert.assertSame(p, ph.getPerson());
+
+ Assert.assertTrue(es.getEntries().get(4).getTemporal() instanceof PersonHobby);
+ ph = (PersonHobby) es.getEntries().get(4).getTemporal();
+ Assert.assertEquals(T4, ph.getEffectivity().getStart());
+ Assert.assertEquals(PersonModelExample.SKI, ph.getName());
+ Assert.assertEquals(PersonModelExample.SKI, ph.getHobby().getName());
+ //Assert.assertSame(p, ph.getPerson());
+
+ Assert.assertEquals(2, p.getPersonHobbies().size());
+
+ }
+
+ @Test
+ public void verifyEditionSets() {
+ TemporalEntityManager em = getEntityManager();
+
+ List<EditionSet> editionSets = em.createQuery("SELECT e FROM EditionSet e ORDER BY e.effective", EditionSet.class).getResultList();
+
+ Assert.assertNotNull(editionSets);
+ Assert.assertEquals("Incorrect number of EditionSets found.", 2, editionSets.size());
+
+ EditionSet t1 = editionSets.get(0);
+ Assert.assertNotNull(t1);
+ Assert.assertEquals(T2, t1.getEffective());
+
+ EditionSet t2 = editionSets.get(1);
+ Assert.assertNotNull(t2);
+ Assert.assertEquals(T4, t2.getEffective());
+
+
+ }
+
+ /**
+ * Verify that the addition of a {@link Temporal} value in a 1:M collection
+ * causes an EditionSetEntry to be created.
+ */
+ @Test
+ public void addHobbyAtT5WithInitializedEditionSet() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T5);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+
+ Person person = em.find(Person.class, getSample().getId());
+ Assert.assertNotNull(person);
+ Assert.assertTrue(TemporalHelper.isTemporalEntity(person));
+ Assert.assertEquals(T5, es.getEffective());
+
+ PersonHobby runHobby = em.newTemporal(PersonHobby.class);
+ runHobby.setHobby(example.hobbies.get(RUN));
+ person.addHobby(runHobby);
+
+ Assert.assertEquals(1, es.getEntries().size());
+
+ EditionSetEntry entry = es.getEntries().get(0);
+
+ Assert.assertTrue(entry.getTemporal() instanceof PersonHobby);
+ }
+
+ /**
+ * TODO
+ */
+ // @Test
+ public void deleteT4() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T4);
+
+ EditionSet esT4 = em.getEditionSet();
+
+ Assert.assertNotNull(esT4);
+
+ em.getTransaction().begin();
+ em.remove(esT4);
+
+ em.flush();
+
+ esT4 = em.find(EditionSet.class, T4);
+ Assert.assertNull(esT4);
+ }
+
+ /**
+ * TODO
+ */
+ // @Test
+ public void deleteT2() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T2);
+
+ EditionSet esT2 = em.getEditionSet();
+
+ Assert.assertNotNull(esT2);
+
+ em.getTransaction().begin();
+ em.remove(esT2);
+
+ em.flush();
+
+ esT2= em.find(EditionSet.class, T2);
+ Assert.assertNull(esT2);
+}
+
+ /**
+ * Populate initial sample entity
+ */
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nEditionSetTests.populate:START");
+ example.populateHobbies(em);
+ em.persist(getSample());
+
+ System.out.println("\nEditionSetTests.populateT2Edition:START");
+
+ em.setEffectiveTime(T2);
+ EditionSet editionSet = em.getEditionSet();
+ editionSet.setDescription("EditionSetTests::Person@T2");
+
+ Person person = em.find(Person.class, getSample().getId());
+ Assert.assertEquals(BOT, person.getEffectivity().getStart());
+
+ Person personEditionT2 = em.newEdition(person);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(personEditionT2.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(personEditionT2.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+
+ PersonHobby golfHobby = em.newTemporal(PersonHobby.class);
+ golfHobby.setHobby(example.hobbies.get(GOLF));
+ personEditionT2.addHobby(golfHobby);
+
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT2Edition::DONE");
+
+ System.out.println("\nEditionSetTests.populateT4Edition:START");
+
+ em.setEffectiveTime(T4);
+ editionSet = em.getEditionSet();
+ editionSet.setDescription("EditionSetTests::Person@T4");
+
+ person = em.find(Person.class, getSample().getId());
+ Assert.assertEquals(T2, person.getEffectivity().getStart());
+
+ Person personEditionT4 = em.newEdition(person);
+ personEditionT4.setName("James");
+ Address aT4 = em.newEdition(personEditionT4.getAddress());
+ aT4.setCity("San Francisco");
+ aT4.setState("CA");
+ personEditionT4.setAddress(aT4);
+ Phone pT4 = em.newEdition(personEditionT4.getPhone("Home"));
+ pT4.setNumber("444-444-4444");
+ personEditionT4.addPhone(pT4);
+ personEditionT4.getPersonHobbies().get(GOLF).getEffectivity().setEnd(T4);
+
+ PersonHobby runHobby = em.newTemporal(PersonHobby.class);
+ runHobby.setHobby(example.hobbies.get(RUN));
+ personEditionT4.addHobby(runHobby);
+
+ PersonHobby skiHobby = em.newTemporal(PersonHobby.class);
+ skiHobby.setHobby(example.hobbies.get(SKI));
+ personEditionT4.addHobby(skiHobby);
+
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT4Edition:DONE");
+
+ System.out.println("\nEditionSetTests.populate::DONE");
+ }
+
+}
diff --git a/Temporal Tests/src/tests/editionsets/EditionSetConfigTests.java b/Temporal Tests/src/tests/editionsets/EditionSetConfigTests.java
new file mode 100644
index 0000000..0374609
--- /dev/null
+++ b/Temporal Tests/src/tests/editionsets/EditionSetConfigTests.java
@@ -0,0 +1,130 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.editionsets;
+
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T6;
+import junit.framework.Assert;
+import model.Person;
+
+import org.eclipse.persistence.descriptors.ClassDescriptor;
+import org.eclipse.persistence.mappings.OneToManyMapping;
+import org.eclipse.persistence.mappings.VariableOneToOneMapping;
+import org.eclipse.persistence.sessions.server.Server;
+import org.junit.Test;
+
+import temporal.EditionSet;
+import temporal.TemporalEntityManager;
+import temporal.TemporalHelper;
+import tests.BaseTestCase;
+import example.PersonModelExample;
+
+/**
+ * Tests verifying the {@link EditionSet} capabilities.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class EditionSetConfigTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void verifyEditionSetMapping() {
+ TemporalEntityManager em = getEntityManager();
+
+ ClassDescriptor desc = em.unwrap(Server.class).getClassDescriptorForAlias("EditionSet");
+ Assert.assertNotNull(desc);
+
+ OneToManyMapping otmMapping = (OneToManyMapping) desc.getMappingForAttributeName("entries");
+ Assert.assertNotNull(otmMapping);
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ @Test
+ public void verifyEditionSetEntryMapping() {
+ TemporalEntityManager em = getEntityManager();
+
+ ClassDescriptor desc = em.unwrap(Server.class).getClassDescriptorForAlias("EditionSetEntry");
+ Assert.assertNotNull(desc);
+
+ VariableOneToOneMapping votoMapping = (VariableOneToOneMapping) desc.getMappingForAttributeName("temporal");
+ Assert.assertNotNull(votoMapping);
+
+ Assert.assertEquals(8, votoMapping.getTypeIndicatorTranslation().size());
+
+ Assert.assertTrue(votoMapping.getTypeIndicatorTranslation().containsKey("Person"));
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class) votoMapping.getTypeIndicatorTranslation().get("Person")));
+
+ Assert.assertTrue(votoMapping.getTypeIndicatorTranslation().containsKey("Phone"));
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class) votoMapping.getTypeIndicatorTranslation().get("Phone")));
+
+ Assert.assertTrue(votoMapping.getTypeIndicatorTranslation().containsKey("Address"));
+ Assert.assertTrue(TemporalHelper.isEditionClass((Class) votoMapping.getTypeIndicatorTranslation().get("Address")));
+
+ Assert.assertTrue(votoMapping.getTypeIndicatorTranslation().containsKey("PersonHobby"));
+ Assert.assertTrue(TemporalHelper.isTemporal((Class) votoMapping.getTypeIndicatorTranslation().get("PersonHobby"), false));
+ }
+
+ @Test
+ public void verifySetEffectiveInitialize() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.setEffectiveTime(T6);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+ Assert.assertEquals(T6, es.getEffective());
+ }
+
+ @Test
+ public void verifyEditionSetPerEffective() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.setEffectiveTime(T2);
+ EditionSet esT2 = em.getEditionSet();
+ Assert.assertNotNull(esT2);
+ Assert.assertEquals(T2, esT2.getEffective());
+
+ em.setEffectiveTime(T6);
+ EditionSet esT6 = em.getEditionSet();
+ Assert.assertNotNull(esT6);
+ Assert.assertEquals(T6, esT6.getEffective());
+
+ Assert.assertNotSame(esT2, esT6);
+ }
+
+ @Test
+ public void verifyNotInitialized() {
+ TemporalEntityManager em = getEntityManager();
+ Assert.assertFalse(em.hasEditionSet());
+
+ em.setEffectiveTime(T6);
+
+ Assert.assertFalse(em.hasEditionSet());
+ }
+
+ /**
+ * Populate initial sample entity
+ */
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nEditionSetTests.populate:START");
+ example.populateHobbies(em);
+ em.persist(getSample());
+ System.out.println("\nEditionSetTests.populate::DONE");
+ }
+
+}
diff --git a/Temporal Tests/src/tests/editionsets/MoveSingleEditionSetTests.java b/Temporal Tests/src/tests/editionsets/MoveSingleEditionSetTests.java
new file mode 100644
index 0000000..921f404
--- /dev/null
+++ b/Temporal Tests/src/tests/editionsets/MoveSingleEditionSetTests.java
@@ -0,0 +1,107 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.editionsets;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.T2;
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.Phone;
+
+import org.junit.Test;
+
+import temporal.EditionSet;
+import temporal.EditionSetEntry;
+import temporal.TemporalEntityManager;
+import tests.BaseTestCase;
+import example.PersonModelExample;
+
+/**
+ * Tests applying a simple (no conflict) {@link EditionSet}
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class MoveSingleEditionSetTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void moveEditionSetFromT2toT3() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.getTransaction().begin();
+
+ em.setEffectiveTime(T2);
+ EditionSet es = em.getEditionSet();
+
+ Assert.assertNotNull(es);
+ Assert.assertEquals(T2, es.getEffective());
+ Assert.assertEquals(3, es.getEntries().size());
+
+ for (EditionSetEntry entry : es.getEntries()) {
+ System.out.println("> " + entry.getTemporal());
+ for (String attrName : entry.getAttributes()) {
+ System.out.println("\t>> " + attrName);
+ }
+ }
+ }
+
+ /**
+ * Populate initial sample entity
+ */
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nEditionSetTests.populate:START");
+ example.populateHobbies(em);
+ em.persist(getSample());
+ populateT2Editions(em);
+ System.out.println("\nEditionSetTests.populate::DONE");
+ }
+
+ /**
+ * Create the edition at T2 if it has not already been created
+ */
+ public Person populateT2Editions(TemporalEntityManager em) {
+ em.setEffectiveTime(T2);
+ EditionSet editionSet = em.getEditionSet();
+ Assert.assertNotNull(editionSet);
+
+ Person personEditionT2 = em.find(Person.class, getSample().getId());
+
+ if (personEditionT2.getEffectivity().getStart() != T2) {
+ System.out.println("\nEditionSetTests.populateT2Edition:START");
+
+ editionSet.setDescription("EditionSetTests::Person@T2");
+ personEditionT2 = em.newEdition(personEditionT2);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(personEditionT2.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(personEditionT2.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ em.persist(personEditionT2.addHobby(example.hobbies.get(GOLF), T2));
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT2Edition::DONE");
+ }
+
+ return personEditionT2;
+ }
+
+}
diff --git a/Temporal Tests/src/tests/editionsets/PropagateChangesTests.java b/Temporal Tests/src/tests/editionsets/PropagateChangesTests.java
new file mode 100644
index 0000000..1d07428
--- /dev/null
+++ b/Temporal Tests/src/tests/editionsets/PropagateChangesTests.java
@@ -0,0 +1,193 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.editionsets;
+
+import static example.PersonModelExample.GOLF;
+import static example.PersonModelExample.RUN;
+import static example.PersonModelExample.SWIM;
+import static example.PersonModelExample.T2;
+import static example.PersonModelExample.T4;
+import junit.framework.Assert;
+import model.Address;
+import model.Person;
+import model.Phone;
+
+import org.junit.Test;
+
+import temporal.EditionSet;
+import temporal.TemporalEntityManager;
+import temporal.TemporalHelper;
+import tests.BaseTestCase;
+import example.PersonModelExample;
+
+/**
+ * Tests change propagation through future editions.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class PropagateChangesTests extends BaseTestCase {
+
+ private static PersonModelExample example = new PersonModelExample();
+
+ private Person getSample() {
+ return example.fullPerson;
+ }
+
+ @Test
+ public void makeBasicChangesAtT2Changes() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.getTransaction().begin();
+
+ em.setEffectiveTime(T2);
+ EditionSet esT2 = em.getEditionSet();
+ Assert.assertNotNull(esT2);
+
+ Person personT2 = em.find(Person.class, getSample().getId());
+
+ Assert.assertNotNull(personT2);
+ Assert.assertTrue(TemporalHelper.isEdition(em, personT2));
+ Assert.assertEquals(T2, personT2.getEffectivity().getStart());
+
+ personT2.setName("Jimster");
+ personT2.setEmail("a@b.c");
+ personT2.getAddress().setState("ONT");
+ personT2.getAddress().setStreet(null);
+
+ em.flush();
+ em.clear();
+
+ em.setEffectiveTime(T4);
+ EditionSet esT4 = em.getEditionSet();
+ Assert.assertNotNull(esT4);
+
+ Person personT4 = em.find(Person.class, getSample().getId());
+
+ Assert.assertNotNull(personT4);
+ Assert.assertTrue(TemporalHelper.isEdition(em, personT4));
+ Assert.assertEquals(T4, personT4.getEffectivity().getStart());
+
+ String nativeName = (String) em.createNativeQuery("SELECT P_NAMES FROM TPERSON WHERE CID = " + getSample().getId() + " AND START_TS = 400").getSingleResult();
+ Assert.assertEquals("Jimbo", nativeName);
+ Assert.assertEquals("Jimbo", personT4.getName());
+
+ String nativeState = (String) em.createNativeQuery("SELECT STATE FROM TADDRESS WHERE CID = " + getSample().getAddress().getId() + " AND START_TS = 400").getSingleResult();
+ Assert.assertEquals("ONT", nativeState);
+ Assert.assertEquals("ONT", personT4.getAddress().getState());
+
+ Assert.assertNull(personT4.getAddress().getStreet());
+ Assert.assertNotNull(personT4.getEmail());
+ }
+
+ @Test
+ public void makeBasicCollectionChangesAtT2Changes() {
+ TemporalEntityManager em = getEntityManager();
+
+ em.getTransaction().begin();
+
+ em.setEffectiveTime(T2);
+ EditionSet esT2 = em.getEditionSet();
+ Assert.assertNotNull(esT2);
+
+ Person personT2 = em.find(Person.class, getSample().getId());
+
+ Assert.assertNotNull(personT2);
+ Assert.assertTrue(TemporalHelper.isEdition(em, personT2));
+ Assert.assertEquals(T2, personT2.getEffectivity().getStart());
+
+ em.persist(personT2.addHobby(example.hobbies.get(SWIM), T2));
+
+ try {
+ em.flush();
+ } catch (UnsupportedOperationException e) {
+ return;
+ }
+ Assert.fail("UnsupportedOperationException expected");
+
+ }
+
+ /**
+ * Populate initial sample entity
+ */
+ @Override
+ public void populate(TemporalEntityManager em) {
+ System.out.println("\nEditionSetTests.populate:START");
+ example.populateHobbies(em);
+ em.persist(getSample());
+ populateT2Editions(em);
+ populateT4Editions(em);
+ System.out.println("\nEditionSetTests.populate::DONE");
+ }
+
+ /**
+ * Create the edition at T2 if it has not already been created
+ */
+ public Person populateT2Editions(TemporalEntityManager em) {
+ em.setEffectiveTime(T2);
+ EditionSet editionSet = em.getEditionSet();
+ Assert.assertNotNull(editionSet);
+
+ Person personEditionT2 = em.find(Person.class, getSample().getId());
+
+ if (personEditionT2.getEffectivity().getStart() != T2) {
+ System.out.println("\nEditionSetTests.populateT2Edition:START");
+
+ editionSet.setDescription("EditionSetTests::Person@T2");
+ personEditionT2 = em.newEdition(personEditionT2);
+ personEditionT2.setName("Jimmy");
+ Address aT2 = em.newEdition(personEditionT2.getAddress());
+ aT2.setCity("Toronto");
+ aT2.setState("ON");
+ personEditionT2.setAddress(aT2);
+ Phone pT2 = em.newEdition(personEditionT2.getPhone("Home"));
+ personEditionT2.addPhone(pT2);
+ pT2.setNumber("222-222-2222");
+ em.persist(personEditionT2.addHobby(example.hobbies.get(GOLF), T2));
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT2Edition::DONE");
+ }
+
+ return personEditionT2;
+ }
+
+ /**
+ * Create the edition at T2 if it has not already been created
+ */
+ public Person populateT4Editions(TemporalEntityManager em) {
+ em.setEffectiveTime(T4);
+ EditionSet editionSet = em.getEditionSet();
+ Assert.assertNotNull(editionSet);
+
+ Person personEditionT4 = em.find(Person.class, getSample().getId());
+
+ if (personEditionT4.getEffectivity().getStart() != T4) {
+ System.out.println("\nEditionSetTests.populateT4Edition:START");
+
+ editionSet.setDescription("EditionSetTests::Person@T4");
+ personEditionT4 = em.newEdition(personEditionT4);
+ personEditionT4.setName("Jimbo");
+ Address aT4 = em.newEdition(personEditionT4.getAddress());
+ aT4.setCity("Ottawa");
+ personEditionT4.setAddress(aT4);
+ Phone pT4 = em.newEdition(personEditionT4.getPhone("Home"));
+ personEditionT4.addPhone(pT4);
+ pT4.setNumber("444-444-4444");
+ em.persist(personEditionT4.addHobby(example.hobbies.get(RUN), T4));
+ em.flush();
+
+ System.out.println("\nEditionSetTests.populateT4Edition::DONE");
+ }
+
+ return personEditionT4;
+ }
+}
diff --git a/Temporal Tests/src/tests/internal/AllTests.java b/Temporal Tests/src/tests/internal/AllTests.java
new file mode 100644
index 0000000..c6125a5
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/AllTests.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.internal;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+/**
+ * Internal test suite verifying how EclipseLInk and the temporal extensions are working.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+@RunWith(Suite.class)
+@SuiteClasses({ VerifyConfigTests.class,
+ VerifySchemaManager.class,
+ TemporalHelperTests.class,
+ TemporalEntityManagerTests.class,
+ TemporalEntityTests.class,
+ //WrapperPolicyTests.class,
+ })
+public class AllTests {
+}
diff --git a/Temporal Tests/src/tests/internal/TemporalEntityManagerTests.java b/Temporal Tests/src/tests/internal/TemporalEntityManagerTests.java
new file mode 100644
index 0000000..f498740
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/TemporalEntityManagerTests.java
@@ -0,0 +1,224 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.internal;
+
+import static example.PersonModelExample.T1;
+import static example.PersonModelExample.T3;
+import static example.PersonModelExample.T4;
+import static example.PersonModelExample.T5;
+import static example.PersonModelExample.T6;
+import static example.PersonModelExample.T7;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static temporal.Effectivity.BOT;
+import static temporal.Effectivity.EOT;
+
+import javax.persistence.EntityManager;
+
+import junit.framework.Assert;
+import model.Person;
+import model.PersonHobby;
+
+import org.eclipse.persistence.internal.sessions.RepeatableWriteUnitOfWork;
+import org.eclipse.persistence.sessions.DatabaseSession;
+import org.eclipse.persistence.sessions.UnitOfWork;
+import org.eclipse.persistence.sessions.server.ClientSession;
+import org.eclipse.persistence.sessions.server.Server;
+import org.junit.Test;
+
+import temporal.EditionSet;
+import temporal.TemporalEntityManager;
+import tests.BaseTestCase;
+
+/**
+ * Verify the {@link TemporalEntityManager} API
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class TemporalEntityManagerTests extends BaseTestCase {
+
+ private void verifySetStartTime(TemporalEntityManager em, Long value) {
+ assertTrue(em.hasEffectiveTime());
+ assertNotNull(em.getEffectiveTime());
+ assertEquals(value, em.getEffectiveTime());
+
+ RepeatableWriteUnitOfWork uow = em.unwrap(RepeatableWriteUnitOfWork.class);
+ assertNotNull(uow);
+
+ ClientSession clientSession = (ClientSession) uow.getParent();
+
+ DatabaseSession session = em.unwrap(DatabaseSession.class);
+ assertNotSame(clientSession, session);
+
+ Server serverSession = em.unwrap(Server.class);
+ assertNotSame(clientSession, serverSession);
+ assertSame(session, serverSession);
+ }
+
+ @Test
+ public void verifyGetInstance() {
+ TemporalEntityManager em1 = getEntityManager();
+
+ Assert.assertTrue(em1.getProperties().containsKey(TemporalEntityManager.TEMPORAL_EM_PROPERTY));
+ Assert.assertFalse(em1.getProperties().containsKey(TemporalEntityManager.EFF_TS_PROPERTY));
+ assertFalse(em1.hasEffectiveTime());
+ assertNull(em1.getEffectiveTime());
+
+ EntityManager wrappedEm = em1.unwrap(EntityManager.class);
+ Assert.assertNotSame(em1, wrappedEm);
+
+ TemporalEntityManager em2 = TemporalEntityManager.getInstance(wrappedEm);
+ Assert.assertSame(em1, em2);
+
+ TemporalEntityManager em3 = TemporalEntityManager.getInstance(wrappedEm.unwrap(UnitOfWork.class));
+ Assert.assertSame(em1, em3);
+
+ TemporalEntityManager em4 = TemporalEntityManager.getInstance(em1);
+ Assert.assertSame(em1, em4);
+ }
+
+ @Test
+ public void verifySetStartTime() {
+ TemporalEntityManager em = getEntityManager();
+
+ assertFalse(em.hasEffectiveTime());
+ assertNull(em.getEffectiveTime());
+
+ em.setEffectiveTime(T1);
+
+ verifySetStartTime(em, T1);
+ }
+
+ @Test
+ public void verifyClearStartTime() {
+ TemporalEntityManager em = getEntityManager();
+ assertFalse(em.hasEffectiveTime());
+ assertNull(em.getEffectiveTime());
+
+ em.setEffectiveTime(T3);
+
+ verifySetStartTime(em, T3);
+
+ em.clearEffectiveTime();
+
+ assertFalse(em.hasEffectiveTime());
+ assertNull(em.getEffectiveTime());
+ }
+
+ @Test
+ public void verifyConcurrentSetStartTime() {
+ TemporalEntityManager em1 = getEntityManager();
+ TemporalEntityManager em2 = TemporalEntityManager.getInstance(getEMF().createEntityManager());
+
+ assertNotSame(em1, em2);
+
+ em1.setEffectiveTime(T4);
+
+ em2.setEffectiveTime(T5);
+
+ verifySetStartTime(em2, T5);
+ verifySetStartTime(em1, T4);
+ }
+
+ @Test
+ public void verifyConcurrentClearStartTime() {
+ TemporalEntityManager em1 = getEntityManager();
+ TemporalEntityManager em2 = TemporalEntityManager.getInstance(getEMF().createEntityManager());
+
+ assertNotSame(em1, em2);
+
+ em1.setEffectiveTime(T6);
+ em2.setEffectiveTime(T7);
+
+ verifySetStartTime(em2, T7);
+ verifySetStartTime(em1, T6);
+
+ em1.clearEffectiveTime();
+ verifySetStartTime(em2, T7);
+ assertFalse(em1.hasEffectiveTime());
+ assertNull(em1.getEffectiveTime());
+
+ em2.clearEffectiveTime();
+ assertFalse(em2.hasEffectiveTime());
+ assertNull(em2.getEffectiveTime());
+ }
+
+ @Test
+ public void verifyCurrentCreateTemporal() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+
+ PersonHobby ph = em.newTemporal(PersonHobby.class);
+
+ Assert.assertNotNull(ph);
+ Assert.assertNotNull(ph.getEffectivity());
+ Assert.assertEquals(BOT, ph.getEffectivity().getStart());
+ Assert.assertEquals(EOT, ph.getEffectivity().getEnd());
+ }
+
+ @Test
+ public void verifyFutureCreateTemporal() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T3);
+ em.getTransaction().begin();
+
+ PersonHobby ph = em.newTemporal(PersonHobby.class);
+
+ Assert.assertNotNull(ph);
+ Assert.assertNotNull(ph.getEffectivity());
+ Assert.assertEquals(T3, ph.getEffectivity().getStart());
+ Assert.assertEquals(EOT, ph.getEffectivity().getEnd());
+ }
+
+ @Test
+ public void verifyChangeEffectiveWithPendingChanges() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T3);
+ EditionSet esT3 = em.getEditionSet();
+
+ em.getTransaction().begin();
+
+ Person newPersonAtT3 = em.newEntity(Person.class);
+ Assert.assertNotNull(newPersonAtT3);
+ Assert.assertEquals(T3, newPersonAtT3.getEffectivity().getStart());
+ Assert.assertTrue(esT3.hasChanges());
+
+ em.setEffectiveTime(T4);
+ EditionSet esT4 = em.getEditionSet();
+
+ Assert.assertFalse(esT4.hasChanges());
+ Assert.assertTrue(esT3.hasChanges());
+
+ em.flush();
+ }
+
+ @Test
+ public void verifyRollbackWithPendingChanges() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T3);
+ em.getTransaction().begin();
+
+ Person newPersonAtT3 = em.newEntity(Person.class);
+ Assert.assertNotNull(newPersonAtT3);
+ Assert.assertEquals(T3, newPersonAtT3.getEffectivity().getStart());
+ Assert.assertTrue(em.hasEditionSet());
+ Assert.assertTrue(em.getEditionSet().hasChanges());
+
+ // TODO : ?
+ em.getTransaction().rollback();
+ }
+}
diff --git a/Temporal Tests/src/tests/internal/TemporalEntityTests.java b/Temporal Tests/src/tests/internal/TemporalEntityTests.java
new file mode 100644
index 0000000..a27c535
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/TemporalEntityTests.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.internal;
+
+import static temporal.Effectivity.BOT;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import temporal.BaseTemporalEntity;
+import temporal.TemporalEntity;
+
+/**
+ * Simple tests verifying the functionality of the interfaces and base classes
+ * used in this temporal extension framework.
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+
+public class TemporalEntityTests {
+
+ @Test
+ public void verifyTestEntityConstructor() {
+ TestEntity entity = new TestEntityImpl();
+
+ Assert.assertNotNull(entity.getEffectivity());
+ Assert.assertNull(entity.getContinuity());
+ Assert.assertNull(entity.getPreviousEdition());
+ Assert.assertEquals(0, entity.getVersion());
+ Assert.assertEquals(BOT, entity.getEffectivity().getStart());
+ }
+
+ @Test
+ public void verifyTestEntityEditionConstructor() {
+ TestEntity entity = new TestEntityEdition();
+
+ Assert.assertNotNull(entity.getEffectivity());
+ Assert.assertNull(entity.getContinuity());
+ Assert.assertNull(entity.getPreviousEdition());
+ Assert.assertEquals(0, entity.getVersion());
+ Assert.assertEquals(BOT, entity.getEffectivity().getStart());
+ }
+
+ @Test
+ public void verifyTestEntityEditionViewConstructor() {
+ TestEntity entity = new TestEntityEditionView();
+
+ Assert.assertNotNull(entity.getEffectivity());
+ Assert.assertNull(entity.getContinuity());
+ Assert.assertNull(entity.getPreviousEdition());
+ Assert.assertEquals(0, entity.getVersion());
+ Assert.assertEquals(BOT, entity.getEffectivity().getStart());
+ }
+
+ @Test
+ public void testIsContinuity() {
+ TestEntity entity = new TestEntityEditionView();
+
+ Assert.assertFalse(entity.isContinuity());
+
+ entity.setId(1);
+ entity.setContinuity(entity);
+
+ Assert.assertTrue(entity.isContinuity());
+ }
+
+ /**
+ * Static test classes
+ */
+
+ public static interface TestEntity extends TemporalEntity<TestEntity> {
+ void setId(int id);
+ }
+
+ public static class TestEntityImpl extends BaseTemporalEntity<TestEntity> implements TestEntity {
+
+ @Override
+ public void setId(int id) {
+ super.setId(id);
+ }
+
+ }
+
+ public static class TestEntityEdition extends TestEntityImpl {
+
+ }
+
+ public static class TestEntityEditionView extends TestEntityEdition {
+
+ }
+}
diff --git a/Temporal Tests/src/tests/internal/TemporalHelperTests.java b/Temporal Tests/src/tests/internal/TemporalHelperTests.java
new file mode 100644
index 0000000..46345b7
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/TemporalHelperTests.java
@@ -0,0 +1,159 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.internal;
+
+import static example.PersonModelExample.T1;
+import static temporal.Effectivity.*;
+import static example.PersonModelExample.T3;
+import static example.PersonModelExample.T4;
+import static example.PersonModelExample.T5;
+import static example.PersonModelExample.T6;
+import static example.PersonModelExample.T7;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import junit.framework.Assert;
+
+import model.PersonHobby;
+
+import org.eclipse.persistence.internal.sessions.RepeatableWriteUnitOfWork;
+import org.eclipse.persistence.sessions.DatabaseSession;
+import org.eclipse.persistence.sessions.server.ClientSession;
+import org.eclipse.persistence.sessions.server.Server;
+import org.junit.Test;
+
+import temporal.TemporalEntityManager;
+import temporal.TemporalHelper;
+import tests.BaseTestCase;
+
+/**
+ * Verify the helper methods on {@link TemporalHelper}
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class TemporalHelperTests extends BaseTestCase {
+
+ private void verifySetStartTime(TemporalEntityManager em, Long value) {
+ assertTrue(em.hasEffectiveTime());
+ assertNotNull(em.getEffectiveTime());
+ assertEquals(value, em.getEffectiveTime());
+
+ RepeatableWriteUnitOfWork uow = em.unwrap(RepeatableWriteUnitOfWork.class);
+ assertNotNull(uow);
+
+ ClientSession clientSession = (ClientSession) uow.getParent();
+
+ DatabaseSession session = em.unwrap(DatabaseSession.class);
+ assertNotSame(clientSession, session);
+
+ Server serverSession = em.unwrap(Server.class);
+ assertNotSame(clientSession, serverSession);
+ assertSame(session, serverSession);
+ }
+
+ @Test
+ public void verifySetStartTime() {
+ TemporalEntityManager em = getEntityManager();
+
+ assertFalse(em.hasEffectiveTime());
+ assertNull(em.getEffectiveTime());
+
+ em.setEffectiveTime(T1);
+
+ verifySetStartTime(em, T1);
+ }
+
+ @Test
+ public void verifyClearStartTime() {
+ TemporalEntityManager em = getEntityManager();
+ assertFalse(em.hasEffectiveTime());
+ assertNull(em.getEffectiveTime());
+
+ em.setEffectiveTime(T3);
+
+ verifySetStartTime(em, T3);
+
+ em.clearEffectiveTime();
+
+ assertFalse(em.hasEffectiveTime());
+ assertNull(em.getEffectiveTime());
+ }
+
+ @Test
+ public void verifyConcurrentSetStartTime() {
+ TemporalEntityManager em1 = getEntityManager();
+ TemporalEntityManager em2 = TemporalEntityManager.getInstance(getEMF().createEntityManager());
+
+ assertNotSame(em1, em2);
+
+ em1.setEffectiveTime(T4);
+
+ em2.setEffectiveTime(T5);
+
+ verifySetStartTime(em2, T5);
+ verifySetStartTime(em1, T4);
+ }
+
+ @Test
+ public void verifyConcurrentClearStartTime() {
+ TemporalEntityManager em1 = getEntityManager();
+ TemporalEntityManager em2 = TemporalEntityManager.getInstance(getEMF().createEntityManager());
+
+ assertNotSame(em1, em2);
+
+ em1.setEffectiveTime(T6);
+ em2.setEffectiveTime(T7);
+
+ verifySetStartTime(em2, T7);
+ verifySetStartTime(em1, T6);
+
+ em1.clearEffectiveTime();
+ verifySetStartTime(em2, T7);
+ assertFalse(em1.hasEffectiveTime());
+ assertNull(em1.getEffectiveTime());
+
+ em2.clearEffectiveTime();
+ assertFalse(em2.hasEffectiveTime());
+ assertNull(em2.getEffectiveTime());
+ }
+
+ @Test
+ public void verifyCurrentCreateTemporal() {
+ TemporalEntityManager em = getEntityManager();
+ em.getTransaction().begin();
+
+ PersonHobby ph = em.newTemporal(PersonHobby.class);
+
+ Assert.assertNotNull(ph);
+ Assert.assertNotNull(ph.getEffectivity());
+ Assert.assertEquals(BOT, ph.getEffectivity().getStart());
+ Assert.assertEquals(EOT, ph.getEffectivity().getEnd());
+ }
+
+ @Test
+ public void verifyFutureCreateTemporal() {
+ TemporalEntityManager em = getEntityManager();
+ em.setEffectiveTime(T3);
+ em.getTransaction().begin();
+
+ PersonHobby ph = em.newTemporal(PersonHobby.class);
+
+ Assert.assertNotNull(ph);
+ Assert.assertNotNull(ph.getEffectivity());
+ Assert.assertEquals(T3, ph.getEffectivity().getStart());
+ Assert.assertEquals(EOT, ph.getEffectivity().getEnd());
+ }
+}
diff --git a/Temporal Tests/src/tests/internal/VerifyConfigTests.java b/Temporal Tests/src/tests/internal/VerifyConfigTests.java
new file mode 100644
index 0000000..a4a8809
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/VerifyConfigTests.java
@@ -0,0 +1,237 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.internal;
+
+import junit.framework.Assert;
+import model.Address;
+import model.Hobby;
+import model.Person;
+import model.PersonHobby;
+import model.Phone;
+import model.entities.AddressEntity;
+import model.entities.PersonEntity;
+import model.entities.PhoneEntity;
+
+import org.eclipse.persistence.config.CacheIsolationType;
+import org.eclipse.persistence.descriptors.ClassDescriptor;
+import org.eclipse.persistence.internal.helper.DatabaseField;
+import org.eclipse.persistence.internal.weaving.PersistenceWeaved;
+import org.eclipse.persistence.internal.weaving.PersistenceWeavedChangeTracking;
+import org.eclipse.persistence.internal.weaving.PersistenceWeavedFetchGroups;
+import org.eclipse.persistence.internal.weaving.PersistenceWeavedLazy;
+import org.eclipse.persistence.jpa.JpaHelper;
+import org.eclipse.persistence.mappings.OneToManyMapping;
+import org.eclipse.persistence.mappings.OneToOneMapping;
+import org.eclipse.persistence.sessions.Session;
+import org.eclipse.persistence.sessions.server.Server;
+import org.junit.Test;
+
+import temporal.Effectivity;
+import temporal.TemporalEdition;
+import temporal.TemporalEntity;
+import temporal.TemporalHelper;
+import temporal.persistence.DescriptorHelper;
+import tests.BaseTestCase;
+
+/**
+ * Tests that verify the descriptors are setup as expected and that the
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class VerifyConfigTests extends BaseTestCase {
+
+ @Test
+ public void verifyDescriptorsExist() {
+ Server session = JpaHelper.getServerSession(getEMF());
+
+ Assert.assertNotNull(session);
+ Assert.assertTrue(session.isConnected());
+ Assert.assertEquals(21, session.getDescriptors().size());
+
+ Assert.assertNotNull(session.getClassDescriptorForAlias("Person"));
+ Assert.assertNotNull(session.getClassDescriptor(PersonEntity.class));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("Address"));
+ Assert.assertNotNull(session.getClassDescriptor(AddressEntity.class));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("Phone"));
+ Assert.assertNotNull(session.getClassDescriptor(PhoneEntity.class));
+ Assert.assertNotNull(session.getClassDescriptor(Effectivity.class));
+
+ Assert.assertNotNull(session.getClassDescriptorForAlias("Hobby"));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("PersonHobby"));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("EditionSet"));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("EditionSetEntry"));
+
+ Assert.assertNotNull(session.getClassDescriptorForAlias("PersonEdition"));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("AddressEdition"));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("PhoneEdition"));
+
+ Assert.assertNotNull(session.getClassDescriptorForAlias("PersonEditionView"));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("AddressEditionView"));
+ Assert.assertNotNull(session.getClassDescriptorForAlias("PhoneEditionView"));
+ }
+
+ @Test
+ public void verifyInterface() {
+ Server session = JpaHelper.getServerSession(getEMF());
+
+ Assert.assertSame(Person.class, session.getClassDescriptor(PersonEntity.class).getProperty(TemporalHelper.INTERFACE));
+ Assert.assertSame(Person.class, session.getClassDescriptor(Person.class).getProperty(TemporalHelper.INTERFACE));
+ Assert.assertSame(Address.class, session.getClassDescriptor(AddressEntity.class).getProperty(TemporalHelper.INTERFACE));
+ Assert.assertSame(Address.class, session.getClassDescriptor(Address.class).getProperty(TemporalHelper.INTERFACE));
+ Assert.assertSame(Phone.class, session.getClassDescriptor(PhoneEntity.class).getProperty(TemporalHelper.INTERFACE));
+ Assert.assertSame(Phone.class, session.getClassDescriptor(Phone.class).getProperty(TemporalHelper.INTERFACE));
+ }
+
+ @Test
+ public void verifyWeavingPerson() {
+ Assert.assertTrue(PersistenceWeaved.class.isAssignableFrom(PersonEntity.class));
+ Assert.assertTrue(PersistenceWeavedLazy.class.isAssignableFrom(PersonEntity.class));
+ Assert.assertTrue(PersistenceWeavedChangeTracking.class.isAssignableFrom(PersonEntity.class));
+ Assert.assertTrue(PersistenceWeavedFetchGroups.class.isAssignableFrom(PersonEntity.class));
+ Assert.assertFalse(TemporalEdition.class.isAssignableFrom(PersonEntity.class));
+ }
+
+ @Test
+ public void verifyWeavingAddress() {
+ Assert.assertTrue(PersistenceWeaved.class.isAssignableFrom(AddressEntity.class));
+ Assert.assertTrue(PersistenceWeavedLazy.class.isAssignableFrom(AddressEntity.class));
+ Assert.assertTrue(PersistenceWeavedChangeTracking.class.isAssignableFrom(AddressEntity.class));
+ Assert.assertTrue(PersistenceWeavedFetchGroups.class.isAssignableFrom(AddressEntity.class));
+ Assert.assertFalse(TemporalEdition.class.isAssignableFrom(AddressEntity.class));
+ }
+
+ @Test
+ public void verifyWeavingPhone() {
+ Assert.assertTrue(PersistenceWeaved.class.isAssignableFrom(PhoneEntity.class));
+ Assert.assertTrue(PersistenceWeavedLazy.class.isAssignableFrom(PhoneEntity.class));
+ Assert.assertTrue(PersistenceWeavedChangeTracking.class.isAssignableFrom(PhoneEntity.class));
+ Assert.assertTrue(PersistenceWeavedFetchGroups.class.isAssignableFrom(PhoneEntity.class));
+ Assert.assertFalse(TemporalEdition.class.isAssignableFrom(PhoneEntity.class));
+ }
+
+ @Test
+ public void verifyAttributeChangeTracking() {
+ Server session = JpaHelper.getServerSession(getEMF());
+
+ assertAttributeChangeTracking(session, "Person");
+ assertAttributeChangeTracking(session, "Address");
+ assertAttributeChangeTracking(session, "Phone");
+ }
+
+ @Test
+ public void verifyEntityDescriptors() {
+ Server session = JpaHelper.getServerSession(getEMF());
+
+ for (String alias : new String[] { "Person", "Address", "Phone" }) {
+ ClassDescriptor descriptor = session.getClassDescriptorForAlias(alias);
+
+ Assert.assertNotNull(descriptor);
+ Assert.assertNotNull(descriptor.getQueryManager().getAdditionalJoinExpression());
+ Assert.assertFalse(descriptor.shouldBeReadOnly());
+ Assert.assertFalse(descriptor.isIsolated());
+ Assert.assertTrue(descriptor.getObjectChangePolicy().isAttributeChangeTrackingPolicy());
+
+ Assert.assertEquals(1, descriptor.getPrimaryKeyFieldNames().size());
+ Assert.assertEquals("OID", descriptor.getPrimaryKeyFields().get(0).getName());
+
+ Assert.assertEquals(CacheIsolationType.PROTECTED, descriptor.getCacheIsolation());
+ }
+ }
+
+ /**
+ * Verify the {@link PersonHobby} and {@link Hobby} mappings are correct.
+ * These mappings are temporal but they are not {@link TemporalEntity}
+ */
+ @Test
+ public void verifyPersonHobbyMappings() {
+ Server session = JpaHelper.getServerSession(getEMF());
+ ClassDescriptor phDesc = session.getDescriptorForAlias("PersonHobby");
+ Assert.assertNotNull(phDesc);
+
+ OneToOneMapping personMapping = (OneToOneMapping) phDesc.getMappingForAttributeName("person");
+ Assert.assertNotNull(personMapping);
+ Assert.assertSame(PersonEntity.class, personMapping.getReferenceClass());
+
+ Assert.assertEquals(1, personMapping.getForeignKeyFields().size());
+ DatabaseField fkField = personMapping.getForeignKeyFields().firstElement();
+ Assert.assertEquals("PERSON_ID", fkField.getName());
+
+ DatabaseField targetField = personMapping.getSourceToTargetKeyFields().get(fkField);
+ Assert.assertEquals("CID", targetField.getName());
+ }
+
+ @Test
+ public void verifyEditionDescriptors() {
+ Server session = JpaHelper.getServerSession(getEMF());
+
+ for (String alias : new String[] { "Person", "Address", "Phone" }) {
+ ClassDescriptor descriptor = session.getClassDescriptorForAlias(alias + DescriptorHelper.EDITION);
+
+ Assert.assertNotNull(descriptor);
+ Assert.assertNotNull(descriptor.getQueryManager().getAdditionalJoinExpression());
+ Assert.assertFalse(descriptor.shouldBeReadOnly());
+ Assert.assertTrue(descriptor.isIsolated());
+ Assert.assertTrue(descriptor.getObjectChangePolicy().isAttributeChangeTrackingPolicy());
+
+ Assert.assertEquals(1, descriptor.getPrimaryKeyFieldNames().size());
+ Assert.assertEquals("OID", descriptor.getPrimaryKeyFields().get(0).getName());
+
+ Assert.assertEquals(CacheIsolationType.ISOLATED, descriptor.getCacheIsolation());
+ }
+ }
+
+ @Test
+ public void verifyEditionViewDescriptors() {
+ Server session = JpaHelper.getServerSession(getEMF());
+
+ for (String alias : new String[] { "Person", "Address", "Phone" }) {
+ ClassDescriptor descriptor = session.getClassDescriptorForAlias(alias + DescriptorHelper.EDITION_VIEW);
+
+ Assert.assertNotNull(descriptor);
+ Assert.assertNull(descriptor.getQueryManager().getAdditionalJoinExpression());
+ Assert.assertTrue(descriptor.getObjectChangePolicy().isAttributeChangeTrackingPolicy());
+ Assert.assertTrue(descriptor.isIsolated());
+ Assert.assertEquals(1, descriptor.getPrimaryKeyFieldNames().size());
+ Assert.assertEquals("OID", descriptor.getPrimaryKeyFields().get(0).getName());
+
+ Assert.assertEquals(CacheIsolationType.ISOLATED, descriptor.getCacheIsolation());
+ }
+ }
+
+ private void assertAttributeChangeTracking(Session session, String alias) {
+ ClassDescriptor descriptor = session.getClassDescriptorForAlias(alias);
+ Assert.assertNotNull(descriptor);
+ Assert.assertTrue(descriptor.getObjectChangePolicy().isAttributeChangeTrackingPolicy());
+
+ if (TemporalEntity.class.isAssignableFrom(descriptor.getJavaClass()) && !descriptor.getAlias().endsWith(DescriptorHelper.EDITION)) {
+ assertAttributeChangeTracking(session, alias + DescriptorHelper.EDITION);
+ }
+ }
+
+ @Test
+ public void verifyPersonPhonesDescriptor() {
+ Server session = JpaHelper.getServerSession(getEMF());
+ ClassDescriptor descriptor = session.getClassDescriptorForAlias("Person");
+
+ Assert.assertNotNull(descriptor);
+ Assert.assertEquals(PersonEntity.class, descriptor.getJavaClass());
+
+ OneToManyMapping phonesMapping = (OneToManyMapping) descriptor.getMappingForAttributeName("phones");
+ Assert.assertNotNull(phonesMapping);
+
+ Assert.assertEquals("Phone", phonesMapping.getReferenceDescriptor().getAlias());
+ Assert.assertTrue(phonesMapping.isCacheable());
+
+ // TODO: Verify FK fields
+ }
+
+}
diff --git a/Temporal Tests/src/tests/internal/VerifySchemaManager.java b/Temporal Tests/src/tests/internal/VerifySchemaManager.java
new file mode 100644
index 0000000..bf211c2
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/VerifySchemaManager.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.internal;
+
+import junit.framework.Assert;
+
+import org.eclipse.persistence.tools.schemaframework.ForeignKeyConstraint;
+import org.eclipse.persistence.tools.schemaframework.SchemaManager;
+import org.eclipse.persistence.tools.schemaframework.TableDefinition;
+import org.junit.Test;
+
+import temporal.persistence.TemporalSchemaManager;
+import tests.BaseTestCase;
+
+/**
+ * Verify the schema manager's table definitions
+ */
+public class VerifySchemaManager extends BaseTestCase {
+
+ private SchemaManager getSchemaManager() {
+ return (SchemaManager) getEMF().getProperties().get(SchemaManager.class.getName());
+ }
+
+ private TemporalSchemaManager getTemporalSchemaManager() {
+ return (TemporalSchemaManager) getSchemaManager();
+ }
+
+ @Test
+ public void verifySchemaManager() {
+ SchemaManager sm = getSchemaManager();
+ Assert.assertNotNull(sm);
+ Assert.assertTrue(sm instanceof TemporalSchemaManager);
+ Assert.assertSame(sm, getTemporalSchemaManager());
+ Assert.assertNotNull(getTemporalSchemaManager().getTableCreator());
+ }
+
+ @Test
+ public void verifyPhoneTable() {
+ TableDefinition td = getTemporalSchemaManager().getTableDefinition("TPHONE");
+ Assert.assertNotNull(td);
+
+ ForeignKeyConstraint fkc = td.getForeignKeyMap().get("FK_TPHONE_PERSON_ID");
+ Assert.assertNotNull(fkc);
+ Assert.assertEquals("OID", fkc.getTargetFields().get(0));
+ }
+
+ @Test
+ public void verifyPersonHobbyTable() {
+ TableDefinition td = getTemporalSchemaManager().getTableDefinition("TPERSON_HOBBY");
+ Assert.assertNotNull(td);
+
+ ForeignKeyConstraint fkc = td.getForeignKeyMap().get("FK_TPERSON_HOBBY_PERSON_ID");
+ Assert.assertNotNull(fkc);
+ Assert.assertEquals("OID", fkc.getTargetFields().get(0));
+ }
+
+ @Test
+ public void verifyPersonTable() {
+ TableDefinition td = getTemporalSchemaManager().getTableDefinition("TPERSON");
+ Assert.assertNotNull(td);
+
+ ForeignKeyConstraint fkc = td.getForeignKeyMap().get("FK_TPERSON_ADDR_ID");
+ Assert.assertNotNull(fkc);
+ Assert.assertEquals("OID", fkc.getTargetFields().get(0));
+ }
+}
diff --git a/Temporal Tests/src/tests/internal/WrapperPolicyTests.java b/Temporal Tests/src/tests/internal/WrapperPolicyTests.java
new file mode 100644
index 0000000..d89200f
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/WrapperPolicyTests.java
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * Copyright (c) 2011-2012 Oracle. All rights reserved. This program and the
+ * accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 and Eclipse Distribution License v. 1.0 which accompanies
+ * this distribution. The Eclipse Public License is available at
+ * http://www.eclipse.org/legal/epl-v10.html and the Eclipse Distribution
+ * License is available at http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors: dclarke - Bug 361016: Future Versions Examples
+ ******************************************************************************/
+package tests.internal;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+
+import junit.framework.Assert;
+
+import org.eclipse.persistence.descriptors.ClassDescriptor;
+import org.eclipse.persistence.internal.sessions.AbstractSession;
+import org.eclipse.persistence.jpa.JpaHelper;
+import org.eclipse.persistence.sessions.server.Server;
+import org.junit.Test;
+
+import temporal.TemporalHelper;
+import temporal.persistence.DescriptorHelper;
+import temporal.persistence.EditionWrapperPolicy;
+import tests.BaseTestCase;
+
+/**
+ * Verify the helper methods on {@link TemporalHelper}
+ *
+ * @author dclarke
+ * @since EclipseLink 2.3.1
+ */
+public class WrapperPolicyTests extends BaseTestCase {
+
+ @Test
+ public void verifyConfig() {
+ Server session = JpaHelper.getServerSession(getEMF());
+
+ Assert.assertNotNull(session);
+
+ for (String alias : new String[] { "Person", "Address", "Phone" }) {
+ ClassDescriptor cd = session.getClassDescriptorForAlias(alias);
+ Assert.assertNotNull(cd);
+ Assert.assertTrue(cd.hasWrapperPolicy());
+ Assert.assertTrue(cd.getWrapperPolicy() instanceof EditionWrapperPolicy);
+
+ cd = session.getClassDescriptorForAlias(alias + DescriptorHelper.EDITION);
+ Assert.assertNotNull(cd);
+ Assert.assertTrue(cd.hasWrapperPolicy());
+ Assert.assertTrue(cd.getWrapperPolicy() instanceof EditionWrapperPolicy);
+ }
+ }
+
+ @Test
+ public void createEntityAndDescriptorLookupUsingProxy() {
+ Server session = JpaHelper.getServerSession(getEMF());
+ Assert.assertNotNull(session);
+
+ for (String alias : new String[] { "Person", "Address", "Phone" }) {
+ ClassDescriptor cd = session.getClassDescriptorForAlias(alias);
+ Assert.assertNotNull(cd);
+
+ Object entity = cd.getInstantiationPolicy().buildNewInstance();
+ Assert.assertNotNull(entity);
+ Assert.assertFalse(cd.getWrapperPolicy().isWrapped(entity));
+
+ Object wrappedEnObject = cd.getWrapperPolicy().wrapObject(entity, (AbstractSession) session);
+
+ Assert.assertNotNull(wrappedEnObject);
+ Assert.assertTrue(cd.getWrapperPolicy().isWrapped(wrappedEnObject));
+ Assert.assertTrue(Proxy.isProxyClass(wrappedEnObject.getClass()));
+ InvocationHandler handler = Proxy.getInvocationHandler(wrappedEnObject);
+ Assert.assertTrue(handler instanceof EditionWrapperPolicy.Handler<?>);
+
+ ClassDescriptor lookupCD = session.getClassDescriptor(wrappedEnObject);
+ Assert.assertNotNull(lookupCD);
+ Assert.assertSame(cd, lookupCD);
+ }
+ }
+
+ @Test
+ public void createEditionAndDescriptorLookupUsingProxy() {
+ Server session = JpaHelper.getServerSession(getEMF());
+ Assert.assertNotNull(session);
+
+ for (String alias : new String[] { "Person", "Address", "Phone" }) {
+ ClassDescriptor cd = session.getClassDescriptorForAlias(alias+ DescriptorHelper.EDITION);
+ Assert.assertNotNull(cd);
+
+ Object entity = cd.getInstantiationPolicy().buildNewInstance();
+ Assert.assertNotNull(entity);
+ Assert.assertFalse(cd.getWrapperPolicy().isWrapped(entity));
+
+ Object wrappedEnObject = cd.getWrapperPolicy().wrapObject(entity, (AbstractSession) session);
+
+ Assert.assertNotNull(wrappedEnObject);
+ Assert.assertTrue(Proxy.isProxyClass(wrappedEnObject.getClass()));
+ InvocationHandler handler = Proxy.getInvocationHandler(wrappedEnObject);
+ Assert.assertTrue(handler instanceof EditionWrapperPolicy.Handler<?>);
+
+ ClassDescriptor lookupCD = session.getClassDescriptor(wrappedEnObject);
+ Assert.assertNotNull(lookupCD);
+ Assert.assertSame(cd, lookupCD);
+ }
+ }
+}
diff --git a/Temporal Tests/src/tests/internal/asm/ASMifyPersonEdition.java b/Temporal Tests/src/tests/internal/asm/ASMifyPersonEdition.java
new file mode 100644
index 0000000..7f2b90b
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/asm/ASMifyPersonEdition.java
@@ -0,0 +1,15 @@
+package tests.internal.asm;
+
+import org.eclipse.persistence.internal.libraries.asm.util.ASMifierClassVisitor;
+
+public class ASMifyPersonEdition {
+
+ /**
+ * @param args
+ * @throws Exception
+ */
+ public static void main(String[] args) throws Exception {
+ ASMifierClassVisitor.main(new String[] { PersonEdition.class.getName()});
+ }
+
+}
diff --git a/Temporal Tests/src/tests/internal/asm/PersonEdition.java b/Temporal Tests/src/tests/internal/asm/PersonEdition.java
new file mode 100644
index 0000000..5d2fff0
--- /dev/null
+++ b/Temporal Tests/src/tests/internal/asm/PersonEdition.java
@@ -0,0 +1,7 @@
+package tests.internal.asm;
+
+import model.Person;
+
+public interface PersonEdition extends Person {
+
+}
