Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml2
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java2275
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java1410
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java435
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java1703
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java330
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java57
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java823
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java53
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java48
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java153
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java67
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java34
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java34
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java330
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java138
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java50
-rw-r--r--jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml4
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/RefactorAttributeTypeFeatureTest.java96
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/ui/ModelIntegrationTest.java221
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/util/ModelIntegrationUtilTest.java88
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferenceInitializerTest.java38
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferencesPageTest.java86
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/provider/JPAEditorToolBehaviorProviderTest.java252
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsInFieldAnnotatedEntitiesTest.java492
-rw-r--r--jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/test.xml2
26 files changed, 9217 insertions, 4 deletions
diff --git a/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml b/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml
index 0ac07d8cb9..1609ffb9ff 100644
--- a/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml
+++ b/jpa/tests/org.eclipse.jpt.jpa.core.tests/test.xml
@@ -21,7 +21,7 @@
</target>
<!-- This target defines the tests that need to be run. -->
- <target name="suite1"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.model.JptJpaCoreModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> </ant> </target> <target name="suite2"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.resource.JptJpaCoreResourceModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence204-jar}"/> </ant> </target> <target name="suite3"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.context.JptJpaCoreContextModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence204-jar}"/> </ant> </target> <target name="suite4"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.metadata.JptJpaCoreMetadataTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence204-jar}"/> </ant> </target>
+ <target name="suite1"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.model.JptJpaCoreModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> </ant> </target> <target name="suite2"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.resource.JptJpaCoreResourceModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence-jar}"/> </ant> </target> <target name="suite3"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.context.JptJpaCoreContextModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence-jar}"/> </ant> </target> <target name="suite4"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.core.tests.internal.metadata.JptJpaCoreMetadataTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence-jar}"/> </ant> </target>
<!-- This target holds code to cleanup the testing environment after -->
<!-- after all of the tests have been run. You can use this target to -->
<!-- delete temporary files that have been created. -->
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java
new file mode 100644
index 0000000000..03b42ab318
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java
@@ -0,0 +1,2275 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2012 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.java;
+
+import java.util.Iterator;
+import java.util.ListIterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceField;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind;
+import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
+import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject.SourceWriter;
+import org.eclipse.jpt.common.utility.internal.ReflectionTools;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jpa.core.MappingKeys;
+import org.eclipse.jpt.jpa.core.context.AttributeOverride;
+import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
+import org.eclipse.jpt.jpa.core.context.BasicMapping;
+import org.eclipse.jpt.jpa.core.context.Embeddable;
+import org.eclipse.jpt.jpa.core.context.EmbeddedIdMapping;
+import org.eclipse.jpt.jpa.core.context.EmbeddedMapping;
+import org.eclipse.jpt.jpa.core.context.EnumType;
+import org.eclipse.jpt.jpa.core.context.BaseEnumeratedConverter;
+import org.eclipse.jpt.jpa.core.context.FetchType;
+import org.eclipse.jpt.jpa.core.context.IdMapping;
+import org.eclipse.jpt.jpa.core.context.ManyToManyMapping;
+import org.eclipse.jpt.jpa.core.context.ManyToOneMapping;
+import org.eclipse.jpt.jpa.core.context.OneToManyMapping;
+import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.PersistentType;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.BaseTemporalConverter;
+import org.eclipse.jpt.jpa.core.context.TemporalType;
+import org.eclipse.jpt.jpa.core.context.TransientMapping;
+import org.eclipse.jpt.jpa.core.context.TypeMapping;
+import org.eclipse.jpt.jpa.core.context.VersionMapping;
+import org.eclipse.jpt.jpa.core.context.VirtualAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpa.core.context.persistence.ClassRef;
+import org.eclipse.jpt.jpa.core.jpa2.context.ElementCollectionMapping2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.OrderColumn2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaElementCollectionMapping2_0;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.ElementCollection2_0Annotation;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyClass2_0Annotation;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyColumn2_0Annotation;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyEnumerated2_0Annotation;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyTemporal2_0Annotation;
+import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.BasicAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.ColumnAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.EmbeddedAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.EmbeddedIdAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.IdAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.JPA;
+import org.eclipse.jpt.jpa.core.resource.java.ManyToManyAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.ManyToOneAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.MapKeyAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.OneToManyAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.TransientAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.VersionAnnotation;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConvert;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkConvertAnnotation;
+import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_0ContextModelTestCase;
+
+@SuppressWarnings("nls")
+public class EclipseLink2_0JavaElementCollectionMappingTests
+ extends EclipseLink2_0ContextModelTestCase
+{
+ public static final String EMBEDDABLE_TYPE_NAME = "Address";
+ public static final String FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME = PACKAGE_NAME + "." + EMBEDDABLE_TYPE_NAME;
+
+ private ICompilationUnit createTestEntityWithElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@ElementCollection").append(CR);
+ }
+ });
+ }
+ private ICompilationUnit createTestEntityWithElementCollectionMappingWithConvert() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, EclipseLink.CONVERT);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@ElementCollection").append(CR);
+ sb.append("@Convert(\"class-instance\")").append(CR);
+ }
+ });
+ }
+
+
+ private ICompilationUnit createTestEntityWithGenericEmbeddableElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Collection<Address> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithGenericBasicElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Collection<String> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithNonGenericElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Collection addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithValidGenericMapElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Map<Integer, Address> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithValidNonGenericMapElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Map addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private void createTestTargetEmbeddableAddress() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDED);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("Address").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private String city;").append(CR);
+ sb.append(CR);
+ sb.append(" @Embedded").append(CR);
+ sb.append(" private State state;").append(CR);
+ sb.append(CR);
+ sb.append(" private int zip;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+ }
+
+ private void createTestEmbeddableState() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("State").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private String name;").append(CR);
+ sb.append(CR);
+ sb.append(" private String abbr;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
+ }
+
+ private ICompilationUnit createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Map<Address, PropertyInfo> parcels;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private void createTestEmbeddablePropertyInfo() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDED);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("PropertyInfo").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private Integer parcelNumber;").append(CR);
+ sb.append(CR);
+ sb.append(" private Integer size;").append(CR);
+ sb.append(CR);
+ sb.append(" private java.math.BigDecimal tax;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+ }
+
+ private void createSelfReferentialElementCollection() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA2_0.ELEMENT_COLLECTION);
+ sb.append(";");
+ sb.append(CR).append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("Foo").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.List<Foo> elementCollection;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "Foo.java", sourceWriter);
+ }
+
+ public EclipseLink2_0JavaElementCollectionMappingTests(String name) {
+ super(name);
+ }
+
+ public void testMorphToBasicMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof BasicMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(BasicAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToDefault() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToVersionMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof VersionMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(VersionAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToIdMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof IdMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(IdAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToEmbeddedMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof EmbeddedMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(EmbeddedAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToEmbeddedIdMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof EmbeddedIdMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(EmbeddedIdAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToTransientMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof TransientMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(TransientAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToManyToOneMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof ManyToOneMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(ManyToOneAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToOneToManyMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof OneToManyMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(OneToManyAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testMorphToManyToManyMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+
+ persistentAttribute.setMappingKey(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
+ assertTrue(persistentAttribute.getMapping() instanceof ManyToManyMapping);
+ assertFalse(persistentAttribute.getMapping().isDefault());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertNull(resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME));
+ assertNotNull(resourceField.getAnnotation(ManyToManyAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testUpdateSpecifiedTargetEntity() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ ElementCollection2_0Annotation elementCollectionAnnotation = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME);
+
+ assertNull(elementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollectionAnnotation.getTargetClass());
+
+ //set target class in the resource model, verify context model updated
+ elementCollectionAnnotation.setTargetClass("newTargetClass");
+ this.getJpaProject().synchronizeContextModel();
+ assertEquals("newTargetClass", elementCollectionMapping.getSpecifiedTargetClass());
+ assertEquals("newTargetClass", elementCollectionAnnotation.getTargetClass());
+
+ //set target class to null in the resource model
+ elementCollectionAnnotation.setTargetClass(null);
+ this.getJpaProject().synchronizeContextModel();
+ assertNull(elementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollectionAnnotation.getTargetClass());
+ }
+
+ public void testModifySpecifiedTargetClass() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ ElementCollection2_0Annotation elementCollection = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME);
+
+ assertNull(elementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollection.getTargetClass());
+
+ //set target class in the context model, verify resource model updated
+ elementCollectionMapping.setSpecifiedTargetClass("newTargetClass");
+ assertEquals("newTargetClass", elementCollectionMapping.getSpecifiedTargetClass());
+ assertEquals("newTargetClass", elementCollection.getTargetClass());
+
+ //set target class to null in the context model
+ elementCollectionMapping.setSpecifiedTargetClass(null);
+ assertNull(elementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollection.getTargetClass());
+ }
+
+ public void testDefaultTargetClass() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ //targetEntity not in the persistence unit, default still set, handled by validation
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass());
+
+ //add targetEntity to the persistence unit
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass());
+
+ //test default still the same when specified target entity it set
+ elementCollectionMapping.setSpecifiedTargetClass("foo");
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass());
+
+ ListIterator<ClassRef> classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator();
+ classRefs.next();
+ ClassRef addressClassRef = classRefs.next();
+ JavaPersistentType addressPersistentType = addressClassRef.getJavaPersistentType();
+
+ //test target is not an Embeddable, default target entity still exists, this case handled with validation
+ addressPersistentType.setMappingKey(MappingKeys.NULL_TYPE_MAPPING_KEY);
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass());
+ }
+
+ public void testDefaultTargetClassNonGenericCollection() throws Exception {
+ createTestEntityWithNonGenericElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getDefaultTargetClass());
+ }
+
+ public void testDefaultTargetClassGenericCollection() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass());
+ }
+
+ public void testDefaultTargetClassNonGenericMap() throws Exception {
+ createTestEntityWithValidNonGenericMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getDefaultTargetClass());
+ }
+
+ public void testDefaultTargetClassGenericMap() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getDefaultTargetClass());
+ }
+
+ public void testTargetClass() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getTargetClass());
+
+ elementCollectionMapping.setSpecifiedTargetClass("foo");
+ assertEquals("foo", elementCollectionMapping.getTargetClass());
+
+ elementCollectionMapping.setSpecifiedTargetClass(null);
+ assertEquals(PACKAGE_NAME + ".Address", elementCollectionMapping.getTargetClass());
+ }
+
+ protected Embeddable getResolvedTargetEmbeddable(ElementCollectionMapping2_0 mapping) {
+ return (Embeddable) ReflectionTools.executeMethod(mapping, "getResolvedTargetEmbeddable");
+ }
+
+ public void testResolvedTargetEmbeddable() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ //target embeddable not in the persistence unit
+ assertNull(this.getResolvedTargetEmbeddable(elementCollectionMapping));
+
+ //add target embeddable to the persistence unit, now target embeddable should resolve
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ ListIterator<ClassRef> classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator();
+ classRefs.next();
+ ClassRef addressClassRef = classRefs.next();
+ TypeMapping addressTypeMapping = addressClassRef.getJavaPersistentType().getMapping();
+ assertEquals(addressTypeMapping, this.getResolvedTargetEmbeddable(elementCollectionMapping));
+
+ //test default still the same when specified target entity it set
+ elementCollectionMapping.setSpecifiedTargetClass("foo");
+ assertNull(this.getResolvedTargetEmbeddable(elementCollectionMapping));
+
+
+ elementCollectionMapping.setSpecifiedTargetClass(PACKAGE_NAME + ".Address");
+ assertEquals(addressTypeMapping, this.getResolvedTargetEmbeddable(elementCollectionMapping));
+
+
+ elementCollectionMapping.setSpecifiedTargetClass(null);
+ assertEquals(addressTypeMapping, this.getResolvedTargetEmbeddable(elementCollectionMapping));
+ }
+
+ public void testResolvedTargetEmbeddableWithBasicType() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ //target is a basic type, so resolved target embeddable is null
+ assertNull(this.getResolvedTargetEmbeddable(elementCollectionMapping));
+ }
+
+ public void testUpdateSpecifiedFetch() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ ElementCollection2_0Annotation elementCollection = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME);
+
+ assertNull(elementCollectionMapping.getSpecifiedFetch());
+ assertNull(elementCollection.getFetch());
+
+ //set fetch in the resource model, verify context model updated
+ elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.java.FetchType.EAGER);
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(FetchType.EAGER, elementCollectionMapping.getSpecifiedFetch());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.EAGER, elementCollection.getFetch());
+
+ elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.java.FetchType.LAZY);
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(FetchType.LAZY, elementCollectionMapping.getSpecifiedFetch());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.LAZY, elementCollection.getFetch());
+
+ //set fetch to null in the resource model
+ elementCollection.setFetch(null);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(elementCollectionMapping.getSpecifiedFetch());
+ assertNull(elementCollection.getFetch());
+ }
+
+ public void testModifySpecifiedFetch() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ ElementCollection2_0Annotation elementCollection = (ElementCollection2_0Annotation) resourceField.getAnnotation(ElementCollection2_0Annotation.ANNOTATION_NAME);
+
+ assertNull(elementCollectionMapping.getSpecifiedFetch());
+ assertNull(elementCollection.getFetch());
+
+ //set fetch in the context model, verify resource model updated
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertEquals(FetchType.EAGER, elementCollectionMapping.getSpecifiedFetch());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.EAGER, elementCollection.getFetch());
+
+ elementCollectionMapping.setSpecifiedFetch(FetchType.LAZY);
+ assertEquals(FetchType.LAZY, elementCollectionMapping.getSpecifiedFetch());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.FetchType.LAZY, elementCollection.getFetch());
+
+ //set fetch to null in the context model
+ elementCollectionMapping.setSpecifiedFetch(null);
+ assertNull(elementCollectionMapping.getSpecifiedFetch());
+ assertNull(elementCollection.getFetch());
+ }
+
+ public void testGetValueTypeEmbeddable() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType());
+ }
+
+ public void testGetValueTypeNone() throws Exception {
+ createTestEntityWithNonGenericElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(ElementCollectionMapping2_0.Type.NO_TYPE, elementCollectionMapping.getValueType());
+
+ elementCollectionMapping.setSpecifiedTargetClass("Address");
+ assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType());
+ }
+
+ public void testGetValueTypeBasic() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(ElementCollectionMapping2_0.Type.BASIC_TYPE, elementCollectionMapping.getValueType());
+ }
+
+ public void testUpdateMapKey() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(elementCollectionMapping.getSpecifiedMapKey());
+ assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME));
+
+ //set mapKey in the resource model, verify context model does not change
+ resourceField.addAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(elementCollectionMapping.getSpecifiedMapKey());
+ MapKeyAnnotation mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertNotNull(mapKey);
+
+ //set mapKey name in the resource model, verify context model updated
+ mapKey.setName("myMapKey");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals("myMapKey", elementCollectionMapping.getSpecifiedMapKey());
+ assertEquals("myMapKey", mapKey.getName());
+
+ //set mapKey name to null in the resource model
+ mapKey.setName(null);
+ getJpaProject().synchronizeContextModel();
+ assertNull(elementCollectionMapping.getSpecifiedMapKey());
+ assertNull(mapKey.getName());
+
+ mapKey.setName("myMapKey");
+ resourceField.removeAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertNull(elementCollectionMapping.getSpecifiedMapKey());
+ assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testModifyMapKey() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(elementCollectionMapping.getSpecifiedMapKey());
+ assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME));
+
+ //set mapKey in the context model, verify resource model updated
+ elementCollectionMapping.setSpecifiedMapKey("myMapKey");
+ MapKeyAnnotation mapKeyAnnotation = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertEquals("myMapKey", elementCollectionMapping.getSpecifiedMapKey());
+ assertEquals("myMapKey", mapKeyAnnotation.getName());
+
+ //set mapKey to null in the context model
+ elementCollectionMapping.setSpecifiedMapKey(null);
+ assertNull(elementCollectionMapping.getSpecifiedMapKey());
+ mapKeyAnnotation = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertNull(mapKeyAnnotation.getName());
+ }
+
+ public void testCandidateMapKeyNames() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping2_0 = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ Iterator<String> mapKeyNames =
+ elementCollectionMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals("city", mapKeyNames.next());
+ assertEquals("state", mapKeyNames.next());
+ assertEquals("state.name", mapKeyNames.next());
+ assertEquals("state.abbr", mapKeyNames.next());
+ assertEquals("zip", mapKeyNames.next());
+ assertFalse(mapKeyNames.hasNext());
+ }
+
+ public void testCandidateMapKeyNames2() throws Exception {
+ createTestEntityWithValidNonGenericMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping2_0 = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ Iterator<String> mapKeyNames = elementCollectionMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals(false, mapKeyNames.hasNext());
+
+ elementCollectionMapping2_0.setSpecifiedTargetClass("Address");
+ mapKeyNames = elementCollectionMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals("city", mapKeyNames.next());
+ assertEquals("state", mapKeyNames.next());
+ assertEquals("state.name", mapKeyNames.next());
+ assertEquals("state.abbr", mapKeyNames.next());
+ assertEquals("zip", mapKeyNames.next());
+ assertFalse(mapKeyNames.hasNext());
+
+ elementCollectionMapping2_0.setSpecifiedTargetClass("String");
+ mapKeyNames = elementCollectionMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals(false, mapKeyNames.hasNext());
+ }
+
+ public void testUpdateMapKeyClass() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(elementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+
+ //set mapKey in the resource model, verify context model does not change
+ resourceField.addAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ assertNull(elementCollectionMapping.getSpecifiedMapKeyClass());
+ MapKeyClass2_0Annotation mapKeyClassAnnotation = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ assertNotNull(mapKeyClassAnnotation);
+
+ //set mapKey name in the resource model, verify context model updated
+ mapKeyClassAnnotation.setValue("myMapKeyClass");
+ this.getJpaProject().synchronizeContextModel();
+ assertEquals("myMapKeyClass", elementCollectionMapping.getSpecifiedMapKeyClass());
+ assertEquals("myMapKeyClass", mapKeyClassAnnotation.getValue());
+
+ //set mapKey name to null in the resource model
+ mapKeyClassAnnotation.setValue(null);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(elementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(mapKeyClassAnnotation.getValue());
+
+ mapKeyClassAnnotation.setValue("myMapKeyClass");
+ resourceField.removeAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(elementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testModifyMapKeyClass() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(elementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+
+ //set mapKey in the context model, verify resource model updated
+ elementCollectionMapping.setSpecifiedMapKeyClass("String");
+ MapKeyClass2_0Annotation mapKeyClass = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ assertEquals("String", elementCollectionMapping.getSpecifiedMapKeyClass());
+ assertEquals("String", mapKeyClass.getValue());
+
+ //set mapKey to null in the context model
+ elementCollectionMapping.setSpecifiedMapKeyClass(null);
+ assertNull(elementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testDefaultMapKeyClass() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals("java.lang.Integer", elementCollectionMapping.getDefaultMapKeyClass());
+
+ //test default still the same when specified target entity it set
+ elementCollectionMapping.setSpecifiedMapKeyClass("foo");
+ assertEquals("java.lang.Integer", elementCollectionMapping.getDefaultMapKeyClass());
+ }
+
+ public void testDefaultMapKeyClassCollectionType() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getDefaultMapKeyClass());
+ }
+
+ public void testMapKeyClass() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals("java.lang.Integer", elementCollectionMapping.getMapKeyClass());
+
+ elementCollectionMapping.setSpecifiedMapKeyClass("foo");
+ assertEquals("foo", elementCollectionMapping.getMapKeyClass());
+
+ elementCollectionMapping.setSpecifiedMapKeyClass(null);
+ assertEquals("java.lang.Integer", elementCollectionMapping.getMapKeyClass());
+ }
+
+ public void testOrderColumnDefaults() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ Orderable2_0 orderable = ((Orderable2_0) elementCollectionMapping.getOrderable());
+ assertEquals(false, orderable.isOrderColumnOrdering());
+ assertEquals(true, orderable.isNoOrdering());
+
+ orderable.setOrderColumnOrdering(true);
+ OrderColumn2_0 orderColumn = orderable.getOrderColumn();
+ assertEquals(true, orderable.isOrderColumnOrdering());
+ assertEquals(null, orderColumn.getSpecifiedName());
+ assertEquals("addresses_ORDER", orderColumn.getDefaultName());
+ assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable());
+
+ orderColumn.setSpecifiedName("FOO");
+ assertEquals("FOO", orderColumn.getSpecifiedName());
+ assertEquals("addresses_ORDER", orderColumn.getDefaultName());
+ assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable());
+ }
+
+ public void testGetValueColumn() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getValueColumn().getSpecifiedName());
+ assertEquals("id", elementCollectionMapping.getValueColumn().getName());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ ColumnAnnotation column = (ColumnAnnotation) resourceField.addAnnotation(JPA.COLUMN);
+ column.setName("foo");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals("foo", elementCollectionMapping.getValueColumn().getSpecifiedName());
+ assertEquals("foo", elementCollectionMapping.getValueColumn().getName());
+ assertEquals("id", elementCollectionMapping.getValueColumn().getDefaultName());
+ }
+
+ public void testSpecifiedAttributeOverrides() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ JavaAttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+
+ ListIterator<JavaAttributeOverride> specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("BAR");
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("BAZ");
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+ //move an annotation to the resource model and verify the context model is updated
+ resourceField.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ }
+
+ public void testVirtualAttributeOverrides() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertEquals("addresses", resourceField.getName());
+ assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME));
+
+ assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize());
+ ReadOnlyAttributeOverride defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("city", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_addresses", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ ListIterator<ClassRef> classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator();
+ classRefs.next();
+ Embeddable embeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+
+ BasicMapping cityMapping = (BasicMapping) embeddable.getPersistentType().getAttributeNamed("city").getMapping();
+ cityMapping.getColumn().setSpecifiedName("FOO");
+ cityMapping.getColumn().setSpecifiedTable("BAR");
+ cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+ cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+ cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+ cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+ cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+
+ assertEquals("addresses", resourceField.getName());
+ assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME));
+
+ assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize());
+ defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+ assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+ assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+ cityMapping.getColumn().setSpecifiedName(null);
+ cityMapping.getColumn().setSpecifiedTable(null);
+ cityMapping.getColumn().setColumnDefinition(null);
+ cityMapping.getColumn().setSpecifiedInsertable(null);
+ cityMapping.getColumn().setSpecifiedUpdatable(null);
+ cityMapping.getColumn().setSpecifiedUnique(null);
+ cityMapping.getColumn().setSpecifiedNullable(null);
+ cityMapping.getColumn().setSpecifiedLength(null);
+ cityMapping.getColumn().setSpecifiedPrecision(null);
+ cityMapping.getColumn().setSpecifiedScale(null);
+ defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("city", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_addresses", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ annotation.setName("city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+ public void testSpecifiedAttributeOverridesSize() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ assertEquals(0, attributeOverrideContainer.getSpecifiedOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("BAR");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(2, attributeOverrideContainer.getSpecifiedOverridesSize());
+ }
+
+ public void testAttributeOverridesSize() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ assertEquals(4, attributeOverrideContainer.getOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("BAR");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(6, attributeOverrideContainer.getOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(6, attributeOverrideContainer.getOverridesSize());
+ }
+
+ public void testVirtualAttributeOverridesSize() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("state.name");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(2, attributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+ public void testAttributeOverrideSetVirtual() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ Iterator<NestableAnnotation> attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ attributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+ assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ assertEquals("city", attributeOverrideContainer.getVirtualOverrides().iterator().next().getName());
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+
+ attributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+ assertFalse(attributeOverrides.hasNext());
+
+ Iterator<? extends VirtualAttributeOverride> virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator();
+ assertEquals("city", virtualAttributeOverrides.next().getName());
+ assertEquals("state.name", virtualAttributeOverrides.next().getName());
+ assertEquals("state.abbr", virtualAttributeOverrides.next().getName());
+ assertEquals("zip", virtualAttributeOverrides.next().getName());
+ assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+ public void testAttributeOverrideSetVirtual2() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ ListIterator<? extends VirtualAttributeOverride> virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator();
+ virtualAttributeOverrides.next();
+ virtualAttributeOverrides.next().convertToSpecified();
+ attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ Iterator<NestableAnnotation> attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+ }
+
+ public void testMoveSpecifiedAttributeOverride() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ resourceField.moveAnnotation(1, 0, AttributeOverrideAnnotation.ANNOTATION_NAME);
+
+ Iterator<NestableAnnotation> attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+ }
+
+ public void testNestedVirtualAttributeOverrides() throws Exception {
+ createTestEntityWithGenericEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ListIterator<ClassRef> specifiedClassRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator();
+ PersistentType persistentType = specifiedClassRefs.next().getJavaPersistentType();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentType.getAttributeNamed("addresses").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+
+ assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize());
+ ListIterator<? extends VirtualAttributeOverride> virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator();
+ ReadOnlyAttributeOverride virtualAttributeOverride = virtualAttributeOverrides.next();
+ assertEquals("city", virtualAttributeOverride.getName());
+ virtualAttributeOverride = virtualAttributeOverrides.next();
+ assertEquals("state.name", virtualAttributeOverride.getName());
+ virtualAttributeOverride = virtualAttributeOverrides.next();
+ assertEquals("state.abbr", virtualAttributeOverride.getName());
+ virtualAttributeOverride = virtualAttributeOverrides.next();
+ assertEquals("zip", virtualAttributeOverride.getName());
+ assertEquals(false, virtualAttributeOverrides.hasNext());
+
+
+ PersistentType addressPersistentType = specifiedClassRefs.next().getJavaPersistentType();
+ EmbeddedMapping nestedEmbeddedMapping = (EmbeddedMapping) addressPersistentType.getAttributeNamed("state").getMapping();
+ AttributeOverrideContainer nestedAttributeOverrideContainer = nestedEmbeddedMapping.getAttributeOverrideContainer();
+ assertEquals(2, nestedAttributeOverrideContainer.getVirtualOverridesSize());
+ virtualAttributeOverrides = nestedAttributeOverrideContainer.getVirtualOverrides().iterator();
+ virtualAttributeOverride = virtualAttributeOverrides.next();
+ assertEquals("name", virtualAttributeOverride.getName());
+ virtualAttributeOverride = virtualAttributeOverrides.next();
+ assertEquals("abbr", virtualAttributeOverride.getName());
+
+ PersistentType statePersistentType = specifiedClassRefs.next().getJavaPersistentType();
+ BasicMapping abbrMapping = (BasicMapping) statePersistentType.getAttributeNamed("abbr").getMapping();
+ abbrMapping.getColumn().setSpecifiedName("BLAH");
+ abbrMapping.getColumn().setSpecifiedTable("BLAH_TABLE");
+ abbrMapping.getColumn().setColumnDefinition("COLUMN_DEFINITION");
+ abbrMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+ abbrMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ abbrMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+ abbrMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+ abbrMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+ abbrMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+ abbrMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+
+ //check the nested embedded (Address.state) attribute override to verify it is getting settings from the specified column on State.abbr
+ virtualAttributeOverride = ((EmbeddedMapping) addressPersistentType.getAttributeNamed("state").getMapping()).getAttributeOverrideContainer().getOverrideNamed("abbr");
+ assertEquals("abbr", virtualAttributeOverride.getName());
+ assertEquals("BLAH", virtualAttributeOverride.getColumn().getName());
+ assertEquals("BLAH_TABLE", virtualAttributeOverride.getColumn().getTable());
+ assertEquals("COLUMN_DEFINITION", virtualAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(false, virtualAttributeOverride.getColumn().isInsertable());
+ assertEquals(false, virtualAttributeOverride.getColumn().isUpdatable());
+ assertEquals(true, virtualAttributeOverride.getColumn().isUnique());
+ assertEquals(false, virtualAttributeOverride.getColumn().isNullable());
+ assertEquals(5, virtualAttributeOverride.getColumn().getLength());
+ assertEquals(6, virtualAttributeOverride.getColumn().getPrecision());
+ assertEquals(7, virtualAttributeOverride.getColumn().getScale());
+ }
+
+ public void testGetMapKeyColumn() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getMapKeyColumn().getSpecifiedName());
+ assertEquals("addresses_KEY", elementCollectionMapping.getMapKeyColumn().getName());
+ assertEquals(TYPE_NAME + "_addresses", elementCollectionMapping.getMapKeyColumn().getTable());//collection table name
+
+ elementCollectionMapping.getCollectionTable().setSpecifiedName("MY_COLLECTION_TABLE");
+ assertEquals("MY_COLLECTION_TABLE", elementCollectionMapping.getMapKeyColumn().getTable());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyColumn2_0Annotation column = (MapKeyColumn2_0Annotation) resourceField.addAnnotation(JPA2_0.MAP_KEY_COLUMN);
+ column.setName("foo");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals("foo", elementCollectionMapping.getMapKeyColumn().getSpecifiedName());
+ assertEquals("foo", elementCollectionMapping.getMapKeyColumn().getName());
+ assertEquals("addresses_KEY", elementCollectionMapping.getMapKeyColumn().getDefaultName());
+ }
+
+ public void testMapKeyValueSpecifiedAttributeOverrides() throws Exception {
+ createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddablePropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+
+ JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+
+ ListIterator<JavaAttributeOverride> specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("value.BAR");
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAZ");
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BLAH");
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ //move an annotation to the resource model and verify the context model is updated
+ resourceField.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertFalse(specifiedAttributeOverrides.hasNext());
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+ }
+
+ public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+ createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEmbeddablePropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertEquals("parcels", resourceField.getName());
+ assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME));
+
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ ReadOnlyAttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("city", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ ListIterator<ClassRef> classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator();
+ classRefs.next();
+ Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+
+ BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+ cityMapping.getColumn().setSpecifiedName("FOO");
+ cityMapping.getColumn().setSpecifiedTable("BAR");
+ cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+ cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+ cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+ cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+ cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+
+ assertEquals("parcels", resourceField.getName());
+ assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME));
+
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+ assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+ assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+ cityMapping.getColumn().setSpecifiedName(null);
+ cityMapping.getColumn().setSpecifiedTable(null);
+ cityMapping.getColumn().setColumnDefinition(null);
+ cityMapping.getColumn().setSpecifiedInsertable(null);
+ cityMapping.getColumn().setSpecifiedUpdatable(null);
+ cityMapping.getColumn().setSpecifiedUnique(null);
+ cityMapping.getColumn().setSpecifiedNullable(null);
+ cityMapping.getColumn().setSpecifiedLength(null);
+ cityMapping.getColumn().setSpecifiedPrecision(null);
+ cityMapping.getColumn().setSpecifiedScale(null);
+ defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("city", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ annotation.setName("key.city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+ defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("parcelNumber", defaultAttributeOverride.getName());
+ assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator();
+ classRefs.next();
+ classRefs.next();
+ Embeddable propertyInfoEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+
+ BasicMapping parcelNumberMapping = (BasicMapping) propertyInfoEmbeddable.getPersistentType().getAttributeNamed("parcelNumber").getMapping();
+ parcelNumberMapping.getColumn().setSpecifiedName("FOO1");
+ parcelNumberMapping.getColumn().setSpecifiedTable("BAR1");
+ parcelNumberMapping.getColumn().setColumnDefinition("COLUMN_DEF1");
+ parcelNumberMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+ parcelNumberMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ parcelNumberMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+ parcelNumberMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+ parcelNumberMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+ parcelNumberMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+ parcelNumberMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+
+ assertEquals("parcels", resourceField.getName());
+
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+ defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("parcelNumber", defaultAttributeOverride.getName());
+ assertEquals("FOO1", defaultAttributeOverride.getColumn().getName());
+ assertEquals("BAR1", defaultAttributeOverride.getColumn().getTable());
+ assertEquals("COLUMN_DEF1", defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+ parcelNumberMapping.getColumn().setSpecifiedName(null);
+ parcelNumberMapping.getColumn().setSpecifiedTable(null);
+ parcelNumberMapping.getColumn().setColumnDefinition(null);
+ parcelNumberMapping.getColumn().setSpecifiedInsertable(null);
+ parcelNumberMapping.getColumn().setSpecifiedUpdatable(null);
+ parcelNumberMapping.getColumn().setSpecifiedUnique(null);
+ parcelNumberMapping.getColumn().setSpecifiedNullable(null);
+ parcelNumberMapping.getColumn().setSpecifiedLength(null);
+ parcelNumberMapping.getColumn().setSpecifiedPrecision(null);
+ parcelNumberMapping.getColumn().setSpecifiedScale(null);
+ defaultAttributeOverride = attributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("parcelNumber", defaultAttributeOverride.getName());
+ assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ annotation.setName("value.parcelNumber");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(2, attributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+ public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+ createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEmbeddablePropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+ assertEquals(0, valueAttributeOverrideContainer.getSpecifiedOverridesSize());
+ assertEquals(0, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAR");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("value.FOO2");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(2, valueAttributeOverrideContainer.getSpecifiedOverridesSize());
+ assertEquals(1, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize());
+ }
+
+ public void testMapKeyValueAttributeOverridesSize() throws Exception {
+ createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEmbeddablePropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+ assertEquals(4, mapKeyAttributeOverrideContainer.getOverridesSize());
+ assertEquals(3, valueAttributeOverrideContainer.getOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAR");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("value.FOO2");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(5, mapKeyAttributeOverrideContainer.getOverridesSize());
+ assertEquals(5, valueAttributeOverrideContainer.getOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(5, mapKeyAttributeOverrideContainer.getOverridesSize());
+ assertEquals(6, valueAttributeOverrideContainer.getOverridesSize());
+ }
+
+ public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+ createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEmbeddablePropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals(3, valueAttributeOverrideContainer.getVirtualOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAR");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals(3, valueAttributeOverrideContainer.getVirtualOverridesSize());
+
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.city");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("value.parcelNumber");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals(2, valueAttributeOverrideContainer.getVirtualOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.state.name");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("size");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(2, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals(1, valueAttributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+ public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+ createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEmbeddablePropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+ valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ Iterator<NestableAnnotation> attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ valueAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+ assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ assertEquals("parcelNumber", valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().getName());
+ assertEquals(2, valueAttributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals("city", mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().getName());
+ assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+
+ valueAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+ assertFalse(attributeOverrides.hasNext());
+
+ Iterator<? extends VirtualAttributeOverride> virtualAttributeOverrides = valueAttributeOverrideContainer.getVirtualOverrides().iterator();
+ assertEquals("parcelNumber", virtualAttributeOverrides.next().getName());
+ assertEquals("size", virtualAttributeOverrides.next().getName());
+ assertEquals("tax", virtualAttributeOverrides.next().getName());
+ assertEquals(3, valueAttributeOverrideContainer.getVirtualOverridesSize());
+
+ virtualAttributeOverrides = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator();
+ assertEquals("city", virtualAttributeOverrides.next().getName());
+ assertEquals("state.name", virtualAttributeOverrides.next().getName());
+ assertEquals("state.abbr", virtualAttributeOverrides.next().getName());
+ assertEquals("zip", virtualAttributeOverrides.next().getName());
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+
+ public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+ createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEmbeddablePropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+ valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ valueAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ ListIterator<? extends AttributeOverride> specifiedOverrides = valueAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("parcelNumber", specifiedOverrides.next().getName());
+ assertEquals("size", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+
+ specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("city", specifiedOverrides.next().getName());
+ assertEquals("state.name", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ resourceField.moveAnnotation(1, 0, AttributeOverrideAnnotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ Iterator<NestableAnnotation> attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ specifiedOverrides = valueAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("size", specifiedOverrides.next().getName());
+ assertEquals("parcelNumber", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+
+ specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("city", specifiedOverrides.next().getName());
+ assertEquals("state.name", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+
+
+ resourceField.moveAnnotation(3, 2, AttributeOverrideAnnotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ specifiedOverrides = valueAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("size", specifiedOverrides.next().getName());
+ assertEquals("parcelNumber", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+
+ specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("state.name", specifiedOverrides.next().getName());
+ assertEquals("city", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+ }
+
+ public void testSelfReferentialElementCollection() throws Exception {
+ createSelfReferentialElementCollection();
+ addXmlClassRef(PACKAGE_NAME + ".Foo");
+
+ //If there is a StackOverflowError you will not be able to get the mapping
+ JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("elementCollection").getMapping();
+ assertFalse(elementCollectionMapping.getAllOverridableAttributeMappingNames().iterator().hasNext());
+ }
+
+
+ public void testSetSpecifiedMapKeyEnumerated() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertNull(elementCollectionMapping.getMapKeyConverter().getType());
+
+ elementCollectionMapping.setMapKeyConverter(BaseEnumeratedConverter.class);
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME);
+
+ assertNotNull(enumerated);
+ assertEquals(null, enumerated.getValue());
+
+ ((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.STRING);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING, enumerated.getValue());
+
+ ((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(null);
+ assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME));
+ assertNull(enumerated.getValue());
+
+ elementCollectionMapping.setMapKeyConverter(null);
+ assertNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testGetSpecifiedMapKeyEnumeratedUpdatesFromResourceModelChange() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getMapKeyConverter().getType());
+
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.addAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME);
+ enumerated.setValue(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING);
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType());
+
+ enumerated.setValue(null);
+ getJpaProject().synchronizeContextModel();
+ assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME));
+ assertNull(((BaseEnumeratedConverter) elementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType());
+ assertFalse(elementCollectionMapping.isDefault());
+ assertSame(elementCollectionMapping, persistentAttribute.getMapping());
+ }
+
+ public void testSetMapKeyTemporal() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertNull(elementCollectionMapping.getMapKeyConverter().getType());
+
+ elementCollectionMapping.setMapKeyConverter(BaseTemporalConverter.class);
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME);
+
+ assertNotNull(temporal);
+ assertEquals(null, temporal.getValue());
+
+ ((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).setTemporalType(TemporalType.TIME);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME, temporal.getValue());
+
+ ((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).setTemporalType(null);
+ assertNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testGetMapKeyTemporalUpdatesFromResourceModelChange() throws Exception {
+ createTestEntityWithValidGenericMapElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getMapKeyConverter().getType());
+
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.addAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME);
+ temporal.setValue(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME);
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(TemporalType.TIME, ((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).getTemporalType());
+
+ temporal.setValue(null);
+ getJpaProject().synchronizeContextModel();
+ assertNotNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME));
+ assertNull(((BaseTemporalConverter) elementCollectionMapping.getMapKeyConverter()).getTemporalType());
+ assertFalse(elementCollectionMapping.isDefault());
+ assertSame(elementCollectionMapping, persistentAttribute.getMapping());
+ }
+
+
+ public void testGetConvert() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ resourceField.addAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(EclipseLinkConvert.class, elementCollectionMapping.getConverter().getType());
+ }
+
+ public void testGetConvert2() throws Exception {
+ createTestEntityWithElementCollectionMappingWithConvert();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals(EclipseLinkConvert.class, elementCollectionMapping.getConverter().getType());
+ assertEquals(EclipseLinkConvert.CLASS_INSTANCE_CONVERTER, ((EclipseLinkConvert) elementCollectionMapping.getConverter()).getConverterName());
+ }
+
+ public void testSetConvert() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+ assertNull(elementCollectionMapping.getConverter().getType());
+
+ elementCollectionMapping.setConverter(EclipseLinkConvert.class);
+ ((EclipseLinkConvert) elementCollectionMapping.getConverter()).setSpecifiedConverterName("foo");
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ EclipseLinkConvertAnnotation eclipselinkConvert = (EclipseLinkConvertAnnotation) resourceField.getAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME);
+
+ assertEquals("foo", eclipselinkConvert.getValue());
+
+ elementCollectionMapping.setConverter(null);
+ assertNull(resourceField.getAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testGetConvertUpdatesFromResourceModelChange() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(elementCollectionMapping.getConverter().getType());
+
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ EclipseLinkConvertAnnotation convert = (EclipseLinkConvertAnnotation) resourceField.addAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME);
+ convert.setValue("foo");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(EclipseLinkConvert.class, elementCollectionMapping.getConverter().getType());
+ assertEquals("foo", ((EclipseLinkConvert) elementCollectionMapping.getConverter()).getConverterName());
+
+ resourceField.removeAnnotation(EclipseLinkConvertAnnotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(elementCollectionMapping.getConverter().getType());
+ assertFalse(elementCollectionMapping.isDefault());
+ assertSame(elementCollectionMapping, persistentAttribute.getMapping());
+ }
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java
new file mode 100644
index 0000000000..754fd71d20
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java
@@ -0,0 +1,1410 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2012 Oracle. 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:
+ * Oracle - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.java;
+
+import java.util.Iterator;
+import java.util.ListIterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceField;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
+import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
+import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject.SourceWriter;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jpa.core.context.AttributeMapping;
+import org.eclipse.jpt.jpa.core.context.BasicMapping;
+import org.eclipse.jpt.jpa.core.context.Embeddable;
+import org.eclipse.jpt.jpa.core.context.Entity;
+import org.eclipse.jpt.jpa.core.context.EnumType;
+import org.eclipse.jpt.jpa.core.context.BaseEnumeratedConverter;
+import org.eclipse.jpt.jpa.core.context.JoinTableRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.ManyToManyMapping;
+import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.PersistentType;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.BaseTemporalConverter;
+import org.eclipse.jpt.jpa.core.context.TemporalType;
+import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.persistence.ClassRef;
+import org.eclipse.jpt.jpa.core.jpa2.context.ManyToManyMapping2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.OrderColumn2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaManyToManyMapping2_0;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyClass2_0Annotation;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyColumn2_0Annotation;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyEnumerated2_0Annotation;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.MapKeyTemporal2_0Annotation;
+import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation;
+import org.eclipse.jpt.jpa.core.resource.java.JPA;
+import org.eclipse.jpt.jpa.core.resource.java.MapKeyAnnotation;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkJoinFetch;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkJoinFetchType;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkRelationshipMapping;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkJoinFetchAnnotation;
+import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_0ContextModelTestCase;
+
+@SuppressWarnings("nls")
+public class EclipseLink2_0JavaManyToManyMappingTests
+ extends EclipseLink2_0ContextModelTestCase
+{
+ public EclipseLink2_0JavaManyToManyMappingTests(String name) {
+ super(name);
+ }
+
+ private ICompilationUnit createTestEntityWithJoinFetchManyToMany() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.MANY_TO_MANY, EclipseLink.JOIN_FETCH);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@ManyToMany").append(CR);
+ sb.append("@JoinFetch").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithValidManyToManyMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID, "java.util.Collection");
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ManyToMany").append(CR);
+ sb.append(" private Collection<Address> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithValidGenericMapManyToManyMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ManyToMany").append(CR);
+ sb.append(" private java.util.Map<Integer, Address> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithValidNonGenericMapManyToManyMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ManyToMany").append(CR);
+ sb.append(" private java.util.Map addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private void createTestTargetEntityAddress() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ENTITY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDED);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.MANY_TO_MANY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Entity");
+ sb.append(CR);
+ sb.append("public class ").append("Address").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ sb.append(" private int id;").append(CR);
+ sb.append(CR);
+ sb.append(" private String city;").append(CR);
+ sb.append(CR);
+ sb.append(" @Embedded").append(CR);
+ sb.append(" private State state;").append(CR);
+ sb.append(CR);
+ sb.append(" private int zip;").append(CR);
+ sb.append(CR);
+ sb.append(" @ManyToMany").append(CR);
+ sb.append(" private java.util.Collection<AnnotationTestType> employees;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+ }
+
+ private void createTestTargetEntityAddressWithElementCollection() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ENTITY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA2_0.ELEMENT_COLLECTION);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Entity");
+ sb.append(CR);
+ sb.append("public class ").append("Address").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ sb.append(" private int id;").append(CR);
+ sb.append(CR);
+ sb.append(" private String city;").append(CR);
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Collection<State> state;").append(CR);
+ sb.append(CR);
+ sb.append(" private int zip;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+ }
+
+ private void createTestEmbeddableState() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("State").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private String foo;").append(CR);
+ sb.append(CR);
+ sb.append(" private String address;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
+ }
+
+ private ICompilationUnit createTestEntityWithEmbeddableKeyManyToManyMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ManyToMany").append(CR);
+ sb.append(" private java.util.Map<Address, PropertyInfo> parcels;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private void createTestEmbeddableAddress() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDED);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("Address").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private String city;").append(CR);
+ sb.append(CR);
+ sb.append(" @Embedded").append(CR);
+ sb.append(" private State state;").append(CR);
+ sb.append(CR);
+ sb.append(" private int zip;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+ }
+
+ private void createTestEntityPropertyInfo() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ENTITY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDED);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Entity");
+ sb.append(CR);
+ sb.append("public class ").append("PropertyInfo").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private Integer parcelNumber;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ sb.append(" private Integer size;").append(CR);
+ sb.append(CR);
+ sb.append(" private java.math.BigDecimal tax;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+ }
+
+ public void testGetJoinFetchValue() throws Exception {
+ createTestEntityWithJoinFetchManyToMany();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ EclipseLinkRelationshipMapping manyToManyMapping = (EclipseLinkRelationshipMapping) persistentAttribute.getMapping();
+ EclipseLinkJoinFetch contextJoinFetch = manyToManyMapping.getJoinFetch();
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ EclipseLinkJoinFetchAnnotation joinFetchAnnotation = (EclipseLinkJoinFetchAnnotation) resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME);
+
+ // base annotated, test context value
+
+ assertNull(joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue());
+
+ // change resource to INNER specifically, test context
+
+ joinFetchAnnotation.setValue(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.INNER);
+
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.INNER, joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue());
+
+ // change resource to OUTER, test context
+
+ joinFetchAnnotation.setValue(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.OUTER);
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.OUTER, joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.OUTER, contextJoinFetch.getValue());
+
+ // remove value from resource, test context
+
+ joinFetchAnnotation.setValue(null);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue());
+
+ // remove annotation, text context
+
+ resourceField.removeAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(joinFetchAnnotation.getValue());
+ assertNull(contextJoinFetch.getValue());
+ }
+
+ public void testSetJoinFetchValue() throws Exception {
+ createTestEntityWithJoinFetchManyToMany();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ EclipseLinkRelationshipMapping manyToManyMapping = (EclipseLinkRelationshipMapping) persistentAttribute.getMapping();
+ EclipseLinkJoinFetch contextJoinFetch = manyToManyMapping.getJoinFetch();
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ EclipseLinkJoinFetchAnnotation joinFetchAnnotation = (EclipseLinkJoinFetchAnnotation) resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME);
+
+ // base annotated, test resource value
+
+ assertNull(joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue());
+
+ // change context to INNER specifically, test resource
+
+ contextJoinFetch.setValue(EclipseLinkJoinFetchType.INNER);
+
+ assertNull(joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue());
+
+ // change context to OUTER, test resource
+
+ contextJoinFetch.setValue(EclipseLinkJoinFetchType.OUTER);
+
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.OUTER, joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.OUTER, contextJoinFetch.getValue());
+
+ // set context to null, test resource
+
+ contextJoinFetch.setValue(null);
+
+ assertNull(resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME));
+ assertNull(contextJoinFetch.getValue());
+
+ // change context to INNER specifically (this time from no annotation), test resource
+
+ contextJoinFetch.setValue(EclipseLinkJoinFetchType.INNER);
+ joinFetchAnnotation = (EclipseLinkJoinFetchAnnotation) resourceField.getAnnotation(EclipseLinkJoinFetchAnnotation.ANNOTATION_NAME);
+
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.java.JoinFetchType.INNER, joinFetchAnnotation.getValue());
+ assertEquals(EclipseLinkJoinFetchType.INNER, contextJoinFetch.getValue());
+ }
+
+ public void testCandidateMappedByAttributeNames() throws Exception {
+ createTestEntityWithValidManyToManyMapping();
+ createTestTargetEntityAddress();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ PersistentAttribute persistentAttribute = (getJavaPersistentType()).getAttributes().iterator().next();
+ ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping();
+
+ Iterator<String> attributeNames =
+ manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator();
+ assertEquals("id", attributeNames.next());
+ assertEquals("city", attributeNames.next());
+ assertEquals("state", attributeNames.next());
+ assertEquals("state.foo", attributeNames.next());
+ assertEquals("state.address", attributeNames.next());
+ assertEquals("zip", attributeNames.next());
+ assertEquals("employees", attributeNames.next());
+ assertFalse(attributeNames.hasNext());
+
+ manyToManyMapping.setSpecifiedTargetEntity("foo");
+ attributeNames =
+ manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator();
+ assertFalse(attributeNames.hasNext());
+
+ manyToManyMapping.setSpecifiedTargetEntity(null);
+ attributeNames =
+ manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator();
+ assertEquals("id", attributeNames.next());
+ assertEquals("city", attributeNames.next());
+ assertEquals("state", attributeNames.next());
+ assertEquals("state.foo", attributeNames.next());
+ assertEquals("state.address", attributeNames.next());
+ assertEquals("zip", attributeNames.next());
+ assertEquals("employees", attributeNames.next());
+ assertFalse(attributeNames.hasNext());
+
+ AttributeMapping stateFooMapping = manyToManyMapping.getResolvedTargetEntity().resolveAttributeMapping("state.foo");
+ assertEquals("foo", stateFooMapping.getName());
+ }
+
+ public void testCandidateMappedByAttributeNamesElementCollection() throws Exception {
+ createTestEntityWithValidManyToManyMapping();
+ createTestTargetEntityAddressWithElementCollection();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ PersistentAttribute persistentAttribute = (getJavaPersistentType()).getAttributes().iterator().next();
+ ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping();
+
+ Iterator<String> attributeNames =
+ manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator();
+ assertEquals("id", attributeNames.next());
+ assertEquals("city", attributeNames.next());
+ assertEquals("state", attributeNames.next());
+ assertEquals("state.foo", attributeNames.next());
+ assertEquals("state.address", attributeNames.next());
+ assertEquals("zip", attributeNames.next());
+ assertFalse(attributeNames.hasNext());
+
+ manyToManyMapping.setSpecifiedTargetEntity("foo");
+ attributeNames =
+ manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator();
+ assertFalse(attributeNames.hasNext());
+
+ manyToManyMapping.setSpecifiedTargetEntity(null);
+ attributeNames =
+ manyToManyMapping.getRelationship().getMappedByStrategy().getCandidateMappedByAttributeNames().iterator();
+ assertEquals("id", attributeNames.next());
+ assertEquals("city", attributeNames.next());
+ assertEquals("state", attributeNames.next());
+ assertEquals("state.foo", attributeNames.next());
+ assertEquals("state.address", attributeNames.next());
+ assertEquals("zip", attributeNames.next());
+ assertFalse(attributeNames.hasNext());
+
+ AttributeMapping stateFooMapping = manyToManyMapping.getResolvedTargetEntity().resolveAttributeMapping("state.foo");
+ assertEquals("foo", stateFooMapping.getName());
+ }
+
+ public void testUpdateMapKey() throws Exception {
+ createTestEntityWithValidManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(manyToManyMapping.getSpecifiedMapKey());
+ assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME));
+
+ //set mapKey in the resource model, verify context model does not change
+ resourceField.addAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertNull(manyToManyMapping.getSpecifiedMapKey());
+ MapKeyAnnotation mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertNotNull(mapKey);
+
+ //set mapKey name in the resource model, verify context model updated
+ mapKey.setName("myMapKey");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals("myMapKey", manyToManyMapping.getSpecifiedMapKey());
+ assertEquals("myMapKey", mapKey.getName());
+
+ //set mapKey name to null in the resource model
+ mapKey.setName(null);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(manyToManyMapping.getSpecifiedMapKey());
+ assertNull(mapKey.getName());
+
+ mapKey.setName("myMapKey");
+ resourceField.removeAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertNull(manyToManyMapping.getSpecifiedMapKey());
+ assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME));
+ }
+
+ public void testModifyMapKey() throws Exception {
+ createTestEntityWithValidManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping manyToManyMapping = (ManyToManyMapping) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(manyToManyMapping.getSpecifiedMapKey());
+ assertNull(resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME));
+
+ //set mapKey in the context model, verify resource model updated
+ manyToManyMapping.setSpecifiedMapKey("myMapKey");
+ MapKeyAnnotation mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertEquals("myMapKey", manyToManyMapping.getSpecifiedMapKey());
+ assertEquals("myMapKey", mapKey.getName());
+ //set mapKey to null in the context model
+ manyToManyMapping.setSpecifiedMapKey(null);
+ assertNull(manyToManyMapping.getSpecifiedMapKey());
+ mapKey = (MapKeyAnnotation) resourceField.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+ assertNull(mapKey.getName());
+ }
+
+ public void testCandidateMapKeyNames() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ createTestTargetEntityAddress();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping manyToManyMapping2_0 = (ManyToManyMapping) persistentAttribute.getMapping();
+
+ Iterator<String> mapKeyNames =
+ manyToManyMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals("id", mapKeyNames.next());
+ assertEquals("city", mapKeyNames.next());
+ assertEquals("state", mapKeyNames.next());
+ assertEquals("state.foo", mapKeyNames.next());
+ assertEquals("state.address", mapKeyNames.next());
+ assertEquals("zip", mapKeyNames.next());
+ assertEquals("employees", mapKeyNames.next());
+ assertFalse(mapKeyNames.hasNext());
+ }
+
+ public void testCandidateMapKeyNames2() throws Exception {
+ createTestEntityWithValidNonGenericMapManyToManyMapping();
+ createTestTargetEntityAddress();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping manyToManyMapping2_0 = (ManyToManyMapping) persistentAttribute.getMapping();
+
+ Iterator<String> mapKeyNames = manyToManyMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals(false, mapKeyNames.hasNext());
+
+ manyToManyMapping2_0.setSpecifiedTargetEntity("Address");
+ mapKeyNames = manyToManyMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals("id", mapKeyNames.next());
+ assertEquals("city", mapKeyNames.next());
+ assertEquals("state", mapKeyNames.next());
+ assertEquals("state.foo", mapKeyNames.next());
+ assertEquals("state.address", mapKeyNames.next());
+ assertEquals("zip", mapKeyNames.next());
+ assertEquals("employees", mapKeyNames.next());
+ assertFalse(mapKeyNames.hasNext());
+
+ manyToManyMapping2_0.setSpecifiedTargetEntity("String");
+ mapKeyNames = manyToManyMapping2_0.getCandidateMapKeyNames().iterator();
+ assertEquals(false, mapKeyNames.hasNext());
+ }
+
+ public void testUpdateMapKeyClass() throws Exception {
+ createTestEntityWithValidManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(manyToManyMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+
+ //set mapKey in the resource model, verify context model does not change
+ resourceField.addAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ assertNull(manyToManyMapping.getSpecifiedMapKeyClass());
+ MapKeyClass2_0Annotation mapKeyClassAnnotation = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ assertNotNull(mapKeyClassAnnotation);
+
+ //set mapKey name in the resource model, verify context model updated
+ mapKeyClassAnnotation.setValue("myMapKeyClass");
+ this.getJpaProject().synchronizeContextModel();
+ assertEquals("myMapKeyClass", manyToManyMapping.getSpecifiedMapKeyClass());
+ assertEquals("myMapKeyClass", mapKeyClassAnnotation.getValue());
+
+ //set mapKey name to null in the resource model
+ mapKeyClassAnnotation.setValue(null);
+ this.getJpaProject().synchronizeContextModel();
+ assertNull(manyToManyMapping.getSpecifiedMapKeyClass());
+ assertNull(mapKeyClassAnnotation.getValue());
+
+ mapKeyClassAnnotation.setValue("myMapKeyClass");
+ resourceField.removeAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ assertNull(manyToManyMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testModifyMapKeyClass() throws Exception {
+ createTestEntityWithValidManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ assertNull(manyToManyMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+
+ //set mapKey in the context model, verify resource model updated
+ manyToManyMapping.setSpecifiedMapKeyClass("String");
+ MapKeyClass2_0Annotation mapKeyClass = (MapKeyClass2_0Annotation) resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME);
+ assertEquals("String", manyToManyMapping.getSpecifiedMapKeyClass());
+ assertEquals("String", mapKeyClass.getValue());
+
+ //set mapKey to null in the context model
+ manyToManyMapping.setSpecifiedMapKeyClass(null);
+ assertNull(manyToManyMapping.getSpecifiedMapKeyClass());
+ assertNull(resourceField.getAnnotation(MapKeyClass2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testDefaultMapKeyClass() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ createTestTargetEntityAddress();
+ createTestEmbeddableState();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals("java.lang.Integer", manyToManyMapping.getDefaultMapKeyClass());
+
+ //test default still the same when specified target entity it set
+ manyToManyMapping.setSpecifiedMapKeyClass("foo");
+ assertEquals("java.lang.Integer", manyToManyMapping.getDefaultMapKeyClass());
+ }
+
+ public void testDefaultMapKeyClassCollectionType() throws Exception {
+ createTestEntityWithValidManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(manyToManyMapping.getDefaultMapKeyClass());
+ }
+
+ public void testMapKeyClass() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ assertEquals("java.lang.Integer", manyToManyMapping.getMapKeyClass());
+
+ manyToManyMapping.setSpecifiedMapKeyClass("foo");
+ assertEquals("foo", manyToManyMapping.getMapKeyClass());
+
+ manyToManyMapping.setSpecifiedMapKeyClass(null);
+ assertEquals("java.lang.Integer", manyToManyMapping.getMapKeyClass());
+ }
+
+ public void testOrderColumnDefaults() throws Exception {
+ createTestEntityPrintQueue();
+ createTestEntityPrintJob();
+
+ addXmlClassRef(PACKAGE_NAME + ".PrintQueue");
+ addXmlClassRef(PACKAGE_NAME + ".PrintJob");
+ JavaPersistentType printQueuePersistentType = (JavaPersistentType) getPersistenceUnit().getPersistentType("test.PrintQueue");
+ ManyToManyMapping jobsMapping = (ManyToManyMapping) printQueuePersistentType.getAttributeNamed("jobs").getMapping();
+ JavaPersistentType printJobPersistentType = (JavaPersistentType) getPersistenceUnit().getPersistentType("test.PrintJob");
+ ManyToManyMapping queuesMapping = (ManyToManyMapping) printJobPersistentType.getAttributeNamed("queues").getMapping();
+
+ Orderable2_0 jobsOrderable = ((Orderable2_0) jobsMapping.getOrderable());
+ OrderColumn2_0 jobsOrderColumn = jobsOrderable.getOrderColumn();
+ assertEquals(true, jobsOrderable.isOrderColumnOrdering());
+ assertEquals(null, jobsOrderColumn.getSpecifiedName());
+ assertEquals("jobs_ORDER", jobsOrderColumn.getDefaultName());
+ assertEquals("PrintJob_PrintQueue", jobsOrderColumn.getTable()); //the join table name
+ Orderable2_0 queuesOrderable = ((Orderable2_0) queuesMapping.getOrderable());
+ OrderColumn2_0 queuesOrderColumn = queuesOrderable.getOrderColumn();
+ assertEquals(true, queuesOrderable.isOrderColumnOrdering());
+ assertEquals(null, queuesOrderColumn.getSpecifiedName());
+ assertEquals("queues_ORDER", queuesOrderColumn.getDefaultName());
+ assertEquals("PrintJob_PrintQueue", queuesOrderColumn.getTable());
+
+ jobsOrderColumn.setSpecifiedName("FOO");
+ assertEquals("FOO", jobsOrderColumn.getSpecifiedName());
+ assertEquals("jobs_ORDER", jobsOrderColumn.getDefaultName());
+ assertEquals("PrintJob_PrintQueue", jobsOrderColumn.getTable());
+ queuesOrderColumn.setSpecifiedName("BAR");
+ assertEquals("BAR", queuesOrderColumn.getSpecifiedName());
+ assertEquals("queues_ORDER", queuesOrderColumn.getDefaultName());
+ assertEquals("PrintJob_PrintQueue", queuesOrderColumn.getTable());
+
+ ((Entity) printJobPersistentType.getMapping()).getTable().setSpecifiedName("MY_TABLE");
+ assertEquals("MY_TABLE_PrintQueue", jobsOrderColumn.getTable());
+ assertEquals("MY_TABLE_PrintQueue", queuesOrderColumn.getTable());
+
+ ((Entity) printQueuePersistentType.getMapping()).getTable().setSpecifiedName("OTHER_TABLE");
+ assertEquals("MY_TABLE_OTHER_TABLE", jobsOrderColumn.getTable());
+ assertEquals("MY_TABLE_OTHER_TABLE", queuesOrderColumn.getTable());
+
+ queuesMapping.getRelationship().getJoinTableStrategy().getJoinTable().setSpecifiedName("MY_JOIN_TABLE");
+ assertEquals("MY_JOIN_TABLE", jobsOrderColumn.getTable());
+ assertEquals("MY_JOIN_TABLE", queuesOrderColumn.getTable());
+ }
+
+ private void createTestEntityPrintQueue() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ENTITY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.MANY_TO_MANY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA2_0.ORDER_COLUMN);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Entity");
+ sb.append(CR);
+ sb.append("public class ").append("PrintQueue").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ sb.append(" private String name;").append(CR);
+ sb.append(CR);
+ sb.append(" @ManyToMany(mappedBy=\"queues\")").append(CR);
+ sb.append(" @OrderColumn").append(CR);
+ sb.append(" private java.util.List<PrintJob> jobs;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "PrintQueue.java", sourceWriter);
+ }
+
+ private void createTestEntityPrintJob() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ENTITY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.MANY_TO_MANY);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA2_0.ORDER_COLUMN);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Entity");
+ sb.append(CR);
+ sb.append("public class ").append("PrintJob").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ sb.append(" private int id;").append(CR);
+ sb.append(CR);
+ sb.append(" @ManyToMany").append(CR);
+ sb.append(" @OrderColumn").append(CR);
+ sb.append(" private java.util.List<PrintQueue> queues;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "PrintJob.java", sourceWriter);
+ }
+
+ public void testGetMapKeyColumnMappedByStrategy() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ createTestTargetEntityAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping();
+ manyToManyMapping.getRelationship().setStrategyToMappedBy();
+ manyToManyMapping.getRelationship().getMappedByStrategy().setMappedByAttribute("employees");
+
+ assertNull(manyToManyMapping.getMapKeyColumn().getSpecifiedName());
+ assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getName());
+ assertEquals("Address_" + TYPE_NAME, manyToManyMapping.getMapKeyColumn().getTable());//join table name of owning many-to-many
+
+ PersistentType persistentType = getPersistenceUnit().getPersistentType("test.Address");
+ ManyToManyMapping owningManyToManyMapping = (ManyToManyMapping) persistentType.getAttributeNamed("employees").getMapping();
+ ((JoinTableRelationshipStrategy) owningManyToManyMapping.getRelationship().getStrategy()).getJoinTable().setSpecifiedName("MY_JOIN_TABLE");
+ assertEquals("MY_JOIN_TABLE", manyToManyMapping.getMapKeyColumn().getTable());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyColumn2_0Annotation column = (MapKeyColumn2_0Annotation) resourceField.addAnnotation(JPA2_0.MAP_KEY_COLUMN);
+ column.setName("foo");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals("foo", manyToManyMapping.getMapKeyColumn().getSpecifiedName());
+ assertEquals("foo", manyToManyMapping.getMapKeyColumn().getName());
+ assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getDefaultName());
+ }
+
+ public void testGetMapKeyColumnJoinTableStrategy() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ createTestTargetEntityAddress();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ ManyToManyMapping2_0 manyToManyMapping = (ManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(manyToManyMapping.getMapKeyColumn().getSpecifiedName());
+ assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getName());
+ assertEquals(TYPE_NAME + "_Address", manyToManyMapping.getMapKeyColumn().getTable());//join table name
+
+ manyToManyMapping.getRelationship().getJoinTableStrategy().getJoinTable().setSpecifiedName("MY_JOIN_TABLE");
+ assertEquals("MY_JOIN_TABLE", manyToManyMapping.getMapKeyColumn().getTable());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyColumn2_0Annotation column = (MapKeyColumn2_0Annotation) resourceField.addAnnotation(JPA2_0.MAP_KEY_COLUMN);
+ column.setName("foo");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals("foo", manyToManyMapping.getMapKeyColumn().getSpecifiedName());
+ assertEquals("foo", manyToManyMapping.getMapKeyColumn().getName());
+ assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getDefaultName());
+ }
+
+ public void testMapKeySpecifiedAttributeOverrides() throws Exception {
+ createTestEntityWithEmbeddableKeyManyToManyMapping();
+ createTestEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEntityPropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+
+ ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("value.BAR");
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAZ");
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BLAH");
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ //move an annotation to the resource model and verify the context model is updated
+ resourceField.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+ assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+ resourceField.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ getJpaProject().synchronizeContextModel();
+ specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+ }
+
+ public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+ createTestEntityWithEmbeddableKeyManyToManyMapping();
+ createTestEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEntityPropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ assertEquals("parcels", resourceField.getName());
+ assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME));
+
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ ReadOnlyAttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("city", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ ListIterator<ClassRef> classRefs = getPersistenceUnit().getSpecifiedClassRefs().iterator();
+ classRefs.next();
+ Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+
+ BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+ cityMapping.getColumn().setSpecifiedName("FOO");
+ cityMapping.getColumn().setSpecifiedTable("BAR");
+ cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+ cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+ cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+ cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+ cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+ cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+
+ assertEquals("parcels", resourceField.getName());
+ assertEquals(0, resourceField.getAnnotationsSize(AttributeOverrideAnnotation.ANNOTATION_NAME));
+
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+ assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+ assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+ cityMapping.getColumn().setSpecifiedName(null);
+ cityMapping.getColumn().setSpecifiedTable(null);
+ cityMapping.getColumn().setColumnDefinition(null);
+ cityMapping.getColumn().setSpecifiedInsertable(null);
+ cityMapping.getColumn().setSpecifiedUpdatable(null);
+ cityMapping.getColumn().setSpecifiedUnique(null);
+ cityMapping.getColumn().setSpecifiedNullable(null);
+ cityMapping.getColumn().setSpecifiedLength(null);
+ cityMapping.getColumn().setSpecifiedPrecision(null);
+ cityMapping.getColumn().setSpecifiedScale(null);
+ defaultAttributeOverride = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next();
+ assertEquals("city", defaultAttributeOverride.getName());
+ assertEquals("city", defaultAttributeOverride.getColumn().getName());
+ assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+ assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+ assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+ assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+ assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+ assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+ assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+ assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+ assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+
+ AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ annotation.setName("key.city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+ public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+ createTestEntityWithEmbeddableKeyManyToManyMapping();
+ createTestEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEntityPropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+ assertEquals(0, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAR");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("value.FOO2");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(3, mapKeyAttributeOverrideContainer.getSpecifiedOverridesSize());
+ }
+
+ public void testMapKeyValueAttributeOverridesSize() throws Exception {
+ createTestEntityWithEmbeddableKeyManyToManyMapping();
+ createTestEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEntityPropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+ assertEquals(4, mapKeyAttributeOverrideContainer.getOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAR");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("value.FOO2");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(7, mapKeyAttributeOverrideContainer.getOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(7, mapKeyAttributeOverrideContainer.getOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.state.foo");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(7, mapKeyAttributeOverrideContainer.getOverridesSize());
+ }
+
+ public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+ createTestEntityWithEmbeddableKeyManyToManyMapping();
+ createTestEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEntityPropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ //add an annotation to the resource model and verify the context model is updated
+ AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("FOO");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.BAR");
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.city");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(3, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("key.state.foo");
+ attributeOverride = (AttributeOverrideAnnotation) resourceField.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE);
+ attributeOverride.setName("size");
+ getJpaProject().synchronizeContextModel();
+ assertEquals(2, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+ public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+ createTestEntityWithEmbeddableKeyManyToManyMapping();
+ createTestEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEntityPropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ Iterator<NestableAnnotation> attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+ assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator().next().convertToVirtual();
+ attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+ assertFalse(attributeOverrides.hasNext());
+
+ Iterator<JavaVirtualAttributeOverride> virtualAttributeOverrides = mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator();
+ assertEquals("city", virtualAttributeOverrides.next().getName());
+ assertEquals("state.foo", virtualAttributeOverrides.next().getName());
+ assertEquals("state.address", virtualAttributeOverrides.next().getName());
+ assertEquals("zip", virtualAttributeOverrides.next().getName());
+ assertEquals(4, mapKeyAttributeOverrideContainer.getVirtualOverridesSize());
+ }
+
+
+ public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+ createTestEntityWithEmbeddableKeyManyToManyMapping();
+ createTestEmbeddableAddress();
+ createTestEmbeddableState();
+ createTestEntityPropertyInfo();
+
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+ addXmlClassRef(PACKAGE_NAME + ".Address");
+ addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+ addXmlClassRef(PACKAGE_NAME + ".State");
+
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+ JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+ mapKeyAttributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ ListIterator<JavaAttributeOverride> specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("city", specifiedOverrides.next().getName());
+ assertEquals("state.foo", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+
+ resourceField.moveAnnotation(1, 0, AttributeOverrideAnnotation.ANNOTATION_NAME);
+ getJpaProject().synchronizeContextModel();
+
+ Iterator<NestableAnnotation> attributeOverrides = resourceField.getAnnotations(AttributeOverrideAnnotation.ANNOTATION_NAME).iterator();
+
+ assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ specifiedOverrides = mapKeyAttributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("state.foo", specifiedOverrides.next().getName());
+ assertEquals("city", specifiedOverrides.next().getName());
+ assertFalse(specifiedOverrides.hasNext());
+ }
+
+ public void testSetSpecifiedMapKeyEnumerated() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping();
+ assertNull(manyToManyMapping.getMapKeyConverter().getType());
+
+ manyToManyMapping.setMapKeyConverter(BaseEnumeratedConverter.class);
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME);
+
+ assertNotNull(enumerated);
+ assertEquals(null, enumerated.getValue());
+
+ ((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.STRING);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING, enumerated.getValue());
+
+ ((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).setSpecifiedEnumType(null);
+ assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME));
+ assertNull(enumerated.getValue());
+
+ manyToManyMapping.setMapKeyConverter(null);
+ assertNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testGetSpecifiedMapKeyEnumeratedUpdatesFromResourceModelChange() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(manyToManyMapping.getMapKeyConverter().getType());
+
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyEnumerated2_0Annotation enumerated = (MapKeyEnumerated2_0Annotation) resourceField.addAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME);
+ enumerated.setValue(org.eclipse.jpt.jpa.core.resource.java.EnumType.STRING);
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).getSpecifiedEnumType());
+
+ enumerated.setValue(null);
+ getJpaProject().synchronizeContextModel();
+ assertNotNull(resourceField.getAnnotation(MapKeyEnumerated2_0Annotation.ANNOTATION_NAME));
+ assertNull(((BaseEnumeratedConverter) manyToManyMapping.getMapKeyConverter()).getSpecifiedEnumType());
+ assertFalse(manyToManyMapping.isDefault());
+ assertSame(manyToManyMapping, persistentAttribute.getMapping());
+ }
+
+ public void testSetMapKeyTemporal() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping();
+ assertNull(manyToManyMapping.getMapKeyConverter().getType());
+
+ manyToManyMapping.setMapKeyConverter(BaseTemporalConverter.class);
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME);
+
+ assertNotNull(temporal);
+ assertEquals(null, temporal.getValue());
+
+ ((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).setTemporalType(TemporalType.TIME);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME, temporal.getValue());
+
+ ((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).setTemporalType(null);
+ assertNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME));
+ }
+
+ public void testGetMapKeyTemporalUpdatesFromResourceModelChange() throws Exception {
+ createTestEntityWithValidGenericMapManyToManyMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistentAttribute persistentAttribute = getJavaPersistentType().getAttributes().iterator().next();
+ JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) persistentAttribute.getMapping();
+
+ assertNull(manyToManyMapping.getMapKeyConverter().getType());
+
+
+ JavaResourceType resourceType = (JavaResourceType) getJpaProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME, Kind.TYPE);
+ JavaResourceField resourceField = resourceType.getFields().iterator().next();
+ MapKeyTemporal2_0Annotation temporal = (MapKeyTemporal2_0Annotation) resourceField.addAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME);
+ temporal.setValue(org.eclipse.jpt.jpa.core.resource.java.TemporalType.TIME);
+ getJpaProject().synchronizeContextModel();
+
+ assertEquals(TemporalType.TIME, ((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).getTemporalType());
+
+ temporal.setValue(null);
+ getJpaProject().synchronizeContextModel();
+ assertNotNull(resourceField.getAnnotation(MapKeyTemporal2_0Annotation.ANNOTATION_NAME));
+ assertNull(((BaseTemporalConverter) manyToManyMapping.getMapKeyConverter()).getTemporalType());
+ assertFalse(manyToManyMapping.isDefault());
+ assertSame(manyToManyMapping, persistentAttribute.getMapping());
+ }
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java
new file mode 100644
index 0000000000..d337783f5b
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink1_1OrmPersistentAttributeTests.java
@@ -0,0 +1,435 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2012 Oracle. 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:
+ * Oracle - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.orm;
+
+import java.util.Iterator;
+import java.util.ListIterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceAttribute;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceField;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceAnnotatedElement.Kind;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jpa.core.MappingKeys;
+import org.eclipse.jpt.jpa.core.context.AccessType;
+import org.eclipse.jpt.jpa.core.context.BasicMapping;
+import org.eclipse.jpt.jpa.core.context.IdMapping;
+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.orm.OrmPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.resource.java.JPA;
+import org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm.OrmEclipseLinkIdMapping;
+import org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm.OrmEclipseLinkOneToOneMapping;
+import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink1_1ContextModelTestCase;
+
+@SuppressWarnings("nls")
+public class EclipseLink1_1OrmPersistentAttributeTests
+ extends EclipseLink1_1ContextModelTestCase
+{
+ public EclipseLink1_1OrmPersistentAttributeTests(String name) {
+ super(name);
+ }
+
+
+ private ICompilationUnit createTestTypeNullAttributeMapping() throws Exception {
+
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" private Address address;").append(CR);
+ sb.append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityIdMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ID, JPA.COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity");
+ }
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Id");
+ sb.append("@Column(name=\"FOO\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityIdMappingPropertyAccess() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ID, JPA.COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity");
+ }
+ @Override
+ public void appendGetIdMethodAnnotationTo(StringBuilder sb) {
+ sb.append("@Id");
+ sb.append("@Column(name=\"FOO\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityOneToOneMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ONE_TO_ONE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity");
+ }
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@OneToOne");
+ sb.append(" private Address address;");
+ }
+ });
+ }
+
+ public void testMakeSpecified() throws Exception {
+ createTestType();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ assertEquals(2, ormPersistentType.getDefaultAttributesSize());
+
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ assertEquals("id", ormPersistentAttribute.getName());
+ assertTrue(ormPersistentAttribute.isVirtual());
+ ormPersistentAttribute.addToXml();
+
+ assertEquals(1, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next();
+ assertEquals("id", specifiedOrmPersistentAttribute.getName());
+ assertFalse(specifiedOrmPersistentAttribute.isVirtual());
+
+ ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ ormPersistentAttribute.addToXml();
+
+ assertEquals(0, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(2, ormPersistentType.getSpecifiedAttributesSize());
+ Iterator<OrmPersistentAttribute> specifiedAttributes = ormPersistentType.getSpecifiedAttributes().iterator();
+ specifiedOrmPersistentAttribute = specifiedAttributes.next();
+ assertEquals("id", specifiedOrmPersistentAttribute.getName());
+ assertFalse(specifiedOrmPersistentAttribute.isVirtual());
+
+ specifiedOrmPersistentAttribute = specifiedAttributes.next();
+ assertEquals("name", specifiedOrmPersistentAttribute.getName());
+ assertFalse(specifiedOrmPersistentAttribute.isVirtual());
+ }
+
+ public void testMakeSpecifiedMappingKey() throws Exception {
+ createTestTypeNullAttributeMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ assertEquals(3, ormPersistentType.getDefaultAttributesSize());
+
+ //take a virtual mapping with a mapping type and make it specified
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ assertEquals("address", ormPersistentAttribute.getName());
+ assertTrue(ormPersistentAttribute.isVirtual());
+ assertNull(ormPersistentAttribute.getMapping().getKey());
+ ormPersistentAttribute.addToXml(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
+
+ assertEquals(2, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next();
+ assertEquals("address", specifiedOrmPersistentAttribute.getName());
+ assertFalse(specifiedOrmPersistentAttribute.isVirtual());
+ assertTrue(specifiedOrmPersistentAttribute.getMapping() instanceof OrmEclipseLinkOneToOneMapping);
+
+
+ ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ ormPersistentAttribute.addToXml(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY);
+
+ assertEquals(1, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(2, ormPersistentType.getSpecifiedAttributesSize());
+ Iterator<OrmPersistentAttribute> specifiedAttributes = ormPersistentType.getSpecifiedAttributes().iterator();
+
+ specifiedOrmPersistentAttribute = specifiedAttributes.next();
+ assertEquals("id", specifiedOrmPersistentAttribute.getName());
+ assertFalse(specifiedOrmPersistentAttribute.isVirtual());
+ assertTrue(specifiedOrmPersistentAttribute.getMapping() instanceof OrmEclipseLinkIdMapping);
+
+ specifiedOrmPersistentAttribute = specifiedAttributes.next();
+ assertEquals("address", specifiedOrmPersistentAttribute.getName());
+ assertFalse(specifiedOrmPersistentAttribute.isVirtual());
+ }
+
+ public void testMakeVirtual() throws Exception {
+ createTestType();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ assertEquals(2, ormPersistentType.getDefaultAttributesSize());
+
+ ormPersistentType.getDefaultAttributes().iterator().next().addToXml();
+ ormPersistentType.getDefaultAttributes().iterator().next().addToXml();
+
+ assertEquals(0, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(2, ormPersistentType.getSpecifiedAttributesSize());
+ OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next();
+ assertEquals("id", specifiedOrmPersistentAttribute.getName());
+ assertFalse(specifiedOrmPersistentAttribute.isVirtual());
+
+ specifiedOrmPersistentAttribute.removeFromXml();
+ assertEquals(1, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+
+ specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next();
+ specifiedOrmPersistentAttribute.removeFromXml();
+ assertEquals(2, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(0, ormPersistentType.getSpecifiedAttributesSize());
+
+ Iterator<OrmReadOnlyPersistentAttribute> virtualAttributes = ormPersistentType.getDefaultAttributes().iterator();
+ OrmReadOnlyPersistentAttribute virtualAttribute = virtualAttributes.next();
+ assertEquals("id", virtualAttribute.getName());
+ virtualAttribute = virtualAttributes.next();
+ assertEquals("name", virtualAttribute.getName());
+ }
+
+ public void testMakeVirtualNoUnderlyingJavaAttribute() throws Exception {
+ createTestType();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ assertEquals(2, ormPersistentType.getDefaultAttributesSize());
+
+ ormPersistentType.getDefaultAttributes().iterator().next().addToXml();
+ ormPersistentType.getDefaultAttributes().iterator().next().addToXml();
+
+
+ ormPersistentType.getSpecifiedAttributes().iterator().next().getMapping().setName("noJavaAttribute");
+ assertEquals(1, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(2, ormPersistentType.getSpecifiedAttributesSize());
+
+
+ OrmPersistentAttribute specifiedOrmPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next();
+ specifiedOrmPersistentAttribute.removeFromXml();
+ assertEquals(1, ormPersistentType.getDefaultAttributesSize());
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+
+ assertEquals("id", ormPersistentType.getDefaultAttributes().iterator().next().getName());
+ assertEquals("name", ormPersistentType.getSpecifiedAttributes().iterator().next().getName());
+ }
+
+ public void testVirtualMappingTypeWhenMetadataComplete() throws Exception {
+ createTestEntityIdMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ assertEquals("id", ormPersistentAttribute.getName());
+ assertEquals(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey());
+ assertEquals("FOO", ((IdMapping) ormPersistentAttribute.getMapping()).getColumn().getName());
+
+
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+
+ ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ assertEquals("id", ormPersistentAttribute.getName());
+ assertEquals(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey());
+ assertEquals("id", ((BasicMapping) ormPersistentAttribute.getMapping()).getColumn().getName());
+ }
+
+ public void testVirtualMappingTypeWhenMetadataComplete2() throws Exception {
+ createTestEntityOneToOneMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ assertEquals("address", ormPersistentAttribute.getName());
+ assertEquals(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey());
+
+
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+
+ ormPersistentAttribute = ormPersistentType.getAttributeNamed("address");
+ assertEquals("address", ormPersistentAttribute.getName());
+ assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey());
+ }
+
+ public void testGetJavaPersistentAttribute() throws Exception {
+ createTestEntityIdMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType();
+
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id");
+
+ //virtual orm attribute, access type matches java : FIELD, name matches java
+ assertTrue(ormPersistentAttribute.isVirtual());
+ assertNotSame(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute());
+ JavaResourceAttribute javaResourceAttribute = ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute();
+ assertTrue(javaResourceAttribute instanceof JavaResourceField);
+ assertEquals("id", javaResourceAttribute.getName());
+ assertEquals(javaPersistentType.getJavaResourceType().getFields().iterator().next(), javaResourceAttribute);
+
+
+ //specified orm attribute, access type matches java : FIELD, name matches java
+ //javaPersistentAttribute should be == to java context model object
+ ormPersistentAttribute.addToXml();
+ ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ assertFalse(ormPersistentAttribute.isVirtual());
+ assertEquals(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute());
+
+
+ //virtual orm attribute, java access type FIELD, orm access type PROPERTY, name matches java
+ //verify both the property java resource attribute and the field java resource attribute are used in orm
+ //because the field is annotated and property is specified
+ ((OrmPersistentAttribute) ormPersistentAttribute).removeFromXml();
+ ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ ormPersistentType.setSpecifiedAccess(AccessType.PROPERTY);
+ ListIterator<OrmReadOnlyPersistentAttribute> attributes = ormPersistentType.getAttributes().iterator();
+ OrmReadOnlyPersistentAttribute idFieldAttribute = attributes.next();
+ OrmReadOnlyPersistentAttribute idPropertyAttribute = attributes.next();
+ assertEquals(ormPersistentAttribute, idFieldAttribute);
+ assertNotSame(ormPersistentAttribute, idPropertyAttribute);
+ ormPersistentAttribute = idPropertyAttribute;
+ assertNotSame(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute());
+ assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess());
+ assertEquals(AccessType.PROPERTY, ormPersistentAttribute.getJavaPersistentAttribute().getAccess());
+ assertEquals(AccessType.FIELD, idFieldAttribute.getJavaPersistentAttribute().getAccess());
+ javaResourceAttribute = ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute();
+ assertEquals("id", javaResourceAttribute.getName());
+ assertEquals(javaPersistentType.getJavaResourceType().getMethods().iterator().next(), javaResourceAttribute);
+
+
+ ormPersistentType.setSpecifiedAccess(null);//default access will be field
+ ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ OrmPersistentAttribute ormPersistentAttribute2 = ormPersistentAttribute.addToXml();
+ ormPersistentAttribute2.getMapping().setName("id2");
+ assertEquals(null, ormPersistentAttribute2.getJavaPersistentAttribute());
+
+ ormPersistentAttribute2.getMapping().setName(null);
+ assertEquals(null, ormPersistentAttribute2.getJavaPersistentAttribute());
+
+ ormPersistentAttribute2.getMapping().setName("id");
+ assertEquals(javaPersistentAttribute, ormPersistentAttribute2.getJavaPersistentAttribute());
+
+
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+ assertEquals(javaPersistentAttribute, ormPersistentAttribute2.getJavaPersistentAttribute());
+ }
+
+ public void testGetJavaPersistentAttributeMixedAccess() throws Exception {
+ createTestEntityIdMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ ormPersistentType.setSpecifiedAccess(AccessType.PROPERTY);
+ JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType();
+
+ ListIterator<OrmReadOnlyPersistentAttribute> attributes = ormPersistentType.getAttributes().iterator();
+ OrmReadOnlyPersistentAttribute ormFieldAttribute = attributes.next();
+ OrmReadOnlyPersistentAttribute ormPropertyAttribute = attributes.next();
+ JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id");
+
+ assertEquals(AccessType.FIELD, ormFieldAttribute.getAccess());
+ assertEquals(AccessType.PROPERTY, ormPropertyAttribute.getAccess());
+ assertEquals(AccessType.FIELD, javaPersistentAttribute.getOwningPersistentType().getAccess());
+ assertTrue(ormFieldAttribute.isVirtual());
+ assertTrue(ormPropertyAttribute.isVirtual());
+ assertNotSame(javaPersistentAttribute, ormPropertyAttribute.getJavaPersistentAttribute());
+ assertEquals(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY, ormFieldAttribute.getMappingKey());
+ assertEquals(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY, ormPropertyAttribute.getMappingKey());
+ assertEquals(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY, javaPersistentAttribute.getMappingKey());
+
+
+ ormPropertyAttribute.addToXml();
+ ormPropertyAttribute = ormPersistentType.getAttributeNamed("id");
+ assertFalse(ormPropertyAttribute.isVirtual());
+ assertEquals(AccessType.PROPERTY, ormPropertyAttribute.getAccess());
+ assertNotSame(javaPersistentAttribute, ormPropertyAttribute.getJavaPersistentAttribute());
+ assertTrue(ormPropertyAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.METHOD);
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD);
+
+ ((OrmPersistentAttribute) ormPropertyAttribute).setSpecifiedAccess(AccessType.FIELD);
+ ormPropertyAttribute = ormPersistentType.getAttributeNamed("id");
+ assertFalse(ormPropertyAttribute.isVirtual());
+ assertEquals(AccessType.FIELD, ormPropertyAttribute.getAccess());
+ assertEquals(javaPersistentAttribute, ormPropertyAttribute.getJavaPersistentAttribute());
+ assertTrue(ormPropertyAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.FIELD);
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD);
+ }
+
+ public void testGetAccess() throws Exception {
+ createTestEntityIdMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType();
+
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id");
+
+ assertTrue(ormPersistentAttribute.isVirtual());
+ assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess());
+ assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.FIELD);
+ assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess());
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD);
+
+
+ ormPersistentAttribute.addToXml();
+ ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ assertFalse(ormPersistentAttribute.isVirtual());
+ assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess());
+ assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.FIELD);
+ assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess());
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD);
+
+
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+ assertFalse(ormPersistentAttribute.isVirtual());
+ assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess());
+ assertEquals(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute());
+ assertEquals(AccessType.FIELD, ormPersistentAttribute.getJavaPersistentAttribute().getAccess());
+ assertEquals(AccessType.FIELD, javaPersistentAttribute.getAccess());
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.FIELD);
+ }
+
+ public void testGetAccessPropertyInJava() throws Exception {
+ createTestEntityIdMappingPropertyAccess();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType();
+
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ JavaPersistentAttribute javaPersistentAttribute = javaPersistentType.getAttributeNamed("id");
+
+ assertTrue(ormPersistentAttribute.isVirtual());
+ assertEquals(AccessType.PROPERTY, ormPersistentAttribute.getAccess());
+ assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.METHOD);
+ assertEquals(AccessType.PROPERTY, javaPersistentAttribute.getAccess());
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.METHOD);
+
+
+ ormPersistentAttribute.addToXml();
+ ormPersistentAttribute = ormPersistentType.getAttributeNamed("id");
+ assertFalse(ormPersistentAttribute.isVirtual());
+ assertEquals(AccessType.PROPERTY, ormPersistentAttribute.getAccess());
+ assertTrue(ormPersistentAttribute.getJavaPersistentAttribute().getResourceAttribute().getKind() == Kind.METHOD);
+ assertEquals(AccessType.PROPERTY, javaPersistentAttribute.getAccess());
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.METHOD);
+
+
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+ assertFalse(ormPersistentAttribute.isVirtual());
+ assertEquals(AccessType.FIELD, ormPersistentAttribute.getAccess());
+ assertNotSame(javaPersistentAttribute, ormPersistentAttribute.getJavaPersistentAttribute());
+ assertEquals(AccessType.FIELD, ormPersistentAttribute.getJavaPersistentAttribute().getAccess());
+ assertEquals(AccessType.PROPERTY, javaPersistentAttribute.getAccess());
+ assertTrue(javaPersistentAttribute.getResourceAttribute().getKind() == Kind.METHOD);
+ }
+
+} \ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java
new file mode 100644
index 0000000000..9dccb43689
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_0OrmElementCollectionMappingTests.java
@@ -0,0 +1,1703 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2012 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.orm;
+
+import java.util.Iterator;
+import java.util.ListIterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject.SourceWriter;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jpa.core.MappingKeys;
+import org.eclipse.jpt.jpa.core.context.AttributeOverride;
+import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
+import org.eclipse.jpt.jpa.core.context.BasicMapping;
+import org.eclipse.jpt.jpa.core.context.Column;
+import org.eclipse.jpt.jpa.core.context.EmbeddedIdMapping;
+import org.eclipse.jpt.jpa.core.context.EmbeddedMapping;
+import org.eclipse.jpt.jpa.core.context.EnumType;
+import org.eclipse.jpt.jpa.core.context.BaseEnumeratedConverter;
+import org.eclipse.jpt.jpa.core.context.FetchType;
+import org.eclipse.jpt.jpa.core.context.IdMapping;
+import org.eclipse.jpt.jpa.core.context.ManyToManyMapping;
+import org.eclipse.jpt.jpa.core.context.ManyToOneMapping;
+import org.eclipse.jpt.jpa.core.context.OneToManyMapping;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn;
+import org.eclipse.jpt.jpa.core.context.BaseTemporalConverter;
+import org.eclipse.jpt.jpa.core.context.TemporalType;
+import org.eclipse.jpt.jpa.core.context.TransientMapping;
+import org.eclipse.jpt.jpa.core.context.VersionMapping;
+import org.eclipse.jpt.jpa.core.context.VirtualAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.java.JavaBasicMapping;
+import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverrideContainer;
+import org.eclipse.jpt.jpa.core.context.orm.OrmColumn;
+import org.eclipse.jpt.jpa.core.context.orm.OrmEntity;
+import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.ElementCollectionMapping2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.OrderColumn2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaElementCollectionMapping2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmElementCollectionMapping2_0;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0;
+import org.eclipse.jpt.jpa.core.resource.java.JPA;
+import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
+import org.eclipse.jpt.jpa.core.resource.orm.XmlElementCollection;
+import org.eclipse.jpt.jpa.core.resource.orm.v2_0.XmlElementCollection_2_0;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConvert;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkElementCollectionMapping2_0;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlConvertibleMapping;
+import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_0ContextModelTestCase;
+
+@SuppressWarnings("nls")
+public class EclipseLink2_0OrmElementCollectionMappingTests
+ extends EclipseLink2_0ContextModelTestCase
+{
+ private static final String ATTRIBUTE_OVERRIDE_NAME = "city";
+ private static final String ATTRIBUTE_OVERRIDE_COLUMN_NAME = "E_CITY";
+
+ public EclipseLink2_0OrmElementCollectionMappingTests(String name) {
+ super(name);
+ }
+
+ private ICompilationUnit createTestEntityWithElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.FETCH_TYPE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity");
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection(targetClass=String.class, fetch=FetchType.EAGER)");
+ sb.append(CR);
+ sb.append(" private java.util.Collection<Address> address;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id");
+ }
+ });
+ }
+
+ private void createTestTargetEmbeddableAddress() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.ID);
+ sb.append(";");
+ sb.append(CR);
+ sb.append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("Address").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private String city;").append(CR);
+ sb.append(CR);
+ sb.append(" private State state;").append(CR);
+ sb.append(CR);
+ sb.append(" private int zip;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+ }
+
+ private ICompilationUnit createTestEntityWithEmbeddableElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.FETCH_TYPE, JPA.ATTRIBUTE_OVERRIDE, JPA.COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity");
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection");
+ sb.append(CR);
+ sb.append(" @AttributeOverride(name=\"" + ATTRIBUTE_OVERRIDE_NAME + "\", column=@Column(name=\"" + ATTRIBUTE_OVERRIDE_COLUMN_NAME + "\"))");
+ sb.append(" private java.util.Collection<Address> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithNonGenericElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Collection addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithGenericBasicElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Collection<String> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithValidMapElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Map<String, Address> addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private void createTestEmbeddableState() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("State").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" private String name;").append(CR);
+ sb.append(CR);
+ sb.append(" private String abbr;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
+ }
+
+ private ICompilationUnit createTestEntityWithValidNonGenericMapElementCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.Map addresses;").append(CR);
+ sb.append(CR);
+ sb.append(" @Id").append(CR);
+ }
+ });
+ }
+
+ private void createSelfReferentialElementCollection() throws Exception {
+ SourceWriter sourceWriter = new SourceWriter() {
+ public void appendSourceTo(StringBuilder sb) {
+ sb.append("import ");
+ sb.append(JPA.EMBEDDABLE);
+ sb.append(";");
+ sb.append(CR);
+ sb.append("import ");
+ sb.append(JPA2_0.ELEMENT_COLLECTION);
+ sb.append(";");
+ sb.append(CR).append(CR);
+ sb.append("@Embeddable");
+ sb.append(CR);
+ sb.append("public class ").append("Foo").append(" ");
+ sb.append("{").append(CR);
+ sb.append(CR);
+ sb.append(" @ElementCollection").append(CR);
+ sb.append(" private java.util.List<Foo> elementCollection;").append(CR);
+ sb.append(CR);
+ sb.append("}").append(CR);
+ }
+ };
+ this.javaProject.createCompilationUnit(PACKAGE_NAME, "Foo.java", sourceWriter);
+ }
+
+ private ICompilationUnit createTestTypeWithCollection() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>("java.util.Collection");
+ }
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append(" private Collection<String> elementCollection;").append(CR);
+ }
+ });
+ }
+
+ public void testUpdateName() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertEquals("elementCollection", ormElementCollectionMapping.getName());
+ assertEquals("elementCollection", elementCollection.getName());
+
+ //set name in the resource model, verify context model updated
+ elementCollection.setName("newName");
+ assertEquals("newName", ormElementCollectionMapping.getName());
+ assertEquals("newName", elementCollection.getName());
+
+ //set name to null in the resource model
+ elementCollection.setName(null);
+ assertNull(ormElementCollectionMapping.getName());
+ assertNull(elementCollection.getName());
+ }
+
+ public void testModifyName() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertEquals("elementCollection", ormElementCollectionMapping.getName());
+ assertEquals("elementCollection", elementCollection.getName());
+
+ //set name in the context model, verify resource model updated
+ ormElementCollectionMapping.setName("newName");
+ assertEquals("newName", ormElementCollectionMapping.getName());
+ assertEquals("newName", elementCollection.getName());
+
+ //set name to null in the context model
+ ormElementCollectionMapping.setName(null);
+ assertNull(ormElementCollectionMapping.getName());
+ assertNull(elementCollection.getName());
+ }
+
+ public void testMappingNoUnderylingJavaAttribute() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("address"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ ormPersistentAttribute.getMapping().setName("foo");
+
+ assertEquals(3, ormPersistentType.getDefaultAttributesSize());
+
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ assertEquals("foo", ormElementCollectionMapping.getName());
+
+ assertNull(ormElementCollectionMapping.getSpecifiedFetch());
+ assertEquals(FetchType.LAZY, ormElementCollectionMapping.getFetch());
+ }
+
+
+ public void testVirtualMappingMetadataCompleteFalse() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ assertEquals(3, ormPersistentType.getDefaultAttributesSize());
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+
+ ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertEquals("address", virtualElementCollectionMapping.getName());
+ assertEquals(FetchType.EAGER, virtualElementCollectionMapping.getSpecifiedFetch());
+ assertEquals("String", virtualElementCollectionMapping.getSpecifiedTargetClass());
+
+ ormPersistentAttribute.addToXml();
+ ormPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next();
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertEquals("address", ormElementCollectionMapping.getName());
+ assertEquals(null, ormElementCollectionMapping.getSpecifiedFetch());
+ assertEquals(FetchType.LAZY, ormElementCollectionMapping.getDefaultFetch());
+ assertEquals(null, ormElementCollectionMapping.getSpecifiedTargetClass());
+ assertEquals(PACKAGE_NAME + ".Address", ormElementCollectionMapping.getDefaultTargetClass());
+ }
+
+ public void testVirtualMappingMetadataCompleteTrue() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+ assertEquals(3, ormPersistentType.getDefaultAttributesSize());
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = ormPersistentType.getAttributeNamed("address");
+
+ assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, ormPersistentAttribute.getMappingKey());
+
+ ormPersistentAttribute.addToXml(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ ormPersistentAttribute= ormPersistentType.getSpecifiedAttributes().iterator().next();
+
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertEquals("address", ormElementCollectionMapping.getName());
+ assertEquals(FetchType.LAZY, ormElementCollectionMapping.getFetch());
+ }
+
+ public void testSpecifiedMapping() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+
+ ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("address"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(2, ormPersistentType.getDefaultAttributesSize());
+
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.getSpecifiedAttributes().iterator().next();
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ assertEquals("address", ormElementCollectionMapping.getName());
+ assertNull(ormElementCollectionMapping.getSpecifiedFetch());
+ assertEquals(FetchType.LAZY, ormElementCollectionMapping.getFetch());
+ }
+
+
+ public void testMorphToIdMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof IdMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+ }
+
+ public void testMorphToVersionMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof VersionMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+ }
+
+ public void testMorphToTransientMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof TransientMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+ }
+
+ public void testMorphToEmbeddedMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof EmbeddedMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+ }
+
+ public void testMorphToEmbeddedIdMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof EmbeddedIdMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+ }
+
+ public void testMorphToManyToManyMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof ManyToManyMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+// assertEquals(FetchType.EAGER, ((ManyToManyMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch());
+ }
+
+ public void testMorphToOneToManyMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof OneToManyMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+// assertEquals(FetchType.EAGER, ((OneToManyMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch());
+ }
+
+ public void testMorphToManyToOneMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof ManyToOneMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+// assertEquals(FetchType.EAGER, ((ManyToOneMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch());
+ }
+
+ public void testMorphToBasicMapping() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ assertFalse(elementCollectionMapping.isDefault());
+ elementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertFalse(elementCollectionMapping.isDefault());
+
+ ormPersistentAttribute.setMappingKey(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY);
+ assertEquals(1, ormPersistentType.getSpecifiedAttributesSize());
+ assertEquals(ormPersistentAttribute, ormPersistentType.getSpecifiedAttributes().iterator().next());
+ assertTrue(ormPersistentAttribute.getMapping() instanceof BasicMapping);
+ assertEquals("elementCollection", ormPersistentAttribute.getMapping().getName());
+//TODO assertEquals(FetchType.EAGER, ((IBasicMapping) ormPersistentAttribute.getMapping()).getSpecifiedFetch());
+ }
+
+ public void testUpdateSpecifiedFetch() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedFetch());
+ assertNull(elementCollection.getFetch());
+
+ //set fetch in the resource model, verify context model updated
+ elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.orm.FetchType.EAGER);
+ assertEquals(FetchType.EAGER, ormElementCollectionMapping.getSpecifiedFetch());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.EAGER, elementCollection.getFetch());
+
+ elementCollection.setFetch(org.eclipse.jpt.jpa.core.resource.orm.FetchType.LAZY);
+ assertEquals(FetchType.LAZY, ormElementCollectionMapping.getSpecifiedFetch());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.LAZY, elementCollection.getFetch());
+
+ //set fetch to null in the resource model
+ elementCollection.setFetch(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedFetch());
+ assertNull(elementCollection.getFetch());
+ }
+
+ public void testModifySpecifiedFetch() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedFetch());
+ assertNull(elementCollection.getFetch());
+
+ //set fetch in the context model, verify resource model updated
+ ormElementCollectionMapping.setSpecifiedFetch(FetchType.EAGER);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.EAGER, elementCollection.getFetch());
+ assertEquals(FetchType.EAGER, ormElementCollectionMapping.getSpecifiedFetch());
+
+ ormElementCollectionMapping.setSpecifiedFetch(FetchType.LAZY);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.FetchType.LAZY, elementCollection.getFetch());
+ assertEquals(FetchType.LAZY, ormElementCollectionMapping.getSpecifiedFetch());
+
+ //set fetch to null in the context model
+ ormElementCollectionMapping.setSpecifiedFetch(null);
+ assertNull(elementCollection.getFetch());
+ assertNull(ormElementCollectionMapping.getSpecifiedFetch());
+ }
+
+ public void testUpdateSpecifiedTargetClass() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection_2_0 elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollection.getTargetClass());
+
+ //set target class in the resource model, verify context model updated
+ elementCollection.setTargetClass("newTargetClass");
+ assertEquals("newTargetClass", ormElementCollectionMapping.getSpecifiedTargetClass());
+ assertEquals("newTargetClass", elementCollection.getTargetClass());
+
+ //set target class to null in the resource model
+ elementCollection.setTargetClass(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollection.getTargetClass());
+ }
+
+ public void testModifySpecifiedTargetClass() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection_2_0 elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollection.getTargetClass());
+
+ //set target class in the context model, verify resource model updated
+ ormElementCollectionMapping.setSpecifiedTargetClass("newTargetClass");
+ assertEquals("newTargetClass", ormElementCollectionMapping.getSpecifiedTargetClass());
+ assertEquals("newTargetClass", elementCollection.getTargetClass());
+
+ //set target class to null in the context model
+ ormElementCollectionMapping.setSpecifiedTargetClass(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedTargetClass());
+ assertNull(elementCollection.getTargetClass());
+ }
+
+
+ public void testGetValueTypeEmbeddable() throws Exception {
+ createTestEntityWithEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, "test.Address");
+
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType());
+ }
+
+ public void testGetValueTypeEntity() throws Exception {
+ createTestEntityWithEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.Address");
+
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ assertEquals(ElementCollectionMapping2_0.Type.BASIC_TYPE, elementCollectionMapping.getValueType());
+ }
+
+ public void testGetValueTypeNone() throws Exception {
+ createTestEntityWithNonGenericElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, "test.Address");
+
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ assertEquals(ElementCollectionMapping2_0.Type.NO_TYPE, elementCollectionMapping.getValueType());
+
+ elementCollectionMapping.setSpecifiedTargetClass("test.Address");
+ assertEquals(ElementCollectionMapping2_0.Type.EMBEDDABLE_TYPE, elementCollectionMapping.getValueType());
+ }
+
+ public void testGetValueTypeBasic() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.Address");
+
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ assertEquals(ElementCollectionMapping2_0.Type.BASIC_TYPE, elementCollectionMapping.getValueType());
+ }
+
+
+ public void testUpdateMapKey() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKey());
+ assertNull(elementCollection.getMapKey());
+
+ //set mapKey in the resource model, verify context model does not change
+ elementCollection.setMapKey(OrmFactory.eINSTANCE.createMapKey());
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKey());
+ assertNotNull(elementCollection.getMapKey());
+
+ //set mapKey name in the resource model, verify context model updated
+ elementCollection.getMapKey().setName("myMapKey");
+ assertEquals("myMapKey", ormElementCollectionMapping.getSpecifiedMapKey());
+ assertEquals("myMapKey", elementCollection.getMapKey().getName());
+
+ //set mapKey name to null in the resource model
+ elementCollection.getMapKey().setName(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKey());
+ assertNull(elementCollection.getMapKey().getName());
+
+ elementCollection.getMapKey().setName("myMapKey");
+ elementCollection.setMapKey(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKey());
+ assertNull(elementCollection.getMapKey());
+ }
+
+ public void testUpdateVirtualMapKey() throws Exception {
+ createTestEntityWithValidMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping();
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ assertNull(virtualElementCollectionMapping.getSpecifiedMapKey());
+ assertNull(virtualElementCollectionMapping.getMapKey());
+ assertFalse(virtualElementCollectionMapping.isPkMapKey());
+ assertFalse(virtualElementCollectionMapping.isCustomMapKey());
+ assertTrue(virtualElementCollectionMapping.isNoMapKey());
+
+ //set pk mapKey in the java, verify virtual orm mapping updates
+ javaElementCollectionMapping.setPkMapKey(true);
+ assertEquals(null, virtualElementCollectionMapping.getMapKey());//no primary key on an embeddable
+ assertTrue(virtualElementCollectionMapping.isPkMapKey());
+ assertFalse(virtualElementCollectionMapping.isCustomMapKey());
+ assertFalse(virtualElementCollectionMapping.isNoMapKey());
+
+
+ //set custom specified mapKey in the java, verify virtual orm mapping updates
+ javaElementCollectionMapping.setCustomMapKey(true);
+ javaElementCollectionMapping.setSpecifiedMapKey("city");
+ assertEquals("city", virtualElementCollectionMapping.getSpecifiedMapKey());
+ assertEquals("city", virtualElementCollectionMapping.getMapKey());
+ assertFalse(virtualElementCollectionMapping.isPkMapKey());
+ assertTrue(virtualElementCollectionMapping.isCustomMapKey());
+ assertFalse(virtualElementCollectionMapping.isNoMapKey());
+ }
+
+ public void testModifyMapKey() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection xmlElementColection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKey());
+ assertNull(xmlElementColection.getMapKey());
+
+ //set mapKey in the context model, verify resource model updated
+ ormElementCollectionMapping.setSpecifiedMapKey("myMapKey");
+ assertEquals("myMapKey", ormElementCollectionMapping.getSpecifiedMapKey());
+ assertEquals("myMapKey", xmlElementColection.getMapKey().getName());
+
+ //set mapKey to null in the context model
+ ormElementCollectionMapping.setSpecifiedMapKey(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKey());
+ assertNull(xmlElementColection.getMapKey().getName());
+ }
+
+ public void testCandidateMapKeyNames() throws Exception {
+ createTestEntityWithValidMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping();
+
+ Iterator<String> mapKeyNames =
+ virtualElementCollectionMapping.getCandidateMapKeyNames().iterator();
+ assertEquals("city", mapKeyNames.next());
+ assertEquals("state", mapKeyNames.next());
+ assertEquals("state.name", mapKeyNames.next());
+ assertEquals("state.abbr", mapKeyNames.next());
+ assertEquals("zip", mapKeyNames.next());
+ assertFalse(mapKeyNames.hasNext());
+ }
+
+ public void testCandidateMapKeyNames2() throws Exception {
+ createTestEntityWithValidNonGenericMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State");
+ OrmReadOnlyPersistentAttribute attribute = ormPersistentType.getAttributeNamed("addresses");
+ ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) attribute.getMapping();
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+
+ Iterator<String> mapKeyNames = virtualElementCollectionMapping.getCandidateMapKeyNames().iterator();
+ assertEquals(false, mapKeyNames.hasNext());
+
+ javaElementCollectionMapping.setSpecifiedTargetClass("test.Address");
+ mapKeyNames = virtualElementCollectionMapping.getCandidateMapKeyNames().iterator();
+ assertEquals("city", mapKeyNames.next());
+ assertEquals("state", mapKeyNames.next());
+ assertEquals("state.name", mapKeyNames.next());
+ assertEquals("state.abbr", mapKeyNames.next());
+ assertEquals("zip", mapKeyNames.next());
+ assertFalse(mapKeyNames.hasNext());
+
+ attribute.addToXml();
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping();
+ mapKeyNames = ormElementCollectionMapping.getCandidateMapKeyNames().iterator();
+ assertEquals(false, mapKeyNames.hasNext());
+
+ ormElementCollectionMapping.setSpecifiedTargetClass("test.Address");
+ mapKeyNames = ormElementCollectionMapping.getCandidateMapKeyNames().iterator();
+ assertEquals("city", mapKeyNames.next());
+ assertEquals("state", mapKeyNames.next());
+ assertEquals("state.name", mapKeyNames.next());
+ assertEquals("state.abbr", mapKeyNames.next());
+ assertEquals("zip", mapKeyNames.next());
+ assertFalse(mapKeyNames.hasNext());
+
+ ormElementCollectionMapping.setSpecifiedTargetClass("String");
+ mapKeyNames = ormElementCollectionMapping.getCandidateMapKeyNames().iterator();
+ assertEquals(false, mapKeyNames.hasNext());
+ }
+
+ public void testUpdateMapKeyClass() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(elementCollection.getMapKeyClass());
+
+ //set mapKey in the resource model, verify context model does not change
+ elementCollection.setMapKeyClass(OrmFactory.eINSTANCE.createXmlClassReference());
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNotNull(elementCollection.getMapKeyClass());
+
+ //set mapKey name in the resource model, verify context model updated
+ elementCollection.getMapKeyClass().setClassName("String");
+ assertEquals("String", ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertEquals("String", elementCollection.getMapKeyClass().getClassName());
+
+ //set mapKey name to null in the resource model
+ elementCollection.getMapKeyClass().setClassName(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(elementCollection.getMapKeyClass().getClassName());
+
+ elementCollection.getMapKeyClass().setClassName("String");
+ elementCollection.setMapKeyClass(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(elementCollection.getMapKeyClass());
+ }
+
+ public void testUpdateVirtualMapKeyClass() throws Exception {
+ createTestEntityWithValidMapElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State");
+
+ ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentType.getAttributeNamed("addresses").getMapping();
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ assertNull(virtualElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertEquals("java.lang.String", virtualElementCollectionMapping.getMapKeyClass());
+ assertEquals("java.lang.String", virtualElementCollectionMapping.getDefaultMapKeyClass());
+
+ //set pk mapKey in the java, verify virtual orm mapping updates
+ javaElementCollectionMapping.setSpecifiedMapKeyClass("Integer");
+ assertEquals("Integer", virtualElementCollectionMapping.getMapKeyClass());
+ assertEquals("Integer", virtualElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertEquals("java.lang.String", virtualElementCollectionMapping.getDefaultMapKeyClass());
+ }
+
+ public void testModifyMapKeyClass() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection elementCollection = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(elementCollection.getMapKeyClass());
+
+ //set mapKey in the context model, verify resource model updated
+ ormElementCollectionMapping.setSpecifiedMapKeyClass("String");
+ assertEquals("String", ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertEquals("String", elementCollection.getMapKeyClass().getClassName());
+
+ //set mapKey to null in the context model
+ ormElementCollectionMapping.setSpecifiedMapKeyClass(null);
+ assertNull(ormElementCollectionMapping.getSpecifiedMapKeyClass());
+ assertNull(elementCollection.getMapKeyClass());
+ }
+ public void testOrderColumnDefaults() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 elementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ Orderable2_0 orderable = (Orderable2_0) elementCollectionMapping.getOrderable();
+ assertEquals(false, orderable.isOrderColumnOrdering());
+ assertEquals(true, orderable.isNoOrdering());
+
+ orderable.setOrderColumnOrdering(true);
+ OrderColumn2_0 orderColumn = orderable.getOrderColumn();
+ assertEquals(true, orderable.isOrderColumnOrdering());
+ assertEquals(null, orderColumn.getSpecifiedName());
+ assertEquals("addresses_ORDER", orderColumn.getDefaultName());
+ assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable());
+
+ orderColumn.setSpecifiedName("FOO");
+ assertEquals("FOO", orderColumn.getSpecifiedName());
+ assertEquals("addresses_ORDER", orderColumn.getDefaultName());
+ assertEquals(TYPE_NAME + "_addresses", orderColumn.getTable());
+ }
+
+ public void testVirtualOrderColumn() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 elementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+
+ Orderable2_0 orderable = (Orderable2_0) elementCollectionMapping.getOrderable();
+ assertEquals(false, orderable.isOrderColumnOrdering());
+ assertEquals(true, orderable.isNoOrdering());
+
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentAttribute.getJavaPersistentAttribute().getMapping();
+ ((Orderable2_0) javaElementCollectionMapping.getOrderable()).setOrderColumnOrdering(true);
+
+ assertEquals(false, orderable.isOrderColumnOrdering());
+ assertEquals(true, orderable.isNoOrdering());
+
+ ormPersistentAttribute.removeFromXml();
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute2 = ormPersistentType.getAttributeNamed("addresses");
+ ElementCollectionMapping2_0 virtualElementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute2.getMapping();
+ orderable = (Orderable2_0) virtualElementCollectionMapping.getOrderable();
+ assertEquals(true, orderable.isOrderColumnOrdering());
+ assertEquals(false, orderable.isNoOrdering());
+ assertEquals(TYPE_NAME + "_addresses", orderable.getOrderColumn().getTable());
+ assertEquals("addresses_ORDER", orderable.getOrderColumn().getName());
+
+ ((Orderable2_0) javaElementCollectionMapping.getOrderable()).getOrderColumn().setSpecifiedName("FOO");
+ assertEquals(TYPE_NAME + "_addresses", orderable.getOrderColumn().getTable());
+ assertEquals("FOO", orderable.getOrderColumn().getName());
+ }
+
+ public void testVirtualValueColumnDefaults() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ //virtual attrubte in orm.xml, java attribute has no value Column annotation
+ OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ Column virtualColumn = addressesVirtualMapping.getValueColumn();
+ assertEquals("addresses", virtualColumn.getName());
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable());
+ assertEquals(null, virtualColumn.getColumnDefinition());
+ assertTrue(virtualColumn.isInsertable());
+ assertTrue(virtualColumn.isUpdatable());
+ assertTrue(virtualColumn.isNullable());
+ assertFalse(virtualColumn.isUnique());
+ assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, virtualColumn.getLength());
+ assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, virtualColumn.getPrecision());
+ assertEquals(ReadOnlyColumn.DEFAULT_SCALE, virtualColumn.getScale());
+
+ //set Column annotation in Java
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ javaElementCollectionMapping.getValueColumn().setSpecifiedName("FOO");
+ javaElementCollectionMapping.getValueColumn().setSpecifiedTable("FOO_TABLE");
+ javaElementCollectionMapping.getValueColumn().setColumnDefinition("COLUMN_DEFINITION");
+ javaElementCollectionMapping.getValueColumn().setSpecifiedInsertable(Boolean.FALSE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedNullable(Boolean.FALSE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedUnique(Boolean.TRUE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedLength(Integer.valueOf(45));
+ javaElementCollectionMapping.getValueColumn().setSpecifiedPrecision(Integer.valueOf(46));
+ javaElementCollectionMapping.getValueColumn().setSpecifiedScale(Integer.valueOf(47));
+
+ assertEquals("FOO", virtualColumn.getSpecifiedName());
+ assertEquals("FOO_TABLE", virtualColumn.getSpecifiedTable());
+ assertEquals("COLUMN_DEFINITION", virtualColumn.getColumnDefinition());
+ assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedInsertable());
+ assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedUpdatable());
+ assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedNullable());
+ assertEquals(Boolean.TRUE, virtualColumn.getSpecifiedUnique());
+ assertEquals(Integer.valueOf(45), virtualColumn.getSpecifiedLength());
+ assertEquals(Integer.valueOf(46), virtualColumn.getSpecifiedPrecision());
+ assertEquals(Integer.valueOf(47), virtualColumn.getSpecifiedScale());
+
+
+ //set metadata-complete, orm.xml virtual column ignores java column annotation
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+ addressesPersistentAttribute = ormPersistentType.getAttributeNamed("addresses");
+ //no longer an element collection mapping
+ assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, addressesPersistentAttribute.getMappingKey());
+ }
+
+ public void testNullColumnDefaults() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ OrmElementCollectionMapping2_0 addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ OrmColumn ormColumn = addressesVirtualMapping.getValueColumn();
+
+ //set Column annotation in Java
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ javaElementCollectionMapping.getValueColumn().setSpecifiedName("FOO");
+ javaElementCollectionMapping.getValueColumn().setSpecifiedTable("FOO_TABLE");
+ javaElementCollectionMapping.getValueColumn().setColumnDefinition("COLUMN_DEFINITION");
+ javaElementCollectionMapping.getValueColumn().setSpecifiedInsertable(Boolean.FALSE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedNullable(Boolean.FALSE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedUnique(Boolean.TRUE);
+ javaElementCollectionMapping.getValueColumn().setSpecifiedLength(Integer.valueOf(45));
+ javaElementCollectionMapping.getValueColumn().setSpecifiedPrecision(Integer.valueOf(46));
+ javaElementCollectionMapping.getValueColumn().setSpecifiedScale(Integer.valueOf(47));
+
+
+ assertEquals("addresses", ormColumn.getDefaultName());
+ assertEquals(TYPE_NAME + "_addresses", ormColumn.getDefaultTable());
+ assertEquals(true, ormColumn.isDefaultInsertable());
+ assertEquals(true, ormColumn.isDefaultUpdatable());
+ assertEquals(true, ormColumn.isDefaultNullable());
+ assertEquals(false, ormColumn.isDefaultUnique());
+ assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, ormColumn.getDefaultLength());
+ assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, ormColumn.getDefaultPrecision());
+ assertEquals(ReadOnlyColumn.DEFAULT_SCALE, ormColumn.getDefaultScale());
+ assertNull(ormColumn.getSpecifiedName());
+ assertNull(ormColumn.getSpecifiedTable());
+ assertNull(ormColumn.getColumnDefinition());
+ assertNull(ormColumn.getSpecifiedInsertable());
+ assertNull(ormColumn.getSpecifiedUpdatable());
+ assertNull(ormColumn.getSpecifiedNullable());
+ assertNull(ormColumn.getSpecifiedUnique());
+ assertNull(ormColumn.getSpecifiedLength());
+ assertNull(ormColumn.getSpecifiedPrecision());
+ assertNull(ormColumn.getSpecifiedScale());
+ }
+
+ public void testVirtualValueColumnTable() throws Exception {
+ createTestEntityWithGenericBasicElementCollectionMapping();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ //default attribute in orm.xml, java attribute has no Column annotation
+ OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ Column virtualColumn = addressesVirtualMapping.getValueColumn();
+
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable());
+
+ //entity table should have no affect on the collection table default name
+ ((OrmEntity) ormPersistentType.getMapping()).getTable().setSpecifiedName("ORM_TABLE");
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable());
+
+ //set Column table element in Java
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ javaElementCollectionMapping.getCollectionTable().setSpecifiedName("JAVA_COLLECTION_TABLE");
+ assertEquals("JAVA_COLLECTION_TABLE", virtualColumn.getTable());
+ javaElementCollectionMapping.getValueColumn().setSpecifiedTable("JAVA_TABLE");
+ assertEquals("JAVA_TABLE", virtualColumn.getTable());
+
+ //make name persistent attribute not default
+ addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ virtualColumn = addressesVirtualMapping.getValueColumn();
+ assertNull(virtualColumn.getSpecifiedTable());
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getDefaultTable());
+ }
+
+ public void testMoveSpecifiedAttributeOverride() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ OrmAttributeOverrideContainer attributeOverrideContainer = ormElementCollectionMapping.getValueAttributeOverrideContainer();
+ XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+ elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+ elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+
+ elementCollectionResource.getAttributeOverrides().get(0).setName("FOO");
+ elementCollectionResource.getAttributeOverrides().get(1).setName("BAR");
+ elementCollectionResource.getAttributeOverrides().get(2).setName("BAZ");
+
+ assertEquals(3, elementCollectionResource.getAttributeOverrides().size());
+
+ attributeOverrideContainer.moveSpecifiedOverride(2, 0);
+ ListIterator<OrmAttributeOverride> attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAR", attributeOverrides.next().getName());
+ assertEquals("BAZ", attributeOverrides.next().getName());
+ assertEquals("FOO", attributeOverrides.next().getName());
+
+ assertEquals("BAR", elementCollectionResource.getAttributeOverrides().get(0).getName());
+ assertEquals("BAZ", elementCollectionResource.getAttributeOverrides().get(1).getName());
+ assertEquals("FOO", elementCollectionResource.getAttributeOverrides().get(2).getName());
+
+
+ attributeOverrideContainer.moveSpecifiedOverride(0, 1);
+ attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", attributeOverrides.next().getName());
+ assertEquals("BAR", attributeOverrides.next().getName());
+ assertEquals("FOO", attributeOverrides.next().getName());
+
+ assertEquals("BAZ", elementCollectionResource.getAttributeOverrides().get(0).getName());
+ assertEquals("BAR", elementCollectionResource.getAttributeOverrides().get(1).getName());
+ assertEquals("FOO", elementCollectionResource.getAttributeOverrides().get(2).getName());
+ }
+
+ public void testUpdateAttributeOverrides() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ OrmAttributeOverrideContainer attributeOverrideContainer = ormElementCollectionMapping.getValueAttributeOverrideContainer();
+ XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+ elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+ elementCollectionResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+
+ elementCollectionResource.getAttributeOverrides().get(0).setName("FOO");
+ elementCollectionResource.getAttributeOverrides().get(1).setName("BAR");
+ elementCollectionResource.getAttributeOverrides().get(2).setName("BAZ");
+
+ ListIterator<OrmAttributeOverride> attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("FOO", attributeOverrides.next().getName());
+ assertEquals("BAR", attributeOverrides.next().getName());
+ assertEquals("BAZ", attributeOverrides.next().getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ elementCollectionResource.getAttributeOverrides().move(2, 0);
+ attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAR", attributeOverrides.next().getName());
+ assertEquals("BAZ", attributeOverrides.next().getName());
+ assertEquals("FOO", attributeOverrides.next().getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ elementCollectionResource.getAttributeOverrides().move(0, 1);
+ attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", attributeOverrides.next().getName());
+ assertEquals("BAR", attributeOverrides.next().getName());
+ assertEquals("FOO", attributeOverrides.next().getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ elementCollectionResource.getAttributeOverrides().remove(1);
+ attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", attributeOverrides.next().getName());
+ assertEquals("FOO", attributeOverrides.next().getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ elementCollectionResource.getAttributeOverrides().remove(1);
+ attributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ assertEquals("BAZ", attributeOverrides.next().getName());
+ assertFalse(attributeOverrides.hasNext());
+
+ elementCollectionResource.getAttributeOverrides().remove(0);
+ assertFalse(attributeOverrideContainer.getSpecifiedOverrides().iterator().hasNext());
+ }
+
+ public void testElementCollectionMappingNoUnderylingJavaAttribute() throws Exception {
+ createTestEntityWithEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"));
+ ormPersistentAttribute.getMapping().setName("foo");
+ assertEquals(3, ormPersistentType.getDefaultAttributesSize());
+
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ OrmAttributeOverrideContainer attributeOverrideContainer = ormElementCollectionMapping.getValueAttributeOverrideContainer();
+
+ assertEquals("foo", ormElementCollectionMapping.getName());
+
+
+ assertFalse(attributeOverrideContainer.getSpecifiedOverrides().iterator().hasNext());
+ assertFalse(attributeOverrideContainer.getVirtualOverrides().iterator().hasNext());
+ }
+
+ public void testVirtualAttributeOverrides() throws Exception {
+ createTestEntityWithEmbeddableElementCollectionMapping();
+ createTestTargetEmbeddableAddress();
+ createTestEmbeddableState();
+
+ OrmPersistentType persistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+ OrmPersistentType persistentType3 = getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".State");
+
+ //embedded mapping is virtual, specified attribute overrides should exist
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute = persistentType.getAttributeNamed("addresses");
+ ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ assertEquals(4, attributeOverrideContainer.getOverridesSize());
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals(1, attributeOverrideContainer.getSpecifiedOverridesSize());
+ ListIterator<? extends AttributeOverride> specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ ReadOnlyAttributeOverride attributeOverride = specifiedAttributeOverrides.next();
+ assertEquals("city", attributeOverride.getName());
+ ListIterator<? extends VirtualAttributeOverride> virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator();
+ attributeOverride = virtualAttributeOverrides.next();
+ assertEquals("state.name", attributeOverride.getName());
+ attributeOverride = virtualAttributeOverrides.next();
+ assertEquals("state.abbr", attributeOverride.getName());
+ attributeOverride = virtualAttributeOverrides.next();
+ assertEquals("zip", attributeOverride.getName());
+
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentAttribute.getJavaPersistentAttribute().getMapping();
+ Column javaAttributeOverrideColumn = javaElementCollectionMapping.getValueAttributeOverrideContainer().getSpecifiedOverrides().iterator().next().getColumn();
+
+ javaAttributeOverrideColumn.setSpecifiedName("FOO_COLUMN");
+ javaAttributeOverrideColumn.setSpecifiedTable("FOO_TABLE");
+ javaAttributeOverrideColumn.setColumnDefinition("COLUMN_DEF");
+ javaAttributeOverrideColumn.setSpecifiedInsertable(Boolean.FALSE);
+ javaAttributeOverrideColumn.setSpecifiedUpdatable(Boolean.FALSE);
+ javaAttributeOverrideColumn.setSpecifiedUnique(Boolean.TRUE);
+ javaAttributeOverrideColumn.setSpecifiedNullable(Boolean.FALSE);
+ javaAttributeOverrideColumn.setSpecifiedLength(Integer.valueOf(5));
+ javaAttributeOverrideColumn.setSpecifiedPrecision(Integer.valueOf(6));
+ javaAttributeOverrideColumn.setSpecifiedScale(Integer.valueOf(7));
+
+ JavaBasicMapping javaBasicMapping = (JavaBasicMapping) persistentType3.getJavaPersistentType().getAttributeNamed("name").getMapping();
+ javaBasicMapping.getColumn().setSpecifiedName("MY_STATE_COLUMN");
+ assertEquals(4, attributeOverrideContainer.getOverridesSize());
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals(1, attributeOverrideContainer.getSpecifiedOverridesSize());
+ specifiedAttributeOverrides = attributeOverrideContainer.getSpecifiedOverrides().iterator();
+ attributeOverride = specifiedAttributeOverrides.next();
+ assertEquals("city", attributeOverride.getName());
+ assertEquals("FOO_COLUMN", attributeOverride.getColumn().getSpecifiedName());
+ assertEquals("FOO_TABLE", attributeOverride.getColumn().getSpecifiedTable());
+ assertEquals("COLUMN_DEF", attributeOverride.getColumn().getColumnDefinition());
+ assertEquals(false, attributeOverride.getColumn().isInsertable());
+ assertEquals(false, attributeOverride.getColumn().isUpdatable());
+ assertEquals(true, attributeOverride.getColumn().isUnique());
+ assertEquals(false, attributeOverride.getColumn().isNullable());
+ assertEquals(5, attributeOverride.getColumn().getLength());
+ assertEquals(6, attributeOverride.getColumn().getPrecision());
+ assertEquals(7, attributeOverride.getColumn().getScale());
+
+ virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator();
+ attributeOverride = virtualAttributeOverrides.next();
+ assertEquals("state.name", attributeOverride.getName());
+ assertEquals("MY_STATE_COLUMN", attributeOverride.getColumn().getSpecifiedName());
+ attributeOverride = virtualAttributeOverrides.next();
+ assertEquals("state.abbr", attributeOverride.getName());
+ attributeOverride = virtualAttributeOverrides.next();
+ assertEquals("zip", attributeOverride.getName());
+
+
+
+ //embedded mapping is specified, virtual attribute overrides should exist
+ persistentType.getAttributeNamed("addresses").addToXml();
+ elementCollectionMapping = (OrmElementCollectionMapping2_0) persistentType.getAttributeNamed("addresses").getMapping();
+ attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+ assertEquals(4, attributeOverrideContainer.getOverridesSize());
+ assertEquals(4, attributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals(0, attributeOverrideContainer.getSpecifiedOverridesSize());
+ virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator();
+ ReadOnlyAttributeOverride virtualOverride = virtualAttributeOverrides.next();
+ assertEquals("city", virtualOverride.getName());
+ virtualOverride = virtualAttributeOverrides.next();
+ assertEquals("state.name", virtualOverride.getName());
+ assertEquals("MY_STATE_COLUMN", virtualOverride.getColumn().getName());
+ assertEquals(TYPE_NAME + "_addresses", virtualOverride.getColumn().getTable());
+ assertEquals(null, virtualOverride.getColumn().getColumnDefinition());
+ assertEquals(true, virtualOverride.getColumn().isInsertable());
+ assertEquals(true, virtualOverride.getColumn().isUpdatable());
+ assertEquals(false, virtualOverride.getColumn().isUnique());
+ assertEquals(true, virtualOverride.getColumn().isNullable());
+ assertEquals(255, virtualOverride.getColumn().getLength());
+ assertEquals(0, virtualOverride.getColumn().getPrecision());
+ assertEquals(0, virtualOverride.getColumn().getScale());
+ virtualOverride = virtualAttributeOverrides.next();
+ assertEquals("state.abbr", virtualOverride.getName());
+ assertEquals(TYPE_NAME + "_addresses", virtualOverride.getColumn().getDefaultTable());
+ virtualOverride = virtualAttributeOverrides.next();
+ assertEquals("zip", virtualOverride.getName());
+
+ //set one of the virtual attribute overrides to specified, verify others are still virtual
+ attributeOverrideContainer.getVirtualOverrides().iterator().next().convertToSpecified();
+
+ assertEquals(4, attributeOverrideContainer.getOverridesSize());
+ assertEquals(1, attributeOverrideContainer.getSpecifiedOverridesSize());
+ assertEquals(3, attributeOverrideContainer.getVirtualOverridesSize());
+ assertEquals("city", attributeOverrideContainer.getSpecifiedOverrides().iterator().next().getName());
+ virtualAttributeOverrides = attributeOverrideContainer.getVirtualOverrides().iterator();
+ virtualOverride = virtualAttributeOverrides.next();
+ assertEquals("state.name", virtualOverride.getName());
+ virtualOverride = virtualAttributeOverrides.next();
+ assertEquals("state.abbr", virtualOverride.getName());
+ virtualOverride = virtualAttributeOverrides.next();
+ assertEquals("zip", virtualOverride.getName());
+ }
+ public void testVirtualMapKeyColumnDefaults() throws Exception {
+ createTestEntityWithValidMapElementCollectionMapping();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ //virtual attribute in orm.xml, java attribute has no value Column annotation
+ OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ Column virtualColumn = addressesVirtualMapping.getMapKeyColumn();
+ assertEquals("addresses_KEY", virtualColumn.getName());
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable());
+ assertEquals(null, virtualColumn.getColumnDefinition());
+ assertTrue(virtualColumn.isInsertable());
+ assertTrue(virtualColumn.isUpdatable());
+ assertTrue(virtualColumn.isNullable());
+ assertFalse(virtualColumn.isUnique());
+ assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, virtualColumn.getLength());
+ assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, virtualColumn.getPrecision());
+ assertEquals(ReadOnlyColumn.DEFAULT_SCALE, virtualColumn.getScale());
+
+ //set Column annotation in Java
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedName("FOO");
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedTable("FOO_TABLE");
+ javaElementCollectionMapping.getMapKeyColumn().setColumnDefinition("COLUMN_DEFINITION");
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedInsertable(Boolean.FALSE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedNullable(Boolean.FALSE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUnique(Boolean.TRUE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedLength(Integer.valueOf(45));
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedPrecision(Integer.valueOf(46));
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedScale(Integer.valueOf(47));
+
+ assertEquals("FOO", virtualColumn.getSpecifiedName());
+ assertEquals("FOO_TABLE", virtualColumn.getSpecifiedTable());
+ assertEquals("COLUMN_DEFINITION", virtualColumn.getColumnDefinition());
+ assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedInsertable());
+ assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedUpdatable());
+ assertEquals(Boolean.FALSE, virtualColumn.getSpecifiedNullable());
+ assertEquals(Boolean.TRUE, virtualColumn.getSpecifiedUnique());
+ assertEquals(Integer.valueOf(45), virtualColumn.getSpecifiedLength());
+ assertEquals(Integer.valueOf(46), virtualColumn.getSpecifiedPrecision());
+ assertEquals(Integer.valueOf(47), virtualColumn.getSpecifiedScale());
+
+
+ //set metadata-complete, orm.xml virtual column ignores java column annotation
+ ormPersistentType.getMapping().setSpecifiedMetadataComplete(Boolean.TRUE);
+ addressesPersistentAttribute = ormPersistentType.getAttributeNamed("addresses");
+ //no longer an element collection mapping
+ assertEquals(MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY, addressesPersistentAttribute.getMappingKey());
+ }
+
+ public void testNullMapKeyColumnDefaults() throws Exception {
+ createTestEntityWithValidMapElementCollectionMapping();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+
+ OrmElementCollectionMapping2_0 addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ Column ormColumn = addressesVirtualMapping.getMapKeyColumn();
+
+ //set Column annotation in Java
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedName("FOO");
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedTable("FOO_TABLE");
+ javaElementCollectionMapping.getMapKeyColumn().setColumnDefinition("COLUMN_DEFINITION");
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedInsertable(Boolean.FALSE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUpdatable(Boolean.FALSE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedNullable(Boolean.FALSE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedUnique(Boolean.TRUE);
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedLength(Integer.valueOf(45));
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedPrecision(Integer.valueOf(46));
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedScale(Integer.valueOf(47));
+
+
+ assertEquals("addresses_KEY", ormColumn.getDefaultName());
+ assertEquals(TYPE_NAME + "_addresses", ormColumn.getDefaultTable());
+ assertEquals(true, ormColumn.isDefaultInsertable());
+ assertEquals(true, ormColumn.isDefaultUpdatable());
+ assertEquals(true, ormColumn.isDefaultNullable());
+ assertEquals(false, ormColumn.isDefaultUnique());
+ assertEquals(ReadOnlyColumn.DEFAULT_LENGTH, ormColumn.getDefaultLength());
+ assertEquals(ReadOnlyColumn.DEFAULT_PRECISION, ormColumn.getDefaultPrecision());
+ assertEquals(ReadOnlyColumn.DEFAULT_SCALE, ormColumn.getDefaultScale());
+ assertNull(ormColumn.getSpecifiedName());
+ assertNull(ormColumn.getSpecifiedTable());
+ assertNull(ormColumn.getColumnDefinition());
+ assertNull(ormColumn.getSpecifiedInsertable());
+ assertNull(ormColumn.getSpecifiedUpdatable());
+ assertNull(ormColumn.getSpecifiedNullable());
+ assertNull(ormColumn.getSpecifiedUnique());
+ assertNull(ormColumn.getSpecifiedLength());
+ assertNull(ormColumn.getSpecifiedPrecision());
+ assertNull(ormColumn.getSpecifiedScale());
+ }
+
+ public void testVirtualMapKeyColumnTable() throws Exception {
+ createTestEntityWithValidMapElementCollectionMapping();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+
+ //virtual attribute in orm.xml, java attribute has no Column annotation
+ OrmReadOnlyPersistentAttribute addressesPersistentAttribute = ormPersistentType.getDefaultAttributes().iterator().next();
+ ElementCollectionMapping2_0 addressesVirtualMapping = (ElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ Column virtualColumn = addressesVirtualMapping.getMapKeyColumn();
+
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable());
+
+ //entity table should have no affect on the collection table default name
+ ((OrmEntity) ormPersistentType.getMapping()).getTable().setSpecifiedName("ORM_TABLE");
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getTable());
+
+ //set Column table element in Java
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("addresses").getMapping();
+ javaElementCollectionMapping.getCollectionTable().setSpecifiedName("JAVA_COLLECTION_TABLE");
+ assertEquals("JAVA_COLLECTION_TABLE", virtualColumn.getTable());
+ javaElementCollectionMapping.getMapKeyColumn().setSpecifiedTable("JAVA_TABLE");
+ assertEquals("JAVA_TABLE", virtualColumn.getTable());
+
+ //make addresses persistent attribute not default
+ addressesPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("addresses"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ addressesVirtualMapping = (OrmElementCollectionMapping2_0) addressesPersistentAttribute.getMapping();
+ virtualColumn = addressesVirtualMapping.getMapKeyColumn();
+ assertNull(virtualColumn.getSpecifiedTable());
+ assertEquals(TYPE_NAME + "_addresses", virtualColumn.getDefaultTable());
+ }
+
+ public void testSelfReferentialElementCollectionMapping() throws Exception {
+ createSelfReferentialElementCollection();
+ OrmPersistentType persistentType = getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Foo");
+
+ ElementCollectionMapping2_0 mapping = (ElementCollectionMapping2_0) persistentType.getAttributeNamed("elementCollection").getMapping();
+ assertFalse(mapping.getAllOverridableAttributeMappingNames().iterator().hasNext());
+ }
+
+ public void testUpdateSpecifiedEnumerated() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ assertNull(elementCollectionResource.getMapKeyEnumerated());
+
+ //set enumerated in the resource model, verify context model updated
+ elementCollectionResource.setMapKeyEnumerated(org.eclipse.jpt.jpa.core.resource.orm.EnumType.ORDINAL);
+ assertEquals(EnumType.ORDINAL, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.ORDINAL, elementCollectionResource.getMapKeyEnumerated());
+
+ elementCollectionResource.setMapKeyEnumerated(org.eclipse.jpt.jpa.core.resource.orm.EnumType.STRING);
+ assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.STRING, elementCollectionResource.getMapKeyEnumerated());
+
+ //set enumerated to null in the resource model
+ elementCollectionResource.setMapKeyEnumerated(null);
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ assertNull(elementCollectionResource.getMapKeyEnumerated());
+ }
+
+ public void testModifySpecifiedEnumerated() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ assertNull(elementCollectionResource.getMapKeyEnumerated());
+
+ //set enumerated in the context model, verify resource model updated
+ ormElementCollectionMapping.setMapKeyConverter(BaseEnumeratedConverter.class);
+ ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.ORDINAL);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.ORDINAL, elementCollectionResource.getMapKeyEnumerated());
+ assertEquals(EnumType.ORDINAL, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType());
+
+ ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).setSpecifiedEnumType(EnumType.STRING);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.EnumType.STRING, elementCollectionResource.getMapKeyEnumerated());
+ assertEquals(EnumType.STRING, ((BaseEnumeratedConverter) ormElementCollectionMapping.getMapKeyConverter()).getSpecifiedEnumType());
+
+ //set enumerated to null in the context model
+ ormElementCollectionMapping.setMapKeyConverter(null);
+ assertNull(elementCollectionResource.getMapKeyEnumerated());
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ }
+
+ public void testUpdateSpecifiedTemporal() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ assertNull(elementCollectionResource.getMapKeyTemporal());
+
+ //set temporal in the resource model, verify context model updated
+ elementCollectionResource.setMapKeyTemporal(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.DATE);
+ assertEquals(TemporalType.DATE, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.DATE, elementCollectionResource.getMapKeyTemporal());
+
+ elementCollectionResource.setMapKeyTemporal(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIME);
+ assertEquals(TemporalType.TIME, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIME, elementCollectionResource.getMapKeyTemporal());
+
+ elementCollectionResource.setMapKeyTemporal(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIMESTAMP);
+ assertEquals(TemporalType.TIMESTAMP, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIMESTAMP, elementCollectionResource.getMapKeyTemporal());
+
+ //set temporal to null in the resource model
+ elementCollectionResource.setMapKeyTemporal(null);
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ assertNull(elementCollectionResource.getMapKeyTemporal());
+ }
+
+ public void testModifySpecifiedTemporal() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlElementCollection_2_0 elementCollectionResource = getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ assertNull(elementCollectionResource.getMapKeyTemporal());
+
+ //set temporal in the context model, verify resource model updated
+ ormElementCollectionMapping.setMapKeyConverter(BaseTemporalConverter.class);
+ ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).setTemporalType(TemporalType.DATE);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.DATE, elementCollectionResource.getMapKeyTemporal());
+ assertEquals(TemporalType.DATE, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType());
+
+ ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).setTemporalType(TemporalType.TIME);
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.TemporalType.TIME, elementCollectionResource.getMapKeyTemporal());
+ assertEquals(TemporalType.TIME, ((BaseTemporalConverter) ormElementCollectionMapping.getMapKeyConverter()).getTemporalType());
+
+ //set temporal to null in the context model
+ ormElementCollectionMapping.setMapKeyConverter(null);
+ assertNull(elementCollectionResource.getMapKeyTemporal());
+ assertNull(ormElementCollectionMapping.getMapKeyConverter().getType());
+ }
+
+ public void testUpdateConvert() throws Exception {
+ createTestEntityWithElementCollectionMapping();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("address"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlConvertibleMapping elementCollectionResource = (XmlConvertibleMapping) getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+ JavaElementCollectionMapping2_0 javaElementCollectionMapping = (JavaElementCollectionMapping2_0) ormPersistentType.getJavaPersistentType().getAttributeNamed("address").getMapping();
+
+ assertNull(ormElementCollectionMapping.getConverter().getType());
+ assertEquals(null, elementCollectionResource.getConvert());
+
+ //set lob in the resource model, verify context model updated
+ elementCollectionResource.setConvert("myConvert");
+ assertEquals(EclipseLinkConvert.class, ormElementCollectionMapping.getConverter().getType());
+ assertEquals("myConvert", elementCollectionResource.getConvert());
+
+ //set lob to null in the resource model
+ elementCollectionResource.setConvert(null);
+ assertNull(ormElementCollectionMapping.getConverter().getType());
+ assertEquals(null, elementCollectionResource.getConvert());
+
+
+ javaElementCollectionMapping.setConverter(EclipseLinkConvert.class);
+ ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).setSpecifiedConverterName("foo");
+
+ assertNull(ormElementCollectionMapping.getConverter().getType());
+ assertEquals(null, elementCollectionResource.getConvert());
+ assertEquals("foo", ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).getSpecifiedConverterName());
+
+
+ ormPersistentAttribute.removeFromXml();
+ OrmReadOnlyPersistentAttribute ormPersistentAttribute2 = ormPersistentType.getAttributeNamed("address");
+ EclipseLinkElementCollectionMapping2_0 virtualElementCollectionMapping = (EclipseLinkElementCollectionMapping2_0) ormPersistentAttribute2.getMapping();
+
+ assertEquals(EclipseLinkConvert.class, virtualElementCollectionMapping.getConverter().getType());
+ assertEquals("foo", ((EclipseLinkConvert) virtualElementCollectionMapping.getConverter()).getSpecifiedConverterName());
+ assertEquals(null, elementCollectionResource.getConvert());
+ assertEquals("foo", ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).getSpecifiedConverterName());
+
+ ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).setSpecifiedConverterName("bar");
+ assertEquals(EclipseLinkConvert.class, virtualElementCollectionMapping.getConverter().getType());
+ assertEquals("bar", ((EclipseLinkConvert) virtualElementCollectionMapping.getConverter()).getSpecifiedConverterName());
+ assertEquals(null, elementCollectionResource.getConvert());
+ assertEquals("bar", ((EclipseLinkConvert) javaElementCollectionMapping.getConverter()).getSpecifiedConverterName());
+
+ javaElementCollectionMapping.setConverter(null);
+ assertNull(virtualElementCollectionMapping.getConverter().getType());
+ assertEquals(null, elementCollectionResource.getConvert());
+ assertNull(javaElementCollectionMapping.getConverter().getType());
+ }
+
+ public void testModifyConvert() throws Exception {
+ createTestTypeWithCollection();
+
+ OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+ OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addAttributeToXml(ormPersistentType.getAttributeNamed("elementCollection"), MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
+ OrmElementCollectionMapping2_0 ormElementCollectionMapping = (OrmElementCollectionMapping2_0) ormPersistentAttribute.getMapping();
+ XmlConvertibleMapping elementCollectionResource = (XmlConvertibleMapping) getXmlEntityMappings().getEntities().get(0).getAttributes().getElementCollections().get(0);
+
+ assertNull(ormElementCollectionMapping.getConverter().getType());
+ assertEquals(null, elementCollectionResource.getConvert());
+
+ //set lob in the context model, verify resource model updated
+ ormElementCollectionMapping.setConverter(EclipseLinkConvert.class);
+ assertEquals("", elementCollectionResource.getConvert());
+ assertEquals(EclipseLinkConvert.class, ormElementCollectionMapping.getConverter().getType());
+
+ ((EclipseLinkConvert) ormElementCollectionMapping.getConverter()).setSpecifiedConverterName("bar");
+ assertEquals("bar", elementCollectionResource.getConvert());
+ assertEquals(EclipseLinkConvert.class, ormElementCollectionMapping.getConverter().getType());
+ assertEquals("bar", ((EclipseLinkConvert) ormElementCollectionMapping.getConverter()).getSpecifiedConverterName());
+
+ ((EclipseLinkConvert) ormElementCollectionMapping.getConverter()).setSpecifiedConverterName(null);
+
+ assertNull(ormElementCollectionMapping.getConverter().getType());
+ assertEquals(null, elementCollectionResource.getConvert());
+
+ //set lob to false in the context model
+ ormElementCollectionMapping.setConverter(null);
+ assertNull(ormElementCollectionMapping.getConverter().getType());
+ assertEquals(null, elementCollectionResource.getConvert());
+ }
+} \ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java
new file mode 100644
index 0000000000..39c93db3c2
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/orm/EclipseLink2_1PersistenceUnitDefaultsTests.java
@@ -0,0 +1,330 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.orm;
+
+import org.eclipse.jpt.jpa.core.context.AccessType;
+import org.eclipse.jpt.jpa.core.context.orm.OrmPersistenceUnitDefaults;
+import org.eclipse.jpt.jpa.core.resource.orm.XmlPersistenceUnitMetadata;
+import org.eclipse.jpt.jpa.core.resource.persistence.PersistenceFactory;
+import org.eclipse.jpt.jpa.core.resource.persistence.XmlMappingFileRef;
+import org.eclipse.jpt.jpa.eclipselink.core.JptJpaEclipseLinkCorePlugin;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkAccessType;
+import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkPersistenceUnitDefaults;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.EclipseLinkOrmFactory;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlPersistenceUnitDefaults;
+import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_1ContextModelTestCase;
+
+@SuppressWarnings("nls")
+public class EclipseLink2_1PersistenceUnitDefaultsTests
+ extends EclipseLink2_1ContextModelTestCase
+{
+ public EclipseLink2_1PersistenceUnitDefaultsTests(String name) {
+ super(name);
+ }
+
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ XmlMappingFileRef mappingFileRef = PersistenceFactory.eINSTANCE.createXmlMappingFileRef();
+ mappingFileRef.setFileName(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ getXmlPersistenceUnit().getMappingFiles().add(mappingFileRef);
+ getPersistenceXmlResource().save(null);
+ }
+
+ protected EclipseLinkPersistenceUnitDefaults getPersistenceUnitDefaults() {
+ return(EclipseLinkPersistenceUnitDefaults) getEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults();
+ }
+
+ protected XmlPersistenceUnitDefaults getXmlPersistenceUnitDefaults() {
+ return (XmlPersistenceUnitDefaults) getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults();
+ }
+
+ public void testIsAllFeaturesUnset() throws Exception {
+ OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ XmlPersistenceUnitMetadata persistenceUnitMetadata = EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata();
+ getXmlEntityMappings().setPersistenceUnitMetadata(persistenceUnitMetadata);
+ assertTrue(persistenceUnitMetadata.isUnset());
+
+ XmlPersistenceUnitDefaults persistenceUnitDefaultsResource = EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults();
+ persistenceUnitMetadata.setPersistenceUnitDefaults(persistenceUnitDefaultsResource);
+ assertTrue(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setCascadePersist(true);
+ assertFalse(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setCascadePersist(false);
+ assertTrue(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setSchema("asdf");
+ assertFalse(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setSchema(null);
+ assertTrue(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setCatalog("asdf");
+ assertFalse(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setCatalog(null);
+ assertTrue(persistenceUnitDefaultsResource.isUnset());
+
+
+ persistenceUnitDefaultsResource.setAccess(org.eclipse.jpt.jpa.core.resource.orm.AccessType.PROPERTY);
+ assertFalse(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setAccess(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD);
+ assertFalse(persistenceUnitDefaultsResource.isUnset());
+
+ persistenceUnitDefaultsResource.setAccess(null);
+ assertTrue(persistenceUnitDefaultsResource.isUnset());
+ }
+
+
+ public void testUpdateAccess() throws Exception {
+ OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set access in the resource model, verify context model updated
+ getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata());
+ getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults());
+ getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setAccess(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD);
+ assertEquals(AccessType.FIELD, persistenceUnitDefaults.getAccess());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setAccess(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL);
+ assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getAccess());
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ //set access to null in the resource model
+ getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setAccess(null);
+ assertNull(persistenceUnitDefaults.getAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+ }
+
+ public void testModifyAccess() throws Exception {
+ OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getSpecifiedAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set access in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedAccess(AccessType.PROPERTY);
+ assertEquals(AccessType.PROPERTY, persistenceUnitDefaults.getSpecifiedAccess());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.PROPERTY, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ persistenceUnitDefaults.setSpecifiedAccess(EclipseLinkAccessType.VIRTUAL);
+ assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getSpecifiedAccess());
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ //set access to null in the context model
+ persistenceUnitDefaults.setSpecifiedAccess(null);
+ assertNull(persistenceUnitDefaults.getSpecifiedAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+ }
+
+ public void testModifyAccess2() throws Exception {
+ OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getSpecifiedAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set access in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedAccess(AccessType.FIELD);
+ assertEquals(AccessType.FIELD, persistenceUnitDefaults.getSpecifiedAccess());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ //set access in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedAccess(EclipseLinkAccessType.VIRTUAL);
+ assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getSpecifiedAccess());
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ //set another element on the persistence-unit-defaults element so it doesn't get removed
+ getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setCascadePersist(true);
+ //set access to null in the context model
+ persistenceUnitDefaults.setSpecifiedAccess(null);
+ assertNull(persistenceUnitDefaults.getSpecifiedAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+ }
+
+ public void testModifyAccess3() throws Exception {
+ OrmPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getSpecifiedAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+ //set another element on the persistence-unit-metadata element so only persistence-unit-defaults element gets removed
+ getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata());
+ getXmlEntityMappings().getPersistenceUnitMetadata().setXmlMappingMetadataComplete(true);
+
+ //set access in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedAccess(AccessType.FIELD);
+ assertEquals(AccessType.FIELD, persistenceUnitDefaults.getSpecifiedAccess());
+ assertEquals(org.eclipse.jpt.jpa.core.resource.orm.AccessType.FIELD, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ //set access in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedAccess(EclipseLinkAccessType.VIRTUAL);
+ assertEquals(EclipseLinkAccessType.VIRTUAL, persistenceUnitDefaults.getSpecifiedAccess());
+ assertEquals(org.eclipse.jpt.jpa.eclipselink.core.resource.orm.v2_1.EclipseLinkAccessType.VIRTUAL, getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().getAccess());
+
+ //set access to null in the context model
+ persistenceUnitDefaults.setSpecifiedAccess(null);
+ assertNull(persistenceUnitDefaults.getSpecifiedAccess());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults());
+ }
+
+ public void testUpdateGetMethod() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set getMethod in the resource model, verify context model updated
+ getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata());
+ getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults());
+ getXmlPersistenceUnitDefaults().setAccessMethods(EclipseLinkOrmFactory.eINSTANCE.createXmlAccessMethods());
+
+ getXmlPersistenceUnitDefaults().getAccessMethods().setGetMethod("getFoo");
+ assertEquals("getFoo", persistenceUnitDefaults.getGetMethod());
+ assertEquals("getFoo", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod());
+
+ //set getMethod to null in the resource model
+ getXmlPersistenceUnitDefaults().getAccessMethods().setGetMethod(null);
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod());
+ }
+
+ public void testModifyGetMethod() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set getMethod in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedGetMethod("getMe");
+ assertEquals("getMe", persistenceUnitDefaults.getGetMethod());
+ assertEquals("getMe", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod());
+
+ //set getMethod to null in the context model
+ persistenceUnitDefaults.setSpecifiedGetMethod(null);
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+ }
+
+ public void testModifyGetMethod2() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set getMethod in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedGetMethod("getMe");
+ assertEquals("getMe", persistenceUnitDefaults.getGetMethod());
+ assertEquals("getMe", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod());
+
+ //set another element on the access-methods element so it doesn't get removed
+ getXmlPersistenceUnitDefaults().getAccessMethods().setSetMethod("setMe");
+ //set getMethod to null in the context model
+ persistenceUnitDefaults.setSpecifiedGetMethod(null);
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod());
+ }
+
+ public void testModifyGetMethod3() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+ //set another element on the ersistence-unit-defaults element so only access-methods element gets removed
+ getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata());
+ getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults());
+ getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setCascadePersist(true);
+
+ //set getMethod in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedGetMethod("getMe");
+ assertEquals("getMe", persistenceUnitDefaults.getGetMethod());
+ assertEquals("getMe", getXmlPersistenceUnitDefaults().getAccessMethods().getGetMethod());
+
+ //set getMethod to null in the context model
+ persistenceUnitDefaults.setSpecifiedGetMethod(null);
+ assertNull(persistenceUnitDefaults.getGetMethod());
+ assertNull(getXmlPersistenceUnitDefaults().getAccessMethods());
+ }
+
+ public void testUpdateSetMethod() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set getMethod in the resource model, verify context model updated
+ getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata());
+ getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults());
+ getXmlPersistenceUnitDefaults().setAccessMethods(EclipseLinkOrmFactory.eINSTANCE.createXmlAccessMethods());
+
+ getXmlPersistenceUnitDefaults().getAccessMethods().setSetMethod("setFoo");
+ assertEquals("setFoo", persistenceUnitDefaults.getSetMethod());
+ assertEquals("setFoo", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod());
+
+ //set getMethod to null in the resource model
+ getXmlPersistenceUnitDefaults().getAccessMethods().setSetMethod(null);
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod());
+ }
+
+ public void testModifySetMethod() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set getMethod in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedSetMethod("setMe");
+ assertEquals("setMe", persistenceUnitDefaults.getSetMethod());
+ assertEquals("setMe", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod());
+
+ //set getMethod to null in the context model
+ persistenceUnitDefaults.setSpecifiedSetMethod(null);
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+ }
+
+ public void testModifySetMethod2() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+
+ //set getMethod in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedSetMethod("setMe");
+ assertEquals("setMe", persistenceUnitDefaults.getSetMethod());
+ assertEquals("setMe", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod());
+
+ //set another element on the access-methods element so it doesn't get removed
+ getXmlPersistenceUnitDefaults().getAccessMethods().setGetMethod("getMe");
+ //set getMethod to null in the context model
+ persistenceUnitDefaults.setSpecifiedSetMethod(null);
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod());
+ }
+
+ public void testModifySetMethod3() throws Exception {
+ EclipseLinkPersistenceUnitDefaults persistenceUnitDefaults = getPersistenceUnitDefaults();
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlEntityMappings().getPersistenceUnitMetadata());
+ //set another element on the ersistence-unit-defaults element so only access-methods element gets removed
+ getXmlEntityMappings().setPersistenceUnitMetadata(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitMetadata());
+ getXmlEntityMappings().getPersistenceUnitMetadata().setPersistenceUnitDefaults(EclipseLinkOrmFactory.eINSTANCE.createXmlPersistenceUnitDefaults());
+ getXmlEntityMappings().getPersistenceUnitMetadata().getPersistenceUnitDefaults().setCascadePersist(true);
+
+ //set getMethod in the context model, verify resource model modified
+ persistenceUnitDefaults.setSpecifiedSetMethod("setMe");
+ assertEquals("setMe", persistenceUnitDefaults.getSetMethod());
+ assertEquals("setMe", getXmlPersistenceUnitDefaults().getAccessMethods().getSetMethod());
+
+ //set getMethod to null in the context model
+ persistenceUnitDefaults.setSpecifiedSetMethod(null);
+ assertNull(persistenceUnitDefaults.getSetMethod());
+ assertNull(getXmlPersistenceUnitDefaults().getAccessMethods());
+ }
+
+} \ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java
new file mode 100644
index 0000000000..55a6479832
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_0PersistenceUnitTestCase.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence;
+
+import org.eclipse.jpt.common.utility.internal.model.value.SimplePropertyValueModel;
+import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
+import org.eclipse.jpt.jpa.core.JpaFacet;
+import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetDataModelProperties;
+import org.eclipse.jpt.jpa.core.tests.internal.context.persistence.PersistenceUnitTestCase;
+import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
+import org.eclipse.jpt.jpa.eclipselink.core.platform.EclipseLinkPlatform;
+import org.eclipse.wst.common.componentcore.datamodel.properties.IFacetDataModelProperties;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * EclipseLink2_0PersistenceUnitTestCase
+ */
+public abstract class EclipseLink2_0PersistenceUnitTestCase extends PersistenceUnitTestCase
+{
+ protected EclipseLinkPersistenceUnit subject;
+
+ protected PropertyValueModel<EclipseLinkPersistenceUnit> subjectHolder;
+
+ // ********** constructors **********
+ protected EclipseLink2_0PersistenceUnitTestCase(String name) {
+ super(name);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ this.subject = this.getPersistenceUnit();
+ this.subjectHolder = new SimplePropertyValueModel<EclipseLinkPersistenceUnit>(this.subject);
+ this.populatePu();
+ }
+
+ @Override
+ protected IDataModel buildJpaConfigDataModel() {
+ IDataModel dataModel = super.buildJpaConfigDataModel();
+ dataModel.setProperty(IFacetDataModelProperties.FACET_VERSION_STR, JpaFacet.VERSION_2_0.getVersionString());
+ dataModel.setProperty(JpaFacetDataModelProperties.PLATFORM, EclipseLinkPlatform.VERSION_2_0);
+ return dataModel;
+ }
+
+ @Override
+ protected EclipseLinkPersistenceUnit getPersistenceUnit() {
+ return (EclipseLinkPersistenceUnit) super.getPersistenceUnit();
+ }
+
+} \ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java
new file mode 100644
index 0000000000..0eecf5c287
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLink2_2JpaMetadataConversionTests.java
@@ -0,0 +1,823 @@
+/*******************************************************************************
+ * Copyright (c) 2011, 2012 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ *
+ * Contributors:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.ListIterator;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.common.utility.internal.CollectionTools;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
+import org.eclipse.jpt.jpa.core.context.java.JavaEntity;
+import org.eclipse.jpt.jpa.core.context.java.JavaIdMapping;
+import org.eclipse.jpt.jpa.core.context.orm.EntityMappings;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
+import org.eclipse.jpt.jpa.core.jpa2.resource.java.JPA2_0;
+import org.eclipse.jpt.jpa.core.resource.java.JPA;
+import org.eclipse.jpt.jpa.core.tests.internal.jpa2.context.persistence.Generic2_0JpaMetadataConversionTests;
+import org.eclipse.jpt.jpa.eclipselink.core.JptJpaEclipseLinkCorePlugin;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConversionValue;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConvertibleMapping;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkCustomConverter;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkObjectTypeConverter;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkStructConverter;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTypeConverter;
+import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkEmbeddable;
+import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkEntity;
+import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkMappedSuperclass;
+import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkEntityMappings;
+import org.eclipse.jpt.jpa.eclipselink.core.context.orm.OrmEclipseLinkConverterContainer;
+import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
+import org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm.OrmEclipseLinkCustomConverter;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink;
+import org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.EclipseLink2_2ContextModelTestCase;
+
+@SuppressWarnings("nls")
+public class EclipseLink2_2JpaMetadataConversionTests extends EclipseLink2_2ContextModelTestCase {
+
+ private IProgressMonitor progressMonitor;
+
+ public EclipseLink2_2JpaMetadataConversionTests(String name) {
+ super(name);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ this.progressMonitor = new IProgressMonitor() {
+ public void worked(int work) {}
+ public void subTask(String name) {}
+ public void setTaskName(String name) {}
+ public void setCanceled(boolean value) {}
+ public boolean isCanceled() {return false;}
+ public void internalWorked(double work) {}
+ public void done() {}
+ public void beginTask(String name, int totalWork) {}
+ } ;
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ this.progressMonitor = null;
+ super.tearDown();
+ }
+
+ // ************ metadata conversion of equivalent queries on EclipseLink platform*************
+
+ private ICompilationUnit createTestEntityWithDuplicateQueries() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ID, JPA.NAMED_QUERY, JPA.NAMED_NATIVE_QUERIES, JPA.NAMED_NATIVE_QUERY);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@NamedQuery(name=\"nquery\")").append(CR);
+ sb.append("@NamedNativeQueries({" +
+ "@NamedNativeQuery(name=\"nnq1\", query=\"abcd\"), " +
+ "@NamedNativeQuery(name=\"nnq1\", query=\"abcde\")})");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithEquivalentQueries() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.NAMED_NATIVE_QUERIES, JPA.NAMED_NATIVE_QUERY, JPA.QUERY_HINT);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@NamedNativeQueries({" +
+ "@NamedNativeQuery(name=\"nnq1\", query=\"abcd\", resultClass=foo1.class, resultSetMapping=\"bar1\", " +
+ "hints={@QueryHint(name=\"nnq1hint1\", value = \"aaa\"), " +
+ "@QueryHint(name=\"nnq1hint2\", value=\"bbb\")}), " +
+ "@NamedNativeQuery(name=\"nnq1\", query=\"abcd\", resultClass=foo1.class, resultSetMapping=\"bar1\", " +
+ "hints={@QueryHint(name=\"nnq1hint1\", value = \"aaa\"), " +
+ "@QueryHint(name=\"nnq1hint2\", value=\"bbb\")})})");
+ }
+ });
+ }
+
+ public void testConvertDuplicateQueries() throws Exception {
+ createTestEntityWithDuplicateQueries();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString());
+ EntityMappings entityMappings = getEntityMappings();
+ persistenceUnit.convertJavaQueries(entityMappings, progressMonitor);
+
+ JavaEntity entity = getJavaEntity();
+ // test duplicate Java queries are not converted to eclipselink-orm.xml and
+ // not removed from the Java entity, but unique query is
+ assertEquals(0, entity.getQueryContainer().getNamedQueriesSize());
+ assertEquals(2, entity.getQueryContainer().getNamedNativeQueriesSize());
+ assertEquals(1, entityMappings.getQueryContainer().getNamedQueriesSize());
+ assertEquals(0, entityMappings.getQueryContainer().getNamedNativeQueriesSize());
+ }
+
+ public void testConvertEquivalentQueries() throws Exception {
+ createTestEntityWithEquivalentQueries();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ JavaEntity entity = getJavaEntity();
+
+ addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString());
+ EntityMappings entityMappings = getEntityMappings();
+ persistenceUnit.convertJavaQueries(entityMappings, progressMonitor);
+
+ // test only one of the equivalent Java queries are converted
+ // to eclipselink-orm.xml and the rest are removed
+ assertEquals(0, entity.getQueryContainer().getNamedNativeQueriesSize());
+ assertEquals(1, entityMappings.getQueryContainer().getNamedNativeQueriesSize());
+ }
+
+ // ************ metadata conversion of equivalent generators on EclipseLink platform*************
+
+ private ICompilationUnit createTestEntityWithDuplicateGenerators() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ID, JPA.TABLE_GENERATOR, JPA.SEQUENCE_GENERATOR);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@TableGenerator(name=\"tgen\", initialValue=100)").append(CR);
+ sb.append("@SequenceGenerator(name=\"sgen\", initialValue=10)");
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Id").append(CR);
+ sb.append("@TableGenerator(name=\"tgen\", initialValue=10)").append(CR);
+ sb.append("@SequenceGenerator(name=\"sgen\", initialValue=1)");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithEquivalentGenerators() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ID, JPA.TABLE_GENERATOR, JPA.SEQUENCE_GENERATOR);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@TableGenerator(name=\"tgen\", table=\"ID_GEN\", schema=\"APP\", catalog=\"FOO\"," +
+ "pkColumnName=\"GEN_NAME\", valueColumnName=\"GEN_VALUE\", pkColumnValue=\"TGEN\"," +
+ "allocationSize=50, initialValue=100)").append(CR);
+ sb.append("@SequenceGenerator(name=\"sgen\", sequenceName=\"Foo_Seq\", schema=\"SYS\", catalog=\"BAR\"," +
+ "allocationSize=5, initialValue=10)");
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Id").append(CR);
+ sb.append("@TableGenerator(name=\"tgen\", table=\"ID_GEN\", schema=\"APP\", catalog=\"FOO\"," +
+ "pkColumnName=\"GEN_NAME\", valueColumnName=\"GEN_VALUE\", pkColumnValue=\"TGEN\"," +
+ "allocationSize=50, initialValue=100)").append(CR);
+ sb.append("@SequenceGenerator(name=\"sgen\", sequenceName=\"Foo_Seq\", schema=\"SYS\", catalog=\"BAR\"," +
+ "allocationSize=5, initialValue=10)");
+ }
+ });
+ }
+
+ public void testConvertDuplicateGenerators() throws Exception {
+ createTestEntityWithDuplicateGenerators();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ PersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ JavaEntity entity = getJavaEntity();
+ JavaIdMapping mapping = (JavaIdMapping)entity.getIdAttribute().getMapping();
+
+ addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString());
+ EntityMappings entityMappings = getEntityMappings();
+ persistenceUnit.convertJavaGenerators(entityMappings, progressMonitor);
+
+ // test duplicate Java generators are not converted to eclipselink-orm.xml and
+ // not removed from the Java entity, but unique generator is
+ assertNotNull(entity.getGeneratorContainer().getSequenceGenerator());
+ assertNotNull(entity.getGeneratorContainer().getTableGenerator());
+ assertEquals(0, entityMappings.getSequenceGeneratorsSize());
+ assertEquals(0, entityMappings.getTableGeneratorsSize());
+ assertNotNull(mapping.getGeneratorContainer().getSequenceGenerator());
+ assertNotNull(mapping.getGeneratorContainer().getTableGenerator());
+ }
+
+ public void testConvertEquivalentGenerators() throws Exception {
+ createTestEntityWithEquivalentGenerators();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ JavaEntity entity = getJavaEntity();
+ JavaIdMapping mapping = (JavaIdMapping)entity.getIdAttribute().getMapping();
+
+ addXmlMappingFileRef(JptJpaCorePlugin.DEFAULT_ORM_XML_RUNTIME_PATH.toString());
+ EntityMappings entityMappings = getEntityMappings();
+ persistenceUnit.convertJavaGenerators(entityMappings, progressMonitor);
+
+ // test only one of the equivalent generators are converted to
+ // eclipselink-orm.xml and the rest are removed
+ assertNull(entity.getGeneratorContainer().getSequenceGenerator());
+ assertNull(entity.getGeneratorContainer().getTableGenerator());
+ assertNull(mapping.getGeneratorContainer().getSequenceGenerator());
+ assertNull(mapping.getGeneratorContainer().getTableGenerator());
+ assertEquals(1, entityMappings.getSequenceGeneratorsSize());
+ assertEquals(1, entityMappings.getTableGeneratorsSize());
+ }
+
+ // ************ entity with converters*************
+
+ private ICompilationUnit createTestEntityWithConverters() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ID, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER,
+ EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR);
+ sb.append("@TypeConverter(name=\"type\", dataType=Number.class, objectType=Integer.class)").append(CR);
+ sb.append("@ObjectTypeConverter(name=\"otype\", dataType=Character.class, objectType=String.class, " +
+ "conversionValues={@ConversionValue(dataValue=\"m\", objectValue=\"male\"), " +
+ "@ConversionValue(dataValue=\"f\", objectValue=\"female\")}," +
+ "defaultObjectValue=\"female\")").append(CR);
+ sb.append("@StructConverter(name=\"struct\", converter=\"bar\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithConverterOnConvertibleMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.ID, EclipseLink.CONVERTERS, EclipseLink.CONVERTER);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Id").append(CR);
+ sb.append("@Converters({" +
+ "@Converter(name = \"custom1\", converterClass=foo1.class)," +
+ "@Converter(name = \"custom2\", converterClass=foo2.class)})");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithConverterOnCollectionMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION,
+ "java.util.Map", EclipseLink.STRUCT_CONVERTER);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity");
+ }
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@ElementCollection").append(CR);
+ sb.append("@StructConverter(name=\"struct\", converter=\"bar\")").append(CR);
+ sb.append(" private Map<String, String> projects;");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithDuplicateConvertersOfDiffTypes() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.BASIC, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER,
+ EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR);
+ sb.append("@TypeConverter(name=\"type\")").append(CR);
+ sb.append("@ObjectTypeConverter(name=\"type\")").append(CR);
+ sb.append("@StructConverter(name=\"struct\", converter=\"bar\")");
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Basic").append(CR);
+ sb.append("@ObjectTypeConverter(name=\"otype\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntity2WithDuplicateConvertersOfSameType() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.BASIC, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER,
+ EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR);
+ sb.append("@TypeConverter(name=\"type\")").append(CR);
+ sb.append("@ObjectTypeConverter(name=\"otype\")").append(CR);
+ sb.append("@StructConverter(name=\"struct\", converter=\"bar\")");
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Basic").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=bar.class)");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEntityWithEquivalentConverters() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.ENTITY, JPA.BASIC, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER,
+ EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Entity").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR);
+ sb.append("@TypeConverter(name=\"type\")").append(CR);
+ sb.append("@ObjectTypeConverter(name=\"otype\")").append(CR);
+ sb.append("@StructConverter(name=\"struct\", converter=\"bar\")");
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Basic").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)");
+ }
+ });
+ }
+
+ public void testConvertConvertersonEntity() throws Exception {
+ createTestEntityWithConverters();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaEclipseLinkEntity entity = getJavaEntity();
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test Java converter are converted to eclipselink-orm.xml and removed from the Java entity
+ assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize());
+ assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0);
+
+ // test the mapping file converters have correct values
+ EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next();
+ assertEquals("custom", custom.getName());
+ assertEquals("foo", custom.getConverterClass());
+
+ EclipseLinkTypeConverter type = entityMappings.getConverterContainer().getTypeConverters().iterator().next();
+ assertEquals("type", type.getName());
+ assertEquals("java.lang.Number", type.getDataType());
+ assertEquals("java.lang.Integer", type.getObjectType());
+
+ EclipseLinkObjectTypeConverter otype = entityMappings.getConverterContainer().getObjectTypeConverters().iterator().next();
+ assertEquals("otype", otype.getName());
+ assertEquals("java.lang.Character", otype.getDataType());
+ assertEquals("java.lang.String", otype.getObjectType());
+ ListIterator<? extends EclipseLinkConversionValue> values = otype.getConversionValues().iterator();
+ EclipseLinkConversionValue value1 = values.next();
+ assertEquals("m", value1.getDataValue());
+ assertEquals("male", value1.getObjectValue());
+ EclipseLinkConversionValue value2 = values.next();
+ assertEquals("f", value2.getDataValue());
+ assertEquals("female", value2.getObjectValue());
+ assertEquals("female", otype.getDefaultObjectValue());
+
+ EclipseLinkStructConverter struct = entityMappings.getConverterContainer().getStructConverters().iterator().next();
+ assertEquals("struct", struct.getName());
+ assertEquals("bar", struct.getConverterClass());
+ }
+
+ public void testConvertConvertersOnEntityConvertibleMapping() throws Exception {
+ createTestEntityWithConverterOnConvertibleMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaEclipseLinkEntity entity = getJavaEntity();
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity
+ assertEquals(2, entityMappings.getConverterContainer().getCustomConvertersSize());
+
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getIdAttribute().getMapping();
+
+ assertEquals(mapping.getConverterContainer().getConvertersSize(), 0);
+
+ // test the mapping file converter have correct values
+ Collection<OrmEclipseLinkCustomConverter> customConverters = CollectionTools.collection(entityMappings.getConverterContainer().getCustomConverters());
+ EclipseLinkCustomConverter custom1 = Generic2_0JpaMetadataConversionTests.selectNodeNamed(customConverters, "custom1");
+ assertEquals("custom1", custom1.getName());
+ assertEquals("foo1", custom1.getConverterClass());
+ EclipseLinkCustomConverter custom2 = Generic2_0JpaMetadataConversionTests.selectNodeNamed(customConverters, "custom2");
+ assertEquals("custom2", custom2.getName());
+ assertEquals("foo2", custom2.getConverterClass());
+ }
+
+ public void testConvertConvertersOnCollectionMapping() throws Exception {
+ createTestEntityWithConverterOnCollectionMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaEclipseLinkEntity entity = getJavaEntity();
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity
+ assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize());
+
+ if (entity.getAttributeMappings().iterator().hasNext()) {
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next();
+ assertEquals(mapping.getConverterContainer().getConvertersSize(), 0);
+ }
+
+ // test the mapping file converter have correct values
+ EclipseLinkStructConverter custom = entityMappings.getConverterContainer().getStructConverters().iterator().next();
+ assertEquals("struct", custom.getName());
+ assertEquals("bar", custom.getConverterClass());
+
+ // TODO test converting converter on map key - not supported yet
+ }
+
+ public void testConvertOverriddenConverters() throws Exception {
+ createTestEntityWithDuplicateConvertersOfDiffTypes();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+ OrmEclipseLinkConverterContainer ormConvertercontainer = entityMappings.getConverterContainer();
+ EclipseLinkCustomConverter converter = ormConvertercontainer.addCustomConverter(ormConvertercontainer.getCustomConvertersSize());
+ converter.setName("type");
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ JavaEclipseLinkEntity entity = getJavaEntity();
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next();
+ assertTrue(CollectionTools.contains(persistenceUnit.getConverters(), mapping.getConverterContainer().getConverters().iterator().next()));
+
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test overriden Java converters are not converted to eclipselink-orm.xml and
+ // not removed from the Java entity, but unique converters are
+ assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 1);
+ assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 1);
+ assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0);
+ assertEquals(mapping.getConverterContainer().getObjectTypeConvertersSize(), 0);
+ assertEquals(2, ormConvertercontainer.getCustomConvertersSize());
+ assertEquals(1, ormConvertercontainer.getStructConvertersSize());
+ assertEquals(0, ormConvertercontainer.getTypeConvertersSize());
+ assertEquals(1, ormConvertercontainer.getObjectTypeConvertersSize());
+ }
+
+ public void testConvertDuplicateConvertersWithDiffTypes() throws Exception {
+ createTestEntityWithDuplicateConvertersOfDiffTypes();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ JavaEclipseLinkEntity entity = getJavaEntity();
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next();
+
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test duplicate Java converters are not converted to eclipselink-orm.xml and
+ // not removed from the Java entity, but unique converters are
+ assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 1);
+ assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 1);
+ assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0);
+ assertEquals(mapping.getConverterContainer().getObjectTypeConvertersSize(), 0);
+ assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize());
+ assertEquals(0, entityMappings.getConverterContainer().getTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize());
+ }
+
+ public void testConvertDuplicateConvertersWithSameType() throws Exception {
+ createTestEntity2WithDuplicateConvertersOfSameType();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ JavaEclipseLinkEntity entity = getJavaEntity();
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next();
+
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test duplicate Java converters are not converted to eclipselink-orm.xml and
+ // not removed from the Java entity, but unique converters are
+ assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 1);
+ assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0);
+ assertEquals(mapping.getConverterContainer().getCustomConvertersSize(), 1);
+ assertEquals(0, entityMappings.getConverterContainer().getCustomConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize());
+ }
+
+ public void testConvertEquivalentConverters() throws Exception {
+ createTestEntityWithEquivalentConverters();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+
+ JavaEclipseLinkEntity entity = getJavaEntity();
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)entity.getAttributeMappings().iterator().next();
+
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test only one of the equivalent converters is converted to
+ // eclipselink-orm.xml and the rest are removed
+ assertEquals(entity.getConverterContainer().getCustomConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getTypeConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getObjectTypeConvertersSize(), 0);
+ assertEquals(entity.getConverterContainer().getStructConvertersSize(), 0);
+ assertEquals(mapping.getConverterContainer().getCustomConvertersSize(), 0);
+ assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize());
+ }
+
+ // ************ embeddable with converters*************
+
+ private ICompilationUnit createTestEmbeddableWithConverters() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.EMBEDDABLE, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER,
+ EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Embeddable").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR);
+ sb.append("@TypeConverter(name=\"type\", dataType=Number.class, objectType=Integer.class)").append(CR);
+ sb.append("@ObjectTypeConverter(name=\"otype\", dataType=Character.class, objectType=String.class, " +
+ "conversionValues={@ConversionValue(dataValue=\"m\", objectValue=\"male\"), " +
+ "@ConversionValue(dataValue=\"f\", objectValue=\"female\")}," +
+ "defaultObjectValue=\"female\")").append(CR);
+ sb.append("@StructConverter(name=\"struct\", converter=\"bar\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestEmbeddableWithConverterOnConvertibleMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.EMBEDDABLE, JPA.VERSION, EclipseLink.CONVERTER);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Embeddable").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Version").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)");
+ }
+ });
+ }
+
+ public void testConvertConvertersOnEmbeddable() throws Exception {
+ createTestEmbeddableWithConverters();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaEclipseLinkEmbeddable embeddable = getJavaEmbeddable();
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test Java converter are converted to eclipselink-orm.xml and removed from the Java entity
+ assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize());
+ assertEquals(embeddable.getConverterContainer().getCustomConvertersSize(), 0);
+ assertEquals(embeddable.getConverterContainer().getTypeConvertersSize(), 0);
+ assertEquals(embeddable.getConverterContainer().getObjectTypeConvertersSize(), 0);
+ assertEquals(embeddable.getConverterContainer().getStructConvertersSize(), 0);
+
+ // test the mapping file converters have correct values
+ EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next();
+ assertEquals("custom", custom.getName());
+ assertEquals("foo", custom.getConverterClass());
+
+ EclipseLinkTypeConverter type = entityMappings.getConverterContainer().getTypeConverters().iterator().next();
+ assertEquals("type", type.getName());
+ assertEquals("java.lang.Number", type.getDataType());
+ assertEquals("java.lang.Integer", type.getObjectType());
+
+ EclipseLinkObjectTypeConverter otype = entityMappings.getConverterContainer().getObjectTypeConverters().iterator().next();
+ assertEquals("otype", otype.getName());
+ assertEquals("java.lang.Character", otype.getDataType());
+ assertEquals("java.lang.String", otype.getObjectType());
+ ListIterator<? extends EclipseLinkConversionValue> values = otype.getConversionValues().iterator();
+ EclipseLinkConversionValue value1 = values.next();
+ assertEquals("m", value1.getDataValue());
+ assertEquals("male", value1.getObjectValue());
+ EclipseLinkConversionValue value2 = values.next();
+ assertEquals("f", value2.getDataValue());
+ assertEquals("female", value2.getObjectValue());
+ assertEquals("female", otype.getDefaultObjectValue());
+
+ EclipseLinkStructConverter struct = entityMappings.getConverterContainer().getStructConverters().iterator().next();
+ assertEquals("struct", struct.getName());
+ assertEquals("bar", struct.getConverterClass());
+ }
+
+ public void testConvertConvertersOnEmbeddableConvertibleMapping() throws Exception {
+ createTestEmbeddableWithConverterOnConvertibleMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaEclipseLinkEmbeddable embeddable = getJavaEmbeddable();
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity
+ assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize());
+
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)embeddable.getAttributeMappings().iterator().next();
+ assertEquals(mapping.getConverterContainer().getConvertersSize(), 0);
+
+ // test the mapping file converter have correct values
+ EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next();
+ assertEquals("custom", custom.getName());
+ assertEquals("foo", custom.getConverterClass());
+ }
+
+ // ************ mapped superclass with converters*************
+ private ICompilationUnit createTestMappedSuperclassWithConverters() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.MAPPED_SUPERCLASS, EclipseLink.CONVERTER, EclipseLink.TYPE_CONVERTER,
+ EclipseLink.OBJECT_TYPE_CONVERTER, EclipseLink.STRUCT_CONVERTER, EclipseLink.CONVERSION_VALUE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@MappedSuperclass").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)").append(CR);
+ sb.append("@TypeConverter(name=\"type\", dataType=Number.class, objectType=Integer.class)").append(CR);
+ sb.append("@ObjectTypeConverter(name=\"otype\", dataType=Character.class, objectType=String.class, " +
+ "conversionValues={@ConversionValue(dataValue=\"m\", objectValue=\"male\"), " +
+ "@ConversionValue(dataValue=\"f\", objectValue=\"female\")}," +
+ "defaultObjectValue=\"female\")").append(CR);
+ sb.append("@StructConverter(name=\"struct\", converter=\"bar\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestMappedSuperclassWithConverterOnConvertibleMapping() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(JPA.MAPPED_SUPERCLASS, JPA.ID, EclipseLink.CONVERTER);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@MappedSuperclass").append(CR);
+ }
+
+ @Override
+ public void appendIdFieldAnnotationTo(StringBuilder sb) {
+ sb.append("@Id").append(CR);
+ sb.append("@Converter(name=\"custom\", converterClass=foo.class)");
+ }
+ });
+ }
+
+ public void testConvertConvertersOnMappedSuperclass() throws Exception {
+ createTestMappedSuperclassWithConverters();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaEclipseLinkMappedSuperclass mappedSuperclass = getJavaMappedSuperclass();
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test Java converter are converted to eclipselink-orm.xml and removed from the Java entity
+ assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getObjectTypeConvertersSize());
+ assertEquals(1, entityMappings.getConverterContainer().getStructConvertersSize());
+ assertEquals(mappedSuperclass.getConverterContainer().getCustomConvertersSize(), 0);
+ assertEquals(mappedSuperclass.getConverterContainer().getTypeConvertersSize(), 0);
+ assertEquals(mappedSuperclass.getConverterContainer().getObjectTypeConvertersSize(), 0);
+ assertEquals(mappedSuperclass.getConverterContainer().getStructConvertersSize(), 0);
+
+ // test the mapping file converters have correct values
+ EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next();
+ assertEquals("custom", custom.getName());
+ assertEquals("foo", custom.getConverterClass());
+
+ EclipseLinkTypeConverter type = entityMappings.getConverterContainer().getTypeConverters().iterator().next();
+ assertEquals("type", type.getName());
+ assertEquals("java.lang.Number", type.getDataType());
+ assertEquals("java.lang.Integer", type.getObjectType());
+
+ EclipseLinkObjectTypeConverter otype = entityMappings.getConverterContainer().getObjectTypeConverters().iterator().next();
+ assertEquals("otype", otype.getName());
+ assertEquals("java.lang.Character", otype.getDataType());
+ assertEquals("java.lang.String", otype.getObjectType());
+ ListIterator<? extends EclipseLinkConversionValue> values = otype.getConversionValues().iterator();
+ EclipseLinkConversionValue value1 = values.next();
+ assertEquals("m", value1.getDataValue());
+ assertEquals("male", value1.getObjectValue());
+ EclipseLinkConversionValue value2 = values.next();
+ assertEquals("f", value2.getDataValue());
+ assertEquals("female", value2.getObjectValue());
+ assertEquals("female", otype.getDefaultObjectValue());
+
+ EclipseLinkStructConverter struct = entityMappings.getConverterContainer().getStructConverters().iterator().next();
+ assertEquals("struct", struct.getName());
+ assertEquals("bar", struct.getConverterClass());
+ }
+
+ public void testConvertConvertersOnMappedSuperclassConvertibleMapping() throws Exception {
+ createTestMappedSuperclassWithConverterOnConvertibleMapping();
+ addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+ JavaEclipseLinkMappedSuperclass mappedSuperclass = getJavaMappedSuperclass();
+ addXmlMappingFileRef(JptJpaEclipseLinkCorePlugin.DEFAULT_ECLIPSELINK_ORM_XML_RUNTIME_PATH.toString());
+ EclipseLinkEntityMappings entityMappings = getEntityMappings();
+
+ EclipseLinkPersistenceUnit persistenceUnit = getPersistenceUnit();
+ persistenceUnit.convertJavaConverters(entityMappings, progressMonitor);
+
+ // test Java converter on attribute mapping is converted to eclipselink-orm.xml and removed from the Java entity
+ assertEquals(1, entityMappings.getConverterContainer().getCustomConvertersSize());
+
+ EclipseLinkConvertibleMapping mapping = (EclipseLinkConvertibleMapping)mappedSuperclass.getAttributeMappings().iterator().next();
+ assertEquals(mapping.getConverterContainer().getConvertersSize(), 0);
+
+ // test the mapping file converter have correct values
+ EclipseLinkCustomConverter custom = entityMappings.getConverterContainer().getCustomConverters().iterator().next();
+ assertEquals("custom", custom.getName());
+ assertEquals("foo", custom.getConverterClass());
+ }
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java
new file mode 100644
index 0000000000..d6ca4d10f5
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/EclipseLinkPersistenceUnitTestCase.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence;
+
+import org.eclipse.jpt.common.utility.internal.model.value.SimplePropertyValueModel;
+import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
+import org.eclipse.jpt.jpa.core.internal.facet.JpaFacetDataModelProperties;
+import org.eclipse.jpt.jpa.core.tests.internal.context.persistence.PersistenceUnitTestCase;
+import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
+import org.eclipse.jpt.jpa.eclipselink.core.platform.EclipseLinkPlatform;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+/**
+ * PersistenceUnitTestCase
+ */
+public abstract class EclipseLinkPersistenceUnitTestCase extends PersistenceUnitTestCase
+{
+ protected EclipseLinkPersistenceUnit subject;
+
+ protected PropertyValueModel<EclipseLinkPersistenceUnit> subjectHolder;
+
+ // ********** constructors **********
+ protected EclipseLinkPersistenceUnitTestCase(String name) {
+ super(name);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ this.subject = this.getPersistenceUnit();
+ this.subjectHolder = new SimplePropertyValueModel<EclipseLinkPersistenceUnit>(this.subject);
+ this.populatePu();
+ }
+
+ @Override
+ protected IDataModel buildJpaConfigDataModel() {
+ IDataModel dataModel = super.buildJpaConfigDataModel();
+ dataModel.setProperty(JpaFacetDataModelProperties.PLATFORM, EclipseLinkPlatform.VERSION_1_0);
+ return dataModel;
+ }
+
+ @Override
+ protected EclipseLinkPersistenceUnit getPersistenceUnit() {
+ return (EclipseLinkPersistenceUnit) super.getPersistenceUnit();
+ }
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java
new file mode 100644
index 0000000000..3525425419
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/JptEclipseLinkCorePersistenceContextModelTests.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2011 Oracle.
+ * 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:
+ * Oracle - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+public class JptEclipseLinkCorePersistenceContextModelTests extends TestCase
+{
+ public static Test suite() {
+ TestSuite suite = new TestSuite(JptEclipseLinkCorePersistenceContextModelTests.class.getName());
+ suite.addTestSuite(EclipseLinkPersistenceUnitTests.class);
+ suite.addTestSuite(GeneralPropertiesValueModelTests.class);
+ suite.addTestSuite(GeneralPropertiesAdapterTests.class);
+// suite.addTestSuite(ConnectionValueModelTests.class);
+ suite.addTestSuite(EclipseLinkConnectionTests.class);
+ suite.addTestSuite(CustomizationValueModelTests.class);
+ suite.addTestSuite(EclipseLinkCustomizationTests.class);
+ suite.addTestSuite(CachingValueModelTests.class);
+ suite.addTestSuite(CachingAdapterTests.class);
+ suite.addTestSuite(LoggingValueModelTests.class);
+ suite.addTestSuite(LoggingAdapterTests.class);
+ suite.addTestSuite(OptionsValueModelTests.class);
+ suite.addTestSuite(OptionsAdapterTests.class);
+ suite.addTestSuite(SchemaGenerationValueModelTests.class);
+ suite.addTestSuite(SchemaGenerationBasicAdapterTests.class);
+ suite.addTestSuite(SchemaGenerationAdapterTests.class);
+ suite.addTestSuite(EclipseLink2_0ConnectionTests.class);
+ suite.addTestSuite(EclipseLink2_0LoggingTests.class);
+ suite.addTestSuite(EclipseLink2_0OptionsTests.class);
+ suite.addTestSuite(EclipseLink2_2JpaMetadataConversionTests.class);
+ return suite;
+ }
+
+ private JptEclipseLinkCorePersistenceContextModelTests() {
+ super();
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java
new file mode 100644
index 0000000000..9638330836
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/context/persistence/SchemaGenerationBasicAdapterTests.java
@@ -0,0 +1,153 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.persistence;
+
+import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
+import org.eclipse.jpt.common.utility.internal.model.value.ItemPropertyListValueModelAdapter;
+import org.eclipse.jpt.common.utility.internal.model.value.ListAspectAdapter;
+import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener;
+import org.eclipse.jpt.common.utility.model.value.ListValueModel;
+import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
+import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnitProperties;
+import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.DdlGenerationType;
+import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
+import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.OutputMode;
+import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.SchemaGeneration;
+
+/**
+ * Tests the update of OutputMode model object by the SchemaGeneration adapter
+ * when the PersistenceUnit changes.
+ */
+@SuppressWarnings("nls")
+public class SchemaGenerationBasicAdapterTests extends EclipseLinkPersistenceUnitTestCase
+{
+ private SchemaGeneration schemaGeneration;
+
+ public static final String outputModeKey = SchemaGeneration.ECLIPSELINK_DDL_GENERATION_OUTPUT_MODE;
+ public static final String ddlGenTypeKey = SchemaGeneration.ECLIPSELINK_DDL_GENERATION_TYPE;
+
+ public static final OutputMode OUTPUT_MODE_TEST_VALUE = OutputMode.sql_script;
+ public static final OutputMode OUTPUT_MODE_TEST_VALUE_2 = OutputMode.database;
+
+ public static final DdlGenerationType DDL_GENERATION_TYPE_TEST_VALUE = DdlGenerationType.drop_and_create_tables;
+ public static final DdlGenerationType DDL_GENERATION_TYPE_TEST_VALUE_2 = DdlGenerationType.none;
+
+ public SchemaGenerationBasicAdapterTests(String name) {
+ super(name);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ this.schemaGeneration = this.subject.getSchemaGeneration();
+ PropertyChangeListener propertyChangeListener = this.buildPropertyChangeListener();
+ this.schemaGeneration.addPropertyChangeListener(SchemaGeneration.OUTPUT_MODE_PROPERTY, propertyChangeListener);
+ this.schemaGeneration.addPropertyChangeListener(SchemaGeneration.DDL_GENERATION_TYPE_PROPERTY, propertyChangeListener);
+ this.clearEvent();
+ }
+
+ /**
+ * Initializes directly the PU properties before testing. Cannot use
+ * Property Holder to initialize because it is not created yet
+ */
+ @Override
+ protected void populatePu() {
+ this.propertiesTotal = 6;
+ this.modelPropertiesSizeOriginal = 2;
+ this.modelPropertiesSize = this.modelPropertiesSizeOriginal;
+
+ this.persistenceUnitSetProperty("property.0", "value.0");
+ this.persistenceUnitSetProperty(outputModeKey, this.getPropertyStringValueOf(OUTPUT_MODE_TEST_VALUE));
+ this.persistenceUnitSetProperty("property.2", "value.2");
+ this.persistenceUnitSetProperty("property.3", "value.3");
+ this.persistenceUnitSetProperty("property.4", "value.4");
+ this.persistenceUnitSetProperty(ddlGenTypeKey, this.getPropertyStringValueOf(DDL_GENERATION_TYPE_TEST_VALUE));
+ return;
+ }
+
+ /** ****** test methods ******* */
+
+ /**
+ * Tests the update of OutputMode property by the SchemaGeneration adapter
+ * when the PU changes.
+ */
+ public void testOutputModeUpdate() throws Exception {
+ ListValueModel<PersistenceUnit.Property> propertiesAdapter = this.buildPropertiesAdapter(this.subjectHolder);
+ ListValueModel<PersistenceUnit.Property> propertyListAdapter = new ItemPropertyListValueModelAdapter<PersistenceUnit.Property>(propertiesAdapter, PersistenceUnit.Property.VALUE_PROPERTY);
+
+ this.verifyHasListeners(this.schemaGeneration, SchemaGeneration.OUTPUT_MODE_PROPERTY);
+
+ // Basic
+ assertTrue(schemaGeneration.itemIsProperty(this.getPersistenceUnit().getProperty(outputModeKey)));
+ assertEquals(OUTPUT_MODE_TEST_VALUE, this.schemaGeneration.getOutputMode());
+
+ // Replace
+ this.persistenceUnitSetProperty(outputModeKey, OUTPUT_MODE_TEST_VALUE_2);
+ this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE_2, this.schemaGeneration.getOutputMode());
+
+ // Remove
+ this.clearEvent();
+ --this.propertiesTotal;
+ --this.modelPropertiesSize;
+ this.getPersistenceUnit().removeProperty(outputModeKey);
+ assertNull(this.getPersistenceUnit().getProperty(outputModeKey));
+ assertEquals(this.modelPropertiesSize, this.modelPropertiesSizeOriginal - 1);
+ assertNotNull(this.propertyChangedEvent);
+ assertNull(this.propertyChangedEvent.getNewValue());
+
+ // Add original OutputMode
+ ++this.propertiesTotal;
+ ++this.modelPropertiesSize;
+ this.persistenceUnitSetProperty(outputModeKey, OUTPUT_MODE_TEST_VALUE);
+ this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE, this.schemaGeneration.getOutputMode());
+
+ // Replace again
+ this.persistenceUnitSetProperty(outputModeKey, OUTPUT_MODE_TEST_VALUE_2);
+ this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE_2, this.schemaGeneration.getOutputMode());
+
+ // Replace by setting model object
+ this.clearEvent();
+ this.schemaGeneration.setOutputMode(OUTPUT_MODE_TEST_VALUE);
+ this.verifyPutEvent(SchemaGeneration.OUTPUT_MODE_PROPERTY, OUTPUT_MODE_TEST_VALUE, this.schemaGeneration.getOutputMode());
+ }
+
+ // ****** convenience methods *******
+ @Override
+ protected PersistenceUnitProperties getModel() {
+ return this.schemaGeneration;
+ }
+
+ private ListValueModel<PersistenceUnit.Property> buildPropertiesAdapter(PropertyValueModel<EclipseLinkPersistenceUnit> subjectHolder) {
+ return new ListAspectAdapter<EclipseLinkPersistenceUnit, PersistenceUnit.Property>(subjectHolder, PersistenceUnit.PROPERTIES_LIST) {
+ @Override
+ protected ListIterable<PersistenceUnit.Property> getListIterable() {
+ return this.subject.getProperties();
+ }
+
+ @Override
+ protected int size_() {
+ return this.subject.getPropertiesSize();
+ }
+ };
+ }
+
+ // ********** get/set property **********
+ @Override
+ protected void setProperty(String propertyName, Object newValue) throws Exception {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ protected Object getProperty(String propertyName) throws NoSuchFieldException {
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java
new file mode 100644
index 0000000000..e10ad455cf
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/metadata/EclipseLinkStaticWeavingBuilderMetadataTests.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+* Copyright (c) 2012 Oracle. 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:
+* Oracle - initial API and implementation
+*******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.metadata;
+
+import junit.framework.Assert;
+
+import org.eclipse.jpt.jpa.core.tests.internal.metadata.JpaMetadataTests;
+import org.eclipse.jpt.jpa.eclipselink.core.builder.EclipseLinkStaticWeavingBuilderConfigurator;
+
+/**
+ * JpaStaticWeavingBuilderMetadataTests
+ */
+public class EclipseLinkStaticWeavingBuilderMetadataTests extends JpaMetadataTests {
+
+ public static final String SOURCE_PREF_KEY = "staticweave.SOURCE"; //$NON-NLS-1$
+ public static final String LOG_LEVEL_PREF_KEY = "staticweave.LOG_LEVEL"; //$NON-NLS-1$
+
+ public static final String SOURCE_TEST_VALUE = "bin"; //$NON-NLS-1$
+ public static final String LOG_LEVEL_TEST_VALUE = "ALL"; //$NON-NLS-1$
+
+ protected EclipseLinkStaticWeavingBuilderConfigurator projectPrefsManager;
+
+ // ********** constructor **********
+
+ public EclipseLinkStaticWeavingBuilderMetadataTests(String name) {
+ super(name);
+ }
+
+ // ********** overrides **********
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ this.projectPrefsManager = new EclipseLinkStaticWeavingBuilderConfigurator(this.getJavaProject().getProject());
+ Assert.assertNotNull(this.projectPrefsManager);
+ }
+
+ // ********** tests **********
+
+ public void testSourceLocationProjectMetadata() throws Exception {
+
+ this.projectPrefsManager.setSourceLocationPreference(SOURCE_TEST_VALUE);
+ this.projectPrefsManager.getLegacyProjectPreferences().flush();
+
+ String value = this.getProjectPrefs().get(SOURCE_PREF_KEY);
+ Assert.assertNotNull(value);
+ Assert.assertTrue(SOURCE_TEST_VALUE.equals(value));
+ }
+
+ public void testLogLevelProjectMetadata() throws Exception {
+
+ this.projectPrefsManager.setLogLevelPreference(LOG_LEVEL_TEST_VALUE);
+ this.projectPrefsManager.getLegacyProjectPreferences().flush();
+
+ String value = this.getProjectPrefs().get(LOG_LEVEL_PREF_KEY);
+ Assert.assertNotNull(value);
+ Assert.assertTrue(LOG_LEVEL_TEST_VALUE.equals(value));
+ }
+} \ No newline at end of file
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java
new file mode 100644
index 0000000000..e521e0b6f8
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_0JavaResourceModelTestCase.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java;
+
+import org.eclipse.jpt.common.core.AnnotationProvider;
+import org.eclipse.jpt.jpa.core.internal.GenericJpaAnnotationDefinitionProvider;
+import org.eclipse.jpt.jpa.core.internal.JpaAnnotationProvider;
+import org.eclipse.jpt.jpa.core.tests.internal.resource.java.JpaJavaResourceModelTestCase;
+import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLink2_0JpaAnnotationDefinitionProvider;
+
+public class EclipseLink2_0JavaResourceModelTestCase extends JpaJavaResourceModelTestCase
+{
+
+ public static final String ECLIPSELINK_ANNOTATIONS_PACKAGE_NAME = "org.eclipse.persistence.annotations"; //$NON-NLS-1$
+
+ public EclipseLink2_0JavaResourceModelTestCase(String name) {
+ super(name);
+ }
+
+ @Override
+ protected AnnotationProvider buildAnnotationProvider() {
+ return new JpaAnnotationProvider(
+ GenericJpaAnnotationDefinitionProvider.instance(),
+ EclipseLink2_0JpaAnnotationDefinitionProvider.instance());
+ }
+
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java
new file mode 100644
index 0000000000..299511293c
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLink2_3JavaResourceModelTestCase.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java;
+
+import org.eclipse.jpt.common.core.AnnotationProvider;
+import org.eclipse.jpt.jpa.core.internal.GenericJpaAnnotationDefinitionProvider;
+import org.eclipse.jpt.jpa.core.internal.JpaAnnotationProvider;
+import org.eclipse.jpt.jpa.core.tests.internal.resource.java.JpaJavaResourceModelTestCase;
+import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLink2_3JpaAnnotationDefinitionProvider;
+
+public class EclipseLink2_3JavaResourceModelTestCase extends JpaJavaResourceModelTestCase
+{
+
+ public static final String ECLIPSELINK_ANNOTATIONS_PACKAGE_NAME = "org.eclipse.persistence.annotations"; //$NON-NLS-1$
+
+ public EclipseLink2_3JavaResourceModelTestCase(String name) {
+ super(name);
+ }
+
+ @Override
+ protected AnnotationProvider buildAnnotationProvider() {
+ return new JpaAnnotationProvider(
+ GenericJpaAnnotationDefinitionProvider.instance(),
+ EclipseLink2_3JpaAnnotationDefinitionProvider.instance());
+ }
+
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java
new file mode 100644
index 0000000000..d7c44fbc50
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.java
@@ -0,0 +1,330 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java;
+
+import java.util.Iterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jpa.core.resource.java.DiscriminatorType;
+import org.eclipse.jpt.jpa.core.resource.java.JPA;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkTenantDiscriminatorColumnAnnotation2_3;
+
+@SuppressWarnings("nls")
+public class EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests extends EclipseLink2_3JavaResourceModelTestCase {
+
+ private static final String COLUMN_NAME = "MY_COLUMN";
+ private static final String COLUMN_COLUMN_DEFINITION = "COLUMN_DEFINITION";
+ private static final String COLUMN_CONTEXT_PROPERTY = "eclipselink.foo-id";
+ private static final String COLUMN_TABLE = "MY_TABLE";
+
+ public EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests(String name) {
+ super(name);
+ }
+
+ private ICompilationUnit createTestTenantDiscriminatorColumn() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestTenantDiscriminatorColumnWithName() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn(name = \"" + COLUMN_NAME + "\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestTenantDiscriminatorColumnWithColumnDefinition() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn(columnDefinition = \"" + COLUMN_COLUMN_DEFINITION + "\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestTenantDiscriminatorColumnWithContextProperty() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn(contextProperty = \"" + COLUMN_CONTEXT_PROPERTY + "\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestTenantDiscriminatorColumnWithTable() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn(table = \"" + COLUMN_TABLE + "\")");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestTenenatDiscriminatorColumnWithDiscriminatorType() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN, JPA.DISCRIMINATOR_TYPE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn(discriminatorType = DiscriminatorType.CHAR)");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestColumnWithIntElement(final String intElement) throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn(" + intElement + " = 5)");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestColumnWithBooleanElement(final String booleanElement) throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@TenantDiscriminatorColumn(" + booleanElement + " = true)");
+ }
+ });
+ }
+
+ public void testGetName() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithName();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ assertNotNull(column);
+ assertEquals(COLUMN_NAME, column.getName());
+ }
+
+ public void testGetNull() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ assertNotNull(column);
+ assertNull(column.getName());
+ assertNull(column.getDiscriminatorType());
+ assertNull(column.getColumnDefinition());
+ }
+
+ public void testSetName() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertNotNull(column);
+ assertNull(column.getName());
+
+ column.setName("Foo");
+ assertEquals("Foo", column.getName());
+
+ assertSourceContains("@TenantDiscriminatorColumn(name = \"Foo\")", cu);
+ }
+
+ public void testSetNameNull() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithName();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertEquals(COLUMN_NAME, column.getName());
+
+ column.setName(null);
+ assertNull(column.getName());
+
+ assertSourceDoesNotContain("(name", cu);
+ }
+
+ public void testGetColumnDefinition() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithColumnDefinition();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ assertEquals(COLUMN_COLUMN_DEFINITION, column.getColumnDefinition());
+ }
+
+ public void testSetColumnDefinition() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertNotNull(column);
+ assertNull(column.getColumnDefinition());
+
+ column.setColumnDefinition("Foo");
+ assertEquals("Foo", column.getColumnDefinition());
+
+ assertSourceContains("@TenantDiscriminatorColumn(columnDefinition = \"Foo\")", cu);
+
+
+ column.setColumnDefinition(null);
+ assertSourceDoesNotContain("(columnDefinition", cu);
+ }
+
+ public void testGetLength() throws Exception {
+ ICompilationUnit cu = this.createTestColumnWithIntElement("length");
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertEquals(Integer.valueOf(5), column.getLength());
+ }
+
+ public void testSetLength() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertNotNull(column);
+ assertNull(column.getLength());
+
+ column.setLength(Integer.valueOf(5));
+ assertEquals(Integer.valueOf(5), column.getLength());
+
+ assertSourceContains("@TenantDiscriminatorColumn(length = 5)", cu);
+
+ column.setLength(null);
+ assertSourceDoesNotContain("(length", cu);
+ }
+
+ public void testGetDiscriminatorType() throws Exception {
+ ICompilationUnit cu = this.createTestTenenatDiscriminatorColumnWithDiscriminatorType();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ assertEquals(DiscriminatorType.CHAR, column.getDiscriminatorType());
+ }
+
+ public void testSetDiscriminatorType() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertNull(column.getDiscriminatorType());
+
+ column.setDiscriminatorType(DiscriminatorType.INTEGER);
+ assertEquals(DiscriminatorType.INTEGER, column.getDiscriminatorType());
+
+ assertSourceContains("@TenantDiscriminatorColumn(discriminatorType = INTEGER)", cu);
+
+ column.setDiscriminatorType(null);
+ assertSourceDoesNotContain("(discriminatorType", cu);
+ }
+
+ public void testGetContextProperty() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithContextProperty();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ assertEquals(COLUMN_CONTEXT_PROPERTY, column.getContextProperty());
+ }
+
+ public void testSetContextProperty() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertNotNull(column);
+ assertNull(column.getContextProperty());
+
+ column.setContextProperty("Foo");
+ assertEquals("Foo", column.getContextProperty());
+
+ assertSourceContains("@TenantDiscriminatorColumn(contextProperty = \"Foo\")", cu);
+
+
+ column.setContextProperty(null);
+ assertSourceDoesNotContain("(contextProperty", cu);
+ }
+
+ public void testGetTable() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumnWithTable();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+ assertEquals(COLUMN_TABLE, column.getTable());
+ }
+
+ public void testSetTable() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertNotNull(column);
+ assertNull(column.getTable());
+
+ column.setTable("Foo");
+ assertEquals("Foo", column.getTable());
+
+ assertSourceContains("@TenantDiscriminatorColumn(table = \"Foo\")", cu);
+
+
+ column.setTable(null);
+ assertSourceDoesNotContain("(table", cu);
+ }
+
+ public void testGetPrimaryKey() throws Exception {
+ ICompilationUnit cu = this.createTestColumnWithBooleanElement("primaryKey");
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertEquals(Boolean.TRUE, column.getPrimaryKey());
+ }
+
+ public void testSetPrimaryKey() throws Exception {
+ ICompilationUnit cu = this.createTestTenantDiscriminatorColumn();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+ EclipseLinkTenantDiscriminatorColumnAnnotation2_3 column = (EclipseLinkTenantDiscriminatorColumnAnnotation2_3) resourceType.getAnnotation(0, EclipseLink.TENANT_DISCRIMINATOR_COLUMN);
+
+ assertNotNull(column);
+ assertNull(column.getPrimaryKey());
+
+ column.setPrimaryKey(Boolean.FALSE);
+ assertEquals(Boolean.FALSE, column.getPrimaryKey());
+
+ assertSourceContains("@TenantDiscriminatorColumn(primaryKey = false)", cu);
+
+ column.setPrimaryKey(null);
+ assertSourceDoesNotContain("primaryKey", cu);
+ }
+
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java
new file mode 100644
index 0000000000..390048d533
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/EclipselinkMultitenantAnnotation2_3Tests.java
@@ -0,0 +1,138 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java;
+
+import java.util.Iterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceType;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLink;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkMultitenantAnnotation2_3;
+import org.eclipse.jpt.jpa.eclipselink.core.resource.java.MultitenantType2_3;
+
+@SuppressWarnings("nls")
+public class EclipselinkMultitenantAnnotation2_3Tests extends EclipseLink2_3JavaResourceModelTestCase {
+
+ public EclipselinkMultitenantAnnotation2_3Tests(String name) {
+ super(name);
+ }
+
+ private ICompilationUnit createTestMultitenant() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.MULTITENANT);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Multitenant");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestMultitenantWithValue() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.MULTITENANT, EclipseLink.MULTITENANT_TYPE);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Multitenant(MultitenantType.SINGLE_TABLE)");
+ }
+ });
+ }
+
+ private ICompilationUnit createTestCacheWithIncludeCriteria() throws Exception {
+ return this.createTestType(new DefaultAnnotationWriter() {
+ @Override
+ public Iterator<String> imports() {
+ return new ArrayIterator<String>(EclipseLink.MULTITENANT);
+ }
+ @Override
+ public void appendTypeAnnotationTo(StringBuilder sb) {
+ sb.append("@Multitenant(includeCriteria=true)");
+ }
+ });
+ }
+
+ public void testMultitenant() throws Exception {
+ ICompilationUnit cu = this.createTestMultitenant();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+
+ EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT);
+ assertNotNull(multitenant);
+ }
+
+ public void testGetValue() throws Exception {
+ ICompilationUnit cu = this.createTestMultitenantWithValue();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+
+ EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT);
+ assertEquals(MultitenantType2_3.SINGLE_TABLE, multitenant.getValue());
+ }
+
+ public void testSetValue() throws Exception {
+ ICompilationUnit cu = this.createTestMultitenantWithValue();
+ JavaResourceType resourceType = buildJavaResourceType(cu);
+
+ EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT);
+ assertEquals(MultitenantType2_3.SINGLE_TABLE, multitenant.getValue());
+
+ multitenant.setValue(MultitenantType2_3.TABLE_PER_TENANT);
+ assertEquals(MultitenantType2_3.TABLE_PER_TENANT, multitenant.getValue());
+
+ assertSourceContains("@Multitenant(TABLE_PER_TENANT)", cu);
+
+ multitenant.setValue(null);
+ assertNull(multitenant.getValue());
+
+ assertSourceDoesNotContain("(TABLE_PER_TENANT)", cu);
+ assertSourceContains("@Multitenant", cu);
+ assertSourceDoesNotContain("@Multitenant(", cu);
+ }
+
+//
+// public void testGetIncludeCriteria() throws Exception {
+// ICompilationUnit cu = this.createTestCacheWithIncludeCriteria();
+// JavaResourceType resourceType = buildJavaResourceType(cu);
+//
+// EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT);
+// assertEquals(Boolean.TRUE, multitenant.getIncludeCriteria());
+// }
+//
+// public void testSetIncludeCriteria() throws Exception {
+// ICompilationUnit cu = this.createTestCacheWithIncludeCriteria();
+// JavaResourceType resourceType = buildJavaResourceType(cu);
+//
+// EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT);
+// assertEquals(Boolean.TRUE, multitenant.getIncludeCriteria());
+//
+// multitenant.setIncludeCriteria(Boolean.FALSE);
+// assertEquals(Boolean.FALSE, multitenant.getIncludeCriteria());
+//
+// assertSourceContains("@Multitenant(includeCriteria=false)", cu);
+// }
+//
+// public void testSetIncludeCriteriaNull() throws Exception {
+// ICompilationUnit cu = this.createTestCacheWithIncludeCriteria();
+// JavaResourceType resourceType = buildJavaResourceType(cu);
+//
+// EclipseLinkMultitenantAnnotation2_3 multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT);
+// assertEquals(Boolean.TRUE, multitenant.getIncludeCriteria());
+//
+// multitenant.setIncludeCriteria(null);
+// multitenant = (EclipseLinkMultitenantAnnotation2_3) resourceType.getAnnotation(EclipseLink.MULTITENANT);
+// assertNull(multitenant.getIncludeCriteria());
+//
+// assertSourceContains("@Multitenant", cu);
+// assertSourceDoesNotContain("@Multitenant(", cu);
+// }
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java
new file mode 100644
index 0000000000..17d5d04489
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/src/org/eclipse/jpt/jpa/eclipselink/core/tests/internal/resource/java/JptEclipseLinkCoreJavaResourceModelTests.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * Copyright (c) 2007, 2011 Oracle. 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:
+ * Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.java;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+public class JptEclipseLinkCoreJavaResourceModelTests {
+
+ public static Test suite() {
+ TestSuite suite = new TestSuite(JptEclipseLinkCoreJavaResourceModelTests.class.getName());
+ suite.addTestSuite(CacheTests.class);
+ suite.addTestSuite(ChangeTrackingTests.class);
+ suite.addTestSuite(ConversionValueAnnotationTests.class);
+ suite.addTestSuite(ConvertAnnotationTests.class);
+ suite.addTestSuite(ConverterAnnotationTests.class);
+ suite.addTestSuite(CustomizerAnnotationTests.class);
+ suite.addTestSuite(ExistenceCheckingTests.class);
+ suite.addTestSuite(JoinFetchTests.class);
+ suite.addTestSuite(MutableAnnotationTests.class);
+ suite.addTestSuite(ObjectTypeConverterAnnotationTests.class);
+ suite.addTestSuite(EclipseLinkPrimaryKeyAnnotationTests.class);
+ suite.addTestSuite(PrivateOwnedTests.class);
+ suite.addTestSuite(ReadOnlyTests.class);
+ suite.addTestSuite(ReadTransformerAnnotationTests.class);
+ suite.addTestSuite(StructConverterAnnotationTests.class);
+ suite.addTestSuite(TimeOfDayTests.class);
+ suite.addTestSuite(TransformationAnnotationTests.class);
+ suite.addTestSuite(TypeConverterAnnotationTests.class);
+ suite.addTestSuite(WriteTransformerAnnotationTests.class);
+ suite.addTestSuite(MapKeyConvertAnnotation2_0Tests.class);
+ suite.addTestSuite(EclipselinkMultitenantAnnotation2_3Tests.class);
+ suite.addTestSuite(EclipseLinkTenantDiscriminatorColumnAnnotation2_3Tests.class);
+
+ return suite;
+ }
+
+ private JptEclipseLinkCoreJavaResourceModelTests() {
+ super();
+ throw new UnsupportedOperationException();
+ }
+
+}
diff --git a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml
index 1d48c747cd..41a8dcde8f 100644
--- a/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml
+++ b/jpa/tests/org.eclipse.jpt.jpa.eclipselink.core.tests/test.xml
@@ -32,10 +32,10 @@
<property name="plugin-name" value="${plugin-name}"/>
<property name="classname" value="org.eclipse.jpt.jpa.eclipselink.core.tests.internal.resource.JptJpaEclipselinkCoreResourceModelTests" />
<property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/>
- <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence204-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/>
+ <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/>
</ant>
</target>
- <target name="suite2"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.JptJpaEclipseLinkCoreContextModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence204-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/> </ant> </target> <target name="suite3"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.eclipselink.core.tests.internal.metadata.JptJpaEclipseLinkCoreMetadataTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence204-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/> </ant> </target>
+ <target name="suite2"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.eclipselink.core.tests.internal.context.JptJpaEclipseLinkCoreContextModelTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/> </ant> </target> <target name="suite3"> <property file="${testRoot}/testServer.properties"/> <property name="jpt-folder" value="${eclipse-home}/jpt_folder"/> <delete dir="${jpt-folder}" quiet="true"/> <ant target="core-test" antfile="${library-file}" dir="${eclipse-home}"> <property name="data-dir" value="${jpt-folder}"/> <property name="plugin-name" value="${plugin-name}"/> <property name="classname" value="org.eclipse.jpt.jpa.eclipselink.core.tests.internal.metadata.JptJpaEclipseLinkCoreMetadataTests" /> <property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/> <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/> </ant> </target>
<!-- This target holds code to cleanup the testing environment after -->
<!-- after all of the tests have been run. You can use this target to -->
<!-- delete temporary files that have been created. -->
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/RefactorAttributeTypeFeatureTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/RefactorAttributeTypeFeatureTest.java
new file mode 100644
index 0000000000..4f600313fb
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/feature/RefactorAttributeTypeFeatureTest.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2011 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.feature;
+
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Date;
+import java.util.List;
+
+import org.easymock.EasyMock;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.graphiti.features.context.ICustomContext;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.jpt.jpa.core.JpaProject;
+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.PersistenceUnit;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.feature.RefactorAttributeTypeFeature;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
+import org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.JPACreateFactory;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RefactorAttributeTypeFeatureTest {
+
+ private IJPAEditorFeatureProvider featureProvider;
+ private ICustomContext context;
+ final String TEST_PROJECT = "Test"+(new Date()).getTime();
+ private JpaProject jpaProject = null;
+ private JPACreateFactory factory = null;
+ private IFile entity;
+
+ @Before
+ public void setUp() throws Exception{
+ factory = JPACreateFactory.instance();
+ jpaProject = factory.createJPAProject(TEST_PROJECT + "_" + System.currentTimeMillis());
+ assertNotNull(jpaProject);
+ entity = factory.createEntity(jpaProject, "org.eclipse.Ent");
+ Thread.sleep(2000);
+ factory.addAttributes(entity, "att", "java.lang.String", "", "att", false);
+
+ }
+
+ @Test
+ public void testRefactorAttributeTypeFeature(){
+ PictogramElement[] elements = new PictogramElement[1];
+ PictogramElement element = EasyMock.createNiceMock(PictogramElement.class);
+ replay(element);
+ elements[0] = element;
+
+ featureProvider = EasyMock.createMock(IJPAEditorFeatureProvider.class);
+ expect(featureProvider.getBusinessObjectForPictogramElement(element)).andReturn(null);
+ replay(featureProvider);
+
+ context = EasyMock.createMock(ICustomContext.class);
+ expect(context.getPictogramElements()).andReturn(elements);
+ replay(context);
+
+ RefactorAttributeTypeFeature feature = new RefactorAttributeTypeFeature(featureProvider);
+ feature.execute(context);
+ }
+
+ @Test
+ public void testAttributeUtils(){
+ PersistenceUnit pu = JpaArtifactFactory.instance().getPersistenceUnit(jpaProject);
+ JavaPersistentType jpt = (JavaPersistentType)pu.getPersistentType("org.eclipse.Ent");
+ JavaPersistentAttribute at = jpt.getAttributeNamed("id");
+ List<String> lst = JpaArtifactFactory.instance().getAnnotationStrings(at);
+ assertEquals(1, lst.size());
+ assertTrue(lst.contains("@Id"));
+ String typeName1 = JPAEditorUtil.getAttributeTypeName(at);
+ assertEquals("int", typeName1);
+ String typeName2 = JPAEditorUtil.getAttributeTypeName(at.getResourceAttribute());
+ assertEquals("int", typeName2);
+ }
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/ui/ModelIntegrationTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/ui/ModelIntegrationTest.java
new file mode 100644
index 0000000000..34e3ba1189
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/ui/ModelIntegrationTest.java
@@ -0,0 +1,221 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2010 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.modelintegration.ui;
+
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.isA;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.easymock.EasyMock;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IWorkspaceRunnable;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.graphiti.dt.IDiagramTypeProvider;
+import org.eclipse.graphiti.mm.pictograms.Diagram;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.platform.IDiagramEditor;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.jpa.core.JpaFile;
+import org.eclipse.jpt.jpa.core.JpaProject;
+import org.eclipse.jpt.jpa.core.JpaStructureNode;
+import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.modelintegration.ui.JPAEditorMatchingStrategy;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.modelintegration.util.IModelIntegrationUtil;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IEclipseFacade;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPADiagramEditorInput;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IJPAEditorUtil;
+import org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.JPACreateFactory;
+import org.eclipse.ui.IEditorReference;
+import org.eclipse.ui.IFileEditorInput;
+import org.eclipse.ui.PartInitException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ModelIntegrationTest {
+
+ private static final String CODE_GENERATED = "CODE_GENERATED";
+ private IJPAEditorFeatureProvider featureProvider;
+ final String TEST_PROJECT = "Test";
+ private JpaProject jpaProject = null;
+ private JPACreateFactory factory = null;
+ IEclipseFacade eclipseFacade = null;
+ private String testProjectName = TEST_PROJECT + "_" + System.currentTimeMillis();
+ IFile entityFile = null;
+
+ @Before
+ public void setUp() throws Exception {
+ factory = JPACreateFactory.instance();
+ jpaProject = factory.createJPAProject(testProjectName);
+ assertNotNull(jpaProject);
+ entityFile = factory.createEntity(jpaProject, "org.eclipse.Entity1");
+ Thread.sleep(2000);
+ featureProvider = EasyMock.createMock(IJPAEditorFeatureProvider.class);
+ expect(featureProvider.getBusinessObjectForPictogramElement(null)).andReturn(JPACreateFactory.getPersistentType(entityFile));
+ expect(featureProvider.getCompilationUnit(isA(JavaPersistentType.class))).andReturn(JavaCore.createCompilationUnitFrom(entityFile)).anyTimes();
+ }
+
+ @Test
+ public void testJPAEditorMatchingStrategyWithEntityFileEditorInputTrue() {
+ IEditorReference editorRef = EasyMock.createMock(IEditorReference.class);
+ IFileEditorInput input = EasyMock.createMock(IFileEditorInput.class);
+ expect(input.getFile()).andStubReturn(entityFile);
+ expect(input.getName()).andStubReturn(CODE_GENERATED);
+ ICompilationUnit cu = createCompilationUnitFrom(entityFile);
+
+ IJPAEditorUtil ut = EasyMock.createMock(IJPAEditorUtil.class);
+ JavaPersistentType inputJptType = (JavaPersistentType) JPACreateFactory.getPersistentType(entityFile);
+ expect(ut.getJPType(cu)).andStubReturn(inputJptType);
+ expect(featureProvider.getJPAEditorUtil()).andStubReturn(ut);
+ Diagram d = EasyMock.createMock(Diagram.class);
+ IJPADiagramEditorInput dEdInput = EasyMock.createMock(IJPADiagramEditorInput.class);
+ try {
+ expect(editorRef.getEditorInput()).andStubReturn(dEdInput);
+ } catch (PartInitException e) {
+ e.printStackTrace();
+ }
+ expect(dEdInput.getDiagram()).andStubReturn(d);
+ IDiagramTypeProvider dtp = EasyMock.createMock(IDiagramTypeProvider.class);
+ expect(featureProvider.getDiagramTypeProvider()).andStubReturn(dtp);
+ IModelIntegrationUtil moinIntUtil = EasyMock.createMock(IModelIntegrationUtil.class);
+ expect(featureProvider.getMoinIntegrationUtil()).andStubReturn(moinIntUtil);
+ expect(moinIntUtil.getProjectByDiagram(d)).andStubReturn(jpaProject);
+ PictogramElement pe = EasyMock.createMock(PictogramElement.class);
+ expect(featureProvider.getPictogramElementForBusinessObject(inputJptType)).andStubReturn(pe);
+ IDiagramEditor dEd = EasyMock.createMock(IDiagramEditor.class);
+ expect(dtp.getDiagramEditor()).andStubReturn(dEd);
+ dEd.setPictogramElementForSelection(pe);
+
+ JPAEditorMatchingStrategy str = new JPAEditorMatchingStrategy(featureProvider);
+
+ EasyMock.replay(editorRef, d, dtp, pe, dEd, moinIntUtil, dEdInput, ut, input, featureProvider);
+ assertTrue(str.matches(editorRef, input));
+ }
+
+ @Test
+ public void testJPAEditorMatchingStrategyWithEntityFileEditorInputFalse() {
+ IEditorReference editorRef = EasyMock.createMock(IEditorReference.class);
+ IFileEditorInput input = EasyMock.createMock(IFileEditorInput.class);
+ expect(input.getFile()).andStubReturn(entityFile);
+ expect(input.getName()).andStubReturn(CODE_GENERATED);
+ ICompilationUnit cu = createCompilationUnitFrom(entityFile);
+
+ IJPAEditorUtil ut = EasyMock.createMock(IJPAEditorUtil.class);
+ JavaPersistentType inputJptType = (JavaPersistentType) JPACreateFactory.getPersistentType(entityFile);
+ expect(ut.getJPType(cu)).andStubReturn(inputJptType);
+ expect(featureProvider.getJPAEditorUtil()).andStubReturn(ut);
+ Diagram d = EasyMock.createMock(Diagram.class);
+ IJPADiagramEditorInput dEdInput = EasyMock.createMock(IJPADiagramEditorInput.class);
+ try {
+ expect(editorRef.getEditorInput()).andStubReturn(dEdInput);
+ } catch (PartInitException e) {
+ e.printStackTrace();
+ }
+ expect(dEdInput.getDiagram()).andStubReturn(d);
+ IDiagramTypeProvider dtp = EasyMock.createMock(IDiagramTypeProvider.class);
+ expect(featureProvider.getDiagramTypeProvider()).andStubReturn(dtp);
+ IModelIntegrationUtil moinIntUtil = EasyMock.createMock(IModelIntegrationUtil.class);
+ expect(featureProvider.getMoinIntegrationUtil()).andStubReturn(moinIntUtil);
+ JpaProject anotherJpaProject = EasyMock.createMock(JpaProject.class);
+ expect(moinIntUtil.getProjectByDiagram(d)).andStubReturn(anotherJpaProject);
+ PictogramElement pe = EasyMock.createMock(PictogramElement.class);
+ expect(featureProvider.getPictogramElementForBusinessObject(inputJptType)).andStubReturn(pe);
+ IDiagramEditor dEd = EasyMock.createMock(IDiagramEditor.class);
+ expect(dtp.getDiagramEditor()).andStubReturn(dEd);
+ dEd.setPictogramElementForSelection(pe);
+
+ JPAEditorMatchingStrategy str = new JPAEditorMatchingStrategy(featureProvider);
+
+ EasyMock.replay(editorRef, d, dtp, pe, dEd, moinIntUtil, anotherJpaProject, dEdInput, ut, input, featureProvider);
+ assertFalse(str.matches(editorRef, input));
+ }
+
+ @Test
+ public void testJPAEditorMatchingStrategyWithJPADiagramEditorInputTrue() {
+ IEditorReference editorRef = EasyMock.createMock(IEditorReference.class);
+ expect(editorRef.getPartName()).andStubReturn("ProjectName");
+ IJPADiagramEditorInput input = EasyMock.createMock(IJPADiagramEditorInput.class);
+ expect(input.getProjectName()).andStubReturn("ProjectName");
+ JPAEditorMatchingStrategy str = new JPAEditorMatchingStrategy(featureProvider);
+ EasyMock.replay(editorRef, input, featureProvider);
+ assertTrue(str.matches(editorRef, input));
+ }
+
+ @Test
+ public void testJPAEditorMatchingStrategyWithJPADiagramEditorInputFalse() {
+ IEditorReference editorRef = EasyMock.createMock(IEditorReference.class);
+ expect(editorRef.getPartName()).andStubReturn("ProjectName");
+ IJPADiagramEditorInput input = EasyMock.createMock(IJPADiagramEditorInput.class);
+ expect(input.getProjectName()).andStubReturn("DifferentProjectName");
+ JPAEditorMatchingStrategy str = new JPAEditorMatchingStrategy(featureProvider);
+ EasyMock.replay(editorRef, input, featureProvider);
+ assertFalse(str.matches(editorRef, input));
+ }
+
+
+// @Test
+// public void testJPAEditorMatchingStrategyWithFileEditorInput() {
+// IEditorReference editorRef = EasyMock.createMock(IEditorReference.class);
+// IFileEditorInput input = EasyMock.createMock(IFileEditorInput.class);
+// IJPAEditorUtil ut = EasyMock.createMock(IJPAEditorUtil.class);
+// expect(featureProvider.getJPAEditorUtil()).andStubReturn(ut);
+// JavaPersistentType jpt = EasyMock.createMock(JavaPersistentType.class);
+// ICompilationUnit cu = JavaCore.createCompilationUnitFrom(entityFile);
+// expect(ut.getJPType(cu)).andStubReturn(jpt);
+// PersistenceUnit pu = EasyMock.createMock(PersistenceUnit.class);
+// expect(jpt.getPersistenceUnit()).andStubReturn(pu);
+// expect(pu.getJpaProject()).andStubReturn(jpaProject);
+// expect(input.getFile()).andStubReturn(entityFile);
+// expect(input.getName()).andStubReturn(entityFile.getName());
+// JPAEditorMatchingStrategy str = new JPAEditorMatchingStrategy(featureProvider);
+// EasyMock.replay(editorRef, input, ut, jpt, pu, featureProvider);
+// assertFalse(str.matches(editorRef, input));
+// }
+
+
+
+ public ICompilationUnit createCompilationUnitFrom(IFile file) {
+ return JavaCore.createCompilationUnitFrom(file);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ deleteAllProjects();
+ }
+
+ private void deleteAllProjects() throws Exception {
+ IProgressMonitor monitor= new NullProgressMonitor();
+ ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
+ public void run(IProgressMonitor monitor) throws CoreException {
+ IProject project = jpaProject.getProject();
+ project.close(monitor);
+ project.close(monitor);
+ project.delete(true, true, monitor);
+ }
+ } , monitor);
+ }
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/util/ModelIntegrationUtilTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/util/ModelIntegrationUtilTest.java
new file mode 100644
index 0000000000..4c8dfe3d51
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/modelintegration/util/ModelIntegrationUtilTest.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2010 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.modelintegration.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import org.easymock.EasyMock;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.util.BasicInternalEList;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jpt.jpa.core.JpaProject;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.modelintegration.util.ModelIntegrationUtil;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.preferences.JPAEditorPreferenceInitializer;
+import org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.JPACreateFactory;
+import org.junit.Test;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.BundleListener;
+
+
+@SuppressWarnings("unchecked")
+public class ModelIntegrationUtilTest {
+
+ @Test
+ public void getMOINNoResourceFolderTest() {
+ IProject project = EasyMock.createMock(IProject.class);
+ //EList rr = new BasicInternalEList(String.class);
+ EasyMock.expect(project.getProjectRelativePath()).andStubReturn(new Path("src"));
+ EasyMock.replay(project);
+ IPath p = ModelIntegrationUtil.getEMFResourceFolderPath(project);
+ assertNotNull(p);
+ assertEquals(2, p.segmentCount());
+ assertEquals(p.segment(0), "src");
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Test
+ public void getMOINSrcResourceFolderTest() {
+ IProject project = EasyMock.createMock(IProject.class);
+ EList rr = new BasicInternalEList(String.class);
+ rr.add("src");
+ EasyMock.expect(project.getProjectRelativePath()).andStubReturn(new Path("src"));
+ EasyMock.replay(project);
+ IPath p = ModelIntegrationUtil.getEMFResourceFolderPath(project);
+ assertNotNull(p);
+ assertEquals(2, p.segmentCount());
+ assertEquals(p.segment(0), "src");
+ }
+
+ @Test
+ public void copyExistingXMIContentAndDeleteFileTest() throws Exception {
+ Bundle b = EasyMock.createMock(Bundle.class);
+ BundleContext bc = EasyMock.createMock(BundleContext.class);
+ EasyMock.expect(bc.getBundle()).andStubReturn(b);
+ EasyMock.expect(b.getSymbolicName()).andStubReturn("jpa_editor");
+ bc.addBundleListener(EasyMock.isA(BundleListener.class));
+ EasyMock.replay(bc, b);
+
+ JPADiagramEditorPlugin p = new JPADiagramEditorPlugin();
+ p.start(bc);
+
+ IPreferenceStore store = JPADiagramEditorPlugin.getDefault().getPreferenceStore();
+ store.putValue(JPAEditorPreferenceInitializer.PROPERTY_DIAGRAM_FOLDER, "diagrams");
+ store.getString(JPAEditorPreferenceInitializer.PROPERTY_DIAGRAM_FOLDER);
+
+ JPACreateFactory factory = JPACreateFactory.instance();
+ JpaProject jpaProject = factory.createJPAProject("Test_" + System.currentTimeMillis());
+ assertNotNull(jpaProject);
+ ModelIntegrationUtil.copyExistingXMIContentAndDeleteFile(jpaProject.getProject(), "diagram_name", null);
+ }
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferenceInitializerTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferenceInitializerTest.java
new file mode 100644
index 0000000000..f34965d054
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferenceInitializerTest.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2010 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.preferences;
+
+import static org.junit.Assert.*;
+
+import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.preference.PreferenceStore;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.preferences.JPAEditorPreferenceInitializer;
+import org.junit.Test;
+
+public class JPAEditorPreferenceInitializerTest {
+ @Test
+ public void testInitializeDefaultPreferences() {
+ IPreferenceStore store = new PreferenceStore();
+ AbstractPreferenceInitializer fixture = new JPAEditorPreferenceInitializer(
+ store);
+ fixture.initializeDefaultPreferences();
+ String pack = store
+ .getDefaultString(JPAEditorPreferenceInitializer.PROPERTY_ENTITY_PACKAGE);
+ assertEquals(JPAEditorPreferenceInitializer.PROPERTY_VAL_ENTITY_PACKAGE, pack);
+ }
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferencesPageTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferencesPageTest.java
new file mode 100644
index 0000000000..718896e8c3
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/preferences/JPAEditorPreferencesPageTest.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2010 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.preferences;
+
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.JPADiagramEditorPlugin;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.preferences.JPAEditorPreferenceInitializer;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.preferences.JPAEditorPreferencesPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JPAEditorPreferencesPageTest {
+
+ private IPreferenceStore store;
+ private String oldValue;
+
+ @Before
+ public void setUp() {
+ store = JPADiagramEditorPlugin.getDefault().getPreferenceStore();
+ oldValue = store
+ .getString(JPAEditorPreferenceInitializer.PROPERTY_ENTITY_PACKAGE);
+ }
+
+ @After
+ public void tearDown() {
+ store.setValue(JPAEditorPreferenceInitializer.PROPERTY_ENTITY_PACKAGE,
+ oldValue);
+ }
+
+ /*
+ @Test
+ public void testCheckState() {
+ JPAEditorPreferencesPage page = createControl();
+ assertNull(page.getErrorMessage());
+ }
+
+ @Test
+ public void testCheckStateErrorMessage() {
+ store.setValue(JPAEditorPreferenceInitializer.DEFAULT_ENTITY_PACKAGE,
+ "d omd");
+ JPAEditorPreferencesPage page = createControl();
+ assertNotNull(page.getErrorMessage());
+ }
+
+ @Test
+ public void testCheckStateWarningMessage() {
+ store.setValue(JPAEditorPreferenceInitializer.DEFAULT_ENTITY_PACKAGE,
+ "CapitalLetter");
+ JPAEditorPreferencesPage page = createControl();
+ assertNull(page.getMessage());
+ assertTrue(page.isValid());
+ }
+ */
+
+ @Test
+ public void testInit() {
+ JPAEditorPreferencesPage page = new JPAEditorPreferencesPage();
+ page.init(null);
+ }
+
+ @SuppressWarnings("unused")
+ private JPAEditorPreferencesPage createControl() {
+ JPAEditorPreferencesPage page = new JPAEditorPreferencesPage();
+ Composite composite = new Composite(Display.getDefault()
+ .getActiveShell(), SWT.NONE);
+ page.createControl(composite);
+ return page;
+ }
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/provider/JPAEditorToolBehaviorProviderTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/provider/JPAEditorToolBehaviorProviderTest.java
new file mode 100644
index 0000000000..a987680cdb
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/provider/JPAEditorToolBehaviorProviderTest.java
@@ -0,0 +1,252 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2010 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Kiril Mitov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.provider;
+
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.verify;
+import static org.junit.Assert.assertEquals;
+
+import org.easymock.EasyMock;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.QualifiedName;
+import org.eclipse.graphiti.dt.IDiagramTypeProvider;
+import org.eclipse.graphiti.features.IFeatureProvider;
+import org.eclipse.graphiti.features.context.IDoubleClickContext;
+import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
+import org.eclipse.graphiti.mm.pictograms.PictogramElement;
+import org.eclipse.graphiti.tb.IDecorator;
+import org.eclipse.graphiti.tb.IToolBehaviorProvider;
+import org.eclipse.graphiti.tb.ImageDecorator;
+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.modelintegration.ui.JPAEditorMatchingStrategy;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.JPAEditorToolBehaviorProvider;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IEclipseFacade;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IStaticIDE;
+import org.eclipse.ui.PartInitException;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JPAEditorToolBehaviorProviderTest {
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Before
+ public void setUp() throws Exception {
+ }
+
+ @Test
+ public void testGetRenderingDecoratorsPictogramElementError() throws Exception {
+ PictogramElement pe = replayPictogramElement(100, 100);
+ IMarker marker = replayMarker(IMarker.SEVERITY_ERROR, "Error message");
+ JavaPersistentType jpt = replayJptWithMarker(new IMarker[] { marker });
+ IDiagramTypeProvider dtp = replayDiagramProvider(pe, jpt);
+
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp);
+ IDecorator[] decorators = provider.getDecorators(pe);
+ assertEquals(1, decorators.length);
+ assertEquals("Error message", decorators[0].getMessage());
+ }
+
+ @Test
+ public void testGetRenderingDecoratorsPictogramElementWarning() throws Exception {
+ PictogramElement pe = replayPictogramElement(100, 100);
+
+ IMarker marker = replayMarker(IMarker.SEVERITY_WARNING, "Warning message");
+ JavaPersistentType jpt = replayJptWithMarker(new IMarker[] { marker });
+ IDiagramTypeProvider dtp = replayDiagramProvider(pe, jpt);
+
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp);
+ IDecorator[] decorators = provider.getDecorators(pe);
+ assertEquals(1, decorators.length);
+ assertEquals("Warning message", decorators[0].getMessage());
+ }
+
+ @Test
+ public void testGetRenderingDecoratorsPictogramElementInfo() throws Exception {
+ PictogramElement pe = replayPictogramElement(100, 100);
+ IMarker marker = replayMarker(IMarker.SEVERITY_INFO, "Info message");
+ JavaPersistentType jpt = replayJptWithMarker(new IMarker[] { marker });
+ IDiagramTypeProvider dtp = replayDiagramProvider(pe, jpt);
+
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp);
+ IDecorator[] decorators = provider.getDecorators(pe);
+ assertEquals(1, decorators.length);
+ assertEquals("Info message", decorators[0].getMessage());
+ }
+
+ @Test
+ public void testGetRenderingDecoratorsPictogramElementNoMarkers() throws Exception {
+ PictogramElement pe = replayPictogramElement(100, 100);
+ JavaPersistentType jpt = replayJptWithMarker(new IMarker[0]);
+ IDiagramTypeProvider dtp = replayDiagramProvider(pe, jpt);
+
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp);
+ IDecorator[] decorators = provider.getDecorators(pe);
+ assertEquals(0, decorators.length);
+ }
+
+ @Test
+ public void testGetRenderingDecoratorsPictogramElementTwoMarkers() throws Exception {
+ PictogramElement pe = replayPictogramElement(100, 100);
+ IMarker warningMarker = replayMarker(IMarker.SEVERITY_WARNING, "warning");
+ IMarker errorMarker = replayMarker(IMarker.SEVERITY_ERROR, "error");
+ JavaPersistentType jpt = replayJptWithMarker(new IMarker[] { errorMarker, warningMarker });
+ IDiagramTypeProvider dtp = replayDiagramProvider(pe, jpt);
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp);
+ IDecorator[] decorators = provider.getDecorators(pe);
+ assertEquals(1, decorators.length);
+ assertEquals("error", decorators[0].getMessage());
+ }
+
+ @Test
+ public void testGetRenderingDecoratorsPictogramElementLocation() throws Exception {
+ PictogramElement pe = replayPictogramElement(100, 100);
+ IMarker marker = replayMarker(IMarker.SEVERITY_ERROR, "Error message");
+ JavaPersistentType jpt = replayJptWithMarker(new IMarker[] { marker });
+ IDiagramTypeProvider dtp = replayDiagramProvider(pe, jpt);
+
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp);
+ IDecorator[] decorators = provider.getDecorators(pe);
+ assertEquals(1, decorators.length);
+ assertEquals(80, ((ImageDecorator) decorators[0]).getX());
+ assertEquals(80, ((ImageDecorator) decorators[0]).getY());
+ }
+
+ @Test
+ public void testGetDoubleClickOnJptFeature() throws PartInitException, CoreException {
+ PictogramElement pe = replayPictogramElement(100, 100);
+ IFile file = replayResource();
+ JavaPersistentType jpt = replayJpt(pe, file);
+ IDiagramTypeProvider dtp = replayDiagramProvider(pe, jpt);
+
+ IEclipseFacade facade = EasyMock.createMock(IEclipseFacade.class);
+ IStaticIDE ide = EasyMock.createMock(IStaticIDE.class);
+ expect(facade.getIDE()).andStubReturn(ide);
+ ide.openEditor(file);
+ replay(facade, ide);
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp, facade);
+
+ IDoubleClickContext context = replayDoubleClickContext(pe);
+ provider.getDoubleClickFeature(context);
+ verify(ide);
+ }
+
+ @Test
+ public void testGetDoubleClickOnJpaFeature() throws Exception {
+ PictogramElement pe = replayPictogramElement(100, 100);
+ IFile file = replayResource();
+ JavaPersistentAttribute jpa = replayJpa(pe, file);
+ IDiagramTypeProvider dtp = replayDiagramProviderForJpa(pe, jpa);
+
+ IEclipseFacade eclipseFacade = EasyMock.createMock(IEclipseFacade.class);
+ IStaticIDE ide = EasyMock.createMock(IStaticIDE.class);
+ expect(eclipseFacade.getIDE()).andStubReturn(ide);
+ ide.openEditor(file);
+ replay(eclipseFacade, ide);
+ IToolBehaviorProvider provider = new JPAEditorToolBehaviorProvider(dtp, eclipseFacade);
+
+ IDoubleClickContext context = replayDoubleClickContext(pe);
+ provider.getDoubleClickFeature(context);
+ verify(ide);
+ }
+
+ private IDiagramTypeProvider replayDiagramProvider(PictogramElement pe, JavaPersistentType jpt) {
+ IFeatureProvider featureProvider = EasyMock.createMock(IFeatureProvider.class);
+ expect(featureProvider.getBusinessObjectForPictogramElement(pe)).andStubReturn(jpt);
+ IDiagramTypeProvider dtp = EasyMock.createMock(IDiagramTypeProvider.class);
+ expect(dtp.getFeatureProvider()).andStubReturn(featureProvider);
+ replay(dtp, featureProvider);
+ return dtp;
+ }
+
+ private IMarker replayMarker(int severity, String message) throws CoreException {
+ IMarker marker = EasyMock.createMock(IMarker.class);
+ expect(marker.getAttribute(IMarker.SEVERITY)).andStubReturn(severity);
+ expect(marker.getAttribute(IMarker.MESSAGE)).andStubReturn(message);
+ replay(marker);
+ return marker;
+ }
+
+ private JavaPersistentType replayJptWithMarker(IMarker[] markers) throws CoreException {
+ JavaPersistentType jpt = EasyMock.createMock(JavaPersistentType.class);
+ IFile file = EasyMock.createMock(IFile.class);
+ expect(file.exists()).andReturn(true);
+ expect(file.findMarkers(null, true, IResource.DEPTH_INFINITE)).andStubReturn(markers);
+ expect(jpt.getResource()).andStubReturn(file);
+ replay(file, jpt);
+ return jpt;
+ }
+
+ private IFile replayResource() throws CoreException {
+ IFile file = EasyMock.createMock(IFile.class);
+ file.setSessionProperty(new QualifiedName(null, JPAEditorMatchingStrategy.DOUBLE_CLICK), "true");
+ EasyMock.expectLastCall().asStub();
+ expect(file.getType()).andStubReturn(IResource.FILE);
+ replay(file);
+ return file;
+ }
+
+ private IDoubleClickContext replayDoubleClickContext(PictogramElement pe){
+ IDoubleClickContext context = EasyMock.createMock(IDoubleClickContext.class);
+ expect(context.getPictogramElements()).andStubReturn(new PictogramElement[] {pe});
+ replay(context);
+ return context;
+ }
+
+ private JavaPersistentType replayJpt(PictogramElement pe, IFile file){
+ IFeatureProvider featureProvider = EasyMock.createMock(IFeatureProvider.class);
+ JavaPersistentType jpt = EasyMock.createMock(JavaPersistentType.class);
+ expect(featureProvider.getBusinessObjectForPictogramElement(pe)).andStubReturn(jpt);
+ expect(jpt.getResource()).andReturn(file);
+ replay(jpt, featureProvider);
+ return jpt;
+ }
+
+ private JavaPersistentAttribute replayJpa(PictogramElement pe, IFile file){
+ IFeatureProvider featureProvider = EasyMock.createMock(IFeatureProvider.class);
+ JavaPersistentAttribute jpa = EasyMock.createMock(JavaPersistentAttribute.class);
+ expect(featureProvider.getBusinessObjectForPictogramElement(pe)).andStubReturn(jpa);
+ expect(jpa.getResource()).andReturn(file);
+ replay(jpa, featureProvider);
+ return jpa;
+ }
+
+ private IDiagramTypeProvider replayDiagramProviderForJpa(PictogramElement pe, JavaPersistentAttribute jpa) {
+ IFeatureProvider featureProvider = EasyMock.createMock(IFeatureProvider.class);
+ expect(featureProvider.getBusinessObjectForPictogramElement(pe)).andStubReturn(jpa);
+ IDiagramTypeProvider dtp = EasyMock.createMock(IDiagramTypeProvider.class);
+ expect(dtp.getFeatureProvider()).andStubReturn(featureProvider);
+ replay(dtp, featureProvider);
+ return dtp;
+ }
+
+ private PictogramElement replayPictogramElement(int width, int height) {
+ PictogramElement pe = EasyMock.createMock(PictogramElement.class);
+ GraphicsAlgorithm algo = EasyMock.createMock(GraphicsAlgorithm.class);
+ expect(algo.getWidth()).andStubReturn(width);
+ expect(algo.getHeight()).andStubReturn(height);
+ expect(pe.getGraphicsAlgorithm()).andStubReturn(algo);
+ replay(pe, algo);
+ return pe;
+ }
+
+}
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsInFieldAnnotatedEntitiesTest.java b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsInFieldAnnotatedEntitiesTest.java
new file mode 100644
index 0000000000..f313512e5d
--- /dev/null
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/src/org/eclipse/jpt/jpadiagrameditor/ui/tests/internal/relation/CreateRelationsInFieldAnnotatedEntitiesTest.java
@@ -0,0 +1,492 @@
+/*******************************************************************************
+ * <copyright>
+ *
+ * Copyright (c) 2005, 2011 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Stefan Dimov - initial API, implementation and documentation
+ *
+ * </copyright>
+ *
+ *******************************************************************************/
+package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.relation;
+
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.isA;
+import static org.easymock.EasyMock.replay;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Set;
+
+import org.easymock.EasyMock;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IField;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jpt.common.core.resource.java.JavaResourceAbstractType;
+import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.jpa.core.JpaFile;
+import org.eclipse.jpt.jpa.core.JpaProject;
+import org.eclipse.jpt.jpa.core.JpaStructureNode;
+import org.eclipse.jpt.jpa.core.JptJpaCorePlugin;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.jpa.core.resource.java.OwnableRelationshipMappingAnnotation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.provider.IJPAEditorFeatureProvider;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.AbstractRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyBiDirRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToManyUniDirRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToOneBiDirRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.ManyToOneUniDirRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.OneToManyUniDirRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.OneToOneBiDirRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.relations.OneToOneUniDirRelation;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IEclipseFacade;
+import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory;
+import org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.JPACreateFactory;
+import org.junit.Before;
+import org.junit.Test;
+
+public class CreateRelationsInFieldAnnotatedEntitiesTest {
+
+ private IJPAEditorFeatureProvider featureProvider;
+ final String TEST_PROJECT = "Test";
+ private JpaProject jpaProject = null;
+ private JPACreateFactory factory = null;
+ IEclipseFacade eclipseFacade = null;
+
+ @Before
+ public void setUp() throws Exception {
+ factory = JPACreateFactory.instance();
+ jpaProject = factory.createJPAProject(TEST_PROJECT + "_" + System.currentTimeMillis());
+ assertNotNull(jpaProject);
+ IFile entity = factory.createEntity(jpaProject, "org.eclipse.Entity1");
+ Thread.sleep(2000);
+ featureProvider = EasyMock.createMock(IJPAEditorFeatureProvider.class);
+ expect(featureProvider.getBusinessObjectForPictogramElement(null)).andReturn(JPACreateFactory.getPersistentType(entity));
+ expect(featureProvider.getCompilationUnit(isA(JavaPersistentType.class))).andReturn(JavaCore.createCompilationUnitFrom(entity)).anyTimes();
+ replay(featureProvider);
+ }
+
+ public ICompilationUnit createCompilationUnitFrom(IFile file) {
+ return JavaCore.createCompilationUnitFrom(file);
+ }
+
+
+ @Test
+ public void testCreateOneToOneUnidirRelation() throws Exception {
+ assertNotNull(jpaProject);
+ IFile customerFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer");
+
+ IFile addressFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com"}, "Address");
+
+ jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+
+ assertTrue(customerFile.exists());
+ JavaResourceAbstractType customerType = jpaProject.getJavaResourceType("com.test.Customer");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ while (t1 == null) {
+ Thread.sleep(200);
+ t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ }
+
+ assertTrue(addressFile.exists());
+ JavaResourceAbstractType addressType = jpaProject.getJavaResourceType("com.Address");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ while (t2 == null) {
+ Thread.sleep(200);
+ t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ }
+ ICompilationUnit cu1 = createCompilationUnitFrom((IFile)t1.getResource());
+ AbstractRelation rel = new OneToOneUniDirRelation(featureProvider, t1, t2, "address",
+ true,
+ cu1,
+ createCompilationUnitFrom((IFile)t2.getResource()));
+ assertNotNull(rel);
+ assertSame(t1, rel.getOwner());
+ assertSame(t2, rel.getInverse());
+ assertEquals("address", rel.getOwnerAttributeName());
+ JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+ assertNotNull(ownerAt);
+ Set<String> annotations = JpaArtifactFactory.instance().getAnnotationNames(ownerAt);
+ assertTrue(annotations.contains("OneToOne"));
+ assertNull(((OwnableRelationshipMappingAnnotation)ownerAt.getMapping()).getMappedBy());
+
+ assertTrue(cu1.isWorkingCopy());
+ IType javaType = cu1.findPrimaryType();
+ IField f = javaType.getField("address");
+ assertTrue(f.exists());
+
+ }
+
+ @Test
+ public void testCreateOneToOneBidirRelation() throws Exception {
+ assertNotNull(jpaProject);
+ IFile customerFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer");
+
+ IFile addressFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com"}, "Address");
+
+ jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+
+ assertTrue(customerFile.exists());
+ JavaResourceAbstractType customerType = jpaProject.getJavaResourceType("com.test.Customer");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ while (t1 == null) {
+ Thread.sleep(200);
+ t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ }
+
+ assertTrue(addressFile.exists());
+ JavaResourceAbstractType addressType = jpaProject.getJavaResourceType("com.Address");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ while (t2 == null) {
+ Thread.sleep(200);
+ t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ }
+ ICompilationUnit cu1 = createCompilationUnitFrom((IFile)t1.getResource());
+ ICompilationUnit cu2 = createCompilationUnitFrom((IFile)t2.getResource());
+ AbstractRelation rel = new OneToOneBiDirRelation(featureProvider, t1, t2, "address", "customer",
+ true,
+ cu1,
+ cu2);
+ assertNotNull(rel);
+ assertSame(t1, rel.getOwner());
+ assertSame(t2, rel.getInverse());
+ assertEquals("address", rel.getOwnerAttributeName());
+ JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+ assertNotNull(ownerAt);
+ Set<String> annotations = JpaArtifactFactory.instance().getAnnotationNames(ownerAt);
+ assertTrue(annotations.contains("OneToOne"));
+ assertNull(((OwnableRelationshipMappingAnnotation)ownerAt.getMapping()).getMappedBy());
+
+ JavaPersistentAttribute inverseAt = t2.getAttributeNamed("customer");
+ assertNotNull(inverseAt);
+ annotations = JpaArtifactFactory.instance().getAnnotationNames(inverseAt);
+ assertTrue(annotations.contains("OneToOne"));
+ assertEquals("address", ((OwnableRelationshipMappingAnnotation)inverseAt.getMapping()).getMappedBy());
+
+ assertTrue(cu1.isWorkingCopy());
+ assertTrue(cu2.isWorkingCopy());
+
+ IType javaType1 = cu1.findPrimaryType();
+ IField f1 = javaType1.getField("address");
+ assertTrue(f1.exists());
+ IType javaType2 = cu2.findPrimaryType();
+ IField f2 = javaType2.getField("customer");
+ assertTrue(f2.exists());
+
+ }
+
+ @Test
+ public void testCreateOneToManyUnidirRelation() throws Exception {
+ assertNotNull(jpaProject);
+ IFile customerFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer");
+
+ IFile addressFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com"}, "Address");
+
+ jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+
+ assertTrue(customerFile.exists());
+ JavaResourceAbstractType customerType = jpaProject.getJavaResourceType("com.test.Customer");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ while (t1 == null) {
+ Thread.sleep(200);
+ t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ }
+
+ assertTrue(addressFile.exists());
+ JavaResourceAbstractType addressType = jpaProject.getJavaResourceType("com.Address");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ while (t2 == null) {
+ Thread.sleep(200);
+ t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ }
+ ICompilationUnit cu1 = createCompilationUnitFrom((IFile)t1.getResource());
+ AbstractRelation rel = new OneToManyUniDirRelation(featureProvider, t1, t2, "address",
+ true,
+ cu1,
+ createCompilationUnitFrom((IFile)t2.getResource()));
+ assertNotNull(rel);
+ assertSame(t1, rel.getOwner());
+ assertSame(t2, rel.getInverse());
+ assertEquals("address", rel.getOwnerAttributeName());
+ JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+ assertNotNull(ownerAt);
+ Set<String> annotations = JpaArtifactFactory.instance().getAnnotationNames(ownerAt);
+ assertTrue(annotations.contains("OneToMany"));
+ assertNull(((OwnableRelationshipMappingAnnotation)ownerAt.getMapping()).getMappedBy());
+
+ assertTrue(cu1.isWorkingCopy());
+
+ IType javaType1 = cu1.findPrimaryType();
+ IField f1 = javaType1.getField("address");
+ assertTrue(f1.exists());
+
+ }
+
+ @Test
+ public void testCreateManyToOneUnidirRelation() throws Exception {
+ assertNotNull(jpaProject);
+ IFile customerFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer");
+
+ IFile addressFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com"}, "Address");
+
+ jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+
+ assertTrue(customerFile.exists());
+ JavaResourceAbstractType customerType = jpaProject.getJavaResourceType("com.test.Customer");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ while (t1 == null) {
+ Thread.sleep(200);
+ t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ }
+
+ assertTrue(addressFile.exists());
+ JavaResourceAbstractType addressType = jpaProject.getJavaResourceType("com.Address");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ while (t2 == null) {
+ Thread.sleep(200);
+ t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ }
+ ICompilationUnit cu1 = createCompilationUnitFrom((IFile)t1.getResource());
+ AbstractRelation rel = new ManyToOneUniDirRelation(featureProvider, t1, t2, "address",
+ true,
+ cu1,
+ createCompilationUnitFrom((IFile)t2.getResource()));
+ assertNotNull(rel);
+ assertSame(t1, rel.getOwner());
+ assertSame(t2, rel.getInverse());
+ assertEquals("address", rel.getOwnerAttributeName());
+ JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+ assertNotNull(ownerAt);
+ Set<String> annotations = JpaArtifactFactory.instance().getAnnotationNames(ownerAt);
+ assertTrue(annotations.contains("ManyToOne"));
+
+ assertTrue(cu1.isWorkingCopy());
+
+ IType javaType1 = cu1.findPrimaryType();
+ IField f1 = javaType1.getField("address");
+ assertTrue(f1.exists());
+
+ }
+
+
+ @Test
+ public void testCreateManyToOneBidirRelation() throws Exception {
+ assertNotNull(jpaProject);
+ IFile customerFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer");
+
+ IFile addressFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com"}, "Address");
+
+ jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+
+ assertTrue(customerFile.exists());
+ JavaResourceAbstractType customerType = jpaProject.getJavaResourceType("com.test.Customer");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ while (t1 == null) {
+ Thread.sleep(200);
+ t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ }
+
+ assertTrue(addressFile.exists());
+ JavaResourceAbstractType addressType = jpaProject.getJavaResourceType("com.Address");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ while (t2 == null) {
+ Thread.sleep(200);
+ t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ }
+ ICompilationUnit cu1 = createCompilationUnitFrom((IFile)t1.getResource());
+ ICompilationUnit cu2 = createCompilationUnitFrom((IFile)t2.getResource());
+ AbstractRelation rel = new ManyToOneBiDirRelation(featureProvider, t1, t2, "address", "customer",
+ true,
+ cu1,
+ cu2);
+ assertNotNull(rel);
+ assertSame(t1, rel.getOwner());
+ assertSame(t2, rel.getInverse());
+ assertEquals("address", rel.getOwnerAttributeName());
+ JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+ assertNotNull(ownerAt);
+ Set<String> annotations = JpaArtifactFactory.instance().getAnnotationNames(ownerAt);
+ assertTrue(annotations.contains("ManyToOne"));
+
+ JavaPersistentAttribute inverseAt = t2.getAttributeNamed("customer");
+ assertNotNull(inverseAt);
+ annotations = JpaArtifactFactory.instance().getAnnotationNames(inverseAt);
+ assertTrue(annotations.contains("OneToMany"));
+ assertEquals("address", ((OwnableRelationshipMappingAnnotation)inverseAt.getMapping()).getMappedBy());
+
+ assertTrue(cu1.isWorkingCopy());
+ assertTrue(cu2.isWorkingCopy());
+
+ IType javaType1 = cu1.findPrimaryType();
+ IField f1 = javaType1.getField("address");
+ assertTrue(f1.exists());
+ IType javaType2 = cu2.findPrimaryType();
+ IField f2 = javaType2.getField("customer");
+ assertTrue(f2.exists());
+
+ }
+
+ @Test
+ public void testCreateManyToManyUnidirRelation() throws Exception {
+ assertNotNull(jpaProject);
+ IFile customerFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer");
+
+ IFile addressFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com"}, "Address");
+
+ jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+
+ assertTrue(customerFile.exists());
+ JavaResourceAbstractType customerType = jpaProject.getJavaResourceType("com.test.Customer");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ while (t1 == null) {
+ Thread.sleep(200);
+ t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ }
+
+ assertTrue(addressFile.exists());
+ JavaResourceAbstractType addressType = jpaProject.getJavaResourceType("com.Address");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ while (t2 == null) {
+ Thread.sleep(200);
+ t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ }
+ ICompilationUnit cu1 = createCompilationUnitFrom((IFile)t1.getResource());
+ AbstractRelation rel = new ManyToManyUniDirRelation(featureProvider, t1, t2, "address",
+ true,
+ cu1,
+ createCompilationUnitFrom((IFile)t2.getResource()));
+ assertNotNull(rel);
+ assertSame(t1, rel.getOwner());
+ assertSame(t2, rel.getInverse());
+ assertEquals("address", rel.getOwnerAttributeName());
+ JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+ assertNotNull(ownerAt);
+ Set<String> annotations = JpaArtifactFactory.instance().getAnnotationNames(ownerAt);
+ assertTrue(annotations.contains("ManyToMany"));
+ assertNull(((OwnableRelationshipMappingAnnotation)ownerAt.getMapping()).getMappedBy());
+
+ assertTrue(cu1.isWorkingCopy());
+
+ IType javaType1 = cu1.findPrimaryType();
+ IField f1 = javaType1.getField("address");
+ assertTrue(f1.exists());
+
+ }
+
+ @Test
+ public void testCreateManyToManyBidirRelation() throws Exception {
+ assertNotNull(jpaProject);
+ IFile customerFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer");
+
+ IFile addressFile = factory.createFieldAnnotatedEntityInProject(jpaProject.getProject(), new String[]{"com"}, "Address");
+
+ jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor());
+
+ assertTrue(customerFile.exists());
+ JavaResourceAbstractType customerType = jpaProject.getJavaResourceType("com.test.Customer");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ while (t1 == null) {
+ Thread.sleep(200);
+ t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName());
+ }
+
+ assertTrue(addressFile.exists());
+ JavaResourceAbstractType addressType = jpaProject.getJavaResourceType("com.Address");
+ assertNotNull(customerType);
+
+
+ JavaPersistentType t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ while (t2 == null) {
+ Thread.sleep(200);
+ t2 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, addressType.getQualifiedName());
+ }
+ ICompilationUnit cu1 = createCompilationUnitFrom((IFile)t1.getResource());
+ ICompilationUnit cu2 = createCompilationUnitFrom((IFile)t2.getResource());
+ AbstractRelation rel = new ManyToManyBiDirRelation(featureProvider, t1, t2, "address", "customer",
+ true,
+ cu1,
+ cu2);
+ assertNotNull(rel);
+ assertSame(t1, rel.getOwner());
+ assertSame(t2, rel.getInverse());
+ assertEquals("address", rel.getOwnerAttributeName());
+ JavaPersistentAttribute ownerAt = t1.getAttributeNamed("address");
+ assertNotNull(ownerAt);
+ Set<String> annotations = JpaArtifactFactory.instance().getAnnotationNames(ownerAt);
+ assertTrue(annotations.contains("ManyToMany"));
+ assertNull(((OwnableRelationshipMappingAnnotation)ownerAt.getMapping()).getMappedBy());
+
+ JavaPersistentAttribute inverseAt = t2.getAttributeNamed("customer");
+ assertNotNull(inverseAt);
+ annotations = JpaArtifactFactory.instance().getAnnotationNames(inverseAt);
+ assertTrue(annotations.contains("ManyToMany"));
+ assertEquals("address", ((OwnableRelationshipMappingAnnotation)inverseAt.getMapping()).getMappedBy());
+
+ assertTrue(cu1.isWorkingCopy());
+ assertTrue(cu2.isWorkingCopy());
+
+ IType javaType1 = cu1.findPrimaryType();
+ IField f1 = javaType1.getField("address");
+ assertTrue(f1.exists());
+ IType javaType2 = cu2.findPrimaryType();
+ IField f2 = javaType2.getField("customer");
+ assertTrue(f2.exists());
+
+ }
+
+
+}
+
+
diff --git a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/test.xml b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/test.xml
index f5e7a14f2e..98ad18889a 100644
--- a/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/test.xml
+++ b/jpa_diagram_editor/tests/org.eclipse.jpt.jpadiagrameditor.ui.tests/test.xml
@@ -31,7 +31,7 @@
<property name="plugin-name" value="${plugin-name}"/>
<property name="classname" value="org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.AllJpaEditorTests" />
<property name="plugin-path" value="${eclipse-home}/plugins/${plugin-name}"/>
- <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence204-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/>
+ <property name="extraVMargs" value="-Dorg.eclipse.jpt.jpa.jar=${testDir}/${jpt-persistence-jar} -Dorg.eclipse.jpt.eclipselink.jar=${testDir}/${jpt-eclipselink-jar}"/>
</ant>
</target>

Back to the top