Added Cascade.DETACH tests (and Java Cascade tests in general)

7 files changed, 498 insertions, 2 deletions

diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/java/JavaCascadeTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/java/JavaCascadeTests.java
new file mode 100644
index 0000000000..9fab8c0a7b
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/java/JavaCascadeTests.java
@@ -0,0 +1,311 @@
+package org.eclipse.jpt.core.tests.internal.context.java;
+
+import java.util.Iterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.core.context.PersistentAttribute;
+import org.eclipse.jpt.core.context.java.JavaCascade;
+import org.eclipse.jpt.core.context.java.JavaOneToOneMapping;
+import org.eclipse.jpt.core.resource.java.JPA;
+import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
+import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
+import org.eclipse.jpt.core.resource.java.OneToOneAnnotation;
+import org.eclipse.jpt.core.tests.internal.context.ContextModelTestCase;
+import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
+
+public class JavaCascadeTests
+	extends ContextModelTestCase
+{
+	private ICompilationUnit createTestEntityWithOneToOneMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.ONE_TO_ONE);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
+			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append("@OneToOne").append(CR);
+			}
+		});
+	}
+	
+	
+	public JavaCascadeTests(String name) {
+		super(name);
+	}
+	
+	
+	public void testUpdateCascadeAll() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isAll());
+		assertFalse(annotation.isCascadeAll());
+		
+		//set all in the resource model, verify context model updated
+		annotation.setCascadeAll(true);
+		getJpaProject().update();
+		assertTrue(annotation.isCascadeAll());
+		assertTrue(cascade.isAll());
+		
+		//set all to false in the resource model
+		annotation.setCascadeAll(false);
+		getJpaProject().update();
+		assertFalse(annotation.isCascadeAll());
+		assertFalse(cascade.isAll());
+	}
+	
+	public void testModifyCascadeAll() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isAll());
+		assertFalse(annotation.isCascadeAll());
+					
+		//set all in the context model, verify resource model updated
+		cascade.setAll(true);
+		assertTrue(annotation.isCascadeAll());
+		assertTrue(cascade.isAll());
+		
+		//set all to false in the context model
+		cascade.setAll(false);
+		assertFalse(annotation.isCascadeAll());
+		assertFalse(cascade.isAll());
+	}
+	
+	public void testUpdateCascadePersist() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isPersist());
+		assertFalse(annotation.isCascadePersist());
+		
+		//set persist in the resource model, verify context model updated
+		annotation.setCascadePersist(true);
+		getJpaProject().update();
+		assertTrue(annotation.isCascadePersist());
+		assertTrue(cascade.isPersist());
+		
+		//set persist to false in the resource model
+		annotation.setCascadePersist(false);
+		getJpaProject().update();
+		assertFalse(annotation.isCascadePersist());
+		assertFalse(cascade.isPersist());
+	}
+	
+	public void testModifyCascadePersist() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isPersist());
+		assertFalse(annotation.isCascadePersist());
+					
+		//set persist in the context model, verify resource model updated
+		cascade.setPersist(true);
+		assertTrue(annotation.isCascadePersist());
+		assertTrue(cascade.isPersist());
+		
+		//set persist to false in the context model
+		cascade.setPersist(false);
+		assertFalse(annotation.isCascadePersist());
+		assertFalse(cascade.isPersist());
+	}
+	
+	public void testUpdateCascadeMerge() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isMerge());
+		assertFalse(annotation.isCascadeMerge());
+		
+		//set merge in the resource model, verify context model updated
+		annotation.setCascadeMerge(true);
+		getJpaProject().update();
+		assertTrue(annotation.isCascadeMerge());
+		assertTrue(cascade.isMerge());
+		
+		//set merge to false in the resource model
+		annotation.setCascadeMerge(false);
+		getJpaProject().update();
+		assertFalse(annotation.isCascadeMerge());
+		assertFalse(cascade.isMerge());
+	}
+	
+	public void testModifyCascadeMerge() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isMerge());
+		assertFalse(annotation.isCascadeMerge());
+					
+		//set merge in the context model, verify resource model updated
+		cascade.setMerge(true);
+		assertTrue(annotation.isCascadeMerge());
+		assertTrue(cascade.isMerge());
+		
+		//set merge to false in the context model
+		cascade.setMerge(false);
+		assertFalse(annotation.isCascadeMerge());
+		assertFalse(cascade.isMerge());
+	}
+	
+	public void testUpdateCascadeRemove() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isRemove());
+		assertFalse(annotation.isCascadeRemove());
+		
+		//set remove in the resource model, verify context model updated
+		annotation.setCascadeRemove(true);
+		getJpaProject().update();
+		assertTrue(annotation.isCascadeRemove());
+		assertTrue(cascade.isRemove());
+		
+		//set remove to false in the resource model
+		annotation.setCascadeRemove(false);
+		getJpaProject().update();
+		assertFalse(annotation.isCascadeRemove());
+		assertFalse(cascade.isRemove());
+	}
+	
+	public void testModifyCascadeRemove() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isRemove());
+		assertFalse(annotation.isCascadeRemove());
+					
+		//set remove in the context model, verify resource model updated
+		cascade.setRemove(true);
+		assertTrue(annotation.isCascadeRemove());
+		assertTrue(cascade.isRemove());
+		
+		//set remove to false in the context model
+		cascade.setRemove(false);
+		assertFalse(annotation.isCascadeRemove());
+		assertFalse(cascade.isRemove());
+	}
+	
+	public void testUpdateCascadeRefresh() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isRefresh());
+		assertFalse(annotation.isCascadeRefresh());
+		
+		//set refresh in the resource model, verify context model updated
+		annotation.setCascadeRefresh(true);
+		getJpaProject().update();
+		assertTrue(annotation.isCascadeRefresh());
+		assertTrue(cascade.isRefresh());
+		
+		//set refresh to false in the resource model
+		annotation.setCascadeRefresh(false);
+		getJpaProject().update();
+		assertFalse(annotation.isCascadeRefresh());
+		assertFalse(cascade.isRefresh());
+	}
+	
+	public void testModifyCascadeRefresh() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOneAnnotation annotation = (OneToOneAnnotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping mapping = (JavaOneToOneMapping) persistentAttribute.getMapping();
+		JavaCascade cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isRefresh());
+		assertFalse(annotation.isCascadeRefresh());
+					
+		//set refresh in the context model, verify resource model updated
+		cascade.setRefresh(true);
+		assertTrue(annotation.isCascadeRefresh());
+		assertTrue(cascade.isRefresh());
+		
+		//set refresh to false in the context model
+		cascade.setRefresh(false);
+		assertFalse(annotation.isCascadeRefresh());
+		assertFalse(cascade.isRefresh());
+	}
+}
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/java/JptCoreContextJavaModelTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/java/JptCoreContextJavaModelTests.java
index 2777d467f0..b2ede9f540 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/java/JptCoreContextJavaModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/java/JptCoreContextJavaModelTests.java
@@ -21,6 +21,7 @@ public class JptCoreContextJavaModelTests extends TestCase
 		suite.addTestSuite(JavaAssociationOverrideTests.class);
 		suite.addTestSuite(JavaAttributeOverrideTests.class);
 		suite.addTestSuite(JavaBasicMappingTests.class);
+		suite.addTestSuite(JavaCascadeTests.class);
 		suite.addTestSuite(JavaColumnTests.class);
 		suite.addTestSuite(JavaDiscriminatorColumnTests.class);
 		suite.addTestSuite(JavaEmbeddableTests.class);
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java
index c745c43224..dc01633e87 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/Generic2_0JavaContextModelTests.java
@@ -19,6 +19,7 @@ public class Generic2_0JavaContextModelTests extends TestCase
 	public static Test suite() {
 		TestSuite suite = new TestSuite(Generic2_0JavaContextModelTests.class.getName());
 		suite.addTestSuite(GenericJavaAssociationOverride2_0Tests.class);
+		suite.addTestSuite(GenericJavaCascade2_0Tests.class);
 		suite.addTestSuite(GenericJavaCollectionTable2_0Tests.class);
 		suite.addTestSuite(GenericJavaElementCollectionMapping2_0Tests.class);
 		suite.addTestSuite(GenericJavaEntity2_0Tests.class);
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaCascade2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaCascade2_0Tests.java
new file mode 100644
index 0000000000..5cdc07dd76
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaCascade2_0Tests.java
@@ -0,0 +1,96 @@
+package org.eclipse.jpt.core.tests.internal.jpa2.context.java;
+
+import java.util.Iterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.core.context.PersistentAttribute;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCascade2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaOneToOneMapping2_0;
+import org.eclipse.jpt.core.jpa2.resource.java.OneToOne2_0Annotation;
+import org.eclipse.jpt.core.resource.java.JPA;
+import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
+import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
+import org.eclipse.jpt.core.resource.java.OneToOneAnnotation;
+import org.eclipse.jpt.core.tests.internal.jpa2.context.Generic2_0ContextModelTestCase;
+import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
+
+public class GenericJavaCascade2_0Tests
+	extends Generic2_0ContextModelTestCase
+{
+	private ICompilationUnit createTestEntityWithOneToOneMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.ONE_TO_ONE);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
+			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append("@OneToOne").append(CR);
+			}
+		});
+	}
+	
+	
+	public GenericJavaCascade2_0Tests(String name) {
+		super(name);
+	}
+	
+	
+	public void testUpdateCascadeDetach() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOne2_0Annotation annotation = (OneToOne2_0Annotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping2_0 mapping = (JavaOneToOneMapping2_0) persistentAttribute.getMapping();
+		JavaCascade2_0 cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isDetach());
+		assertFalse(annotation.isCascadeDetach());
+		
+		//set detach in the resource model, verify context model updated
+		annotation.setCascadeDetach(true);
+		getJpaProject().update();
+		assertTrue(annotation.isCascadeDetach());
+		assertTrue(cascade.isDetach());
+		
+		//set detach to false in the resource model
+		annotation.setCascadeDetach(false);
+		getJpaProject().update();
+		assertFalse(annotation.isCascadeDetach());
+		assertFalse(cascade.isDetach());
+	}
+	
+	public void testModifyCascadeDetach() throws Exception {
+		createTestEntityWithOneToOneMapping();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		OneToOne2_0Annotation annotation = (OneToOne2_0Annotation) attributeResource.getAnnotation(OneToOneAnnotation.ANNOTATION_NAME);
+		
+		PersistentAttribute persistentAttribute = getJavaPersistentType().attributes().next();
+		JavaOneToOneMapping2_0 mapping = (JavaOneToOneMapping2_0) persistentAttribute.getMapping();
+		JavaCascade2_0 cascade = mapping.getCascade();
+		
+		assertFalse(cascade.isDetach());
+		assertFalse(annotation.isCascadeDetach());
+					
+		//set detach in the context model, verify resource model updated
+		cascade.setDetach(true);
+		assertTrue(annotation.isCascadeDetach());
+		assertTrue(cascade.isDetach());
+		
+		//set detach to false in the context model
+		cascade.setDetach(false);
+		assertFalse(annotation.isCascadeDetach());
+		assertFalse(cascade.isDetach());
+	}
+}
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java
index 976e197c11..1ca82d696e 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java
@@ -10,12 +10,10 @@
 package org.eclipse.jpt.core.tests.internal.jpa2.context.java;
 
 import java.util.Iterator;
-
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.OneToManyMapping;
-import org.eclipse.jpt.core.context.OneToManyRelationshipReference;
 import org.eclipse.jpt.core.context.PersistentAttribute;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.jpa2.context.OneToManyMapping2_0;
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/Generic2_0OrmContextModelTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/Generic2_0OrmContextModelTests.java
index 9995ca7f68..768684f87e 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/Generic2_0OrmContextModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/Generic2_0OrmContextModelTests.java
@@ -19,6 +19,7 @@ public class Generic2_0OrmContextModelTests extends TestCase
 	public static Test suite() {
 		TestSuite suite = new TestSuite(Generic2_0OrmContextModelTests.class.getName());
 		suite.addTestSuite(GenericOrmAssociationOverride2_0Tests.class);
+		suite.addTestSuite(GenericOrmCascade2_0Tests.class);
 		suite.addTestSuite(GenericOrmCollectionTable2_0Tests.class);
 		suite.addTestSuite(GenericOrmElementCollectionMapping2_0Tests.class);
 		suite.addTestSuite(GenericOrmEntity2_0Tests.class);
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/GenericOrmCascade2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/GenericOrmCascade2_0Tests.java
new file mode 100644
index 0000000000..64fae2313a
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/GenericOrmCascade2_0Tests.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ *  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.core.tests.internal.jpa2.context.orm;
+
+import org.eclipse.jpt.core.JptCorePlugin;
+import org.eclipse.jpt.core.MappingKeys;
+import org.eclipse.jpt.core.context.orm.OrmOneToOneMapping;
+import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
+import org.eclipse.jpt.core.context.orm.OrmPersistentType;
+import org.eclipse.jpt.core.jpa2.context.Cascade2_0;
+import org.eclipse.jpt.core.resource.orm.OrmFactory;
+import org.eclipse.jpt.core.resource.orm.XmlOneToOne;
+import org.eclipse.jpt.core.resource.persistence.PersistenceFactory;
+import org.eclipse.jpt.core.resource.persistence.XmlMappingFileRef;
+import org.eclipse.jpt.core.tests.internal.jpa2.context.Generic2_0ContextModelTestCase;
+
+public class GenericOrmCascade2_0Tests extends Generic2_0ContextModelTestCase
+{
+	public GenericOrmCascade2_0Tests(String name) {
+		super(name);
+	}
+	
+	
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		XmlMappingFileRef mappingFileRef = PersistenceFactory.eINSTANCE.createXmlMappingFileRef();
+		mappingFileRef.setFileName(JptCorePlugin.DEFAULT_ORM_XML_FILE_PATH);
+		getXmlPersistenceUnit().getMappingFiles().add(mappingFileRef);
+		getPersistenceXmlResource().save(null);
+	}
+	
+	public void testUpdateCascadeDetach() throws Exception {
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
+		OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addSpecifiedAttribute(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY, "oneToOneMapping");
+		OrmOneToOneMapping ormOneToOneMapping = (OrmOneToOneMapping) ormPersistentAttribute.getMapping();
+		XmlOneToOne oneToOne = getXmlEntityMappings().getEntities().get(0).getAttributes().getOneToOnes().get(0);
+		Cascade2_0 cascade = ormOneToOneMapping.getCascade();
+		
+		assertEquals(false, cascade.isDetach());
+		assertNull(oneToOne.getCascade());
+		
+		//set cascade in the resource model, verify context model does not change
+		oneToOne.setCascade(OrmFactory.eINSTANCE.createCascadeType());
+		assertEquals(false, cascade.isDetach());
+		assertNotNull(oneToOne.getCascade());
+		
+		//set detach in the resource model, verify context model updated
+		oneToOne.getCascade().setCascadeDetach(true);
+		assertEquals(true, cascade.isDetach());
+		assertEquals(true, oneToOne.getCascade().isCascadeDetach());
+		
+		//set detach to false in the resource model
+		oneToOne.getCascade().setCascadeDetach(false);
+		assertEquals(false, cascade.isDetach());
+		assertEquals(false, oneToOne.getCascade().isCascadeDetach());
+	}
+	
+	public void testModifyCascadeDetach() throws Exception {
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "model.Foo");
+		OrmPersistentAttribute ormPersistentAttribute = ormPersistentType.addSpecifiedAttribute(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY, "oneToOneMapping");
+		OrmOneToOneMapping ormOneToOneMapping = (OrmOneToOneMapping) ormPersistentAttribute.getMapping();
+		XmlOneToOne oneToOne = getXmlEntityMappings().getEntities().get(0).getAttributes().getOneToOnes().get(0);
+		
+		Cascade2_0 cascade = ormOneToOneMapping.getCascade();
+		
+		assertEquals(false, cascade.isDetach());
+		assertNull(oneToOne.getCascade());
+		
+		//set detach in the context model, verify resource model updated
+		cascade.setDetach(true);
+		assertEquals(true, cascade.isDetach());
+		assertEquals(true, oneToOne.getCascade().isCascadeDetach());
+		
+		//set detach to false in the context model
+		cascade.setDetach(false);
+		assertEquals(false, cascade.isDetach());
+		assertNull(oneToOne.getCascade());
+	}
+}