added XmlSeeAlso to context model, added references to jaxb context calculation

6 files changed, 390 insertions, 116 deletions

diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/GenericContextRootTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/GenericContextRootTests.java
index ac046fd601..ebbd71d09c 100644
--- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/GenericContextRootTests.java
+++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/GenericContextRootTests.java
@@ -13,11 +13,17 @@ import java.util.Iterator;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.dom.Annotation;
+import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.MarkerAnnotation;
 import org.eclipse.jdt.core.dom.NormalAnnotation;
+import org.eclipse.jdt.core.dom.TypeLiteral;
 import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
 import org.eclipse.jpt.common.core.utility.jdt.Member;
 import org.eclipse.jpt.common.core.utility.jdt.ModifiedDeclaration;
+import org.eclipse.jpt.common.utility.internal.ArrayTools;
 import org.eclipse.jpt.common.utility.internal.CollectionTools;
+import org.eclipse.jpt.common.utility.internal.iterables.ArrayIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
 import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
 import org.eclipse.jpt.jaxb.core.context.JaxbPackage;
@@ -45,36 +51,6 @@ public class GenericContextRootTests
 				"@XmlAccessorOrder(value = XmlAccessOrder.ALPHABETICAL)",
 				JAXB.XML_ACCESS_ORDER, JAXB.XML_ACCESSOR_ORDER);
 	}
-
-	private ICompilationUnit createUnannotatedPackageInfo(String packageName) throws CoreException {
-		return createTestPackageInfo(packageName);
-	}
-
-	private ICompilationUnit createAnnotatedRegistry() throws Exception {
-		return this.createTestType(new DefaultAnnotationWriter() {
-			@Override
-			public Iterator<String> imports() {
-				return new ArrayIterator<String>(JAXB.XML_REGISTRY);
-			}
-			@Override
-			public void appendTypeAnnotationTo(StringBuilder sb) {
-				sb.append("@XmlRegistry");
-			}
-		});
-	}
-
-	private ICompilationUnit createAnnotatedPersistentClass() throws Exception {
-		return this.createTestType(new DefaultAnnotationWriter() {
-			@Override
-			public Iterator<String> imports() {
-				return new ArrayIterator<String>(JAXB.XML_TYPE);
-			}
-			@Override
-			public void appendTypeAnnotationTo(StringBuilder sb) {
-				sb.append("@XmlType");
-			}
-		});
-	}
 	
 	private ICompilationUnit createAnnotatedPersistentClassWithSuperclassNamed(final String superclassName) throws Exception {
 		return this.createTestType(new DefaultAnnotationWriter() {
@@ -131,27 +107,6 @@ public class GenericContextRootTests
 		});
 	}
 	
-	private ICompilationUnit createUnannotatedClassNamed(String typeName) throws Exception {
-		return this.createTestType(PACKAGE_NAME, typeName + ".java", typeName, new DefaultAnnotationWriter());
-	}
-
-	private ICompilationUnit createAnnotatedEnum() throws Exception {
-		return this.createTestEnum(new DefaultEnumAnnotationWriter() {
-			@Override
-			public Iterator<String> imports() {
-				return new ArrayIterator<String>(JAXB.XML_TYPE);
-			}
-			@Override
-			public void appendEnumAnnotationTo(StringBuilder sb) {
-				sb.append("@XmlType");
-			}
-		});
-	}
-
-	private ICompilationUnit createUnannotatedEnumNamed(String enumName) throws Exception {
-		return this.createTestEnum(PACKAGE_NAME, enumName + ".java", enumName, new DefaultEnumAnnotationWriter());
-	}
-
 	public void testGetPackages() throws Exception {
 		this.createPackageInfoWithAccessorOrder();
 		Iterator<JaxbPackage> packages = this.getContextRoot().getPackages().iterator();
@@ -200,11 +155,37 @@ public class GenericContextRootTests
 	
 	protected void addXmlAccessorTypeAnnotation(ModifiedDeclaration declaration, String accessType) {
 		NormalAnnotation annotation = this.addNormalAnnotation(declaration.getDeclaration(), JAXB.XML_ACCESSOR_TYPE);
-		this.addEnumMemberValuePair(annotation, JAXB.XML_ACCESSOR_TYPE__VALUE, accessType);
+		addEnumMemberValuePair(annotation, JAXB.XML_ACCESSOR_TYPE__VALUE, accessType);
 	}
-
+	
 	protected void removeXmlAccessorTypeAnnotation(ModifiedDeclaration declaration) {
-		this.removeAnnotation(declaration, JAXB.XML_ACCESSOR_TYPE);
+		removeAnnotation(declaration, JAXB.XML_ACCESSOR_TYPE);
+	}
+	
+	protected void addXmlSeeAlsoAnnotation(final ModifiedDeclaration declaration, String... typeNames) {
+		Annotation annotation = declaration.getAnnotationNamed(JAXB.XML_SEE_ALSO);
+		NormalAnnotation normalAnnotation = null;
+		if (annotation == null) {
+			normalAnnotation = addNormalAnnotation(declaration.getDeclaration(), JAXB.XML_SEE_ALSO);
+		}
+		else if (annotation.isMarkerAnnotation()) {
+			normalAnnotation = replaceMarkerAnnotation((MarkerAnnotation) annotation);
+		}
+		else {
+			normalAnnotation = (NormalAnnotation) annotation;
+		}
+		
+		Expression arrayInitializer = newArrayInitializer(
+				declaration.getAst(),
+				ArrayTools.array(
+						new TransformationIterable<String, TypeLiteral>(new ArrayIterable<String>(typeNames)) {
+							@Override
+							protected TypeLiteral transform(String o) {
+								return newTypeLiteral(declaration.getAst(), o);
+							}
+						},
+						new Expression[0]));
+		addMemberValuePair(normalAnnotation, JAXB.XML_SEE_ALSO__VALUE, arrayInitializer);
 	}
 
 	public void testGetRegistries() throws Exception {
@@ -308,7 +289,7 @@ public class GenericContextRootTests
 	}
 
 	public void testGetPersistentEnums() throws Exception {
-		this.createAnnotatedEnum();
+		this.createAnnotatedPersistentEnum();
 		Iterator<JaxbPersistentEnum> persistentEnums = this.getContextRoot().getPersistentEnums().iterator();
 		assertEquals(1, CollectionTools.size(getContextRoot().getPersistentEnums()));
 		assertEquals(FULLY_QUALIFIED_TYPE_NAME, persistentEnums.next().getFullyQualifiedName());
@@ -517,4 +498,61 @@ public class GenericContextRootTests
 		assertNotNull(getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME));
 		assertNull(getContextRoot().getPersistentClass(fqOtherClassName));
 	}
+	
+	public void testDirectReferencedSeeAlso() throws Exception {
+		final String otherClassName = "Other" + TYPE_NAME;
+		final String fqOtherClassName = PACKAGE_NAME_ + otherClassName;
+		final String otherClassName2 = "Other" + TYPE_NAME + "2";
+		final String fqOtherClassName2 = PACKAGE_NAME_ + otherClassName2;
+		createUnannotatedClassNamed(otherClassName);
+		createUnannotatedClassNamed(otherClassName2);
+		
+		// make sure unannotated other classes are not in context
+		assertTrue(CollectionTools.isEmpty(getContextRoot().getPersistentClasses()));
+		
+		createAnnotatedPersistentClass();
+		JavaResourceType thisType = (JavaResourceType) getJaxbProject().getJavaResourceType(FULLY_QUALIFIED_TYPE_NAME);
+		AnnotatedElement annotatedType = annotatedElement(thisType);
+		
+		// make sure unannotated other classes are not in context
+		assertEquals(1, CollectionTools.size(getContextRoot().getPersistentClasses()));
+		assertNotNull(getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME));
+		
+		// add an @XmlSeeAlso with one class
+		annotatedType.edit(
+				new Member.Editor() {
+					public void edit(ModifiedDeclaration declaration) {
+						addXmlSeeAlsoAnnotation(declaration, otherClassName);
+					}
+				});
+		
+		assertEquals(2, CollectionTools.size(getContextRoot().getPersistentClasses()));
+		assertNotNull(getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME));
+		assertNotNull(getContextRoot().getPersistentClass(fqOtherClassName));
+		
+		// change to @XmlSeeAlso with two classes
+		annotatedType.edit(
+				new Member.Editor() {
+					public void edit(ModifiedDeclaration declaration) {
+						removeAnnotation(declaration, JAXB.XML_SEE_ALSO);
+						addXmlSeeAlsoAnnotation(declaration, otherClassName, otherClassName2);
+					}
+				});
+		
+		assertEquals(3, CollectionTools.size(getContextRoot().getPersistentClasses()));
+		assertNotNull(getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME));
+		assertNotNull(getContextRoot().getPersistentClass(fqOtherClassName));
+		assertNotNull(getContextRoot().getPersistentClass(fqOtherClassName2));
+		
+		// remove the @XmlSeeAlso annotation
+		annotatedType.edit(
+				new Member.Editor() {
+					public void edit(ModifiedDeclaration declaration) {
+						removeAnnotation(declaration, JAXB.XML_SEE_ALSO);
+					}
+				});
+		
+		assertEquals(1, CollectionTools.size(getContextRoot().getPersistentClasses()));
+		assertNotNull(getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME));
+	}
 }
diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/JaxbContextModelTestCase.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/JaxbContextModelTestCase.java
index cd8c6f4f07..8df30d422a 100644
--- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/JaxbContextModelTestCase.java
+++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/JaxbContextModelTestCase.java
@@ -9,10 +9,15 @@
  ******************************************************************************/
 package org.eclipse.jpt.jaxb.core.tests.internal.context;
 
+import java.util.Iterator;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jpt.common.core.tests.internal.projects.TestJavaProject;
 import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
 import org.eclipse.jpt.common.utility.internal.ReflectionTools;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
 import org.eclipse.jpt.jaxb.core.context.JaxbContextRoot;
+import org.eclipse.jpt.jaxb.core.resource.java.JAXB;
 import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAnnotatedElement;
 import org.eclipse.jpt.jaxb.core.tests.internal.JaxbTestCase;
 
@@ -39,4 +44,55 @@ public abstract class JaxbContextModelTestCase
 	protected AnnotatedElement annotatedElement(JavaResourceAnnotatedElement resource) {
 		return (AnnotatedElement) ReflectionTools.getFieldValue(resource, "annotatedElement");
 	}
+	
+	protected ICompilationUnit createUnannotatedPackageInfo(String packageName) throws CoreException {
+		return createTestPackageInfo(packageName);
+	}
+	
+	protected ICompilationUnit createAnnotatedPersistentClass() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JAXB.XML_TYPE);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@XmlType");
+			}
+		});
+	}
+	
+	protected ICompilationUnit createUnannotatedClassNamed(String typeName) throws Exception {
+		return this.createTestType(PACKAGE_NAME, typeName + ".java", typeName, new DefaultAnnotationWriter());
+	}
+	
+	protected ICompilationUnit createAnnotatedPersistentEnum() throws Exception {
+		return this.createTestEnum(new DefaultEnumAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JAXB.XML_TYPE);
+			}
+			@Override
+			public void appendEnumAnnotationTo(StringBuilder sb) {
+				sb.append("@XmlType");
+			}
+		});
+	}
+	
+	protected ICompilationUnit createUnannotatedEnumNamed(String enumName) throws Exception {
+		return this.createTestEnum(PACKAGE_NAME, enumName + ".java", enumName, new DefaultEnumAnnotationWriter());
+	}
+	
+	protected ICompilationUnit createAnnotatedRegistry() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JAXB.XML_REGISTRY);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@XmlRegistry");
+			}
+		});
+	}
 }
diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaPersistentClassTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaPersistentClassTests.java
index 7fa8fecfca..b485214abb 100644
--- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaPersistentClassTests.java
+++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaPersistentClassTests.java
@@ -35,8 +35,8 @@ import org.eclipse.jpt.jaxb.core.context.JaxbPersistentField;
 import org.eclipse.jpt.jaxb.core.context.JaxbPersistentProperty;
 import org.eclipse.jpt.jaxb.core.context.XmlAccessOrder;
 import org.eclipse.jpt.jaxb.core.context.XmlAccessType;
-import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAbstractType;
 import org.eclipse.jpt.jaxb.core.resource.java.JAXB;
+import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceAbstractType;
 import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceField;
 import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceMember;
 import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceMethod;
@@ -46,32 +46,21 @@ import org.eclipse.jpt.jaxb.core.resource.java.XmlAccessorTypeAnnotation;
 import org.eclipse.jpt.jaxb.core.resource.java.XmlAttributeAnnotation;
 import org.eclipse.jpt.jaxb.core.resource.java.XmlJavaTypeAdapterAnnotation;
 import org.eclipse.jpt.jaxb.core.resource.java.XmlRootElementAnnotation;
+import org.eclipse.jpt.jaxb.core.resource.java.XmlSeeAlsoAnnotation;
 import org.eclipse.jpt.jaxb.core.resource.java.XmlTransientAnnotation;
 import org.eclipse.jpt.jaxb.core.resource.java.XmlTypeAnnotation;
 import org.eclipse.jpt.jaxb.core.tests.internal.context.JaxbContextModelTestCase;
 
 
 @SuppressWarnings("nls")
-public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
-{
+public class GenericJavaPersistentClassTests
+		extends JaxbContextModelTestCase {
 	
 	public GenericJavaPersistentClassTests(String name) {
 		super(name);
 	}
-
-	private ICompilationUnit createTypeWithXmlType() throws Exception {
-		return this.createTestType(new DefaultAnnotationWriter() {
-			@Override
-			public Iterator<String> imports() {
-				return new ArrayIterator<String>(JAXB.XML_TYPE);
-			}
-			@Override
-			public void appendTypeAnnotationTo(StringBuilder sb) {
-				sb.append("@XmlType");
-			}
-		});
-	}
-
+	
+	
 	private void createTestSubType() throws Exception {
 		SourceWriter sourceWriter = new SourceWriter() {
 			public void appendSourceTo(StringBuilder sb) {
@@ -272,9 +261,9 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 		};
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "AnnotationTestType.java", sourceWriter);
 	}
-
+	
     public void testModifyFactoryClass() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -303,7 +292,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 	
 	public void testUpdateFactoryClass() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -331,7 +320,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testModifyFactoryMethod() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -360,7 +349,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 	
 	public void testUpdateFactoryMethod() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -388,7 +377,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testModifySchemaTypeName() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -423,7 +412,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 	
 	public void testUpdateSchemaTypeName() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -455,7 +444,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testModifyNamespace() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -489,7 +478,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 	
 	public void testUpdateNamespace() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -601,7 +590,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	 * Otherwise, the @XmlAccessorType on a package is inherited. 	
 	 */
 	public void testGetDefaultAccessType() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		this.createTestSubType();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JaxbPersistentClass childPersistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
@@ -628,7 +617,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testGetSuperPersistentClass() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		this.createTestSubType();
 		JaxbPersistentClass persistentClass = getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME);
 		JaxbPersistentClass childPersistentClass = getContextRoot().getPersistentClass(PACKAGE_NAME + ".AnnotationTestTypeChild");
@@ -696,7 +685,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testGetPropOrder() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
 
@@ -723,7 +712,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testGetPropOrderSize() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
 
@@ -741,7 +730,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testAddProp() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
 
@@ -759,7 +748,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testAddProp2() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
 
@@ -777,7 +766,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testRemoveProp() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
 
@@ -805,7 +794,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testMoveProp() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
 
@@ -844,7 +833,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testSyncXmlNsPrefixes() throws Exception {
-		this.createTypeWithXmlType();
+		this.createAnnotatedPersistentClass();
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
 
@@ -956,7 +945,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testModifyXmlRootElement() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -978,7 +967,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testUpdateXmlRootElement() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 		
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -2014,7 +2003,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testModifyXmlJavaTypeAdapter() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -2033,7 +2022,7 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 	}
 
 	public void testUpdateXmlJavaTypeAdapter() throws Exception {
-		createTypeWithXmlType();
+		createAnnotatedPersistentClass();
 
 		JaxbPersistentClass persistentClass = CollectionTools.get(getContextRoot().getPersistentClasses(), 0);
 		JavaResourceAbstractType resourceType = persistentClass.getJavaResourceType();
@@ -2064,7 +2053,61 @@ public class GenericJavaPersistentClassTests extends JaxbContextModelTestCase
 		assertNull(persistentClass.getXmlJavaTypeAdapter());
 		assertNull(xmlJavaTypeAdapterAnnotation);
 	}
-
+	
+	public void testModifyXmlSeeAlso() throws Exception {
+		createAnnotatedPersistentClass();
+		
+		JaxbPersistentClass persistentClass = getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourceType resourceType = persistentClass.getJavaResourceType();
+		
+		XmlSeeAlsoAnnotation annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertNull(persistentClass.getXmlSeeAlso());
+		assertNull(annotation);
+		
+		persistentClass.addXmlSeeAlso();
+		annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertNotNull(persistentClass.getXmlSeeAlso());
+		assertNotNull(annotation);
+		
+		persistentClass.removeXmlSeeAlso();
+		annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertNull(persistentClass.getXmlSeeAlso());
+		assertNull(annotation);
+	}
+	
+	public void testUpdateXmlSeeAlso() throws Exception {
+		createAnnotatedPersistentClass();
+		
+		JaxbPersistentClass persistentClass = getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourceType resourceType = persistentClass.getJavaResourceType();
+		
+		XmlSeeAlsoAnnotation annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertNull(persistentClass.getXmlSeeAlso());
+		assertNull(annotation);
+		
+		AnnotatedElement annotatedElement = this.annotatedElement(resourceType);
+		annotatedElement.edit(
+				new Member.Editor() {
+					public void edit(ModifiedDeclaration declaration) {
+						GenericJavaPersistentClassTests.this.addMarkerAnnotation(declaration.getDeclaration(), JAXB.XML_SEE_ALSO);
+					}
+				});
+		annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertNotNull(persistentClass.getXmlSeeAlso());
+		assertNotNull(annotation);
+		
+		annotatedElement.edit(
+				new Member.Editor() {
+					public void edit(
+						ModifiedDeclaration declaration) {
+							GenericJavaPersistentClassTests.this.removeAnnotation(declaration, JAXB.XML_SEE_ALSO);
+						}
+					});
+		annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertNull(persistentClass.getXmlSeeAlso());
+		assertNull(annotation);
+	}
+	
 	protected void addModifiers(JavaResourceMember resourceMember, final ModifierKeyword... modifiers) {
 		AnnotatedElement annotatedElement = this.annotatedElement(resourceMember);
 		annotatedElement.edit(new Member.Editor() {
diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaXmlSeeAlsoTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaXmlSeeAlsoTests.java
new file mode 100644
index 0000000000..7ae551bd70
--- /dev/null
+++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/GenericJavaXmlSeeAlsoTests.java
@@ -0,0 +1,149 @@
+/*******************************************************************************
+ *  Copyright (c) 2011  Oracle. All rights reserved.
+ *  This program and the accompanying materials are made available under the
+ *  terms of the Eclipse Public License v1.0, which accompanies this distribution
+ *  and is available at http://www.eclipse.org/legal/epl-v10.html
+ *  
+ *  Contributors: 
+ *  	Oracle - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jpt.jaxb.core.tests.internal.context.java;
+
+import java.util.Iterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.dom.Annotation;
+import org.eclipse.jdt.core.dom.NormalAnnotation;
+import org.eclipse.jpt.common.core.utility.jdt.AnnotatedElement;
+import org.eclipse.jpt.common.core.utility.jdt.Member;
+import org.eclipse.jpt.common.core.utility.jdt.ModifiedDeclaration;
+import org.eclipse.jpt.common.utility.internal.CollectionTools;
+import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
+import org.eclipse.jpt.jaxb.core.context.JaxbPersistentClass;
+import org.eclipse.jpt.jaxb.core.context.XmlSeeAlso;
+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.jaxb.core.tests.internal.context.JaxbContextModelTestCase;
+
+
+public class GenericJavaXmlSeeAlsoTests
+		extends JaxbContextModelTestCase {
+	
+	public GenericJavaXmlSeeAlsoTests(String name) {
+		super(name);
+	}
+	
+	
+	private ICompilationUnit createAnnotatedPersistentClassWithXmlSeeAlso() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JAXB.XML_TYPE, JAXB.XML_SEE_ALSO);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@XmlType" + CR);
+				sb.append("@XmlSeeAlso");
+			}
+		});
+	}
+	
+	public void testModifyClasses() throws Exception {
+		createAnnotatedPersistentClassWithXmlSeeAlso();
+		JaxbPersistentClass contextPersistentClass = getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME);
+		XmlSeeAlso contextXmlSeeAlso = contextPersistentClass.getXmlSeeAlso();
+		JavaResourceType resourceType = contextPersistentClass.getJavaResourceType();
+		
+		assertEquals(0, contextXmlSeeAlso.getClassesSize());
+		
+		// add a class
+		contextXmlSeeAlso.addClass(0, "foo");
+		XmlSeeAlsoAnnotation annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertEquals(1, annotation.getClassesSize());
+		assertTrue(CollectionTools.contains(annotation.getClasses(), "foo"));
+		assertFalse(CollectionTools.contains(annotation.getClasses(), "bar"));
+		
+		// add another
+		contextXmlSeeAlso.addClass(0, "bar");
+		annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertEquals(2, annotation.getClassesSize());
+		assertTrue(CollectionTools.contains(annotation.getClasses(), "foo"));
+		assertTrue(CollectionTools.contains(annotation.getClasses(), "bar"));
+		
+		 // remove one
+		contextXmlSeeAlso.removeClass(1);
+		annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertEquals(1, annotation.getClassesSize());
+		assertFalse(CollectionTools.contains(annotation.getClasses(), "foo"));
+		assertTrue(CollectionTools.contains(annotation.getClasses(), "bar"));
+		
+		// remove the other
+		contextXmlSeeAlso.removeClass(0);
+		annotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
+		assertEquals(0, annotation.getClassesSize());
+		assertFalse(CollectionTools.contains(annotation.getClasses(), "bar"));
+		assertFalse(CollectionTools.contains(annotation.getClasses(), "foo"));
+	}
+	
+	public void testUpdateClasses() throws Exception {
+		createAnnotatedPersistentClassWithXmlSeeAlso();
+		JaxbPersistentClass contextPersistentClass = getContextRoot().getPersistentClass(FULLY_QUALIFIED_TYPE_NAME);
+		XmlSeeAlso contextXmlSeeAlso = contextPersistentClass.getXmlSeeAlso();
+		JavaResourceType resourceType = contextPersistentClass.getJavaResourceType();
+		AnnotatedElement annotatedElement = annotatedElement(resourceType);
+		
+		assertEquals(0, contextXmlSeeAlso.getClassesSize());
+		
+		// add a class
+		annotatedElement.edit(new Member.Editor() {
+			public void edit(ModifiedDeclaration declaration) {
+				GenericJavaXmlSeeAlsoTests.this.addClass(declaration, 0, "foo");
+			}
+		});
+		assertEquals(1, contextXmlSeeAlso.getClassesSize());
+		assertTrue(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "foo"));
+		assertFalse(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "bar"));
+		
+		// add another
+		annotatedElement.edit(new Member.Editor() {
+			public void edit(ModifiedDeclaration declaration) {
+				GenericJavaXmlSeeAlsoTests.this.addClass(declaration, 0, "bar");
+			}
+		});
+		assertEquals(2, contextXmlSeeAlso.getClassesSize());
+		assertTrue(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "foo"));
+		assertTrue(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "bar"));
+		
+		 // remove one
+		annotatedElement.edit(new Member.Editor() {
+			public void edit(ModifiedDeclaration declaration) {
+				GenericJavaXmlSeeAlsoTests.this.removeClass(declaration, 1);
+			}
+		});
+		assertEquals(1, contextXmlSeeAlso.getClassesSize());
+		assertFalse(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "foo"));
+		assertTrue(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "bar"));
+		
+		// remove the other
+		annotatedElement.edit(new Member.Editor() {
+			public void edit(ModifiedDeclaration declaration) {
+				GenericJavaXmlSeeAlsoTests.this.removeClass(declaration, 0);
+			}
+		});
+		assertEquals(0, contextXmlSeeAlso.getClassesSize());
+		assertFalse(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "bar"));
+		assertFalse(CollectionTools.contains(contextXmlSeeAlso.getClasses(), "foo"));
+	}
+	
+	protected void addClass(ModifiedDeclaration declaration, int index, String clazz) {
+		addArrayElement(declaration, JAXB.XML_SEE_ALSO, index, JAXB.XML_SEE_ALSO__VALUE, newTypeLiteral(declaration.getAst(), clazz));		
+	}
+	
+	protected void removeClass(ModifiedDeclaration declaration, int index) {
+		removeArrayElement((NormalAnnotation) getXmlSeeAlsoAnnotation(declaration), JAXB.XML_SEE_ALSO__VALUE, index);
+	}
+	
+	protected Annotation getXmlSeeAlsoAnnotation(ModifiedDeclaration declaration) {
+		return declaration.getAnnotationNamed(JAXB.XML_SEE_ALSO);
+	}
+}
diff --git a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/JaxbCoreJavaContextModelTests.java b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/JaxbCoreJavaContextModelTests.java
index c5ba01b3e2..74d0b330bb 100644
--- a/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/JaxbCoreJavaContextModelTests.java
+++ b/jaxb/tests/org.eclipse.jpt.jaxb.core.tests/src/org/eclipse/jpt/jaxb/core/tests/internal/context/java/JaxbCoreJavaContextModelTests.java
@@ -13,8 +13,9 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
-public class JaxbCoreJavaContextModelTests extends TestCase
-{
+public class JaxbCoreJavaContextModelTests
+		extends TestCase {
+	
 	public static Test suite() {
 		TestSuite suite = new TestSuite(JaxbCoreJavaContextModelTests.class.getName());
 		suite.addTestSuite(GenericJavaElementFactoryMethodTests.class);
@@ -33,10 +34,12 @@ public class JaxbCoreJavaContextModelTests extends TestCase
 		suite.addTestSuite(GenericJavaXmlRootElementTests.class);
 		suite.addTestSuite(GenericJavaXmlSchemaTests.class);
 		suite.addTestSuite(GenericJavaXmlSchemaTypeTests.class);
+		suite.addTestSuite(GenericJavaXmlSeeAlsoTests.class);
 		suite.addTestSuite(GenericJavaXmlValueMappingTests.class);
 		return suite;
 	}
-
+	
+	
 	private JaxbCoreJavaContextModelTests() {
 		super();
 		throw new UnsupportedOperationException();
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 53f1ecebcc..d56a259722 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
@@ -18,8 +18,8 @@ import org.eclipse.jpt.jaxb.core.resource.java.JavaResourceType;
 import org.eclipse.jpt.jaxb.core.resource.java.XmlSeeAlsoAnnotation;
 
 @SuppressWarnings("nls")
-public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase {
-
+public class XmlSeeAlsoAnnotationTests
+		extends JaxbJavaResourceModelTestCase {
 
 	public XmlSeeAlsoAnnotationTests(String name) {
 		super(name);
@@ -107,7 +107,7 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase {
 
 		assertSourceContains("@XmlSeeAlso({ Barr.class, Blah.class, Fooo.class })", cu);
 	}
-
+	
 	public void testRemoveClass() throws Exception {
 		ICompilationUnit cu = this.createTestXmlSeeAlsoWithValue();
 		JavaResourceType resourceType = buildJavaResourceType(cu); 
@@ -115,21 +115,6 @@ public class XmlSeeAlsoAnnotationTests extends JaxbJavaResourceModelTestCase {
 		XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
 		assertTrue(xmlSeeAlsoAnnotation != null);
 
-		xmlSeeAlsoAnnotation.removeClass("Foo");
-		assertSourceContains("@XmlSeeAlso(value = Bar.class)", cu);
-
-		xmlSeeAlsoAnnotation.removeClass("Bar");
-		assertSourceContains("@XmlSeeAlso", cu);
-		assertSourceDoesNotContain("value", cu);
-	}
-
-	public void testRemoveClassIndex() throws Exception {
-		ICompilationUnit cu = this.createTestXmlSeeAlsoWithValue();
-		JavaResourceType resourceType = buildJavaResourceType(cu); 
-
-		XmlSeeAlsoAnnotation xmlSeeAlsoAnnotation = (XmlSeeAlsoAnnotation) resourceType.getAnnotation(JAXB.XML_SEE_ALSO);
-		assertTrue(xmlSeeAlsoAnnotation != null);
-
 		xmlSeeAlsoAnnotation.removeClass(0);
 		assertSourceContains("@XmlSeeAlso(value = Bar.class)", cu);