Bug 364603 - JPA 2.0 - Support for element collection.
Add and update copyright.
Change-Id: I67a0abb10ff665d4798ea831ee878b2207964e9b
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);
