Add JUnit tests for One-to-Many unidirectional relationship JPA 2.0 support

2 files changed, 480 insertions, 42 deletions

diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/JPACreateFactory.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/JPACreateFactory.java
index 5c79978a1d..ca03444531 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/JPACreateFactory.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/JPACreateFactory.java
@@ -2,9 +2,7 @@ package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.File;
 import java.io.IOException;
-import java.net.URL;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -19,7 +17,6 @@ import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceDescription;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.FileLocator;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.NullProgressMonitor;
@@ -46,7 +43,6 @@ import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetInstallDataModelPropertie
 import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetInstallDataModelProvider;
 import org.eclipse.jpt.jpa.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
-import org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.util.URLEscaper;
 import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
 import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory;
 import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
@@ -92,15 +88,17 @@ public class JPACreateFactory {
 	}
 	
 	public JpaProject createJPAProject(String projectName) throws CoreException {
-		return createJPAProject(projectName, null);
+		return createJPAProject(projectName, null, "1.0");
 	}
 
+	public JpaProject createJPA20Project(String projectName) throws CoreException {
+		return createJPAProject(projectName, null, "2.0");
+	}
 	
 	
-	public JpaProject createJPAProject(String projectName, IDataModel jpaConfig) throws CoreException {
+	public JpaProject createJPAProject(String projectName, IDataModel jpaConfig, String jpaFacetVersion) throws CoreException {
 		project = buildPlatformProject(projectName);
 		javaProject = createJavaProject(project, true);
-		String jpaFacetVersion = "1.0";
 		if (jpaConfig != null) {
 			jpaFacetVersion = jpaConfig.getStringProperty(IFacetDataModelProperties.FACET_VERSION_STR);
 		}
@@ -182,7 +180,7 @@ public class JPACreateFactory {
 	}
 	
 	public IJavaProject createJavaProject(IProject project,  
-										  @SuppressWarnings("unused") boolean autoBuild) throws CoreException {
+										  boolean autoBuild) throws CoreException {
 		facetedProject = createFacetedProject(project);
 		installFacet(facetedProject, "jst.java", "5.0");
 		javaProject = JavaCore.create(project);
@@ -237,12 +235,25 @@ public class JPACreateFactory {
 		return entity1;
 	}
 	
-	@SuppressWarnings("deprecation")
 	public IFile createEntityInProject(IProject project, 
 									   String[] packageFragments, 
 									   String entityName) throws IOException, 
 									   							 CoreException, 
 									   							 JavaModelException {
+		String folderName = getFolderName(project, packageFragments);
+		String packageName = packageFragments[0];		
+		for (int i = 1; i < packageFragments.length; i++) {
+			packageName += "." + packageFragments[i];
+		}
+		
+		IPath path = new Path(folderName);
+		IFolder folder = project.getFolder(path);		 
+		return createEntity(folder, packageName , entityName);
+	}
+
+	@SuppressWarnings("deprecation")
+	private String getFolderName(IProject project, String[] packageFragments)
+			throws JavaModelException {
 		IJavaProject javaProject = JavaCore.create(project);		
 		IPackageFragmentRoot[] packageFragmentRoots = new IPackageFragmentRoot[0];
 		final IClasspathEntry[] classpathEntries =  javaProject.getRawClasspath();		
@@ -257,14 +268,7 @@ public class JPACreateFactory {
 		for (String fragment : packageFragments) {
 			folderName += Path.SEPARATOR + fragment;
 		}
-		String packageName = packageFragments[0];		
-		for (int i = 1; i < packageFragments.length; i++) {
-			packageName += "." + packageFragments[i];
-		}
-		
-		IPath path = new Path(folderName);
-		IFolder folder = project.getFolder(path);		 
-		return createEntity(folder, packageName , entityName);
+		return folderName;
 	}
 	
 	private IFile createEntity(IFolder folder, String packageName, String entityName) throws IOException, CoreException {
@@ -299,6 +303,204 @@ public class JPACreateFactory {
 		return file;
 	}	
 	
+	public IFile createEntityWithCompositePKInProject(IProject project,
+			String[] packageFragments, String entityName) throws IOException,
+			CoreException, JavaModelException {
+		String folderName = getFolderName(project, packageFragments);
+
+		String packageName = packageFragments[0];
+		for (int i = 1; i < packageFragments.length; i++) {
+			packageName += "." + packageFragments[i];
+		}
+
+		IPath path = new Path(folderName);
+		IFolder folder = project.getFolder(path);
+		return createEntityWithCompositePK(folder, packageName, entityName);
+	}
+
+	public IFile createIdClassInProject(IProject project,
+			String[] packageFragments, String entityName) throws IOException,
+			CoreException, JavaModelException {
+		String folderName = getFolderName(project, packageFragments);
+
+		String packageName = packageFragments[0];
+		for (int i = 1; i < packageFragments.length; i++) {
+			packageName += "." + packageFragments[i];
+		}
+
+		IPath path = new Path(folderName);
+		IFolder folder = project.getFolder(path);
+		return createIdClass(folder, packageName, entityName);
+	}
+
+	public IFile createEmbeddedClassInProject(IProject project,
+			String[] packageFragments, String entityName) throws IOException,
+			CoreException, JavaModelException {
+		String folderName = getFolderName(project, packageFragments);
+
+		String packageName = packageFragments[0];
+		for (int i = 1; i < packageFragments.length; i++) {
+			packageName += "." + packageFragments[i];
+		}
+
+		IPath path = new Path(folderName);
+		IFolder folder = project.getFolder(path);
+		return createEmbeddedClass(folder, packageName, entityName);
+	}
+
+	public IFile createEntityWithEmbeddedPKInProject(IProject project,
+			String[] packageFragments, String entityName) throws IOException,
+			CoreException, JavaModelException {
+		String folderName = getFolderName(project, packageFragments);
+
+		String packageName = packageFragments[0];
+		for (int i = 1; i < packageFragments.length; i++) {
+			packageName += "." + packageFragments[i];
+		}
+
+		IPath path = new Path(folderName);
+		IFolder folder = project.getFolder(path);
+		return createEntityWithEmbeddedPK(folder, packageName, entityName);
+	}
+	
+		
+		
+		private IFile createEntityWithCompositePK(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+			String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+			if (!folder.exists()) {
+				createDirectories(folder, true, true, new NullProgressMonitor());
+			}
+			IFile file = folder.getFile(entityShortName + ".java");		
+			if (!file.exists()) {
+				String content = "package " + packageName + ";\n\n" 
+						+ "import javax.persistence.*;\n\n" 
+						+ "@Entity \n"
+						+ "@IdClass("+entityShortName+"Id.class)"
+					+ "public class " + entityShortName + " {\n"
+						+ "	@Id \n"
+						+ "	private String firstName;\n"
+						+ "	@Id \n"
+						+ "	private String lastName;\n"
+						+ " public "+entityShortName+"Id() {}\n"
+	                    + " public "+entityShortName+"Id(String firstName, String lastName)\n{"
+	                    + "     this.firstName = firstName;\n"
+	                    + "     this.lastName = lastName;\n"
+	                    + " }\n"
+						+ "}"; //$NON-NLS-1$
+				ByteArrayOutputStream stream = new ByteArrayOutputStream();
+				try {
+					stream.write(content.getBytes());
+					stream.flush();
+					file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+				} finally {
+					stream.close();
+				}	
+			}
+			return file;
+			}
+		
+		private IFile createIdClass(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+			String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+			if (!folder.exists()) {
+				createDirectories(folder, true, true, new NullProgressMonitor());
+			}
+			IFile file = folder.getFile(entityShortName + "Id.java");		
+			if (!file.exists()) {
+				String content = "package " + packageName + ";\n\n" 
+						+ "import javax.persistence.*;\n\n" 
+						+"import java.io.Serializable;"
+						+ "public class " + entityShortName + "Id {\n"
+						+ "	private String firstName;\n"
+						+ "	private String lastName;\n"
+						+ "	public String getFirstName() {\n" 
+						+ "		return firstName;\n"
+						+ "	}\n"
+						+ "	public void setFirstName(String firstName) {\n"
+						+ "		this.firstName = firstName;\n" 
+						+ "	}\n"
+						+ "	public String getLastName() {\n" 
+						+ "		return lastName;\n"
+						+ "	}\n"
+						+ "	public void setLastName(String lastName) {\n"
+						+ "		this.lastName = lastName;\n" 
+						+ "	}\n"
+						+ "}"; //$NON-NLS-1$
+				ByteArrayOutputStream stream = new ByteArrayOutputStream();
+				try {
+					stream.write(content.getBytes());
+					stream.flush();
+					file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+				} finally {
+					stream.close();
+				}	
+			}
+			return file;
+			}
+		
+		private IFile createEntityWithEmbeddedPK(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+			String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+			if (!folder.exists()) {
+				createDirectories(folder, true, true, new NullProgressMonitor());
+			}
+			IFile file = folder.getFile(entityShortName + ".java");		
+			if (!file.exists()) {
+				String content = "package " + packageName + ";\n\n" 
+						+ "import javax.persistence.*;\n\n" 					
+						+ "@Entity\n"
+						+ "public class " + entityShortName + " {\n"
+						+ "@EmbeddedId\n"
+						+ "	private "+ entityShortName +"Id id;\n"						
+						+ "public void setId(" + entityShortName+ "Id param) {\n"
+						+ "	this.id = param;\n"
+						+ "}\n"
+						+ "public "+entityShortName+"Id getId() {\n"
+						+	"return id;\n"
+						+ "}\n"						
+						+ "}"; //$NON-NLS-1$
+				ByteArrayOutputStream stream = new ByteArrayOutputStream();
+				try {
+					stream.write(content.getBytes());
+					stream.flush();
+					file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+				} finally {
+					stream.close();
+				}	
+			}
+			return file;
+			}
+		
+		private IFile createEmbeddedClass(IFolder folder, String packageName, String entityName) throws IOException, CoreException{
+			String entityShortName = entityName.substring(entityName.lastIndexOf('.') + 1);
+			if (!folder.exists()) {
+				createDirectories(folder, true, true, new NullProgressMonitor());
+			}
+			IFile file = folder.getFile(entityShortName + ".java");		
+		if (!file.exists()) {
+			String content = "package " + packageName + ";\n\n"
+			                 + "import javax.persistence.*;\n" 
+			                 + "@Embeddable\n"
+					         + "public class " + entityShortName + " {\n"
+					     	 +"private String firstName;\n"
+					     	 +"public String getFirstName() {\n"
+					     	 + "	return firstName;\n"
+					     	 + "}\n"
+					     	 + "public void setFirstName(String firstName) {\n"
+					     	 +	"this.firstName = firstName;\n"
+					     	 + "}\n"
+					         + "}"; //$NON-NLS-1$
+				ByteArrayOutputStream stream = new ByteArrayOutputStream();
+				try {
+					stream.write(content.getBytes());
+					stream.flush();
+					file.create(new ByteArrayInputStream(stream.toByteArray()), true, new NullProgressMonitor());
+				} finally {
+					stream.close();
+				}	
+			}
+			return file;
+			}
+	
+	
 	private void createDirectories(IContainer container, boolean force,
 			boolean local, IProgressMonitor monitor) throws CoreException {
 		if (container != null && container instanceof IFolder) {
@@ -403,22 +605,8 @@ public class JPACreateFactory {
 		return file;
 	}	
 
-	@SuppressWarnings("deprecation")
 	public IFile createFieldAnnotatedEntityInProject(IProject project, String[] packageFragments, String entityName) throws IOException, CoreException, JavaModelException {
-		IJavaProject javaProject = JavaCore.create(project);		
-		IPackageFragmentRoot[] packageFragmentRoots = new IPackageFragmentRoot[0];
-		final IClasspathEntry[] classpathEntries =  javaProject.getRawClasspath();		
-		for (IClasspathEntry classpathEntry : classpathEntries) {
-			if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
-				packageFragmentRoots = javaProject.getPackageFragmentRoots(classpathEntry);
-				break;
-			}  			
-		}
-		
-		String folderName = packageFragmentRoots[0].getResource().getName();
-		for (String fragment : packageFragments) {
-			folderName += Path.SEPARATOR + fragment;
-		}
+		String folderName = getFolderName(project, packageFragments);
 		String packageName = packageFragments[0];		
 		for (int i = 1; i < packageFragments.length; i++) {
 			packageName += "." + packageFragments[i];
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsTest.java
index 6a3bba47a6..ba81940fe2 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsTest.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsTest.java
@@ -18,42 +18,39 @@ package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.relation;
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.isA;
 import static org.easymock.EasyMock.replay;
+import static org.junit.Assert.*;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
-import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.Properties;
-import java.util.Set;
 
 import org.easymock.EasyMock;
 import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IncrementalProjectBuilder;
 import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.graphiti.features.context.IAddContext;
-import org.eclipse.graphiti.mm.pictograms.ContainerShape;
 import org.eclipse.graphiti.mm.pictograms.Shape;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jpt.common.utility.Command;
 import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
-import org.eclipse.jpt.common.utility.internal.synchronizers.CallbackAsynchronousSynchronizer;
 import org.eclipse.jpt.jpa.core.JpaFile;
 import org.eclipse.jpt.jpa.core.JpaProject;
 import org.eclipse.jpt.jpa.core.JpaStructureNode;
 import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
+import org.eclipse.jpt.jpa.core.context.AttributeMapping;
+import org.eclipse.jpt.jpa.core.context.Embeddable;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.jpa.core.resource.java.JavaResourcePersistentType;
+import org.eclipse.jpt.jpa.core.resource.java.JoinColumnAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.JoinColumnsAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.ManyToManyAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.ManyToOneAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.NestableJoinColumnAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.OneToManyAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.OneToOneAnnotation;
-import org.eclipse.jpt.jpa.core.resource.java.OwnableRelationshipMappingAnnotation;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.propertypage.JPADiagramPropertyPage;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.AbstractRelation;
@@ -67,6 +64,7 @@ import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.OneToOneUniDirRela
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IEclipseFacade;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
 import org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.JPACreateFactory;
+import org.eclipse.swt.widgets.Display;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -84,6 +82,8 @@ public class CreateRelationsTest {
 	ICompilationUnit cu1 = null;
 	JavaPersistentType t2 = null;
 	ICompilationUnit cu2 = null;
+	private IJPAEditorFeatureProvider featureProvider20;
+	private JpaProject jpa20Project;
 	
 	
 	@Before
@@ -147,8 +147,17 @@ public class CreateRelationsTest {
 		props.setProperty(JPADiagramPropertyPage.PROP_COLLECTION_TYPE.getLocalName(), "collection");
 		expect(featureProvider.loadProperties(jpaProject.getProject())).andStubReturn(props);
 		
-		replay(featureProvider);		
+		replay(featureProvider);	
 		
+		jpa20Project = factory.createJPA20Project(TEST_PROJECT + "_" + System.currentTimeMillis());
+		assertNotNull(jpa20Project);
+
+		IFile entity20 = factory.createEntity(jpa20Project,	"org.eclipse.Entity1");
+		Thread.sleep(2000);
+		featureProvider20 = EasyMock.createMock(IJPAEditorFeatureProvider.class);
+		expect(featureProvider20.getBusinessObjectForPictogramElement(null)).andReturn(getPersistentType(entity20));
+		expect(featureProvider20.getCompilationUnit(isA(JavaPersistentType.class)))
+				.andReturn(JavaCore.createCompilationUnitFrom(entity20)).anyTimes();
 	}
 	
 	public static JavaPersistentType getPersistentType(IFile file){
@@ -315,5 +324,246 @@ public class CreateRelationsTest {
 		
 	}
 
+	@Test
+		public void testCreateOneToManyUnidirRelation20() throws Exception {
+			
+			assertNotNull(jpa20Project);	
+			IFile customerFile = factory.createEntityInProject(jpa20Project.getProject(), new String[]{"com","test"}, "Customer");
+			
+			IFile addressFile = factory.createEntityInProject(jpa20Project.getProject(), new String[]{"com"}, "Address");
+			
+			jpa20Project.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+	
+			assertTrue(customerFile.exists());
+			JavaResourcePersistentType customerType = jpa20Project.getJavaResourcePersistentType("com.test.Customer");
+			assertNotNull(customerType);
+					
+			JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, customerType.getQualifiedName());
+			int c = 0;
+			while ((t1 == null) && (c < MAX_NUM_OF_ITERATIONS)) {
+				Thread.sleep(200);
+				jpa20Project.update(null);
+				t1 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, customerType.getQualifiedName());
+				c++;
+			}
+					
+			expect(featureProvider20.getPictogramElementForBusinessObject(t1)).andStubReturn(isA(Shape.class));
+			ICompilationUnit cu1 = JavaCore.createCompilationUnitFrom(customerFile);
+			expect(featureProvider20.getCompilationUnit(t1)).andStubReturn(cu1);
+				
+			assertTrue(addressFile.exists());
+			JavaResourcePersistentType addressType = jpa20Project.getJavaResourcePersistentType("com.Address");
+			assertNotNull(customerType);
+	
+			
+			JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, addressType.getQualifiedName());
+			while ((t2 == null) && (c < MAX_NUM_OF_ITERATIONS)) {
+				Thread.sleep(200);
+				jpa20Project.update(null);
+				t2 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, addressType.getQualifiedName());
+				c++;
+			}
+			expect(featureProvider20.getPictogramElementForBusinessObject(t2)).andStubReturn(isA(Shape.class));
+			ICompilationUnit cu2 = JavaCore.createCompilationUnitFrom(addressFile);
+			expect(featureProvider20.getCompilationUnit(t2)).andStubReturn(cu2);
+			
+			Properties props = new Properties();
+			props.setProperty(JPADiagramPropertyPage.PROP_COLLECTION_TYPE.getLocalName(), "list");
+			expect(featureProvider20.loadProperties(jpa20Project.getProject())).andReturn(props);
+			replay(featureProvider20);
+							
+			AbstractRelation rel = new OneToManyUniDirRelation(featureProvider20, t1, t2, "address",
+									  					true, 
+									  					cu1,
+									  					cu2);
+			assertNotNull(rel);
+			assertSame(t1, rel.getOwner());
+			assertSame(t2, rel.getInverse());
+			assertEquals("address", rel.getOwnerAttributeName());
+			JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+			assertNotNull(ownerAt);
+			
+			Object o1 = ownerAt.getResourcePersistentAttribute().getAnnotation(OneToManyAnnotation.ANNOTATION_NAME);
+			assertNotNull(o1);
+			
+			Object o2 = ownerAt.getResourcePersistentAttribute().getAnnotation(JoinColumnAnnotation.ANNOTATION_NAME);
+			assertNotNull(o2);
+			
+			JoinColumnAnnotation joinColumn = (JoinColumnAnnotation) o2;
+			assertNotNull(joinColumn.getName());
+			
+			assertNotNull(joinColumn.getReferencedColumnName());
+			
+			assertEquals("Customer_id", joinColumn.getName());
+			assertEquals("id", joinColumn.getReferencedColumnName());
+						
+		}
+		
+		
+		@Test
+		public void testCreateOneToManyUnidirIDClassRelation20() throws Exception {
+			
+			assertNotNull(jpa20Project);	
+			IFile simpleEmployeeFile = factory.createIdClassInProject(jpa20Project.getProject(), new String[]{"com","test"}, "Employee");
+			IFile employeeFile = factory.createEntityWithCompositePKInProject(jpa20Project.getProject(), new String[]{"com","test"}, "Employee");
+	
+			IFile projectFile = factory.createEntityInProject(jpa20Project.getProject(), new String[]{"com"}, "Project");
+			
+			jpa20Project.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+			
+			assertTrue(simpleEmployeeFile.exists());
+			assertTrue(employeeFile.exists());
+			JavaResourcePersistentType employeeType = jpa20Project.getJavaResourcePersistentType("com.test.Employee");
+			assertNotNull(employeeType);
+					
+			JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, employeeType.getQualifiedName());
+			int c = 0;
+			while ((t1 == null) && (c < MAX_NUM_OF_ITERATIONS)) {
+				Thread.sleep(200);
+				jpa20Project.update(null);
+				t1 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, employeeType.getQualifiedName());
+				c++;
+			}
+					
+			expect(featureProvider20.getPictogramElementForBusinessObject(t1)).andStubReturn(isA(Shape.class));
+			ICompilationUnit cu1 = JavaCore.createCompilationUnitFrom(employeeFile);
+			expect(featureProvider20.getCompilationUnit(t1)).andStubReturn(cu1);
+				
+			assertTrue(projectFile.exists());
+			JavaResourcePersistentType projectType = jpa20Project.getJavaResourcePersistentType("com.Project");
+			assertNotNull(employeeType);
+	
+			
+			JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, projectType.getQualifiedName());
+			while ((t2 == null) && (c < MAX_NUM_OF_ITERATIONS)) {
+				Thread.sleep(200);
+				jpa20Project.update(null);
+				t2 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, projectType.getQualifiedName());
+				c++;
+			}
+			expect(featureProvider20.getPictogramElementForBusinessObject(t2)).andStubReturn(isA(Shape.class));
+			ICompilationUnit cu2 = JavaCore.createCompilationUnitFrom(projectFile);
+			expect(featureProvider20.getCompilationUnit(t2)).andStubReturn(cu2);
+			Properties props = new Properties();
+			props.setProperty(JPADiagramPropertyPage.PROP_COLLECTION_TYPE.getLocalName(), "list");
+			expect(featureProvider20.loadProperties(jpa20Project.getProject())).andReturn(props);
+			replay(featureProvider20);
+							
+			AbstractRelation rel = new OneToManyUniDirRelation(featureProvider20, t1, t2, "project",
+									  					true, 
+									  					cu1,
+									  					cu2);
+			assertNotNull(rel);
+			assertSame(t1, rel.getOwner());
+			assertSame(t2, rel.getInverse());
+			assertEquals("project", rel.getOwnerAttributeName());
+			JavaPersistentAttribute ownerAt = t1.getAttributeNamed("project");
+			assertNotNull(ownerAt);
+			
+			Object o1 = ownerAt.getResourcePersistentAttribute().getAnnotation(OneToManyAnnotation.ANNOTATION_NAME);
+			assertNotNull(o1);
+			
+			Object o2 = ownerAt.getResourcePersistentAttribute().getAnnotation(JoinColumnsAnnotation.ANNOTATION_NAME);
+			assertNotNull(o2);
+			
+			JoinColumnsAnnotation joinColumns = (JoinColumnsAnnotation) o2;
+			assertEquals(2, joinColumns.getNestedAnnotationsSize());
+			assertEquals("javax.persistence.JoinColumn", joinColumns.getNestedAnnotationName());
+			
+						
+		}
+		
+		@Test
+		public void testCreateOneToManyUnidirEmbeddedRelation20() throws Exception {
+			
+			assertNotNull(jpa20Project);	
+			IFile simpleEmployeeFile = factory.createEmbeddedClassInProject(jpa20Project.getProject(), new String[]{"com","test"}, "EmployeerId");
+			IFile employeeFile = factory.createEntityWithEmbeddedPKInProject(jpa20Project.getProject(), new String[]{"com","test"}, "Employeer");
+	
+			IFile projectFile = factory.createEntityInProject(jpa20Project.getProject(), new String[]{"com"}, "Person");
+			
+			jpa20Project.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+			
+			assertTrue(simpleEmployeeFile.exists());
+			assertTrue(employeeFile.exists());
+			JavaResourcePersistentType employeeType = jpa20Project.getJavaResourcePersistentType("com.test.Employeer");
+			assertNotNull(employeeType);
+			
+					
+			JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, employeeType.getQualifiedName());
+			int c = 0;
+			while ((t1 == null) && (c < MAX_NUM_OF_ITERATIONS)) {
+				Thread.sleep(200);
+				jpa20Project.update(null);
+				t1 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, employeeType.getQualifiedName());
+				c++;
+			}
+					
+			expect(featureProvider20.getPictogramElementForBusinessObject(t1)).andStubReturn(isA(Shape.class));
+			ICompilationUnit cu1 = JavaCore.createCompilationUnitFrom(employeeFile);
+			expect(featureProvider20.getCompilationUnit(t1)).andStubReturn(cu1);
+			
+			
+			Embeddable emb = JpaArtifactFactory.instance().getPersistenceUnit(t1).getEmbeddable("com.test.EmployeerId");
+			Iterator<AttributeMapping> embIt = emb.allAttributeMappings();
+			int c1 = 0;
+			while ((embIt.hasNext() == false) && (c1 < MAX_NUM_OF_ITERATIONS)) {
+				Thread.sleep(200);
+				jpa20Project.update(null);
+				emb.update();
+				embIt = emb.allAttributeMappings();
+				c1++;
+			}
+							
+			assertTrue(projectFile.exists());
+			JavaResourcePersistentType projectType = jpa20Project.getJavaResourcePersistentType("com.Person");
+			assertNotNull(employeeType);
+	
+			
+			JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, projectType.getQualifiedName());
+			while ((t2 == null) && (c < MAX_NUM_OF_ITERATIONS)) {
+				Thread.sleep(200);
+				jpa20Project.update(null);
+				t2 = JpaArtifactFactory.instance().getContextPersistentType(jpa20Project, projectType.getQualifiedName());
+				c++;
+			}
+			
+			expect(featureProvider20.getPictogramElementForBusinessObject(t2)).andStubReturn(isA(Shape.class));
+			ICompilationUnit cu2 = JavaCore.createCompilationUnitFrom(projectFile);
+			expect(featureProvider20.getCompilationUnit(t2)).andStubReturn(cu2);
+			Properties props = new Properties();
+			props.setProperty(JPADiagramPropertyPage.PROP_COLLECTION_TYPE.getLocalName(), "list");
+			expect(featureProvider20.loadProperties(jpa20Project.getProject())).andReturn(props);
+			replay(featureProvider20);
+										
+			AbstractRelation rel = new OneToManyUniDirRelation(featureProvider20, t1, t2, "person",
+									  					true, 
+									  					cu1,
+									  					cu2);
+			assertNotNull(rel);
+			assertSame(t1, rel.getOwner());
+			assertSame(t2, rel.getInverse());
+			assertEquals("person", rel.getOwnerAttributeName());
+		    JavaPersistentAttribute ownerAt = t1.getAttributeNamed("person");
+			assertNotNull(ownerAt);
+						
+			Object o1 = ownerAt.getResourcePersistentAttribute().getAnnotation(OneToManyAnnotation.ANNOTATION_NAME);
+			assertNotNull(o1);
+			
+			Object o2 = ownerAt.getResourcePersistentAttribute().getAnnotation(JoinColumnsAnnotation.ANNOTATION_NAME);
+			assertNotNull(o2);
+			
+			JoinColumnsAnnotation joinColumns = (JoinColumnsAnnotation) o2;
+			assertEquals(1, joinColumns.getNestedAnnotationsSize());
+			assertEquals("javax.persistence.JoinColumn", joinColumns.getNestedAnnotationName());
+			Iterable<NestableJoinColumnAnnotation> nestedAnnotations = joinColumns.getNestedAnnotations();
+			Iterator<NestableJoinColumnAnnotation> nestedIterator = nestedAnnotations.iterator();
+			while(nestedIterator.hasNext()){
+				NestableJoinColumnAnnotation joinColumn = nestedIterator.next();
+				assertEquals("Employeer_firstName",joinColumn.getName());
+				assertEquals("firstName",joinColumn.getReferencedColumnName());
+			}
+						
+		}
 	
 }