diff --git a/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/EntityType.java b/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/EntityType.java
new file mode 100644
index 0000000..6253bc1
--- /dev/null
+++ b/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/EntityType.java
@@ -0,0 +1,118 @@
+package org.eclipse.persistence.jpa.dynamic;
+
+import java.util.ArrayList;
+
+import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicCollectionAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicMapAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ElementCollectionAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToManyAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToOneAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToManyAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToOneAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransformationAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransientAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VariableOneToOneAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VersionAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.columns.AssociationOverrideMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.columns.AttributeOverrideMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.columns.ColumnMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.sequencing.GeneratedValueMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.structures.ArrayAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.structures.StructureAccessor;
+
+public class EntityType {
+
+    private Mappings mappings;
+    
+    private EntityAccessor accessor;
+
+    public EntityType(Mappings mappings, String name) {
+        this.mappings = mappings;
+        this.accessor = new EntityAccessor();
+        this.accessor.setName(name);
+        this.accessor.setClassName(name);
+        this.accessor.setAccess("VIRTUAL");
+        this.accessor.setMetadataComplete(true);
+        this.accessor.setAssociationOverrides(new ArrayList<AssociationOverrideMetadata>());
+        this.accessor.setAttributeOverrides(new ArrayList<AttributeOverrideMetadata>());
+        
+        XMLAttributes xmlAttributes = new XMLAttributes();
+        this.accessor.setAttributes(xmlAttributes);
+        xmlAttributes.setEntityMappings(getMappings().getXmlMappings());
+        xmlAttributes.setIds(new ArrayList<IdAccessor>());
+        xmlAttributes.setBasics(new ArrayList<BasicAccessor>());
+
+        xmlAttributes.setBasicCollections(new ArrayList<BasicCollectionAccessor>());
+        xmlAttributes.setBasicMaps(new ArrayList<BasicMapAccessor>());
+        xmlAttributes.setArrays(new ArrayList<ArrayAccessor>());
+        xmlAttributes.setElementCollections(new ArrayList<ElementCollectionAccessor>());
+        xmlAttributes.setEmbeddeds(new ArrayList<EmbeddedAccessor>());
+        xmlAttributes.setManyToManys(new ArrayList<ManyToManyAccessor>());
+        xmlAttributes.setManyToOnes(new ArrayList<ManyToOneAccessor>());
+        xmlAttributes.setOneToManys(new ArrayList<OneToManyAccessor>());
+        xmlAttributes.setOneToOnes(new ArrayList<OneToOneAccessor>());
+        xmlAttributes.setStructures(new ArrayList<StructureAccessor>());
+        xmlAttributes.setTransformations(new ArrayList<TransformationAccessor>());
+        xmlAttributes.setTransients(new ArrayList<TransientAccessor>());
+        xmlAttributes.setVariableOneToOnes(new ArrayList<VariableOneToOneAccessor>());
+        xmlAttributes.setVersions(new ArrayList<VersionAccessor>());
+    }
+
+    public Mappings getMappings() {
+        return mappings;
+    }
+
+    public EntityAccessor getAccessor() {
+        return accessor;
+    }
+
+    public void addId(String name, String type, String columnName) {
+        IdAccessor id = new IdAccessor();
+        id.setName(name);
+        id.setAttributeType(type);
+        if (columnName != null) {
+            ColumnMetadata column = new ColumnMetadata();
+            column.setEntityMappings(getMappings().getXmlMappings());
+            column.setName(columnName);
+            id.setColumn(column);
+        }
+       getAccessor().getAttributes().getIds().add(id);
+    }
+
+    public void addGeneratedId(String name, String type, String columnName) {
+        IdAccessor id = new IdAccessor();
+        id.setName(name);
+        id.setAttributeType(type);
+        if (columnName != null) {
+            ColumnMetadata column = new ColumnMetadata();
+            column.setEntityMappings(getMappings().getXmlMappings());
+            column.setName(columnName);
+            id.setColumn(column);
+        }
+        GeneratedValueMetadata gen = new GeneratedValueMetadata();
+        gen.setEntityMappings(getMappings().getXmlMappings());
+        gen.setStrategy("AUTO");
+        id.setGeneratedValue(gen);
+        
+       getAccessor().getAttributes().getIds().add(id);
+    }
+
+    public void addBasic(String name, String type, String columnName) {
+        BasicAccessor basic = new BasicAccessor();
+        basic.setName(name);
+        basic.setAttributeType(type);
+        if (columnName != null) {
+            ColumnMetadata column = new ColumnMetadata();
+            column.setEntityMappings(getMappings().getXmlMappings());
+            column.setName(columnName);
+            basic.setColumn(column);
+        }
+        getAccessor().getAttributes().getBasics().add(basic);
+        
+    }
+}
diff --git a/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/Mappings.java b/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/Mappings.java
new file mode 100644
index 0000000..8235f31
--- /dev/null
+++ b/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/Mappings.java
@@ -0,0 +1,124 @@
+/*******************************************************************************
+ * Copyright (c) 2013 Oracle and/or its affiliates. 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 - initial
+ ******************************************************************************/
+package org.eclipse.persistence.jpa.dynamic;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.MappedSuperclassAccessor;
+import org.eclipse.persistence.internal.jpa.metadata.columns.TenantDiscriminatorColumnMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.converters.ConverterMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.converters.ObjectTypeConverterMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.converters.StructConverterMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.converters.TypeConverterMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.HashPartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.PartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.PinnedPartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.RangePartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.ReplicationPartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.RoundRobinPartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.UnionPartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.partitioning.ValuePartitioningMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.NamedNativeQueryMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredProcedureQueryMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.NamedQueryMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredFunctionQueryMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredProcedureQueryMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLRecordMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLTableMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.queries.SQLResultSetMappingMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.sequencing.SequenceGeneratorMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.sequencing.TableGeneratorMetadata;
+import org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappings;
+import org.eclipse.persistence.internal.jpa.metadata.xml.XMLPersistenceUnitMetadata;
+
+public class Mappings {
+    
+    private PersistenceUnit unit;
+
+    private XMLEntityMappings mappings;
+    
+    private Map<String, EntityType> types;
+    
+    protected Mappings(PersistenceUnit unit) {
+        this.unit = unit;
+        this.types = new HashMap<String, EntityType>();
+        this.mappings = new XMLEntityMappings();
+        
+        this.mappings.setAccess("VIRTUAL");
+        this.mappings.setPackage("org.eclipse.persistence.jpa.dynamic.model");
+        
+        XMLPersistenceUnitMetadata md = new XMLPersistenceUnitMetadata();
+        md.setEntityMappings(this.mappings);
+        md.setXMLMappingMetadataComplete(true);
+        this.mappings.setPersistenceUnitMetadata(md);
+        
+        // Populate empty collections
+        this.mappings.setConverters(new ArrayList<ConverterMetadata>());
+        this.mappings.setEmbeddables(new ArrayList<EmbeddableAccessor>());
+        this.mappings.setEntities(new ArrayList<EntityAccessor>());
+        this.mappings.setHashPartitioning(new ArrayList<HashPartitioningMetadata>());
+        this.mappings.setIsEclipseLinkORMFile(true);
+        this.mappings.setLoadedForCanonicalModel(false);
+        this.mappings.setLoader(getUnit().getInfo().getClassLoader());
+        this.mappings.setMappedSuperclasses(new ArrayList<MappedSuperclassAccessor>());
+        this.mappings.setMappingFile("in-memory");
+        this.mappings.setNamedQueries(new ArrayList<NamedQueryMetadata>());
+        this.mappings.setNamedStoredFunctionQueries(new ArrayList<NamedStoredFunctionQueryMetadata>());
+        this.mappings.setNamedNativeQueries(new ArrayList<NamedNativeQueryMetadata>());
+        this.mappings.setNamedPLSQLStoredFunctionQueries(new ArrayList<NamedPLSQLStoredFunctionQueryMetadata>());
+        this.mappings.setNamedPLSQLStoredProcedureQueries(new ArrayList<NamedPLSQLStoredProcedureQueryMetadata>());
+        this.mappings.setNamedStoredProcedureQueries(new ArrayList<NamedStoredProcedureQueryMetadata>());
+        this.mappings.setObjectTypeConverters(new ArrayList<ObjectTypeConverterMetadata>());
+        this.mappings.setPartitioning(new ArrayList<PartitioningMetadata>());
+        this.mappings.setPinnedPartitioning(new ArrayList<PinnedPartitioningMetadata>());
+        this.mappings.setPLSQLRecords(new ArrayList<PLSQLRecordMetadata>());
+        this.mappings.setPLSQLTables(new ArrayList<PLSQLTableMetadata>());
+        this.mappings.setRangePartitioning(new ArrayList<RangePartitioningMetadata>());
+        this.mappings.setReplicationPartitioning(new ArrayList<ReplicationPartitioningMetadata>());
+        this.mappings.setRoundRobinPartitioning(new ArrayList<RoundRobinPartitioningMetadata>());
+        this.mappings.setSequenceGenerators(new ArrayList<SequenceGeneratorMetadata>());
+        this.mappings.setSqlResultSetMappings(new ArrayList<SQLResultSetMappingMetadata>());
+        this.mappings.setStructConverters(new ArrayList<StructConverterMetadata>());
+        this.mappings.setTableGenerators(new ArrayList<TableGeneratorMetadata>());
+        this.mappings.setTenantDiscriminatorColumns(new ArrayList<TenantDiscriminatorColumnMetadata>());
+        this.mappings.setTypeConverters(new ArrayList<TypeConverterMetadata>());
+        this.mappings.setUnionPartitioning(new ArrayList<UnionPartitioningMetadata>());
+        this.mappings.setValuePartitioning(new ArrayList<ValuePartitioningMetadata>());
+    }
+    protected Map<String, EntityType> getTypes() {
+        return this.types;
+    }
+    
+    protected PersistenceUnit getUnit() {
+        return this.unit;
+    }
+    
+    protected XMLEntityMappings getXmlMappings() {
+        return this.mappings;
+    }
+
+    public EntityType addType(String name) {
+        EntityType type = new EntityType(this, name);
+        getTypes().put(name, type);
+        
+        getXmlMappings().getEntities().add(type.getAccessor());
+        
+        return type;
+    }
+    
+}
diff --git a/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/PersistenceUnit.java b/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/PersistenceUnit.java
new file mode 100644
index 0000000..0157957
--- /dev/null
+++ b/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/PersistenceUnit.java
@@ -0,0 +1,168 @@
+/*******************************************************************************
+ * Copyright (c) 2013 Oracle and/or its affiliates. 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 - initial
+ ******************************************************************************/
+package org.eclipse.persistence.jpa.dynamic;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.spi.PersistenceUnitInfo;
+import javax.persistence.spi.PersistenceUnitTransactionType;
+
+import org.eclipse.persistence.config.PersistenceUnitProperties;
+import org.eclipse.persistence.exceptions.PersistenceUnitLoadingException;
+import org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl;
+import org.eclipse.persistence.internal.jpa.EntityManagerFactoryProvider;
+import org.eclipse.persistence.internal.jpa.EntityManagerSetupImpl;
+import org.eclipse.persistence.internal.jpa.deployment.JPAInitializer;
+import org.eclipse.persistence.internal.jpa.deployment.SEPersistenceUnitInfo;
+import org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappings;
+import org.eclipse.persistence.jpa.PersistenceProvider;
+import org.eclipse.persistence.jpa.metadata.XMLMetadataSource;
+import org.eclipse.persistence.logging.SessionLog;
+
+public class PersistenceUnit {
+
+    private SEPersistenceUnitInfo puInfo;
+
+    private Mappings mappings;
+
+    public PersistenceUnit(String name, ClassLoader cl) {
+        this.puInfo = new SEPersistenceUnitInfo();
+        this.puInfo.setClassLoader(cl);
+        this.puInfo.setPersistenceUnitName(name);
+        try {
+            this.puInfo.setPersistenceUnitRootUrl(new URL("http://localhost"));
+        } catch (MalformedURLException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+        this.puInfo.setTransactionType(PersistenceUnitTransactionType.RESOURCE_LOCAL);
+
+        this.puInfo.setProperties(new Properties());
+
+        this.mappings = new Mappings(this);
+
+        this.puInfo.getProperties().put(PersistenceUnitProperties.METADATA_SOURCE, new InMemoryMetadataSource());
+    }
+
+    public PersistenceUnitInfo getInfo() {
+        return this.puInfo;
+    }
+
+    public Mappings getMappings() {
+        return this.mappings;
+    }
+
+    public void setProperty(String key, String value) {
+        getInfo().getProperties().put(key, value);
+    }
+
+    private class InMemoryMetadataSource extends XMLMetadataSource {
+        @Override
+        public XMLEntityMappings getEntityMappings(Map<String, Object> properties, ClassLoader classLoader, SessionLog log) {
+            return getMappings().getXmlMappings();
+        }
+
+    }
+
+    public EntityManagerFactory createEntityManagerFactory() {
+        EntityManagerSetupImpl emSetupImpl = null;
+        boolean isNew = false;
+        // the name that uniquely defines persistence unit
+        String name = getInfo().getPersistenceUnitName();
+
+        // TODO: Fix this
+        String uniqueName = name;
+        String sessionName = name;
+        Map<String, Object> nonNullProperties = new HashMap<>();
+        JPAInitializer initializer = new PersistenceProvider().getInitializer(name, nonNullProperties);
+
+        try {
+            uniqueName = initializer.createUniquePersistenceUnitName(puInfo);
+
+            sessionName = EntityManagerSetupImpl.getOrBuildSessionName(nonNullProperties, puInfo, uniqueName);
+            synchronized (EntityManagerFactoryProvider.emSetupImpls) {
+                emSetupImpl = EntityManagerFactoryProvider.getEntityManagerSetupImpl(sessionName);
+                if (emSetupImpl == null) {
+                    // there may be initial emSetupImpl cached in Initializer -
+                    // remove it and use.
+                    emSetupImpl = initializer.extractInitialEmSetupImpl(name);
+                    if (emSetupImpl != null) {
+                        // change the name
+                        emSetupImpl.changeSessionName(sessionName);
+                    } else {
+                        // create and predeploy a new emSetupImpl
+                        emSetupImpl = initializer.callPredeploy(puInfo, nonNullProperties, uniqueName, sessionName);
+                    }
+                    // emSetupImpl has been already predeployed, predeploy will
+                    // just increment factoryCount.
+                    emSetupImpl.predeploy(emSetupImpl.getPersistenceUnitInfo(), nonNullProperties);
+                    EntityManagerFactoryProvider.addEntityManagerSetupImpl(sessionName, emSetupImpl);
+                    isNew = true;
+                }
+            }
+
+        } catch (Exception e) {
+            throw PersistenceUnitLoadingException.exceptionSearchingForPersistenceResources(initializer.getInitializationClassLoader(), e);
+        }
+
+        if (!isNew) {
+            if (!uniqueName.equals(emSetupImpl.getPersistenceUnitUniqueName())) {
+                throw PersistenceUnitLoadingException.sessionNameAlreadyInUse(sessionName, uniqueName, emSetupImpl.getPersistenceUnitUniqueName());
+            }
+
+            // synchronized to prevent undeploying by other threads.
+            boolean undeployed = false;
+            synchronized (emSetupImpl) {
+                if (emSetupImpl.isUndeployed()) {
+                    undeployed = true;
+                }
+
+                // emSetupImpl has been already predeployed, predeploy will just
+                // increment factoryCount.
+                emSetupImpl.predeploy(emSetupImpl.getPersistenceUnitInfo(), nonNullProperties);
+            }
+            if (undeployed) {
+                // after the emSetupImpl has been obtained from emSetupImpls
+                // it has been undeployed by factory.close() in another thread -
+                // start all over again.
+                return createEntityManagerFactory();
+            }
+        }
+
+        EntityManagerFactoryImpl factory = null;
+        try {
+            factory = new EntityManagerFactoryImpl(emSetupImpl, nonNullProperties);
+
+            // This code has been added to allow validation to occur without
+            // actually calling createEntityManager
+            if (emSetupImpl.shouldGetSessionOnCreateFactory(nonNullProperties)) {
+                factory.getDatabaseSession();
+            }
+            return factory;
+        } catch (RuntimeException ex) {
+            if (factory != null) {
+                factory.close();
+            } else {
+                emSetupImpl.undeploy();
+            }
+            throw ex;
+        }
+
+    }
+
+}
diff --git a/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/package-info.java b/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/package-info.java
deleted file mode 100644
index 30c5cb3..0000000
--- a/jpars.script.clojure/src/main/java/org/eclipse/persistence/jpa/dynamic/package-info.java
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * 
- */
-/**
- * @author dclarke
- *
- */
-package org.eclipse.persistence.jpa.dynamic;
\ No newline at end of file
diff --git a/jpars.script.clojure/src/test/java/test/jpa/dynamic/TestCreate.java b/jpars.script.clojure/src/test/java/test/jpa/dynamic/TestCreate.java
new file mode 100644
index 0000000..4babd12
--- /dev/null
+++ b/jpars.script.clojure/src/test/java/test/jpa/dynamic/TestCreate.java
@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * Copyright (c) 2013 Oracle and/or its affiliates. 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 - initial
+ ******************************************************************************/
+package test.jpa.dynamic;
+
+import javax.persistence.EntityManagerFactory;
+
+import org.eclipse.persistence.config.PersistenceUnitProperties;
+import org.eclipse.persistence.jpa.JpaHelper;
+import org.eclipse.persistence.jpa.dynamic.EntityType;
+import org.eclipse.persistence.jpa.dynamic.PersistenceUnit;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestCreate {
+
+    @Test
+    public void createEmpty() {
+        PersistenceUnit unit = new PersistenceUnit("test", Thread.currentThread().getContextClassLoader());
+        
+        unit.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.apache.derby.jdbc.EmbeddedDriver");
+        unit.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:derby:target/derby/test;create=true");
+        unit.setProperty(PersistenceUnitProperties.JDBC_USER, "app");
+        unit.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "app");
+        
+        unit.setProperty(PersistenceUnitProperties.LOGGING_LEVEL, "FINE");
+
+        EntityManagerFactory emf = unit.createEntityManagerFactory();
+        
+        Assert.assertNotNull(emf);
+        Assert.assertTrue(emf.isOpen());
+        
+        JpaHelper.getServerSession(emf);
+        
+        emf.close();
+    }
+
+    @Test
+    public void createSimple() {
+        PersistenceUnit unit = new PersistenceUnit("test", Thread.currentThread().getContextClassLoader());
+        
+        unit.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.apache.derby.jdbc.EmbeddedDriver");
+        unit.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:derby:target/derby/test;create=true");
+        unit.setProperty(PersistenceUnitProperties.JDBC_USER, "app");
+        unit.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "app");
+        
+        unit.setProperty(PersistenceUnitProperties.DDL_GENERATION_MODE, PersistenceUnitProperties.DDL_DATABASE_GENERATION);
+        unit.setProperty(PersistenceUnitProperties.DDL_GENERATION, PersistenceUnitProperties.DROP_AND_CREATE);
+
+        unit.setProperty(PersistenceUnitProperties.LOGGING_LEVEL, "FINE");
+        
+        // Add simple Person type
+        EntityType person = unit.getMappings().addType("Person");
+        person.addGeneratedId("id", "Integer", null);
+        person.addBasic("name", "String", null);
+
+        EntityManagerFactory emf = unit.createEntityManagerFactory();
+        
+        Assert.assertNotNull(emf);
+        Assert.assertTrue(emf.isOpen());
+        
+        JpaHelper.getServerSession(emf);
+        
+        emf.close();
+    }
+}