diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/icons/ent/add_element-collection.gif b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/icons/ent/add_element-collection.gif
new file mode 100644
index 0000000..d03b399
--- /dev/null
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/icons/ent/add_element-collection.gif
Binary files differ
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/AddAttributeCommand.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/AddAttributeCommand.java
index 5c7d53e..1a693d8 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/AddAttributeCommand.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/AddAttributeCommand.java
@@ -1,5 +1,23 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.command;
 
+import java.util.Iterator;
+import java.util.List;
 import java.util.Locale;
 import java.util.Properties;
 
@@ -18,22 +36,43 @@
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
 
-public class AddAttributeCommand implements Command{
+/**
+ * A new {@link Command} class that is called to create a new attribute in the
+ * selected persistent type.
+ * 
+ * @author i045693
+ * 
+ */
+public class AddAttributeCommand implements Command {
 
 	private IJPAEditorFeatureProvider fp;
 	private JavaPersistentType jpt;
-	private JavaPersistentType attributeType;
+	private String attributeType;
 	private String mapKeyType;
 	private String attributeName;
 	private String actName;
+	private String[] attrTypes;
+	private List<String> annotations;
 	private boolean isCollection;
-	private ICompilationUnit cu1;
-	private ICompilationUnit cu2;
-	
-	public AddAttributeCommand(IJPAEditorFeatureProvider fp, JavaPersistentType jpt, 
-			JavaPersistentType attributeType, String mapKeyType, String attributeName,
-			String actName, boolean isCollection, ICompilationUnit cu1,
-			ICompilationUnit cu2){
+	private ICompilationUnit cu;
+
+	/**
+	 * Constructor for the create new attribute command.
+	 * 
+	 * @param fp
+	 * @param jpt
+	 * @param attributeType
+	 * @param mapKeyType
+	 * @param attributeName
+	 * @param actName
+	 * @param isCollection
+	 * @param cu
+	 */
+	public AddAttributeCommand(IJPAEditorFeatureProvider fp,
+			JavaPersistentType jpt, String attributeType, String mapKeyType,
+			String attributeName, String actName, String[] attrTypes,
+			List<String> annotations,
+			boolean isCollection, ICompilationUnit cu) {
 		super();
 		this.fp = fp;
 		this.jpt = jpt;
@@ -41,140 +80,341 @@
 		this.mapKeyType = mapKeyType;
 		this.attributeName = attributeName;
 		this.actName = actName;
+		this.attrTypes = attrTypes;
+		this.annotations = annotations;
 		this.isCollection = isCollection;
-		this.cu1 = cu1;
-		this.cu2 = cu2;
+		this.cu = cu;
 	}
 
+	/**
+	 * Creates a new attribute.
+	 */
 	public void execute() {
 		IType type = null;
 		try {
-			JPAEditorUtil.createImport(cu1, cu2.getType(attributeType.getName()).getElementName());
-			type = cu1.findPrimaryType();	
+			JPAEditorUtil.createImport(cu, attributeType);
+			attributeType = JPAEditorUtil.returnSimpleName(attributeType);
+			type = cu.findPrimaryType();
 
-			if (isCollection) {
-				createAttributeOfCollectiontype(fp, jpt, attributeType,
-						mapKeyType, attributeName, actName, cu1, type);
-			} else {
-				createSimpleAttribute(attributeType, attributeName, actName,
-						isCollection, type);
+			if ((attrTypes != null) && (attrTypes.length > 0)) {
+				JPAEditorUtil.createImports(cu, attrTypes);
+			}
+
+			String contents = "";
+			if (annotations != null) {
+				Iterator<String> it = annotations.iterator();
+				while (it.hasNext()) {
+					String an = it.next();
+					contents += "   " + an + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
+				}
 			}
 			
-			JavaPersistentAttribute attr  = jpt.getAttributeNamed(attributeName);
+			createAttribute(fp, jpt, attributeType, mapKeyType, attributeName,
+					actName, cu, type, isCollection, attrTypes, contents);
+
+			JavaPersistentAttribute attr = jpt.getAttributeNamed(actName);
 			int cnt = 0;
 			while ((attr == null) && (cnt < 25)) {
 				try {
 					Thread.sleep(250);
 				} catch (InterruptedException e) {
+					JPADiagramEditorPlugin.logError("Cannnot create a new attribute with name " + attributeName, e); //$NON-NLS-1$				
 				}
-				jpt.getJavaResourceType().getJavaResourceCompilationUnit().synchronizeWithJavaSource();
-				attr = jpt.getAttributeNamed(attributeName);
+				jpt.getJavaResourceType().getJavaResourceCompilationUnit()
+						.synchronizeWithJavaSource();
+				jpt.update();
+				attr = jpt.getAttributeNamed(actName);
 				cnt++;
 			}
-			
+
 		} catch (JavaModelException e) {
-			JPADiagramEditorPlugin.logError("Cannnot create a new attribute with name " + attributeName, e); //$NON-NLS-1$				
+			JPADiagramEditorPlugin
+					.logError(
+							"Cannnot create a new attribute with name " + attributeName, e); //$NON-NLS-1$				
 		}
 	}
-	
-	private void createSimpleAttribute(JavaPersistentType attributeType,
-			String attributeName, String actName, boolean isCollection,
-			IType type) throws JavaModelException {
-		type.createField("  private " + JPAEditorUtil.returnSimpleName(attributeType.getName()) + " " //$NON-NLS-1$ //$NON-NLS-2$
-			+ JPAEditorUtil.decapitalizeFirstLetter(actName) + ";", null, false, new NullProgressMonitor()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-		type.createMethod(JpaArtifactFactory.instance().genGetterContents(attributeName,
-				JPAEditorUtil.returnSimpleName(attributeType.getName()), null,
-				actName, null, isCollection), null, false,
-				new NullProgressMonitor());
-		type.createMethod(JpaArtifactFactory.instance().genSetterContents(attributeName,
-				JPAEditorUtil.returnSimpleName(attributeType.getName()), null,
-				actName, isCollection), null, false,
-				new NullProgressMonitor());
+
+	/**
+	 * Creates an attribute the persistent type.
+	 * 
+	 * @param fp
+	 * @param jpt
+	 * @param attrTypeName
+	 * @param mapKeyType
+	 * @param attrName
+	 * @param actName
+	 * @param cu
+	 * @param type
+	 * @param isCollection
+	 * @throws JavaModelException
+	 */
+	private void createAttribute(IJPAEditorFeatureProvider fp,
+			JavaPersistentType jpt, String attrTypeName, String mapKeyType,
+			String attrName, String actName, ICompilationUnit cu, IType type,
+			boolean isCollection, String[] attrTypeElementNames, String annotationContents) throws JavaModelException {
+
+			if (isCollection) {
+				createAttributeOfCollectiontype(fp, jpt, attrTypeName,
+						mapKeyType, attrName, actName, cu, type);
+			} else {
+				createSimpleAttribute(attrTypeName, attrName, actName,
+						isCollection, type, attrTypeElementNames, annotationContents);
+			}
 	}
 
+	/**
+	 * Creates a new attribute of a basic type.
+	 * 
+	 * @param attributeType
+	 * @param attributeName
+	 * @param actName
+	 * @param isCollection
+	 * @param type
+	 * @throws JavaModelException
+	 */
+	private void createSimpleAttribute(String attributeType,
+			String attributeName, String actName, boolean isCollection,
+			IType type, String[] attrTypeElementNames, String annotationContents) throws JavaModelException {
+		
+		
+		String attrFieldContent = "    private " + attributeType + //$NON-NLS-1$
+				((attrTypes == null) ? "" : ("<" + JPAEditorUtil.createCommaSeparatedListOfSimpleTypeNames(attrTypes) + ">")) + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				" " + JPAEditorUtil.decapitalizeFirstLetter(actName) + ";"; //$NON-NLS-1$ //$NON-NLS-2$
+		
+		String contents = "";
+		if(!JpaArtifactFactory.instance().isMethodAnnotated(jpt)){
+			contents = annotationContents + attrFieldContent;
+		} else {
+			contents = attrFieldContent;
+		}
+		
+		type.createField(contents, null, false, new NullProgressMonitor()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+		
+		type.createMethod(
+				genGetterContents(attributeName, attributeType, actName, attrTypeElementNames, annotationContents), null,
+				false, new NullProgressMonitor());
+		type.createMethod(
+				genSetterContents(attributeName, attributeType, actName, attrTypeElementNames), null,
+				false, new NullProgressMonitor());
+	}
+
+	/**
+	 * Creates a new attribute of a collection type, depending on the specified
+	 * collection type in the Preference/Properties page.
+	 * 
+	 * @param fp
+	 * @param jpt
+	 * @param attributeType
+	 * @param mapKeyType
+	 * @param attributeName
+	 * @param actName
+	 * @param cu
+	 * @param type
+	 * @throws JavaModelException
+	 */
 	private void createAttributeOfCollectiontype(IJPAEditorFeatureProvider fp,
-			JavaPersistentType jpt, JavaPersistentType attributeType,
-			String mapKeyType, String attributeName, String actName,
-			ICompilationUnit cu1, IType type) throws JavaModelException {
+			JavaPersistentType jpt, String attributeType, String mapKeyType,
+			String attributeName, String actName, ICompilationUnit cu,
+			IType type) throws JavaModelException {
 		IProject project = jpt.getJpaProject().getProject();
 		Properties props = fp.loadProperties(project);
 		if (JPADiagramPropertyPage.isCollectionType(project, props)) {
 			createAttributeByCollectionMethodType(attributeType, null,
-					attributeName, actName, cu1, type, JPAEditorConstants.COLLECTION_TYPE);
+					attributeName, actName, cu, type,
+					JPAEditorConstants.COLLECTION_TYPE);
 		} else if (JPADiagramPropertyPage.isListType(project, props)) {
 			createAttributeByCollectionMethodType(attributeType, null,
-					attributeName, actName, cu1, type, JPAEditorConstants.LIST_TYPE);
+					attributeName, actName, cu, type,
+					JPAEditorConstants.LIST_TYPE);
 		} else if (JPADiagramPropertyPage.isSetType(project, props)) {
 			createAttributeByCollectionMethodType(attributeType, null,
-					attributeName, actName, cu1, type, JPAEditorConstants.SET_TYPE);
+					attributeName, actName, cu, type,
+					JPAEditorConstants.SET_TYPE);
 		} else {
 			createAttributeByCollectionMethodType(attributeType, mapKeyType,
-					attributeName, actName, cu1, type, JPAEditorConstants.MAP_TYPE);
+					attributeName, actName, cu, type,
+					JPAEditorConstants.MAP_TYPE);
 		}
 	}
 
-	
-	private void createAttributeByCollectionMethodType(
-			JavaPersistentType attributeType,  String mapKeyType, String attributeName,
-			String actName, ICompilationUnit cu1, IType type, String collectionType)
+	/**
+	 * Create attribute by the specified collection type in the
+	 * Preference/Properties page.
+	 * 
+	 * @param attributeType
+	 * @param mapKeyType
+	 * @param attributeName
+	 * @param actName
+	 * @param cu
+	 * @param type
+	 * @param collectionType
+	 * @throws JavaModelException
+	 */
+	private void createAttributeByCollectionMethodType(String attributeType,
+			String mapKeyType, String attributeName, String actName,
+			ICompilationUnit cu, IType type, String collectionType)
 			throws JavaModelException {
-		mapKeyType = createContentType(mapKeyType, attributeType, actName, cu1, type, collectionType);
-		type.createMethod(genGetterWithAppropriateType(attributeName, mapKeyType,
-				JPAEditorUtil.returnSimpleName(attributeType.getName()), 
-				actName, collectionType), null, false,
+		mapKeyType = createContentType(mapKeyType, attributeType, actName, cu,
+				type, collectionType);
+		type.createMethod(
+				genGetterWithAppropriateType(attributeName, mapKeyType,
+						attributeType, actName, collectionType), null, false,
 				new NullProgressMonitor());
-		type.createMethod(genSetterWithAppropriateType(attributeName, mapKeyType,
-				JPAEditorUtil.returnSimpleName(attributeType.getName()), 
-				actName, collectionType), null, false,
+		type.createMethod(
+				genSetterWithAppropriateType(attributeName, mapKeyType,
+						attributeType, actName, collectionType), null, false,
 				new NullProgressMonitor());
 	}
-	
-	private String createContentType(String mapKeyType, JavaPersistentType attributeType,
-			String actName, ICompilationUnit cu1, IType type, String collectionType)
-			throws JavaModelException {
-		
+
+	/**
+	 * Create field in the entity by the specified collection type.
+	 * 
+	 * @param mapKeyType
+	 * @param attributeType
+	 * @param actName
+	 * @param cu
+	 * @param type
+	 * @param collectionType
+	 * @return string representation of the field's collection type.
+	 * @throws JavaModelException
+	 */
+	private String createContentType(String mapKeyType, String attributeType,
+			String actName, ICompilationUnit cu, IType type,
+			String collectionType) throws JavaModelException {
+
 		if (mapKeyType != null) {
-			mapKeyType = JPAEditorUtil.createImport(cu1, mapKeyType); 
+			mapKeyType = JPAEditorUtil.createImport(cu, mapKeyType);
 		}
-		JPAEditorUtil.createImport(cu1, collectionType);
+		JPAEditorUtil.createImport(cu, collectionType);
 		type.createField(
-				"  private " + JPAEditorUtil.returnSimpleName(collectionType) + "<" +//$NON-NLS-1$ //$NON-NLS-2$
-				((mapKeyType != null) ? (mapKeyType + ", ") : "") +			//$NON-NLS-1$ //$NON-NLS-2$
-				JPAEditorUtil.returnSimpleName(attributeType.getName()) + "> " + JPAEditorUtil.decapitalizeFirstLetter(actName) +  //$NON-NLS-1$
-				";", null, false, new NullProgressMonitor()); //$NON-NLS-1$ 
+				"  private " + JPAEditorUtil.returnSimpleName(collectionType) + "<" + //$NON-NLS-1$ //$NON-NLS-2$
+						((mapKeyType != null) ? (mapKeyType + ", ") : "") + //$NON-NLS-1$ //$NON-NLS-2$
+						attributeType
+						+ "> " + JPAEditorUtil.decapitalizeFirstLetter(actName) + //$NON-NLS-1$
+						";", null, false, new NullProgressMonitor()); //$NON-NLS-1$ 
 		return mapKeyType;
 	}
-	
-	private String genGetterWithAppropriateType(String attrName, String mapKeyType, String attrType,
-			String actName, String type) {
+
+	/**
+	 * Create the attribute's getter method in entity's compilation unit with
+	 * the appropriate collection type, selected in the Preference/Properties
+	 * page.
+	 * 
+	 * @param attrName
+	 *            - the name of the attribute
+	 * @param attrType
+	 *            - the type of the attribute
+	 * @param attrTypeElementNames
+	 * @param actName
+	 * @param isCollection
+	 * @return the string representation of the attribute's getter method.
+	 */
+	private String genGetterWithAppropriateType(String attrName,
+			String mapKeyType, String attrType, String actName, String type) {
 
 		String attrNameWithCapitalA = actName.substring(0, 1).toUpperCase(
 				Locale.ENGLISH)
 				+ actName.substring(1);
-		String contents = "    public " + JPAEditorUtil.returnSimpleName(type) + 		//$NON-NLS-1$
-				"<" + ((mapKeyType != null) ? (mapKeyType + ", ") : "")  +  attrType + "> " +	//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-				"get" + attrNameWithCapitalA + "() {\n" + 	//$NON-NLS-1$ //$NON-NLS-2$
-				"        return " 	//$NON-NLS-1$
-				+ JPAEditorUtil.decapitalizeFirstLetter(actName) + ";\n" + 		//$NON-NLS-1$
-				"    }\n"; 	//$NON-NLS-1$
+		String contents = "    public " + JPAEditorUtil.returnSimpleName(type) + //$NON-NLS-1$
+				"<"
+				+ ((mapKeyType != null) ? (mapKeyType + ", ") : "") + attrType + "> " + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+				"get" + attrNameWithCapitalA + "() {\n" + //$NON-NLS-1$ //$NON-NLS-2$
+				"        return " //$NON-NLS-1$
+				+ JPAEditorUtil.decapitalizeFirstLetter(actName) + ";\n" + //$NON-NLS-1$
+				"    }\n"; //$NON-NLS-1$
 		return contents;
 	}
-	
-	private String genSetterWithAppropriateType(String attrName, String mapKeyType, String attrType,
-			String actName, String type) {
+
+	/**
+	 * Create the attribute's setter method in entity's compilation unit with
+	 * the appropriate collection type, selected in the Preference/Properties
+	 * page.
+	 * 
+	 * @param attrName
+	 *            - the name of the attribute
+	 * @param attrType
+	 *            - the type of the attribute
+	 * @param attrTypeElementNames
+	 * @param actName
+	 * @param isCollection
+	 * @return the string representation of the attribute's setter method.
+	 */
+	private String genSetterWithAppropriateType(String attrName,
+			String mapKeyType, String attrType, String actName, String type) {
 
 		String attrNameWithCapitalA = actName.substring(0, 1).toUpperCase(
 				Locale.ENGLISH)
 				+ actName.substring(1);
-		String contents = "    public void set" + attrNameWithCapitalA + 			//$NON-NLS-1$
-				"(" + JPAEditorUtil.returnSimpleName(type) + 						//$NON-NLS-1$
-				"<" + ((mapKeyType != null) ? (mapKeyType + ", ") : "") + attrType + "> param) " +	//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
-				"{\n" +   	//$NON-NLS-1$
-				"        this." 	//$NON-NLS-1$
+		String contents = "    public void set" + attrNameWithCapitalA + //$NON-NLS-1$
+				"("
+				+ JPAEditorUtil.returnSimpleName(type)
+				+ //$NON-NLS-1$
+				"<"
+				+ ((mapKeyType != null) ? (mapKeyType + ", ") : "") + attrType + "> param) " + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+				"{\n"
+				+ //$NON-NLS-1$
+				"        this." //$NON-NLS-1$
 				+ JPAEditorUtil.decapitalizeFirstLetter(actName)
-				+ " = param;\n" + 	//$NON-NLS-1$
-				"    }\n"; 			//$NON-NLS-1$
+				+ " = param;\n" + //$NON-NLS-1$
+				"    }\n"; //$NON-NLS-1$
 		return contents;
 	}
-	
+
+	/**
+	 * Create the attribute's getter method in entity's compilation unit.
+	 * 
+	 * @param attrName
+	 *            - the name of the attribute
+	 * @param attrType
+	 *            - the type of the attribute
+	 * @param actName
+	 * @param annotationContents - the annotations as string representation
+	 * @return the string representation of the attribute's getter method.
+	 */
+	private String genGetterContents(String attrName, String attrType,
+			String actName, String[] attrTypeElementNames, String annotationContents) {
+		
+		String attrNameWithCapitalA = actName.substring(0, 1).toUpperCase(
+				Locale.ENGLISH)
+				+ actName.substring(1);
+		
+		String contents = "";
+		if(JpaArtifactFactory.instance().isMethodAnnotated(jpt)){
+			contents += annotationContents;
+		}
+		contents += "    public " + attrType + //$NON-NLS-1$
+				((attrTypeElementNames == null) ? "" : ("<" + JPAEditorUtil.createCommaSeparatedListOfSimpleTypeNames(attrTypeElementNames) + ">")) + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				(attrType.equals("boolean") ? " is" : " get") + attrNameWithCapitalA + "() {\n" + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ 
+				"        return " //$NON-NLS-1$
+				+ JPAEditorUtil.decapitalizeFirstLetter(actName) + ";\n" + //$NON-NLS-1$ 
+				"    }\n"; //$NON-NLS-1$
+
+		return contents;
+	}
+
+	/**
+	 * Create the attribute's setter method in entity's compilation unit.
+	 * 
+	 * @param attrName
+	 *            - the name of the attribute
+	 * @param attrType
+	 *            - the type of the attribute
+	 * @return the string representation of the attribute's setter method.
+	 */
+	private String genSetterContents(String attrName, String attrType,
+			String actName, String[] attrTypeElementNames) {
+		
+		String attrNameWithCapitalA = actName.substring(0, 1).toUpperCase(
+				Locale.ENGLISH) + actName.substring(1);
+
+		String contents = "    public void set" + attrNameWithCapitalA + "(" + attrType + //$NON-NLS-1$ //$NON-NLS-2$
+				((attrTypeElementNames == null) ? "" : ("<" + JPAEditorUtil.createCommaSeparatedListOfSimpleTypeNames(attrTypeElementNames) + ">")) + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				" param) {\n" //$NON-NLS-1$
+				+ "        this." //$NON-NLS-1$
+				+ JPAEditorUtil.decapitalizeFirstLetter(actName)
+				+ " = param;\n" + //$NON-NLS-1$ 
+				"    }\n";
+		return contents;
+	}
+
 }
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/CreateNewAttributeCommand.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/CreateNewAttributeCommand.java
deleted file mode 100644
index d6714db..0000000
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/CreateNewAttributeCommand.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.eclipse.jpt.jpadiagrameditor.ui.internal.command;
-
-import java.util.Iterator;
-import java.util.List;
-
-import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.jdt.core.ICompilationUnit;
-import org.eclipse.jdt.core.IImportDeclaration;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jpt.common.utility.command.Command;
-import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
-import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
-import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
-import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
-
-public class CreateNewAttributeCommand implements Command {
-	
-	private JavaPersistentType jpt;
-	private ICompilationUnit cu;
-	private String attrName;
-	private String attrTypeName;
-	private String[] attrTypes;
-	private String actName;
-	private List<String> annotations;
-	private boolean isCollection;
-	private boolean isMethodAnnotated;
-	
-	public CreateNewAttributeCommand(JavaPersistentType jpt, 
-		ICompilationUnit cu, String attrName, String attrTypeName,
-		String[] attrTypes, String actName,
-		List<String> annotations, boolean isCollection,
-		boolean isMethodAnnotated){
-		super();
-		this.jpt = jpt;
-		this.cu = cu;
-		this.attrName = attrName;
-		this.attrTypeName = attrTypeName;
-		this.attrTypes = attrTypes;
-		this.actName = actName;
-		this.annotations = annotations;
-		this.isCollection = isCollection;
-		this.isMethodAnnotated = isMethodAnnotated;
-	}
-
-	public void execute() {
-		try {
-		IType type = cu.findPrimaryType();
-		String contents = ""; 														//$NON-NLS-1$
-		isMethodAnnotated = (annotations != null) && (!annotations.isEmpty()) ? isMethodAnnotated
-				: JpaArtifactFactory.instance().isMethodAnnotated(jpt);
-		
-		if (!isMethodAnnotated) {
-			if (annotations != null) {
-				Iterator<String> it = annotations.iterator();
-				while (it.hasNext()) {
-					String an = it.next();
-					contents += "   " + an + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
-				}							
-			}
-		}
-		
-		if(annotations!=null && annotations.contains("@Basic")){ //$NON-NLS-1$
-			if(!cu.getImport("javax.persistence.*").exists() && !cu.getImport("javax.persistence.Basic").exists()){ //$NON-NLS-1$ //$NON-NLS-2$
-				JPAEditorUtil.createImports(cu, "javax.persistence.Basic"); //$NON-NLS-1$
-			}
-		}
-		
-		boolean shouldAddImport = true;
-		IImportDeclaration[] importDeclarations = cu.getImports();
-		String attrShortTypeName = JPAEditorUtil.returnSimpleName(attrTypeName);
-		for(IImportDeclaration importDecl : importDeclarations){
-			String importedDeclarationFQN = importDecl.getElementName();
-			String importedDeclarationShortName = JPAEditorUtil.returnSimpleName(importedDeclarationFQN);
-			if(attrShortTypeName.equals(importedDeclarationShortName) && !attrTypeName.equals(importedDeclarationFQN))
-				shouldAddImport = false;
-		}
-		
-		if(shouldAddImport){
-			JPAEditorUtil.createImports(cu, attrTypeName);
-		    attrTypeName = JPAEditorUtil.returnSimpleName(attrTypeName);
-		}
-		if ((attrTypes != null) && (attrTypes.length > 0)) {
-			JPAEditorUtil.createImports(cu, attrTypes);
-		}
-		
-		contents += "    private " + attrTypeName + //$NON-NLS-1$
-				((attrTypes == null) ? "" : ("<" + JPAEditorUtil.createCommaSeparatedListOfSimpleTypeNames(attrTypes) + ">")) + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-				" " + attrName + ";"; //$NON-NLS-1$ //$NON-NLS-2$		
-
-		type.createMethod(
-				JpaArtifactFactory.instance().genSetterContents(attrName, attrTypeName, attrTypes,
-						actName, isCollection), null, false,
-				new NullProgressMonitor());
-		if (isMethodAnnotated) {
-			type.createMethod(
-					JpaArtifactFactory.instance().genGetterContents(attrName, attrTypeName,
-							attrTypes, actName, annotations,
-							isCollection), null, false,
-					new NullProgressMonitor());
-			type.createField(contents, null, false, new NullProgressMonitor());
-		} else {
-			type.createField(contents, null, false, new NullProgressMonitor());
-			type.createMethod(
-					JpaArtifactFactory.instance().genGetterContents(attrName, attrTypeName,
-							attrTypes, actName, null, isCollection),
-					null, false, new NullProgressMonitor());
-		}
-		
-	} catch (JavaModelException e) {
-		
-	}
-		
-		JavaPersistentAttribute attr  = jpt.getAttributeNamed(attrName);
-		int cnt = 0;
-		while ((attr == null) && (cnt < 25)) {
-			try {
-				Thread.sleep(250);
-			} catch (InterruptedException e) {
-			}
-			jpt.getJavaResourceType().getJavaResourceCompilationUnit().synchronizeWithJavaSource();
-			attr = jpt.getAttributeNamed(attrName);
-			cnt++;
-		}
-	}
-}
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/DeleteAttributeCommand.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/DeleteAttributeCommand.java
index 5877009..1e42dc2 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/DeleteAttributeCommand.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/DeleteAttributeCommand.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.command;
 
 import java.util.Locale;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameAttributeCommand.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameAttributeCommand.java
index 37b4b0c..9e6e5c7 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameAttributeCommand.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameAttributeCommand.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.command;
 
 import java.lang.reflect.InvocationTargetException;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameEntityCommand.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameEntityCommand.java
index f91a718..d62c293 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameEntityCommand.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/RenameEntityCommand.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.command;
 
 import org.eclipse.jdt.core.ICompilationUnit;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/SetMappedByNewValueCommand.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/SetMappedByNewValueCommand.java
index 872c9a2..2da316d 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/SetMappedByNewValueCommand.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/command/SetMappedByNewValueCommand.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.command;
 
 import org.eclipse.jpt.common.core.resource.java.Annotation;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddAllEntitiesFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddAllEntitiesFeature.java
index 1390704..70fe35a 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddAllEntitiesFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddAllEntitiesFeature.java
@@ -70,7 +70,6 @@
 		return true;
 	}
 	
-	@SuppressWarnings("restriction")
 	public void execute(ICustomContext context) {
 		Diagram d = getDiagram();
 		JpaProject project = getTargetJPAProject();
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddHasReferenceRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddHasReferenceRelationFeature.java
index 75dcf8e..16ac692 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddHasReferenceRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/AddHasReferenceRelationFeature.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
 
 import static org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.HasReferanceRelation.HasReferenceType.COLLECTION;
@@ -87,7 +103,6 @@
             IAddBendpointFeature ft = getFeatureProvider().getAddBendpointFeature(ctx);
             ft.addBendpoint(ctx);
         }
-        getFeatureProvider().getPeServiceUtil().setPropertyValue(connection, HasReferanceRelation.HAS_REFERENCE_CONNECTION_PROP_KEY, Boolean.TRUE.toString());
         addDecorators(connection, relation);
         addTextDecorators(connection, relation);
 
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ClickAddAttributeButtonFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ClickAddAttributeButtonFeature.java
index 4d9a785..8cc319b 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ClickAddAttributeButtonFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ClickAddAttributeButtonFeature.java
@@ -53,7 +53,7 @@
 		JavaPersistentType jpt = (JavaPersistentType)getFeatureProvider().getBusinessObjectForPictogramElement(entityShape);
 		String newAttrName = JpaArtifactFactory.instance().createNewAttribute(jpt, false, getFeatureProvider());
 
-		JavaPersistentAttribute newAttr = jpt.getAttributeNamed(newAttrName);
+		JavaPersistentAttribute newAttr = (JavaPersistentAttribute) jpt.resolveAttribute(newAttrName);
 
 		getFeatureProvider().addAddIgnore((JavaPersistentType)newAttr.getParent(), newAttr.getName());
 		addGraphicalRepresentation(context, newAttr);
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ClickAddElementCollectionButtonFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ClickAddElementCollectionButtonFeature.java
new file mode 100644
index 0000000..ac1e6d8
--- /dev/null
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/ClickAddElementCollectionButtonFeature.java
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
+package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
+
+import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.features.context.IContext;
+import org.eclipse.graphiti.features.context.ICreateContext;
+import org.eclipse.graphiti.features.impl.AbstractCreateFeature;
+import org.eclipse.graphiti.mm.pictograms.ContainerShape;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.ElementCollection2_0Annotation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IWorkbenchSite;
+
+public class ClickAddElementCollectionButtonFeature extends AbstractCreateFeature {
+	
+	public ClickAddElementCollectionButtonFeature(IFeatureProvider provider) {
+		super(provider, "", "");	//$NON-NLS-1$ //$NON-NLS-2$
+	}
+	
+	public boolean canExecute(IContext context) {
+		return true;
+	}
+
+	public boolean canUndo(IContext context) {
+		return false;
+	}
+
+	public boolean canCreate(ICreateContext context) {
+		return true;
+	}
+	
+	public Object[] create(ICreateContext context) {
+		ContainerShape entityShape = context.getTargetContainer();
+		JavaPersistentType jpt = (JavaPersistentType)getFeatureProvider().getBusinessObjectForPictogramElement(entityShape);
+		String newAttrName = JpaArtifactFactory.instance().createNewAttribute(jpt, true, getFeatureProvider());
+
+		JavaPersistentAttribute newAttr = (JavaPersistentAttribute) jpt.resolveAttribute(newAttrName);
+		newAttr.setMappingKey(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+		newAttr.getResourceAttribute().addAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME);
+
+		getFeatureProvider().addAddIgnore((JavaPersistentType)newAttr.getParent(), newAttr.getName());
+		addGraphicalRepresentation(context, newAttr);
+        getFeatureProvider().getDirectEditingInfo().setActive(true);
+        
+        IWorkbenchSite ws = ((IEditorPart)getDiagramEditor()).getSite();
+        ICompilationUnit cu = getFeatureProvider().getCompilationUnit(jpt);
+        getFeatureProvider().getJPAEditorUtil().formatCode(cu, ws);
+
+		return new Object[] {newAttr};
+	}
+
+	public boolean isAvailable(IContext context) {
+		return true;
+	}
+
+	public String getName() {
+		return JPAEditorMessages.ClickAddElementCollectionButtonFeature_CreateElementCollectionAttributeFeatureName;  			
+	}
+
+	public String getDescription() {
+		return JPAEditorMessages.ClickAddElementCollectionButtonFeature_CreateElementCollectionAttributeFeatureDescription;  
+	}
+	
+	public IJPAEditorFeatureProvider getFeatureProvider() {
+		return (IJPAEditorFeatureProvider)super.getFeatureProvider();
+	}
+
+}
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateEmbeddableFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateEmbeddableFeature.java
index f25fa0f..7f73f3e 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateEmbeddableFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateEmbeddableFeature.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
 
 import java.util.List;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateInheritedEntityFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateInheritedEntityFeature.java
index e7f47cd..6947fa7 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateInheritedEntityFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateInheritedEntityFeature.java
@@ -120,7 +120,6 @@
 		disableAllNotValidJPTs();
 	}
 	
-	@SuppressWarnings("restriction")
 	private void disableAllNotValidJPTs(){
 		Diagram d = getDiagram();
 		JpaProject project = ModelIntegrationUtil.getProjectByDiagram(d.getName());
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateJPAEntityFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateJPAEntityFeature.java
index 02d90ba..db45096 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateJPAEntityFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateJPAEntityFeature.java
@@ -100,7 +100,6 @@
         return context.getTargetContainer() instanceof Diagram;
     }
 
-    @SuppressWarnings("restriction")
 	public Object[] create(ICreateContext context) {
 		List<Shape> shapes = this.getFeatureProvider().getDiagramTypeProvider().getDiagram().getChildren();
 		IProject targetProject = null;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyBiDirRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyBiDirRelationFeature.java
index af75f94..db16e24 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyBiDirRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyBiDirRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyUniDirRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyUniDirRelationFeature.java
index f227422..81fe2d3 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyUniDirRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToManyUniDirRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneBiDirRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneBiDirRelationFeature.java
index 1c6e2ff..e18cd35 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneBiDirRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneBiDirRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneUniDirRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneUniDirRelationFeature.java
index 7280e65..560e49c 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneUniDirRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateManyToOneUniDirRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToManyRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToManyRelationFeature.java
index bf531a0..a448461 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToManyRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToManyRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneBiDirRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneBiDirRelationFeature.java
index 6fb57c2..689fbf9 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneBiDirRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneBiDirRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneUniDirRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneUniDirRelationFeature.java
index 1e556db..6036ef3 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneUniDirRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateOneToOneUniDirRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateRelationFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateRelationFeature.java
index 6149fa8..fd6aef9 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateRelationFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/CreateRelationFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -173,7 +173,6 @@
 	 * For each unvalid relationship's target, change the color of the respective
 	 * java persistent type in gray to simulate disability of the persistent type.
 	 */
-	@SuppressWarnings("restriction")
 	private void disableUnvalidRelationTargets(){
 		Diagram d = getDiagram();
 		JpaProject project = ModelIntegrationUtil.getProjectByDiagram(d.getName());
@@ -234,7 +233,6 @@
 	 * registered in the persistence unit.
 	 * @param unit
 	 */
-	@SuppressWarnings("restriction")
 	private void disableAllEmbeddables() {
 		Diagram d = getDiagram();
 		JpaProject project = ModelIntegrationUtil.getProjectByDiagram(d.getName());
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedCollectionOfObjectsFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedCollectionOfObjectsFeature.java
index 90368bf..cd293a7 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedCollectionOfObjectsFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedCollectionOfObjectsFeature.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
 
 import java.util.Set;
@@ -14,6 +30,7 @@
 import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.MappedSuperclass;
 import org.eclipse.jpt.jpa.core.context.PersistentType;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.jpa.core.context.persistence.ClassRef;
@@ -139,13 +156,21 @@
 	/**
 	 * Checks whether the connection is possible. If the source of the connection is embeddable and it already
 	 * embeds in itself an element collection of another embeddable, or if the target of the connection is already
-	 * embedded as an element connection in some entity, then the connection is not allowed by specification.
+	 * embedded as an element connection in some entity, or the if the target embeddable contains an attribute with
+	 * mapping element-collection, then the connection is not allowed by specification.
 	 * @param embeddingEntity - the source entity of the connection
 	 * @param embeddable - the target entity of the connection
 	 * @return true if the connection is possible, false otherwise.
 	 */
 	private boolean isNotAllowed(JavaPersistentType embeddingEntity, JavaPersistentType embeddable){
 		boolean notAllowed = false;
+		if(JpaArtifactFactory.instance().hasEmbeddableAnnotation(embeddable)){
+			for(ReadOnlyPersistentAttribute attr : embeddable.getAllAttributes()){
+				if(attr.getMappingKey().equals(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY)){
+					return true;
+				}
+			}
+		}
 		if(JpaArtifactFactory.instance().hasEmbeddableAnnotation(embeddingEntity)){
 			notAllowed = isEmbeddableAlreadyEmbeddedAsElementCollection(embeddingEntity, false);
 		} else if(JpaArtifactFactory.instance().hasEntityAnnotation(embeddingEntity)){
@@ -181,7 +206,6 @@
 	 * For each unvalid relationship's target, change the color of the respective
 	 * java persistent type in gray to simulate disability of the persistent type.
 	 */
-	@SuppressWarnings("restriction")
 	private void disableUnvalidRelationTargets(){
 		Diagram d = getDiagram();
 		JpaProject project = ModelIntegrationUtil.getProjectByDiagram(d.getName());
@@ -233,7 +257,6 @@
 	 * registered in the persistence unit.
 	 * @param unit
 	 */
-	@SuppressWarnings("restriction")
 	private void disableAllMappedSuperclasses() {
 		Diagram d = getDiagram();
 		JpaProject project = ModelIntegrationUtil.getProjectByDiagram(d.getName());
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedSingleObjectFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedSingleObjectFeature.java
index 72fe587..b41f28c 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedSingleObjectFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/EmbedSingleObjectFeature.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.feature;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
@@ -130,7 +146,6 @@
 	 * For each unvalid relationship's target, change the color of the respective
 	 * java persistent type in gray to simulate disability of the persistent type.
 	 */
-	@SuppressWarnings("restriction")
 	private void disableUnvalidRelationTargets(){
 		Diagram d = getDiagram();
 		JpaProject project = ModelIntegrationUtil.getProjectByDiagram(d.getName());
@@ -169,7 +184,6 @@
 	 * registered in the persistence unit.
 	 * @param unit
 	 */
-	@SuppressWarnings("restriction")
 	private void disableAllMappedSuperclasses() {
 		Diagram d = getDiagram();
 		JpaProject project = ModelIntegrationUtil.getProjectByDiagram(d.getName());
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RefactorAttributeTypeFeature.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RefactorAttributeTypeFeature.java
index c5c4387..24fb6c8 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RefactorAttributeTypeFeature.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/feature/RefactorAttributeTypeFeature.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2011 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -17,6 +17,7 @@
 
 import java.text.MessageFormat;
 import java.util.List;
+
 import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.features.context.ICustomContext;
 import org.eclipse.graphiti.features.custom.AbstractCustomFeature;
@@ -25,7 +26,6 @@
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.jpt.common.core.resource.java.JavaResourceAttribute;
-import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind;
 import org.eclipse.jpt.jpa.core.context.PersistentType;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
@@ -37,10 +37,7 @@
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IWorkbenchSite;
 
-
 public class RefactorAttributeTypeFeature extends AbstractCustomFeature {
-
-	//private static final TracerI tracer = TracingManager.getTracer(RefactorAttributeTypeFeature.class);				
 	
 	public RefactorAttributeTypeFeature(IFeatureProvider fp) {
 		super(fp);
@@ -72,18 +69,20 @@
 		getFeatureProvider().addAddIgnore((JavaPersistentType)jpa.getParent(), jpa.getName());
 		JavaResourceAttribute jra = jpa.getResourceAttribute();
 		getFeatureProvider().addRemoveIgnore((JavaPersistentType)jpa.getParent(), jra.getName());
-		boolean isMethodAnnotated = jra.getKind() == Kind.METHOD;
 
 		List<String> annotations = JpaArtifactFactory.instance().getAnnotationStrings(jpa);
 		JpaArtifactFactory.instance().deleteAttribute((JavaPersistentType)jpa.getParent(), jpa.getName(),
-				getFeatureProvider());		
-		JavaPersistentAttribute newAt = JpaArtifactFactory.instance().createANewAttribute((JavaPersistentType)jpa.getParent(),
-				jpa.getName(), newTypeName, attributeTypeTypeNames, jpa.getName(), annotations,
-				false, isMethodAnnotated, getFeatureProvider());
+				getFeatureProvider());
+		
+		JavaPersistentAttribute newAt = JpaArtifactFactory.instance().makeNewAttribute(getFeatureProvider(), (JavaPersistentType)jpa.getParent(),
+				null, jpa.getName(), newTypeName, jpa.getName(), newTypeName, attributeTypeTypeNames, annotations, false);
+		
 		getFeatureProvider().replaceAttribute(jpa, newAt);
+		
         IWorkbenchSite ws = ((IEditorPart)getDiagramEditor()).getSite();
         ICompilationUnit cu = getFeatureProvider().getCompilationUnit((JavaPersistentType)newAt.getParent());
-        getFeatureProvider().getJPAEditorUtil().formatCode(cu, ws);					
+        getFeatureProvider().getJPAEditorUtil().formatCode(cu, ws);	
+        JPAEditorUtil.organizeImports(cu, ws);
 		JpaArtifactFactory.instance().remakeRelations(getFeatureProvider(), 
 				((Shape)pe).getContainer(), (JavaPersistentType)newAt.getParent());
 	}
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/JPAEditorMessages.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/JPAEditorMessages.java
index c577927..08c8b41 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/JPAEditorMessages.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/JPAEditorMessages.java
@@ -29,6 +29,10 @@
 	public static String ClickAddAttributeButtonFeature_createAttributeButtonDescription;
 	public static String ClickAddAttributeButtonFeature_createAttributeButtonLabel;
 	
+	public static String ClickAddElementCollectionButtonFeature_CreateElementCollectionAttributeFeatureDescription;
+
+	public static String ClickAddElementCollectionButtonFeature_CreateElementCollectionAttributeFeatureName;
+
 	public static String ClickRemoveAttributeButtonFeature_createAttributeButtonDescription;
 	public static String ClickRemoveAttributeButtonFeature_createAttributeButtonlabel;
 	public static String ClickRemoveAttributeButtonFeature_deleteAttributeQuestion;
@@ -176,6 +180,9 @@
 	public static String JPAEditorToolBehaviorProvider_openMiniatureViewDesc;
 
 	public static String JPAEditorToolBehaviorProvider_CompositionPaletteName;
+
+	public static String JPAEditorToolBehaviorProvider_CreateElementCollectionAttributeButtonLabel;
+	public static String JPAEditorToolBehaviorProvider_CreateElementCollectionAttributeButtonDescription;
 	public static String JPAEditorToolBehaviorProvider_expandAttrMenuItem;
 
 	public static String JPAEditorToolBehaviorProvider_expandAttrMenuItemDescr;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/messages.properties b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/messages.properties
index 4f1314a..17ffd80 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/messages.properties
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/i18n/messages.properties
@@ -18,6 +18,8 @@
 AddJPAEntityFeature_relationAttributesShapes=Relation Attributes
 ClickAddAttributeButtonFeature_createAttributeButtonDescription=Create a new attribute of this persistent type.
 ClickAddAttributeButtonFeature_createAttributeButtonLabel=Create Attribute
+ClickAddElementCollectionButtonFeature_CreateElementCollectionAttributeFeatureDescription=Create a new attribute of a basic collection type in the persistent type.
+ClickAddElementCollectionButtonFeature_CreateElementCollectionAttributeFeatureName=Create Collection Attribute
 
 ClickRemoveAttributeButtonFeature_createAttributeButtonDescription=Create a new attribute of this persistent type.
 ClickRemoveAttributeButtonFeature_createAttributeButtonlabel=Create Attribute
@@ -148,6 +150,8 @@
 JPAEditorToolBehaviorProvider_openMiniatureView=Open Miniature View 
 JPAEditorToolBehaviorProvider_openMiniatureViewDesc=Open the Miniature view to display the diagram in a larger scale.
 JPAEditorToolBehaviorProvider_CompositionPaletteName=Composition
+JPAEditorToolBehaviorProvider_CreateElementCollectionAttributeButtonLabel=Create Collection Attribute
+JPAEditorToolBehaviorProvider_CreateElementCollectionAttributeButtonDescription=Create a new attribute of a basic collection type in the persistent type.
 JPAEditorToolBehaviorProvider_expandAttrMenuItem=Expand Attributes Group
 JPAEditorToolBehaviorProvider_expandAttrMenuItemDescr=Expand the attributes group.
 JPAEditorToolBehaviorProvider_expandCompartToolTip=Double click to expand "{0}" attributes group.
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/modelintegration/util/ModelIntegrationUtil.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/modelintegration/util/ModelIntegrationUtil.java
index 2a60010..bb49a50 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/modelintegration/util/ModelIntegrationUtil.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/modelintegration/util/ModelIntegrationUtil.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2011 SAP AG and others.
+ * Copyright (c) 2005, 2012 SAP AG and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorFeatureProvider.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorFeatureProvider.java
index c12e148..d1d8397 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorFeatureProvider.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorFeatureProvider.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorImageCreator.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorImageCreator.java
index 9baccf6..a4caab9 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorImageCreator.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/IJPAEditorImageCreator.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorFeatureProvider.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorFeatureProvider.java
index 53655ff..da59395 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorFeatureProvider.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorFeatureProvider.java
@@ -84,6 +84,7 @@
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddJPAEntityFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddRelationFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.ClickAddAttributeButtonFeature;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.ClickAddElementCollectionButtonFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.ClickRemoveAttributeButtonFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseAllEntitiesFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseCompartmentShapeFeature;
@@ -144,6 +145,8 @@
 public class JPAEditorFeatureProvider extends DefaultFeatureProvider implements IJPAEditorFeatureProvider {
 	
 	private ClickAddAttributeButtonFeature clickAddAttBtnFeat = null;
+	private ClickAddElementCollectionButtonFeature clickAddCollectionAttBtnFeat = null;
+
 	private ClickRemoveAttributeButtonFeature clickRemoveAttBtnFeat = null;
 	private IPeServiceUtil peServiceUtil = new PeServiceUtilImpl();
 	private IPeService peService = Graphiti.getPeService();
@@ -189,12 +192,14 @@
 		EList<Connection> allCons = getDiagram().getConnections();
 		HashSet<HasReferanceRelation> res = new HashSet<HasReferanceRelation>();
 		for (Connection conn : allCons) {
-			if (HasReferanceRelation.isHasReferenceConnection(conn)) 
-				try {
-					HasReferanceRelation hasReferenceRelation = (HasReferanceRelation) getBusinessObjectForPictogramElement(conn);
+			try {
+				Object ob = getBusinessObjectForPictogramElement(conn);
+				if(ob instanceof HasReferanceRelation) {
+					HasReferanceRelation hasReferenceRelation = (HasReferanceRelation) ob;
 					res.add(hasReferenceRelation);
-				} catch (NullPointerException e) {
 				}
+			} catch (NullPointerException e) {
+			}
 		}
 		return res;
 	}
@@ -494,6 +499,13 @@
     	return clickAddAttBtnFeat;
     }
     
+    public ClickAddElementCollectionButtonFeature getClickAddElementCollectionButtonFeature() {
+    	if (clickAddCollectionAttBtnFeat == null) {
+    		clickAddCollectionAttBtnFeat = new ClickAddElementCollectionButtonFeature(this);
+    	}
+    	return clickAddCollectionAttBtnFeat;
+    }
+    
     public ClickRemoveAttributeButtonFeature getClickRemoveAttributeButtonFeature() {
     	if (clickRemoveAttBtnFeat == null) {
     		clickRemoveAttBtnFeat = new ClickRemoveAttributeButtonFeature(this);
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageCreator.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageCreator.java
index 75efe4a..403ca00 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageCreator.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageCreator.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageProvider.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageProvider.java
index 824c9b2..224a860 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageProvider.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorImageProvider.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -24,15 +24,16 @@
     
     public static final String JPA_ENTITY 				= PREFIX + "entity"; 							//$NON-NLS-1$
     public static final String MAPPED_SUPERCLASS 		= PREFIX + "mapped_superclass"; 				//$NON-NLS-1$
-    public static final String EMBEDDABLE 		        = PREFIX + "embeddable"; 				//$NON-NLS-1$
+    public static final String EMBEDDABLE 		        = PREFIX + "embeddable"; 				        //$NON-NLS-1$
     public static final String ADD_JPA_ENTITY 			= PREFIX + "add_entity"; 						//$NON-NLS-1$    
     public static final String ADD_INHERITED_ENTITY 	= PREFIX + "add_inherited_entity";		        //$NON-NLS-1$
     public static final String ADD_MAPPED_SUPERCLASS	= PREFIX + "add_mapped_superclass";	        	//$NON-NLS-1$    
-    public static final String ADD_EMBEDDABLE	        = PREFIX + "add_embeddable";	        	//$NON-NLS-1$    
+    public static final String ADD_EMBEDDABLE	        = PREFIX + "add_embeddable";	        	    //$NON-NLS-1$    
     
     public static final String PRIMARY_KEY 				= PREFIX + "pk"; 								//$NON-NLS-1$
     public static final String ICON_BASIC 				= PREFIX + "field"; 							//$NON-NLS-1$
     public static final String ADD_ATTRIBUTE 			= PREFIX + "add_attribute"; 					//$NON-NLS-1$
+    public static final String ADD_ELEMENT_COLLECTION 	= PREFIX + "add_element-collection.gif";    	//$NON-NLS-1$
     public static final String REMOVE_ATTRIBUTE 		= PREFIX + "remove_attribute"; 					//$NON-NLS-1$
     public static final String ICON_ONE_TO_ONE 			= PREFIX + "one_to_one_relation"; 				//$NON-NLS-1$
     public static final String ICON_ONE_TO_MANY 		= PREFIX + "one_to_many_relation"; 				//$NON-NLS-1$
@@ -42,7 +43,7 @@
     public static final String ICON_VERSION 			= PREFIX + "version"; 							//$NON-NLS-1$ 
     public static final String ICON_TRANSIENT 			= PREFIX + "transient"; 						//$NON-NLS-1$  
     public static final String ICON_EMBEDDED 			= PREFIX + "embedded"; 							//$NON-NLS-1$ 
-    public static final String ICON_ELEMENT_COLLECTION  = PREFIX + "element-collection"; 							//$NON-NLS-1$ 
+    public static final String ICON_ELEMENT_COLLECTION  = PREFIX + "element-collection"; 				//$NON-NLS-1$ 
     public static final String ICON_UNMAPPED 			= PREFIX + "unmapped"; 							//$NON-NLS-1$  
 
 
@@ -71,13 +72,14 @@
         addImageFilePath(ICON_BASIC, ROOT_FOLDER_FOR_IMG + "ent/basic.gif");							//$NON-NLS-1$
         addImageFilePath(JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/entity.gif");							//$NON-NLS-1$
         addImageFilePath(MAPPED_SUPERCLASS, ROOT_FOLDER_FOR_IMG + "ent/mapped-superclass.gif");			//$NON-NLS-1$
-        addImageFilePath(EMBEDDABLE, ROOT_FOLDER_FOR_IMG + "ent/embeddable.gif");			//$NON-NLS-1$
+        addImageFilePath(EMBEDDABLE, ROOT_FOLDER_FOR_IMG + "ent/embeddable.gif");			            //$NON-NLS-1$
         addImageFilePath(ADD_JPA_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/add_entity.gif");					//$NON-NLS-1$        
         addImageFilePath(ADD_INHERITED_ENTITY, ROOT_FOLDER_FOR_IMG + "ent/add_entity.gif"); 			//$NON-NLS-1$
         addImageFilePath(ADD_MAPPED_SUPERCLASS, ROOT_FOLDER_FOR_IMG + "ent/add_mapped-superclass.gif"); //$NON-NLS-1$
-        addImageFilePath(ADD_EMBEDDABLE, ROOT_FOLDER_FOR_IMG + "ent/add_embeddable.gif"); //$NON-NLS-1$
+        addImageFilePath(ADD_EMBEDDABLE, ROOT_FOLDER_FOR_IMG + "ent/add_embeddable.gif");               //$NON-NLS-1$
         addImageFilePath(PRIMARY_KEY, ROOT_FOLDER_FOR_IMG + "ent/id.gif");								//$NON-NLS-1$
         addImageFilePath(ADD_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/add_attribute.gif");					//$NON-NLS-1$
+        addImageFilePath(ADD_ELEMENT_COLLECTION, ROOT_FOLDER_FOR_IMG + "ent/add_element-collection.gif"); //$NON-NLS-1$
         addImageFilePath(REMOVE_ATTRIBUTE, ROOT_FOLDER_FOR_IMG + "ent/remove_attribute.gif");			//$NON-NLS-1$
         addImageFilePath(ICON_ONE_TO_ONE, ROOT_FOLDER_FOR_IMG + "ent/one-to-one.gif");					//$NON-NLS-1$
         addImageFilePath(ICON_ONE_TO_MANY, ROOT_FOLDER_FOR_IMG + "ent/one-to-many.gif");				//$NON-NLS-1$
@@ -87,7 +89,7 @@
         addImageFilePath(ICON_VERSION, ROOT_FOLDER_FOR_IMG + "ent/version.gif"); 						//$NON-NLS-1$
         addImageFilePath(ICON_TRANSIENT, ROOT_FOLDER_FOR_IMG + "ent/transient.gif"); 					//$NON-NLS-1$
         addImageFilePath(ICON_EMBEDDED, ROOT_FOLDER_FOR_IMG + "ent/embedded.gif"); 						//$NON-NLS-1$
-        addImageFilePath(ICON_ELEMENT_COLLECTION, ROOT_FOLDER_FOR_IMG + "ent/element-collection.gif"); 						//$NON-NLS-1$
+        addImageFilePath(ICON_ELEMENT_COLLECTION, ROOT_FOLDER_FOR_IMG + "ent/element-collection.gif"); 	//$NON-NLS-1$
         addImageFilePath(ICON_UNMAPPED, ROOT_FOLDER_FOR_IMG + "ent/null-attribute-mapping.gif"); 		//$NON-NLS-1$
 
         addImageFilePath(ICON_ONE_TO_ONE_1_DIR, ROOT_FOLDER_FOR_IMG + "ent/one-to-one-1-dir.gif");		//$NON-NLS-1$
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorToolBehaviorProvider.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorToolBehaviorProvider.java
index bc02b90..f4d319c 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorToolBehaviorProvider.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/provider/JPAEditorToolBehaviorProvider.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -66,6 +66,7 @@
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.facade.EclipseFacade;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.AddAllEntitiesFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.ClickAddAttributeButtonFeature;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.ClickAddElementCollectionButtonFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.ClickRemoveAttributeButtonFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseAllEntitiesFeature;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.CollapseCompartmentShapeFeature;
@@ -169,6 +170,17 @@
 			button.setDescription(JPAEditorMessages.JPAEditorToolBehaviorProvider_createAttributeButtonDescription);
 			button.setIconId(JPAEditorImageProvider.ADD_ATTRIBUTE);
 			data.getDomainSpecificContextButtons().add(button);
+			
+			if(!JPAEditorUtil.checkJPAFacetVersion(getTargetJPAProject(), JPAEditorUtil.JPA_PROJECT_FACET_10)){
+				ClickAddElementCollectionButtonFeature addCollectionfeature = getConcreteFeatureProvider().getClickAddElementCollectionButtonFeature();
+				createCtx = new CreateContext();
+				createCtx.setTargetContainer(cs);
+				button = new ContextButtonEntry(addCollectionfeature, createCtx);
+				button.setText(JPAEditorMessages.JPAEditorToolBehaviorProvider_CreateElementCollectionAttributeButtonLabel);
+				button.setDescription(JPAEditorMessages.JPAEditorToolBehaviorProvider_CreateElementCollectionAttributeButtonDescription);
+				button.setIconId(JPAEditorImageProvider.ADD_ELEMENT_COLLECTION);
+				data.getDomainSpecificContextButtons().add(button);
+			}
 
 			PictogramElementContext c = (PictogramElementContext) context;
 			RemoveAndSaveEntityFeature ft2 = new RemoveAndSaveEntityFeature(getFeatureProvider());
@@ -550,18 +562,7 @@
         		expandCompartmentMenuItem.setSubmenu(false);
         		return new IContextMenuEntry[] {collapseCompartmentMenuItem, expandCompartmentMenuItem};
             }
-            
-            /*
-            //Apply Pattern menu
-            
-            ICustomFeature applyPatternFeature = new ApplyPatternFeature(getFeatureProvider());
-            ContextMenuEntry applyPatternMenuItem = new ContextMenuEntry(applyPatternFeature, context);
-            applyPatternMenuItem.setText(JPAEditorMessages.JPAEditorToolBehaviorProvider_applyPattern);
-            applyPatternMenuItem.setDescription(JPAEditorMessages.JPAEditorToolBehaviorProvider_applyPatternDesc);
-            applyPatternMenuItem.setSubmenu(false);
-            //Apply Pattern menu
-             */
-            
+
             ContextMenuEntry refactorClassSubmenu = new ContextMenuEntry(null, null);
             refactorClassSubmenu.setText(JPAEditorMessages.JPAEditorToolBehaviorProvider_refactorSubMenu);
             refactorClassSubmenu.setDescription(JPAEditorMessages.JPAEditorToolBehaviorProvider_refactorSubMenu);
@@ -593,22 +594,21 @@
             		                             expandEntityMenuItem,
             		                             expandAllMenuItem,
             		                             restoreEntityMenuItem,
-            									 //applyPatternMenuItem, 
             									 removeAllEntitiesSubmenu,
             									 openJPADetailsViewMenuItem,
             									 openMiniatureViewMenuItem};
-            
-    		customFeature = new RefactorAttributeTypeFeature(getFeatureProvider());     		
+
+            customFeature = new RefactorAttributeTypeFeature(getFeatureProvider());     		
             ContextMenuEntry refactorAttributeTypeMenuItem = new ContextMenuEntry(customFeature, context);
             refactorAttributeTypeMenuItem.setText(JPAEditorMessages.JPAEditorToolBehaviorProvider_refactorAttributeType);
             refactorAttributeTypeMenuItem.setDescription(JPAEditorMessages.JPAEditorToolBehaviorProvider_refactorAttributeTypeDesc);
             refactorAttributeTypeMenuItem.setSubmenu(false);                   
 
+            
         	return new IContextMenuEntry[] { refactorClassSubmenu, 
         									 refactorAttributeTypeMenuItem, 
         									 collapseAllMenuItem,
         									 expandAllMenuItem,
-        									 //applyPatternMenuItem, 
         									 openJPADetailsViewMenuItem,
         									 openMiniatureViewMenuItem};
     	}
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasCollectionReferenceRelation.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasCollectionReferenceRelation.java
index 59972c8..e4ba675 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasCollectionReferenceRelation.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasCollectionReferenceRelation.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.relations;
 
 import org.eclipse.graphiti.mm.pictograms.Connection;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasReferanceRelation.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasReferanceRelation.java
index d044a9f..da8c575 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasReferanceRelation.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasReferanceRelation.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.relations;
 
 import java.util.Hashtable;
@@ -9,11 +25,9 @@
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants;
-import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
 
 public abstract class HasReferanceRelation {
 	protected final static String SEPARATOR = ";hasReference;";							//$NON-NLS-1$
-	public final static String HAS_REFERENCE_CONNECTION_PROP_KEY = "is_has_reference_connection";	//$NON-NLS-1$
 
 	protected JavaPersistentType embeddingEntity;
 	protected JavaPersistentType embeddable;
@@ -58,14 +72,9 @@
 	public JavaPersistentType getEmbeddingEntity() {
 		return embeddingEntity; 
 	}
-	
-	public static boolean isHasReferenceConnection(Connection conn) {
-		String val = JPAEditorUtil.getPeUtil().getPropertyValue(conn, HAS_REFERENCE_CONNECTION_PROP_KEY);
-		return (Boolean.TRUE.toString().equals(val));
-	}
 
 	public String getId() {
-		return generateId(embeddable, embeddingEntity, embeddedAnnotatedAttribute.getName(), getReferenceType());
+		return generateId(embeddingEntity, embeddable, embeddedAnnotatedAttribute.getName(), getReferenceType());
 	}
 
 	public static String generateId(JavaPersistentType startJpt, JavaPersistentType endJpt, String embeddedAttributeName, HasReferenceType relType) {		
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasSingleReferenceRelation.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasSingleReferenceRelation.java
index 48c204d..807f064 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasSingleReferenceRelation.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/HasSingleReferenceRelation.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.relations;
 
 import org.eclipse.graphiti.mm.pictograms.Connection;
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToManyBiDirRelation.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToManyBiDirRelation.java
index df0af0a..b57a95f 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToManyBiDirRelation.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToManyBiDirRelation.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -70,7 +70,6 @@
 		
 		mapKeyType = getMapKeyType(isMap, owner, embeddingEntity);
 		if(JpaArtifactFactory.instance().hasEmbeddableAnnotation(owner)){
-//			inverseAnnotatedAttribute = JpaArtifactFactory.instance().addEmbeddedAttribute(owner, inverse, mapKeyType, true, fp);
 			inverseAnnotatedAttribute = JPAEditorUtil.addAnnotatedAttribute(fp, inverse, embeddingEntity, true, mapKeyType);
 
 		} else {
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToOneBiDirRelation.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToOneBiDirRelation.java
index 96c025b..e83431c 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToOneBiDirRelation.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/ManyToOneBiDirRelation.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -60,7 +60,6 @@
 		boolean isMap = JPADiagramPropertyPage.isMapType(owner.getJpaProject().getProject());
 		String mapKeyType = getMapKeyType(isMap, owner, embeddingEntity);
 		if(JpaArtifactFactory.instance().hasEmbeddableAnnotation(owner)){
-//			inverseAnnotatedAttribute = JpaArtifactFactory.instance().addEmbeddedAttribute(owner, inverse, mapKeyType, true, fp);
 			inverseAnnotatedAttribute = JPAEditorUtil.addAnnotatedAttribute(fp, inverse, embeddingEntity, true, mapKeyType);
 
 		} else {
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/OneToOneBiDirRelation.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/OneToOneBiDirRelation.java
index 8784131..56ef135 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/OneToOneBiDirRelation.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/relations/OneToOneBiDirRelation.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -57,7 +57,6 @@
 		ownerAnnotatedAttribute = JPAEditorUtil.addAnnotatedAttribute(fp, owner, inverse, false, null);
 		
 		if(JpaArtifactFactory.instance().hasEmbeddableAnnotation(owner)){
-//			inverseAnnotatedAttribute = JpaArtifactFactory.instance().addEmbeddedAttribute(owner, inverse, null, false, fp);
 			inverseAnnotatedAttribute = JPAEditorUtil.addAnnotatedAttribute(fp, inverse, embeddingEntity, false, null);
 		} else {
 			inverseAnnotatedAttribute = JPAEditorUtil.addAnnotatedAttribute(fp, inverse, owner, false, null);
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/EntitiesCoordinatesXML.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/EntitiesCoordinatesXML.java
index 884e466..971ae1a 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/EntitiesCoordinatesXML.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/EntitiesCoordinatesXML.java
@@ -1,3 +1,19 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2010, 2012 SAP AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Petya Sabeva - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+
 package org.eclipse.jpt.jpadiagrameditor.ui.internal.util;
 
 import java.io.Closeable;
@@ -42,6 +58,7 @@
 import org.w3c.dom.Text;
 import org.xml.sax.SAXException;
 
+@SuppressWarnings("resource")
 public class EntitiesCoordinatesXML {
 	
 	private Document document;
@@ -88,10 +105,8 @@
 		return (JpaProjectManager) ResourcesPlugin.getWorkspace().getAdapter(JpaProjectManager.class);
 	}
 	
-    private Closeable findXMLFile(boolean inputStream) throws FileNotFoundException{
-    	
-    	Iterator<JpaProject> iter = getJpaProjectManager().getJpaProjects().iterator();
-    	
+	private Closeable findXMLFile(boolean inputStream) throws FileNotFoundException{
+    	    	
     	IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
 		try {
 			IResource[] resources = project.members();
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorPredefinedRenderingStyle.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorPredefinedRenderingStyle.java
index d38ac35..bf657a1 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorPredefinedRenderingStyle.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorPredefinedRenderingStyle.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorUtil.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorUtil.java
index e0b5f3d..b43aeb0 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorUtil.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/IJPAEditorUtil.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorConstants.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorConstants.java
index dca88e1..3929af2 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorConstants.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorConstants.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorPredefinedColoredAreas.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorPredefinedColoredAreas.java
index 1038671..fd75cdd 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorPredefinedColoredAreas.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorPredefinedColoredAreas.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtil.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtil.java
index a4c5b15..07d3f0d 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtil.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtil.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2011 SAP AG and others.
+ * Copyright (c) 2005, 2012 SAP AG and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -1411,12 +1411,10 @@
 		actNameWithNonCapitalLetter = produceUniqueAttributeName(referencingJPT, actNameWithNonCapitalLetter);
 
 		ICompilationUnit referencingCU = JPAEditorUtil.getCompilationUnit(referencingJPT);
-		ICompilationUnit referencedCU = JPAEditorUtil.getCompilationUnit(referencedJPT);
 		return JpaArtifactFactory.instance().addAttribute(fp, referencingJPT, referencedJPT, mapKeyType,
 																			 nameWithNonCapitalLetter, 
 																			 actNameWithNonCapitalLetter, isCollection, 
-																			 referencingCU,
-																			 referencedCU);
+																			 referencingCU);
 	}
 	
 }
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtilImpl.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtilImpl.java
index b111c76..87a11d0 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtilImpl.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPAEditorUtilImpl.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2010 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPASolver.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPASolver.java
index 5a3ee9e..e9ad502 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPASolver.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JPASolver.java
@@ -1,7 +1,7 @@
 /*******************************************************************************
  * <copyright>
  *
- * Copyright (c) 2005, 2011 SAP AG.
+ * Copyright (c) 2005, 2012 SAP AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
diff --git a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java
index 8df8768..5703776 100644
--- a/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java
+++ b/jpa_diagram_editor/plugins/org.eclipse.jpt.jpadiagrameditor.ui/src/org/eclipse/jpt/jpadiagrameditor/ui/internal/util/JpaArtifactFactory.java
@@ -86,7 +86,6 @@
 import org.eclipse.jpt.jpa.core.resource.java.TableAnnotation;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.command.AddAttributeCommand;
-import org.eclipse.jpt.jpadiagrameditor.ui.internal.command.CreateNewAttributeCommand;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.command.DeleteAttributeCommand;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.command.RenameAttributeCommand;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.command.RenameEntityCommand;
@@ -572,32 +571,6 @@
 			gje.setSpecifiedName(newName);
 		}
 	}
-
-	/**
-	 * Create inverseSideAttribute of the bidirectional relationship between an embeddable class
-	 * and an entity.
-	 * @param embeddableOwner - the embeddable class
-	 * @param inverseEntity - the entity class
-	 * @param mapKeyType
-	 * @param isCollection - whether the attribute is of a collection type
-	 * @param fp
-	 * @return the inverse attribute of the relationship.
-	 */
-	public JavaPersistentAttribute addEmbeddedAttribute(JavaPersistentType embeddableOwner, JavaPersistentType inverseEntity, String mapKeyType, boolean isCollection, IJPAEditorFeatureProvider fp){
-		ICompilationUnit ijl = fp.getCompilationUnit(inverseEntity);
-		JavaPersistentType embeddingEntity = null;
-		String attributeName = ""; //$NON-NLS-1$
-		String actName = ""; //$NON-NLS-1$
-		ICompilationUnit cu2 = null;
-		HasReferanceRelation ref = findFisrtHasReferenceRelationByEmbeddable(embeddableOwner, fp);
-		if(ref != null){
-			embeddingEntity = ref.getEmbeddingEntity();
-			attributeName = JPAEditorUtil.decapitalizeFirstLetter(embeddingEntity.getSimpleName());
-			actName = JPAEditorUtil.decapitalizeFirstLetter(embeddingEntity.getSimpleName());
-			cu2 = JPAEditorUtil.getCompilationUnit(embeddingEntity);
-		}
-		return  addAttribute(fp, inverseEntity, embeddingEntity, mapKeyType, attributeName, actName, isCollection, ijl, cu2);
-	}
 	
 	/**
 	 * Find the first {@link HasReferenceRelation} for the given embeddable class from all existing
@@ -655,33 +628,23 @@
 	 * @param attributeName - the name of the attribute
 	 * @param actName - the actual name of the attribute
 	 * @param isCollection - whether the attribute is of a collection type
-	 * @param cu1 - the {@link ICompilationUnit} of the referencing {@link JavaPersistentType}
-	 * @param cu2 - the {@link ICompilationUnit} of the referenced {@link JavaPersistentType}
+	 * @param cu - the {@link ICompilationUnit} of the referencing {@link JavaPersistentType}
 	 * @return the newly created relationship attribute.
 	 */
 	public JavaPersistentAttribute addAttribute(IJPAEditorFeatureProvider fp, JavaPersistentType jpt, 
 			JavaPersistentType attributeType, String mapKeyType, String attributeName,
-			String actName, boolean isCollection, ICompilationUnit cu1,
-			ICompilationUnit cu2) {
+			String actName, boolean isCollection, ICompilationUnit cu) {
 				
 		try {
 			if (doesAttributeExist(jpt, actName)) {
-				return (JavaPersistentAttribute) jpt
-						.resolveAttribute(attributeName);
+				return (JavaPersistentAttribute) jpt.resolveAttribute(attributeName);
 			}
-
 		} catch (JavaModelException e) {
 			JPADiagramEditorPlugin.logError("Cannnot create a new attribute with name " + attributeName, e); //$NON-NLS-1$				
 		}
 		
-		Command addAttributeCommand = new AddAttributeCommand(fp, jpt, attributeType, mapKeyType, attributeName, actName, isCollection, cu1, cu2);
-		try {
-			getJpaProjectManager().execute(addAttributeCommand, SynchronousUiCommandExecutor.instance());
-		} catch (InterruptedException e) {
-			JPADiagramEditorPlugin.logError("Cannot add a new attribute with name " + actName, e); //$NON-NLS-1$		
-		}
-
-		JavaPersistentAttribute res = jpt.getAttributeNamed(actName);
+		JavaPersistentAttribute res = makeNewAttribute(fp, jpt, cu, attributeName, attributeType.getName(), actName, mapKeyType, null, null, isCollection);
+		
 		return res;
 	}
 	
@@ -759,72 +722,31 @@
 	public String createNewAttribute(JavaPersistentType jpt, 
 			boolean isCollection, IJPAEditorFeatureProvider fp) {
 		
-		ICompilationUnit ijl = fp.getCompilationUnit(jpt);
 		String attrTypeName = "java.lang.String"; 																	//$NON-NLS-1$
 		String newAttrName = genUniqueAttrName(jpt, attrTypeName, fp);
-		return addNewAttribute(jpt, ijl, newAttrName, attrTypeName,
-				"", newAttrName, isCollection, fp); //$NON-NLS-1$
+		ICompilationUnit cu = fp.getCompilationUnit(jpt);
+		makeNewAttribute(fp, jpt, cu, newAttrName, attrTypeName, newAttrName, attrTypeName, null, null, isCollection);
+		return newAttrName;
 	}
-	
-	public String addNewAttribute(JavaPersistentType jpt, ICompilationUnit cu,
-			String attrName, String attrTypeName, String annotation,
-			String actName, boolean isCollection, IJPAEditorFeatureProvider fp) {
-		
-		try {
-			List<String> annotations = new LinkedList<String>();
-			annotations.add(annotation);
-			boolean isMethodAnnotated = JpaArtifactFactory.instance()
-					.isMethodAnnotated(jpt);
-			makeNewAttribute(fp, jpt, cu, attrName, attrTypeName, null, actName,
-					annotations, isCollection, isMethodAnnotated);
-		} catch (JavaModelException e) {
-			JPADiagramEditorPlugin.logError("Cannot create a new attribute with name " + attrName, e); //$NON-NLS-1$		
+
+	public JavaPersistentAttribute makeNewAttribute(IJPAEditorFeatureProvider fp, JavaPersistentType jpt, ICompilationUnit cu, String attrName, String attrTypeName,
+			String actName, String mapKeyType, String[] attrTypes, List<String> annotations, boolean isCollection) {
+
+		if(cu == null){
+			cu = fp.getCompilationUnit(jpt);
 		}
-		return attrName;				
-	}
-	
-	public JavaPersistentAttribute createANewAttribute(JavaPersistentType jpt, 
-			String attrName, String attrTypeName, String[] attrTypeElementNames,
-			String actName, List<String> annotations, boolean isCollection,
-			boolean isMethodAnnotated, IJPAEditorFeatureProvider fp) {
 		
-		ICompilationUnit ijl = fp.getCompilationUnit(jpt);
-		return addANewAttribute(jpt, ijl, attrName, attrTypeName,
-				attrTypeElementNames, actName, annotations, isCollection,
-				isMethodAnnotated, fp);
-	}
-	
-	private JavaPersistentAttribute addANewAttribute(JavaPersistentType jpt, 
-			ICompilationUnit cu, String attrName, String attrTypeName,
-			String[] attrTypeElementNames, String actName,
-			List<String> annotations, boolean isCollection,
-			boolean isMethodAnnotated, IJPAEditorFeatureProvider fp) {
-		
-		JavaPersistentAttribute attr = null;
-		try {
-			attr = makeNewAttribute(fp, jpt, cu, attrName, attrTypeName,
-					attrTypeElementNames, actName, annotations, isCollection,
-					isMethodAnnotated);
-		} catch (JavaModelException e) {
-			JPADiagramEditorPlugin.logError("Cannot create a new attribute with name " + attrName, e); //$NON-NLS-1$		
-		}
-		return attr;						
-	}
-	
-	public JavaPersistentAttribute makeNewAttribute(IFeatureProvider fp, JavaPersistentType jpt, 
-			ICompilationUnit cu, String attrName, String attrTypeName,
-			String[] attrTypes, String actName,
-			List<String> annotations, boolean isCollection,
-			boolean isMethodAnnotated) throws JavaModelException {
-				
-		Command createNewAttributeCommand = new CreateNewAttributeCommand(jpt, cu, attrName, attrTypeName, attrTypes, actName, annotations, isCollection, isMethodAnnotated);
+		Command createNewAttributeCommand = new AddAttributeCommand(fp, jpt, attrTypeName, mapKeyType, attrName, actName, attrTypes, annotations, isCollection, cu);
 		try {
 			getJpaProjectManager().execute(createNewAttributeCommand, SynchronousUiCommandExecutor.instance());
 		} catch (InterruptedException e) {
 			JPADiagramEditorPlugin.logError("Cannot create a new attribute with name " + attrName, e); //$NON-NLS-1$		
 		}
 
-		JavaPersistentAttribute jpa = jpt.getAttributeNamed(attrName);		
+		JavaPersistentAttribute jpa = jpt.getAttributeNamed(attrName);
+		if(jpa == null){
+			jpa = jpt.getAttributeNamed(actName);
+		}
 		return jpa;
 	}
 		
@@ -936,7 +858,7 @@
 		CompilationUnit jdtCU = jpt.getJavaResourceType().getJavaResourceCompilationUnit().buildASTRoot();
 		JavaResourceAttribute jrpt = persistentAttribite.getResourceAttribute();
 		List<String> res = new LinkedList<String>();
-		for (Annotation an : jrpt.getAnnotations()) {
+		for (Annotation an : jrpt.getTopLevelAnnotations()) {
 			org.eclipse.jdt.core.dom.Annotation jdtAn = an.getAstAnnotation(jdtCU);
 			res.add(jdtAn.toString());
 		}
@@ -1591,81 +1513,6 @@
 		return false;
 	}
 	
-	/**
-	 * Create the attribute's getter method in entity's compilation unit.
-	 * @param attrName - the name of the attribute
-	 * @param attrType - the type of the attribute
-	 * @param attrTypeElementNames
-	 * @param actName
-	 * @param annotations
-	 * @param isCollection
-	 * @return the string representation of the attribute's getter method.
-	 */
-	public String genGetterContents(String attrName, String attrType,
-			String[] attrTypeElementNames, String actName,
-			List<String> annotations, boolean isCollection) {
-		
-		String attrNameWithCapitalA = actName.substring(0, 1).toUpperCase(Locale.ENGLISH)
-				+ actName.substring(1);
-		String contents = ""; //$NON-NLS-1$
-		if (annotations != null) {
-			Iterator<String> it = annotations.iterator();
-			while (it.hasNext()) {
-				String an = it.next();
-				contents += "   " + an + "\n"; //$NON-NLS-1$ //$NON-NLS-2$
-			}
-		}
-		if (isCollection) {
-			contents += "    public Collection<"+ attrType + "> get" + attrNameWithCapitalA + "() {\n" +  	//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ 
-					"        return "	//$NON-NLS-1$
-					+ JPAEditorUtil.decapitalizeFirstLetter(actName) + ";\n" + //$NON-NLS-1$ 
-			  "    }\n";  //$NON-NLS-1$			
-		} else {
-			contents += "    public "+ attrType + //$NON-NLS-1$
-							((attrTypeElementNames == null)?"":("<" + JPAEditorUtil.createCommaSeparatedListOfSimpleTypeNames(attrTypeElementNames) + ">")) + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-							(attrType.equals("boolean") ? " is" : " get") + attrNameWithCapitalA + "() {\n" +  	//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ 
-					"        return "	//$NON-NLS-1$
-					+ JPAEditorUtil.decapitalizeFirstLetter(actName) + ";\n" + //$NON-NLS-1$ 
-			  "    }\n";  																//$NON-NLS-1$			
-		}
-		return contents;
-	}
-	
-	/**
-	 * Create the attribute's setter method in entity's compilation unit.
-	 * @param attrName - the name of the attribute
-	 * @param attrType - the type of the attribute
-	 * @param attrTypeElementNames
-	 * @param actName
-	 * @param isCollection
-	 * @return the string representation of the attribute's setter method.
-	 */
-	public String genSetterContents(String attrName, String attrType,
-			String[] attrTypeElementNames, String actName, boolean isCollection) {
-		
-		String attrNameWithCapitalA = actName.substring(0, 1).toUpperCase(Locale.ENGLISH)
-				+ actName.substring(1);
-		String contents = ""; //$NON-NLS-1$
-		if (isCollection) {
-			contents = "    public void set" + attrNameWithCapitalA + "(Collection<" + attrType + "> param) " + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-					"{\n" + //$NON-NLS-1$ 
-					"        this."	//$NON-NLS-1$
-					+ JPAEditorUtil.decapitalizeFirstLetter(actName)
-					+ " = param;\n" + //$NON-NLS-1$ 
-						  "    }\n";  	//$NON-NLS-1$
-		} else {
-			contents = "    public void set" + attrNameWithCapitalA + "(" + attrType + //$NON-NLS-1$ //$NON-NLS-2$
-								((attrTypeElementNames == null)?"":("<" + JPAEditorUtil.createCommaSeparatedListOfSimpleTypeNames(attrTypeElementNames) + ">")) + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-					" param) {\n"	//$NON-NLS-1$
-					+ 
-					"        this."	//$NON-NLS-1$
-					+ JPAEditorUtil.decapitalizeFirstLetter(actName)
-					+ " = param;\n" + //$NON-NLS-1$ 
-			  "    }\n";  			//$NON-NLS-1$			
-		}
-		return contents;
-	}
-	
 	private boolean doesAttributeExist(JavaPersistentType jpt, String name)
 											throws JavaModelException {
 		boolean exists = false;
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java
index 3de6230..cec84fa 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/internal/JPACreateFactory.java
@@ -593,7 +593,7 @@
 		if (javaPersistentType == null)
 			throw new RuntimeException("The entity could not be created");
 		ICompilationUnit compilationUnit = JavaCore.createCompilationUnitFrom(entity);
-		JpaArtifactFactory.instance().addNewAttribute(javaPersistentType, compilationUnit, attName, attType, annotation, attActName, isCollection, null);
+		JpaArtifactFactory.instance().makeNewAttribute(null, javaPersistentType, compilationUnit, attName, attType, attActName, attType, null, null, isCollection);
 	}
 	
 	private IFile createFieldAnnotatedEntity(IFolder folder, String packageName, String entityName) throws IOException, CoreException {
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java
index ccfbd64..7fc8418 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EditorProxy.java
@@ -25,8 +25,11 @@
 import org.eclipse.gef.LayerConstants;
 import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
 import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.internal.ExternalPictogramLink;
+import org.eclipse.graphiti.mm.Property;
 import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.services.Graphiti;
 import org.eclipse.graphiti.ui.internal.contextbuttons.ContextButton;
 import org.eclipse.graphiti.ui.internal.contextbuttons.ContextButtonPad;
 import org.eclipse.graphiti.ui.internal.parts.DiagramEditPart;
@@ -35,7 +38,9 @@
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
 import org.eclipse.jpt.jpa.ui.internal.details.JptUiDetailsMessages;
+import org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.Utils;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.i18n.JPAEditorMessages;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.HasReferanceRelation;
@@ -63,6 +68,8 @@
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotStyledText;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
+import org.eclipse.swtbot.swt.finder.widgets.TimeoutException;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IEditorReference;
 
@@ -73,7 +80,7 @@
 	protected SWTGefBot bot;
 
 	private SWTBotGefEditor jpaDiagramEditor;
-	
+
 	/**
 	 * Create proxy object.
 	 * 
@@ -84,19 +91,22 @@
 		this.bot = bot;
 	}
 
-	public SWTBotGefEditor openDiagramOnJPAContentNode(String name, boolean isJPA20) {
+	public SWTBotGefEditor openDiagramOnJPAContentNode(String name,
+			boolean isJPA20) {
 		SWTBotTree projectTree = workbenchBot.viewByTitle("Project Explorer")
 				.bot().tree();
-		projectTree.expandNode(name).expandNode("JPA Content").select();
+		SWTBotTreeItem item = projectTree.expandNode(name)
+				.expandNode("JPA Content").select();
+		assertTrue("The JPA Content node is disabled.", item.isEnabled());
 		ContextMenuHelper.clickContextMenu(projectTree, "Open Diagram");
 
-		if(isJPA20) {
+		if (isJPA20) {
 			workbenchBot
-				.waitUntil(
-						shellIsActive(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle),
-						10000);
+					.waitUntil(
+							shellIsActive(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle),
+							10000);
 			SWTBotShell jpaSupportWarningDialog = workbenchBot
-				.shell(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle);
+					.shell(JPAEditorMessages.OpenJpaDiagramActionDelegate_jpaSupportWarningTitle);
 			getOkButton(jpaSupportWarningDialog).click();
 		}
 
@@ -137,7 +147,8 @@
 	 * @param attribute
 	 * @return the "Select Type" dialog
 	 */
-	public SWTBotShell getSelectNewAttributeTypeDialog(SWTBotGefEditPart attribute) {
+	public SWTBotShell getSelectNewAttributeTypeDialog(
+			SWTBotGefEditPart attribute) {
 		attribute.click();
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_refactorAttributeType);
@@ -176,7 +187,8 @@
 	 * @param fp
 	 * @return the value of the attribute's type
 	 */
-	public String getAttributeType(String attributeName, final IFeatureProvider fp) {
+	public String getAttributeType(String attributeName,
+			final IFeatureProvider fp) {
 		SWTBotGefEditPart attribute = jpaDiagramEditor
 				.getEditPart(attributeName);
 		PictogramElement el = (PictogramElement) attribute.part().getModel();
@@ -198,15 +210,51 @@
 	 */
 	public SWTBotGefEditPart addAttributeToJPT(SWTBotGefEditPart jptType,
 			String attributeName) {
-		pressEntityContextButton(jptType,
+		
+		JavaPersistentType jpt = getJPTObjectForGefElement(jptType);
+		
+		System.out.println(">>>>>> Attribute is trying to be added in " + jpt.getName());
+		
+		pressEntityContextButton(
+				jptType,
 				JPAEditorMessages.JPAEditorToolBehaviorProvider_createAttributeButtonlabel);
 
 		bot.waitUntil(new ElementIsShown(jpaDiagramEditor, attributeName),
 				10000);
 		List<SWTBotGefEditPart> editParts = new ArrayList<SWTBotGefEditPart>();
 		editParts.add(jptType);
-		SWTBotGefEditPart attribute = jpaDiagramEditor
-				.getEditpart(attributeName, editParts);
+		SWTBotGefEditPart attribute = jpaDiagramEditor.getEditpart(
+				attributeName, editParts);
+		assertNotNull("Atrribute is not added.", attribute);
+		
+		System.out.println(">>>>>> Attribute is successfully added in " + jpt.getName());
+
+		assertTrue("The newly added attribute must be selected.",
+				jpaDiagramEditor.selectedEditParts().size() == 1);
+		// assertTrue("The newly added attribute must be selected.",
+		// jpaDiagramEditor.selectedEditParts().contains(attribute));
+
+		assertTrue(
+				"\"Other Attributes\" section must be visible!",
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+						jptType));
+
+		return attribute;
+	}
+
+	public SWTBotGefEditPart addElementCollectionAttributeToJPT(
+			SWTBotGefEditPart jptType, String attributeName) {
+		pressEntityContextButton(
+				jptType,
+				JPAEditorMessages.JPAEditorToolBehaviorProvider_CreateElementCollectionAttributeButtonLabel);
+
+		bot.waitUntil(new ElementIsShown(jpaDiagramEditor, attributeName),
+				10000);
+		List<SWTBotGefEditPart> editParts = new ArrayList<SWTBotGefEditPart>();
+		editParts.add(jptType);
+		SWTBotGefEditPart attribute = jpaDiagramEditor.getEditpart(
+				attributeName, editParts);
 		assertNotNull("Atrribute is not added.", attribute);
 
 		assertTrue("The newly added attribute must be selected.",
@@ -214,8 +262,17 @@
 		assertTrue("The newly added attribute must be selected.",
 				jpaDiagramEditor.selectedEditParts().contains(attribute));
 
-		assertTrue("\"Other Attributes\" section must be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, jptType));
+		assertTrue(
+				"\"Other Attributes\" section must be visible!",
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+						jptType));
+
+		JavaPersistentAttribute jpa = getJPAObjectForGefElement(attribute);
+		assertEquals(
+				"The newly added attribute must be mapped as element-collection.",
+				MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY,
+				jpa.getMappingKey());
 
 		return attribute;
 	}
@@ -228,7 +285,8 @@
 	 * @return true, if the section with the specified name is visible, false
 	 *         otherwise
 	 */
-	public boolean isSectionVisible(String sectionTitle, SWTBotGefEditPart editPart) {
+	public boolean isSectionVisible(String sectionTitle,
+			SWTBotGefEditPart editPart) {
 		List<SWTBotGefEditPart> editParts = new ArrayList<SWTBotGefEditPart>();
 		editParts.add(editPart);
 		SWTBotGefEditPart section = jpaDiagramEditor.getEditpart(sectionTitle,
@@ -249,8 +307,21 @@
 		jpaDiagramEditor
 				.activateTool(JPAEditorMessages.CreateJPAEntityFeature_jpaEntityFeatureName);
 		jpaDiagramEditor.doubleClick(x, y);
-		bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 10000);
 
+		try{
+			bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 30000);
+		} catch (TimeoutException e){
+			jpaDiagramEditor.activateDefaultTool();
+			
+			Utils.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>> yavno tova e");
+			
+			jpaDiagramEditor
+			.activateTool(JPAEditorMessages.CreateJPAEntityFeature_jpaEntityFeatureName);
+			jpaDiagramEditor.doubleClick(x, y);
+	
+			bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 30000);
+		}
+		
 		List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart()
 				.children();
 		assertFalse("Editor must contains at least one entity!",
@@ -264,13 +335,19 @@
 
 		assertTrue(
 				"\"Primary Key\" section must be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape, entity));
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape,
+						entity));
 		assertFalse(
 				"\"Relation Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes, entity));
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes,
+						entity));
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, entity));
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+						entity));
 
 		return entity;
 	}
@@ -282,11 +359,25 @@
 	 *            - the name of the mapped superclass to be added
 	 * @return the added mapped superclass
 	 */
-	public SWTBotGefEditPart addMappedSuperclassToDiagram(int x, int y, String entityName) {
+	public SWTBotGefEditPart addMappedSuperclassToDiagram(int x, int y,
+			String entityName) {
 		jpaDiagramEditor
 				.activateTool(JPAEditorMessages.CreateMappedSuperclassFeature_createMappedSuperclassFeatureName);
 		jpaDiagramEditor.doubleClick(x, y);
-		bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 10000);
+				
+		try{
+			bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 30000);
+		} catch (TimeoutException e){
+			jpaDiagramEditor.activateDefaultTool();
+			
+			Utils.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>> yavno tova e");
+			
+			jpaDiagramEditor
+			.activateTool(JPAEditorMessages.CreateMappedSuperclassFeature_createMappedSuperclassFeatureName);
+			jpaDiagramEditor.doubleClick(x, y);
+	
+			bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 30000);
+		}
 
 		List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart()
 				.children();
@@ -299,22 +390,26 @@
 
 		List<SWTBotGefEditPart> parts = new ArrayList<SWTBotGefEditPart>();
 		parts.add(mappedSuperclass);
-		
-		SWTBotGefEditPart idAttribute = jpaDiagramEditor.getEditpart("id", parts);
+
+		SWTBotGefEditPart idAttribute = jpaDiagramEditor.getEditpart("id",
+				parts);
 		assertNull("Mapped superclass must not have a primary key attribute!",
 				idAttribute);
 
 		assertFalse(
 				"\"Primary Key\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape,
 						mappedSuperclass));
 		assertFalse(
 				"\"Relation Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes,
 						mappedSuperclass));
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						mappedSuperclass));
 
 		return mappedSuperclass;
@@ -327,11 +422,26 @@
 	 *            - the name of the mapped superclass to be added
 	 * @return the added mapped superclass
 	 */
-	public SWTBotGefEditPart addEmbeddableToDiagram(int x, int y, String entityName) {
-		jpaDiagramEditor.activateTool(JPAEditorMessages.CreateEmbeddableFeature_EmbeddableFeatureName);
+	public SWTBotGefEditPart addEmbeddableToDiagram(int x, int y,
+			String entityName) {
+		jpaDiagramEditor
+				.activateTool(JPAEditorMessages.CreateEmbeddableFeature_EmbeddableFeatureName);
 		jpaDiagramEditor.doubleClick(x, y);
-		bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 10000);
-
+		
+		try{
+			bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 30000);
+		} catch (TimeoutException e){
+			jpaDiagramEditor.activateDefaultTool();
+			
+			Utils.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>> yavno tova e");
+			
+			jpaDiagramEditor
+			.activateTool(JPAEditorMessages.CreateEmbeddableFeature_EmbeddableFeatureName);
+			jpaDiagramEditor.doubleClick(x, y);
+	
+			bot.waitUntil(new ElementIsShown(jpaDiagramEditor, entityName), 30000);
+		}
+		
 		List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart()
 				.children();
 		assertFalse("Editor must contains at least one embeddable!",
@@ -349,15 +459,18 @@
 
 		assertFalse(
 				"\"Primary Key\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape,
 						embeddable));
 		assertFalse(
 				"\"Relation Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes,
 						embeddable));
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						embeddable));
 
 		return embeddable;
@@ -429,8 +542,10 @@
 	 * menu is pressed. Press the OK button.
 	 */
 	public void confirmRemoveEntitiesFromDiagramDialog() {
-		workbenchBot.waitUntil(
-			shellIsActive(JPAEditorMessages.JPAEditorToolBehaviorProvider_removeAllEntitiesMenu), 10000);
+		workbenchBot
+				.waitUntil(
+						shellIsActive(JPAEditorMessages.JPAEditorToolBehaviorProvider_removeAllEntitiesMenu),
+						10000);
 		SWTBotShell shell = workbenchBot
 				.shell(JPAEditorMessages.JPAEditorToolBehaviorProvider_removeAllEntitiesMenu);
 		assertTrue("Ok button is disabled", getOkButton(shell).isEnabled());
@@ -450,8 +565,8 @@
 
 		List<SWTBotGefEditPart> entitiesInDiagram = jpaDiagramEditor
 				.mainEditPart().children();
-		assertFalse("Diagram must contain at least one entity!",
-				entitiesInDiagram.isEmpty());
+//		assertFalse("Diagram must contain at least one entity!",
+//				entitiesInDiagram.isEmpty());
 
 		for (int i = 0; i < entitiesInDiagram.size(); i++) {
 			SWTBotGefEditPart editPart = entitiesInDiagram.get(i);
@@ -467,14 +582,14 @@
 		waitASecond();
 		entitiesInDiagram = jpaDiagramEditor.mainEditPart().children();
 		assertTrue("Diagram must be empty!", entitiesInDiagram.isEmpty());
-		assertTrue("Editor must be dirty!", jpaDiagramEditor.isDirty());
+//		assertTrue("Editor must be dirty!", jpaDiagramEditor.isDirty());
 	}
 
 	public void deleteAttributeInJPT(SWTBotGefEditPart jpt, String attributeName) {
-		
+
 		waitASecond();
 		jpaDiagramEditor.activateDefaultTool();
-		
+
 		List<SWTBotGefEditPart> jptParts = new ArrayList<SWTBotGefEditPart>();
 		jptParts.add(jpt);
 		SWTBotGefEditPart attribute = jpaDiagramEditor.getEditpart(
@@ -483,8 +598,8 @@
 		attribute.click();
 		jpaDiagramEditor.clickContextMenu("Delete");
 		confirmDelete();
-		bot.waitUntil(new ElementDisappears(jpaDiagramEditor, jpt, attributeName),
-				10000);
+		bot.waitUntil(new ElementDisappears(jpaDiagramEditor, jpt,
+				attributeName), 10000);
 	}
 
 	/**
@@ -494,7 +609,8 @@
 	 * @param contextButtonName
 	 *            - the name of the button to be pressed
 	 */
-	public void pressEntityContextButton(SWTBotGefEditPart part, String contextButtonName) {
+	public void pressEntityContextButton(SWTBotGefEditPart part,
+			String contextButtonName) {
 		pressContextButton(part, contextButtonName);
 	}
 
@@ -503,7 +619,8 @@
 	 * 
 	 */
 	public void pressAttributeDeleteContextButton(SWTBotGefEditPart part) {
-		pressContextButton(part,
+		pressContextButton(
+				part,
 				JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteAttributeButtonlabel);
 	}
 
@@ -514,7 +631,8 @@
 	 * @param contextButtonName
 	 *            - the name of the button to be pressed.
 	 */
-	private void pressContextButton(SWTBotGefEditPart part, String contextButtonName) {
+	private void pressContextButton(SWTBotGefEditPart part,
+			String contextButtonName) {
 		jpaDiagramEditor.click(0, 0);
 		jpaDiagramEditor.click(part);
 
@@ -658,14 +776,22 @@
 	 * @return the IRelation object for the given GEF Connection
 	 */
 	@SuppressWarnings("restriction")
-	public HasReferanceRelation getHasReferenceConnection(SWTBotGefConnectionEditPart gefConn) {
+	public HasReferanceRelation getHasReferenceConnection(
+			SWTBotGefConnectionEditPart gefConn) {
 		IFeatureProvider fp = ((DiagramEditPart) jpaDiagramEditor
 				.mainEditPart().part()).getFeatureProvider();
 		FreeFormConnection conn = (FreeFormConnection) gefConn.part()
 				.getModel();
+		assertNotNull("Relation is not created.", conn);
+			
 		Object ob = fp.getBusinessObjectForPictogramElement(conn);
+		
+		assertNotNull("Such a relation must exists.", ob);
 		if (ob instanceof HasReferanceRelation) {
+			System.out.println("======================= axam axam");
 			return (HasReferanceRelation) ob;
+		} else if (ob instanceof IRelation) {
+			System.out.println("++++++++++++ dobre");
 		}
 
 		return null;
@@ -678,7 +804,8 @@
 	 * @return the java persistent type for the given element, null if the
 	 *         selected element is not an entity
 	 */
-	public JavaPersistentType getJPTObjectForGefElement(SWTBotGefEditPart element) {
+	public JavaPersistentType getJPTObjectForGefElement(
+			SWTBotGefEditPart element) {
 		final IFeatureProvider fp = ((DiagramEditPart) jpaDiagramEditor
 				.mainEditPart().part()).getFeatureProvider();
 		PictogramElement el = (PictogramElement) element.part().getModel();
@@ -689,7 +816,8 @@
 		return null;
 	}
 
-	public JavaPersistentAttribute getJPAObjectForGefElement(SWTBotGefEditPart element) {
+	public JavaPersistentAttribute getJPAObjectForGefElement(
+			SWTBotGefEditPart element) {
 		final IFeatureProvider fp = ((DiagramEditPart) jpaDiagramEditor
 				.mainEditPart().part()).getFeatureProvider();
 		PictogramElement el = (PictogramElement) element.part().getModel();
@@ -774,11 +902,13 @@
 		assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
 		assertTrue(
 				"\"Relation Attributes\" section of the owner entity must be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 		assertTrue(
 				"\"Relation Attributes\" section of the inverse entity must be visible!",
-				isSectionVisible(entity2,
+				isSectionVisible(
+						entity2,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -807,7 +937,8 @@
 		assertNotNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
 		assertTrue(
 				"\"Relation Attributes\" section of the owner entity must be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -836,11 +967,13 @@
 		assertNotNull(jpaDiagramEditor.getEditPart(attributeName));
 		assertTrue(
 				"\"Relation Attributes\" section of the owner entity must be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 		assertFalse(
 				"\"Relation Attributes\" section of the inverse entity must not be visible!",
-				isSectionVisible(entity2,
+				isSectionVisible(
+						entity2,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -867,7 +1000,8 @@
 		assertNotNull(jpaDiagramEditor.getEditPart(attributeName));
 		assertTrue(
 				"\"Relation Attributes\" section of the owner entity must be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -883,9 +1017,9 @@
 	 * @param ownerAttributeName
 	 * @param inverseAttributeName
 	 */
-	public void assertBiDirRelationIsDeleted(SWTBotGefEditPart entity1, SWTBotGefEditPart entity2,
-			SWTBotGefConnectionEditPart connection, String ownerAttributeName,
-			String inverseAttributeName) {
+	public void assertBiDirRelationIsDeleted(SWTBotGefEditPart entity1,
+			SWTBotGefEditPart entity2, SWTBotGefConnectionEditPart connection,
+			String ownerAttributeName, String inverseAttributeName) {
 		connection.select();
 		jpaDiagramEditor.clickContextMenu("Delete");
 		confirmDelete();
@@ -895,14 +1029,16 @@
 		assertTrue(entity2.targetConnections().isEmpty());
 		assertNull(jpaDiagramEditor.getEditPart(ownerAttributeName));
 		assertNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
-				
+
 		assertFalse(
 				"\"Relation Attributes\" section of the owner entity must not be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 		assertFalse(
 				"\"Relation Attributes\" section of the inverse entity must not be visible!",
-				isSectionVisible(entity2,
+				isSectionVisible(
+						entity2,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -931,7 +1067,8 @@
 		assertNull(jpaDiagramEditor.getEditPart(inverseAttributeName));
 		assertFalse(
 				"\"Relation Attributes\" section of the owner entity must not be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -947,8 +1084,9 @@
 	 * @param ownerAttributeName
 	 * @param inverseAttributeName
 	 */
-	public void assertUniDirRelationIsDeleted(SWTBotGefEditPart entity1, SWTBotGefEditPart entity2,
-			SWTBotGefConnectionEditPart connection, String attributeName) {
+	public void assertUniDirRelationIsDeleted(SWTBotGefEditPart entity1,
+			SWTBotGefEditPart entity2, SWTBotGefConnectionEditPart connection,
+			String attributeName) {
 		connection.select();
 		jpaDiagramEditor.clickContextMenu("Delete");
 		confirmDelete();
@@ -959,11 +1097,13 @@
 		assertNull(jpaDiagramEditor.getEditPart(attributeName));
 		assertFalse(
 				"\"Relation Attributes\" section of the owner entity must not be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 		assertFalse(
 				"\"Relation Attributes\" section of the inverse entity must not be visible!",
-				isSectionVisible(entity2,
+				isSectionVisible(
+						entity2,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -990,7 +1130,8 @@
 		assertNull(jpaDiagramEditor.getEditPart(attributeName));
 		assertFalse(
 				"\"Relation Attributes\" section of the owner entity must not be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
@@ -1001,8 +1142,8 @@
 	 * @param entity1
 	 * @param entity2
 	 */
-	public void assertConnectionIsCreated(SWTBotGefEditPart entity1, SWTBotGefEditPart entity2,
-			boolean isBiDIr) {
+	public void assertConnectionIsCreated(SWTBotGefEditPart entity1,
+			SWTBotGefEditPart entity2, boolean isBiDIr) {
 		// assert that there is exactly one relationship, which start from
 		// entity1
 		// and that there is no relationship which starts from entity2
@@ -1014,26 +1155,30 @@
 		// and that there is no relationship which end in entity1.
 		assertFalse(entity2.targetConnections().isEmpty());
 		assertEquals(1, entity2.targetConnections().size());
-//		assertTrue(entity1.targetConnections().isEmpty());
+		// assertTrue(entity1.targetConnections().isEmpty());
 
 		assertTrue(
 				"\"Relation Attributes\" section of the owner entity must be visible!",
-				isSectionVisible(entity1,
+				isSectionVisible(
+						entity1,
 						JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 		if (isBiDIr) {
 			assertTrue(
 					"\"Relation Attributes\" section of the inverse entity must be visible!",
-					isSectionVisible(entity2,
+					isSectionVisible(
+							entity2,
 							JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 		} else {
 			assertFalse(
 					"\"Relation Attributes\" section of the inverse entity must not be visible!",
-					isSectionVisible(entity2,
+					isSectionVisible(
+							entity2,
 							JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 		}
 	}
 
-	public void assertIsARelationExists(SWTBotGefEditPart entity1, SWTBotGefEditPart entity2) {
+	public void assertIsARelationExists(SWTBotGefEditPart entity1,
+			SWTBotGefEditPart entity2) {
 		// assert that there is exactly one relationship, which start from
 		// entity2 and that there is no relationship which starts from entity2
 		assertFalse(entity2.sourceConnections().isEmpty());
@@ -1063,7 +1208,8 @@
 		assertFalse(entity1.targetConnections().isEmpty());
 		assertEquals(1, entity1.targetConnections().size());
 
-		assertTrue(isSectionVisible(entity1, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+		assertTrue(isSectionVisible(entity1,
+				JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
 	/**
@@ -1125,7 +1271,8 @@
 	 * @return true, if the sections is visible, false otherwise
 	 */
 	@SuppressWarnings("deprecation")
-	public boolean isSectionVisible(SWTBotGefEditPart editPart, String sectionTitle) {
+	public boolean isSectionVisible(SWTBotGefEditPart editPart,
+			String sectionTitle) {
 		List<SWTBotGefEditPart> children = editPart.children();
 		SWTBotGefEditPart section = jpaDiagramEditor.getEditpart(sectionTitle,
 				children);
@@ -1134,7 +1281,8 @@
 		return figure.isVisible() || figure.isShowing();
 	}
 
-	public SWTBotGefEditPart getSectionInJPT(SWTBotGefEditPart editPart, String sectionTitle) {
+	public SWTBotGefEditPart getSectionInJPT(SWTBotGefEditPart editPart,
+			String sectionTitle) {
 		List<SWTBotGefEditPart> children = editPart.children();
 		SWTBotGefEditPart section = jpaDiagramEditor.getEditpart(sectionTitle,
 				children);
@@ -1216,39 +1364,62 @@
 	 *            - the expected type mapping
 	 */
 	public void assertTypeIsCorretlyMapped(String typeName, String typeMapping) {
-		workbenchBot.viewByTitle("JPA Details").close();
-		
-		SWTBotGefEditPart type = jpaDiagramEditor.getEditPart(typeName);
-		type.click();
-		
-		jpaDiagramEditor
-				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_openJPADetailsView);
+		// workbenchBot.viewByTitle("JPA Details").close();
+
+//		SWTBotGefEditPart type = jpaDiagramEditor.getEditPart(typeName);
+
+//		JavaPersistentType jpt = getJPTObjectForGefElement(type);
+//		assertEquals("Type is not mapped correctly.", jpt.getMappingKey(),
+//				typeMapping);
+
+		// type.click();
+		//
+		// jpaDiagramEditor
+		// .clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_openJPADetailsView);
+		// // assert that the JPA Details view is opened
+		// SWTBotView jpaDetailsView = workbenchBot.viewByTitle("JPA Details");
+		// assertTrue("JPA Details view must be opened!",
+		// jpaDetailsView.isActive());
+		//
+		// // assert that the default entity's attribute is mapped as the given
+		// // mapping key
+		// SWTBot jpaDetailsBot = jpaDetailsView.bot();
+		// SWTBotStyledText styledText = jpaDetailsBot.styledText();
+		// assertEquals("Type '" + typeName + "' is mapped as " + typeMapping
+		// + ".", styledText.getText());
+
 		// assert that the JPA Details view is opened
 		SWTBotView jpaDetailsView = workbenchBot.viewByTitle("JPA Details");
+		jpaDetailsView.setFocus();
 		assertTrue("JPA Details view must be opened!",
 				jpaDetailsView.isActive());
 
-		// assert that the default entity's attribute is mapped as the given
-		// mapping key
+		SWTBotGefEditPart type = jpaDiagramEditor.getEditPart(typeName);
+
+		type.select();
+		type.click();
+
+		// assert that the default entity's attribute is mapped as primary key
 		SWTBot jpaDetailsBot = jpaDetailsView.bot();
 		SWTBotStyledText styledText = jpaDetailsBot.styledText();
-		assertEquals("Type '" + typeName + "' is mapped as " + typeMapping
-				+ ".", styledText.getText());
+		assertEquals("Type '" + typeName + "' is mapped as "
+				+ typeMapping + ".", styledText.getText());
 	}
 
 	public void deleteJPTViaButton(SWTBotGefEditPart jptType) {
 
-		String jptName = getJPTObjectForGefElement(jptType)
-				.getSimpleName();
+		String jptName = getJPTObjectForGefElement(jptType).getSimpleName();
 
-		pressEntityContextButton(jptType,
+		pressEntityContextButton(
+				jptType,
 				JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteEntityFromModelButtonLabel);
 		denyDelete();
 
 		jptType = jpaDiagramEditor.getEditPart(jptName);
 		assertNotNull("Entity is deleted!", jptType);
 
-		pressEntityContextButton(jptType,
+		pressEntityContextButton(
+				jptType,
 				JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteEntityFromModelButtonLabel);
 		confirmDelete();
 		bot.waitUntil(new ElementDisappears(jpaDiagramEditor, jptName), 10000);
@@ -1258,8 +1429,7 @@
 
 	public void deleteJPTViaMenu(SWTBotGefEditPart jptType) {
 
-		String jptName = getJPTObjectForGefElement(jptType)
-				.getSimpleName();
+		String jptName = getJPTObjectForGefElement(jptType).getSimpleName();
 
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_deleteEntityFromModelButtonLabel);
@@ -1276,12 +1446,14 @@
 		assertNull("Entity is not deleted!", jptType);
 	}
 
-	public void removeAttributeViaButton(SWTBotGefEditPart jptType, String attributeName) {
+	public void removeAttributeViaButton(SWTBotGefEditPart jptType,
+			String attributeName) {
 
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
 
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						jptType));
 
 		SWTBotGefEditPart attribute = addAttributeToJPT(jptType, attributeName);
@@ -1303,15 +1475,18 @@
 		jpaDiagramEditor.save();
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						jptType));
 
 	}
 
-	public void removeAttributeViaMenu(SWTBotGefEditPart jptType, String attributeName) {
+	public void removeAttributeViaMenu(SWTBotGefEditPart jptType,
+			String attributeName) {
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						jptType));
 
 		SWTBotGefEditPart attribute = addAttributeToJPT(jptType, attributeName);
@@ -1334,15 +1509,18 @@
 
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						jptType));
 	}
 
-	public void directEditAttribute(SWTBotGefEditPart jptType, String attributeName) {
+	public void directEditAttribute(SWTBotGefEditPart jptType,
+			String attributeName) {
 
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						jptType));
 
 		SWTBotGefEditPart attribute = addAttributeToJPT(jptType, attributeName);
@@ -1373,7 +1551,7 @@
 
 		pressEntityContextButton(jptType, "Expand");
 		waitASecond();
-		
+
 		newHeight = ((PictogramElement) jptType.part().getModel())
 				.getGraphicsAlgorithm().getHeight();
 		assertEquals("Entity must be expanded!", heigth, newHeight);
@@ -1384,13 +1562,13 @@
 
 		int heigth = ((PictogramElement) jptType.part().getModel())
 				.getGraphicsAlgorithm().getHeight();
-		
+
 		jpaDiagramEditor.click(jptType);
 
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_collapseEntityMenuItem);
 		waitASecond();
-		
+
 		int newHeight = ((PictogramElement) jptType.part().getModel())
 				.getGraphicsAlgorithm().getHeight();
 		assertEquals("Entity must be collapsed!",
@@ -1400,14 +1578,15 @@
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_expandEntityMenuItem);
 		waitASecond();
-		
+
 		newHeight = ((PictogramElement) jptType.part().getModel())
 				.getGraphicsAlgorithm().getHeight();
 		assertEquals("Entity must be expanded!", heigth, newHeight);
 		assertTrue(newHeight > JPAEditorConstants.ENTITY_MIN_HEIGHT);
 	}
 
-	public void collapseExpandAllJPTsViaMenu(SWTBotGefEditPart jptType1, SWTBotGefEditPart jptType2) {
+	public void collapseExpandAllJPTsViaMenu(SWTBotGefEditPart jptType1,
+			SWTBotGefEditPart jptType2) {
 
 		int heigth1 = ((PictogramElement) jptType1.part().getModel())
 				.getGraphicsAlgorithm().getHeight();
@@ -1418,7 +1597,7 @@
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_collapseAllEntitiesMenuItem);
 		waitASecond();
-		
+
 		// check that entity1 is collapsed
 		int newHeight1 = ((PictogramElement) jptType1.part().getModel())
 				.getGraphicsAlgorithm().getHeight();
@@ -1436,7 +1615,7 @@
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_expandAllEntitiesMenuItem);
 		waitASecond();
-		
+
 		// check that entity1 is expanded
 		newHeight1 = ((PictogramElement) jptType1.part().getModel())
 				.getGraphicsAlgorithm().getHeight();
@@ -1454,7 +1633,8 @@
 
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						jptType));
 		assertFalse(isJPTDirty(jptType));
 
@@ -1465,7 +1645,8 @@
 		jptType.click();
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_discardChangesMenuItem);
-		SWTBotGefEditPart attribute = jpaDiagramEditor.getEditPart(attributeName);
+		SWTBotGefEditPart attribute = jpaDiagramEditor
+				.getEditPart(attributeName);
 		assertNull("Changes must be discard!", attribute);
 		assertFalse(isJPTDirty(jptType));
 	}
@@ -1480,7 +1661,9 @@
 
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, jptType));
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+						jptType));
 		assertFalse(isJPTDirty(jptType));
 
 		addAttributeToJPT(jptType, attributeName);
@@ -1496,6 +1679,9 @@
 
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_showAllTheEntities);
+		
+		bot.waitUntil(new ElementAppearsInDiagram(jpaDiagramEditor), 20000);
+		
 		assertFalse("Diagram must contain at least one entity!",
 				jpaDiagramEditor.mainEditPart().children().isEmpty());
 
@@ -1506,7 +1692,8 @@
 		assertFalse(isJPTDirty(jptType));
 	}
 
-	public void removeAndSaveChangesViaMenu(SWTBotGefEditPart jptType, String attributeName) {
+	public void removeAndSaveChangesViaMenu(SWTBotGefEditPart jptType,
+			String attributeName) {
 
 		assertFalse("Diagram must contain at least one entity!",
 				jpaDiagramEditor.mainEditPart().children().isEmpty());
@@ -1515,7 +1702,9 @@
 
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, jptType));
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+						jptType));
 		assertFalse(isJPTDirty(jptType));
 
 		addAttributeToJPT(jptType, attributeName);
@@ -1531,6 +1720,9 @@
 
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_showAllTheEntities);
+		
+		bot.waitUntil(new ElementAppearsInDiagram(jpaDiagramEditor), 20000);
+		
 		assertFalse("Diagram must contain at least one entity!",
 				jpaDiagramEditor.mainEditPart().children().isEmpty());
 
@@ -1545,7 +1737,8 @@
 
 		assertFalse(
 				"\"Other Attributes\" section must not be visible!",
-				isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
+				isSectionVisible(
+						JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes,
 						jptType));
 		assertFalse(isJPTDirty(jptType));
 
@@ -1560,8 +1753,9 @@
 		assertFalse(isJPTDirty(jptType));
 	}
 
-	public void testUniDirRelation(String relationFeatureName, SWTBotGefEditPart owner,
-			SWTBotGefEditPart inverse, RelType reltype, String linkLabel) {
+	public void testUniDirRelation(String relationFeatureName,
+			SWTBotGefEditPart owner, SWTBotGefEditPart inverse,
+			RelType reltype, String linkLabel) {
 
 		jpaDiagramEditor.activateTool(relationFeatureName, 0);
 
@@ -1584,42 +1778,41 @@
 		String attributeName = testOwnerRelationAttributeProperties(rel);
 		assertNull(rel.getInverseAnnotatedAttribute());
 
-		assertAttributeIsCorretlyMapped(attributeName,
-				linkLabel);
+		assertAttributeIsCorretlyMapped(attributeName, linkLabel);
 
-		assertUniDirRelationIsNotDeleted(owner, inverse,
-				connection, attributeName);
+		assertUniDirRelationIsNotDeleted(owner, inverse, connection,
+				attributeName);
 
-		assertUniDirRelationIsDeleted(owner, inverse,
-				connection, attributeName);
+		assertUniDirRelationIsDeleted(owner, inverse, connection, attributeName);
 	}
-	
-	public void testSelfUniDirRelation(String relationFeatureName, SWTBotGefEditPart entity,
-			RelType reltype, String linkLabel){
-		
-		jpaDiagramEditor.activateTool(relationFeatureName, 0);		
+
+	public void testSelfUniDirRelation(String relationFeatureName,
+			SWTBotGefEditPart entity, RelType reltype, String linkLabel) {
+
+		jpaDiagramEditor.activateTool(relationFeatureName, 0);
 		jpaDiagramEditor.click(entity);
 		jpaDiagramEditor.click(entity);
 		bot.waitUntil(new ConnectionIsShown(entity));
-		
+
 		waitASecond();
 		jpaDiagramEditor.activateDefaultTool();
-		
+
 		assertSelfConnectionIsCreated(entity);
-		
-		SWTBotGefConnectionEditPart connection = entity.sourceConnections().get(0);
+
+		SWTBotGefConnectionEditPart connection = entity.sourceConnections()
+				.get(0);
 		IRelation rel = getConnection(connection);
 		assertNotNull(rel);
 		assertEquals(IRelation.RelDir.UNI, rel.getRelDir());
 		assertEquals(reltype, rel.getRelType());
-		
+
 		String attributeName = testOwnerRelationAttributeProperties(rel);
 		assertNull(rel.getInverseAnnotatedAttribute());
-		
+
 		assertAttributeIsCorretlyMapped(attributeName, linkLabel);
-		
+
 		assertSelfUniDirRelationIsNotDeleted(entity, connection, attributeName);
-		
+
 		assertSelfUniDirRelationIsDeleted(entity, connection, attributeName);
 	}
 
@@ -1661,19 +1854,21 @@
 		assertTrue(owner.sourceConnections().isEmpty());
 		assertTrue(inverse.targetConnections().isEmpty());
 		assertNull(jpaDiagramEditor.getEditPart(attributeName));
-		assertFalse(isSectionVisible(owner, JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
+		assertFalse(isSectionVisible(owner,
+				JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
-	public void testBiDirRel(String relationFeatureName, SWTBotGefEditPart owner,
-			SWTBotGefEditPart inverse, RelType reltype, String linkLabel) {
-		testBiDirRelWithTwoMappingTypes(relationFeatureName,
-				owner, inverse, reltype, linkLabel, linkLabel);
-	}
-	
-	public void testSelfBiDirRel(String relationFeatureName, SWTBotGefEditPart owner,
+	public void testBiDirRel(String relationFeatureName,
+			SWTBotGefEditPart owner, SWTBotGefEditPart inverse,
 			RelType reltype, String linkLabel) {
-		testSelfBiDirRelWithTwoMappings(relationFeatureName,
-				owner, reltype, linkLabel, linkLabel);
+		testBiDirRelWithTwoMappingTypes(relationFeatureName, owner, inverse,
+				reltype, linkLabel, linkLabel);
+	}
+
+	public void testSelfBiDirRel(String relationFeatureName,
+			SWTBotGefEditPart owner, RelType reltype, String linkLabel) {
+		testSelfBiDirRelWithTwoMappings(relationFeatureName, owner, reltype,
+				linkLabel, linkLabel);
 	}
 
 	public void testBiDirRelWithTwoMappingTypes(String relationFeatureName,
@@ -1704,56 +1899,60 @@
 		assertAttributeIsCorretlyMapped(ownerAttributeName, ownerLinkLabel);
 		assertAttributeIsCorretlyMapped(inverseAttributeName, inverseLinkLabel);
 
-		assertBiDirRelationIsNotDeleted(owner, inverse,
-				connection, ownerAttributeName, inverseAttributeName);
+		assertBiDirRelationIsNotDeleted(owner, inverse, connection,
+				ownerAttributeName, inverseAttributeName);
 
-		assertBiDirRelationIsDeleted(owner, inverse,
-				connection, ownerAttributeName, inverseAttributeName);
+		assertBiDirRelationIsDeleted(owner, inverse, connection,
+				ownerAttributeName, inverseAttributeName);
 	}
-	
+
 	public void testSelfBiDirRelWithTwoMappings(String relationFeatureName,
-			SWTBotGefEditPart entity, RelType reltype, String ownerLinkLabel, String inverseLinkLabel){
-		
-		jpaDiagramEditor.activateTool(relationFeatureName, 1);		
+			SWTBotGefEditPart entity, RelType reltype, String ownerLinkLabel,
+			String inverseLinkLabel) {
+
+		jpaDiagramEditor.activateTool(relationFeatureName, 1);
 		jpaDiagramEditor.click(entity);
-		jpaDiagramEditor.click(entity);		
+		jpaDiagramEditor.click(entity);
 		bot.waitUntil(new ConnectionIsShown(entity));
-		
+
 		waitASecond();
 		jpaDiagramEditor.activateDefaultTool();
-		
+
 		assertSelfConnectionIsCreated(entity);
-		
-		SWTBotGefConnectionEditPart connection = entity.sourceConnections().get(0);
+
+		SWTBotGefConnectionEditPart connection = entity.sourceConnections()
+				.get(0);
 		IRelation rel = getConnection(connection);
 		assertNotNull(rel);
 		assertEquals(IRelation.RelDir.BI, rel.getRelDir());
 		assertEquals(reltype, rel.getRelType());
-		
+
 		String ownerAttributeName = testOwnerRelationAttributeProperties(rel);
-		
+
 		String inverseAttributeName = testInverseRelationAttributeProperties(rel);
-		
+
 		assertAttributeIsCorretlyMapped(ownerAttributeName, ownerLinkLabel);
 		assertAttributeIsCorretlyMapped(inverseAttributeName, inverseLinkLabel);
-		
-		assertSelfBiDirRelationIsNotDeleted(entity, connection, ownerAttributeName,
-				inverseAttributeName);
-		
-		assertSelfBiDirRelationIsDeleted(entity, connection, ownerAttributeName, inverseAttributeName);
+
+		assertSelfBiDirRelationIsNotDeleted(entity, connection,
+				ownerAttributeName, inverseAttributeName);
+
+		assertSelfBiDirRelationIsDeleted(entity, connection,
+				ownerAttributeName, inverseAttributeName);
 	}
 
 	public void testBiDirRelRemoveInverseAttribute(String relationFeatureName,
 			SWTBotGefEditPart owner, SWTBotGefEditPart inverse,
 			RelType reltype, String linkLabel) {
 
-		testBiDirRelWithTwoMappingsWithoutInverseAttr(relationFeatureName, owner, inverse, reltype, linkLabel,
-				linkLabel);
+		testBiDirRelWithTwoMappingsWithoutInverseAttr(relationFeatureName,
+				owner, inverse, reltype, linkLabel, linkLabel);
 	}
 
-	public void testBiDirRelWithTwoMappingsWithoutInverseAttr(String relationFeatureName,
-			SWTBotGefEditPart owner, SWTBotGefEditPart inverse,
-			RelType reltype, String ownerLinkLabel, String inverseLinkLabel) {
+	public void testBiDirRelWithTwoMappingsWithoutInverseAttr(
+			String relationFeatureName, SWTBotGefEditPart owner,
+			SWTBotGefEditPart inverse, RelType reltype, String ownerLinkLabel,
+			String inverseLinkLabel) {
 
 		jpaDiagramEditor.activateTool(relationFeatureName, 1);
 		jpaDiagramEditor.click(owner);
@@ -1776,7 +1975,7 @@
 
 		String inverseAttributeName = testInverseRelationAttributeProperties(rel);
 
-		assertAttributeIsCorretlyMapped(ownerAttributeName,	ownerLinkLabel);
+		assertAttributeIsCorretlyMapped(ownerAttributeName, ownerLinkLabel);
 		assertAttributeIsCorretlyMapped(inverseAttributeName, inverseLinkLabel);
 
 		// delete the inverse attribute
@@ -1797,13 +1996,12 @@
 		assertEquals(ownerAttributeName,
 				testOwnerRelationAttributeProperties(rel));
 		assertNull(rel.getInverseAnnotatedAttribute());
-		assertAttributeIsCorretlyMapped(ownerAttributeName,
-				ownerLinkLabel);
+		assertAttributeIsCorretlyMapped(ownerAttributeName, ownerLinkLabel);
 
 		// delete the owner attribute
 		SWTBotGefEditPart ownerAttr = jpaDiagramEditor
 				.getEditPart(ownerAttributeName);
-		ownerAttr.click();
+		ownerAttr.select();
 		jpaDiagramEditor.clickContextMenu("Delete");
 		confirmDelete();
 		bot.waitUntil(new ElementDisappears(jpaDiagramEditor,
@@ -1819,16 +2017,17 @@
 				JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
-	public void testBiDirRelRemoveOwnerAttr(String relationFeatureName, SWTBotGefEditPart owner,
-			SWTBotGefEditPart inverse, RelType reltype, String linkLabel) {
-		testBiDirRelWithTwoMappingsWithoutOwnerAttr(
-				relationFeatureName, owner, inverse, reltype, linkLabel,
-				linkLabel);
+	public void testBiDirRelRemoveOwnerAttr(String relationFeatureName,
+			SWTBotGefEditPart owner, SWTBotGefEditPart inverse,
+			RelType reltype, String linkLabel) {
+		testBiDirRelWithTwoMappingsWithoutOwnerAttr(relationFeatureName, owner,
+				inverse, reltype, linkLabel, linkLabel);
 	}
 
-	public void testBiDirRelWithTwoMappingsWithoutOwnerAttr(String relationFeatureName,
-			SWTBotGefEditPart owner, SWTBotGefEditPart inverse,
-			RelType reltype, String ownerLinkLabel, String inverseLinkLabel) {
+	public void testBiDirRelWithTwoMappingsWithoutOwnerAttr(
+			String relationFeatureName, SWTBotGefEditPart owner,
+			SWTBotGefEditPart inverse, RelType reltype, String ownerLinkLabel,
+			String inverseLinkLabel) {
 
 		jpaDiagramEditor.activateTool(relationFeatureName, 1);
 		jpaDiagramEditor.click(owner);
@@ -1851,7 +2050,7 @@
 
 		String inverseAttributeName = testInverseRelationAttributeProperties(rel);
 
-		assertAttributeIsCorretlyMapped(ownerAttributeName,	ownerLinkLabel);
+		assertAttributeIsCorretlyMapped(ownerAttributeName, ownerLinkLabel);
 		assertAttributeIsCorretlyMapped(inverseAttributeName, inverseLinkLabel);
 
 		// delete the owner attribute
@@ -1875,10 +2074,12 @@
 				JPAEditorMessages.AddJPAEntityFeature_relationAttributesShapes));
 	}
 
-	public void createInheritedEntity(SWTBotGefEditPart superclass, String subclassName,
-			String superclassMappingLinkLabel, boolean byMappedSuperclass) {
+	public void createInheritedEntity(SWTBotGefEditPart superclass,
+			String subclassName, String superclassMappingLinkLabel,
+			boolean byMappedSuperclass) {
 
-		String superclassName = getJPTObjectForGefElement(superclass).getSimpleName();
+		String superclassName = getJPTObjectForGefElement(superclass)
+				.getSimpleName();
 
 		jpaDiagramEditor
 				.activateTool(JPAEditorMessages.CreateJPAEntityFromMappedSuperclassFeature_createInheritedEntityFeatureName);
@@ -1890,7 +2091,7 @@
 		SWTBotGefEditPart inheritedEntity = jpaDiagramEditor
 				.getEditPart(subclassName);
 		assertNotNull(inheritedEntity);
-		if(byMappedSuperclass){
+		if (byMappedSuperclass) {
 			assertTrue(isSectionVisible(inheritedEntity,
 					JPAEditorMessages.AddJPAEntityFeature_primaryKeysShape));
 		} else {
@@ -1914,17 +2115,19 @@
 		IsARelation rel = getIsARelationship();
 		assertNotNull(rel);
 
-		assertEquals(getJPTObjectForGefElement(inheritedEntity), rel.getSubclass());
-		assertEquals(getJPTObjectForGefElement(superclass),	rel.getSuperclass());
+		assertEquals(getJPTObjectForGefElement(inheritedEntity),
+				rel.getSubclass());
+		assertEquals(getJPTObjectForGefElement(superclass), rel.getSuperclass());
 
 		assertTypeIsCorretlyMapped(superclassName, superclassMappingLinkLabel);
-		assertTypeIsCorretlyMapped(subclassName, JptUiDetailsMessages.EntityUiProvider_linkLabel);
+		assertTypeIsCorretlyMapped(subclassName,
+				JptUiDetailsMessages.EntityUiProvider_linkLabel);
 	}
-	
+
 	public void testNoConnectionIsCreated(String relationFeatureName,
 			int indexInPallete, SWTBotGefEditPart owner,
 			SWTBotGefEditPart inverse) {
-		
+
 		jpaDiagramEditor.activateTool(relationFeatureName, indexInPallete);
 
 		jpaDiagramEditor.click(owner);
@@ -1932,18 +2135,18 @@
 
 		waitASecond();
 
-		assertTrue("There is no connection created.", owner
-				.sourceConnections().isEmpty());
+		assertTrue("There is no connection created.", owner.sourceConnections()
+				.isEmpty());
 		assertTrue("There is no connection created.", inverse
 				.sourceConnections().isEmpty());
 		assertTrue("There is no connection.", inverse.targetConnections()
 				.isEmpty());
 	}
-	
-	public void testNoConnectionIsCreatedWithEmbeddable(String relationFeatureName,
-			int indexInPallete, SWTBotGefEditPart owner,
-			SWTBotGefEditPart inverse) {
-		
+
+	public void testNoConnectionIsCreatedWithEmbeddable(
+			String relationFeatureName, int indexInPallete,
+			SWTBotGefEditPart owner, SWTBotGefEditPart inverse) {
+
 		jpaDiagramEditor.activateTool(relationFeatureName, indexInPallete);
 
 		jpaDiagramEditor.click(owner);
@@ -1951,16 +2154,16 @@
 
 		waitASecond();
 
-		assertTrue("There is no connection created.", owner
-				.sourceConnections().isEmpty());
+		assertTrue("There is no connection created.", owner.sourceConnections()
+				.isEmpty());
 		assertTrue("There is no connection created.", inverse
 				.sourceConnections().isEmpty());
 	}
-	
+
 	public void testNoEmbeddedConnectionIsCreated(String relationFeatureName,
 			int indexInPallete, SWTBotGefEditPart owner,
 			SWTBotGefEditPart inverse, boolean alreadyEmbed) {
-		
+
 		jpaDiagramEditor.activateTool(relationFeatureName, indexInPallete);
 
 		jpaDiagramEditor.click(owner);
@@ -1968,9 +2171,9 @@
 
 		waitASecond();
 
-		assertTrue("There is no connection created.", owner
-				.sourceConnections().isEmpty());
-		if(alreadyEmbed){
+		assertTrue("There is no connection created.", owner.sourceConnections()
+				.isEmpty());
+		if (alreadyEmbed) {
 			assertFalse("There is no connection created.", inverse
 					.sourceConnections().isEmpty());
 		} else {
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementAppearsInDiagram.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementAppearsInDiagram.java
new file mode 100644
index 0000000..572690e
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/ElementAppearsInDiagram.java
@@ -0,0 +1,23 @@
+package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
+
+import org.eclipse.swtbot.eclipse.gef.finder.widgets.SWTBotGefEditor;
+import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
+
+public class ElementAppearsInDiagram extends DefaultCondition{
+	
+	private SWTBotGefEditor gefEditor;
+	
+	public ElementAppearsInDiagram(SWTBotGefEditor gefEditor){
+		super();
+		this.gefEditor = gefEditor;
+	}
+
+	public boolean test() throws Exception {
+		return !(gefEditor.mainEditPart().children().isEmpty());
+	}
+
+	public String getFailureMessage() {
+		return "Diagram is still empty.";
+	}
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EmbeddableInDiagramSWTBotTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EmbeddableInDiagramSWTBotTest.java
index c0aeadd..5dea59e 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EmbeddableInDiagramSWTBotTest.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EmbeddableInDiagramSWTBotTest.java
@@ -1,10 +1,10 @@
 package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
 
+import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.ListIterator;
 
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.graphiti.features.IFeatureProvider;
@@ -12,7 +12,9 @@
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jpt.jpa.core.JpaProject;
 import org.eclipse.jpt.jpa.core.MappingKeys;
+import org.eclipse.jpt.jpa.core.context.PersistentType;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
 import org.eclipse.jpt.jpa.ui.internal.details.JptUiDetailsMessages;
 import org.eclipse.jpt.jpa.ui.internal.jpa2.details.JptUiDetailsMessages2_0;
@@ -22,6 +24,7 @@
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.HasReferanceRelation;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.HasReferanceRelation.HasReferenceType;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.IRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
 import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
 import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
 import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
@@ -35,8 +38,7 @@
 import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
-import org.eclipse.swtbot.swt.finder.widgets.TimeoutException;
-import org.junit.AfterClass;
+import org.junit.After;
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -94,6 +96,8 @@
 	public void testAddEmbeddable() {
 		Utils.sayTestStarted("testAddEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+		
 		editorProxy.addEmbeddableToDiagram(50, 50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
 
@@ -114,6 +118,8 @@
 	public void testRemoveEmnbeddableViaButton() {
 		Utils.sayTestStarted("testRemoveEmnbeddableViaButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+		
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -134,6 +140,8 @@
 	public void testRemoveEmbeddableViaContextMenu() {
 		Utils.sayTestStarted("testRemoveEmbeddableViaContextMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -154,6 +162,8 @@
 	public void testAddAttributeToEmbeddablle() {
 		Utils.sayTestStarted("testAddAttributeToEmbeddablle");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -174,6 +184,74 @@
 
 		Utils.sayTestFinished("testAddAttributeToEmbeddablle");
 	}
+	
+	@Test
+	public void testAddElementCollectionAttributeToEmbeddable(){
+		Utils.sayTestStarted("testAddElementCollectionAttributeToEmbeddable");
+
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+		SWTBotGefEditPart entity = editorProxy.addEmbeddableToDiagram(50, 50, "Embeddable1");
+
+		assertFalse(
+				"\"Other Attributes\" section must not be visible!",
+				editorProxy.isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, entity));
+
+		editorProxy.addElementCollectionAttributeToJPT(entity, "attribute1");
+		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+		entity.click();
+		editorProxy.deleteDiagramElements();
+		jpaDiagramEditor.save();
+
+		Utils.sayTestFinished("testAddElementCollectionAttributeToEmbeddable");
+	}
+	
+	
+	/**
+	 * Add two embeddables and one entity in the diagram. Add an attribute of collection type to
+	 * the first embeddable. Check that it is not possible to embed a collection of the first
+	 * embeddable neither into the second embeddable, nor into the entity, but it is possible to embed
+	 * a collection of the second embeddable to the first embeddable.
+	 */
+	
+	@Test
+	public void testEmbedCollectionOfObjectsWithCollectionAttribute() {
+		Utils.sayTestStarted("testEmbedCollectionOfObjectsWithCollectionAttribute");
+
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+		SWTBotGefEditPart embeddable1 = editorProxy.addEmbeddableToDiagram(50,
+				50, "Embeddable1");
+		SWTBotGefEditPart embeddable2 = editorProxy.addEmbeddableToDiagram(50,
+				200, "Embeddable2");
+		
+		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(200, 50, "Entity1");
+
+		assertFalse(
+				"\"Other Attributes\" section must not be visible!",
+				editorProxy.isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, embeddable1));
+
+		editorProxy.addElementCollectionAttributeToJPT(embeddable1, "attribute1");
+		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+		
+		editorProxy.testNoEmbeddedConnectionIsCreated(
+				JPAEditorMessages.EmbedCollectionOfObjectsFeature_ElementCollectionFeatureName, 0, entity, embeddable1, false);
+		
+		editorProxy.testNoEmbeddedConnectionIsCreated(
+				JPAEditorMessages.EmbedCollectionOfObjectsFeature_ElementCollectionFeatureName, 0, embeddable2, embeddable1, false);
+
+		_testEmbeddedConnection(JPAEditorMessages.EmbedCollectionOfObjectsFeature_ElementCollectionFeatureName, embeddable1,
+				embeddable2, HasReferenceType.COLLECTION,
+				MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY,
+				JptUiDetailsMessages2_0.ElementCollectionMapping2_0_linkLabel,
+				3);
+
+		editorProxy.deleteDiagramElements();
+		jpaDiagramEditor.save();
+
+		Utils.sayTestFinished("testEmbedCollectionOfObjectsWithCollectionAttribute");
+	}
 
 	/**
 	 * Removes the attribute using the "Delete Attribute" context button.
@@ -182,6 +260,8 @@
 	public void testRemoveAttributeFromEmbeddableViaContextButton() {
 		Utils.sayTestStarted("testRemoveAttributeFromEmbeddableViaContextButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -202,6 +282,8 @@
 	public void testRemoveAttributeFromEmbeddableViaMenu() {
 		Utils.sayTestStarted("testRemoveAttributeFromEmbeddableViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -222,6 +304,8 @@
 	public void testDirectEditingAttributeInEmbeddable() {
 		Utils.sayTestStarted("testDirectEditingAttributeInEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -244,6 +328,8 @@
 	public void testDirectEditingEmbeddable() {
 		Utils.sayTestStarted("testDirectEditingEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -278,6 +364,8 @@
 	public void testDoubleClickOnEmbeddable() {
 		Utils.sayTestStarted("testDoubleClickOnEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -304,6 +392,8 @@
 	public void testChangeAttributeTypeInEmbeddable() {
 		Utils.sayTestStarted("testChangeAttributeTypeInEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -383,6 +473,8 @@
 	public void testRenameEmbeddableViaMenu() {
 		Utils.sayTestStarted("testRenameEmbeddableViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -429,6 +521,8 @@
 	public void testMoveEmbeddableViaMenu() throws JavaModelException {
 		Utils.sayTestStarted("testMoveEmbeddableViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -472,6 +566,8 @@
 	public void testCollapseExapandEmbeddableViaContextButton() {
 		Utils.sayTestStarted("testCollapseExapandEmbeddableViaContextButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -493,6 +589,8 @@
 	public void testCollapseExapandEmbeddableViaMenu() {
 		Utils.sayTestStarted("testCollapseExapandEmbeddableViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -508,41 +606,17 @@
 	}
 
 	/**
-	 * Collapse/expand all embeddables using the context menus
-	 */
-	@Test
-	public void testCollapseExapandAllEmbeddablesViaMenu() {
-		Utils.sayTestStarted("testCollapseExapandAllEmbeddablesViaMenu");
-
-		SWTBotGefEditPart embeddable1 = editorProxy.addEmbeddableToDiagram(50,
-				50, "Embeddable1");
-		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
-
-		editorProxy.addAttributeToJPT(embeddable1, "attribute1");
-
-		SWTBotGefEditPart embeddable2 = editorProxy.addEmbeddableToDiagram(300,
-				50, "Embeddable2");
-		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
-
-		editorProxy.addAttributeToJPT(embeddable2, "attribute1");
-
-		editorProxy.collapseExpandAllJPTsViaMenu(embeddable1, embeddable2);
-
-		editorProxy.deleteDiagramElements();
-		jpaDiagramEditor.save();
-
-		Utils.sayTestFinished("testCollapseExapandAllEmbeddablesViaMenu");
-	}
-
-	/**
 	 * Add a new attribute without saving the embeddable and call the
 	 * "Discard Changes" context menu. Assert that the newly added attribute is
 	 * removed and the embeddable does not contain unsaved changes.
 	 */
+	@Ignore
 	@Test
 	public void testDiscardChangesFromEmbeddable() {
 		Utils.sayTestStarted("testDiscardChangesFromEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -567,6 +641,8 @@
 	public void testRemoveAndDiscardChangesFromEmbeddableViaMenu() {
 		Utils.sayTestStarted("testRemoveAndDiscardChangesFromEmbeddableViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -591,6 +667,8 @@
 	public void testRemoveAndSaveChangesToEmbeddableViaMenu() {
 		Utils.sayTestStarted("testRemoveAndSaveChangesToEmbeddableViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -613,6 +691,8 @@
 	public void testSaveOnlyEmbeddable() {
 		Utils.sayTestStarted("testSaveOnlyEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
@@ -634,6 +714,8 @@
 	public void testEmbedSingleObjectInEntity() {
 		Utils.sayTestStarted("testEmbedSingleObjectInEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -656,10 +738,13 @@
 	 * the embeddable into the entity and checks that the connection exists and
 	 * a new embedded attribute is added to the entity.
 	 */
+	@Ignore
 	@Test
 	public void testEmbedCollectionOfObjectsInEntity() {
 		Utils.sayTestStarted("testEmbedCollectionOfObjectsInEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -687,6 +772,8 @@
 	public void testEmbedSingleObjectInEmbeddable() {
 		Utils.sayTestStarted("testEmbedSingleObjectInEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable1 = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		SWTBotGefEditPart embeddable2 = editorProxy.addEmbeddableToDiagram(50,
@@ -709,10 +796,13 @@
 	 * embeddable into the second embeddable and checks that the connection
 	 * exists and a new embedded attribute is added to the second embeddable.
 	 */
+	
 	@Test
 	public void testEmbedCollectionOfObjectsInEmbeddable() {
 		Utils.sayTestStarted("testEmbedCollectionOfObjectsInEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable1 = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		SWTBotGefEditPart embeddable2 = editorProxy.addEmbeddableToDiagram(50,
@@ -737,10 +827,13 @@
 	 * embed a collection of the second embeddable into the entity, but it is
 	 * possible to embed a collection of the first embeddable to the entity.
 	 */
+	
 	@Test
 	public void testEmbedCollectionOfObjectsInEmbeddableAndEntity() {
 		Utils.sayTestStarted("testEmbedCollectionOfObjectsInEmbeddableAndEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart embeddable1 = editorProxy.addEmbeddableToDiagram(50,
 				50, "Embeddable1");
 		SWTBotGefEditPart embeddable2 = editorProxy.addEmbeddableToDiagram(50,
@@ -773,7 +866,53 @@
 
 		Utils.sayTestFinished("testEmbedCollectionOfObjectsInEmbeddableAndEntity");
 	}
+	
+	/**
+	 * Add three embeddables in the diagram. Embed a collection of
+	 * the first embeddable to the second one. Check that it is not possible to
+	 * embed a collection of the second embeddable into the third one, but it is
+	 * possible to embed a collection of the first embeddable to the third embeddable.
+	 */
+	
+	@Test
+	public void testEmbedCollectionOfObjectsInTwoEmbeddables() {
+		Utils.sayTestStarted("testEmbedCollectionOfObjectsInTwoEmbeddables");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+		SWTBotGefEditPart embeddable1 = editorProxy.addEmbeddableToDiagram(50,
+				50, "Embeddable1");
+		SWTBotGefEditPart embeddable2 = editorProxy.addEmbeddableToDiagram(50,
+				200, "Embeddable2");
+
+		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+		embedConnection(JPAEditorMessages.EmbedCollectionOfObjectsFeature_ElementCollectionFeatureName, embeddable1,
+				embeddable2, HasReferenceType.COLLECTION,
+				MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY,
+				JptUiDetailsMessages2_0.ElementCollectionMapping2_0_linkLabel,
+				2);
+
+		SWTBotGefEditPart embeddable3 = editorProxy.addEmbeddableToDiagram(200, 50,
+				"Embeddable3");
+
+		editorProxy.testNoEmbeddedConnectionIsCreated(
+				JPAEditorMessages.EmbedCollectionOfObjectsFeature_ElementCollectionFeatureName, 0, embeddable3, embeddable1, true);
+
+		_testEmbeddedConnection(JPAEditorMessages.EmbedCollectionOfObjectsFeature_ElementCollectionFeatureName, embeddable3,
+				embeddable2, HasReferenceType.COLLECTION,
+				MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY,
+				JptUiDetailsMessages2_0.ElementCollectionMapping2_0_linkLabel,
+				4);
+
+		editorProxy.deleteAttributeInJPT(embeddable1, "embeddable2");
+
+		editorProxy.deleteDiagramElements();
+		jpaDiagramEditor.save();
+
+		Utils.sayTestFinished("testEmbedCollectionOfObjectsInTwoEmbeddables");
+	}
+	
 	/**
 	 * Test no one-to-one unidirectional relationship from entity to embeddable
 	 * is created.
@@ -782,6 +921,8 @@
 	public void testOneToOneUniDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testOneToOneUniDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -806,6 +947,8 @@
 	public void testOneToOneBiDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testOneToOneBiDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -830,6 +973,8 @@
 	public void testOneToManyUniDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testOneToManyUniDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -854,6 +999,8 @@
 	public void testManyToOneUniDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testManyToOneUniDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -878,6 +1025,8 @@
 	public void testManyToOneBiDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testManyToOneBiDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -902,6 +1051,8 @@
 	public void testManyToManyUniDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testManyToManyUniDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -926,6 +1077,8 @@
 	public void testManyToManyBiDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testManyToManyBiDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -955,6 +1108,8 @@
 	public void testOneToOneBiDirRelationFromEmbeddableToEntity() {
 		Utils.sayTestStarted("testOneToOneBiDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1016,6 +1171,8 @@
 	public void testManyToOneBiDirRelationFromEmbeddableToEntity() {
 		Utils.sayTestStarted("testManyToOneBiDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1081,6 +1238,8 @@
 	public void testManyToManyBiDirRelationFromEmbeddableToEntity() {
 		Utils.sayTestStarted("testManyToManyBiDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1141,6 +1300,8 @@
 	public void testOneToOneUniDirRelationFromEmbeddableToEntity() {
 		Utils.sayTestStarted("testOneToOneUniDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1193,6 +1354,8 @@
 	public void testManyToOneUniDirRelationFromEmbeddableToEntity() {
 		Utils.sayTestStarted("testManyToOneUniDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1245,6 +1408,8 @@
 	public void testManyToManyUniDirRelationFromEmbeddableToEntity() {
 		Utils.sayTestStarted("testManyToManyUniDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1297,6 +1462,8 @@
 	public void testOneToOneBiDirRelationFromEmbeddedCollectionToEntity() {
 		Utils.sayTestStarted("testOneToOneBiDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1354,10 +1521,13 @@
 	 * Check that if the owner attribute will be deleted, the relationship will
 	 * disappear.
 	 */
+	
 	@Test
 	public void testManyToOneBiDirRelationFromEmbeddedCollectionToEntity() {
 		Utils.sayTestStarted("testManyToOneBiDirRelationFromEmbeddableToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1418,6 +1588,8 @@
 	public void testNoOneToOneBiDirConnectionIsCreatedInEmbeddableInTwoEntities() {
 		Utils.sayTestStarted("testNoOneToOneBiDirConnectionIsCreatedInEmbeddableInTwoEntities");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1474,6 +1646,8 @@
 	public void testNoManyToOneBiDirConnectionIsCreatedInEmbeddableInTwoEntities() {
 		Utils.sayTestStarted("testNoBiDirConnectionIsCreatedInEmbeddableInTwoEntities");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1530,6 +1704,8 @@
 	public void testNoManyToManyBiDirConnectionIsCreatedInEmbeddableInTwoEntities() {
 		Utils.sayTestStarted("testNoManyToManyBiDirConnectionIsCreatedInEmbeddableInTwoEntities");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1590,6 +1766,8 @@
 	public void testOneToOneUniDirRelationFromEmbeddedCollectionToEntity() {
 		Utils.sayTestStarted("testOneToOneUniDirRelationFromEmbeddedCollectionToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1643,6 +1821,8 @@
 	public void testManyToOneUniDirRelationFromEmbeddedCollectionToEntity() {
 		Utils.sayTestStarted("testManyToOneUniDirRelationFromEmbeddedCollectionToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1693,6 +1873,8 @@
 	public void testManyToManyRelationFromEmbeddedCollectionToEntity() {
 		Utils.sayTestStarted("testManyToManyRelationFromEmbeddedCollectionToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1741,6 +1923,8 @@
 	public void testOneToManyRelationFromEmbeddedCollectionToEntity() {
 		Utils.sayTestStarted("testOneToManyRelationFromEmbeddedCollectionToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart embeddable = editorProxy.addEmbeddableToDiagram(50,
@@ -1766,7 +1950,7 @@
 						0, embeddable, entity);
 
 		editorProxy.deleteDiagramElements();
-		jpaDiagramEditor.save();
+		jpaDiagramEditor.saveAndClose();
 
 		Utils.sayTestFinished("testOneToManyRelationFromEmbeddedCollectionToEntity");
 	}
@@ -1946,7 +2130,7 @@
 			HasReferenceType refType, String embeddedMappingKey,
 			String linkLabel) {
 		
-		bot.waitUntil(new ConnectionIsShown(embeddingEntity), 15000);
+		bot.waitUntil(new ConnectionIsShown(embeddingEntity), 30000);
 
 //		List<SWTBotGefEditPart> entitiesInDiagram = jpaDiagramEditor
 //				.mainEditPart().children();
@@ -1957,6 +2141,17 @@
 				.sourceConnections().isEmpty());
 		SWTBotGefConnectionEditPart connection = embeddingEntity
 				.sourceConnections().get(0);
+		
+		JavaPersistentType emb = editorProxy.getJPTObjectForGefElement(embeddable);
+		String embAttr = JPAEditorUtil.decapitalizeFirstLetter(emb.getSimpleName());
+		
+		List<SWTBotGefEditPart> editParts = new ArrayList<SWTBotGefEditPart>();
+		editParts.add(embeddingEntity);
+		SWTBotGefEditPart attribute = jpaDiagramEditor.getEditpart(
+				embAttr, editParts);
+		
+		assertNotNull("Embedded attribute must be added.", attribute);
+
 		HasReferanceRelation rel = editorProxy
 				.getHasReferenceConnection(connection);
 		assertNotNull(rel);
@@ -1980,13 +2175,19 @@
 		return attributeName;
 	}
 	
-	@AfterClass
-	public static void afterClass() throws CoreException{
-		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
-		for(IProject project : projects){
-			project.delete(true, true, new NullProgressMonitor());
-		}
+	@After
+	public void tearDown() throws Exception {
+		editorProxy.deleteDiagramElements();
+		Utils.printFormatted(">>>>>>>>>>>> elements are deleted from the diagram.");
 		
-		ResourcesPlugin.getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
+		ListIterator<PersistenceUnit> lit = jpaProject.getRootContextNode().getPersistenceXml().getRoot().getPersistenceUnits().iterator();		
+		PersistenceUnit pu = lit.next();
+		Iterator<PersistentType> persistentTypesIterator = (Iterator<PersistentType>) pu.getPersistentTypes().iterator();
+		while(persistentTypesIterator.hasNext()){
+			Utils.printFormatted(">>>>>>>>>>>>>> persistent type resource must be deleted.");
+			PersistentType type = persistentTypesIterator.next();
+			type.getResource().delete(true, new NullProgressMonitor());
+		}
 	}
 }
+
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EntitiesInDiagramSWTBotTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EntitiesInDiagramSWTBotTest.java
index 41cbb15..32be204 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EntitiesInDiagramSWTBotTest.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/EntitiesInDiagramSWTBotTest.java
@@ -1,17 +1,17 @@
 package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
 
+import java.util.Iterator;
 import java.util.List;
+import java.util.ListIterator;
 
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 import org.eclipse.graphiti.ui.internal.parts.DiagramEditPart;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jpt.jpa.core.JpaProject;
+import org.eclipse.jpt.jpa.core.context.PersistentType;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.jpa.ui.internal.details.JptUiDetailsMessages;
 import org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.JPACreateFactory;
 import org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.Utils;
@@ -32,7 +32,7 @@
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotStyledText;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
-import org.junit.AfterClass;
+import org.junit.After;
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -88,6 +88,8 @@
 	public void testAddEntity() {
 		Utils.sayTestStarted("testAddEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		editorProxy.addEntityToDiagram(50, 50, "Entity1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
 
@@ -108,6 +110,8 @@
 	public void testRemoveEntityViaButton() {
 		Utils.sayTestStarted("testRemoveEntityViaButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.deleteJPTViaButton(entity);
@@ -126,6 +130,8 @@
 	public void testRemoveEntityViaContextMenu() {
 		Utils.sayTestStarted("testRemoveEntityViaContextMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.deleteJPTViaMenu(entity);
@@ -142,7 +148,9 @@
 	 */
 	@Test
 	public void testAddAttribute() {
-		Utils.sayTestStarted("testRemoveEntityViaContextMenu");
+		Utils.sayTestStarted("testAddAttribute");
+
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
 
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
@@ -157,7 +165,29 @@
 		editorProxy.deleteDiagramElements();
 		jpaDiagramEditor.save();
 
-		Utils.sayTestFinished("testRemoveEntityViaContextMenu");
+		Utils.sayTestFinished("testAddAttribute");
+	}
+	
+	@Test
+	public void testAddElementCollectionAttribute(){
+		Utils.sayTestStarted("testAddElementCollectionAttribute");
+
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
+
+		assertFalse(
+				"\"Other Attributes\" section must not be visible!",
+				editorProxy.isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, entity));
+
+		editorProxy.addElementCollectionAttributeToJPT(entity, "attribute1");
+		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+		entity.click();
+		editorProxy.deleteDiagramElements();
+		jpaDiagramEditor.save();
+
+		Utils.sayTestFinished("testAddElementCollectionAttribute");
 	}
 
 	/**
@@ -167,6 +197,8 @@
 	public void testRemoveAttributeViaContextButton() {
 		Utils.sayTestStarted("testRemoveAttributeViaContextButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.removeAttributeViaButton(entity, "attribute1");
@@ -185,6 +217,8 @@
 	public void testRemoveAttributeViaMenu() {
 		Utils.sayTestStarted("testRemoveAttributeViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.removeAttributeViaMenu(entity, "attribute1");
@@ -203,6 +237,8 @@
 	public void testDirectEditingAttribute() {
 		Utils.sayTestStarted("testDirectEditingAttribute");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.directEditAttribute(entity, "attribute1");
@@ -223,6 +259,8 @@
 	public void testDirectEditingEntity() {
 		Utils.sayTestStarted("testDirectEditingEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
 
@@ -255,6 +293,8 @@
 	public void testDoubleClickOnEntity() {
 		Utils.sayTestStarted("testDoubleClickOnEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
 		editorProxy.moveMouse(100, 70);
@@ -279,6 +319,8 @@
 	public void testChangeAttributeType() {
 		Utils.sayTestStarted("testChangeAttributeType");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		assertFalse("\"Other Attributes\" section must not be visible!", 
@@ -349,6 +391,8 @@
 	public void testRenameEntityViaMenu() {
 		Utils.sayTestStarted("testRenameEntityViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		entity.click();
@@ -393,6 +437,8 @@
 	public void testMoveEntityViaMenu() throws JavaModelException {
 		Utils.sayTestStarted("testMoveEntityViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 		JpaArtifactFactory factory = JpaArtifactFactory.instance();
 
@@ -433,6 +479,8 @@
 	public void testCollapseExapandEntityViaContextButton() {
 		Utils.sayTestStarted("testCollapseExapandEntityViaContextButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.collapseExpandJPTViaButton(entity);
@@ -450,6 +498,8 @@
 	public void testCollapseExapandEntityViaMenu() {
 		Utils.sayTestStarted("testCollapseExapandEntityViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.collapseExpandJPTViaMenu(entity);
@@ -467,6 +517,8 @@
 	public void testCollapseExapandAllEntitiesViaMenu() {
 		Utils.sayTestStarted("testCollapseExapandAllEntitiesViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(300, 50, "Entity2");
 
@@ -487,6 +539,8 @@
 	public void testDiscardChanges() {
 		Utils.sayTestStarted("testDiscardChanges");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.discardChanges(entity, "attribute1");
@@ -508,6 +562,8 @@
 	public void testRemoveAndDiscardChangesViaMenu() {
 		Utils.sayTestStarted("testRemoveAndDiscardChangesViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.removeAndDiscardChangesViaMenu(entity,
@@ -531,6 +587,8 @@
 	public void testRemoveAndSaveChangesViaMenu() {
 		Utils.sayTestStarted("testRemoveAndSaveChangesViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.removeAndSaveChangesViaMenu(entity, "attribute1");
@@ -551,6 +609,8 @@
 	public void testSaveOnlyEntity() {
 		Utils.sayTestStarted("testSaveOnlyEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 		editorProxy.saveOnlyJPT(entity, "attribute1");
 
@@ -571,11 +631,15 @@
 	public void testShowAllEntities() throws Exception {
 		Utils.sayTestStarted("testShowAllEntities");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		factory.createEntity(jpaProject, "com.sap.test.Customer");
 		assertTrue(jpaDiagramEditor.mainEditPart().children().isEmpty());
 
 		jpaDiagramEditor
 				.clickContextMenu(JPAEditorMessages.JPAEditorToolBehaviorProvider_showAllTheEntities);
+		
+		bot.waitUntil(new ElementAppearsInDiagram(jpaDiagramEditor), 20000);
 
 		List<SWTBotGefEditPart> entities = jpaDiagramEditor.mainEditPart()
 				.children();
@@ -599,6 +663,8 @@
 	public void testCollapseExpandCompartmentByDoubleClick() {
 		Utils.sayTestStarted("testCollapseExpandCompartmentByDoubleClick");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.moveMouse(100, 100);
@@ -643,6 +709,8 @@
 	public void testCollapseExpandCompartmentByContextMenu() {
 		Utils.sayTestStarted("testCollapseExpandCompartmentByContextMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// editorProxy.moveMouse(jpaDiagramEditor, 100, 100);
@@ -699,6 +767,8 @@
 	public void testChangeEntityMappingTypeViaJPADetailsView() {
 		Utils.sayTestStarted("testChangeEntityMappingTypeViaJPADetailsView");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		workbenchBot.viewByTitle("JPA Details").close();
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
@@ -799,6 +869,8 @@
 	public void testChangeAttributeMappingTypeViaJPADetailsView() {
 		Utils.sayTestStarted("testChangeAttributeMappingTypeViaJPADetailsView");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		workbenchBot.viewByTitle("JPA Details").close();
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
@@ -933,8 +1005,10 @@
 	public void testOneToOneUniDirRelationship() {
 		Utils.sayTestStarted("testOneToOneUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+		
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
-		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(50, 200, "Entity2");
+		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(200, 50, "Entity2");
 
 		// create One-to-One unidirectional relation from entity1 to entity2
 		editorProxy.testUniDirRelation(JPAEditorMessages.CreateOneToOneUniDirRelationFeature_oneToOneUniDirFeatureName,
@@ -963,6 +1037,8 @@
 	public void testSelfOneToOneUniDirRelationship() {
 		Utils.sayTestStarted("testSelfOneToOneUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// create One-to-One unidirectional self relation from entity1 to
@@ -992,8 +1068,10 @@
 	public void testOneToOneBiDirRelationship() {
 		Utils.sayTestStarted("testOneToOneBiDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
-		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(50, 200, "Entity2");
+		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(200, 50, "Entity2");
 
 		// create One-to-One bidirectional relation from entity1 to entity2
 		editorProxy.testBiDirRel(
@@ -1029,6 +1107,8 @@
 	public void testSelfOneToOneBiDirRelationship() {
 		Utils.sayTestStarted("testSelfOneToOneBiDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// create One-to-One bidirectional self relation from entity1 to entity1
@@ -1055,8 +1135,10 @@
 	public void testOneToManyUniDirRelationship() {
 		Utils.sayTestStarted("testOneToManyUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
-		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(50, 200, "Entity2");
+		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(200, 50, "Entity2");
 
 		// create One-to-Many unidirectional relation from entity1 to entity2
 		editorProxy.testUniDirRelation(
@@ -1086,6 +1168,8 @@
 	public void testSelfOneToManyUniDirRelationship() {
 		Utils.sayTestStarted("testSelfOneToManyUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// create One-to-Many unidirectional self relation from entity1 to
@@ -1114,8 +1198,10 @@
 	public void testManyToOneUniDirRelationship() {
 		Utils.sayTestStarted("testManyToOneUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
-		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(50, 200, "Entity2");
+		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(200, 50, "Entity2");
 
 		// create Many-to-One unidirectional relation from entity1 to entity2
 		editorProxy.testUniDirRelation(
@@ -1145,6 +1231,8 @@
 	public void testSelfManyToOneUniDirRelationship() {
 		Utils.sayTestStarted("testSelfManyToOneUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// create Many-to-One unidirectional self relation from entity1 to
@@ -1174,8 +1262,10 @@
 	public void testManyToOneBiDirRelationship() {
 		Utils.sayTestStarted("testManyToOneBiDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
-		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(50, 200, "Entity2");
+		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(200, 50, "Entity2");
 
 		// create Many-to-One bidirectional relation from entity1 to entity2
 		editorProxy.testBiDirRelWithTwoMappingTypes(
@@ -1214,6 +1304,8 @@
 	public void testSelfManyToOneBiDirRelationship() {
 		Utils.sayTestStarted("testSelfManyToOneBiDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// create Many-to-Many bidirectional self relation from entity1 to
@@ -1241,8 +1333,10 @@
 	public void testManyToManyUniDirRelationship() {
 		Utils.sayTestStarted("testManyToManyUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
-		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(50, 200, "Entity2");
+		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(200, 50, "Entity2");
 
 		// create Many-to-Many unidirectional relation from entity1 to entity2
 		editorProxy.testUniDirRelation(
@@ -1272,6 +1366,8 @@
 	public void testSelfManyToManyUniDirRelationship() {
 		Utils.sayTestStarted("testSelfManyToManyUniDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// create Many-to-Many unidirectional self relation from entity1 to
@@ -1301,8 +1397,10 @@
 	public void testManyToManyBiDirRelationship() {
 		Utils.sayTestStarted("testManyToManyBiDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
-		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(50, 200, "Entity2");
+		SWTBotGefEditPart entity2 = editorProxy.addEntityToDiagram(200, 50, "Entity2");
 
 		// create Many-to-Many bidirectional relation from entity1 to entity2
 		editorProxy.testBiDirRel(
@@ -1338,6 +1436,8 @@
 	public void testSelfManyToManyBiDirRelationship() {
 		Utils.sayTestStarted("testSelfManyToManyBiDirRelationship");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		// create Many-to-Many bidirectional self relation from entity1 to
@@ -1362,6 +1462,8 @@
 	public void testInheritedEntityByEntity() {
 		Utils.sayTestFinished("testInheritedEntityByEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity1 = editorProxy.addEntityToDiagram(50, 50, "Entity1");
 
 		editorProxy.createInheritedEntity(entity1, "Entity2",
@@ -1382,6 +1484,8 @@
 	public void testOpenDiagramOnProjectLevel() {
 		Utils.sayTestStarted("testOpenDiagramOnProjectLevel");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		workbenchBot.closeAllEditors();
 		// open JPA diagram editor on project level: JPA Tools -> Open Diagram
 		SWTBotGefEditor diagramEditor = editorProxy
@@ -1399,6 +1503,8 @@
 	public void testOpenDiagramOnJPAContentNodeLevel() {
 		Utils.sayTestStarted("testOpenDiagramOnJPAContentNodeLevel");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		workbenchBot.closeAllEditors();
 		// open JPA diagram editor on JPA content level: Open Diagram
 		SWTBotGefEditor diagramEditor = editorProxy
@@ -1407,14 +1513,19 @@
 
 		Utils.sayTestFinished("testOpenDiagramOnJPAContentNodeLevel");
 	}
-	
-	@AfterClass
-	public static void afterClass() throws CoreException{
-		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
-		for(IProject project : projects){
-			project.delete(true, true, new NullProgressMonitor());
-		}
+
+	@After
+	public void tearDown() throws Exception {
+		editorProxy.deleteDiagramElements();
+		Utils.printFormatted(">>>>>>>>>>>> elements are deleted from the diagram.");
 		
-		ResourcesPlugin.getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
+		ListIterator<PersistenceUnit> lit = jpaProject.getRootContextNode().getPersistenceXml().getRoot().getPersistenceUnits().iterator();		
+		PersistenceUnit pu = lit.next();
+		Iterator<PersistentType> persistentTypesIterator = (Iterator<PersistentType>) pu.getPersistentTypes().iterator();
+		while(persistentTypesIterator.hasNext()){
+			Utils.printFormatted(">>>>>>>>>>>>>> persistent type resource must be deleted.");
+			PersistentType type = persistentTypesIterator.next();
+			type.getResource().delete(true, new NullProgressMonitor());
+		}
 	}
 }
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/MappedSuperclassesInDiagramSWTBotTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/MappedSuperclassesInDiagramSWTBotTest.java
index b716322..f57cb92 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/MappedSuperclassesInDiagramSWTBotTest.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.swtbot.tests/src/org/eclipse/jpt/jpadiagrameditor/swtbot/tests/ui/editor/MappedSuperclassesInDiagramSWTBotTest.java
@@ -1,14 +1,15 @@
 package org.eclipse.jpt.jpadiagrameditor.swtbot.tests.ui.editor;
 
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.CoreException;
+import java.util.Iterator;
+import java.util.ListIterator;
+
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.ui.internal.parts.DiagramEditPart;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jpt.jpa.core.JpaProject;
+import org.eclipse.jpt.jpa.core.context.PersistentType;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.jpa.ui.internal.details.JptUiDetailsMessages;
 import org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.JPACreateFactory;
 import org.eclipse.jpt.jpadiagrameditor.swtbot.tests.internal.Utils;
@@ -25,7 +26,7 @@
 import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
 import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
-import org.junit.AfterClass;
+import org.junit.After;
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -82,6 +83,8 @@
 	public void testAddMappedSuperclass() {
 		Utils.sayTestStarted("testAddMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
 
@@ -102,6 +105,8 @@
 	public void testRemoveEntityViaButton() {
 		Utils.sayTestStarted("testRemoveEntityViaButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.deleteJPTViaButton(mappedSuperclass);
@@ -120,6 +125,8 @@
 	public void testRemoveEntityViaContextMenu() {
 		Utils.sayTestStarted("testRemoveEntityViaContextMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.deleteJPTViaMenu(mappedSuperclass);
@@ -136,7 +143,9 @@
 	 */
 	@Test
 	public void testAddAttribute() {
-		Utils.sayTestStarted("testRemoveEntityViaContextMenu");
+		Utils.sayTestStarted("testAddAttribute");
+
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
 
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
@@ -151,7 +160,29 @@
 		editorProxy.deleteDiagramElements();
 		jpaDiagramEditor.save();
 
-		Utils.sayTestFinished("testRemoveEntityViaContextMenu");
+		Utils.sayTestFinished("testAddAttribute");
+	}
+	
+	@Test
+	public void testAddElementCollectionAttributeToMappedSuperclass(){
+		Utils.sayTestStarted("testAddElementCollectionAttributeToMappedSuperclass");
+
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+		SWTBotGefEditPart entity = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
+
+		assertFalse(
+				"\"Other Attributes\" section must not be visible!",
+				editorProxy.isSectionVisible(JPAEditorMessages.AddJPAEntityFeature_basicAttributesShapes, entity));
+
+		editorProxy.addElementCollectionAttributeToJPT(entity, "attribute1");
+		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
+
+		entity.click();
+		editorProxy.deleteDiagramElements();
+		jpaDiagramEditor.save();
+
+		Utils.sayTestFinished("testAddElementCollectionAttributeToMappedSuperclass");
 	}
 
 	/**
@@ -161,6 +192,8 @@
 	public void testRemoveAttributeViaContextButton() {
 		Utils.sayTestStarted("testRemoveAttributeViaContextButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.removeAttributeViaButton(mappedSuperclass, "attribute1");
@@ -179,6 +212,8 @@
 	public void testRemoveAttributeViaMenu() {
 		Utils.sayTestStarted("testRemoveAttributeViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.removeAttributeViaMenu(mappedSuperclass, "attribute1");
@@ -197,6 +232,8 @@
 	public void testDirectEditingAttribute() {
 		Utils.sayTestStarted("testDirectEditingAttribute");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.directEditAttribute(mappedSuperclass, "attribute1");
@@ -217,6 +254,8 @@
 	public void testDirectEditingEntity() {
 		Utils.sayTestStarted("testDirectEditingEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
 
@@ -249,6 +288,8 @@
 	public void testDoubleClickOnEntity() {
 		Utils.sayTestStarted("testDoubleClickOnEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		assertTrue("Editor must be dirty", jpaDiagramEditor.isDirty());
 		editorProxy.moveMouse(100, 70);
@@ -273,6 +314,8 @@
 	public void testChangeAttributeType() {
 		Utils.sayTestStarted("testChangeAttributeType");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		assertFalse("\"Other Attributes\" section must not be visible!", 
@@ -343,6 +386,8 @@
 	public void testRenameEntityViaMenu() {
 		Utils.sayTestStarted("testRenameEntityViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		mappedSuperclass.click();
@@ -387,6 +432,8 @@
 	public void testMoveEntityViaMenu() throws JavaModelException {
 		Utils.sayTestStarted("testMoveEntityViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		JpaArtifactFactory factory = JpaArtifactFactory.instance();
 
@@ -427,6 +474,8 @@
 	public void testCollapseExapandEntityViaContextButton() {
 		Utils.sayTestStarted("testCollapseExapandEntityViaContextButton");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.addAttributeToJPT(mappedSuperclass, "attribute1");
@@ -446,6 +495,8 @@
 	public void testCollapseExapandEntityViaMenu() {
 		Utils.sayTestStarted("testCollapseExapandEntityViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.addAttributeToJPT(mappedSuperclass, "attribute1");
@@ -459,29 +510,6 @@
 	}
 
 	/**
-	 * Collapse/expand all mapped superclasses using the context menus
-	 */
-	@Test
-	public void testCollapseExapandAllEntitiesViaMenu() {
-		Utils.sayTestStarted("testCollapseExapandAllEntitiesViaMenu");
-
-		SWTBotGefEditPart mappedSuperclass1 = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
-		
-		editorProxy.addAttributeToJPT(mappedSuperclass1, "attribute1");
-		
-		SWTBotGefEditPart mappedSuperclass2 = editorProxy.addMappedSuperclassToDiagram(300, 50, "MpdSuprcls2");
-		
-		editorProxy.addAttributeToJPT(mappedSuperclass2, "attribute1");
-
-		editorProxy.collapseExpandAllJPTsViaMenu(mappedSuperclass1, mappedSuperclass2);
-
-		editorProxy.deleteDiagramElements();
-		jpaDiagramEditor.save();
-
-		Utils.sayTestFinished("testCollapseExapandAllEntitiesViaMenu");
-	}
-
-	/**
 	 * Add a new attribute without saving the mapped superclass and call the
 	 * "Discard Changes" context menu. Assert that the newly added attribute is
 	 * removed and the mapped superclass does not contain unsaved changes.
@@ -490,7 +518,9 @@
 	public void testDiscardChanges() {
 		Utils.sayTestStarted("testDiscardChanges");
 
-		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
+		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(200, 50, "MpdSuprcls1");
 
 		editorProxy.discardChanges(mappedSuperclass, "attribute1");
 
@@ -511,6 +541,8 @@
 	public void testRemoveAndDiscardChangesViaMenu() {
 		Utils.sayTestStarted("testRemoveAndDiscardChangesViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.removeAndDiscardChangesViaMenu(mappedSuperclass, "attribute1");
@@ -533,6 +565,8 @@
 	public void testRemoveAndSaveChangesViaMenu() {
 		Utils.sayTestStarted("testRemoveAndSaveChangesViaMenu");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
 		editorProxy.removeAndSaveChangesViaMenu(mappedSuperclass, "attribute1");
@@ -553,6 +587,8 @@
 	public void testSaveOnlyEntity() {
 		Utils.sayTestStarted("testSaveOnlyEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		editorProxy.saveOnlyJPT(mappedSuperclass, "attribute1");
 
@@ -570,6 +606,8 @@
 	public void testInheritedEntityByMappedSuperclass() {
 		Utils.sayTestStarted("testInheritedEntityByMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy
 				.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 
@@ -591,6 +629,8 @@
 	public void testOneToOneUniDirRelFromMappedSuperclass() {
 		Utils.sayTestStarted("testOneToOneUniDirRelFromMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1");
 
@@ -615,6 +655,8 @@
 	public void testOneToManyUniDirRelFromMappedSuperclass() {
 		Utils.sayTestStarted("testOneToManyUniDirRelFromMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1");
 
@@ -639,6 +681,8 @@
 	public void testManyToOneUniDirRelFromMappedSuperclass() {
 		Utils.sayTestStarted("testManyToOneUniDirRelFromMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1");
 
@@ -663,6 +707,8 @@
 	public void testManyToManyUniDirRelFromMappedSuperclass() {
 		Utils.sayTestStarted("testManyToManyUniDirRelFromMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50, 50, "MpdSuprcls1");
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200, "Entity1");
 
@@ -687,6 +733,8 @@
 	public void testOneToOneRelationFromEntityToMappedSuperclass() {
 		Utils.sayTestStarted("testOneToOneRelationFromEntityToMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50,
@@ -716,6 +764,8 @@
 	public void testOneToOneBiDirRelationFromMappedSuperclassToEntity() {
 		Utils.sayTestStarted("testOneToOneBiDirRelationFromMappedSuperclassToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50,
@@ -740,6 +790,8 @@
 	public void testOneToManyUniDirRelationFromEntityToMappedSuperclass() {
 		Utils.sayTestStarted("testOneToManyUniDirRelationFromEntityToMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50,
@@ -764,6 +816,8 @@
 	public void testManyToOneRelationFromEntityToMappedSuperclass() {
 		Utils.sayTestStarted("testManyToOneRelationFromEntityToMappedSuperclass");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50,
@@ -793,6 +847,8 @@
 	public void testManyToOneBiDirRelationFromMappedSuperclassToEntity() {
 		Utils.sayTestStarted("testManyToOneBiDirRelationFromMappedSuperclassToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50,
@@ -817,6 +873,8 @@
 	public void testManyToManyUniDirRelationFromEntityToEmbeddable() {
 		Utils.sayTestStarted("testManyToManyUniDirRelationFromEntityToEmbeddable");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50,
@@ -846,6 +904,8 @@
 	public void testManyToManyBiDirRelationFromMappedSuperclassToEntity() {
 		Utils.sayTestStarted("testManyToManyBiDirRelationFromMappedSuperclassToEntity");
 
+		assertTrue("The diagram must be empty.", jpaDiagramEditor.mainEditPart().children().isEmpty());
+
 		SWTBotGefEditPart entity = editorProxy.addEntityToDiagram(50, 200,
 				"Entity1");
 		SWTBotGefEditPart mappedSuperclass = editorProxy.addMappedSuperclassToDiagram(50,
@@ -857,18 +917,24 @@
 						1, mappedSuperclass, entity);
 
 		editorProxy.deleteDiagramElements();
-		jpaDiagramEditor.save();
+		jpaDiagramEditor.saveAndClose();
 
 		Utils.sayTestFinished("testManyToManyBiDirRelationFromMappedSuperclassToEntity");
 	}
-
-	@AfterClass
-	public static void afterClass() throws CoreException{
-		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
-		for(IProject project : projects){
-			project.delete(true, true, new NullProgressMonitor());
-		}
+	
+	@After
+	public void tearDown() throws Exception {
+		editorProxy.deleteDiagramElements();
+		Utils.printFormatted(">>>>>>>>>>>> elements are deleted from the diagram.");
 		
-		ResourcesPlugin.getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
+		ListIterator<PersistenceUnit> lit = jpaProject.getRootContextNode().getPersistenceXml().getRoot().getPersistenceUnits().iterator();		
+		PersistenceUnit pu = lit.next();
+		Iterator<PersistentType> persistentTypesIterator = (Iterator<PersistentType>) pu.getPersistentTypes().iterator();
+		while(persistentTypesIterator.hasNext()){
+			Utils.printFormatted(">>>>>>>>>>>>>> persistent type resource must be deleted.");
+
+			PersistentType type = persistentTypesIterator.next();
+			type.getResource().delete(true, new NullProgressMonitor());
+		}
 	}
 }
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 fe4e987..761e664 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
@@ -22,6 +22,7 @@
 import java.util.HashSet;
 import java.util.Set;
 import java.util.StringTokenizer;
+
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
@@ -589,7 +590,7 @@
 		if (javaPersistentType == null)
 			throw new RuntimeException("The entity could not be created");
 		ICompilationUnit compilationUnit = JavaCore.createCompilationUnitFrom(entity);
-		JpaArtifactFactory.instance().addNewAttribute(javaPersistentType, compilationUnit, attName, attType, annotation, attActName, isCollection, null);
+		JpaArtifactFactory.instance().makeNewAttribute(null, javaPersistentType, compilationUnit, attName, attType, attActName, attType, null, null, isCollection);
 	}
 	
 	private IFile createFieldAnnotatedEntity(IFolder folder, String packageName, String entityName) throws IOException, CoreException {
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/CreateDeleteOnlyAttributeTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/CreateDeleteOnlyAttributeTest.java
index 9d6264b..a9e61bb 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/CreateDeleteOnlyAttributeTest.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/CreateDeleteOnlyAttributeTest.java
@@ -96,7 +96,7 @@
 		jpt.removeListChangeListener(JavaPersistentType.ATTRIBUTES_LIST, lsnr);
 		lsnr = new EntityAttributesChangeTestListener(2, 0);
 		jpt.addListChangeListener(JavaPersistentType.ATTRIBUTES_LIST, lsnr);
-		JpaArtifactFactory.instance().makeNewAttribute(featureProvider, jpt, featureProvider.getCompilationUnit(jpt), "aaa", "java.lang.String", null, "aaa", null, false, true);
+		JpaArtifactFactory.instance().makeNewAttribute(featureProvider, jpt, null, "aaa", "java.lang.String", "aaa", "java.lang.String", null, null, false);
 		assertFalse(lsnr.waitForEvents());
 		assertEquals(1, lsnr.incrementCounter);
 		assertEquals(0, lsnr.decrementCounter);		
@@ -113,7 +113,7 @@
 		jpt.removeListChangeListener(JavaPersistentType.ATTRIBUTES_LIST, lsnr);
 		lsnr = new EntityAttributesChangeTestListener(2, 0);
 		jpt.addListChangeListener(JavaPersistentType.ATTRIBUTES_LIST, lsnr);
-		JpaArtifactFactory.instance().makeNewAttribute(featureProvider, jpt, featureProvider.getCompilationUnit(jpt), "aaa", "java.lang.String", null, "aaa", null, false, false);
+		JpaArtifactFactory.instance().makeNewAttribute(featureProvider, jpt, null, "aaa", "java.lang.String", "aaa", "java.lang.String", null, null, false);
 		assertFalse(lsnr.waitForEvents());
 		assertEquals(1, lsnr.incrementCounter);
 		assertEquals(0, lsnr.decrementCounter);		
@@ -136,7 +136,7 @@
 		EntityAttributesChangeTestListener lsnr = new EntityAttributesChangeTestListener(1, 1);
 		jpt.addListChangeListener(JavaPersistentType.ATTRIBUTES_LIST, lsnr);
 		deleteAttribute("id");
-		JpaArtifactFactory.instance().makeNewAttribute(featureProvider, jpt, featureProvider.getCompilationUnit(jpt), "aaa", "java.lang.String", null, "aaa", null, false, false);
+		JpaArtifactFactory.instance().makeNewAttribute(featureProvider, jpt, null, "aaa", "java.lang.String", "aaa", "java.lang.String", null, null, false);
 		assertTrue(lsnr.waitForEvents());
 		jpt.removeListChangeListener(JavaPersistentType.ATTRIBUTES_LIST, lsnr);
 		lsnr = new EntityAttributesChangeTestListener(0, 2);
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationAttributesTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationAttributesTest.java
index ab2c58b..78b8f2c 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationAttributesTest.java
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationAttributesTest.java
@@ -108,8 +108,7 @@
  
 		JavaPersistentAttribute attr = JpaArtifactFactory.instance().
 				addAttribute(featureProvider, (JavaPersistentType)t1, (JavaPersistentType)t2, null, "add", "add", false, 
-						createCompilationUnitFrom(customerFile),
-						createCompilationUnitFrom(addressFile));
+						createCompilationUnitFrom(customerFile));
 		jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
 		PersistenceUnit pu = jpaProject.getRootContextNode().getPersistenceXml().getRoot().getPersistenceUnits().iterator().next();
 		t1 = pu.getPersistentType("abc.Customer");
@@ -151,8 +150,7 @@
  
 		JavaPersistentAttribute attr = JpaArtifactFactory.instance().
 			addAttribute(featureProvider, (JavaPersistentType)t1, (JavaPersistentType)t2, null, "address", "address", false, 						
-					createCompilationUnitFrom((IFile)t1.getResource()),
-					createCompilationUnitFrom((IFile)t2.getResource()));		
+					createCompilationUnitFrom((IFile)t1.getResource()));		
 		assertNotNull(attr);
 			
 		JpaArtifactFactory.instance().addOneToOneUnidirectionalRelation(featureProvider, (JavaPersistentType)t1, attr);
@@ -202,14 +200,12 @@
  
 		JavaPersistentAttribute attr = JpaArtifactFactory.instance().
 			addAttribute( featureProvider, (JavaPersistentType)t1, (JavaPersistentType)t2, null, "creditCard", "creditCard", false,
-					createCompilationUnitFrom((IFile)t1.getResource()),
-					createCompilationUnitFrom((IFile)t2.getResource()));		
+					createCompilationUnitFrom((IFile)t1.getResource()));		
 		assertNotNull(attr);
 
 		JavaPersistentAttribute attr2 = JpaArtifactFactory.instance().
 			addAttribute(featureProvider, (JavaPersistentType)t2, (JavaPersistentType)t1, null, "customer", "customer", false, 
-					createCompilationUnitFrom((IFile)t2.getResource()),
-					createCompilationUnitFrom((IFile)t1.getResource()));		
+					createCompilationUnitFrom((IFile)t2.getResource()));		
 		assertNotNull(attr2);
 		
 		JpaArtifactFactory.instance().addOneToOneBidirectionalRelation(featureProvider, (JavaPersistentType)t1, attr, (JavaPersistentType)t2, attr2);
@@ -278,8 +274,7 @@
 		}
  
 		JavaPersistentAttribute attr = JpaArtifactFactory.instance().addAttribute(featureProvider, (JavaPersistentType)t1, (JavaPersistentType)t2, null, "phones", "phones", true, 
-				createCompilationUnitFrom((IFile)t1.getResource()),
-				createCompilationUnitFrom((IFile)t2.getResource()));		
+				createCompilationUnitFrom((IFile)t1.getResource()));		
 		assertNotNull(attr);
 			
 		JpaArtifactFactory.instance().addOneToManyUnidirectionalRelation(featureProvider, (JavaPersistentType)t1, attr, false);
@@ -333,14 +328,12 @@
  
 		JavaPersistentAttribute singleSideAttribute = JpaArtifactFactory.instance().
 			addAttribute(featureProvider, (JavaPersistentType)singleSidePersistentType, (JavaPersistentType)manySidePersistentType, null, "reservations", "reservations", true, 
-				createCompilationUnitFrom((IFile)singleSidePersistentType.getResource()),
-				createCompilationUnitFrom((IFile)manySidePersistentType.getResource()));		
+				createCompilationUnitFrom((IFile)singleSidePersistentType.getResource()));		
 		assertNotNull(singleSideAttribute);
 
 		JavaPersistentAttribute manySideAttribute = JpaArtifactFactory.instance().
 			addAttribute(featureProvider, (JavaPersistentType)manySidePersistentType, (JavaPersistentType)singleSidePersistentType, null, "cruise", "cruise", false, 
-				createCompilationUnitFrom((IFile)manySidePersistentType.getResource()),
-				createCompilationUnitFrom((IFile)singleSidePersistentType.getResource()));		
+				createCompilationUnitFrom((IFile)manySidePersistentType.getResource()));		
 		assertNotNull(manySideAttribute);
 		
 		JpaArtifactFactory.instance().addOneToManyBidirectionalRelation(featureProvider, (JavaPersistentType)singleSidePersistentType, singleSideAttribute, (JavaPersistentType)manySidePersistentType, manySideAttribute, false);
@@ -428,8 +421,7 @@
  
 		JavaPersistentAttribute mappedAttribute = JpaArtifactFactory.instance().
 			addAttribute(featureProvider, (JavaPersistentType)manySidePersistentType, (JavaPersistentType)singleSidePersistentType, null, "ship", "ship", true, 
-					createCompilationUnitFrom((IFile)manySidePersistentType.getResource()),
-					createCompilationUnitFrom((IFile)singleSidePersistentType.getResource()));		
+					createCompilationUnitFrom((IFile)manySidePersistentType.getResource()));		
 		assertNotNull(mappedAttribute);
 			
 		JpaArtifactFactory.instance().addManyToOneUnidirectionalRelation(featureProvider, (JavaPersistentType)manySidePersistentType, mappedAttribute);
@@ -494,13 +486,11 @@
  
 		JavaPersistentAttribute ownerSideAttribute = JpaArtifactFactory.instance().
 			addAttribute(featureProvider, (JavaPersistentType)ownerSidePersistentType, (JavaPersistentType)inverseSidePersistentType, null, "customers", "customers", true,
-					createCompilationUnitFrom((IFile)ownerSidePersistentType.getResource()),
-					createCompilationUnitFrom((IFile)inverseSidePersistentType.getResource()));		
+					createCompilationUnitFrom((IFile)ownerSidePersistentType.getResource()));		
 		assertNotNull(ownerSideAttribute);
 
 		JavaPersistentAttribute inverseSideAttributes = JpaArtifactFactory.instance().addAttribute(featureProvider, (JavaPersistentType)inverseSidePersistentType, (JavaPersistentType)ownerSidePersistentType, null, "reservations", "reservations", true, 
-				createCompilationUnitFrom((IFile)inverseSidePersistentType.getResource()),
-				createCompilationUnitFrom((IFile)ownerSidePersistentType.getResource()));		
+				createCompilationUnitFrom((IFile)inverseSidePersistentType.getResource()));		
 		assertNotNull(inverseSideAttributes);
 		
 		JpaArtifactFactory.instance().addManyToManyBidirectionalRelation(featureProvider, (JavaPersistentType)ownerSidePersistentType, ownerSideAttribute, (JavaPersistentType)inverseSidePersistentType, inverseSideAttributes, false);
@@ -567,8 +557,7 @@
  
 		JavaPersistentAttribute annotatedSideAttribute = JpaArtifactFactory.instance().
 			addAttribute(featureProvider, (JavaPersistentType)annotatedPersistentType, (JavaPersistentType)referencedPersistentType, null, "cabins", "cabins", true,
-					createCompilationUnitFrom((IFile)annotatedPersistentType.getResource()),
-					createCompilationUnitFrom((IFile)referencedPersistentType.getResource()));		
+					createCompilationUnitFrom((IFile)annotatedPersistentType.getResource()));		
 		assertNotNull(annotatedSideAttribute);
 		
 		JpaArtifactFactory.instance().addManyToManyUnidirectionalRelation(featureProvider, (JavaPersistentType)annotatedPersistentType, annotatedSideAttribute, false);