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 {
+
+}