diff options
Diffstat (limited to 'jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org')
32 files changed, 576 insertions, 400 deletions
diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/JavaResourceModelTestCase.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/JavaResourceModelTestCase.java new file mode 100644 index 0000000000..31b0b51ff3 --- /dev/null +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/JavaResourceModelTestCase.java @@ -0,0 +1,179 @@ +/******************************************************************************* + * Copyright (c) 2010 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.jaxb.core.tests.internal.resource.java; + +import org.eclipse.jdt.core.ElementChangedEvent; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IElementChangedListener; +import org.eclipse.jdt.core.IJavaElement; +import org.eclipse.jdt.core.IJavaElementDelta; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jpt.core.internal.utility.jdt.NullAnnotationEditFormatter; +import org.eclipse.jpt.core.tests.internal.utility.jdt.AnnotationTestCase; +import org.eclipse.jpt.jaxb.core.AnnotationDefinitionProvider; +import org.eclipse.jpt.jaxb.core.AnnotationProvider; +import org.eclipse.jpt.jaxb.core.internal.GenericAnnotationProvider; +import org.eclipse.jpt.jaxb.core.internal.resource.java.source.SourcePackageInfoCompilationUnit; +import org.eclipse.jpt.jaxb.core.internal.resource.java.source.SourceTypeCompilationUnit; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceCompilationUnit; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourcePackage; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourcePackageInfoCompilationUnit; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; +import org.eclipse.jpt.utility.CommandExecutor; +import org.eclipse.jpt.utility.internal.BitTools; +import org.eclipse.jpt.utility.internal.CollectionTools; +import org.eclipse.jpt.utility.internal.ReflectionTools; +import org.eclipse.jpt.utility.internal.StringTools; + +@SuppressWarnings("nls") +public abstract class JavaResourceModelTestCase + extends AnnotationTestCase { + + private JavaElementChangeListener javaElementChangeListener; + protected JavaResourceCompilationUnit javaResourceCompilationUnit; + + + public JavaResourceModelTestCase(String name) { + super(name); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + this.javaElementChangeListener = new JavaElementChangeListener(); + JavaCore.addElementChangedListener(this.javaElementChangeListener); + } + + @Override + protected void tearDown() throws Exception { + super.tearDown(); + JavaCore.removeElementChangedListener(this.javaElementChangeListener); + this.javaElementChangeListener = null; + } + + private class JavaElementChangeListener + implements IElementChangedListener { + + JavaElementChangeListener() { + super(); + } + + public void elementChanged(ElementChangedEvent event) { + JavaResourceModelTestCase.this.javaElementChanged(event); + } + + @Override + public String toString() { + return StringTools.buildToStringFor(this); + } + } + + void javaElementChanged(ElementChangedEvent event) { + if (this.javaResourceCompilationUnit == null) { + return; + } + this.syncWithJavaDelta(event.getDelta()); + } + + /** + * NB: this is copied from GenericJpaProject, so it might need to be + * kept in synch with that code if it changes... yech... + */ + protected void syncWithJavaDelta(IJavaElementDelta delta) { + switch (delta.getElement().getElementType()) { + case IJavaElement.JAVA_MODEL : + case IJavaElement.JAVA_PROJECT : + case IJavaElement.PACKAGE_FRAGMENT_ROOT : + case IJavaElement.PACKAGE_FRAGMENT : + this.syncWithJavaDeltaChildren(delta); + break; + case IJavaElement.COMPILATION_UNIT : + this.javaCompilationUnitChanged(delta); + break; + default : + break; // ignore the elements inside a compilation unit + } + } + + protected void syncWithJavaDeltaChildren(IJavaElementDelta delta) { + for (IJavaElementDelta child : delta.getAffectedChildren()) { + this.syncWithJavaDelta(child); // recurse + } + } + + protected void javaCompilationUnitChanged(IJavaElementDelta delta) { + if (this.deltaIsRelevant(delta)) { + this.javaResourceCompilationUnit.synchronizeWithJavaSource(); + } + } + + protected boolean deltaIsRelevant(IJavaElementDelta delta) { + if (BitTools.onlyFlagIsSet(delta.getFlags(), IJavaElementDelta.F_PRIMARY_WORKING_COPY)) { + return false; + } + return delta.getKind() == IJavaElementDelta.CHANGED; + } + + protected ICompilationUnit createAnnotationAndMembers(String packageName, String annotationName, String annotationBody) throws Exception { + return this.javaProject.createCompilationUnit(packageName, annotationName + ".java", "public @interface " + annotationName + " { " + annotationBody + " }"); + } + + protected ICompilationUnit createEnumAndMembers(String packageName, String enumName, String enumBody) throws Exception { + return this.javaProject.createCompilationUnit(packageName, enumName + ".java", "public enum " + enumName + " { " + enumBody + " }"); + } + + protected JavaResourcePackage buildJavaResourcePackage(ICompilationUnit cu) { + JavaResourcePackageInfoCompilationUnit pkgCu = + new SourcePackageInfoCompilationUnit( + cu, + this.buildAnnotationProvider(), + NullAnnotationEditFormatter.instance(), + CommandExecutor.Default.instance()); + this.javaResourceCompilationUnit = pkgCu; + return pkgCu.getPackage(); + } + + protected JavaResourceType buildJavaResourceType(ICompilationUnit cu) { + this.javaResourceCompilationUnit = this.buildJavaResourceCompilationUnit(cu); + this.javaResourceCompilationUnit.resolveTypes(); + return this.hackJavaResourceType(); + } + + protected JavaResourceAttribute getField(JavaResourceType type, int index) { + return CollectionTools.get(type.getFields(), index); + } + + protected JavaResourceAttribute getMethod(JavaResourceType type, int index) { + return CollectionTools.get(type.getMethods(), index); + } + + protected JavaResourceType hackJavaResourceType() { + return (JavaResourceType) ReflectionTools.getFieldValue(this.javaResourceCompilationUnit, "type"); + } + + protected JavaResourceCompilationUnit buildJavaResourceCompilationUnit(ICompilationUnit cu) { + if (this.javaResourceCompilationUnit != null) { + throw new IllegalStateException(); + } + return new SourceTypeCompilationUnit( + cu, + this.buildAnnotationProvider(), + NullAnnotationEditFormatter.instance(), + CommandExecutor.Default.instance() + ); + } + + protected AnnotationProvider buildAnnotationProvider() { + return new GenericAnnotationProvider(this.annotationDefinitionProvider()); + } + + protected abstract AnnotationDefinitionProvider annotationDefinitionProvider(); +} diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/JaxbJavaResourceModelTestCase.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/JaxbJavaResourceModelTestCase.java index 96f23c62ce..5ece726dfa 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/JaxbJavaResourceModelTestCase.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/JaxbJavaResourceModelTestCase.java @@ -9,21 +9,18 @@ ******************************************************************************/ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; -import org.eclipse.jpt.core.JpaAnnotationProvider; -import org.eclipse.jpt.core.internal.GenericJpaAnnotationProvider; -import org.eclipse.jpt.core.tests.internal.resource.java.JavaResourceModelTestCase; +import org.eclipse.jpt.jaxb.core.AnnotationDefinitionProvider; import org.eclipse.jpt.jaxb.core.internal.GenericJaxbAnnotationDefinitionProvider; public class JaxbJavaResourceModelTestCase extends JavaResourceModelTestCase { - + public JaxbJavaResourceModelTestCase(String name) { super(name); } - @Override - protected JpaAnnotationProvider buildAnnotationProvider() { - return new GenericJpaAnnotationProvider(GenericJaxbAnnotationDefinitionProvider.instance()); + protected AnnotationDefinitionProvider annotationDefinitionProvider() { + return GenericJaxbAnnotationDefinitionProvider.instance(); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderPackageAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderPackageAnnotationTests.java index f138f12642..5fde462795 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderPackageAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderPackageAnnotationTests.java @@ -11,12 +11,12 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import org.eclipse.core.runtime.CoreException; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessOrder; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessorOrderAnnotation; - +@SuppressWarnings("nls") public class XmlAccessorOrderPackageAnnotationTests extends JaxbJavaResourceModelTestCase { @@ -35,10 +35,10 @@ public class XmlAccessorOrderPackageAnnotationTests throws Exception { ICompilationUnit cu = createPackageInfoWithAccessorOrder(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); XmlAccessorOrderAnnotation annotation = - (XmlAccessorOrderAnnotation) packageResource.getAnnotation(JAXB.XML_ACCESSOR_ORDER); + (XmlAccessorOrderAnnotation) resourcePackage.getAnnotation(JAXB.XML_ACCESSOR_ORDER); assertTrue(annotation != null); assertEquals(XmlAccessOrder.UNDEFINED, annotation.getValue()); @@ -47,7 +47,7 @@ public class XmlAccessorOrderPackageAnnotationTests assertSourceContains("@XmlAccessorOrder(ALPHABETICAL)", cu); annotation.setValue(null); - assertNull(packageResource.getAnnotation(JAXB.XML_ACCESSOR_ORDER)); + assertNull(resourcePackage.getAnnotation(JAXB.XML_ACCESSOR_ORDER)); assertSourceDoesNotContain("@XmlAccessorOrder", cu); // TODO uncomment when bug 328400 is addressed diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderTypeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderTypeAnnotationTests.java index bb921f2615..cb39c66a01 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderTypeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorOrderTypeAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessOrder; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessorOrderAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -53,26 +53,26 @@ public class XmlAccessorOrderTypeAnnotationTests public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorOrder(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_ORDER); + XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_ORDER); assertTrue(xmlAccessorOrderAnnotation != null); assertNull(xmlAccessorOrderAnnotation.getValue()); } public void testGetValue() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorOrderWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_ORDER); + XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_ORDER); assertEquals(XmlAccessOrder.ALPHABETICAL, xmlAccessorOrderAnnotation.getValue()); } public void testSetValue() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorOrder(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_ORDER); + XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_ORDER); assertEquals(null, xmlAccessorOrderAnnotation.getValue()); xmlAccessorOrderAnnotation.setValue(XmlAccessOrder.UNDEFINED); @@ -83,9 +83,9 @@ public class XmlAccessorOrderTypeAnnotationTests public void testSetValueNull() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorOrderWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_ORDER); + XmlAccessorOrderAnnotation xmlAccessorOrderAnnotation = (XmlAccessorOrderAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_ORDER); assertEquals(XmlAccessOrder.ALPHABETICAL, xmlAccessorOrderAnnotation.getValue()); xmlAccessorOrderAnnotation.setValue(null); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypePackageAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypePackageAnnotationTests.java index 48f011f3c3..39f61e6b72 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypePackageAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypePackageAnnotationTests.java @@ -11,12 +11,12 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import org.eclipse.core.runtime.CoreException; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessorTypeAnnotation; - +@SuppressWarnings("nls") public class XmlAccessorTypePackageAnnotationTests extends JaxbJavaResourceModelTestCase { @@ -35,10 +35,10 @@ public class XmlAccessorTypePackageAnnotationTests throws Exception { ICompilationUnit cu = createPackageInfoWithAccessorOrder(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); XmlAccessorTypeAnnotation annotation = - (XmlAccessorTypeAnnotation) packageResource.getAnnotation(JAXB.XML_ACCESSOR_TYPE); + (XmlAccessorTypeAnnotation) resourcePackage.getAnnotation(JAXB.XML_ACCESSOR_TYPE); assertTrue(annotation != null); assertEquals(XmlAccessType.PROPERTY, annotation.getValue()); @@ -55,7 +55,7 @@ public class XmlAccessorTypePackageAnnotationTests assertSourceContains("@XmlAccessorType(value = PUBLIC_MEMBER)", cu); annotation.setValue(null); - assertNull(packageResource.getAnnotation(JAXB.XML_ACCESSOR_TYPE)); + assertNull(resourcePackage.getAnnotation(JAXB.XML_ACCESSOR_TYPE)); assertSourceDoesNotContain("@XmlAccessorType", cu); // TODO uncomment when bug 328400 is addressed diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypeTypeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypeTypeAnnotationTests.java index d09d819b7b..392c4d39a5 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypeTypeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAccessorTypeTypeAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessorTypeAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -53,26 +53,26 @@ public class XmlAccessorTypeTypeAnnotationTests public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_TYPE); + XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_TYPE); assertTrue(xmlAccessorTypeAnnotation != null); assertNull(xmlAccessorTypeAnnotation.getValue()); } public void testGetValue() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorTypeWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_TYPE); + XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_TYPE); assertEquals(XmlAccessType.FIELD, xmlAccessorTypeAnnotation.getValue()); } public void testSetValue() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_TYPE); + XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_TYPE); assertEquals(null, xmlAccessorTypeAnnotation.getValue()); xmlAccessorTypeAnnotation.setValue(XmlAccessType.PUBLIC_MEMBER); @@ -93,9 +93,9 @@ public class XmlAccessorTypeTypeAnnotationTests public void testSetValueNull() throws Exception { ICompilationUnit cu = this.createTestXmlAccessorTypeWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) typeResource.getAnnotation(JAXB.XML_ACCESSOR_TYPE); + XmlAccessorTypeAnnotation xmlAccessorTypeAnnotation = (XmlAccessorTypeAnnotation) resourceType.getAnnotation(JAXB.XML_ACCESSOR_TYPE); assertEquals(XmlAccessType.FIELD, xmlAccessorTypeAnnotation.getValue()); xmlAccessorTypeAnnotation.setValue(null); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyAttributeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyAttributeAnnotationTests.java index 6bd1c4e774..c4d72e2b2f 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyAttributeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyAttributeAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAnyAttributeAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -39,13 +39,13 @@ public class XmlAnyAttributeAnnotationTests extends JaxbJavaResourceModelTestCas public void testGetXmlAnyAttribute() throws Exception { ICompilationUnit cu = this.createTestXmlAnyAttribute(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAnyAttributeAnnotation xmlAnyAttributeAnnotation = (XmlAnyAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ANY_ATTRIBUTE); + XmlAnyAttributeAnnotation xmlAnyAttributeAnnotation = (XmlAnyAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ANY_ATTRIBUTE); assertTrue(xmlAnyAttributeAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_ANY_ATTRIBUTE); + resourceAttribute.removeAnnotation(JAXB.XML_ANY_ATTRIBUTE); assertSourceDoesNotContain("@XmlAnyAttribute", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyElementAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyElementAnnotationTests.java index 501d274bb5..2cbd003b11 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyElementAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAnyElementAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAnyElementAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -67,10 +67,10 @@ public class XmlAnyElementAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlAnyElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ANY_ELEMENT); + XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ANY_ELEMENT); assertTrue(xmlAnyElementAnnotation != null); assertNull(xmlAnyElementAnnotation.getLax()); assertNull(xmlAnyElementAnnotation.getValue()); @@ -78,18 +78,18 @@ public class XmlAnyElementAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetLax() throws Exception { ICompilationUnit cu = this.createTestXmlAnyElementWithBooleanElement("lax"); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ANY_ELEMENT); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ANY_ELEMENT); assertEquals(Boolean.TRUE, xmlAnyElementAnnotation.getLax()); } public void testSetLax() throws Exception { ICompilationUnit cu = this.createTestXmlAnyElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ANY_ELEMENT); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ANY_ELEMENT); assertNotNull(xmlAnyElementAnnotation); assertNull(xmlAnyElementAnnotation.getLax()); @@ -106,10 +106,10 @@ public class XmlAnyElementAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetValue() throws Exception { ICompilationUnit cu = this.createTestXmlAnyElementWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ANY_ELEMENT); + XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ANY_ELEMENT); assertTrue(xmlAnyElementAnnotation != null); assertEquals(XML_ANY_ELEMENT_VALUE, xmlAnyElementAnnotation.getValue()); assertEquals("java.lang." + XML_ANY_ELEMENT_VALUE, xmlAnyElementAnnotation.getFullyQualifiedValueClassName()); @@ -117,10 +117,10 @@ public class XmlAnyElementAnnotationTests extends JaxbJavaResourceModelTestCase public void testSetValue() throws Exception { ICompilationUnit cu = this.createTestXmlAnyElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ANY_ELEMENT); + XmlAnyElementAnnotation xmlAnyElementAnnotation = (XmlAnyElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ANY_ELEMENT); assertNull(xmlAnyElementAnnotation.getValue()); xmlAnyElementAnnotation.setValue(XML_ANY_ELEMENT_VALUE); assertEquals(XML_ANY_ELEMENT_VALUE, xmlAnyElementAnnotation.getValue()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttachmentRefAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttachmentRefAnnotationTests.java index 9dc7870059..51a4533042 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttachmentRefAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttachmentRefAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAttachmentRefAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -39,13 +39,13 @@ public class XmlAttachmentRefAnnotationTests extends JaxbJavaResourceModelTestCa public void testGetXmlAttachmentRef() throws Exception { ICompilationUnit cu = this.createTestXmlAttachmentRef(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAttachmentRefAnnotation xmlAttachmentRefAnnotation = (XmlAttachmentRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTACHMENT_REF); + XmlAttachmentRefAnnotation xmlAttachmentRefAnnotation = (XmlAttachmentRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTACHMENT_REF); assertTrue(xmlAttachmentRefAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_ATTACHMENT_REF); + resourceAttribute.removeAnnotation(JAXB.XML_ATTACHMENT_REF); assertSourceDoesNotContain("@XmlAttachmentRef", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttributeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttributeAnnotationTests.java index e4a2ea3227..642ee5750d 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttributeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlAttributeAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlAttributeAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -76,20 +76,20 @@ public class XmlAttributeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetName() throws Exception { ICompilationUnit cu = this.createTestXmlAttributeWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTRIBUTE); + XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTRIBUTE); assertTrue(xmlAttributeAnnotation != null); assertEquals(XML_ATTRIBUTE_NAME, xmlAttributeAnnotation.getName()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlAttribute(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTRIBUTE); + XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTRIBUTE); assertTrue(xmlAttributeAnnotation != null); assertNull(xmlAttributeAnnotation.getName()); assertNull(xmlAttributeAnnotation.getNamespace()); @@ -98,10 +98,10 @@ public class XmlAttributeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testSetName() throws Exception { ICompilationUnit cu = this.createTestXmlAttribute(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTRIBUTE); + XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTRIBUTE); assertNull(xmlAttributeAnnotation.getName()); xmlAttributeAnnotation.setName(XML_ATTRIBUTE_NAME); assertEquals(XML_ATTRIBUTE_NAME, xmlAttributeAnnotation.getName()); @@ -117,20 +117,20 @@ public class XmlAttributeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlAttributeWithNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTRIBUTE); + XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTRIBUTE); assertTrue(xmlAttributeAnnotation != null); assertEquals(XML_ATTRIBUTE_NAMESPACE, xmlAttributeAnnotation.getNamespace()); } public void testSetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlAttribute(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTRIBUTE); + XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTRIBUTE); assertNull(xmlAttributeAnnotation.getNamespace()); xmlAttributeAnnotation.setNamespace(XML_ATTRIBUTE_NAMESPACE); assertEquals(XML_ATTRIBUTE_NAMESPACE, xmlAttributeAnnotation.getNamespace()); @@ -146,18 +146,18 @@ public class XmlAttributeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetRequired() throws Exception { ICompilationUnit cu = this.createTestXmlAttributeWithBooleanElement("required"); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTRIBUTE); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTRIBUTE); assertEquals(Boolean.TRUE, xmlAttributeAnnotation.getRequired()); } public void testSetRequired() throws Exception { ICompilationUnit cu = this.createTestXmlAttribute(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) attributeResource.getAnnotation(JAXB.XML_ATTRIBUTE); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlAttributeAnnotation xmlAttributeAnnotation = (XmlAttributeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ATTRIBUTE); assertNotNull(xmlAttributeAnnotation); assertNull(xmlAttributeAnnotation.getRequired()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementAnnotationTests.java index fee920f40b..373e2701d2 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlElementAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -95,20 +95,20 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetName() throws Exception { ICompilationUnit cu = this.createTestXmlElementWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertTrue(xmlElementAnnotation != null); assertEquals(XML_ELEMENT_NAME, xmlElementAnnotation.getName()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertTrue(xmlElementAnnotation != null); assertNull(xmlElementAnnotation.getName()); assertNull(xmlElementAnnotation.getNamespace()); @@ -120,10 +120,10 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testSetName() throws Exception { ICompilationUnit cu = this.createTestXmlElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertNull(xmlElementAnnotation.getName()); xmlElementAnnotation.setName(XML_ELEMENT_NAME); assertEquals(XML_ELEMENT_NAME, xmlElementAnnotation.getName()); @@ -139,20 +139,20 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementWithNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertTrue(xmlElementAnnotation != null); assertEquals(XML_ELEMENT_NAMESPACE, xmlElementAnnotation.getNamespace()); } public void testSetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertNull(xmlElementAnnotation.getNamespace()); xmlElementAnnotation.setNamespace(XML_ELEMENT_NAMESPACE); assertEquals(XML_ELEMENT_NAMESPACE, xmlElementAnnotation.getNamespace()); @@ -168,20 +168,20 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetDefaultValue() throws Exception { ICompilationUnit cu = this.createTestXmlElementWithDefaultValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertTrue(xmlElementAnnotation != null); assertEquals(XML_ELEMENT_DEFAULT_VALUE, xmlElementAnnotation.getDefaultValue()); } public void testSetDefaultValue() throws Exception { ICompilationUnit cu = this.createTestXmlElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertNull(xmlElementAnnotation.getDefaultValue()); xmlElementAnnotation.setDefaultValue(XML_ELEMENT_DEFAULT_VALUE); assertEquals(XML_ELEMENT_DEFAULT_VALUE, xmlElementAnnotation.getDefaultValue()); @@ -197,18 +197,18 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetNillable() throws Exception { ICompilationUnit cu = this.createTestXmlElementWithBooleanElement("nillable"); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertEquals(Boolean.TRUE, xmlElementAnnotation.getNillable()); } public void testSetNillable() throws Exception { ICompilationUnit cu = this.createTestXmlElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertNotNull(xmlElementAnnotation); assertNull(xmlElementAnnotation.getNillable()); @@ -225,18 +225,18 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetRequired() throws Exception { ICompilationUnit cu = this.createTestXmlElementWithBooleanElement("required"); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertEquals(Boolean.TRUE, xmlElementAnnotation.getRequired()); } public void testSetRequired() throws Exception { ICompilationUnit cu = this.createTestXmlElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertNotNull(xmlElementAnnotation); assertNull(xmlElementAnnotation.getRequired()); @@ -253,10 +253,10 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetType() throws Exception { ICompilationUnit cu = this.createTestXmlElementWithType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertTrue(xmlElementAnnotation != null); assertEquals(XML_ELEMENT_TYPE, xmlElementAnnotation.getType()); assertEquals("java.lang." + XML_ELEMENT_TYPE, xmlElementAnnotation.getFullyQualifiedTypeName()); @@ -264,10 +264,10 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testSetType() throws Exception { ICompilationUnit cu = this.createTestXmlElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertNull(xmlElementAnnotation.getType()); xmlElementAnnotation.setType(XML_ELEMENT_TYPE); assertEquals(XML_ELEMENT_TYPE, xmlElementAnnotation.getType()); @@ -283,14 +283,14 @@ public class XmlElementAnnotationTests extends JaxbJavaResourceModelTestCase { public void testAddXmlElementAnnotation() throws Exception { ICompilationUnit cu = this.createTestXmlElementWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT); + XmlElementAnnotation xmlElementAnnotation = (XmlElementAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT); assertTrue(xmlElementAnnotation != null); assertEquals(XML_ELEMENT_NAME, xmlElementAnnotation.getName()); - XmlElementAnnotation xmlElementAnnotation2 = (XmlElementAnnotation) attributeResource.addAnnotation(1, JAXB.XML_ELEMENT, JAXB.XML_ELEMENTS); + XmlElementAnnotation xmlElementAnnotation2 = (XmlElementAnnotation) resourceAttribute.addAnnotation(1, JAXB.XML_ELEMENT, JAXB.XML_ELEMENTS); xmlElementAnnotation2.setName("Foo"); assertSourceContains("@XmlElements({@XmlElement(name = \"" + XML_ELEMENT_NAME + "\"),@XmlElement(name = \"Foo\")})", cu); } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementDeclAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementDeclAnnotationTests.java index da3f2d0e76..fecc1e428d 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementDeclAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementDeclAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlElementDeclAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -90,20 +90,20 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetName() throws Exception { ICompilationUnit cu = this.createTestXmlElementDeclWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertTrue(xmlElementDeclAnnotation != null); assertEquals(XML_ELEMENT_DECL_NAME, xmlElementDeclAnnotation.getName()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlElementDecl(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertTrue(xmlElementDeclAnnotation != null); assertNull(xmlElementDeclAnnotation.getName()); assertNull(xmlElementDeclAnnotation.getNamespace()); @@ -115,10 +115,10 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testSetName() throws Exception { ICompilationUnit cu = this.createTestXmlElementDecl(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertNull(xmlElementDeclAnnotation.getName()); xmlElementDeclAnnotation.setName(XML_ELEMENT_DECL_NAME); assertEquals(XML_ELEMENT_DECL_NAME, xmlElementDeclAnnotation.getName()); @@ -134,20 +134,20 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementDeclWithNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertTrue(xmlElementDeclAnnotation != null); assertEquals(XML_ELEMENT_DECL_NAMESPACE, xmlElementDeclAnnotation.getNamespace()); } public void testSetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementDecl(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertNull(xmlElementDeclAnnotation.getNamespace()); xmlElementDeclAnnotation.setNamespace(XML_ELEMENT_DECL_NAMESPACE); assertEquals(XML_ELEMENT_DECL_NAMESPACE, xmlElementDeclAnnotation.getNamespace()); @@ -163,20 +163,20 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetDefaultValue() throws Exception { ICompilationUnit cu = this.createTestXmlElementDeclWithDefaultValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertTrue(xmlElementDeclAnnotation != null); assertEquals(XML_ELEMENT_DECL_DEFAULT_VALUE, xmlElementDeclAnnotation.getDefaultValue()); } public void testSetDefaultValue() throws Exception { ICompilationUnit cu = this.createTestXmlElementDecl(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertNull(xmlElementDeclAnnotation.getDefaultValue()); xmlElementDeclAnnotation.setDefaultValue(XML_ELEMENT_DECL_DEFAULT_VALUE); assertEquals(XML_ELEMENT_DECL_DEFAULT_VALUE, xmlElementDeclAnnotation.getDefaultValue()); @@ -192,10 +192,10 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetScope() throws Exception { ICompilationUnit cu = this.createTestXmlElementDeclWithScope(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertTrue(xmlElementDeclAnnotation != null); assertEquals(XML_ELEMENT_DECL_SCOPE, xmlElementDeclAnnotation.getScope()); assertEquals("javax.xml.bind.annotation." + XML_ELEMENT_DECL_SCOPE, xmlElementDeclAnnotation.getFullyQualifiedScopeClassName()); @@ -203,10 +203,10 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testSetScope() throws Exception { ICompilationUnit cu = this.createTestXmlElementDecl(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertNull(xmlElementDeclAnnotation.getScope()); xmlElementDeclAnnotation.setScope(XML_ELEMENT_DECL_SCOPE); assertEquals(XML_ELEMENT_DECL_SCOPE, xmlElementDeclAnnotation.getScope()); @@ -222,20 +222,20 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetSubstitutionHeadName() throws Exception { ICompilationUnit cu = this.createTestXmlElementDeclWithSubstitutionHeadName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertTrue(xmlElementDeclAnnotation != null); assertEquals(XML_ELEMENT_DECL_NAME, xmlElementDeclAnnotation.getSubstitutionHeadName()); } public void testSetSubstitutionHeadName() throws Exception { ICompilationUnit cu = this.createTestXmlElementDecl(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertNull(xmlElementDeclAnnotation.getSubstitutionHeadName()); xmlElementDeclAnnotation.setSubstitutionHeadName(XML_ELEMENT_DECL_NAME); assertEquals(XML_ELEMENT_DECL_NAME, xmlElementDeclAnnotation.getSubstitutionHeadName()); @@ -251,20 +251,20 @@ public class XmlElementDeclAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetSubstitutionHeadNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementDeclWithSubstitutionHeadNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertTrue(xmlElementDeclAnnotation != null); assertEquals(XML_ELEMENT_DECL_NAME, xmlElementDeclAnnotation.getSubstitutionHeadNamespace()); } public void testSetSubstitutionHeadNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementDecl(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.methods().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getMethod(resourceType, 0); - XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_DECL); + XmlElementDeclAnnotation xmlElementDeclAnnotation = (XmlElementDeclAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_DECL); assertNull(xmlElementDeclAnnotation.getSubstitutionHeadNamespace()); xmlElementDeclAnnotation.setSubstitutionHeadNamespace(XML_ELEMENT_DECL_NAME); assertEquals(XML_ELEMENT_DECL_NAME, xmlElementDeclAnnotation.getSubstitutionHeadNamespace()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementRefAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementRefAnnotationTests.java index 7c563f7dc8..463ff70c05 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementRefAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementRefAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlElementRefAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -77,20 +77,20 @@ public class XmlElementRefAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetName() throws Exception { ICompilationUnit cu = this.createTestXmlElementRefWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertTrue(xmlElementRefAnnotation != null); assertEquals(XML_ELEMENT_REF_NAME, xmlElementRefAnnotation.getName()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlElementRef(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertTrue(xmlElementRefAnnotation != null); assertNull(xmlElementRefAnnotation.getName()); assertNull(xmlElementRefAnnotation.getNamespace()); @@ -99,10 +99,10 @@ public class XmlElementRefAnnotationTests extends JaxbJavaResourceModelTestCase public void testSetName() throws Exception { ICompilationUnit cu = this.createTestXmlElementRef(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertNull(xmlElementRefAnnotation.getName()); xmlElementRefAnnotation.setName(XML_ELEMENT_REF_NAME); assertEquals(XML_ELEMENT_REF_NAME, xmlElementRefAnnotation.getName()); @@ -118,20 +118,20 @@ public class XmlElementRefAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementRefWithNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertTrue(xmlElementRefAnnotation != null); assertEquals(XML_ELEMENT_REF_NAMESPACE, xmlElementRefAnnotation.getNamespace()); } public void testSetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementRef(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertNull(xmlElementRefAnnotation.getNamespace()); xmlElementRefAnnotation.setNamespace(XML_ELEMENT_REF_NAMESPACE); assertEquals(XML_ELEMENT_REF_NAMESPACE, xmlElementRefAnnotation.getNamespace()); @@ -147,10 +147,10 @@ public class XmlElementRefAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetType() throws Exception { ICompilationUnit cu = this.createTestXmlElementRefWithType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertTrue(xmlElementRefAnnotation != null); assertEquals(XML_ELEMENT_REF_TYPE, xmlElementRefAnnotation.getType()); assertEquals("java.lang." + XML_ELEMENT_REF_TYPE, xmlElementRefAnnotation.getFullyQualifiedTypeName()); @@ -158,10 +158,10 @@ public class XmlElementRefAnnotationTests extends JaxbJavaResourceModelTestCase public void testSetType() throws Exception { ICompilationUnit cu = this.createTestXmlElementRef(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertNull(xmlElementRefAnnotation.getType()); xmlElementRefAnnotation.setType(XML_ELEMENT_REF_TYPE); assertEquals(XML_ELEMENT_REF_TYPE, xmlElementRefAnnotation.getType()); @@ -177,14 +177,14 @@ public class XmlElementRefAnnotationTests extends JaxbJavaResourceModelTestCase public void testAddXmlElementRefAnnotation() throws Exception { ICompilationUnit cu = this.createTestXmlElementRefWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_REF); + XmlElementRefAnnotation xmlElementRefAnnotation = (XmlElementRefAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_REF); assertTrue(xmlElementRefAnnotation != null); assertEquals(XML_ELEMENT_REF_NAME, xmlElementRefAnnotation.getName()); - XmlElementRefAnnotation xmlElementRefAnnotation2 = (XmlElementRefAnnotation) attributeResource.addAnnotation(1, JAXB.XML_ELEMENT_REF, JAXB.XML_ELEMENT_REFS); + XmlElementRefAnnotation xmlElementRefAnnotation2 = (XmlElementRefAnnotation) resourceAttribute.addAnnotation(1, JAXB.XML_ELEMENT_REF, JAXB.XML_ELEMENT_REFS); xmlElementRefAnnotation2.setName("Foo"); assertSourceContains("@XmlElementRefs({@XmlElementRef(name = \"" + XML_ELEMENT_REF_NAME + "\"),@XmlElementRef(name = \"Foo\")})", cu); } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementWrapperAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementWrapperAnnotationTests.java index 9ac02daebf..c7ecab5e9b 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementWrapperAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlElementWrapperAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlElementWrapperAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -76,20 +76,20 @@ public class XmlElementWrapperAnnotationTests extends JaxbJavaResourceModelTestC public void testGetName() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapperWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertTrue(xmlElementWrapperAnnotation != null); assertEquals(XML_ELEMENT_WRAPPER_NAME, xmlElementWrapperAnnotation.getName()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapper(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertTrue(xmlElementWrapperAnnotation != null); assertNull(xmlElementWrapperAnnotation.getName()); assertNull(xmlElementWrapperAnnotation.getNamespace()); @@ -99,10 +99,10 @@ public class XmlElementWrapperAnnotationTests extends JaxbJavaResourceModelTestC public void testSetName() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapper(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertNull(xmlElementWrapperAnnotation.getName()); xmlElementWrapperAnnotation.setName(XML_ELEMENT_WRAPPER_NAME); assertEquals(XML_ELEMENT_WRAPPER_NAME, xmlElementWrapperAnnotation.getName()); @@ -118,20 +118,20 @@ public class XmlElementWrapperAnnotationTests extends JaxbJavaResourceModelTestC public void testGetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapperWithNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertTrue(xmlElementWrapperAnnotation != null); assertEquals(XML_ELEMENT_WRAPPER_NAMESPACE, xmlElementWrapperAnnotation.getNamespace()); } public void testSetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapper(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertNull(xmlElementWrapperAnnotation.getNamespace()); xmlElementWrapperAnnotation.setNamespace(XML_ELEMENT_WRAPPER_NAMESPACE); assertEquals(XML_ELEMENT_WRAPPER_NAMESPACE, xmlElementWrapperAnnotation.getNamespace()); @@ -147,18 +147,18 @@ public class XmlElementWrapperAnnotationTests extends JaxbJavaResourceModelTestC public void testGetNillable() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapperWithBooleanElement("nillable"); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertEquals(Boolean.TRUE, xmlElementWrapperAnnotation.getNillable()); } public void testSetNillable() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapper(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertNotNull(xmlElementWrapperAnnotation); assertNull(xmlElementWrapperAnnotation.getNillable()); @@ -175,18 +175,18 @@ public class XmlElementWrapperAnnotationTests extends JaxbJavaResourceModelTestC public void testGetRequired() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapperWithBooleanElement("required"); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertEquals(Boolean.TRUE, xmlElementWrapperAnnotation.getRequired()); } public void testSetRequired() throws Exception { ICompilationUnit cu = this.createTestXmlElementWrapper(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); - XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) attributeResource.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); + XmlElementWrapperAnnotation xmlElementWrapperAnnotation = (XmlElementWrapperAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ELEMENT_WRAPPER); assertNotNull(xmlElementWrapperAnnotation); assertNull(xmlElementWrapperAnnotation.getRequired()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumAnnotationTests.java index 56b02601d4..ab4376356c 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlEnumAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -53,18 +53,18 @@ public class XmlEnumAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlEnum(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlEnumAnnotation xmlEnumAnnotation = (XmlEnumAnnotation) typeResource.getAnnotation(JAXB.XML_ENUM); + XmlEnumAnnotation xmlEnumAnnotation = (XmlEnumAnnotation) resourceType.getAnnotation(JAXB.XML_ENUM); assertTrue(xmlEnumAnnotation != null); assertNull(xmlEnumAnnotation.getValue()); } public void testGetValue() throws Exception { ICompilationUnit cu = this.createTestXmlEnumWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlEnumAnnotation xmlEnumAnnotation = (XmlEnumAnnotation) typeResource.getAnnotation(JAXB.XML_ENUM); + XmlEnumAnnotation xmlEnumAnnotation = (XmlEnumAnnotation) resourceType.getAnnotation(JAXB.XML_ENUM); assertTrue(xmlEnumAnnotation != null); assertEquals(XML_ENUM_JAVA_TYPE, xmlEnumAnnotation.getValue()); assertEquals("java.lang." + XML_ENUM_JAVA_TYPE, xmlEnumAnnotation.getFullyQualifiedValueClassName()); @@ -72,9 +72,9 @@ public class XmlEnumAnnotationTests extends JaxbJavaResourceModelTestCase { public void testSetValue() throws Exception { ICompilationUnit cu = this.createTestXmlEnum(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlEnumAnnotation xmlEnumAnnotation = (XmlEnumAnnotation) typeResource.getAnnotation(JAXB.XML_ENUM); + XmlEnumAnnotation xmlEnumAnnotation = (XmlEnumAnnotation) resourceType.getAnnotation(JAXB.XML_ENUM); assertNull(xmlEnumAnnotation.getValue()); xmlEnumAnnotation.setValue(XML_ENUM_JAVA_TYPE); assertEquals(XML_ENUM_JAVA_TYPE, xmlEnumAnnotation.getValue()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumValueAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumValueAnnotationTests.java index a0221a5c51..f82a4bd648 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumValueAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlEnumValueAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlEnumValueAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -58,43 +58,43 @@ public class XmlEnumValueAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlEnumValue() throws Exception { ICompilationUnit cu = this.createTestXmlEnumValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) attributeResource.getAnnotation(JAXB.XML_ENUM_VALUE); + XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ENUM_VALUE); assertTrue(xmlEnumValueAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_ENUM_VALUE); + resourceAttribute.removeAnnotation(JAXB.XML_ENUM_VALUE); assertSourceDoesNotContain("@XmlEnumValue", cu); } public void testGetValue() throws Exception { ICompilationUnit cu = this.createTestXmlEnumValueWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) attributeResource.getAnnotation(JAXB.XML_ENUM_VALUE); + XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ENUM_VALUE); assertTrue(xmlEnumValueAnnotation != null); assertEquals(XML_ENUM_VALUE_VALUE, xmlEnumValueAnnotation.getValue()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlEnumValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) attributeResource.getAnnotation(JAXB.XML_ENUM_VALUE); + XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ENUM_VALUE); assertTrue(xmlEnumValueAnnotation != null); assertNull(xmlEnumValueAnnotation.getValue()); } public void testSetValue() throws Exception { ICompilationUnit cu = this.createTestXmlEnumValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) attributeResource.getAnnotation(JAXB.XML_ENUM_VALUE); + XmlEnumValueAnnotation xmlEnumValueAnnotation = (XmlEnumValueAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ENUM_VALUE); assertNull(xmlEnumValueAnnotation.getValue()); xmlEnumValueAnnotation.setValue(XML_ENUM_VALUE_VALUE); assertEquals(XML_ENUM_VALUE_VALUE, xmlEnumValueAnnotation.getValue()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDAnnotationTests.java index c9186f40c8..727b5c0417 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlIDAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -39,13 +39,13 @@ public class XmlIDAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlID() throws Exception { ICompilationUnit cu = this.createTestXmlID(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlIDAnnotation xmlIDAnnotation = (XmlIDAnnotation) attributeResource.getAnnotation(JAXB.XML_ID); + XmlIDAnnotation xmlIDAnnotation = (XmlIDAnnotation) resourceAttribute.getAnnotation(JAXB.XML_ID); assertTrue(xmlIDAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_ID); + resourceAttribute.removeAnnotation(JAXB.XML_ID); assertSourceDoesNotContain("@XmlID", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDREFAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDREFAnnotationTests.java index 8b1961fd46..a4b0576a6e 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDREFAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlIDREFAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlIDREFAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -39,13 +39,13 @@ public class XmlIDREFAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlIDREF() throws Exception { ICompilationUnit cu = this.createTestXmlIDREF(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlIDREFAnnotation xmlIDREFAnnotation = (XmlIDREFAnnotation) attributeResource.getAnnotation(JAXB.XML_IDREF); + XmlIDREFAnnotation xmlIDREFAnnotation = (XmlIDREFAnnotation) resourceAttribute.getAnnotation(JAXB.XML_IDREF); assertTrue(xmlIDREFAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_IDREF); + resourceAttribute.removeAnnotation(JAXB.XML_IDREF); assertSourceDoesNotContain("@XmlIDREF", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlInlineBinaryDataAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlInlineBinaryDataAnnotationTests.java index 3fbc49522e..27d7245bae 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlInlineBinaryDataAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlInlineBinaryDataAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlInlineBinaryDataAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -38,12 +38,12 @@ public class XmlInlineBinaryDataAnnotationTests extends JaxbJavaResourceModelTes public void testGetXmlInlineBinaryData() throws Exception { ICompilationUnit cu = this.createTestXmlInlineBinaryData(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlInlineBinaryDataAnnotation xmlInlineBinaryDataAnnotation = (XmlInlineBinaryDataAnnotation) typeResource.getAnnotation(JAXB.XML_INLINE_BINARY_DATA); + XmlInlineBinaryDataAnnotation xmlInlineBinaryDataAnnotation = (XmlInlineBinaryDataAnnotation) resourceType.getAnnotation(JAXB.XML_INLINE_BINARY_DATA); assertTrue(xmlInlineBinaryDataAnnotation != null); - typeResource.removeAnnotation(JAXB.XML_INLINE_BINARY_DATA); + resourceType.removeAnnotation(JAXB.XML_INLINE_BINARY_DATA); assertSourceDoesNotContain("@XmlInlineBinaryData", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterPackageAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterPackageAnnotationTests.java index 5060201996..883f584b43 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterPackageAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterPackageAnnotationTests.java @@ -11,13 +11,13 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import org.eclipse.core.runtime.CoreException; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.XmlJavaTypeAdapterAnnotation; import org.eclipse.jpt.jaxb.core.resource.java.XmlJavaTypeAdaptersAnnotation; - +@SuppressWarnings("nls") public class XmlJavaTypeAdapterPackageAnnotationTests extends JaxbJavaResourceModelTestCase { @@ -84,11 +84,11 @@ public class XmlJavaTypeAdapterPackageAnnotationTests throws Exception { ICompilationUnit cu = createPackageInfoWithJavaTypeAdapterAndValue(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); createTestClass2(); XmlJavaTypeAdapterAnnotation annotation = - (XmlJavaTypeAdapterAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); + (XmlJavaTypeAdapterAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); assertTrue(annotation != null); assertEquals(TEST_CLASS, annotation.getValue()); assertEquals(FQ_TEST_CLASS, annotation.getFullyQualifiedValue()); @@ -114,11 +114,11 @@ public class XmlJavaTypeAdapterPackageAnnotationTests throws Exception { ICompilationUnit cu = createPackageInfoWithJavaTypeAdapterAndType(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); createTestClass2(); XmlJavaTypeAdapterAnnotation annotation = - (XmlJavaTypeAdapterAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); + (XmlJavaTypeAdapterAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); assertTrue(annotation != null); assertEquals(TEST_CLASS, annotation.getType()); assertEquals(FQ_TEST_CLASS, annotation.getFullyQualifiedType()); @@ -144,11 +144,11 @@ public class XmlJavaTypeAdapterPackageAnnotationTests throws Exception { ICompilationUnit cu = createPackageInfoWithJavaTypeAdapterAndValue(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); createTestClass2(); XmlJavaTypeAdapterAnnotation annotation = - (XmlJavaTypeAdapterAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); + (XmlJavaTypeAdapterAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); assertTrue(annotation != null); assertEquals(TEST_CLASS, annotation.getValue()); assertSourceContains("@XmlJavaTypeAdapter(" + TEST_CLASS + ".class)", cu); @@ -179,11 +179,11 @@ public class XmlJavaTypeAdapterPackageAnnotationTests // test contained annotation value setting/updating ICompilationUnit cu = createPackageInfoWithJavaTypeAdapters(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); createTestClass(); XmlJavaTypeAdaptersAnnotation adaptersAnnotation = - (XmlJavaTypeAdaptersAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); + (XmlJavaTypeAdaptersAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); XmlJavaTypeAdapterAnnotation adapterAnnotation = adaptersAnnotation.getNestedAnnotation(0); adapterAnnotation.setValue(TEST_CLASS); @@ -204,11 +204,11 @@ public class XmlJavaTypeAdapterPackageAnnotationTests // test contained annotation type setting/updating ICompilationUnit cu = createPackageInfoWithJavaTypeAdapters(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); createTestClass(); XmlJavaTypeAdaptersAnnotation adaptersAnnotation = - (XmlJavaTypeAdaptersAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); + (XmlJavaTypeAdaptersAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); XmlJavaTypeAdapterAnnotation adapterAnnotation = adaptersAnnotation.getNestedAnnotation(1); adapterAnnotation.setType(TEST_CLASS); @@ -229,17 +229,17 @@ public class XmlJavaTypeAdapterPackageAnnotationTests // test adding/removing/moving ICompilationUnit cu = createPackageInfoWithJavaTypeAdapter(); - JavaResourcePackage packageResource = buildJavaResourcePackage(cu); + JavaResourcePackage resourcePackage = buildJavaResourcePackage(cu); createTestClass(); createTestClass2(); XmlJavaTypeAdaptersAnnotation adaptersAnnotation = - (XmlJavaTypeAdaptersAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); + (XmlJavaTypeAdaptersAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); assertNull(adaptersAnnotation); - packageResource.addAnnotation(1, JAXB.XML_JAVA_TYPE_ADAPTER, JAXB.XML_JAVA_TYPE_ADAPTERS); + resourcePackage.addAnnotation(1, JAXB.XML_JAVA_TYPE_ADAPTER, JAXB.XML_JAVA_TYPE_ADAPTERS); adaptersAnnotation = - (XmlJavaTypeAdaptersAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); + (XmlJavaTypeAdaptersAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); assertEquals(2, adaptersAnnotation.getNestedAnnotationsSize()); assertSourceContains("@XmlJavaTypeAdapters({@XmlJavaTypeAdapter,@XmlJavaTypeAdapter})", cu); @@ -252,16 +252,16 @@ public class XmlJavaTypeAdapterPackageAnnotationTests + ".class),@XmlJavaTypeAdapter(" + TEST_CLASS_2 + ".class)})", cu); - packageResource.moveAnnotation(0, 1, JAXB.XML_JAVA_TYPE_ADAPTERS); + resourcePackage.moveAnnotation(0, 1, JAXB.XML_JAVA_TYPE_ADAPTERS); assertSourceContains( "@XmlJavaTypeAdapters({@XmlJavaTypeAdapter(" + TEST_CLASS_2 + ".class),@XmlJavaTypeAdapter(" + TEST_CLASS + ".class)})", cu); // TODO uncomment when bug 328400 is addressed -// packageResource.removeAnnotation(1, JAXB.XML_JAVA_TYPE_ADAPTER, JAXB.XML_JAVA_TYPE_ADAPTERS); +// resourcePackage.removeAnnotation(1, JAXB.XML_JAVA_TYPE_ADAPTER, JAXB.XML_JAVA_TYPE_ADAPTERS); // adaptersAnnotation = -// (XmlJavaTypeAdaptersAnnotation) packageResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); +// (XmlJavaTypeAdaptersAnnotation) resourcePackage.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTERS); // assertNull(adaptersAnnotation); // assertSourceContains( // "@XmlJavaTypeAdapter(" + TEST_CLASS_2 + ")", cu); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterTypeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterTypeAnnotationTests.java index 53ab19c722..b7babc158b 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterTypeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlJavaTypeAdapterTypeAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlJavaTypeAdapterAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -66,18 +66,18 @@ public class XmlJavaTypeAdapterTypeAnnotationTests extends JaxbJavaResourceModel public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlJavaTypeAdapter(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) typeResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); + XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) resourceType.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); assertTrue(xmlJavaTypeAdapterAnnotation != null); assertNull(xmlJavaTypeAdapterAnnotation.getValue()); } public void testGetValue() throws Exception { ICompilationUnit cu = this.createTestXmlJavaTypeAdapterWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) typeResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); + XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) resourceType.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); assertTrue(xmlJavaTypeAdapterAnnotation != null); assertEquals(XML_JAVA_TYPE_ADAPTER_CLASS, xmlJavaTypeAdapterAnnotation.getValue()); assertEquals("test." + XML_JAVA_TYPE_ADAPTER_CLASS, xmlJavaTypeAdapterAnnotation.getFullyQualifiedValue()); @@ -85,9 +85,9 @@ public class XmlJavaTypeAdapterTypeAnnotationTests extends JaxbJavaResourceModel public void testSetValue() throws Exception { ICompilationUnit cu = this.createTestXmlJavaTypeAdapter(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) typeResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); + XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) resourceType.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); assertNull(xmlJavaTypeAdapterAnnotation.getValue()); xmlJavaTypeAdapterAnnotation.setValue(XML_JAVA_TYPE_ADAPTER_CLASS); assertEquals(XML_JAVA_TYPE_ADAPTER_CLASS, xmlJavaTypeAdapterAnnotation.getValue()); @@ -97,9 +97,9 @@ public class XmlJavaTypeAdapterTypeAnnotationTests extends JaxbJavaResourceModel public void testSetValueNull() throws Exception { ICompilationUnit cu = this.createTestXmlJavaTypeAdapterWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) typeResource.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); + XmlJavaTypeAdapterAnnotation xmlJavaTypeAdapterAnnotation = (XmlJavaTypeAdapterAnnotation) resourceType.getAnnotation(JAXB.XML_JAVA_TYPE_ADAPTER); assertEquals(XML_JAVA_TYPE_ADAPTER_CLASS, xmlJavaTypeAdapterAnnotation.getValue()); xmlJavaTypeAdapterAnnotation.setValue(null); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlListAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlListAnnotationTests.java index f25b5f3e02..add1da747c 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlListAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlListAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlListAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -39,13 +39,13 @@ public class XmlListAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlList() throws Exception { ICompilationUnit cu = this.createTestXmlList(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlListAnnotation xmlListAnnotation = (XmlListAnnotation) attributeResource.getAnnotation(JAXB.XML_LIST); + XmlListAnnotation xmlListAnnotation = (XmlListAnnotation) resourceAttribute.getAnnotation(JAXB.XML_LIST); assertTrue(xmlListAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_LIST); + resourceAttribute.removeAnnotation(JAXB.XML_LIST); assertSourceDoesNotContain("@XmlList", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMimeTypeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMimeTypeAnnotationTests.java index 2c9b336293..f50c4feb9a 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMimeTypeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMimeTypeAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlMimeTypeAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -58,42 +58,42 @@ public class XmlMimeTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlMimeType() throws Exception { ICompilationUnit cu = this.createTestXmlMimeType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) attributeResource.getAnnotation(JAXB.XML_MIME_TYPE); + XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_MIME_TYPE); assertTrue(xmlMimeTypeAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_MIME_TYPE); + resourceAttribute.removeAnnotation(JAXB.XML_MIME_TYPE); assertSourceDoesNotContain("@XmlMimeType", cu); } public void testGetValue() throws Exception { ICompilationUnit cu = this.createTestXmlMimeTypeWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) attributeResource.getAnnotation(JAXB.XML_MIME_TYPE); + XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_MIME_TYPE); assertTrue(xmlMimeTypeAnnotation != null); assertEquals(XML_MIME_TYPE_VALUE, xmlMimeTypeAnnotation.getValue()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlMimeType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) attributeResource.getAnnotation(JAXB.XML_MIME_TYPE); + XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_MIME_TYPE); assertTrue(xmlMimeTypeAnnotation != null); assertNull(xmlMimeTypeAnnotation.getValue()); } public void testSetValue() throws Exception { ICompilationUnit cu = this.createTestXmlMimeType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) attributeResource.getAnnotation(JAXB.XML_MIME_TYPE); + XmlMimeTypeAnnotation xmlMimeTypeAnnotation = (XmlMimeTypeAnnotation) resourceAttribute.getAnnotation(JAXB.XML_MIME_TYPE); assertNull(xmlMimeTypeAnnotation.getValue()); xmlMimeTypeAnnotation.setValue(XML_MIME_TYPE_VALUE); assertEquals(XML_MIME_TYPE_VALUE, xmlMimeTypeAnnotation.getValue()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMixedAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMixedAnnotationTests.java index c476c0ec50..e6b8d4c848 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMixedAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlMixedAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlMixedAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -39,13 +39,13 @@ public class XmlMixedAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlMixed() throws Exception { ICompilationUnit cu = this.createTestXmlMixed(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlMixedAnnotation xmlMixedAnnotation = (XmlMixedAnnotation) attributeResource.getAnnotation(JAXB.XML_MIXED); + XmlMixedAnnotation xmlMixedAnnotation = (XmlMixedAnnotation) resourceAttribute.getAnnotation(JAXB.XML_MIXED); assertTrue(xmlMixedAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_MIXED); + resourceAttribute.removeAnnotation(JAXB.XML_MIXED); assertSourceDoesNotContain("@XmlMixed", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRegistryAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRegistryAnnotationTests.java index c11f4ef9ce..4868727977 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRegistryAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRegistryAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlRegistryAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -38,12 +38,12 @@ public class XmlRegistryAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlRegistry() throws Exception { ICompilationUnit cu = this.createTestXmlRegistry(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlRegistryAnnotation xmlRegistryAnnotation = (XmlRegistryAnnotation) typeResource.getAnnotation(JAXB.XML_REGISTRY); + XmlRegistryAnnotation xmlRegistryAnnotation = (XmlRegistryAnnotation) resourceType.getAnnotation(JAXB.XML_REGISTRY); assertTrue(xmlRegistryAnnotation != null); - typeResource.removeAnnotation(JAXB.XML_REGISTRY); + resourceType.removeAnnotation(JAXB.XML_REGISTRY); assertSourceDoesNotContain("@XmlRegistry", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRootElementAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRootElementAnnotationTests.java index e7a49cfd01..9295ba8dbf 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRootElementAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlRootElementAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlRootElementAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -67,18 +67,18 @@ public class XmlRootElementAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetName() throws Exception { ICompilationUnit cu = this.createTestXmlRootElementWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) typeResource.getAnnotation(JAXB.XML_ROOT_ELEMENT); + XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) resourceType.getAnnotation(JAXB.XML_ROOT_ELEMENT); assertTrue(xmlRootElementAnnotation != null); assertEquals(XML_ROOT_ELEMENT_NAME, xmlRootElementAnnotation.getName()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlRootElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) typeResource.getAnnotation(JAXB.XML_ROOT_ELEMENT); + XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) resourceType.getAnnotation(JAXB.XML_ROOT_ELEMENT); assertTrue(xmlRootElementAnnotation != null); assertNull(xmlRootElementAnnotation.getName()); assertNull(xmlRootElementAnnotation.getNamespace()); @@ -86,9 +86,9 @@ public class XmlRootElementAnnotationTests extends JaxbJavaResourceModelTestCase public void testSetName() throws Exception { ICompilationUnit cu = this.createTestXmlRootElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) typeResource.getAnnotation(JAXB.XML_ROOT_ELEMENT); + XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) resourceType.getAnnotation(JAXB.XML_ROOT_ELEMENT); assertNull(xmlRootElementAnnotation.getName()); xmlRootElementAnnotation.setName(XML_ROOT_ELEMENT_NAME); assertEquals(XML_ROOT_ELEMENT_NAME, xmlRootElementAnnotation.getName()); @@ -104,18 +104,18 @@ public class XmlRootElementAnnotationTests extends JaxbJavaResourceModelTestCase public void testGetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlRootElementWithNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) typeResource.getAnnotation(JAXB.XML_ROOT_ELEMENT); + XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) resourceType.getAnnotation(JAXB.XML_ROOT_ELEMENT); assertTrue(xmlRootElementAnnotation != null); assertEquals(XML_ROOT_ELEMENT_NAMESPACE, xmlRootElementAnnotation.getNamespace()); } public void testSetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlRootElement(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) typeResource.getAnnotation(JAXB.XML_ROOT_ELEMENT); + XmlRootElementAnnotation xmlRootElementAnnotation = (XmlRootElementAnnotation) resourceType.getAnnotation(JAXB.XML_ROOT_ELEMENT); assertNull(xmlRootElementAnnotation.getNamespace()); xmlRootElementAnnotation.setNamespace(XML_ROOT_ELEMENT_NAMESPACE); assertEquals(XML_ROOT_ELEMENT_NAMESPACE, xmlRootElementAnnotation.getNamespace()); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaAnnotationTests.java index bd5ad41d5a..c3ca286281 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import org.eclipse.core.runtime.CoreException; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.XmlNsAnnotation; import org.eclipse.jpt.jaxb.core.resource.java.XmlNsForm; import org.eclipse.jpt.jaxb.core.resource.java.XmlSchemaAnnotation; diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaTypeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaTypeAnnotationTests.java index f7751a3522..03099f4306 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaTypeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSchemaTypeAnnotationTests.java @@ -13,12 +13,12 @@ import java.util.Date; import java.util.GregorianCalendar; import org.eclipse.core.runtime.CoreException; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourcePackage; import org.eclipse.jpt.jaxb.core.resource.java.XmlSchemaTypeAnnotation; import org.eclipse.jpt.jaxb.core.resource.java.XmlSchemaTypesAnnotation; - +@SuppressWarnings("nls") public class XmlSchemaTypeAnnotationTests extends JaxbJavaResourceModelTestCase { diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSeeAlsoAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSeeAlsoAnnotationTests.java index 145aa283d9..a312562667 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSeeAlsoAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlSeeAlsoAnnotationTests.java @@ -12,8 +12,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import java.util.ListIterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlSeeAlsoAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -54,18 +54,18 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlso(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); assertEquals(0, xmlSeeAlsoAnnotation.getClassesSize()); } public void testGetClasses() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlsoWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); ListIterator<String> classes = xmlSeeAlsoAnnotation.getClasses().iterator(); assertEquals("Foo", classes.next()); @@ -74,18 +74,18 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetClassesSize() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlsoWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); assertEquals(2, xmlSeeAlsoAnnotation.getClassesSize()); } public void testAddClass() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlso(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); xmlSeeAlsoAnnotation.addClass("Fooo"); @@ -96,9 +96,9 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase { public void testAddClassIndex() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlso(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); xmlSeeAlsoAnnotation.addClass(0, "Fooo"); @@ -110,9 +110,9 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase { public void testRemoveClass() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlsoWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); xmlSeeAlsoAnnotation.removeClass("Foo"); @@ -125,9 +125,9 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase { public void testRemoveClassIndex() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlsoWithValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); xmlSeeAlsoAnnotation.removeClass(0); @@ -140,9 +140,9 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase { public void testMoveClass() throws Exception { ICompilationUnit cu = this.createTestXmlSeeAlso(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) typeResource.getAnnotation(JAXB.XML_SEE_ALSO); + XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO); assertTrue(xmlSeeAlsoAnnotation != null); xmlSeeAlsoAnnotation.addClass("Fooo"); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTransientAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTransientAnnotationTests.java index 82b7c32991..59551d8f1c 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTransientAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTransientAnnotationTests.java @@ -11,8 +11,8 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlTransientAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -38,12 +38,12 @@ public class XmlTransientAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlTransient() throws Exception { ICompilationUnit cu = this.createTestXmlTransient(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTransientAnnotation xmlTransientAnnotation = (XmlTransientAnnotation) typeResource.getAnnotation(JAXB.XML_TRANSIENT); + XmlTransientAnnotation xmlTransientAnnotation = (XmlTransientAnnotation) resourceType.getAnnotation(JAXB.XML_TRANSIENT); assertTrue(xmlTransientAnnotation != null); - typeResource.removeAnnotation(JAXB.XML_TRANSIENT); + resourceType.removeAnnotation(JAXB.XML_TRANSIENT); assertSourceDoesNotContain("@XmlTransient", cu); } } diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTypeAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTypeAnnotationTests.java index 309b71650c..3c06252b96 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTypeAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlTypeAnnotationTests.java @@ -12,9 +12,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import java.util.ListIterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlTypeAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -122,18 +122,18 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetName() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithName(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); assertEquals(XML_TYPE_NAME, xmlTypeAnnotation.getName()); } public void testGetNull() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); assertNull(xmlTypeAnnotation.getName()); assertNull(xmlTypeAnnotation.getNamespace()); @@ -144,9 +144,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testSetName() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertNull(xmlTypeAnnotation.getName()); xmlTypeAnnotation.setName(XML_TYPE_NAME); assertEquals(XML_TYPE_NAME, xmlTypeAnnotation.getName()); @@ -162,18 +162,18 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithNamespace(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); assertEquals(XML_TYPE_NAMESPACE, xmlTypeAnnotation.getNamespace()); } public void testSetNamespace() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertNull(xmlTypeAnnotation.getNamespace()); xmlTypeAnnotation.setNamespace(XML_TYPE_NAMESPACE); assertEquals(XML_TYPE_NAMESPACE, xmlTypeAnnotation.getNamespace()); @@ -189,18 +189,18 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetFactoryMethod() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithFactoryMethod(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); assertEquals(XML_TYPE_FACTORY_METHOD, xmlTypeAnnotation.getFactoryMethod()); } public void testSetFactoryMethod() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertNull(xmlTypeAnnotation.getFactoryMethod()); xmlTypeAnnotation.setFactoryMethod(XML_TYPE_FACTORY_METHOD); assertEquals(XML_TYPE_FACTORY_METHOD, xmlTypeAnnotation.getFactoryMethod()); @@ -216,9 +216,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetFactoryClass() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithFactoryClass(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); assertEquals(XML_TYPE_FACTORY_CLASS, xmlTypeAnnotation.getFactoryClass()); assertEquals("test." + XML_TYPE_FACTORY_CLASS, xmlTypeAnnotation.getFullyQualifiedFactoryClassName()); @@ -226,9 +226,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testSetFactoryClass() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertNull(xmlTypeAnnotation.getFactoryClass()); xmlTypeAnnotation.setFactoryClass(XML_TYPE_FACTORY_CLASS); assertEquals(XML_TYPE_FACTORY_CLASS, xmlTypeAnnotation.getFactoryClass()); @@ -244,9 +244,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetPropOrder() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithPropOrder(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); ListIterator<String> propOrder = xmlTypeAnnotation.getPropOrder().iterator(); assertEquals("foo", propOrder.next()); @@ -255,18 +255,18 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetPropOrderSize() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithPropOrder(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); assertEquals(2, xmlTypeAnnotation.getPropOrderSize()); } public void testAddProp() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); xmlTypeAnnotation.addProp("fooo"); @@ -277,9 +277,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testAddPropIndex() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); xmlTypeAnnotation.addProp(0, "fooo"); @@ -291,9 +291,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testRemoveProp() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithPropOrder(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); xmlTypeAnnotation.removeProp("foo"); @@ -306,9 +306,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testRemovePropIndex() throws Exception { ICompilationUnit cu = this.createTestXmlTypeWithPropOrder(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); xmlTypeAnnotation.removeProp(0); @@ -321,9 +321,9 @@ public class XmlTypeAnnotationTests extends JaxbJavaResourceModelTestCase { public void testMoveProp() throws Exception { ICompilationUnit cu = this.createTestXmlType(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); + JavaResourceType resourceType = buildJavaResourceType(cu); - XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) typeResource.getAnnotation(JAXB.XML_TYPE); + XmlTypeAnnotation xmlTypeAnnotation = (XmlTypeAnnotation) resourceType.getAnnotation(JAXB.XML_TYPE); assertTrue(xmlTypeAnnotation != null); xmlTypeAnnotation.addProp("fooo"); diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlValueAnnotationTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlValueAnnotationTests.java index 1ba7e774f9..114f4c3a48 100644 --- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlValueAnnotationTests.java +++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/resource/java/XmlValueAnnotationTests.java @@ -11,9 +11,9 @@ package org.eclipse.jpt.jaxb.core.tests.internal.resource.java; import java.util.Iterator; import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.jaxb.core.resource.java.JAXB; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAttribute; +import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType; import org.eclipse.jpt.jaxb.core.resource.java.XmlValueAnnotation; import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; @@ -39,13 +39,13 @@ public class XmlValueAnnotationTests extends JaxbJavaResourceModelTestCase { public void testGetXmlValue() throws Exception { ICompilationUnit cu = this.createTestXmlValue(); - JavaResourcePersistentType typeResource = buildJavaTypeResource(cu); - JavaResourcePersistentAttribute attributeResource = typeResource.fields().next(); + JavaResourceType resourceType = buildJavaResourceType(cu); + JavaResourceAttribute resourceAttribute = getField(resourceType, 0); - XmlValueAnnotation xmlValueAnnotation = (XmlValueAnnotation) attributeResource.getAnnotation(JAXB.XML_VALUE); + XmlValueAnnotation xmlValueAnnotation = (XmlValueAnnotation) resourceAttribute.getAnnotation(JAXB.XML_VALUE); assertTrue(xmlValueAnnotation != null); - attributeResource.removeAnnotation(JAXB.XML_VALUE); + resourceAttribute.removeAnnotation(JAXB.XML_VALUE); assertSourceDoesNotContain("@XmlValue", cu); } } |