279098 - first pass at Cacheable support for EclipseLink 2.0 entities

50 files changed, 3972 insertions, 231 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaFactory.java
index 4ce3c05476..079946d233 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaFactory.java
@@ -129,6 +129,7 @@ import org.eclipse.jpt.core.jpa2.JpaProject2_0;
 import org.eclipse.jpt.core.jpa2.MetamodelSynchronizer;
 import org.eclipse.jpt.core.jpa2.PersistentTypeMetamodelSynchronizer;
 import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaDerivedId2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaEmbeddedMapping2_0;
@@ -377,7 +378,7 @@ public abstract class AbstractJpaFactory
 		return new NullJavaMapsId2_0(parent);
 	}
 	
-	public JavaCacheable2_0 buildJavaCacheable(JavaTypeMapping parent) {
+	public JavaCacheable2_0 buildJavaCacheable(JavaCacheableHolder2_0 parent) {
 		return new NullJavaCacheable2_0(parent);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java
index a3b886be10..6367440d8a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java
@@ -49,11 +49,7 @@ import org.eclipse.jpt.core.context.java.JavaTable;
 import org.eclipse.jpt.core.internal.resource.java.NullPrimaryKeyJoinColumnAnnotation;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
-import org.eclipse.jpt.core.jpa2.JpaFactory2_0;
-import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
-import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
-import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.resource.java.DiscriminatorValueAnnotation;
 import org.eclipse.jpt.core.resource.java.EntityAnnotation;
 import org.eclipse.jpt.core.resource.java.IdClassAnnotation;
@@ -84,7 +80,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 public abstract class AbstractJavaEntity
 	extends AbstractJavaTypeMapping
-	implements JavaEntity, Entity2_0
+	implements JavaEntity, JavaCacheableHolder2_0
 {
 	protected String specifiedName;
 
@@ -132,8 +128,6 @@ public abstract class AbstractJavaEntity
 	
 	protected Entity rootEntity;
 	
-	protected final JavaCacheable2_0 cacheable;
-	
 	protected AbstractJavaEntity(JavaPersistentType parent) {
 		super(parent);
 		this.table = this.getJpaFactory().buildJavaTable(this);
@@ -144,7 +138,6 @@ public abstract class AbstractJavaEntity
 		this.associationOverrideContainer = this.getJpaFactory().buildJavaAssociationOverrideContainer(this, new AssociationOverrideContainerOwner());
 		this.queryContainer = this.getJpaFactory().buildJavaQueryContainer(this);
 		this.generatorContainer = this.getJpaFactory().buildJavaGeneratorContainer(this);
-		this.cacheable = ((JpaFactory2_0) this.getJpaFactory()).buildJavaCacheable(this);
 	}
 	
 	protected JavaBaseJoinColumn.Owner buildPrimaryKeyJoinColumnOwner() {
@@ -228,7 +221,6 @@ public abstract class AbstractJavaEntity
 		this.attributeOverrideContainer.initialize(resourcePersistentType);
 		this.associationOverrideContainer.initialize(resourcePersistentType);
 		this.initializeIdClass();
-		this.cacheable.initialize(resourcePersistentType);
 	}
 	
 	protected void initializeSecondaryTables() {
@@ -1084,30 +1076,6 @@ public abstract class AbstractJavaEntity
 		return null;
 	}
 	
-	//****************** Entity2_0 implementation *******************
-
-	public Cacheable2_0 getCacheable() {
-		return this.cacheable;
-	}
-	
-	public boolean calculateDefaultCacheable() {		
-		Entity2_0 parentEntity = (Entity2_0) getParentEntity();
-		if (parentEntity != null) {
-			return parentEntity.getCacheable().isCacheable();
-		}
-		
-		switch (((PersistenceUnit2_0) getPersistenceUnit()).getSharedCacheMode()) {
-			case NONE:
-			case UNSPECIFIED:
-			case ENABLE_SELECTIVE:
-				return false;
-			case ALL:
-			case DISABLE_SELECTIVE:
-				return true;
-		}
-		return false;
-	}
-	
 	@Override
 	public void update(JavaResourcePersistentType resourcePersistentType) {
 		super.update(resourcePersistentType);
@@ -1130,7 +1098,6 @@ public abstract class AbstractJavaEntity
 		this.attributeOverrideContainer.update(resourcePersistentType);
 		this.associationOverrideContainer.update(resourcePersistentType);
 		this.updateIdClass();
-		this.cacheable.update(resourcePersistentType);
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
index e70fe066b8..94eb087afd 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
@@ -56,10 +56,7 @@ import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.internal.context.java.AbstractJavaEntity;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
-import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
-import org.eclipse.jpt.core.jpa2.context.orm.OrmXml2_0ContextNodeFactory;
-import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.orm.Inheritance;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
@@ -86,7 +83,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 public abstract class AbstractOrmEntity
 	extends AbstractOrmTypeMapping<XmlEntity>
-	implements OrmEntity, Entity2_0
+	implements OrmEntity, OrmCacheableHolder2_0
 {
 	protected String specifiedName;
 
@@ -135,8 +132,6 @@ public abstract class AbstractOrmEntity
 	protected final OrmQueryContainer queryContainer;
 	
 	protected Entity rootEntity;
-
-	protected final OrmCacheable2_0 cacheable;
 	
 	protected AbstractOrmEntity(OrmPersistentType parent, XmlEntity resourceMapping) {
 		super(parent, resourceMapping);
@@ -169,7 +164,6 @@ public abstract class AbstractOrmEntity
 		this.initializeSpecifiedPrimaryKeyJoinColumns();
 		this.initializeDefaultPrimaryKeyJoinColumns();
 		this.initializeIdClass(this.getResourceIdClass());
-		this.cacheable = ((OrmXml2_0ContextNodeFactory) getXmlContextNodeFactory()).buildOrmCacheable(this, resourceMapping);
 	}
 	
 	protected OrmDiscriminatorColumn buildDiscriminatorColumn() {
@@ -1202,37 +1196,6 @@ public abstract class AbstractOrmEntity
 //	public boolean containsSpecifiedPrimaryKeyJoinColumns() {
 //		return !this.getSpecifiedPrimaryKeyJoinColumns().isEmpty();
 //	}
-
-	//****************** Entity2_0 implementation *******************
-	
-	public OrmCacheable2_0 getCacheable() {
-		return this.cacheable;
-	}
-	
-	public boolean calculateDefaultCacheable() {
-		if (!isMetadataComplete()) {
-			Entity2_0 javaEntity = (Entity2_0) getJavaEntity();
-			if (javaEntity != null) {
-				return javaEntity.getCacheable().isCacheable();
-			}
-		}
-		
-		Entity2_0 parentEntity = (Entity2_0) getParentEntity();
-		if (parentEntity != null) {
-			return parentEntity.getCacheable().isCacheable();
-		}
-		
-		switch (((PersistenceUnit2_0) getPersistenceUnit()).getSharedCacheMode()) {
-			case NONE:
-			case UNSPECIFIED:
-			case ENABLE_SELECTIVE:
-				return false;
-			case ALL:
-			case DISABLE_SELECTIVE:
-				return true;
-		}
-		return false;
-	}
 	
 	protected void initializeInheritance(Inheritance inheritanceResource) {
 		this.specifiedInheritanceStrategy = this.getResourceInheritanceStrategy(inheritanceResource);
@@ -1319,7 +1282,6 @@ public abstract class AbstractOrmEntity
 		getAssociationOverrideContainer().update();
 		getQueryContainer().update();
 		this.updateIdClass(this.getResourceIdClass());
-		getCacheable().update();
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmXmlContextNodeFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmXmlContextNodeFactory.java
index dae219f63d..3b76204e6e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmXmlContextNodeFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmXmlContextNodeFactory.java
@@ -125,6 +125,7 @@ import org.eclipse.jpt.core.internal.jpa2.context.orm.NullOrmDerivedId2_0;
 import org.eclipse.jpt.core.internal.jpa2.context.orm.NullOrmMapsId2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmDerivedId2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmEmbeddedMapping2_0;
@@ -381,7 +382,7 @@ public abstract class AbstractOrmXmlContextNodeFactory implements OrmXml2_0Conte
 		throw new UnsupportedOperationException();
 	}
 	
-	public OrmCacheable2_0 buildOrmCacheable(OrmTypeMapping parent, XmlCacheable2_0 resource) {
+	public OrmCacheable2_0 buildOrmCacheable(OrmCacheableHolder2_0 parent, XmlCacheable2_0 resource) {
 		return new NullOrmCacheable2_0(parent);
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaEntity.java
index 676f7ec1a7..4bdefc8639 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaEntity.java
@@ -11,11 +11,47 @@ package org.eclipse.jpt.core.internal.jpa1.context.java;
 
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.internal.context.java.AbstractJavaEntity;
+import org.eclipse.jpt.core.jpa2.JpaFactory2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
+import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 
 public class GenericJavaEntity
 	extends AbstractJavaEntity
 {
+	
+	protected final JavaCacheable2_0 cacheable;
+
 	public GenericJavaEntity(JavaPersistentType parent) {
 		super(parent);
-	}	
+		this.cacheable = ((JpaFactory2_0) this.getJpaFactory()).buildJavaCacheable(this);
+	}
+	
+	@Override
+	public void initialize(JavaResourcePersistentType resourcePersistentType) {
+		super.initialize(resourcePersistentType);
+		this.cacheable.initialize(resourcePersistentType);
+	}
+	
+	@Override
+	public void update(JavaResourcePersistentType resourcePersistentType) {
+		super.update(resourcePersistentType);
+		this.cacheable.update(resourcePersistentType);
+	}
+	
+	//****************** Entity2_0 implementation *******************
+
+	public JavaCacheable2_0 getCacheable() {
+		return this.cacheable;
+	}
+	
+	public boolean calculateDefaultCacheable() {		
+		CacheableHolder2_0 parentEntity = (CacheableHolder2_0) getParentEntity();
+		if (parentEntity != null) {
+			return parentEntity.getCacheable().isCacheable();
+		}
+		return ((PersistenceUnit2_0) getPersistenceUnit()).calculateDefaultCacheable();
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmEntity.java
index 26af651193..867a738828 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmEntity.java
@@ -11,14 +11,46 @@ package org.eclipse.jpt.core.internal.jpa1.context.orm;
 
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmEntity;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmXml2_0ContextNodeFactory;
+import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
 import org.eclipse.jpt.core.resource.orm.XmlEntity;
 
 public class GenericOrmEntity
 	extends AbstractOrmEntity
+
 {
+
+	protected final OrmCacheable2_0 cacheable;
 	
 	public GenericOrmEntity(OrmPersistentType parent, XmlEntity resourceMapping) {
 		super(parent, resourceMapping);
+		this.cacheable = ((OrmXml2_0ContextNodeFactory) getXmlContextNodeFactory()).buildOrmCacheable(this, resourceMapping);
+	}
+	
+	public OrmCacheable2_0 getCacheable() {
+		return this.cacheable;
 	}
 	
+	public boolean calculateDefaultCacheable() {
+		if (!isMetadataComplete()) {
+			CacheableHolder2_0 javaEntity = (CacheableHolder2_0) getJavaEntity();
+			if (javaEntity != null) {
+				return javaEntity.getCacheable().isCacheable();
+			}
+		}
+		
+		CacheableHolder2_0 parentEntity = (CacheableHolder2_0) getParentEntity();
+		if (parentEntity != null) {
+			return parentEntity.getCacheable().isCacheable();
+		}
+		return ((PersistenceUnit2_0) getPersistenceUnit()).calculateDefaultCacheable();
+	}
+	
+	@Override
+	public void update() {
+		super.update();
+		getCacheable().update();
+	}
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/GenericJpaFactory2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/GenericJpaFactory2_0.java
index d898415941..f215f54af2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/GenericJpaFactory2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/GenericJpaFactory2_0.java
@@ -22,7 +22,6 @@ import org.eclipse.jpt.core.context.java.JavaOneToOneMapping;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.context.java.JavaSequenceGenerator;
-import org.eclipse.jpt.core.context.java.JavaTypeMapping;
 import org.eclipse.jpt.core.internal.AbstractJpaFactory;
 import org.eclipse.jpt.core.internal.jpa1.context.java.GenericJavaAssociationOverrideContainer;
 import org.eclipse.jpt.core.internal.jpa2.context.java.GenericJavaAssociationOverrideRelationshipReference2_0;
@@ -41,6 +40,7 @@ import org.eclipse.jpt.core.jpa2.JpaProject2_0;
 import org.eclipse.jpt.core.jpa2.MetamodelSynchronizer;
 import org.eclipse.jpt.core.jpa2.PersistentTypeMetamodelSynchronizer;
 import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaDerivedId2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaEmbeddedMapping2_0;
@@ -141,7 +141,7 @@ public class GenericJpaFactory2_0
 	}
 	
 	@Override
-	public JavaCacheable2_0 buildJavaCacheable(JavaTypeMapping parent) {
+	public JavaCacheable2_0 buildJavaCacheable(JavaCacheableHolder2_0 parent) {
 		return new GenericJavaCacheable2_0(parent);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaCacheable2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaCacheable2_0.java
index e904dd0ca7..e21fb8be65 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaCacheable2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaCacheable2_0.java
@@ -10,10 +10,9 @@
 package org.eclipse.jpt.core.internal.jpa2.context.java;
 
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.context.java.JavaTypeMapping;
 import org.eclipse.jpt.core.internal.context.java.AbstractJavaJpaContextNode;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.Cacheable2_0Annotation;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.utility.TextRange;
@@ -27,13 +26,13 @@ public class GenericJavaCacheable2_0
 	
 	protected JavaResourcePersistentType resourcePersistentType;
 	
-	public GenericJavaCacheable2_0(JavaTypeMapping parent) {
+	public GenericJavaCacheable2_0(JavaCacheableHolder2_0 parent) {
 		super(parent);
 	}
 
 	@Override
-	public JavaTypeMapping getParent() {
-		return (JavaTypeMapping) super.getParent();
+	public JavaCacheableHolder2_0 getParent() {
+		return (JavaCacheableHolder2_0) super.getParent();
 	}
 	
 	protected String getCacheableAnnotationName() {
@@ -53,7 +52,7 @@ public class GenericJavaCacheable2_0
 	}
 
 	protected boolean calculateDefaultCacheable() {		
-		return ((Entity2_0) getParent()).calculateDefaultCacheable();
+		return getParent().calculateDefaultCacheable();
 	}
 
 	public boolean isCacheable() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/NullJavaCacheable2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/NullJavaCacheable2_0.java
index 4ad911a968..7110530551 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/NullJavaCacheable2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/NullJavaCacheable2_0.java
@@ -12,9 +12,9 @@
 package org.eclipse.jpt.core.internal.jpa2.context.java;
 
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.context.java.JavaTypeMapping;
 import org.eclipse.jpt.core.internal.context.java.AbstractJavaJpaContextNode;
 import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.utility.TextRange;
 
@@ -22,7 +22,7 @@ public class NullJavaCacheable2_0
 	extends AbstractJavaJpaContextNode
 	implements JavaCacheable2_0
 {
-	public NullJavaCacheable2_0(JavaTypeMapping parent) {
+	public NullJavaCacheable2_0(JavaCacheableHolder2_0 parent) {
 		super(parent);
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmCacheable2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmCacheable2_0.java
index 6eb6ecee56..03907c97fe 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmCacheable2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmCacheable2_0.java
@@ -9,10 +9,9 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.jpa2.context.orm;
 
-import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmXmlContextNode;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
 import org.eclipse.jpt.core.resource.orm.v2_0.XmlCacheable2_0;
 import org.eclipse.jpt.core.utility.TextRange;
 
@@ -26,12 +25,17 @@ public class GenericOrmCacheable2_0 extends AbstractOrmXmlContextNode
 	protected Boolean specifiedCacheable;
 	
 	
-	public GenericOrmCacheable2_0(OrmTypeMapping parent, XmlCacheable2_0 resource) {
+	public GenericOrmCacheable2_0(OrmCacheableHolder2_0 parent, XmlCacheable2_0 resource) {
 		super(parent);
 		this.resource = resource;
 		this.specifiedCacheable = this.getResourceCacheable();
 	}
 
+	@Override
+	public OrmCacheableHolder2_0 getParent() {
+		return (OrmCacheableHolder2_0) super.getParent();
+	}
+	
 	public boolean isCacheable() {
 		return (this.specifiedCacheable != null) ? this.specifiedCacheable.booleanValue() : this.defaultCacheable;
 	}
@@ -67,8 +71,8 @@ public class GenericOrmCacheable2_0 extends AbstractOrmXmlContextNode
 	// **************** initialize/update **************************************
 		
 	public void update() {
-		setDefaultCacheable(this.calculateDefaultCacheable());
 		setSpecifiedCacheable_(this.getResourceCacheable());
+		setDefaultCacheable(this.calculateDefaultCacheable());
 	}
 	
 	protected Boolean getResourceCacheable() {
@@ -76,7 +80,7 @@ public class GenericOrmCacheable2_0 extends AbstractOrmXmlContextNode
 	}
 	
 	protected boolean calculateDefaultCacheable() {
-		return ((Entity2_0) getParent()).calculateDefaultCacheable();
+		return getParent().calculateDefaultCacheable();
 	}
 	
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmXml2_0ContextNodeFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmXml2_0ContextNodeFactory.java
index 857481ca20..7218fd3273 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmXml2_0ContextNodeFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmXml2_0ContextNodeFactory.java
@@ -40,6 +40,7 @@ import org.eclipse.jpt.core.jpa2.context.java.JavaManyToOneMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaOneToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaOneToOneMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmDerivedId2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmEmbeddedMapping2_0;
@@ -117,7 +118,7 @@ public class GenericOrmXml2_0ContextNodeFactory extends AbstractOrmXmlContextNod
 	}
 	
 	@Override
-	public OrmCacheable2_0 buildOrmCacheable(OrmTypeMapping parent, XmlCacheable2_0 resource) {
+	public OrmCacheable2_0 buildOrmCacheable(OrmCacheableHolder2_0 parent, XmlCacheable2_0 resource) {
 		return new GenericOrmCacheable2_0(parent, resource);
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/NullOrmCacheable2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/NullOrmCacheable2_0.java
index ab33daca60..9bcf898ae8 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/NullOrmCacheable2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/NullOrmCacheable2_0.java
@@ -10,16 +10,16 @@
  *******************************************************************************/
 package org.eclipse.jpt.core.internal.jpa2.context.orm;
 
-import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmXmlContextNode;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
 import org.eclipse.jpt.core.utility.TextRange;
 
 public class NullOrmCacheable2_0
 	extends AbstractOrmXmlContextNode
 	implements OrmCacheable2_0
 {
-	public NullOrmCacheable2_0(OrmTypeMapping parent) {
+	public NullOrmCacheable2_0(OrmCacheableHolder2_0 parent) {
 		super(parent);
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/persistence/GenericPersistenceUnit2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/persistence/GenericPersistenceUnit2_0.java
index 21a308309b..88ab8de82e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/persistence/GenericPersistenceUnit2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/persistence/GenericPersistenceUnit2_0.java
@@ -147,6 +147,19 @@ public class GenericPersistenceUnit2_0
 		this.firePropertyChanged(DEFAULT_SHARED_CACHE_MODE_PROPERTY, old, defaultSharedCacheMode);
 	}
 	
+	public boolean calculateDefaultCacheable() {
+		switch (getSharedCacheMode()) {
+			case NONE:
+			case ENABLE_SELECTIVE:
+			case UNSPECIFIED:
+				return false;
+			case ALL:
+			case DISABLE_SELECTIVE:
+				return true;
+		}
+		return false;//null
+	}
+	
 	
 	// ********** validation mode **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/JpaFactory2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/JpaFactory2_0.java
index 8b17702dc2..ead464c4de 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/JpaFactory2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/JpaFactory2_0.java
@@ -14,8 +14,8 @@ import org.eclipse.jpt.core.context.AssociationOverrideContainer;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.java.JavaAssociationOverrideContainer;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
-import org.eclipse.jpt.core.context.java.JavaTypeMapping;
 import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaDerivedId2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaEmbeddedMapping2_0;
@@ -54,5 +54,5 @@ public interface JpaFactory2_0
 	
 	JavaMapsId2_0 buildJavaMapsId(JavaSingleRelationshipMapping2_0 parent);
 	
-	JavaCacheable2_0 buildJavaCacheable(JavaTypeMapping parent);
+	JavaCacheable2_0 buildJavaCacheable(JavaCacheableHolder2_0 parent);
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/Entity2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/CacheableHolder2_0.java
index 96ca618e15..bb887cea2f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/Entity2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/CacheableHolder2_0.java
@@ -9,7 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.jpa2.context;
 
-import org.eclipse.jpt.core.context.Entity;
+import org.eclipse.jpt.core.JpaNode;
 
 /**
  * 
@@ -23,7 +23,7 @@ import org.eclipse.jpt.core.context.Entity;
  * @version 3.0
  * @since 3.0
  */
-public interface Entity2_0 extends Entity
+public interface CacheableHolder2_0 extends JpaNode
 {
 	Cacheable2_0 getCacheable();
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaCacheableHolder2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaCacheableHolder2_0.java
new file mode 100644
index 0000000000..8e340f4156
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaCacheableHolder2_0.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jpa2.context.java;
+
+import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+
+/**
+ * 
+ * 
+ * Provisional API: This interface is part of an interim API that is still
+ * under development and expected to change significantly before reaching
+ * stability. It is available at this early stage to solicit feedback from
+ * pioneering adopters on the understanding that any code that uses this API
+ * will almost certainly be broken (repeatedly) as the API evolves.
+ * 
+ * @version 3.0
+ * @since 3.0
+ */
+public interface JavaCacheableHolder2_0 extends CacheableHolder2_0, JavaJpaContextNode
+{
+	JavaCacheable2_0 getCacheable();
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/orm/OrmCacheableHolder2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/orm/OrmCacheableHolder2_0.java
new file mode 100644
index 0000000000..fd08274483
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/orm/OrmCacheableHolder2_0.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.jpa2.context.orm;
+
+import org.eclipse.jpt.core.context.XmlContextNode;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+
+/**
+ * 
+ * 
+ * Provisional API: This interface is part of an interim API that is still
+ * under development and expected to change significantly before reaching
+ * stability. It is available at this early stage to solicit feedback from
+ * pioneering adopters on the understanding that any code that uses this API
+ * will almost certainly be broken (repeatedly) as the API evolves.
+ * 
+ * @version 3.0
+ * @since 3.0
+ */
+public interface OrmCacheableHolder2_0 extends CacheableHolder2_0, XmlContextNode
+{
+	OrmCacheable2_0 getCacheable();
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/orm/OrmXml2_0ContextNodeFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/orm/OrmXml2_0ContextNodeFactory.java
index 31a7943517..b4447c096b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/orm/OrmXml2_0ContextNodeFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/orm/OrmXml2_0ContextNodeFactory.java
@@ -41,5 +41,5 @@ public interface OrmXml2_0ContextNodeFactory extends OrmXmlContextNodeFactory
 	XmlElementCollection buildVirtualXmlElementCollection2_0(
 			OrmTypeMapping ormTypeMapping, JavaElementCollectionMapping2_0 javaMapping);
 	
-	OrmCacheable2_0 buildOrmCacheable(OrmTypeMapping parent, XmlCacheable2_0 resource);
+	OrmCacheable2_0 buildOrmCacheable(OrmCacheableHolder2_0 parent, XmlCacheable2_0 resource);
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/persistence/PersistenceUnit2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/persistence/PersistenceUnit2_0.java
index 882b1e5c45..e713ee748b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/persistence/PersistenceUnit2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/persistence/PersistenceUnit2_0.java
@@ -63,6 +63,7 @@ public interface PersistenceUnit2_0
 	 */
 	SharedCacheMode getDefaultSharedCacheMode();
 
+	boolean calculateDefaultCacheable();
 
 	// ********** validation mode **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkCaching.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkCaching.java
index 2bd5b6d829..20e3916c2b 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkCaching.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkCaching.java
@@ -11,9 +11,10 @@ package org.eclipse.jpt.eclipselink.core.context.orm;
 
 import org.eclipse.jpt.core.context.XmlContextNode;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkCaching;
 
 public interface OrmEclipseLinkCaching
 	extends EclipseLinkCaching, XmlContextNode
 {
-	// just combine two interfaces
+	void update(JavaEclipseLinkCaching javaCaching);
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkEntity.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkEntity.java
index f8a7a6ea50..f4e9652354 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkEntity.java
@@ -15,4 +15,6 @@ import org.eclipse.jpt.eclipselink.core.context.EclipseLinkEntity;
 public interface OrmEclipseLinkEntity extends EclipseLinkEntity, OrmEntity
 {
 	EclipseLinkConverterHolder getConverterHolder();
+	
+	OrmEclipseLinkCaching getCaching();
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkMappedSuperclass.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkMappedSuperclass.java
index 0105a9cf72..df8ee7e307 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkMappedSuperclass.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/context/orm/OrmEclipseLinkMappedSuperclass.java
@@ -15,4 +15,6 @@ import org.eclipse.jpt.eclipselink.core.context.EclipseLinkMappedSuperclass;
 public interface OrmEclipseLinkMappedSuperclass extends EclipseLinkMappedSuperclass, OrmMappedSuperclass
 {
 	EclipseLinkConverterHolder getConverterHolder();
+	
+	OrmEclipseLinkCaching getCaching();
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkCachingImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkCachingImpl.java
index 226352d220..02f6f61cb7 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkCachingImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkCachingImpl.java
@@ -11,13 +11,20 @@ package org.eclipse.jpt.eclipselink.core.internal.context.java;
 
 import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.java.JavaTypeMapping;
 import org.eclipse.jpt.core.internal.context.java.AbstractJavaJpaContextNode;
+import org.eclipse.jpt.core.jpa2.JpaFactory2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCacheCoordinationType;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCacheType;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.core.context.EclipseLinkEntity;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkExistenceType;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkExpiryTimeOfDay;
 import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkCaching;
@@ -29,7 +36,11 @@ import org.eclipse.jpt.eclipselink.core.resource.java.EclipseLinkTimeOfDayAnnota
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
-public class JavaEclipseLinkCachingImpl extends AbstractJavaJpaContextNode implements JavaEclipseLinkCaching
+public class JavaEclipseLinkCachingImpl
+	extends AbstractJavaJpaContextNode
+	implements 
+		JavaEclipseLinkCaching,
+		JavaCacheableHolder2_0
 {
 	
 	protected EclipseLinkCacheType specifiedType;
@@ -48,11 +59,13 @@ public class JavaEclipseLinkCachingImpl extends AbstractJavaJpaContextNode imple
 	protected Integer expiry;
 	protected JavaEclipseLinkExpiryTimeOfDay expiryTimeOfDay;
 	
+	protected final JavaCacheable2_0 cacheable;
 	
 	protected JavaResourcePersistentType resourcePersistentType;
 	
 	public JavaEclipseLinkCachingImpl(JavaTypeMapping parent) {
 		super(parent);
+		this.cacheable = ((JpaFactory2_0) this.getJpaFactory()).buildJavaCacheable(this);
 	}
 	
 	@Override
@@ -415,10 +428,25 @@ public class JavaEclipseLinkCachingImpl extends AbstractJavaJpaContextNode imple
 		firePropertyChanged(EXPIRY_TIME_OF_DAY_PROPERTY, oldExpiryTimeOfDay, newExpiryTimeOfDay);
 	}
 	
+	public JavaCacheable2_0 getCacheable() {
+		return this.cacheable;
+	}
+	
+	public boolean calculateDefaultCacheable() {
+		if (getParent() instanceof Entity) {
+			EclipseLinkEntity parentEntity = (EclipseLinkEntity) ((Entity) getParent()).getParentEntity();
+			if (parentEntity != null) {
+				return ((CacheableHolder2_0) parentEntity).getCacheable().isCacheable();
+			}
+		}
+		return ((PersistenceUnit2_0) getPersistenceUnit()).calculateDefaultCacheable();
+	}
+	
 	public void initialize(JavaResourcePersistentType resourcePersistentType) {
 		this.resourcePersistentType = resourcePersistentType;
 		initialize(getCacheAnnotation());
 		initialize(getExistenceCheckingAnnotation());
+		this.cacheable.initialize(resourcePersistentType);
 	}
 
 	protected void initialize(EclipseLinkCacheAnnotation cache) {
@@ -455,6 +483,7 @@ public class JavaEclipseLinkCachingImpl extends AbstractJavaJpaContextNode imple
 		update(getCacheAnnotation());
 		update(getExistenceCheckingAnnotation());
 		updateExpiry(getCacheAnnotation());
+		this.cacheable.update(resourcePersistentType);
 	}
 	
 	protected void update(EclipseLinkCacheAnnotation cache) {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkEntityImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkEntityImpl.java
index 7b2b5a5834..a1b336a394 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkEntityImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkEntityImpl.java
@@ -13,6 +13,8 @@ import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.internal.context.java.AbstractJavaEntity;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkChangeTracking;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCustomizer;
@@ -63,6 +65,14 @@ public class JavaEclipseLinkEntityImpl extends AbstractJavaEntity implements Jav
 	public EclipseLinkChangeTracking getChangeTracking() {
 		return this.changeTracking;
 	}
+
+	public JavaCacheable2_0 getCacheable() {
+		return ((JavaCacheableHolder2_0) getCaching()).getCacheable();
+	}
+	
+	public boolean calculateDefaultCacheable() {
+		return ((JavaCacheableHolder2_0) getCaching()).calculateDefaultCacheable();
+	}
 	
 	@Override
 	public void initialize(JavaResourcePersistentType jrpt) {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCachingImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCachingImpl.java
index b8aebad1dd..d01e84d763 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCachingImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCachingImpl.java
@@ -9,11 +9,20 @@
  ******************************************************************************/
 package org.eclipse.jpt.eclipselink.core.internal.context.orm;
 
+import org.eclipse.jpt.core.context.Entity;
+import org.eclipse.jpt.core.context.orm.OrmEntity;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmXmlContextNode;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmXml2_0ContextNodeFactory;
+import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
+import org.eclipse.jpt.core.resource.orm.v2_0.XmlCacheable2_0;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCacheCoordinationType;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCacheType;
+import org.eclipse.jpt.eclipselink.core.context.EclipseLinkEntity;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkExistenceType;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkExpiryTimeOfDay;
 import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkCaching;
@@ -23,8 +32,11 @@ import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCache;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCacheHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlTimeOfDay;
 
-public class OrmEclipseLinkCachingImpl extends AbstractOrmXmlContextNode
-	implements OrmEclipseLinkCaching
+public class OrmEclipseLinkCachingImpl 
+	extends AbstractOrmXmlContextNode
+	implements 
+		OrmEclipseLinkCaching,
+		OrmCacheableHolder2_0
 {
 	protected final XmlCacheHolder resource;
 	
@@ -54,8 +66,10 @@ public class OrmEclipseLinkCachingImpl extends AbstractOrmXmlContextNode
 	
 	protected Integer expiry;
 	protected OrmEclipseLinkExpiryTimeOfDay expiryTimeOfDay;
+
+	protected final OrmCacheable2_0 cacheable;
 	
-	public OrmEclipseLinkCachingImpl(OrmTypeMapping parent, XmlCacheHolder resource, JavaEclipseLinkCaching javaCaching) {
+	public OrmEclipseLinkCachingImpl(OrmTypeMapping parent, XmlCacheHolder resource, XmlCacheable2_0 cacheableResource, JavaEclipseLinkCaching javaCaching) {
 		super(parent);
 		this.resource = resource;
 		XmlCache resourceCache = getResourceCache();
@@ -76,8 +90,14 @@ public class OrmEclipseLinkCachingImpl extends AbstractOrmXmlContextNode
 		this.defaultExistenceType = this.defaultExistenceType(javaCaching);
 		this.specifiedExistenceType = this.getResourceExistenceChecking();
 		this.initializeExpiry(resourceCache);
+		this.cacheable = ((OrmXml2_0ContextNodeFactory) getXmlContextNodeFactory()).buildOrmCacheable(this, cacheableResource);
 	}
 
+	@Override
+	public OrmTypeMapping getParent() {
+		return (OrmTypeMapping) super.getParent();
+	}
+	
 	public int getSize() {
 		return (this.specifiedSize == null) ? this.defaultSize : this.specifiedSize.intValue();
 	}
@@ -503,6 +523,26 @@ public class OrmEclipseLinkCachingImpl extends AbstractOrmXmlContextNode
 		this.resource.setCache(null);
 	}
 	
+	public OrmCacheable2_0 getCacheable() {
+		return this.cacheable;
+	}
+	
+	public boolean calculateDefaultCacheable() {
+		if (getParent() instanceof Entity) {
+			if (!getParent().isMetadataComplete()) {
+				EclipseLinkEntity javaEntity = (EclipseLinkEntity) ((OrmEntity) getParent()).getJavaEntity();
+				if (javaEntity != null) {
+					return ((CacheableHolder2_0) javaEntity).getCacheable().isCacheable();
+				}
+			}
+		
+			EclipseLinkEntity parentEntity = (EclipseLinkEntity) ((OrmEntity) getParent()).getParentEntity();
+			if (parentEntity != null) {
+				return ((CacheableHolder2_0) parentEntity).getCacheable().isCacheable();
+			}
+		}
+		return ((PersistenceUnit2_0) getPersistenceUnit()).calculateDefaultCacheable();
+	}
 	
 	// **************** initialize/update **************************************
 
@@ -521,7 +561,7 @@ public class OrmEclipseLinkCachingImpl extends AbstractOrmXmlContextNode
 		}
 	}
 
-	protected void update(JavaEclipseLinkCaching javaCaching) {
+	public void update(JavaEclipseLinkCaching javaCaching) {
 		XmlCache resourceCache = getResourceCache();
 		setDefaultSize(this.defaultSize(javaCaching));
 		setSpecifiedSize_(this.getResourceSize(resourceCache));
@@ -540,6 +580,7 @@ public class OrmEclipseLinkCachingImpl extends AbstractOrmXmlContextNode
 		setDefaultExistenceType(this.defaultExistenceType(javaCaching));
 		setSpecifiedExistenceType_(this.getResourceExistenceChecking());
 		this.updateExpiry(resourceCache);
+		this.cacheable.update();
 	}
 	
 	protected void updateExpiry(XmlCache resourceCache) {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java
index af98fa8245..e7c8aea031 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java
@@ -12,13 +12,17 @@ package org.eclipse.jpt.eclipselink.core.internal.context.orm;
 import java.util.List;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmEntity;
-import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
+import org.eclipse.jpt.core.resource.orm.v2_0.XmlCacheable2_0;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkChangeTracking;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCustomizer;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkReadOnly;
 import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkEntity;
 import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.EclipseLinkConverterHolder;
+import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkEntity;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCacheHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlChangeTrackingHolder;
@@ -38,7 +42,7 @@ public class OrmEclipseLinkEntityImpl extends AbstractOrmEntity
 	
 	protected final OrmEclipseLinkChangeTracking changeTracking;
 	
-	protected final OrmEclipseLinkCachingImpl caching;
+	protected final OrmEclipseLinkCaching caching;
 	
 	protected final OrmEclipseLinkConverterHolder converterHolder;
 	
@@ -48,11 +52,11 @@ public class OrmEclipseLinkEntityImpl extends AbstractOrmEntity
 		this.readOnly = new OrmEclipseLinkReadOnly(this, (XmlReadOnly) this.resourceTypeMapping, getJavaReadOnly());
 		this.customizer = new OrmEclipseLinkCustomizer(this, (XmlCustomizerHolder) this.resourceTypeMapping, getJavaCustomizer());
 		this.changeTracking = new OrmEclipseLinkChangeTracking(this, (XmlChangeTrackingHolder) this.resourceTypeMapping, getJavaChangeTracking());
-		this.caching = new OrmEclipseLinkCachingImpl(this, (XmlCacheHolder) this.resourceTypeMapping, getJavaCaching());
+		this.caching = new OrmEclipseLinkCachingImpl(this, (XmlCacheHolder) this.resourceTypeMapping, (XmlCacheable2_0) this.resourceTypeMapping, getJavaCaching());
 		this.converterHolder = new OrmEclipseLinkConverterHolder(this, (XmlConvertersHolder) this.resourceTypeMapping);
 	}
 	
-	public EclipseLinkCaching getCaching() {
+	public OrmEclipseLinkCaching getCaching() {
 		return this.caching;
 	}
 
@@ -71,6 +75,14 @@ public class OrmEclipseLinkEntityImpl extends AbstractOrmEntity
 	public EclipseLinkConverterHolder getConverterHolder() {
 		return this.converterHolder;
 	}
+
+	public OrmCacheable2_0 getCacheable() {
+		return ((OrmCacheableHolder2_0) getCaching()).getCacheable();
+	}
+	
+	public boolean calculateDefaultCacheable() {
+		return ((CacheableHolder2_0) getCaching()).calculateDefaultCacheable();
+	}
 	
 	// **************** resource-context interaction ***************************
 	
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java
index 9c6e76f70e..7f405d5ad9 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java
@@ -12,13 +12,14 @@ package org.eclipse.jpt.eclipselink.core.internal.context.orm;
 import java.util.List;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmMappedSuperclass;
-import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.core.resource.orm.v2_0.XmlCacheable2_0;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkChangeTracking;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCustomizer;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkReadOnly;
 import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkMappedSuperclass;
 import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.EclipseLinkConverterHolder;
+import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkMappedSuperclass;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCacheHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlChangeTrackingHolder;
@@ -38,7 +39,7 @@ public class OrmEclipseLinkMappedSuperclassImpl extends AbstractOrmMappedSupercl
 	
 	protected final OrmEclipseLinkChangeTracking changeTracking;
 	
-	protected final OrmEclipseLinkCachingImpl caching;
+	protected final OrmEclipseLinkCaching caching;
 	
 	protected final OrmEclipseLinkConverterHolder converterHolder;
 	
@@ -48,11 +49,11 @@ public class OrmEclipseLinkMappedSuperclassImpl extends AbstractOrmMappedSupercl
 		this.readOnly = new OrmEclipseLinkReadOnly(this, (XmlReadOnly) this.resourceTypeMapping, getJavaReadOnly());
 		this.customizer = new OrmEclipseLinkCustomizer(this, (XmlCustomizerHolder) this.resourceTypeMapping, getJavaCustomizer());
 		this.changeTracking = new OrmEclipseLinkChangeTracking(this, (XmlChangeTrackingHolder) this.resourceTypeMapping, getJavaChangeTracking());
-		this.caching = new OrmEclipseLinkCachingImpl(this, (XmlCacheHolder) this.resourceTypeMapping, getJavaCaching());
+		this.caching = new OrmEclipseLinkCachingImpl(this, (XmlCacheHolder) this.resourceTypeMapping, (XmlCacheable2_0) this.resourceTypeMapping, getJavaCaching());
 		this.converterHolder = new OrmEclipseLinkConverterHolder(this, (XmlConvertersHolder) this.resourceTypeMapping);
 	}
 	
-	public EclipseLinkCaching getCaching() {
+	public OrmEclipseLinkCaching getCaching() {
 		return this.caching;
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/EclipseLink2_0JpaFactory.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/EclipseLink2_0JpaFactory.java
index 940441042e..83d6a6320c 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/EclipseLink2_0JpaFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/EclipseLink2_0JpaFactory.java
@@ -21,7 +21,6 @@ import org.eclipse.jpt.core.context.java.JavaOneToOneMapping;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.context.java.JavaSequenceGenerator;
-import org.eclipse.jpt.core.context.java.JavaTypeMapping;
 import org.eclipse.jpt.core.internal.jpa1.context.java.GenericJavaAssociationOverrideContainer;
 import org.eclipse.jpt.core.internal.jpa2.GenericMetamodelSynchronizer;
 import org.eclipse.jpt.core.internal.jpa2.GenericPersistentTypeMetamodelSynchronizer;
@@ -37,6 +36,7 @@ import org.eclipse.jpt.core.jpa2.JpaProject2_0;
 import org.eclipse.jpt.core.jpa2.MetamodelSynchronizer;
 import org.eclipse.jpt.core.jpa2.PersistentTypeMetamodelSynchronizer;
 import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaDerivedId2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaEmbeddedMapping2_0;
@@ -114,7 +114,7 @@ public class EclipseLink2_0JpaFactory
 	}
 	
 	@Override
-	public JavaCacheable2_0 buildJavaCacheable(JavaTypeMapping parent) {
+	public JavaCacheable2_0 buildJavaCacheable(JavaCacheableHolder2_0 parent) {
 		return new GenericJavaCacheable2_0(parent);
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/EclipseLinkOrmXml2_0ContextNodeFactory.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/EclipseLinkOrmXml2_0ContextNodeFactory.java
index 1d87b25799..d5f7d9b173 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/EclipseLinkOrmXml2_0ContextNodeFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/EclipseLinkOrmXml2_0ContextNodeFactory.java
@@ -43,6 +43,7 @@ import org.eclipse.jpt.core.internal.jpa2.context.orm.VirtualXmlAssociationOverr
 import org.eclipse.jpt.core.jpa2.context.java.JavaElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaOneToOneMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmDerivedId2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmElementCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmEmbeddedMapping2_0;
@@ -139,7 +140,7 @@ public class EclipseLinkOrmXml2_0ContextNodeFactory extends EclipseLinkOrmXmlCon
 	}
 	
 	@Override
-	public OrmCacheable2_0 buildOrmCacheable(OrmTypeMapping parent, XmlCacheable2_0 resource) {
+	public OrmCacheable2_0 buildOrmCacheable(OrmCacheableHolder2_0 parent, XmlCacheable2_0 resource) {
 		return new GenericOrmCacheable2_0(parent, resource);
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/persistence/EclipseLinkPersistenceUnit2_0.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/persistence/EclipseLinkPersistenceUnit2_0.java
index cb27e21b4d..ab4066c076 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/persistence/EclipseLinkPersistenceUnit2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/persistence/EclipseLinkPersistenceUnit2_0.java
@@ -143,6 +143,19 @@ public class EclipseLinkPersistenceUnit2_0
 		this.defaultSharedCacheMode = defaultSharedCacheMode;
 		this.firePropertyChanged(DEFAULT_SHARED_CACHE_MODE_PROPERTY, old, defaultSharedCacheMode);
 	}
+	
+	public boolean calculateDefaultCacheable() {
+		switch (getSharedCacheMode()) {
+			case NONE:
+			case ENABLE_SELECTIVE:
+				return false;
+			case ALL:
+			case DISABLE_SELECTIVE:
+			case UNSPECIFIED:
+				return true;
+		}
+		return true;//null
+	}
 
 	// ********** validation mode **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/AbstractJavaEclipseLinkEntityComposite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/AbstractJavaEclipseLinkEntityComposite.java
index f0a976bc31..66038743f8 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/AbstractJavaEclipseLinkEntityComposite.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/AbstractJavaEclipseLinkEntityComposite.java
@@ -61,7 +61,7 @@ public abstract class AbstractJavaEclipseLinkEntityComposite<T extends JavaEntit
 		initializeSecondaryTablesPane(container);
 		initializeAdvancedPane(container);
 	}
-	
+
 	protected void initializeCachingPane(Composite container) {
 
 		container = addCollapsableSection(
@@ -69,7 +69,11 @@ public abstract class AbstractJavaEclipseLinkEntityComposite<T extends JavaEntit
 			EclipseLinkUiDetailsMessages.EclipseLinkTypeMappingComposite_caching
 		);
 
-		new JavaEclipseLinkCachingComposite(this, buildCachingHolder(), container);
+		addCachingComposite(container, buildCachingHolder());
+	}
+	
+	protected void addCachingComposite(Composite container, PropertyValueModel<JavaEclipseLinkCaching> cachingHolder) {
+		new JavaEclipseLinkCachingComposite(this, cachingHolder, container);
 	}
 
 	private PropertyAspectAdapter<JavaEntity, JavaEclipseLinkCaching> buildCachingHolder() {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/JavaEclipseLinkCachingComposite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/JavaEclipseLinkCachingComposite.java
index 84cddb80ad..75082f75d1 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/JavaEclipseLinkCachingComposite.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/java/JavaEclipseLinkCachingComposite.java
@@ -34,7 +34,7 @@ import org.eclipse.swt.widgets.Composite;
  * -----------------------------------------------------------------------------</pre>
  *
  * @see Entity
- * @see EclipseLinkCaching
+ * @see EclipseLinkCaching2_0
  * @see JavaEclipseLinkEntityComposite - The parent container
  * @see EclipseLinkCacheTypeComposite
  * @see EclipseLinkCacheSizeComposite
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/AbstractOrmEclipseLinkEntityComposite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/AbstractOrmEclipseLinkEntityComposite.java
index 5cbb46d47e..5667eb9682 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/AbstractOrmEclipseLinkEntityComposite.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/AbstractOrmEclipseLinkEntityComposite.java
@@ -11,8 +11,8 @@
 package org.eclipse.jpt.eclipselink.ui.internal.details.orm;
 
 import org.eclipse.jpt.core.context.orm.OrmEntity;
-import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.EclipseLinkConverterHolder;
+import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkEntity;
 import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkEntityAdvancedComposite;
 import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkUiDetailsMessages;
@@ -48,13 +48,18 @@ public abstract class AbstractOrmEclipseLinkEntityComposite extends AbstractOrmE
 		container = addCollapsableSection(
 			addSubPane(container, 5),
 			EclipseLinkUiDetailsMessages.EclipseLinkTypeMappingComposite_caching);
-		new OrmEclipseLinkCachingComposite(this, buildCachingHolder(), container);
+		addCachingComposite(container, buildCachingHolder());
 	}
 	
-	private PropertyAspectAdapter<OrmEntity, EclipseLinkCaching> buildCachingHolder() {
-		return new PropertyAspectAdapter<OrmEntity, EclipseLinkCaching>(getSubjectHolder()) {
+	protected void addCachingComposite(Composite container, PropertyValueModel<OrmEclipseLinkCaching> cachingHolder) {
+		new OrmEclipseLinkCachingComposite(this, cachingHolder, container);
+	}
+
+	
+	private PropertyAspectAdapter<OrmEntity, OrmEclipseLinkCaching> buildCachingHolder() {
+		return new PropertyAspectAdapter<OrmEntity, OrmEclipseLinkCaching>(getSubjectHolder()) {
 			@Override
-			protected EclipseLinkCaching buildValue_() {
+			protected OrmEclipseLinkCaching buildValue_() {
 				return ((OrmEclipseLinkEntity) this.subject).getCaching();
 			}
 		};
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkCachingComposite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkCachingComposite.java
index 9051dcd10d..4ced36b7b7 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkCachingComposite.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkCachingComposite.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.eclipselink.ui.internal.details.orm;
 
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkAlwaysRefreshComposite;
 import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheSizeComposite;
 import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheTypeComposite;
@@ -51,11 +52,11 @@ import org.eclipse.swt.widgets.Composite;
  * @version 2.1
  * @since 2.1
  */
-public class OrmEclipseLinkCachingComposite extends EclipseLinkCachingComposite<EclipseLinkCaching>
+public class OrmEclipseLinkCachingComposite extends EclipseLinkCachingComposite<OrmEclipseLinkCaching>
 {
 
 	public OrmEclipseLinkCachingComposite(FormPane<?> parentPane,
-        PropertyValueModel<EclipseLinkCaching> subjectHolder,
+        PropertyValueModel<OrmEclipseLinkCaching> subjectHolder,
         Composite parent) {
 
 		super(parentPane, subjectHolder, parent);
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkMappedSuperclassComposite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkMappedSuperclassComposite.java
index bd1e82c44d..1f173b36e2 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkMappedSuperclassComposite.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkMappedSuperclassComposite.java
@@ -11,8 +11,8 @@
 package org.eclipse.jpt.eclipselink.ui.internal.details.orm;
 
 import org.eclipse.jpt.core.context.AccessHolder;
-import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.EclipseLinkConverterHolder;
+import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkMappedSuperclass;
 import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkMappedSuperclassAdvancedComposite;
 import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkUiDetailsMessages;
@@ -74,12 +74,12 @@ public class OrmEclipseLinkMappedSuperclassComposite<T extends OrmEclipseLinkMap
 		new OrmEclipseLinkCachingComposite(this, buildCachingHolder(), container);
 	}
 
-	private PropertyAspectAdapter<T, EclipseLinkCaching> buildCachingHolder() {
-		return new PropertyAspectAdapter<T, EclipseLinkCaching>(
+	private PropertyAspectAdapter<T, OrmEclipseLinkCaching> buildCachingHolder() {
+		return new PropertyAspectAdapter<T, OrmEclipseLinkCaching>(
 			getSubjectHolder())
 		{
 			@Override
-			protected EclipseLinkCaching buildValue_() {
+			protected OrmEclipseLinkCaching buildValue_() {
 				return this.subject.getCaching();
 			}
 		};
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/EclipseLinkCaching2_0Composite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/EclipseLinkCaching2_0Composite.java
new file mode 100644
index 0000000000..7aab5afd40
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/EclipseLinkCaching2_0Composite.java
@@ -0,0 +1,188 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.eclipselink.ui.internal.v2_0.details;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import org.eclipse.jpt.core.context.Entity;
+import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkAlwaysRefreshComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheCoordinationTypeComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheSizeComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheTypeComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkDisableHitsComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkExpiryComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkRefreshOnlyIfNewerComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkUiDetailsMessages;
+import org.eclipse.jpt.eclipselink.ui.internal.details.java.JavaEclipseLinkEntityComposite;
+import org.eclipse.jpt.ui.internal.JpaHelpContextIds;
+import org.eclipse.jpt.ui.internal.details.JptUiDetailsMessages;
+import org.eclipse.jpt.ui.internal.jpa2.details.JptUiDetailsMessages2_0;
+import org.eclipse.jpt.ui.internal.util.PaneEnabler;
+import org.eclipse.jpt.ui.internal.widgets.FormPane;
+import org.eclipse.jpt.ui.internal.widgets.Pane;
+import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
+import org.eclipse.jpt.utility.internal.model.value.SimplePropertyValueModel;
+import org.eclipse.jpt.utility.internal.model.value.TransformationPropertyValueModel;
+import org.eclipse.jpt.utility.model.value.PropertyValueModel;
+import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * This pane shows the caching options.
+ * <p>
+ * Here the layout of this pane:
+ * <pre>
+ * -----------------------------------------------------------------------------
+ * | x Shared                                                                  |
+ * |    CacheTypeComposite                                                     |
+ * |    CacheSizeComposite                                                     |
+ * |    > Advanced   	                                                       |
+ * |    	ExpiryComposite                                                    |
+ * |    	AlwaysRefreshComposite                                             |
+ * |   		RefreshOnlyIfNewerComposite                                        |
+ * |    	DisableHitsComposite                                               |
+ * |    	CacheCoordinationComposite                                         |
+ * | ExistenceTypeComposite                                                    |
+ * -----------------------------------------------------------------------------</pre>
+ *
+ * @see Entity
+ * @see EclipseLinkCaching
+ * @see JavaEclipseLinkEntityComposite - The parent container
+ * @see EclipseLinkCacheTypeComposite
+ * @see EclipseLinkCacheSizeComposite
+ * @see EclipseLinkAlwaysRefreshComposite
+ * @see EclipseLinkRefreshOnlyIfNewerComposite
+ * @see EclipseLinkDisableHitsComposite
+ *
+ * @version 3.0
+ * @since 3.0
+ */
+public abstract class EclipseLinkCaching2_0Composite<T extends EclipseLinkCaching> extends FormPane<T>
+{
+	
+	protected EclipseLinkCaching2_0Composite(FormPane<?> parentPane,
+        PropertyValueModel<T> subjectHolder,
+        Composite parent) {
+
+		super(parentPane, subjectHolder, parent, false);
+	}
+	
+	@Override
+	protected void initializeLayout(Composite container) {
+		PropertyValueModel<Cacheable2_0> cacheableHolder = buildCacheableHolder();
+		
+		//Shared Check box, uncheck this and the rest of the panel is disabled
+		addTriStateCheckBoxWithDefault(
+			addSubPane(container, 8),
+			JptUiDetailsMessages2_0.Entity_cacheableLabel,
+			buildSpecifiedCacheableHolder(cacheableHolder),
+			buildCacheableStringHolder(cacheableHolder),
+			JpaHelpContextIds.ENTITY_CACHEABLE
+		);
+
+		Composite subPane = addSubPane(container, 0, 16);
+
+		Collection<Pane<?>> panes = new ArrayList<Pane<?>>();
+		
+		panes.add(new EclipseLinkCacheTypeComposite(this, subPane));
+		panes.add(new EclipseLinkCacheSizeComposite(this, subPane));
+		
+		// Advanced sub-pane
+		Composite advancedSection = addCollapsableSubSection(
+			subPane,
+			EclipseLinkUiDetailsMessages.EclipseLinkCachingComposite_advanced,
+			new SimplePropertyValueModel<Boolean>(Boolean.FALSE)
+		);
+
+		initializeAdvancedPane(addSubPane(advancedSection, 0, 16), panes);
+			
+		new PaneEnabler(buildCacheableEnabler(cacheableHolder), panes);
+		
+		initializeExistenceCheckingComposite(addSubPane(container, 8));
+	}
+	
+	protected PropertyValueModel<Cacheable2_0> buildCacheableHolder() {
+		return new PropertyAspectAdapter<EclipseLinkCaching, Cacheable2_0>(getSubjectHolder()) {
+			@Override
+			protected Cacheable2_0 buildValue_() {
+				return ((CacheableHolder2_0) this.subject).getCacheable();
+			}
+		};
+	}
+
+	protected void initializeAdvancedPane(Composite container, Collection<Pane<?>> panes) {
+		panes.add(new EclipseLinkExpiryComposite(this, container));
+		panes.add(new EclipseLinkAlwaysRefreshComposite(this, container));
+		panes.add(new EclipseLinkRefreshOnlyIfNewerComposite(this, container));
+		panes.add(new EclipseLinkDisableHitsComposite(this, container));
+		panes.add(new EclipseLinkCacheCoordinationTypeComposite(this, container));
+	}
+	
+	protected abstract void initializeExistenceCheckingComposite(Composite parent);
+	
+	private PropertyValueModel<Boolean> buildCacheableEnabler(PropertyValueModel<Cacheable2_0> cacheableHolder) {
+		return new PropertyAspectAdapter<Cacheable2_0, Boolean>(
+				cacheableHolder,
+				Cacheable2_0.SPECIFIED_CACHEABLE_PROPERTY, 
+				Cacheable2_0.DEFAULT_CACHEABLE_PROPERTY) {
+			@Override
+			protected Boolean buildValue_() {
+				return Boolean.valueOf(this.subject.isCacheable());
+			}
+		};
+	}	
+	
+	private WritablePropertyValueModel<Boolean> buildSpecifiedCacheableHolder(PropertyValueModel<Cacheable2_0> cacheableHolder) {
+		return new PropertyAspectAdapter<Cacheable2_0, Boolean>(cacheableHolder, Cacheable2_0.SPECIFIED_CACHEABLE_PROPERTY) {
+			@Override
+			protected Boolean buildValue_() {
+				return this.subject.getSpecifiedCacheable();
+			}
+
+			@Override
+			protected void setValue_(Boolean value) {
+				this.subject.setSpecifiedCacheable(value);
+			}
+		};
+	}
+
+	private PropertyValueModel<String> buildCacheableStringHolder(PropertyValueModel<Cacheable2_0> cacheableHolder) {
+		return new TransformationPropertyValueModel<Boolean, String>(buildDefaultCacheableHolder(cacheableHolder)) {
+			@Override
+			protected String transform(Boolean value) {
+				if (value != null) {
+					String defaultStringValue = value.booleanValue() ? JptUiDetailsMessages.Boolean_True : JptUiDetailsMessages.Boolean_False;
+					return NLS.bind(JptUiDetailsMessages2_0.Entity_cacheableWithDefaultLabel, defaultStringValue);
+				}
+				return JptUiDetailsMessages2_0.Entity_cacheableLabel;
+			}
+		};
+	}
+	
+	private PropertyValueModel<Boolean> buildDefaultCacheableHolder(PropertyValueModel<Cacheable2_0> cacheableHolder) {
+		return new PropertyAspectAdapter<Cacheable2_0, Boolean>(
+			cacheableHolder,
+			Cacheable2_0.SPECIFIED_CACHEABLE_PROPERTY,
+			Cacheable2_0.DEFAULT_CACHEABLE_PROPERTY)
+		{
+			@Override
+			protected Boolean buildValue_() {
+				if (this.subject.getSpecifiedCacheable() != null) {
+					return null;
+				}
+				return Boolean.valueOf(this.subject.isDefaultCacheable());
+			}
+		};
+	}
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/java/JavaEclipseLinkCaching2_0Composite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/java/JavaEclipseLinkCaching2_0Composite.java
new file mode 100644
index 0000000000..e6cd8e24f6
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/java/JavaEclipseLinkCaching2_0Composite.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.eclipselink.ui.internal.v2_0.details.java;
+
+import org.eclipse.jpt.core.context.Entity;
+import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkAlwaysRefreshComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheSizeComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheTypeComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkDisableHitsComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkRefreshOnlyIfNewerComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.java.JavaEclipseLinkEntityComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.java.JavaEclipseLinkExistenceCheckingComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.EclipseLinkCaching2_0Composite;
+import org.eclipse.jpt.ui.internal.widgets.FormPane;
+import org.eclipse.jpt.utility.model.value.PropertyValueModel;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * This pane shows the caching options.
+ * <p>
+ * Here the layout of this pane:
+ * <pre>
+ * -----------------------------------------------------------------------------
+ * | x Shared                                                                  |
+ * |    CacheTypeComposite                                                     |
+ * |    CacheSizeComposite                                                     |
+ * |    > Advanced   	                                                       |
+ * |    	ExpiryComposite                                                    |
+ * |    	AlwaysRefreshComposite                                             |
+ * |   		RefreshOnlyIfNewerComposite                                        |
+ * |    	DisableHitsComposite                                               |
+ * |    	CacheCoordinationComposite                                         |
+ * | ExistenceTypeComposite                                                    |
+ * -----------------------------------------------------------------------------</pre>
+ *
+ * @see Entity
+ * @see EclipseLinkCaching
+ * @see JavaEclipseLinkEntityComposite - The parent container
+ * @see EclipseLinkCacheTypeComposite
+ * @see EclipseLinkCacheSizeComposite
+ * @see EclipseLinkAlwaysRefreshComposite
+ * @see EclipseLinkRefreshOnlyIfNewerComposite
+ * @see EclipseLinkDisableHitsComposite
+ *
+ * @version 3.0
+ * @since 3.0
+ */
+public class JavaEclipseLinkCaching2_0Composite extends EclipseLinkCaching2_0Composite<JavaEclipseLinkCaching>
+{
+
+	public JavaEclipseLinkCaching2_0Composite(FormPane<?> parentPane,
+        PropertyValueModel<JavaEclipseLinkCaching> subjectHolder,
+        Composite parent) {
+
+		super(parentPane, subjectHolder, parent);
+	}
+
+	@Override
+	protected void initializeExistenceCheckingComposite(Composite parent) {
+		new JavaEclipseLinkExistenceCheckingComposite(this, parent);
+	}
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/java/JavaEclipseLinkEntity2_0Composite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/java/JavaEclipseLinkEntity2_0Composite.java
index 2bd8e27382..b2ca11b351 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/java/JavaEclipseLinkEntity2_0Composite.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/java/JavaEclipseLinkEntity2_0Composite.java
@@ -12,6 +12,7 @@ package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.java;
 import org.eclipse.jpt.core.context.AccessHolder;
 import org.eclipse.jpt.core.context.GeneratorContainer;
 import org.eclipse.jpt.core.context.java.JavaEntity;
+import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.core.context.java.JavaEclipseLinkEntity;
 import org.eclipse.jpt.eclipselink.ui.internal.details.java.AbstractJavaEclipseLinkEntityComposite;
 import org.eclipse.jpt.ui.WidgetFactory;
@@ -80,5 +81,10 @@ public class JavaEclipseLinkEntity2_0Composite extends AbstractJavaEclipseLinkEn
 	protected void addGeneratorsComposite(Composite container, PropertyValueModel<GeneratorContainer> generatorContainerHolder) {
 		new Generation2_0Composite(this, generatorContainerHolder, container);
 	}
+	
+	@Override
+	protected void addCachingComposite(Composite container, PropertyValueModel<JavaEclipseLinkCaching> cachingHolder) {
+		new JavaEclipseLinkCaching2_0Composite(this, cachingHolder, container);
+	}
 
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkCaching2_0Composite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkCaching2_0Composite.java
new file mode 100644
index 0000000000..afe63cb254
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkCaching2_0Composite.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.eclipselink.ui.internal.v2_0.details.orm;
+
+import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkCaching;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkAlwaysRefreshComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheSizeComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkCacheTypeComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkDisableHitsComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkRefreshOnlyIfNewerComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.java.JavaEclipseLinkEntityComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.details.orm.OrmEclipseLinkExistenceCheckingComposite;
+import org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.EclipseLinkCaching2_0Composite;
+import org.eclipse.jpt.ui.internal.widgets.FormPane;
+import org.eclipse.jpt.utility.model.value.PropertyValueModel;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * This pane shows the caching options.
+ * <p>
+ * Here the layout of this pane:
+ * <pre>
+ * -----------------------------------------------------------------------------
+ * | x Shared                                                                  |
+ * |    CacheTypeComposite                                                     |
+ * |    CacheSizeComposite                                                     |
+ * |    > Advanced   	                                                       |
+ * |    	ExpiryComposite                                                    |
+ * |    	AlwaysRefreshComposite                                             |
+ * |   		RefreshOnlyIfNewerComposite                                        |
+ * |    	DisableHitsComposite                                               |
+ * |    	CacheCoordinationComposite                                         |
+ * | ExistenceTypeComposite                                                    |
+ * -----------------------------------------------------------------------------</pre>
+ *
+ * @see Entity
+ * @see EclipseLinkCaching
+ * @see JavaEclipseLinkEntityComposite - The parent container
+ * @see EclipseLinkCacheTypeComposite
+ * @see EclipseLinkCacheSizeComposite
+ * @see EclipseLinkAlwaysRefreshComposite
+ * @see EclipseLinkRefreshOnlyIfNewerComposite
+ * @see EclipseLinkDisableHitsComposite
+ *
+ * @version 3.0
+ * @since 3.0
+ */
+public class OrmEclipseLinkCaching2_0Composite extends EclipseLinkCaching2_0Composite<OrmEclipseLinkCaching>
+{
+
+	public OrmEclipseLinkCaching2_0Composite(FormPane<?> parentPane,
+        PropertyValueModel<OrmEclipseLinkCaching> subjectHolder,
+        Composite parent) {
+
+		super(parentPane, subjectHolder, parent);
+	}
+
+	@Override
+	protected void initializeExistenceCheckingComposite(Composite parent) {
+		new OrmEclipseLinkExistenceCheckingComposite(this, parent);
+	}
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkEntity2_0Composite.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkEntity2_0Composite.java
index fb946655a3..0f99e18a2a 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkEntity2_0Composite.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkEntity2_0Composite.java
@@ -12,6 +12,7 @@ package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.orm;
 
 import org.eclipse.jpt.core.context.GeneratorContainer;
 import org.eclipse.jpt.core.context.orm.OrmEntity;
+import org.eclipse.jpt.eclipselink.core.context.orm.OrmEclipseLinkCaching;
 import org.eclipse.jpt.eclipselink.ui.internal.details.orm.AbstractOrmEclipseLinkEntityComposite;
 import org.eclipse.jpt.ui.WidgetFactory;
 import org.eclipse.jpt.ui.internal.jpa2.details.Entity2_0OverridesComposite;
@@ -36,5 +37,10 @@ public class OrmEclipseLinkEntity2_0Composite extends AbstractOrmEclipseLinkEnti
 	protected void addGeneratorsComposite(Composite container, PropertyValueModel<GeneratorContainer> generatorContainerHolder) {
 		new Generation2_0Composite(this, generatorContainerHolder, container);
 	}
+	
+	@Override
+	protected void addCachingComposite(Composite container, PropertyValueModel<OrmEclipseLinkCaching> cachingHolder) {
+		new OrmEclipseLinkCaching2_0Composite(this, cachingHolder, container);
+	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/java/JavaEntity2_0Composite.java b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/java/JavaEntity2_0Composite.java
index 18465a5a3a..b7c9a531ab 100644
--- a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/java/JavaEntity2_0Composite.java
+++ b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/java/JavaEntity2_0Composite.java
@@ -12,7 +12,7 @@ package org.eclipse.jpt.ui.internal.jpa2.details.java;
 import org.eclipse.jpt.core.context.AccessHolder;
 import org.eclipse.jpt.core.context.java.JavaEntity;
 import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
 import org.eclipse.jpt.ui.WidgetFactory;
 import org.eclipse.jpt.ui.internal.details.AbstractEntityComposite;
 import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
@@ -78,7 +78,7 @@ public class JavaEntity2_0Composite extends AbstractEntityComposite<JavaEntity>
 		return new PropertyAspectAdapter<JavaEntity, Cacheable2_0>(getSubjectHolder()) {
 			@Override
 			protected Cacheable2_0 buildValue_() {
-				return ((Entity2_0) this.subject).getCacheable();
+				return ((CacheableHolder2_0) this.subject).getCacheable();
 			}
 		};
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/orm/OrmEntity2_0Composite.java b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/orm/OrmEntity2_0Composite.java
index a8b856512e..3f7088e763 100644
--- a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/orm/OrmEntity2_0Composite.java
+++ b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/jpa2/details/orm/OrmEntity2_0Composite.java
@@ -12,7 +12,7 @@ package org.eclipse.jpt.ui.internal.jpa2.details.orm;
 import org.eclipse.jpt.core.context.GeneratorContainer;
 import org.eclipse.jpt.core.context.orm.OrmEntity;
 import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
 import org.eclipse.jpt.ui.WidgetFactory;
 import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
 import org.eclipse.jpt.ui.internal.details.EntityNameComposite;
@@ -66,7 +66,7 @@ public class OrmEntity2_0Composite extends AbstractOrmEntityComposite
 		return new PropertyAspectAdapter<OrmEntity, Cacheable2_0>(getSubjectHolder()) {
 			@Override
 			protected Cacheable2_0 buildValue_() {
-				return ((Entity2_0) this.subject).getCacheable();
+				return ((CacheableHolder2_0) this.subject).getCacheable();
 			}
 		};
 	}
diff --git a/jpa/tests/org.eclipse.jpt.core.tests.extension.resource/src/org/eclipse/jpt/core/tests/extension/resource/TestJavaEntity.java b/jpa/tests/org.eclipse.jpt.core.tests.extension.resource/src/org/eclipse/jpt/core/tests/extension/resource/TestJavaEntity.java
index 55e8265c3f..89dbb7472b 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests.extension.resource/src/org/eclipse/jpt/core/tests/extension/resource/TestJavaEntity.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests.extension.resource/src/org/eclipse/jpt/core/tests/extension/resource/TestJavaEntity.java
@@ -11,10 +11,21 @@ package org.eclipse.jpt.core.tests.extension.resource;
 
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.internal.context.java.AbstractJavaEntity;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCacheable2_0;
 
 public class TestJavaEntity extends AbstractJavaEntity
 {
 	protected TestJavaEntity(JavaPersistentType parent) {
 		super(parent);
 	}
+
+	public JavaCacheable2_0 getCacheable() {
+		return null;
+	}
+	
+	public boolean calculateDefaultCacheable() {
+		return false;
+	}
+
+	
 }
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEntity2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEntity2_0Tests.java
index de810b2fcb..8e32cd010f 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEntity2_0Tests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEntity2_0Tests.java
@@ -27,7 +27,9 @@ import org.eclipse.jpt.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
 import org.eclipse.jpt.core.context.java.JavaEntity;
 import org.eclipse.jpt.core.context.persistence.ClassRef;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
+import org.eclipse.jpt.core.jpa2.MappingKeys2_0;
+import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
 import org.eclipse.jpt.core.jpa2.context.persistence.options.SharedCacheMode;
 import org.eclipse.jpt.core.jpa2.resource.java.Cacheable2_0Annotation;
@@ -283,6 +285,7 @@ public class GenericJavaEntity2_0Tests extends Generic2_0ContextModelTestCase
 		Entity entity = (Entity) getJavaPersistentType().getMapping();
 		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY));
 		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY));
 		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY));
 		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY));
 		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY));
@@ -1440,26 +1443,26 @@ public class GenericJavaEntity2_0Tests extends Generic2_0ContextModelTestCase
 		ICompilationUnit cu = createTestEntity();
 		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 entity = (Entity2_0) getJavaEntity();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
 		Cacheable2_0Annotation cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, cacheableAnnotation);
 		
-		entity.getCacheable().setSpecifiedCacheable(Boolean.FALSE);
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
 		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
-		assertEquals(Boolean.FALSE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.FALSE, cacheable.getSpecifiedCacheable());
 		assertEquals(Boolean.FALSE, cacheableAnnotation.getValue());
 		assertSourceContains("@Cacheable(false)", cu);
 		
-		entity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
 		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
-		assertEquals(Boolean.TRUE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
 		assertEquals(null, cacheableAnnotation.getValue());
 		assertSourceContains("@Cacheable", cu);
 		
-		entity.getCacheable().setSpecifiedCacheable(null);
+		cacheable.setSpecifiedCacheable(null);
 		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, cacheableAnnotation);
 		assertSourceDoesNotContain("@Cacheable", cu);
 	}
@@ -1468,35 +1471,35 @@ public class GenericJavaEntity2_0Tests extends Generic2_0ContextModelTestCase
 		ICompilationUnit cu = createTestEntity();
 		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 entity = (Entity2_0) getJavaEntity();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
 		Cacheable2_0Annotation cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, cacheableAnnotation);
 		
 		getJavaPersistentType().getResourcePersistentType().addAnnotation(JPA2_0.CACHEABLE);
 		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);
-		assertEquals(Boolean.TRUE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
 		assertEquals(null, cacheableAnnotation.getValue());
 		assertSourceContains("@Cacheable", cu);
 
 		cacheableAnnotation.setValue(Boolean.FALSE);
-		assertEquals(Boolean.FALSE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.FALSE, cacheable.getSpecifiedCacheable());
 		assertEquals(Boolean.FALSE, cacheableAnnotation.getValue());
 		assertSourceContains("@Cacheable(false)", cu);
 		
 		cacheableAnnotation.setValue(Boolean.TRUE);
-		assertEquals(Boolean.TRUE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
 		assertEquals(Boolean.TRUE, cacheableAnnotation.getValue());
 		assertSourceContains("@Cacheable(true)", cu);
 		
 		cacheableAnnotation.setValue(null);
-		assertEquals(Boolean.TRUE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
 		assertEquals(null, cacheableAnnotation.getValue());
 		assertSourceContains("@Cacheable", cu);
 
 		getJavaPersistentType().getResourcePersistentType().removeAnnotation(JPA2_0.CACHEABLE);
 		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, cacheableAnnotation);
 		assertSourceDoesNotContain("@Cacheable", cu);
 	}
@@ -1505,22 +1508,22 @@ public class GenericJavaEntity2_0Tests extends Generic2_0ContextModelTestCase
 		createTestEntity();
 		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 entity = (Entity2_0) getJavaEntity();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
 		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
 		assertEquals(SharedCacheMode.UNSPECIFIED, persistenceUnit2_0.getSharedCacheMode());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ALL);
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 	}
 	
 	public void testInheritedIsDefaultCacheable() throws Exception {
@@ -1529,27 +1532,27 @@ public class GenericJavaEntity2_0Tests extends Generic2_0ContextModelTestCase
 		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
 		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 subEntity = (Entity2_0) getJavaEntity();
-		Entity2_0 entity = (Entity2_0) subEntity.getParentEntity();
-		entity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		Cacheable2_0 subCacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity().getParentEntity()).getCacheable();
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
 		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 				
-		entity.getCacheable().setSpecifiedCacheable(Boolean.FALSE);
-		assertEquals(false, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
-		assertEquals(false, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
-		entity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/GenericOrmEntity2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/GenericOrmEntity2_0Tests.java
index a03393fe09..837e80361e 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/GenericOrmEntity2_0Tests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/orm/GenericOrmEntity2_0Tests.java
@@ -26,7 +26,8 @@ import org.eclipse.jpt.core.context.orm.OrmAttributeOverride;
 import org.eclipse.jpt.core.context.orm.OrmEntity;
 import org.eclipse.jpt.core.context.orm.OrmMappedSuperclass;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
-import org.eclipse.jpt.core.jpa2.context.Entity2_0;
+import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
 import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
 import org.eclipse.jpt.core.jpa2.context.persistence.options.SharedCacheMode;
 import org.eclipse.jpt.core.resource.java.JPA;
@@ -1410,21 +1411,21 @@ public class GenericOrmEntity2_0Tests extends Generic2_0OrmContextModelTestCase
 		createTestEntity();
 		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 entity = (Entity2_0) ormPersistentType.getMapping();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
 		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, entityResource.getCacheable());
 		
-		entity.getCacheable().setSpecifiedCacheable(Boolean.FALSE);
-		assertEquals(Boolean.FALSE, entity.getCacheable().getSpecifiedCacheable());
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(Boolean.FALSE, cacheable.getSpecifiedCacheable());
 		assertEquals(Boolean.FALSE, entityResource.getCacheable());
 		
-		entity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
-		assertEquals(Boolean.TRUE, entity.getCacheable().getSpecifiedCacheable());
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
 		assertEquals(Boolean.TRUE, entityResource.getCacheable());
 		
-		entity.getCacheable().setSpecifiedCacheable(null);
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		cacheable.setSpecifiedCacheable(null);
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, entityResource.getCacheable());
 	}
 	
@@ -1432,21 +1433,21 @@ public class GenericOrmEntity2_0Tests extends Generic2_0OrmContextModelTestCase
 		createTestEntity();
 		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 entity = (Entity2_0) ormPersistentType.getMapping();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
 		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, entityResource.getCacheable());
 		
 		entityResource.setCacheable(Boolean.TRUE);
-		assertEquals(Boolean.TRUE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
 		assertEquals(Boolean.TRUE, entityResource.getCacheable());
 
 		entityResource.setCacheable(Boolean.FALSE);
-		assertEquals(Boolean.FALSE, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(Boolean.FALSE, cacheable.getSpecifiedCacheable());
 		assertEquals(Boolean.FALSE, entityResource.getCacheable());
 		
 		entityResource.setCacheable(null);
-		assertEquals(null, entity.getCacheable().getSpecifiedCacheable());
+		assertEquals(null, cacheable.getSpecifiedCacheable());
 		assertEquals(null, entityResource.getCacheable());
 	}
 	
@@ -1454,22 +1455,22 @@ public class GenericOrmEntity2_0Tests extends Generic2_0OrmContextModelTestCase
 		createTestEntity();
 		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 entity = (Entity2_0) ormPersistentType.getMapping();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
 		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
 		assertEquals(SharedCacheMode.UNSPECIFIED, persistenceUnit2_0.getSharedCacheMode());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ALL);
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 	}
 	
 	public void testIsDefaultCacheableFromSuperType() throws Exception {
@@ -1478,28 +1479,28 @@ public class GenericOrmEntity2_0Tests extends Generic2_0OrmContextModelTestCase
 		OrmPersistentType subOrmPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_SUB_TYPE_NAME);
 		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 subEntity = (Entity2_0) subOrmPersistentType.getMapping();
-		Entity2_0 entity = (Entity2_0) ormPersistentType.getMapping();
-		entity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		Cacheable2_0 subCacheable = ((CacheableHolder2_0) subOrmPersistentType.getMapping()).getCacheable();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
 		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 				
-		entity.getCacheable().setSpecifiedCacheable(Boolean.FALSE);
-		assertEquals(false, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
-		assertEquals(false, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
-		entity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 	}
 	
 	public void testIsDefaultCacheableFromJava() throws Exception {
@@ -1508,41 +1509,41 @@ public class GenericOrmEntity2_0Tests extends Generic2_0OrmContextModelTestCase
 		OrmPersistentType subOrmPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_SUB_TYPE_NAME);
 		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
 		
-		Entity2_0 subEntity = (Entity2_0) subOrmPersistentType.getMapping();
-		Entity2_0 entity = (Entity2_0) ormPersistentType.getMapping();
+		Cacheable2_0 subCacheable = ((CacheableHolder2_0) subOrmPersistentType.getMapping()).getCacheable();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
 		
-		Entity2_0 javaEntity = (Entity2_0) ormPersistentType.getJavaPersistentType().getMapping();
-		javaEntity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		Cacheable2_0 javaCacheable = ((CacheableHolder2_0) ormPersistentType.getJavaPersistentType().getMapping()).getCacheable();
+		javaCacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 		
 		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 				
-		javaEntity.getCacheable().setSpecifiedCacheable(Boolean.FALSE);
-		assertEquals(false, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		javaCacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
-		assertEquals(false, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
-		javaEntity.getCacheable().setSpecifiedCacheable(Boolean.TRUE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		javaCacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 		
 		getEntityMappings().getPersistenceUnitMetadata().setXmlMappingMetadataComplete(true);
-		assertEquals(false, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(false, entity.getCacheable().isDefaultCacheable());
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
 		
 		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 		
-		javaEntity.getCacheable().setSpecifiedCacheable(Boolean.FALSE);
-		assertEquals(true, subEntity.getCacheable().isDefaultCacheable());
-		assertEquals(true, entity.getCacheable().isDefaultCacheable());
+		javaCacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
 	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink/core/tests/internal/context/java/EclipseLinkJavaEntityTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink/core/tests/internal/context/java/EclipseLinkJavaEntityTests.java
index 5146aa836d..909a8f1752 100644
--- a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink/core/tests/internal/context/java/EclipseLinkJavaEntityTests.java
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink/core/tests/internal/context/java/EclipseLinkJavaEntityTests.java
@@ -11,8 +11,11 @@ package org.eclipse.jpt.eclipselink.core.tests.internal.context.java;
 
 import java.util.Iterator;
 import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.core.MappingKeys;
+import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.resource.java.JPA;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
+import org.eclipse.jpt.eclipselink.core.EclipseLinkMappingKeys;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkChangeTracking;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkChangeTrackingType;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCustomizer;
@@ -28,6 +31,19 @@ import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 @SuppressWarnings("nls")
 public class EclipseLinkJavaEntityTests extends EclipseLinkContextModelTestCase
 {
+
+	private ICompilationUnit createTestEntity() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity");
+			}
+		});
+	}
 	
 	private ICompilationUnit createTestEntityWithConvertAndCustomizerClass() throws Exception {
 		return this.createTestType(new DefaultAnnotationWriter() {
@@ -75,6 +91,27 @@ public class EclipseLinkJavaEntityTests extends EclipseLinkContextModelTestCase
 		super(name);
 	}
 
+	public void testAttributeMappingKeyAllowed() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+		Entity entity = (Entity) getJavaPersistentType().getMapping();
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.BASIC_COLLECTION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.BASIC_MAP_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.TRANSFORMATION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.VARIABLE_ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+	}
+
 
 	public void testGetCustomizerClass() throws Exception {
 		createTestEntityWithConvertAndCustomizerClass();
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaEntityTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaEntityTests.java
new file mode 100644
index 0000000000..853ba7123f
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaEntityTests.java
@@ -0,0 +1,1580 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.eclipselink2_0.core.tests.internal.context.java;
+
+import java.util.Iterator;
+import java.util.ListIterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.core.MappingKeys;
+import org.eclipse.jpt.core.context.AssociationOverride;
+import org.eclipse.jpt.core.context.AssociationOverrideContainer;
+import org.eclipse.jpt.core.context.AttributeOverride;
+import org.eclipse.jpt.core.context.AttributeOverrideContainer;
+import org.eclipse.jpt.core.context.BasicMapping;
+import org.eclipse.jpt.core.context.EmbeddedMapping;
+import org.eclipse.jpt.core.context.Entity;
+import org.eclipse.jpt.core.context.InheritanceType;
+import org.eclipse.jpt.core.context.MappedSuperclass;
+import org.eclipse.jpt.core.context.PersistentType;
+import org.eclipse.jpt.core.context.java.JavaAssociationOverride;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.core.context.java.JavaEntity;
+import org.eclipse.jpt.core.context.persistence.ClassRef;
+import org.eclipse.jpt.core.jpa2.MappingKeys2_0;
+import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
+import org.eclipse.jpt.core.jpa2.context.persistence.options.SharedCacheMode;
+import org.eclipse.jpt.core.jpa2.resource.java.Cacheable2_0Annotation;
+import org.eclipse.jpt.core.jpa2.resource.java.JPA2_0;
+import org.eclipse.jpt.core.resource.java.AssociationOverrideAnnotation;
+import org.eclipse.jpt.core.resource.java.AssociationOverridesAnnotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverridesAnnotation;
+import org.eclipse.jpt.core.resource.java.JPA;
+import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
+import org.eclipse.jpt.core.resource.java.NestableAnnotation;
+import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter;
+import org.eclipse.jpt.eclipselink.core.EclipseLinkMappingKeys;
+import org.eclipse.jpt.eclipselink2_0.core.tests.internal.context.EclipseLink2_0ContextModelTestCase;
+import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
+
+@SuppressWarnings("nls")
+public class EclipseLink2_0JavaEntityTests extends EclipseLink2_0ContextModelTestCase
+{
+	protected static final String SUB_TYPE_NAME = "AnnotationTestTypeChild";
+	protected static final String FULLY_QUALIFIED_SUB_TYPE_NAME = PACKAGE_NAME + "." + SUB_TYPE_NAME;
+	
+	
+	public EclipseLink2_0JavaEntityTests(String name) {
+		super(name);
+	}
+
+	private ICompilationUnit createTestEntity() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity");
+			}
+		});
+	}
+
+	private ICompilationUnit createTestMappedSuperclass() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.MAPPED_SUPERCLASS, JPA.ONE_TO_ONE, JPA.MANY_TO_ONE, JPA.ONE_TO_MANY, JPA.MANY_TO_MANY);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@MappedSuperclass");
+			}
+			
+			@Override
+			public void appendGetIdMethodAnnotationTo(StringBuilder sb) {
+				sb.append("private String foo;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToOne");
+				sb.append(CR);
+				sb.append("    private int address;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToOne");
+				sb.append(CR);
+				sb.append("    private int address2;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToMany");
+				sb.append(CR);
+				sb.append("    private int address3;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToMany");
+				sb.append(CR);
+				sb.append("    private int address4;").append(CR);
+				sb.append(CR);
+				sb.append("    ");
+			}
+		});
+	}
+	
+	private ICompilationUnit createTestAbstractEntityTablePerClass() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.INHERITANCE, JPA.INHERITANCE_TYPE, JPA.ONE_TO_ONE, JPA.MANY_TO_ONE, JPA.ONE_TO_MANY, JPA.MANY_TO_MANY);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+				sb.append("@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)");
+				sb.append("abstract");
+			}
+			
+			@Override
+			public void appendGetIdMethodAnnotationTo(StringBuilder sb) {
+				sb.append("private String foo;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToOne");
+				sb.append(CR);
+				sb.append("    private int address;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToOne");
+				sb.append(CR);
+				sb.append("    private int address2;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToMany");
+				sb.append(CR);
+				sb.append("    private int address3;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToMany");
+				sb.append(CR);
+				sb.append("    private int address4;").append(CR);
+				sb.append(CR);
+				sb.append("    ");
+			}
+		});
+	}
+
+	private void createTestSubType() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("AnnotationTestTypeChild").append(" ");
+				sb.append("extends " + TYPE_NAME + " ");
+				sb.append("{}").append(CR);
+			}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "AnnotationTestTypeChild.java", sourceWriter);
+	}
+	
+	private void createTestMappedSuperclassCustomer() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.MAPPED_SUPERCLASS);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@MappedSuperclass");
+				sb.append(CR);
+				sb.append("public class ").append("Customer ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    @Id").append(CR);
+				sb.append("    private String id;").append(CR);
+				sb.append(CR);
+				sb.append("    private String name;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private Address address;").append(CR);
+				sb.append(CR);
+			sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Customer.java", sourceWriter);
+	}
+	
+	private void createTestEntityLongTimeCustomer() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("LongTimeCustomer extends Customer ");
+				sb.append("{}");
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "LongTimeCustomer.java", sourceWriter);
+	}
+
+
+	private void createTestEmbeddableAddress() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("Address").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String street;").append(CR);
+				sb.append(CR);
+				sb.append("    private String city;").append(CR);
+				sb.append(CR);
+				sb.append("    private String state;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private ZipCode zipCode;").append(CR);
+				sb.append(CR);
+			sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+	}
+	
+	private void createTestEmbeddableZipCode() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("ZipCode").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String zip;").append(CR);
+				sb.append(CR);
+				sb.append("    private String plusfour;").append(CR);
+				sb.append(CR);
+			sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "ZipCode.java", sourceWriter);
+	}
+
+	public void testAttributeMappingKeyAllowed() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+		Entity entity = (Entity) getJavaPersistentType().getMapping();
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.BASIC_COLLECTION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.BASIC_MAP_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.TRANSFORMATION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(EclipseLinkMappingKeys.VARIABLE_ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+	}
+	
+	public void testOverridableAttributes() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		Iterator<String> overridableAttributes = getJavaEntity().overridableAttributeNames();
+		assertFalse(overridableAttributes.hasNext());
+		
+		
+		getJavaEntity().setSpecifiedInheritanceStrategy(InheritanceType.TABLE_PER_CLASS);
+		
+		overridableAttributes = getJavaEntity().overridableAttributeNames();		
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+	}
+
+	public void testOverridableAttributeNames() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		Iterator<String> overridableAttributeNames = getJavaEntity().overridableAttributeNames();
+		assertFalse(overridableAttributeNames.hasNext());
+		
+		
+		getJavaEntity().setSpecifiedInheritanceStrategy(InheritanceType.TABLE_PER_CLASS);
+		
+		overridableAttributeNames = getJavaEntity().overridableAttributeNames();
+		assertEquals("id", overridableAttributeNames.next());
+		assertEquals("name", overridableAttributeNames.next());
+		assertFalse(overridableAttributeNames.hasNext());
+	}
+
+	public void testAllOverridableAttributes() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		Iterator<String> overridableAttributes = getJavaEntity().allOverridableAttributeNames();
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertEquals("foo", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+	}
+	
+	public void testAllOverridableAttributesTablePerClass() throws Exception {
+		createTestAbstractEntityTablePerClass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		Iterator<String> overridableAttributes = getJavaEntity().allOverridableAttributeNames();
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertEquals("foo", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		JavaEntity abstractEntity = (JavaEntity) classRefs.next().getJavaPersistentType().getMapping();
+		overridableAttributes = abstractEntity.allOverridableAttributeNames();
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertEquals("foo", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+	}
+	
+	public void testAllOverridableAssociationsTablePerClass() throws Exception {
+		createTestAbstractEntityTablePerClass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		Iterator<String> overridableAssociations = getJavaEntity().allOverridableAssociationNames();
+		assertEquals("address", overridableAssociations.next());
+		assertEquals("address2", overridableAssociations.next());
+		assertEquals("address3", overridableAssociations.next());
+		assertEquals("address4", overridableAssociations.next());
+		assertFalse(overridableAssociations.hasNext());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		JavaEntity abstractEntity = (JavaEntity) classRefs.next().getJavaPersistentType().getMapping();
+		overridableAssociations = abstractEntity.allOverridableAssociationNames();
+		assertEquals("address", overridableAssociations.next());
+		assertEquals("address2", overridableAssociations.next());
+		assertEquals("address3", overridableAssociations.next());
+		assertEquals("address4", overridableAssociations.next());
+		assertFalse(overridableAssociations.hasNext());
+	}
+
+	public void testAllOverridableAttributesMappedSuperclassInOrmXml() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		
+		Iterator<String> overridableAttributes = getJavaEntity().allOverridableAttributeNames();
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertEquals("foo", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+	}
+
+	public void testAllOverridableAttributeNames() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		Iterator<String> overridableAttributeNames = getJavaEntity().allOverridableAttributeNames();
+		assertEquals("id", overridableAttributeNames.next());
+		assertEquals("name", overridableAttributeNames.next());
+		assertEquals("foo", overridableAttributeNames.next());
+		assertFalse(overridableAttributeNames.hasNext());
+	}
+		
+	public void testSpecifiedAttributeOverrides() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		ListIterator<JavaAttributeOverride> specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) typeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		attributeOverride = (AttributeOverrideAnnotation) typeResource.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("BAR");
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+
+		attributeOverride = (AttributeOverrideAnnotation) typeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("BAZ");
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+	
+		//move an annotation to the resource model and verify the context model is updated
+		typeResource.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDES);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		typeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+	
+		typeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		
+		typeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedAttributeOverrides.hasNext());
+	}
+
+	public void testDefaultAttributeOverrides() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		JavaEntity javaEntity = (JavaEntity) classRefs.next().getJavaPersistentType().getMapping();
+		AttributeOverrideContainer overrideContainer = javaEntity.getAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+
+		MappedSuperclass mappedSuperclass = (MappedSuperclass) getJavaPersistentType().getMapping();
+		
+		BasicMapping idMapping = (BasicMapping) mappedSuperclass.getPersistentType().getAttributeNamed("id").getMapping();
+		idMapping.getColumn().setSpecifiedName("FOO");
+		idMapping.getColumn().setSpecifiedTable("BAR");
+		
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("FOO", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BAR", virtualAttributeOverride.getColumn().getTable());
+
+		idMapping.getColumn().setSpecifiedName(null);
+		idMapping.getColumn().setSpecifiedTable(null);
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+		virtualAttributeOverride = virtualAttributeOverride.setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testDefaultAttributeOverridesEntityHierachy() throws Exception {
+		createTestAbstractEntityTablePerClass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		JavaEntity javaEntity = (JavaEntity) classRefs.next().getJavaPersistentType().getMapping();
+		AttributeOverrideContainer overrideContainer = javaEntity.getAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+
+		JavaEntity superclass = (JavaEntity) getJavaPersistentType().getMapping();
+		
+		BasicMapping idMapping = (BasicMapping) superclass.getPersistentType().getAttributeNamed("id").getMapping();
+		idMapping.getColumn().setSpecifiedName("FOO");
+		idMapping.getColumn().setSpecifiedTable("BAR");
+		
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("FOO", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BAR", virtualAttributeOverride.getColumn().getTable());
+
+		idMapping.getColumn().setSpecifiedName(null);
+		idMapping.getColumn().setSpecifiedTable(null);
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+		virtualAttributeOverride = virtualAttributeOverride.setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		assertEquals(0, overrideContainer.specifiedAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) typeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) typeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("BAR");
+
+		assertEquals(2, overrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testDefaultAttributeOverridesSize() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAttributeOverridesSize());
+		
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(1, overrideContainer.virtualAttributeOverridesSize());
+		
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(0, overrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testAttributeOverridesSize() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		
+		assertEquals(3, overrideContainer.attributeOverridesSize());
+
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(3, overrideContainer.attributeOverridesSize());
+		
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(3, overrideContainer.attributeOverridesSize());
+		
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) typeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("bar");	
+		assertEquals(4, overrideContainer.attributeOverridesSize());
+	}
+
+	public void testAttributeOverrideSetVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+				
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		Iterator<NestableAnnotation> attributeOverrides = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("id", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+	}
+	
+	public void testAttributeOverrideSetVirtual2() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> virtualAttributeOverrides = overrideContainer.virtualAttributeOverrides();
+		virtualAttributeOverrides.next();
+		virtualAttributeOverrides.next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		Iterator<NestableAnnotation> attributeOverrides = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("id", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+	}
+	
+	public void testAttributeOverrideSetVirtualTrue() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+				
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		assertEquals(3, CollectionTools.size(typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME)));
+
+		overrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		
+		Iterator<NestableAnnotation> attributeOverrideResources = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("name", ((AttributeOverrideAnnotation) attributeOverrideResources.next()).getName());		
+		assertEquals("foo", ((AttributeOverrideAnnotation) attributeOverrideResources.next()).getName());
+		assertFalse(attributeOverrideResources.hasNext());
+		
+		Iterator<JavaAttributeOverride> attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("name", attributeOverrides.next().getName());		
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		
+		overrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrideResources = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("foo", ((AttributeOverrideAnnotation) attributeOverrideResources.next()).getName());		
+		assertFalse(attributeOverrideResources.hasNext());
+
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+
+		
+		overrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrideResources = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(attributeOverrideResources.hasNext());
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertFalse(attributeOverrides.hasNext());
+
+		assertNull(typeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+	}
+	
+	public void testMoveSpecifiedAttributeOverride() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		
+		Iterator<NestableAnnotation> javaAttributeOverrides = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals(3, CollectionTools.size(javaAttributeOverrides));
+		
+		
+		overrideContainer.moveSpecifiedAttributeOverride(2, 0);
+		ListIterator<AttributeOverride> attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("name", attributeOverrides.next().getName());
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertEquals("id", attributeOverrides.next().getName());
+
+		javaAttributeOverrides = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("name", ((AttributeOverrideAnnotation) javaAttributeOverrides.next()).getName());
+		assertEquals("foo", ((AttributeOverrideAnnotation) javaAttributeOverrides.next()).getName());
+		assertEquals("id", ((AttributeOverrideAnnotation) javaAttributeOverrides.next()).getName());
+
+
+		overrideContainer.moveSpecifiedAttributeOverride(0, 1);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertEquals("name", attributeOverrides.next().getName());
+		assertEquals("id", attributeOverrides.next().getName());
+
+		javaAttributeOverrides = typeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("foo", ((AttributeOverrideAnnotation) javaAttributeOverrides.next()).getName());
+		assertEquals("name", ((AttributeOverrideAnnotation) javaAttributeOverrides.next()).getName());
+		assertEquals("id", ((AttributeOverrideAnnotation) javaAttributeOverrides.next()).getName());
+	}
+//	
+	public void testUpdateSpecifiedAttributeOverrides() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+	
+		((AttributeOverrideAnnotation) typeResource.addAnnotation(0, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME)).setName("FOO");
+		((AttributeOverrideAnnotation) typeResource.addAnnotation(1, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME)).setName("BAR");
+		((AttributeOverrideAnnotation) typeResource.addAnnotation(2, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME)).setName("BAZ");
+			
+		ListIterator<AttributeOverride> attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertEquals("BAR", attributeOverrides.next().getName());
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		typeResource.moveAnnotation(2, 0, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAR", attributeOverrides.next().getName());
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		typeResource.moveAnnotation(0, 1, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertEquals("BAR", attributeOverrides.next().getName());
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		typeResource.removeAnnotation(1,  AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		typeResource.removeAnnotation(1,  AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		typeResource.removeAnnotation(0,  AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertFalse(attributeOverrides.hasNext());
+	}
+
+	public void testAttributeOverrideIsVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AttributeOverrideContainer overrideContainer = getJavaEntity().getAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> virtualAttributeOverrides = overrideContainer.virtualAttributeOverrides();	
+		AttributeOverride virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("name", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("foo", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		assertFalse(virtualAttributeOverrides.hasNext());
+
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		AttributeOverride specifiedAttributeOverride = overrideContainer.specifiedAttributeOverrides().next();
+		assertFalse(specifiedAttributeOverride.isVirtual());
+		
+		
+		virtualAttributeOverrides = overrideContainer.virtualAttributeOverrides();	
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("name", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("foo", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		assertFalse(virtualAttributeOverrides.hasNext());
+	}
+	
+	
+	public void testOverridableAssociations() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+		Iterator<String> overridableAssociations = getJavaEntity().overridableAssociationNames();
+		assertFalse(overridableAssociations.hasNext());
+	}
+
+	public void testOverridableAssociationNames() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+		Iterator<String> overridableAssociationNames = getJavaEntity().overridableAssociationNames();
+		assertFalse(overridableAssociationNames.hasNext());
+	}
+	
+//	//TODO add all mapping types to the mapped superclass to test which ones are overridable
+	public void testAllOverridableAssociationNames() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+		Iterator<String> overridableAssociationNames = getJavaEntity().allOverridableAssociationNames();
+		assertEquals("address", overridableAssociationNames.next());
+		assertEquals("address2", overridableAssociationNames.next());
+		assertEquals("address3", overridableAssociationNames.next());
+		assertEquals("address4", overridableAssociationNames.next());
+		assertFalse(overridableAssociationNames.hasNext());
+	}
+		
+	public void testAllOverridableAssociationsMappedSuperclassInOrmXml() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		
+		Iterator<String> overridableAssociations = getJavaEntity().allOverridableAssociationNames();
+		assertEquals("address", overridableAssociations.next());
+		assertEquals("address2", overridableAssociations.next());
+		assertEquals("address3", overridableAssociations.next());
+		assertEquals("address4", overridableAssociations.next());
+		assertFalse(overridableAssociations.hasNext());
+	}
+
+	public void testSpecifiedAssociationOverrides() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		ListIterator<JavaAssociationOverride> specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();
+		
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+
+		//add an annotation to the resource model and verify the context model is updated
+		AssociationOverrideAnnotation associationOverride = (AssociationOverrideAnnotation) typeResource.addAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		associationOverride.setName("FOO");
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		associationOverride = (AssociationOverrideAnnotation) typeResource.addAnnotation(1, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		associationOverride.setName("BAR");
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+
+		associationOverride = (AssociationOverrideAnnotation) typeResource.addAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		associationOverride.setName("BAZ");
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("BAZ", specifiedAssociationOverrides.next().getName());
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+	
+		//move an annotation to the resource model and verify the context model is updated
+		typeResource.moveAnnotation(1, 0, JPA.ASSOCIATION_OVERRIDES);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAZ", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		typeResource.removeAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("BAZ", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+	
+		typeResource.removeAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		
+		typeResource.removeAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertFalse(specifiedAssociationOverrides.hasNext());
+	}
+
+	public void testDefaultAssociationOverrides() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		JavaEntity javaEntity = (JavaEntity) classRefs.next().getJavaPersistentType().getMapping();
+		AssociationOverrideContainer overrideContainer = javaEntity.getAssociationOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AssociationOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AssociationOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(4, overrideContainer.virtualAssociationOverridesSize());
+		AssociationOverride virtualAssociationOverride = overrideContainer.virtualAssociationOverrides().next();
+		assertEquals("address", virtualAssociationOverride.getName());
+		
+
+		//MappedSuperclass mappedSuperclass = (MappedSuperclass) javaPersistentType().getMapping();
+		//BasicMapping idMapping = (BasicMapping) mappedSuperclass.persistentType().attributeNamed("id").getMapping();
+		//idMapping.getColumn().setSpecifiedName("FOO");
+		//idMapping.getColumn().setSpecifiedTable("BAR");
+		
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AssociationOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AssociationOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, overrideContainer.virtualAssociationOverridesSize());
+		virtualAssociationOverride = overrideContainer.virtualAssociationOverrides().next();
+		assertEquals("address", virtualAssociationOverride.getName());
+
+		//idMapping.getColumn().setSpecifiedName(null);
+		//idMapping.getColumn().setSpecifiedTable(null);
+		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+		assertNull(typeResource.getAnnotation(AssociationOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(typeResource.getAnnotation(AssociationOverridesAnnotation.ANNOTATION_NAME));
+
+		virtualAssociationOverride = overrideContainer.virtualAssociationOverrides().next();
+		assertEquals("address", virtualAssociationOverride.getName());
+		
+		virtualAssociationOverride = virtualAssociationOverride.setVirtual(false);
+		assertEquals(3, overrideContainer.virtualAssociationOverridesSize());
+		
+		
+		
+//		//TODO joinColumns for default association overrides
+////	IJoinColumn defaultJoinColumn = defaultAssociationOverride.joinColumns().next();
+////	assertEquals("address", defaultJoinColumn.getName());
+////	assertEquals("address", defaultJoinColumn.getReferencedColumnName());
+////	assertEquals(SUB_TYPE_NAME, defaultJoinColumn.getTable());
+////	
+////
+////	IMappedSuperclass mappedSuperclass = (IMappedSuperclass) javaPersistentType().getMapping();
+////	
+////	IOneToOneMapping addressMapping = (IOneToOneMapping) mappedSuperclass.persistentType().attributeNamed("address").getMapping();
+////	IJoinColumn joinColumn = addressMapping.addSpecifiedJoinColumn(0);
+////	joinColumn.setSpecifiedName("FOO");
+////	joinColumn.setSpecifiedReferencedColumnName("BAR");
+////	joinColumn.setSpecifiedTable("BAZ");
+////	
+////	assertEquals(SUB_TYPE_NAME, typeResource.getName());
+////	assertNull(typeResource.annotation(AssociationOverride.ANNOTATION_NAME));
+////	assertNull(typeResource.annotation(AssociationOverrides.ANNOTATION_NAME));
+////
+////	assertEquals(1, CollectionTools.size(javaEntity.defaultAssociationOverrides()));
+////	defaultAssociationOverride = javaEntity.defaultAssociationOverrides().next();
+////	assertEquals("address", defaultAssociationOverride.getName());
+////	assertEquals("FOO", defaultJoinColumn.getName());
+////	assertEquals("BAR", defaultJoinColumn.getReferencedColumnName());
+////	assertEquals("BAZ", defaultJoinColumn.getTable());
+////
+////	joinColumn.setSpecifiedName(null);
+////	joinColumn.setSpecifiedReferencedColumnName(null);
+////	joinColumn.setSpecifiedTable(null);
+////	assertEquals(SUB_TYPE_NAME, typeResource.getName());
+////	assertNull(typeResource.annotation(AssociationOverride.ANNOTATION_NAME));
+////	assertNull(typeResource.annotation(AssociationOverrides.ANNOTATION_NAME));
+////
+////	defaultAssociationOverride = javaEntity.defaultAssociationOverrides().next();
+////	assertEquals("address", defaultJoinColumn.getName());
+////	assertEquals("address", defaultJoinColumn.getReferencedColumnName());
+////	assertEquals(SUB_TYPE_NAME, defaultJoinColumn.getTable());
+////	
+////	javaEntity.addSpecifiedAssociationOverride(0).setName("address");
+////	assertEquals(0, CollectionTools.size(javaEntity.defaultAssociationOverrides()));
+
+	}
+	
+	public void testSpecifiedAssociationOverridesSize() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		
+		assertEquals(0, overrideContainer.specifiedAssociationOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+
+		//add an annotation to the resource model and verify the context model is updated
+		AssociationOverrideAnnotation associationOverride = (AssociationOverrideAnnotation) typeResource.addAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		associationOverride.setName("FOO");
+		associationOverride = (AssociationOverrideAnnotation) typeResource.addAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		associationOverride.setName("BAR");
+
+		assertEquals(2, overrideContainer.specifiedAssociationOverridesSize());
+	}
+	
+	public void testDefaultAssociationOverridesSize() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		
+		assertEquals(4, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(3, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(1, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(0, overrideContainer.virtualAssociationOverridesSize());
+	}
+	
+	public void testAssociationOverridesSize() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		
+		assertEquals(4, overrideContainer.associationOverridesSize());
+
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(4, overrideContainer.associationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(4, overrideContainer.associationOverridesSize());
+		
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		AssociationOverrideAnnotation annotation = (AssociationOverrideAnnotation) typeResource.addAnnotation(0, JPA.ASSOCIATION_OVERRIDE, JPA.ASSOCIATION_OVERRIDES);
+		annotation.setName("bar");	
+		assertEquals(5, overrideContainer.associationOverridesSize());
+	}
+
+	public void testAssociationOverrideSetVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+				
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		Iterator<NestableAnnotation> associationOverrides = typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("address", ((AssociationOverrideAnnotation) associationOverrides.next()).getName());
+		assertEquals("address2", ((AssociationOverrideAnnotation) associationOverrides.next()).getName());
+		assertFalse(associationOverrides.hasNext());
+	}
+	
+	public void testAssociationOverrideSetVirtual2() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		
+		ListIterator<JavaAssociationOverride> virtualAssociationOverrides = overrideContainer.virtualAssociationOverrides();
+		virtualAssociationOverrides.next();
+		virtualAssociationOverrides.next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		Iterator<NestableAnnotation> associationOverrides = typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("address2", ((AssociationOverrideAnnotation) associationOverrides.next()).getName());
+		assertEquals("address", ((AssociationOverrideAnnotation) associationOverrides.next()).getName());
+		assertFalse(associationOverrides.hasNext());
+	}
+	
+	public void testAssociationOverrideSetVirtualTrue() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+				
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		assertEquals(2, CollectionTools.size(typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME)));
+
+		overrideContainer.specifiedAssociationOverrides().next().setVirtual(true);
+		
+		Iterator<NestableAnnotation> associationOverrideResources = typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("address2", ((AssociationOverrideAnnotation) associationOverrideResources.next()).getName());		
+		assertFalse(associationOverrideResources.hasNext());
+
+		Iterator<JavaAssociationOverride> associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("address2", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+
+		
+		overrideContainer.specifiedAssociationOverrides().next().setVirtual(true);
+		associationOverrideResources = typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(associationOverrideResources.hasNext());
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertFalse(associationOverrides.hasNext());
+
+		assertNull(typeResource.getAnnotation(AssociationOverridesAnnotation.ANNOTATION_NAME));
+	}
+	
+	public void testMoveSpecifiedAssociationOverride() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		
+		Iterator<NestableAnnotation> javaAssociationOverrides = typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals(2, CollectionTools.size(javaAssociationOverrides));
+		
+		
+		overrideContainer.moveSpecifiedAssociationOverride(1, 0);
+		ListIterator<AssociationOverride> associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("address2", associationOverrides.next().getName());
+		assertEquals("address", associationOverrides.next().getName());
+
+		javaAssociationOverrides = typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("address2", ((AssociationOverrideAnnotation) javaAssociationOverrides.next()).getName());
+		assertEquals("address", ((AssociationOverrideAnnotation) javaAssociationOverrides.next()).getName());
+
+
+		overrideContainer.moveSpecifiedAssociationOverride(0, 1);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("address", associationOverrides.next().getName());
+		assertEquals("address2", associationOverrides.next().getName());
+
+		javaAssociationOverrides = typeResource.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("address", ((AssociationOverrideAnnotation) javaAssociationOverrides.next()).getName());
+		assertEquals("address2", ((AssociationOverrideAnnotation) javaAssociationOverrides.next()).getName());
+	}
+
+	public void testUpdateSpecifiedAssociationOverrides() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+	
+		((AssociationOverrideAnnotation) typeResource.addAnnotation(0, AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME)).setName("FOO");
+		((AssociationOverrideAnnotation) typeResource.addAnnotation(1, AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME)).setName("BAR");
+		((AssociationOverrideAnnotation) typeResource.addAnnotation(2, AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME)).setName("BAZ");
+			
+		ListIterator<AssociationOverride> associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertEquals("BAR", associationOverrides.next().getName());
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+		
+		typeResource.moveAnnotation(2, 0, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAR", associationOverrides.next().getName());
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+	
+		typeResource.moveAnnotation(0, 1, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertEquals("BAR", associationOverrides.next().getName());
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+	
+		typeResource.removeAnnotation(1,  AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+	
+		typeResource.removeAnnotation(1,  AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+		
+		typeResource.removeAnnotation(0,  AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertFalse(associationOverrides.hasNext());
+	}
+
+	public void testAssociationOverrideIsVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		AssociationOverrideContainer overrideContainer = getJavaEntity().getAssociationOverrideContainer();
+		
+		ListIterator<JavaAssociationOverride> virtualAssociationOverrides = overrideContainer.virtualAssociationOverrides();	
+		AssociationOverride virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address2", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address3", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address4", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		assertFalse(virtualAssociationOverrides.hasNext());
+
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		AssociationOverride specifiedAssociationOverride = overrideContainer.specifiedAssociationOverrides().next();
+		assertFalse(specifiedAssociationOverride.isVirtual());
+		
+		
+		virtualAssociationOverrides = overrideContainer.virtualAssociationOverrides();	
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address2", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address3", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address4", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		assertFalse(virtualAssociationOverrides.hasNext());
+	}
+	
+	
+	public void testNestedVirtualAttributeOverrides() throws Exception {
+		createTestMappedSuperclassCustomer();
+		createTestEntityLongTimeCustomer();
+		createTestEmbeddableAddress();
+		createTestEmbeddableZipCode();
+		
+		addXmlClassRef(PACKAGE_NAME + ".Customer");
+		addXmlClassRef(PACKAGE_NAME + ".LongTimeCustomer");
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".ZipCode");
+		ListIterator<ClassRef> specifiedClassRefs = getPersistenceUnit().specifiedClassRefs();
+		PersistentType customerPersistentType = specifiedClassRefs.next().getJavaPersistentType();
+		PersistentType longTimeCustomerPersistentType = specifiedClassRefs.next().getJavaPersistentType();
+		PersistentType addressPersistentType = specifiedClassRefs.next().getJavaPersistentType();		
+		PersistentType zipCodePersistentType = specifiedClassRefs.next().getJavaPersistentType();
+
+		AttributeOverrideContainer attributeOverrideContainer = ((Entity) longTimeCustomerPersistentType.getMapping()).getAttributeOverrideContainer();
+		
+		assertEquals(7, attributeOverrideContainer.virtualAttributeOverridesSize());
+		ListIterator<AttributeOverride> virtualAttributeOverrides = attributeOverrideContainer.virtualAttributeOverrides();
+		AttributeOverride virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("name", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.street", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.city", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.state", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.zipCode.zip", virtualAttributeOverride.getName());
+		assertEquals("zip", virtualAttributeOverride.getColumn().getName());
+		assertEquals("LongTimeCustomer", virtualAttributeOverride.getColumn().getTable());		
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.zipCode.plusfour", virtualAttributeOverride.getName());
+		assertEquals("plusfour", virtualAttributeOverride.getColumn().getName());
+		assertEquals("LongTimeCustomer", virtualAttributeOverride.getColumn().getTable());	
+		assertEquals(null, virtualAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, virtualAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, virtualAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, virtualAttributeOverride.getColumn().isUnique());
+		assertEquals(true, virtualAttributeOverride.getColumn().isNullable());
+		assertEquals(255, virtualAttributeOverride.getColumn().getLength());
+		assertEquals(0, virtualAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, virtualAttributeOverride.getColumn().getScale());
+
+		
+		BasicMapping plusFourMapping = (BasicMapping) zipCodePersistentType.getAttributeNamed("plusfour").getMapping();
+		plusFourMapping.getColumn().setSpecifiedName("BLAH");
+		plusFourMapping.getColumn().setSpecifiedTable("BLAH_TABLE");
+		plusFourMapping.getColumn().setColumnDefinition("COLUMN_DEFINITION");
+		plusFourMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		plusFourMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		plusFourMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		plusFourMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		plusFourMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		plusFourMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		plusFourMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+
+		attributeOverrideContainer = ((Entity) longTimeCustomerPersistentType.getMapping()).getAttributeOverrideContainer();
+		//check the top-level embedded (Customer.address) attribute override to verify it is getting settings from the specified column on Zipcode.plusfour
+		virtualAttributeOverride = attributeOverrideContainer.getAttributeOverrideNamed("address.zipCode.plusfour");
+		assertEquals("address.zipCode.plusfour", virtualAttributeOverride.getName());
+		assertEquals("BLAH", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BLAH_TABLE", virtualAttributeOverride.getColumn().getTable());	
+		assertEquals("COLUMN_DEFINITION", virtualAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, virtualAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, virtualAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, virtualAttributeOverride.getColumn().isUnique());
+		assertEquals(false, virtualAttributeOverride.getColumn().isNullable());
+		assertEquals(5, virtualAttributeOverride.getColumn().getLength());
+		assertEquals(6, virtualAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, virtualAttributeOverride.getColumn().getScale());
+		
+		//set an attribute override on Address.zipCode embedded mapping
+		AttributeOverride specifiedAttributeOverride = ((EmbeddedMapping) addressPersistentType.getAttributeNamed("zipCode").getMapping()).getAttributeOverrideContainer().getAttributeOverrideNamed("plusfour").setVirtual(false);
+		specifiedAttributeOverride.getColumn().setSpecifiedName("BLAH_OVERRIDE");
+		specifiedAttributeOverride.getColumn().setSpecifiedTable("BLAH_TABLE_OVERRIDE");
+		specifiedAttributeOverride.getColumn().setColumnDefinition("COLUMN_DEFINITION_OVERRIDE");
+
+
+		attributeOverrideContainer = ((Entity) longTimeCustomerPersistentType.getMapping()).getAttributeOverrideContainer();
+		virtualAttributeOverride = attributeOverrideContainer.getAttributeOverrideNamed("address.zipCode.plusfour");
+		assertEquals("address.zipCode.plusfour", virtualAttributeOverride.getName());
+		assertEquals("BLAH_OVERRIDE", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BLAH_TABLE_OVERRIDE", virtualAttributeOverride.getColumn().getTable());	
+		assertEquals("COLUMN_DEFINITION_OVERRIDE", virtualAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, virtualAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, virtualAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, virtualAttributeOverride.getColumn().isUnique());
+		assertEquals(true, virtualAttributeOverride.getColumn().isNullable());
+		assertEquals(255, virtualAttributeOverride.getColumn().getLength());
+		assertEquals(0, virtualAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, virtualAttributeOverride.getColumn().getScale());
+		
+		specifiedAttributeOverride = virtualAttributeOverride.setVirtual(false);
+		assertEquals(false, specifiedAttributeOverride.isVirtual());
+		assertEquals("address.zipCode.plusfour", specifiedAttributeOverride.getName());
+		//TODO I have the default wrong in this case, but this was wrong before as well.  Need to fix this later
+//		assertEquals("plusfour", specifiedAttributeOverride.getColumn().getDefaultName());
+		assertEquals("BLAH_OVERRIDE", specifiedAttributeOverride.getColumn().getSpecifiedName());
+//		assertEquals("Customer", specifiedAttributeOverride.getColumn().getDefaultTable());	
+		assertEquals(null, specifiedAttributeOverride.getColumn().getSpecifiedTable());	
+		assertEquals(null, specifiedAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, specifiedAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, specifiedAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, specifiedAttributeOverride.getColumn().isUnique());
+		assertEquals(true, specifiedAttributeOverride.getColumn().isNullable());
+		assertEquals(255, specifiedAttributeOverride.getColumn().getLength());
+		assertEquals(0, specifiedAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, specifiedAttributeOverride.getColumn().getScale());
+	}
+	
+	public void testSetSpecifiedCacheable() throws Exception {
+		ICompilationUnit cu = createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
+		Cacheable2_0Annotation cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);
+		assertEquals(null, cacheable.getSpecifiedCacheable());
+		assertEquals(null, cacheableAnnotation);
+		
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
+		assertEquals(Boolean.FALSE, cacheable.getSpecifiedCacheable());
+		assertEquals(Boolean.FALSE, cacheableAnnotation.getValue());
+		assertSourceContains("@Cacheable(false)", cu);
+		
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
+		assertEquals(null, cacheableAnnotation.getValue());
+		assertSourceContains("@Cacheable", cu);
+		
+		cacheable.setSpecifiedCacheable(null);
+		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
+		assertEquals(null, cacheable.getSpecifiedCacheable());
+		assertEquals(null, cacheableAnnotation);
+		assertSourceDoesNotContain("@Cacheable", cu);
+	}
+	
+	public void testGetSpecifiedCacheable() throws Exception {
+		ICompilationUnit cu = createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
+		Cacheable2_0Annotation cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);
+		assertEquals(null, cacheable.getSpecifiedCacheable());
+		assertEquals(null, cacheableAnnotation);
+		
+		getJavaPersistentType().getResourcePersistentType().addAnnotation(JPA2_0.CACHEABLE);
+		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
+		assertEquals(null, cacheableAnnotation.getValue());
+		assertSourceContains("@Cacheable", cu);
+
+		cacheableAnnotation.setValue(Boolean.FALSE);
+		assertEquals(Boolean.FALSE, cacheable.getSpecifiedCacheable());
+		assertEquals(Boolean.FALSE, cacheableAnnotation.getValue());
+		assertSourceContains("@Cacheable(false)", cu);
+		
+		cacheableAnnotation.setValue(Boolean.TRUE);
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, cacheableAnnotation.getValue());
+		assertSourceContains("@Cacheable(true)", cu);
+		
+		cacheableAnnotation.setValue(null);
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
+		assertEquals(null, cacheableAnnotation.getValue());
+		assertSourceContains("@Cacheable", cu);
+
+		getJavaPersistentType().getResourcePersistentType().removeAnnotation(JPA2_0.CACHEABLE);
+		cacheableAnnotation = (Cacheable2_0Annotation) getJavaPersistentType().getResourcePersistentType().getAnnotation(JPA2_0.CACHEABLE);		
+		assertEquals(null,  cacheable.getSpecifiedCacheable());
+		assertEquals(null, cacheableAnnotation);
+		assertSourceDoesNotContain("@Cacheable", cu);
+	}
+	
+	public void testIsDefaultCacheable() throws Exception {
+		createTestEntity();
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
+		PersistenceUnit2_0 persistenceUnit = (PersistenceUnit2_0) getPersistenceUnit();
+		assertEquals(SharedCacheMode.DISABLE_SELECTIVE, persistenceUnit.getSharedCacheMode());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit.setSpecifiedSharedCacheMode(SharedCacheMode.ALL);
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
+		assertEquals(false, cacheable.isDefaultCacheable());
+
+		persistenceUnit.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
+		assertEquals(false, cacheable.isDefaultCacheable());
+
+		persistenceUnit.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit.setSpecifiedSharedCacheMode(SharedCacheMode.UNSPECIFIED);
+		assertEquals(true, cacheable.isDefaultCacheable());
+	}
+	
+	public void testInheritedIsDefaultCacheable() throws Exception {
+		createTestEntity();
+		createTestSubType();
+		addXmlClassRef(FULLY_QUALIFIED_SUB_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 subCacheable = ((CacheableHolder2_0) getJavaEntity()).getCacheable();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) getJavaEntity().getParentEntity()).getCacheable();
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+
+		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(null);
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+				
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+		
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+		
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+	}
+}
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/JptEclipseLink2_0JavaContextModelTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/JptEclipseLink2_0JavaContextModelTests.java
index 7f4dd87d23..fca290edc9 100644
--- a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/JptEclipseLink2_0JavaContextModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/JptEclipseLink2_0JavaContextModelTests.java
@@ -17,6 +17,7 @@ public class JptEclipseLink2_0JavaContextModelTests extends TestCase
 {
 	public static Test suite() {
 		TestSuite suite = new TestSuite(JptEclipseLink2_0JavaContextModelTests.class.getName());
+		suite.addTestSuite(EclipseLink2_0JavaEntityTests.class);
 		suite.addTestSuite(EclipseLink2_0JavaManyToOneMappingTests.class);
 		suite.addTestSuite(EclipseLink2_0JavaOneToOneMappingTests.class);
 		suite.addTestSuite(EclipseLink2_0JavaOneToManyMappingTests.class);
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/orm/EclipseLink2_0OrmEntityTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/orm/EclipseLink2_0OrmEntityTests.java
new file mode 100644
index 0000000000..c1985db329
--- /dev/null
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/orm/EclipseLink2_0OrmEntityTests.java
@@ -0,0 +1,1567 @@
+/*******************************************************************************
+ * Copyright (c) 2009 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.eclipselink2_0.core.tests.internal.context.orm;
+
+import java.util.Iterator;
+import java.util.ListIterator;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.core.MappingKeys;
+import org.eclipse.jpt.core.context.AssociationOverride;
+import org.eclipse.jpt.core.context.AssociationOverrideContainer;
+import org.eclipse.jpt.core.context.AttributeOverride;
+import org.eclipse.jpt.core.context.AttributeOverrideContainer;
+import org.eclipse.jpt.core.context.BasicMapping;
+import org.eclipse.jpt.core.context.EmbeddedMapping;
+import org.eclipse.jpt.core.context.Entity;
+import org.eclipse.jpt.core.context.InheritanceType;
+import org.eclipse.jpt.core.context.orm.OrmAssociationOverride;
+import org.eclipse.jpt.core.context.orm.OrmAttributeOverride;
+import org.eclipse.jpt.core.context.orm.OrmEntity;
+import org.eclipse.jpt.core.context.orm.OrmMappedSuperclass;
+import org.eclipse.jpt.core.context.orm.OrmPersistentType;
+import org.eclipse.jpt.core.jpa2.context.Cacheable2_0;
+import org.eclipse.jpt.core.jpa2.context.CacheableHolder2_0;
+import org.eclipse.jpt.core.jpa2.context.persistence.PersistenceUnit2_0;
+import org.eclipse.jpt.core.jpa2.context.persistence.options.SharedCacheMode;
+import org.eclipse.jpt.core.resource.java.JPA;
+import org.eclipse.jpt.core.resource.orm.OrmFactory;
+import org.eclipse.jpt.core.resource.orm.XmlAssociationOverride;
+import org.eclipse.jpt.core.resource.orm.XmlEntity;
+import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter;
+import org.eclipse.jpt.eclipselink.core.context.EclipseLinkEntity;
+import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
+
+@SuppressWarnings("nls")
+public class EclipseLink2_0OrmEntityTests extends EclipseLink2_0OrmContextModelTestCase
+{
+	protected static final String SUB_TYPE_NAME = "AnnotationTestTypeChild";
+	protected static final String FULLY_QUALIFIED_SUB_TYPE_NAME = PACKAGE_NAME + "." + SUB_TYPE_NAME;
+	
+	
+	public EclipseLink2_0OrmEntityTests(String name) {
+		super(name);
+	}
+
+	private ICompilationUnit createTestEntity() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity");
+			}
+		});
+	}
+
+	private ICompilationUnit createTestMappedSuperclass() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.MAPPED_SUPERCLASS, JPA.ONE_TO_ONE, JPA.MANY_TO_ONE, JPA.ONE_TO_MANY, JPA.MANY_TO_MANY);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@MappedSuperclass");
+			}
+			
+			@Override
+			public void appendGetIdMethodAnnotationTo(StringBuilder sb) {
+				sb.append("private String foo;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToOne");
+				sb.append(CR);
+				sb.append("    private int address;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToOne");
+				sb.append(CR);
+				sb.append("    private int address2;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToMany");
+				sb.append(CR);
+				sb.append("    private int address3;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToMany");
+				sb.append(CR);
+				sb.append("    private int address4;").append(CR);
+				sb.append(CR);
+				sb.append("    ");
+			}
+		});
+	}
+	
+	private ICompilationUnit createTestAbstractEntityTablePerClass() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.INHERITANCE, JPA.INHERITANCE_TYPE, JPA.ONE_TO_ONE, JPA.MANY_TO_ONE, JPA.ONE_TO_MANY, JPA.MANY_TO_MANY);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+				sb.append("@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)");
+				sb.append("abstract");
+			}
+			
+			@Override
+			public void appendGetIdMethodAnnotationTo(StringBuilder sb) {
+				sb.append("private String foo;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToOne");
+				sb.append(CR);
+				sb.append("    private int address;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToOne");
+				sb.append(CR);
+				sb.append("    private int address2;").append(CR);
+				sb.append(CR);
+				sb.append("    @OneToMany");
+				sb.append(CR);
+				sb.append("    private int address3;").append(CR);
+				sb.append(CR);
+				sb.append("    @ManyToMany");
+				sb.append(CR);
+				sb.append("    private int address4;").append(CR);
+				sb.append(CR);
+				sb.append("    ");
+			}
+		});
+	}
+
+	private void createTestSubType() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("AnnotationTestTypeChild").append(" ");
+				sb.append("extends " + TYPE_NAME + " ");
+				sb.append("{}").append(CR);
+			}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "AnnotationTestTypeChild.java", sourceWriter);
+	}
+	
+	private void createTestMappedSuperclassCustomer() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.MAPPED_SUPERCLASS);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@MappedSuperclass");
+				sb.append(CR);
+				sb.append("public class ").append("Customer ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    @Id").append(CR);
+				sb.append("    private String id;").append(CR);
+				sb.append(CR);
+				sb.append("    private String name;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private Address address;").append(CR);
+				sb.append(CR);
+			sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Customer.java", sourceWriter);
+	}
+	
+	private void createTestEntityLongTimeCustomer() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("LongTimeCustomer extends Customer ");
+				sb.append("{}");
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "LongTimeCustomer.java", sourceWriter);
+	}
+
+
+	private void createTestEmbeddableAddress() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("Address").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String street;").append(CR);
+				sb.append(CR);
+				sb.append("    private String city;").append(CR);
+				sb.append(CR);
+				sb.append("    private String state;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private ZipCode zipCode;").append(CR);
+				sb.append(CR);
+			sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+	}
+	
+	private void createTestEmbeddableZipCode() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("ZipCode").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String zip;").append(CR);
+				sb.append(CR);
+				sb.append("    private String plusfour;").append(CR);
+				sb.append(CR);
+			sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "ZipCode.java", sourceWriter);
+	}
+
+	public void testAttributeMappingKeyAllowed() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		OrmEntity entity = (OrmEntity) ormPersistentType.getMapping();
+
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ID_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY));
+		assertTrue(entity.attributeMappingKeyAllowed(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY));
+	}
+	
+	public void testOverridableAttributes() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity entity = (OrmEntity) ormPersistentType.getMapping();
+	
+		Iterator<String> overridableAttributes = entity.overridableAttributeNames();
+		assertFalse(overridableAttributes.hasNext());
+		
+		
+		entity.setSpecifiedInheritanceStrategy(InheritanceType.TABLE_PER_CLASS);
+		
+		overridableAttributes = entity.overridableAttributeNames();		
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+	}
+
+	public void testOverridableAttributeNames() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity entity = (OrmEntity) ormPersistentType.getMapping();
+	
+		Iterator<String> overridableAttributeNames = entity.overridableAttributeNames();
+		assertFalse(overridableAttributeNames.hasNext());
+		
+		
+		entity.setSpecifiedInheritanceStrategy(InheritanceType.TABLE_PER_CLASS);
+		
+		overridableAttributeNames = entity.overridableAttributeNames();
+		assertEquals("id", overridableAttributeNames.next());
+		assertEquals("name", overridableAttributeNames.next());
+		assertFalse(overridableAttributeNames.hasNext());
+	}
+
+	public void testAllOverridableAttributes() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+	
+		Iterator<String> overridableAttributes = getJavaEntity().allOverridableAttributeNames();
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertEquals("foo", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+	}
+	
+	public void testAllOverridableAttributesTablePerClass() throws Exception {
+		createTestAbstractEntityTablePerClass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+	
+		Iterator<String> overridableAttributes = ormEntity.allOverridableAttributeNames();
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertEquals("foo", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+		
+		
+		OrmEntity abstractEntity = (OrmEntity) ormEntity.getParentEntity();
+		overridableAttributes = abstractEntity.allOverridableAttributeNames();
+		assertEquals("id", overridableAttributes.next());
+		assertEquals("name", overridableAttributes.next());
+		assertEquals("foo", overridableAttributes.next());
+		assertFalse(overridableAttributes.hasNext());
+	}
+	
+	public void testAllOverridableAssociationsTablePerClass() throws Exception {
+		createTestAbstractEntityTablePerClass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+	
+		Iterator<String> overridableAssociations = ormEntity.allOverridableAssociationNames();
+		assertEquals("address", overridableAssociations.next());
+		assertEquals("address2", overridableAssociations.next());
+		assertEquals("address3", overridableAssociations.next());
+		assertEquals("address4", overridableAssociations.next());
+		assertFalse(overridableAssociations.hasNext());
+		
+		
+		OrmEntity abstractEntity = (OrmEntity) ormEntity.getParentEntity();
+		overridableAssociations = abstractEntity.allOverridableAssociationNames();
+		assertEquals("address", overridableAssociations.next());
+		assertEquals("address2", overridableAssociations.next());
+		assertEquals("address3", overridableAssociations.next());
+		assertEquals("address4", overridableAssociations.next());
+		assertFalse(overridableAssociations.hasNext());
+	}
+//TODO
+//	public void testAllOverridableAttributesMappedSuperclassInOrmXml() throws Exception {
+//		createTestMappedSuperclass();
+//		createTestSubType();
+//		addXmlClassRef(PACKAGE_NAME + ".AnnotationTestTypeChild");
+//		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+//		
+//		Iterator<PersistentAttribute> overridableAttributes = getJavaEntity().allOverridableAttributes();
+//		assertEquals("id", overridableAttributes.next().getName());
+//		assertEquals("name", overridableAttributes.next().getName());
+//		assertEquals("foo", overridableAttributes.next().getName());
+//		assertFalse(overridableAttributes.hasNext());
+//	}
+
+	public void testAllOverridableAttributeNames() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+	
+		Iterator<String> overridableAttributeNames = ormEntity.allOverridableAttributeNames();
+		assertEquals("id", overridableAttributeNames.next());
+		assertEquals("name", overridableAttributeNames.next());
+		assertEquals("foo", overridableAttributeNames.next());
+		assertFalse(overridableAttributeNames.hasNext());
+	}
+		
+	public void testSpecifiedAttributeOverrides() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity entity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = entity.getAttributeOverrideContainer();
+		
+		ListIterator<OrmAttributeOverride> specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+
+		//add an annotation to the resource model and verify the context model is updated
+		entityResource.getAttributeOverrides().add(0, OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(0).setName("FOO");
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		entityResource.getAttributeOverrides().add(1, OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(1).setName("BAR");
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+
+		entityResource.getAttributeOverrides().add(0, OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(0).setName("BAZ");
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+	
+		//move an annotation to the resource model and verify the context model is updated
+		entityResource.getAttributeOverrides().move(1, 0);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		entityResource.getAttributeOverrides().remove(0);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+	
+		entityResource.getAttributeOverrides().remove(0);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		
+		entityResource.getAttributeOverrides().remove(0);
+		specifiedAttributeOverrides = overrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedAttributeOverrides.hasNext());
+	}
+
+	public void testDefaultAttributeOverrides() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(0, entityResource.getAttributeOverrides().size());
+		
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+
+		OrmMappedSuperclass mappedSuperclass = (OrmMappedSuperclass) ormEntity.getPersistentType().getSuperPersistentType().getMapping();
+		
+		mappedSuperclass.getPersistentType().getAttributeNamed("id").makeSpecified();
+		BasicMapping idMapping = (BasicMapping) mappedSuperclass.getPersistentType().getAttributeNamed("id").getMapping();
+		idMapping.getColumn().setSpecifiedName("FOO");
+		idMapping.getColumn().setSpecifiedTable("BAR");
+		
+		assertEquals(0, entityResource.getAttributeOverrides().size());
+
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("FOO", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BAR", virtualAttributeOverride.getColumn().getTable());
+
+		idMapping.getColumn().setSpecifiedName(null);
+		idMapping.getColumn().setSpecifiedTable(null);
+		assertEquals(0, entityResource.getAttributeOverrides().size());
+
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+		virtualAttributeOverride = virtualAttributeOverride.setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testDefaultAttributeOverridesEntityHierachy() throws Exception {
+		createTestAbstractEntityTablePerClass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(0, entityResource.getAttributeOverrides().size());
+
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+
+		OrmEntity superclass = (OrmEntity) ormEntity.getParentEntity();
+		
+		superclass.getPersistentType().getAttributeNamed("id").makeSpecified();
+		BasicMapping idMapping = (BasicMapping) superclass.getPersistentType().getAttributeNamed("id").getMapping();
+		idMapping.getColumn().setSpecifiedName("FOO");
+		idMapping.getColumn().setSpecifiedTable("BAR");
+		
+		assertEquals(0, entityResource.getAttributeOverrides().size());
+
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("FOO", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BAR", virtualAttributeOverride.getColumn().getTable());
+
+		idMapping.getColumn().setSpecifiedName(null);
+		idMapping.getColumn().setSpecifiedTable(null);
+		assertEquals(0, entityResource.getAttributeOverrides().size());
+
+		virtualAttributeOverride = overrideContainer.virtualAttributeOverrides().next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertEquals("id", virtualAttributeOverride.getColumn().getName());
+		assertEquals(SUB_TYPE_NAME, virtualAttributeOverride.getColumn().getTable());
+		
+		virtualAttributeOverride = virtualAttributeOverride.setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+		
+		assertEquals(0, overrideContainer.specifiedAttributeOverridesSize());
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+
+		//add an annotation to the resource model and verify the context model is updated
+		entityResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(0).setName("FOO");
+		entityResource.getAttributeOverrides().add(OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(0).setName("BAR");
+
+		assertEquals(2, overrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testDefaultAttributeOverridesSize() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+		
+		assertEquals(3, overrideContainer.virtualAttributeOverridesSize());
+
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAttributeOverridesSize());
+		
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(1, overrideContainer.virtualAttributeOverridesSize());
+		
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(0, overrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testAttributeOverridesSize() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+		
+		assertEquals(3, overrideContainer.attributeOverridesSize());
+
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(3, overrideContainer.attributeOverridesSize());
+		
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		assertEquals(3, overrideContainer.attributeOverridesSize());
+		
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		entityResource.getAttributeOverrides().add(0, OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(0).setName("bar");
+		assertEquals(4, overrideContainer.attributeOverridesSize());
+	}
+
+	public void testAttributeOverrideSetVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+			
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+				
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		
+		assertEquals("id", entityResource.getAttributeOverrides().get(0).getName());		
+		assertEquals("name", entityResource.getAttributeOverrides().get(1).getName());		
+		assertEquals(2, entityResource.getAttributeOverrides().size());
+	}
+	
+	public void testAttributeOverrideSetVirtual2() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+		
+		ListIterator<OrmAttributeOverride> virtualAttributeOverrides = overrideContainer.virtualAttributeOverrides();
+		virtualAttributeOverrides.next();
+		virtualAttributeOverrides.next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		
+		assertEquals("name", entityResource.getAttributeOverrides().get(0).getName());
+		assertEquals("id", entityResource.getAttributeOverrides().get(1).getName());		
+		assertEquals(2, entityResource.getAttributeOverrides().size());
+	}
+	
+	public void testAttributeOverrideSetVirtualTrue() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+				
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(3, entityResource.getAttributeOverrides().size());
+
+		overrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		
+		assertEquals("name", entityResource.getAttributeOverrides().get(0).getName());		
+		assertEquals("foo", entityResource.getAttributeOverrides().get(1).getName());
+		assertEquals(2, entityResource.getAttributeOverrides().size());
+		
+		Iterator<OrmAttributeOverride> attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("name", attributeOverrides.next().getName());		
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		
+		overrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		assertEquals("foo", entityResource.getAttributeOverrides().get(0).getName());		
+		assertEquals(1, entityResource.getAttributeOverrides().size());
+
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+
+		
+		overrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		assertEquals(0, entityResource.getAttributeOverrides().size());
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertFalse(attributeOverrides.hasNext());
+	}
+	
+	public void testMoveSpecifiedAttributeOverride() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		
+		assertEquals(3, entityResource.getAttributeOverrides().size());
+		
+		
+		overrideContainer.moveSpecifiedAttributeOverride(2, 0);
+		ListIterator<OrmAttributeOverride> attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("name", attributeOverrides.next().getName());
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertEquals("id", attributeOverrides.next().getName());
+
+		assertEquals("name", entityResource.getAttributeOverrides().get(0).getName());
+		assertEquals("foo", entityResource.getAttributeOverrides().get(1).getName());
+		assertEquals("id", entityResource.getAttributeOverrides().get(2).getName());
+
+
+		overrideContainer.moveSpecifiedAttributeOverride(0, 1);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("foo", attributeOverrides.next().getName());
+		assertEquals("name", attributeOverrides.next().getName());
+		assertEquals("id", attributeOverrides.next().getName());
+
+		assertEquals("foo", entityResource.getAttributeOverrides().get(0).getName());
+		assertEquals("name", entityResource.getAttributeOverrides().get(1).getName());
+		assertEquals("id", entityResource.getAttributeOverrides().get(2).getName());
+	}
+	
+	public void testUpdateSpecifiedAttributeOverrides() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+	
+		entityResource.getAttributeOverrides().add(0, OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(0).setName("FOO");
+		entityResource.getAttributeOverrides().add(1, OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(1).setName("BAR");
+		entityResource.getAttributeOverrides().add(2, OrmFactory.eINSTANCE.createXmlAttributeOverride());
+		entityResource.getAttributeOverrides().get(2).setName("BAZ");
+			
+		ListIterator<OrmAttributeOverride> attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertEquals("BAR", attributeOverrides.next().getName());
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		entityResource.getAttributeOverrides().move(2, 0);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAR", attributeOverrides.next().getName());
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		entityResource.getAttributeOverrides().move(0, 1);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertEquals("BAR", attributeOverrides.next().getName());
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		entityResource.getAttributeOverrides().remove(1);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertEquals("FOO", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+	
+		entityResource.getAttributeOverrides().remove(1);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertEquals("BAZ", attributeOverrides.next().getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		entityResource.getAttributeOverrides().remove(0);
+		attributeOverrides = overrideContainer.specifiedAttributeOverrides();
+		assertFalse(attributeOverrides.hasNext());
+	}
+
+	public void testAttributeOverrideIsVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AttributeOverrideContainer overrideContainer = ormEntity.getAttributeOverrideContainer();
+		
+		ListIterator<OrmAttributeOverride> virtualAttributeOverrides = overrideContainer.virtualAttributeOverrides();	
+		AttributeOverride virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("name", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("foo", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		assertFalse(virtualAttributeOverrides.hasNext());
+
+		overrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		AttributeOverride specifiedAttributeOverride = overrideContainer.specifiedAttributeOverrides().next();
+		assertFalse(specifiedAttributeOverride.isVirtual());
+		
+		
+		virtualAttributeOverrides = overrideContainer.virtualAttributeOverrides();	
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("name", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("foo", virtualAttributeOverride.getName());
+		assertTrue(virtualAttributeOverride.isVirtual());
+		assertFalse(virtualAttributeOverrides.hasNext());
+	}
+
+	public void testOverridableAssociationNames() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		OrmEntity entity = (OrmEntity) ormPersistentType.getMapping();
+
+		Iterator<String> overridableAssociationNames = entity.overridableAssociationNames();
+		assertFalse(overridableAssociationNames.hasNext());
+	}
+	
+//	//TODO add all mapping types to the mapped superclass to test which ones are overridable
+	public void testAllOverridableAssociationNames() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+
+		Iterator<String> overridableAssociationNames = ormEntity.allOverridableAssociationNames();
+		assertEquals("address", overridableAssociationNames.next());
+		assertEquals("address2", overridableAssociationNames.next());
+		assertEquals("address3", overridableAssociationNames.next());
+		assertEquals("address4", overridableAssociationNames.next());
+		assertFalse(overridableAssociationNames.hasNext());
+	}
+	
+	public void testAllOverridableAssociations() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+	
+		Iterator<String> overridableAssociations = ormEntity.allOverridableAssociationNames();
+		assertEquals("address", overridableAssociations.next());
+		assertEquals("address2", overridableAssociations.next());
+		assertEquals("address3", overridableAssociations.next());
+		assertEquals("address4", overridableAssociations.next());
+		assertFalse(overridableAssociations.hasNext());
+	}
+
+	public void testSpecifiedAssociationOverrides() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+		
+		ListIterator<OrmAssociationOverride> specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();
+		
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+
+		//add an annotation to the resource model and verify the context model is updated
+		XmlAssociationOverride xmlAssociationOverride = OrmFactory.eINSTANCE.createXmlAssociationOverride();
+		entityResource.getAssociationOverrides().add(0, xmlAssociationOverride);
+		xmlAssociationOverride.setName("FOO");
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		xmlAssociationOverride = OrmFactory.eINSTANCE.createXmlAssociationOverride();
+		entityResource.getAssociationOverrides().add(1, xmlAssociationOverride);
+		xmlAssociationOverride.setName("BAR");
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+
+		xmlAssociationOverride = OrmFactory.eINSTANCE.createXmlAssociationOverride();
+		entityResource.getAssociationOverrides().add(0, xmlAssociationOverride);
+		xmlAssociationOverride.setName("BAZ");
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("BAZ", specifiedAssociationOverrides.next().getName());
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+	
+		//move an annotation to the resource model and verify the context model is updated
+		entityResource.getAssociationOverrides().move(1, 0);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("FOO", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAZ", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		entityResource.getAssociationOverrides().remove(0);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("BAZ", specifiedAssociationOverrides.next().getName());
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+	
+		entityResource.getAssociationOverrides().remove(0);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertEquals("BAR", specifiedAssociationOverrides.next().getName());
+		assertFalse(specifiedAssociationOverrides.hasNext());
+
+		
+		entityResource.getAssociationOverrides().remove(0);
+		specifiedAssociationOverrides = overrideContainer.specifiedAssociationOverrides();		
+		assertFalse(specifiedAssociationOverrides.hasNext());
+	}
+
+	public void testDefaultAssociationOverrides() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(FULLY_QUALIFIED_SUB_TYPE_NAME, entityResource.getClassName());
+		assertTrue(entityResource.getAssociationOverrides().isEmpty());
+		
+		assertEquals(4, overrideContainer.virtualAssociationOverridesSize());
+		AssociationOverride virtualAssociationOverride = overrideContainer.virtualAssociationOverrides().next();
+		assertEquals("address", virtualAssociationOverride.getName());
+		
+//
+//		//MappedSuperclass mappedSuperclass = (MappedSuperclass) javaPersistentType().getMapping();
+//		//BasicMapping idMapping = (BasicMapping) mappedSuperclass.persistentType().attributeNamed("id").getMapping();
+//		//idMapping.getColumn().setSpecifiedName("FOO");
+//		//idMapping.getColumn().setSpecifiedTable("BAR");
+//		
+//		assertEquals(SUB_TYPE_NAME, entityResource.getName());
+//		assertNull(typeResource.getAnnotation(AssociationOverrideAnnotation.ANNOTATION_NAME));
+//		assertNull(typeResource.getAnnotation(AssociationOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, overrideContainer.virtualAssociationOverridesSize());
+		virtualAssociationOverride = overrideContainer.virtualAssociationOverrides().next();
+		assertEquals("address", virtualAssociationOverride.getName());
+
+//		//idMapping.getColumn().setSpecifiedName(null);
+//		//idMapping.getColumn().setSpecifiedTable(null);
+//		assertEquals(SUB_TYPE_NAME, typeResource.getName());
+//		assertNull(typeResource.getAnnotation(AssociationOverrideAnnotation.ANNOTATION_NAME));
+//		assertNull(typeResource.getAnnotation(AssociationOverridesAnnotation.ANNOTATION_NAME));
+
+		virtualAssociationOverride = overrideContainer.virtualAssociationOverrides().next();
+		assertEquals("address", virtualAssociationOverride.getName());
+		
+		virtualAssociationOverride = virtualAssociationOverride.setVirtual(false);
+		assertEquals(3, overrideContainer.virtualAssociationOverridesSize());
+		
+		
+		
+//		//TODO joinColumns for default association overrides
+////	IJoinColumn defaultJoinColumn = defaultAssociationOverride.joinColumns().next();
+////	assertEquals("address", defaultJoinColumn.getName());
+////	assertEquals("address", defaultJoinColumn.getReferencedColumnName());
+////	assertEquals(SUB_TYPE_NAME, defaultJoinColumn.getTable());
+////	
+////
+////	IMappedSuperclass mappedSuperclass = (IMappedSuperclass) javaPersistentType().getMapping();
+////	
+////	IOneToOneMapping addressMapping = (IOneToOneMapping) mappedSuperclass.persistentType().attributeNamed("address").getMapping();
+////	IJoinColumn joinColumn = addressMapping.addSpecifiedJoinColumn(0);
+////	joinColumn.setSpecifiedName("FOO");
+////	joinColumn.setSpecifiedReferencedColumnName("BAR");
+////	joinColumn.setSpecifiedTable("BAZ");
+////	
+////	assertEquals(SUB_TYPE_NAME, typeResource.getName());
+////	assertNull(typeResource.annotation(AssociationOverride.ANNOTATION_NAME));
+////	assertNull(typeResource.annotation(AssociationOverrides.ANNOTATION_NAME));
+////
+////	assertEquals(1, CollectionTools.size(javaEntity.defaultAssociationOverrides()));
+////	defaultAssociationOverride = javaEntity.defaultAssociationOverrides().next();
+////	assertEquals("address", defaultAssociationOverride.getName());
+////	assertEquals("FOO", defaultJoinColumn.getName());
+////	assertEquals("BAR", defaultJoinColumn.getReferencedColumnName());
+////	assertEquals("BAZ", defaultJoinColumn.getTable());
+////
+////	joinColumn.setSpecifiedName(null);
+////	joinColumn.setSpecifiedReferencedColumnName(null);
+////	joinColumn.setSpecifiedTable(null);
+////	assertEquals(SUB_TYPE_NAME, typeResource.getName());
+////	assertNull(typeResource.annotation(AssociationOverride.ANNOTATION_NAME));
+////	assertNull(typeResource.annotation(AssociationOverrides.ANNOTATION_NAME));
+////
+////	defaultAssociationOverride = javaEntity.defaultAssociationOverrides().next();
+////	assertEquals("address", defaultJoinColumn.getName());
+////	assertEquals("address", defaultJoinColumn.getReferencedColumnName());
+////	assertEquals(SUB_TYPE_NAME, defaultJoinColumn.getTable());
+////	
+////	javaEntity.addSpecifiedAssociationOverride(0).setName("address");
+////	assertEquals(0, CollectionTools.size(javaEntity.defaultAssociationOverrides()));
+
+	}
+	
+	public void testSpecifiedAssociationOverridesSize() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		
+		assertEquals(0, overrideContainer.specifiedAssociationOverridesSize());
+
+		//add to the resource model and verify the context model is updated
+		entityResource.getAssociationOverrides().add(OrmFactory.eINSTANCE.createXmlAssociationOverride());
+		entityResource.getAssociationOverrides().get(0).setName("FOO");
+		entityResource.getAssociationOverrides().add(0, OrmFactory.eINSTANCE.createXmlAssociationOverride());
+		entityResource.getAssociationOverrides().get(0).setName("BAR");
+
+		assertEquals(2, overrideContainer.specifiedAssociationOverridesSize());
+	}
+	
+	public void testDefaultAssociationOverridesSize() throws Exception {		
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+		
+		assertEquals(4, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(3, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(2, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(1, overrideContainer.virtualAssociationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(0, overrideContainer.virtualAssociationOverridesSize());
+	}
+	
+	public void testAssociationOverridesSize() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+		
+		assertEquals(4, overrideContainer.associationOverridesSize());
+
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(4, overrideContainer.associationOverridesSize());
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		assertEquals(4, overrideContainer.associationOverridesSize());
+		
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		entityResource.getAssociationOverrides().add(0, OrmFactory.eINSTANCE.createXmlAssociationOverride());
+		entityResource.getAssociationOverrides().get(0).setName("bar");
+		assertEquals(5, overrideContainer.associationOverridesSize());
+	}
+
+	public void testAssociationOverrideSetVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+				
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		
+		assertEquals("address", entityResource.getAssociationOverrides().get(0).getName());
+		assertEquals("address2", entityResource.getAssociationOverrides().get(1).getName());
+		assertEquals(2, entityResource.getAssociationOverrides().size());
+	}
+	
+	public void testAssociationOverrideSetVirtual2() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+		
+		ListIterator<OrmAssociationOverride> virtualAssociationOverrides = overrideContainer.virtualAssociationOverrides();
+		virtualAssociationOverrides.next();
+		virtualAssociationOverrides.next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		
+		assertEquals("address2", entityResource.getAssociationOverrides().get(0).getName());
+		assertEquals("address", entityResource.getAssociationOverrides().get(1).getName());
+		assertEquals(2, entityResource.getAssociationOverrides().size());
+	}
+	
+	public void testAssociationOverrideSetVirtualTrue() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+				
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(2, entityResource.getAssociationOverrides().size());
+
+		overrideContainer.specifiedAssociationOverrides().next().setVirtual(true);
+		
+		assertEquals("address2", entityResource.getAssociationOverrides().get(0).getName());
+		assertEquals(1, entityResource.getAssociationOverrides().size());
+
+		Iterator<OrmAssociationOverride> associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("address2", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+
+		
+		overrideContainer.specifiedAssociationOverrides().next().setVirtual(true);
+		assertEquals(0, entityResource.getAssociationOverrides().size());
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertFalse(associationOverrides.hasNext());
+	}
+	
+	public void testMoveSpecifiedAssociationOverride() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+		
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(2, entityResource.getAssociationOverrides().size());
+		
+		
+		overrideContainer.moveSpecifiedAssociationOverride(1, 0);
+		ListIterator<OrmAssociationOverride> associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("address2", associationOverrides.next().getName());
+		assertEquals("address", associationOverrides.next().getName());
+
+		assertEquals("address2", entityResource.getAssociationOverrides().get(0).getName());
+		assertEquals("address", entityResource.getAssociationOverrides().get(1).getName());
+
+
+		overrideContainer.moveSpecifiedAssociationOverride(0, 1);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("address", associationOverrides.next().getName());
+		assertEquals("address2", associationOverrides.next().getName());
+
+		assertEquals("address", entityResource.getAssociationOverrides().get(0).getName());
+		assertEquals("address2", entityResource.getAssociationOverrides().get(1).getName());
+	}
+
+	public void testUpdateSpecifiedAssociationOverrides() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		
+		entityResource.getAssociationOverrides().add(0, OrmFactory.eINSTANCE.createXmlAssociationOverride());
+		entityResource.getAssociationOverrides().get(0).setName("FOO");
+		entityResource.getAssociationOverrides().add(1, OrmFactory.eINSTANCE.createXmlAssociationOverride());
+		entityResource.getAssociationOverrides().get(1).setName("BAR");
+		entityResource.getAssociationOverrides().add(2, OrmFactory.eINSTANCE.createXmlAssociationOverride());
+		entityResource.getAssociationOverrides().get(2).setName("BAZ");
+			
+		ListIterator<OrmAssociationOverride> associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertEquals("BAR", associationOverrides.next().getName());
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+		
+		entityResource.getAssociationOverrides().move(2, 0);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAR", associationOverrides.next().getName());
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+	
+		entityResource.getAssociationOverrides().move(0, 1);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertEquals("BAR", associationOverrides.next().getName());
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+	
+		entityResource.getAssociationOverrides().remove(1);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertEquals("FOO", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+	
+		entityResource.getAssociationOverrides().remove(1);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertEquals("BAZ", associationOverrides.next().getName());
+		assertFalse(associationOverrides.hasNext());
+		
+		entityResource.getAssociationOverrides().remove(0);
+		associationOverrides = overrideContainer.specifiedAssociationOverrides();
+		assertFalse(associationOverrides.hasNext());
+	}
+
+	public void testAssociationOverrideIsVirtual() throws Exception {
+		createTestMappedSuperclass();
+		createTestSubType();
+
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, "test.AnnotationTestTypeChild");
+		getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		OrmEntity ormEntity = (OrmEntity) ormPersistentType.getMapping();
+		AssociationOverrideContainer overrideContainer = ormEntity.getAssociationOverrideContainer();
+		
+		ListIterator<OrmAssociationOverride> virtualAssociationOverrides = overrideContainer.virtualAssociationOverrides();	
+		AssociationOverride virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address2", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address3", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address4", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		assertFalse(virtualAssociationOverrides.hasNext());
+
+		overrideContainer.virtualAssociationOverrides().next().setVirtual(false);
+		AssociationOverride specifiedAssociationOverride = overrideContainer.specifiedAssociationOverrides().next();
+		assertFalse(specifiedAssociationOverride.isVirtual());
+		
+		
+		virtualAssociationOverrides = overrideContainer.virtualAssociationOverrides();	
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address2", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address3", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		
+		virtualAssociationOverride = virtualAssociationOverrides.next();
+		assertEquals("address4", virtualAssociationOverride.getName());
+		assertTrue(virtualAssociationOverride.isVirtual());
+		assertFalse(virtualAssociationOverrides.hasNext());
+	}
+	
+	public void testNestedVirtualAttributeOverrides() throws Exception {
+		createTestMappedSuperclassCustomer();
+		createTestEntityLongTimeCustomer();
+		createTestEmbeddableAddress();
+		createTestEmbeddableZipCode();
+		
+		OrmPersistentType customerPersistentType = getEntityMappings().addPersistentType(MappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Customer");
+		OrmPersistentType longTimeCustomerPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, PACKAGE_NAME + ".LongTimeCustomer");
+		OrmPersistentType addressPersistentType = getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".Address");
+		OrmPersistentType zipCodePersistentType = getEntityMappings().addPersistentType(MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY, PACKAGE_NAME + ".ZipCode");
+
+		AttributeOverrideContainer attributeOverrideContainer = ((Entity) longTimeCustomerPersistentType.getMapping()).getAttributeOverrideContainer();
+		
+		assertEquals(7, attributeOverrideContainer.virtualAttributeOverridesSize());
+		ListIterator<AttributeOverride> virtualAttributeOverrides = attributeOverrideContainer.virtualAttributeOverrides();
+		AttributeOverride virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("id", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("name", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.street", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.city", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.state", virtualAttributeOverride.getName());
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.zipCode.zip", virtualAttributeOverride.getName());
+		assertEquals("zip", virtualAttributeOverride.getColumn().getName());
+		assertEquals("LongTimeCustomer", virtualAttributeOverride.getColumn().getTable());		
+		virtualAttributeOverride = virtualAttributeOverrides.next();
+		assertEquals("address.zipCode.plusfour", virtualAttributeOverride.getName());
+		assertEquals("plusfour", virtualAttributeOverride.getColumn().getName());
+		assertEquals("LongTimeCustomer", virtualAttributeOverride.getColumn().getTable());	
+		assertEquals(null, virtualAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, virtualAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, virtualAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, virtualAttributeOverride.getColumn().isUnique());
+		assertEquals(true, virtualAttributeOverride.getColumn().isNullable());
+		assertEquals(255, virtualAttributeOverride.getColumn().getLength());
+		assertEquals(0, virtualAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, virtualAttributeOverride.getColumn().getScale());
+
+		
+		zipCodePersistentType.getAttributeNamed("plusfour").makeSpecified();
+		BasicMapping plusFourMapping = (BasicMapping) zipCodePersistentType.getAttributeNamed("plusfour").getMapping();
+		plusFourMapping.getColumn().setSpecifiedName("BLAH");
+		plusFourMapping.getColumn().setSpecifiedTable("BLAH_TABLE");
+		plusFourMapping.getColumn().setColumnDefinition("COLUMN_DEFINITION");
+		plusFourMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		plusFourMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		plusFourMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		plusFourMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		plusFourMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		plusFourMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		plusFourMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+
+		attributeOverrideContainer = ((Entity) longTimeCustomerPersistentType.getMapping()).getAttributeOverrideContainer();
+		//check the top-level embedded (Customer.address) attribute override to verify it is getting settings from the specified column on Zipcode.plusfour
+		virtualAttributeOverride = attributeOverrideContainer.getAttributeOverrideNamed("address.zipCode.plusfour");
+		assertEquals("address.zipCode.plusfour", virtualAttributeOverride.getName());
+		assertEquals("BLAH", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BLAH_TABLE", virtualAttributeOverride.getColumn().getTable());	
+		assertEquals("COLUMN_DEFINITION", virtualAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, virtualAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, virtualAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, virtualAttributeOverride.getColumn().isUnique());
+		assertEquals(false, virtualAttributeOverride.getColumn().isNullable());
+		assertEquals(5, virtualAttributeOverride.getColumn().getLength());
+		assertEquals(6, virtualAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, virtualAttributeOverride.getColumn().getScale());
+		
+		//set an attribute override on Address.zipCode embedded mapping
+		addressPersistentType.getAttributeNamed("zipCode").makeSpecified();
+		AttributeOverride specifiedAttributeOverride = ((EmbeddedMapping) addressPersistentType.getAttributeNamed("zipCode").getMapping()).getAttributeOverrideContainer().getAttributeOverrideNamed("plusfour").setVirtual(false);
+		specifiedAttributeOverride.getColumn().setSpecifiedName("BLAH_OVERRIDE");
+		specifiedAttributeOverride.getColumn().setSpecifiedTable("BLAH_TABLE_OVERRIDE");
+		specifiedAttributeOverride.getColumn().setColumnDefinition("COLUMN_DEFINITION_OVERRIDE");
+
+
+		attributeOverrideContainer = ((Entity) longTimeCustomerPersistentType.getMapping()).getAttributeOverrideContainer();
+		virtualAttributeOverride = attributeOverrideContainer.getAttributeOverrideNamed("address.zipCode.plusfour");
+		assertEquals("address.zipCode.plusfour", virtualAttributeOverride.getName());
+		assertEquals("BLAH_OVERRIDE", virtualAttributeOverride.getColumn().getName());
+		assertEquals("BLAH_TABLE_OVERRIDE", virtualAttributeOverride.getColumn().getTable());	
+		assertEquals("COLUMN_DEFINITION_OVERRIDE", virtualAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, virtualAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, virtualAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, virtualAttributeOverride.getColumn().isUnique());
+		assertEquals(true, virtualAttributeOverride.getColumn().isNullable());
+		assertEquals(255, virtualAttributeOverride.getColumn().getLength());
+		assertEquals(0, virtualAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, virtualAttributeOverride.getColumn().getScale());
+		
+		specifiedAttributeOverride = virtualAttributeOverride.setVirtual(false);
+		assertEquals(false, specifiedAttributeOverride.isVirtual());
+		assertEquals("address.zipCode.plusfour", specifiedAttributeOverride.getName());
+		//TODO I have the default wrong in this case, but this was wrong before as well.  Need to fix this later
+//		assertEquals("plusfour", specifiedAttributeOverride.getColumn().getDefaultName());
+		assertEquals("BLAH_OVERRIDE", specifiedAttributeOverride.getColumn().getSpecifiedName());
+//		assertEquals("Customer", specifiedAttributeOverride.getColumn().getDefaultTable());	
+		assertEquals(null, specifiedAttributeOverride.getColumn().getSpecifiedTable());	
+		assertEquals(null, specifiedAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, specifiedAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, specifiedAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, specifiedAttributeOverride.getColumn().isUnique());
+		assertEquals(true, specifiedAttributeOverride.getColumn().isNullable());
+		assertEquals(255, specifiedAttributeOverride.getColumn().getLength());
+		assertEquals(0, specifiedAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, specifiedAttributeOverride.getColumn().getScale());
+	}
+	
+	public void testSetSpecifiedCacheable() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 cacheable2_0 = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(null, cacheable2_0.getSpecifiedCacheable());
+		assertEquals(null, entityResource.getCacheable());
+		
+		cacheable2_0.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(Boolean.FALSE, cacheable2_0.getSpecifiedCacheable());
+		assertEquals(Boolean.FALSE, entityResource.getCacheable());
+		
+		cacheable2_0.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(Boolean.TRUE, cacheable2_0.getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, entityResource.getCacheable());
+		
+		cacheable2_0.setSpecifiedCacheable(null);
+		assertEquals(null, cacheable2_0.getSpecifiedCacheable());
+		assertEquals(null, entityResource.getCacheable());
+	}
+	
+	public void testGetSpecifiedCacheable() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
+		XmlEntity entityResource = getXmlEntityMappings().getEntities().get(0);
+		assertEquals(null, cacheable.getSpecifiedCacheable());
+		assertEquals(null, entityResource.getCacheable());
+		
+		entityResource.setCacheable(Boolean.TRUE);
+		assertEquals(Boolean.TRUE, cacheable.getSpecifiedCacheable());
+		assertEquals(Boolean.TRUE, entityResource.getCacheable());
+
+		entityResource.setCacheable(Boolean.FALSE);
+		assertEquals(Boolean.FALSE, cacheable.getSpecifiedCacheable());
+		assertEquals(Boolean.FALSE, entityResource.getCacheable());
+		
+		entityResource.setCacheable(null);
+		assertEquals(null, cacheable.getSpecifiedCacheable());
+		assertEquals(null, entityResource.getCacheable());
+	}
+	
+	public void testIsDefaultCacheable() throws Exception {
+		createTestEntity();
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
+		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
+		assertEquals(SharedCacheMode.DISABLE_SELECTIVE, persistenceUnit2_0.getSharedCacheMode());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ALL);
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
+		assertEquals(false, cacheable.isDefaultCacheable());
+
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
+		assertEquals(false, cacheable.isDefaultCacheable());
+
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.UNSPECIFIED);
+		assertEquals(true, cacheable.isDefaultCacheable());
+	}
+	
+	public void testIsDefaultCacheableFromSuperType() throws Exception {
+		createTestEntity();
+		createTestSubType();
+		OrmPersistentType subOrmPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_SUB_TYPE_NAME);
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		
+		EclipseLinkEntity subEntity = (EclipseLinkEntity) subOrmPersistentType.getMapping();
+		EclipseLinkEntity entity = (EclipseLinkEntity) ormPersistentType.getMapping();
+		Cacheable2_0 subCacheable = ((CacheableHolder2_0) subEntity).getCacheable();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) entity).getCacheable();
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+	
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(null);
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+				
+		cacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+		
+		cacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.NONE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+	}
+	
+	public void testIsDefaultCacheableFromJava() throws Exception {
+		createTestEntity();
+		createTestSubType();
+		OrmPersistentType subOrmPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_SUB_TYPE_NAME);
+		OrmPersistentType ormPersistentType = getEntityMappings().addPersistentType(MappingKeys.ENTITY_TYPE_MAPPING_KEY, FULLY_QUALIFIED_TYPE_NAME);
+		
+		Cacheable2_0 subCacheable = ((CacheableHolder2_0) subOrmPersistentType.getMapping()).getCacheable();
+		Cacheable2_0 cacheable = ((CacheableHolder2_0) ormPersistentType.getMapping()).getCacheable();
+		
+		Cacheable2_0 javaCacheable = ((CacheableHolder2_0) ormPersistentType.getJavaPersistentType().getMapping()).getCacheable();
+		javaCacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		PersistenceUnit2_0 persistenceUnit2_0 = (PersistenceUnit2_0) getPersistenceUnit();
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+				
+		javaCacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+		
+		javaCacheable.setSpecifiedCacheable(Boolean.TRUE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		getEntityMappings().getPersistenceUnitMetadata().setXmlMappingMetadataComplete(true);
+		assertEquals(false, subCacheable.isDefaultCacheable());
+		assertEquals(false, cacheable.isDefaultCacheable());
+		
+		persistenceUnit2_0.setSpecifiedSharedCacheMode(SharedCacheMode.DISABLE_SELECTIVE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+		
+		javaCacheable.setSpecifiedCacheable(Boolean.FALSE);
+		assertEquals(true, subCacheable.isDefaultCacheable());
+		assertEquals(true, cacheable.isDefaultCacheable());
+	}
+}
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/orm/JptEclipseLink2_0OrmContextModelTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/orm/JptEclipseLink2_0OrmContextModelTests.java
index f89333b993..aab7587fe4 100644
--- a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/orm/JptEclipseLink2_0OrmContextModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/orm/JptEclipseLink2_0OrmContextModelTests.java
@@ -17,6 +17,7 @@ public class JptEclipseLink2_0OrmContextModelTests extends TestCase
 {
 	public static Test suite() {
 		TestSuite suite = new TestSuite(JptEclipseLink2_0OrmContextModelTests.class.getName());
+		suite.addTestSuite(EclipseLink2_0OrmEntityTests.class);
 		suite.addTestSuite(Eclipselink2_0OrmManyToOneMappingTests.class);
 		suite.addTestSuite(EclipseLink2_0OrmOneToOneMappingTests.class);
 		suite.addTestSuite(EclipseLink2_0OrmOneToManyMappingTests.class);