### Eclipse Workspace Patch 1.0
#P org.eclipse.gmf.codegen
Index: src/org/eclipse/gmf/internal/codegen/util/MigrationDelegate.java
===================================================================
RCS file: /cvsroot/modeling/org.eclipse.gmf/plugins/org.eclipse.gmf.codegen/src/org/eclipse/gmf/internal/codegen/util/MigrationDelegate.java,v
retrieving revision 1.2
diff -u -r1.2 MigrationDelegate.java
--- src/org/eclipse/gmf/internal/codegen/util/MigrationDelegate.java	18 May 2007 22:44:51 -0000	1.2
+++ src/org/eclipse/gmf/internal/codegen/util/MigrationDelegate.java	19 May 2007 19:23:45 -0000
@@ -16,19 +16,23 @@
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.impl.EAttributeImpl;
 import org.eclipse.emf.ecore.impl.EReferenceImpl;
+import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.gmf.codegen.gmfgen.GMFGenFactory;
 import org.eclipse.gmf.codegen.gmfgen.GMFGenPackage;
 import org.eclipse.gmf.codegen.gmfgen.GenAuditContainer;
 import org.eclipse.gmf.codegen.gmfgen.GenAuditRoot;
 import org.eclipse.gmf.codegen.gmfgen.GenAuditRule;
-import org.eclipse.gmf.codegen.gmfgen.GenEditorGenerator;
 import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegateImpl;
 
 class MigrationDelegate extends MigrationHelperDelegateImpl {
-	private EReference ourGenEditorGenerator_Audits;
 	private EReference ourGenAuditContainer_ChildContainers;
 	private EReference ourGenAuditContainer_Audits;
+	private EAttributeImpl myGenAuditRoot_Id;
+	private EAttributeImpl myGenAuditRoot_Name;
+	private EAttributeImpl myGenAuditRoot_Description;
+	private GenAuditContainer myRootContainer;
 	
 	MigrationDelegate() {
 	}
@@ -60,12 +64,6 @@
 			renamings.put("metaFeature", GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet_MetaFeatures()); //$NON-NLS-1$
 			registerRenamedAttributes(GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet(), renamings);
 		}
-		ourGenEditorGenerator_Audits = new EReferenceImpl() {};
-		ourGenEditorGenerator_Audits.setName("audits"); //$NON-NLS-1$
-		ourGenEditorGenerator_Audits.setEType(GMFGenPackage.eINSTANCE.getGenAuditContainer());
-		ourGenEditorGenerator_Audits.setContainment(true);
-		ourGenEditorGenerator_Audits.setLowerBound(0);
-		ourGenEditorGenerator_Audits.setUpperBound(1);
 		ourGenAuditContainer_ChildContainers = new EReferenceImpl() {};
 		ourGenAuditContainer_ChildContainers.setName("childContainers"); //$NON-NLS-1$
 		ourGenAuditContainer_ChildContainers.setEType(GMFGenPackage.eINSTANCE.getGenAuditContainer());
@@ -78,33 +76,66 @@
 		ourGenAuditContainer_Audits.setContainment(true);
 		ourGenAuditContainer_Audits.setLowerBound(0);
 		ourGenAuditContainer_Audits.setUpperBound(-1);
+		myGenAuditRoot_Id = (EAttributeImpl) EcoreUtil.copy(GMFGenPackage.eINSTANCE.getGenAuditContainer_Id());
+		myGenAuditRoot_Name = (EAttributeImpl) EcoreUtil.copy(GMFGenPackage.eINSTANCE.getGenAuditContainer_Name());
+		myGenAuditRoot_Description = (EAttributeImpl) EcoreUtil.copy(GMFGenPackage.eINSTANCE.getGenAuditContainer_Description());
 		{
 			Map<String, EStructuralFeature> renamings = new HashMap<String, EStructuralFeature>();
-			renamings.put(ourGenEditorGenerator_Audits.getName(), ourGenEditorGenerator_Audits);
-			registerRenamedAttributes(GMFGenPackage.eINSTANCE.getGenEditorGenerator(), renamings);
+			renamings.put(ourGenAuditContainer_Audits.getName(), ourGenAuditContainer_Audits);
+			renamings.put(ourGenAuditContainer_ChildContainers.getName(), ourGenAuditContainer_ChildContainers);
+			registerRenamedAttributes(GMFGenPackage.eINSTANCE.getGenAuditContainer(), renamings);
 		}
 		{
 			Map<String, EStructuralFeature> renamings = new HashMap<String, EStructuralFeature>();
 			renamings.put(ourGenAuditContainer_Audits.getName(), ourGenAuditContainer_Audits);
 			renamings.put(ourGenAuditContainer_ChildContainers.getName(), ourGenAuditContainer_ChildContainers);
-			registerRenamedAttributes(GMFGenPackage.eINSTANCE.getGenAuditContainer(), renamings);
+			renamings.put(myGenAuditRoot_Id.getName(), myGenAuditRoot_Id);
+			renamings.put(myGenAuditRoot_Name.getName(), myGenAuditRoot_Name);
+			renamings.put(myGenAuditRoot_Description.getName(), myGenAuditRoot_Description);
+			registerRenamedAttributes(GMFGenPackage.eINSTANCE.getGenAuditRoot(), renamings);
 		}
 		registerRenamedType("CompositeFeatureLabelModelFacet", GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet()); //$NON-NLS-1$
+		myRootContainer = null;
 	}
 	
 	@Override
 	public boolean setValue(EObject object, EStructuralFeature feature, Object value, int position) {
-		if (ourGenEditorGenerator_Audits.equals(feature)) {
-			GenEditorGenerator generator = (GenEditorGenerator) object;
-			GenAuditContainer rootContainer = (GenAuditContainer) value;
-			generator.setAudits(getOrCreateRoot(rootContainer));
-		} else if (ourGenAuditContainer_ChildContainers.equals(feature)) {
+		if (myGenAuditRoot_Id.equals(feature)) {
+			GenAuditRoot root = (GenAuditRoot) object;
+			String id = (String) value;
+			GenAuditContainer rootContainer = getOrCreateRootContainerOnce(root);
+			rootContainer.setId(id);
+		} else if (myGenAuditRoot_Name.equals(feature)) {
+			GenAuditRoot root = (GenAuditRoot) object;
+			String name = (String) value;
+			GenAuditContainer rootContainer = getOrCreateRootContainerOnce(root);
+			rootContainer.setName(name);
+		} else if (myGenAuditRoot_Description.equals(feature)) {
+			GenAuditRoot root = (GenAuditRoot) object;
+			String description = (String) value;
+			GenAuditContainer rootContainer = getOrCreateRootContainerOnce(root);
+			rootContainer.setDescription(description);
+		} else if (ourGenAuditContainer_ChildContainers.equals(feature) && object instanceof GenAuditRoot) {
+			GenAuditRoot root = (GenAuditRoot)object;
+			GenAuditContainer container = (GenAuditContainer)value;
+			if (myRootContainer != null) {
+				container.getPath().add(myRootContainer);
+			}
+			root.getCategories().add(container);
+		} else if (ourGenAuditContainer_Audits.equals(feature) && object instanceof GenAuditRoot) {
+			GenAuditRoot root = (GenAuditRoot)object;
+			GenAuditRule rule = (GenAuditRule)value;
+			if (myRootContainer != null) {
+				rule.setCategory(myRootContainer);
+			}
+			root.getRules().add(rule);
+		} else if (ourGenAuditContainer_ChildContainers.equals(feature) && object instanceof GenAuditContainer) {
 			GenAuditContainer parent = (GenAuditContainer)object;
 			GenAuditContainer container = (GenAuditContainer)value;
 			container.getPath().addAll(parent.getPath());
 			container.getPath().add(parent);
 			getOrCreateRoot(parent).getCategories().add(container);
-		} else if (ourGenAuditContainer_Audits.equals(feature)) {
+		} else if (ourGenAuditContainer_Audits.equals(feature) && object instanceof GenAuditContainer) {
 			GenAuditContainer container = (GenAuditContainer)object;
 			GenAuditRule rule = (GenAuditRule)value;
 			rule.setCategory(container);
@@ -116,6 +147,14 @@
 		return true;
 	}
 
+	private GenAuditContainer getOrCreateRootContainerOnce(GenAuditRoot root) {
+		if (myRootContainer == null) {
+			myRootContainer = GMFGenFactory.eINSTANCE.createGenAuditContainer();
+			root.getCategories().add(myRootContainer);
+		}
+		return myRootContainer;
+	}
+
 	private GenAuditRoot getOrCreateRoot(GenAuditContainer auditContainer) {
 		GenAuditRoot result = auditContainer.getRoot();
 		if (result == null) {
#P org.eclipse.gmf.common
Index: src/org/eclipse/gmf/internal/common/migrate/MigrationHelper.java
===================================================================
RCS file: /cvsroot/modeling/org.eclipse.gmf/plugins/org.eclipse.gmf.common/src/org/eclipse/gmf/internal/common/migrate/MigrationHelper.java,v
retrieving revision 1.2
diff -u -r1.2 MigrationHelper.java
--- src/org/eclipse/gmf/internal/common/migrate/MigrationHelper.java	18 May 2007 22:44:52 -0000	1.2
+++ src/org/eclipse/gmf/internal/common/migrate/MigrationHelper.java	19 May 2007 19:23:45 -0000
@@ -10,21 +10,22 @@
  */
 package org.eclipse.gmf.internal.common.migrate;
 
+import java.util.HashMap;
+import java.util.Map;
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EFactory;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.impl.EReferenceImpl;
+import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.ecore.xmi.XMLResource;
 import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl;
 
 public class MigrationHelper extends XMIHelperImpl {
 	private final MigrationHelperDelegate myDelegate;
-	private EStructuralFeature mySavedFeature;
-	private EReferenceImpl myFakeFeatureWithNarrowType;
 	private boolean myIsDelegateDisabled = true;
+	private Map<EStructuralFeature, EStructuralFeature> myNarrowedFeatureTypes;
 
 	public MigrationHelper(XMLResource resource, MigrationHelperDelegate delegate) {
 		super(resource);
@@ -55,8 +56,9 @@
 			super.setValue(object, feature, value, position);
 			return; 
 		}
-		if (feature != null && feature.equals(myFakeFeatureWithNarrowType)) {
-			feature = mySavedFeature;
+		EStructuralFeature originalFeature = getOriginalFeature(feature);
+		if (originalFeature != null) {
+			feature = originalFeature;
 		}
 		if (!myDelegate.setValue(object, feature, value, position)) {
 			super.setValue(object, feature, value, position);
@@ -74,11 +76,9 @@
 		}
 		EClass narrow = myDelegate.getStructuralFeatureType(result);
 		if (narrow != null) {
-			mySavedFeature = result;
-			myFakeFeatureWithNarrowType = new EReferenceImpl() {};
-			myFakeFeatureWithNarrowType.setName(result.getName());
-			myFakeFeatureWithNarrowType.setEType(narrow);
-			return myFakeFeatureWithNarrowType;
+			EStructuralFeature fake = addNarrowedFeature(result);
+			fake.setEType(narrow);
+			return fake;
 		}
 		return result;
 	}
@@ -103,4 +103,20 @@
 		}
 		myDelegate.postProcess();
 	}
+	
+	protected EStructuralFeature getOriginalFeature(EStructuralFeature feature) {
+		if (myNarrowedFeatureTypes == null) {
+			myNarrowedFeatureTypes = new HashMap<EStructuralFeature, EStructuralFeature>();
+		}
+		return myNarrowedFeatureTypes.get(feature);
+	}
+	
+	protected EStructuralFeature addNarrowedFeature(EStructuralFeature originalFeature) {
+		if (myNarrowedFeatureTypes == null) {
+			myNarrowedFeatureTypes = new HashMap<EStructuralFeature, EStructuralFeature>();
+		}
+		EStructuralFeature result = (EStructuralFeature) EcoreUtil.copy(originalFeature);
+		myNarrowedFeatureTypes.put(result, originalFeature);
+		return result;
+	}
 }
#P org.eclipse.gmf.tests
Index: src/org/eclipse/gmf/tests/migration/MigrationPatchesTest.java
===================================================================
RCS file: /cvsroot/modeling/org.eclipse.gmf/tests/org.eclipse.gmf.tests/src/org/eclipse/gmf/tests/migration/MigrationPatchesTest.java,v
retrieving revision 1.11
diff -u -r1.11 MigrationPatchesTest.java
--- src/org/eclipse/gmf/tests/migration/MigrationPatchesTest.java	18 May 2007 20:39:12 -0000	1.11
+++ src/org/eclipse/gmf/tests/migration/MigrationPatchesTest.java	19 May 2007 19:23:47 -0000
@@ -10,12 +10,16 @@
  */
 package org.eclipse.gmf.tests.migration;
 
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.util.Iterator;
 
 import junit.framework.TestCase;
 
 import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Path;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
@@ -23,7 +27,9 @@
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
 import org.eclipse.gmf.codegen.gmfgen.GenAuditContainer;
+import org.eclipse.gmf.codegen.gmfgen.GenAuditRoot;
 import org.eclipse.gmf.codegen.gmfgen.GenAuditRule;
+import org.eclipse.gmf.codegen.gmfgen.GenEditorGenerator;
 import org.eclipse.gmf.internal.common.ToolingResourceFactory;
 import org.eclipse.gmf.internal.common.migrate.MigrationResource;
 import org.eclipse.gmf.internal.common.migrate.ModelLoadHelper;
@@ -39,34 +45,54 @@
 	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=138440
 	 */
 	public void testPatch_138440() throws Exception {
-		String genmodelFileName = "patch_138440.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("patch_138440.gmfgen"); //$NON-NLS-1$
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected IllegalArgumentException from metamodel EFactory", caughtGenException instanceof IllegalArgumentException); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
 
-		String gmfmapmodelFileName = "patch_138440.gmfmap"; //$NON-NLS-1$
+		URI newGenUri = temporarySaveMigratedModel(genmodelFileName, "patch_138440", "gmfgen");
+		changeNsUriToOldOne(newGenUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newGenUri);
+		
+		URI gmfmapmodelFileName = createURI("patch_138440.gmfmap"); //$NON-NLS-1$
 		Exception caughtMapException = assertOrdinaryLoadModelProblems(gmfmapmodelFileName);
 		assertTrue("expected IllegalArgumentException from metamodel EFactory", caughtMapException instanceof IllegalArgumentException); //$NON-NLS-1$
 
 		assertOnLoadModelMigrationSuccess(gmfmapmodelFileName);
+
+		URI newMapUri = temporarySaveMigratedModel(gmfmapmodelFileName, "patch_138440", "gmfmap");
+		changeNsUriToOldOne(newMapUri, "gmfmap", "http://www.eclipse.org/gmf/2005/mappings/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newMapUri);
 	}
 
 	/*
 	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=161380
 	 */
 	public void testPatch_161380() throws Exception {
-		String genmodelFileName = "patch_161380.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("patch_161380.gmfgen"); //$NON-NLS-1$
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
 
-		String gmfmapmodelFileName = "patch_161380.gmfmap"; //$NON-NLS-1$		
+		URI newGenUri = temporarySaveMigratedModel(genmodelFileName, "patch_138440", "gmfgen");
+		changeNsUriToOldOne(newGenUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newGenUri);
+		
+		URI gmfmapmodelFileName = createURI("patch_161380.gmfmap"); //$NON-NLS-1$		
 		Exception caughtMapException = assertOrdinaryLoadModelProblems(gmfmapmodelFileName);
 		assertTrue("expected diagnostic exception", caughtMapException != null); //$NON-NLS-1$
 
 		assertOnLoadModelMigrationSuccess(gmfmapmodelFileName);
+
+		URI newUri = temporarySaveMigratedModel(gmfmapmodelFileName, "patch_161380", "gmfmap");
+		changeNsUriToOldOne(newUri, "gmfmap", "http://www.eclipse.org/gmf/2005/mappings/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newUri);
 	}
 
 	private static URI createURI(String testModelFileName) {
@@ -79,8 +105,7 @@
 		return null;
 	}
 
-	void assertOnLoadModelMigrationSuccess(String modelFileName) throws Exception {
-		URI uri = createURI(modelFileName);
+	void assertOnLoadModelMigrationSuccess(URI uri) throws Exception {
 		ModelLoadHelper loadHelper = new ModelLoadHelper(new ResourceSetImpl(), uri);
 		
 		assertTrue("Migration warning load status expected", loadHelper.getStatus().matches(IStatus.WARNING)); //$NON-NLS-1$
@@ -88,11 +113,11 @@
 		assertEquals("Single Warning diagnostic expected", 1, warnings.size()); //$NON-NLS-1$		
 		assertTrue("MigrationDiagnostic expected as warning", warnings.get(0) instanceof MigrationResource.Diagnostic); //$NON-NLS-1$
 		
-		assertTrue(loadHelper.getLoadedResource().getErrors().isEmpty());
+		EList<Resource.Diagnostic> errors = loadHelper.getLoadedResource().getErrors();
+		assertTrue(errors.isEmpty());
 	}
 
-	Exception assertOrdinaryLoadModelProblems(String modelFileName) throws Exception {
-		URI uri = createURI(modelFileName);
+	Exception assertOrdinaryLoadModelProblems(URI uri) throws Exception {
 		Resource resource = new ToolingResourceFactory().createResource(uri);
 		ResourceSet rset = new ResourceSetImpl();
 		rset.getResources().add(resource);
@@ -121,12 +146,17 @@
 	attr String preferenceInitializerClassName;
 	 */
 	public void testGenDiagram() throws Exception {
-		String genmodelFileName = "testGenDiagram.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("testGenDiagram.gmfgen"); //$NON-NLS-1$
 		
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
+
+		URI newUri = temporarySaveMigratedModel(genmodelFileName, "testGenDiagram", "gmfgen");
+		changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newUri);
 	}
 
 	/*
@@ -135,12 +165,17 @@
 	ref genmodel.GenFeature[1] metaFeature;
 	 */
 	public void testFeatureLabelModelFacet() throws Exception {
-		String genmodelFileName = "testFeatureLabelModelFacet.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("testFeatureLabelModelFacet.gmfgen"); //$NON-NLS-1$
 		
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
+
+		URI newUri = temporarySaveMigratedModel(genmodelFileName, "testFeatureLabelModelFacet", "gmfgen");
+		changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newUri);
 	}
 
 //	/*
@@ -158,16 +193,21 @@
 //	}
 
 	public void testGenAuditRootDefaultAndNested() throws Exception {
-		String genmodelFileName = "testGenAuditRootDefaultAndNested.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("testGenAuditRootDefaultAndNested.gmfgen"); //$NON-NLS-1$
 		
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
+
+		URI newUri = temporarySaveMigratedModel(genmodelFileName, "testGenAuditRootDefaultAndNested", "gmfgen");
+		changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newUri);
 	}
 
 	public void testGenAuditRootNoDefaultButNested() throws Exception {
-		String genmodelFileName = "testGenAuditRootNoDefaultButNested.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("testGenAuditRootNoDefaultButNested.gmfgen"); //$NON-NLS-1$
 		
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
@@ -176,41 +216,105 @@
 	}
 
 	public void testGenAudits() throws Exception {
-		String genmodelFileName = "testGenAudits.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("testGenAudits.gmfgen"); //$NON-NLS-1$
 		
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
+
+		URI newUri = temporarySaveMigratedModel(genmodelFileName, "testGenAudits", "gmfgen");
+		changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newUri);
 	}
 
 	public void testGenEditorAuditRootNoDefaultButNested() throws Exception {
-		String genmodelFileName = "testGenEditorAuditRootNoDefaultButNested.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("testGenEditorAuditRootNoDefaultButNested.gmfgen"); //$NON-NLS-1$
 		
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
+
+		URI newUri = temporarySaveMigratedModel(genmodelFileName, "testGenEditorAuditRootNoDefaultButNested", "gmfgen");
+		changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newUri);
 	}
 
 	public void testGenAuditsCorrectCategories() throws Exception {
-		String genmodelFileName = "testGenAuditsCorrectCategories.gmfgen"; //$NON-NLS-1$
+		URI genmodelFileName = createURI("testGenAuditsCorrectCategories.gmfgen"); //$NON-NLS-1$
 		
 		Exception caughtGenException = assertOrdinaryLoadModelProblems(genmodelFileName);
 		assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$				
 
 		assertOnLoadModelMigrationSuccess(genmodelFileName);
+		
+		checkModelAndCorrectCategories(genmodelFileName);
+
+		URI newUri = temporarySaveMigratedModel(genmodelFileName, "testGenAuditsCorrectCategories", "gmfgen");
+		changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
+		
+		assertOnLoadModelMigrationSuccess(newUri);
+		
+		checkModelAndCorrectCategories(newUri);
+	}
+
+	private URI temporarySaveMigratedModel(URI uri, String tempFilename, String tempFileExtension) throws IOException {
+		ModelLoadHelper loadHelper = new ModelLoadHelper(new ResourceSetImpl(), uri);
+		Resource resource = loadHelper.getLoadedResource();
+		File newGenmodelFile = File.createTempFile(tempFilename, tempFileExtension.startsWith(".") ? tempFileExtension : "."+tempFileExtension);
+		URI newUri = URI.createFileURI(newGenmodelFile.getAbsolutePath());
+		resource.setURI(newUri);
+		try {
+			resource.save(null);
+		} catch (IOException ex) {
+			fail(ex.toString());
+		}
+		return newUri;
+	}
+
+	private void changeNsUriToOldOne(URI newUri, String nsPrefix, String nsUri) throws IOException {
+		Path path = new Path(newUri.toFileString());
+		File file = path.toFile();
+		FileReader reader = new FileReader(file);
+		char[] chars = new char[100000];
+		int length = reader.read(chars);
+		String content = new String(chars, 0, length).replaceFirst("xmlns:"+nsPrefix+"=\"[^\"]+\"", "xmlns:"+nsPrefix+"=\""+nsUri+"\"");
+		FileWriter writer = new FileWriter(file);
+		writer.write(content.toCharArray());
+		writer.flush();
+	}
 
-		URI uri = createURI(genmodelFileName);
+	private void checkModelAndCorrectCategories(URI uri) {
 		ModelLoadHelper loadHelper = new ModelLoadHelper(new ResourceSetImpl(), uri);
 		Resource resource = loadHelper.getLoadedResource();
+		int allContentsSize = 0;
 		for (Iterator<EObject> it = resource.getAllContents(); it.hasNext();) {
 			EObject next = it.next();
-			if (next instanceof GenAuditRule) {
+			allContentsSize++;
+			if (next instanceof GenEditorGenerator) {
+				GenEditorGenerator genEditor = (GenEditorGenerator) next;
+				assertNotNull(genEditor.getAudits());
+			} else if (next instanceof GenAuditRoot) {
+				GenAuditRoot root = (GenAuditRoot) next;
+				assertFalse(root.getCategories().isEmpty());
+				assertFalse(root.getRules().isEmpty());
+				assertEquals(3, root.getCategories().size());
+				assertEquals(3, root.getRules().size());
+			} else if (next instanceof GenAuditContainer) {
+				GenAuditContainer nextContainer = (GenAuditContainer) next;
+				assertFalse(nextContainer.getAudits().isEmpty());
+				assertEquals(nextContainer.getAudits().size(), 1);
+			} else if (next instanceof GenAuditRule) {
 				GenAuditRule nextRule = (GenAuditRule) next;
 				GenAuditContainer nextCategory = nextRule.getCategory();
+				assertNotNull(nextCategory);
 				assertEquals("Audit rule expected to be placed to correct audit category after migration", "rule:"+nextCategory.getId(), nextRule.getId()); //$NON-NLS-1$ //$NON-NLS-2$
 			}
 		}
+		assertEquals(8, allContentsSize);
 	}
+
 }
Index: src/org/eclipse/gmf/tests/migration/GenericMigrationTest.java
===================================================================
RCS file: /cvsroot/modeling/org.eclipse.gmf/tests/org.eclipse.gmf.tests/src/org/eclipse/gmf/tests/migration/GenericMigrationTest.java,v
retrieving revision 1.7
diff -u -r1.7 GenericMigrationTest.java
--- src/org/eclipse/gmf/tests/migration/GenericMigrationTest.java	18 May 2007 23:30:51 -0000	1.7
+++ src/org/eclipse/gmf/tests/migration/GenericMigrationTest.java	19 May 2007 19:23:47 -0000
@@ -18,6 +18,8 @@
 
 import junit.framework.TestCase;
 
+import org.eclipse.emf.common.util.BasicEList;
+import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.emf.ecore.EClass;
@@ -43,6 +45,7 @@
 	private EAttribute myAttrToRename;
 	private EReference myWidenedRef;
 	private EAttribute myAttrNarrow;
+	private EAttribute myAttrNarrowChild;
 
 	public GenericMigrationTest(String name) {
 		super(name);
@@ -61,27 +64,36 @@
 		myAttrToRename = EcoreFactory.eINSTANCE.createEAttribute();
 		myWidenedRef = EcoreFactory.eINSTANCE.createEReference();
 		myAttrNarrow = EcoreFactory.eINSTANCE.createEAttribute();
+		myAttrNarrowChild = EcoreFactory.eINSTANCE.createEAttribute();
 		EClass mNarrowClass = EcoreFactory.eINSTANCE.createEClass();
+		EClass mNarrowClassChild = EcoreFactory.eINSTANCE.createEClass();
+		mNarrowClassChild.getESuperTypes().add(mNarrowClass);
 		mmPackage.getEClassifiers().add(mClass);
 		mmPackage.getEClassifiers().add(mNarrowClass);
+		mmPackage.getEClassifiers().add(mNarrowClassChild);
 		mClass.getEStructuralFeatures().add(myAttrToRemove);
 		mClass.getEStructuralFeatures().add(myAttrToRename);
 		mClass.getEStructuralFeatures().add(myWidenedRef);
 		mNarrowClass.getEStructuralFeatures().add(myAttrNarrow);
+		mNarrowClassChild.getEStructuralFeatures().add(myAttrNarrowChild);
 		mmPackage.setName("MM1");
 		mmPackage.setNsPrefix("mm");
 		mmPackage.setNsURI("uri:/mm/1");
 		mClass.setName("MClass");
 		mNarrowClass.setName("NarrowClass");
+		mNarrowClassChild.setName("NarrowClassChild");
 		myAttrToRemove.setName("myRemovedAttr");
 		myAttrToRemove.setEType(EcorePackage.eINSTANCE.getEString());
 		myAttrToRename.setName("myRenamedAttr");
 		myAttrToRename.setEType(EcorePackage.eINSTANCE.getEString());
 		myWidenedRef.setName("myWidenedRef");
+		myWidenedRef.setUpperBound(-1);
 		myWidenedRef.setContainment(true);
 		myWidenedRef.setEType(mNarrowClass);
 		myAttrNarrow.setName("myNarrowAttr");
 		myAttrNarrow.setEType(EcorePackage.eINSTANCE.getEString());
+		myAttrNarrowChild.setName("myNarrowChildAttr");
+		myAttrNarrowChild.setEType(EcorePackage.eINSTANCE.getEString());
 	}
 
 	private EObject newInstance() {
@@ -92,6 +104,10 @@
 		return getMetaModel().getEFactoryInstance().create(myWidenedRef.getEReferenceType());
 	}
 
+	private EObject newNarrowChildInstance() {
+		return getMetaModel().getEFactoryInstance().create(myAttrNarrowChild.getEContainingClass());
+	}
+
 	private EPackage getMetaModel() {
 		return myAttrToRemove.getEContainingClass().getEPackage();
 	}
@@ -243,7 +259,9 @@
 		String attrValue = "narrow value";
 		
 		narrowValue.eSet(myAttrNarrow, attrValue);
-		testObject.eSet(myWidenedRef, narrowValue);
+		EList narrowValues = new BasicEList();
+		narrowValues.add(narrowValue);
+		testObject.eSet(myWidenedRef, narrowValues);
 
 		EPackage metamodel = getMetaModel();
 		
@@ -326,8 +344,13 @@
 			
 			assertTrue(migratedObj.eIsSet(myWidenedRef));
 			Object narrowRef = migratedObj.eGet(myWidenedRef, true);
-			assertTrue(narrowRef instanceof EObject);
-			EObject narrowInstance = (EObject) narrowRef;
+			assertTrue(narrowRef instanceof EList);
+			EList narrowRefs = (EList) narrowRef;
+			assertFalse(narrowRefs.isEmpty());
+			assertEquals(1, narrowRefs.size());
+			Object narrowRefsFirst = narrowRefs.get(0);
+			assertTrue(narrowRefsFirst instanceof EObject);
+			EObject narrowInstance = (EObject) narrowRefsFirst;
 			assertFalse(narrowInstance.eClass().isAbstract());
 			assertFalse(narrowInstance.eClass().equals(myWidenedRef.getEType()));
 			assertEquals(narrowInstance.eClass(), myAttrNarrow.getEContainingClass());
@@ -341,6 +364,132 @@
 		}
 	}
 
+	public void testWidenedReferenceWith2Types() {
+		final EObject testObject = newInstance();
+		EObject narrowValue = newNarrowInstance();
+		String attrValue = "narrow value";
+		EObject narrowChildValue = newNarrowChildInstance();
+		String attrChildValue = "narrow child value";
+		
+		narrowValue.eSet(myAttrNarrow, attrValue);
+		narrowChildValue.eSet(myAttrNarrowChild, attrChildValue);
+		EList narrowValues = new BasicEList();
+		narrowValues.add(narrowValue);
+		narrowValues.add(narrowChildValue);
+		testObject.eSet(myWidenedRef, narrowValues);
+
+		EPackage metamodel = getMetaModel();
+		
+		final String oldNsURI = metamodel.getNsURI();
+		EPackage.Registry.INSTANCE.put(oldNsURI, metamodel);
+		final String newNsURI = oldNsURI + "/2";
+		EPackage.Registry.INSTANCE.put(newNsURI, metamodel);
+
+		try {
+			URI uri = null;
+			try {
+				uri = URI.createFileURI(File.createTempFile("widened2Types", ".tests").getAbsolutePath());
+				final ResourceSetImpl resourceSetImpl = new ResourceSetImpl();
+				final Resource res = resourceSetImpl.createResource(uri);
+				res.getContents().add(testObject);
+				res.save(null);
+				resourceSetImpl.getResources().remove(testObject);
+			} catch (IOException ex) {
+				fail(ex.toString());
+			}
+			
+			// widen reference in metamodel
+			
+			EClass mWideClass = EcoreFactory.eINSTANCE.createEClass();
+			myWidenedRef.getEContainingClass().getEPackage().getEClassifiers().add(mWideClass);
+			mWideClass.setName("WideClass");
+			mWideClass.setAbstract(true);
+			myWidenedRef.setEType(mWideClass);
+			myAttrNarrow.getEContainingClass().getESuperTypes().add(mWideClass);
+			
+			// try to load mm
+			try {
+				new ResourceSetImpl().createResource(uri).load(null);
+				fail("Load should fail because of unknown meta-model attribute");
+			} catch (RuntimeException ex) {
+				// expected
+				assertNotNull(ex.getMessage());
+			} catch (IOException ex) {
+				// expected
+				assertNotNull(ex.getMessage());
+			}
+
+			EPackage.Registry.INSTANCE.put(oldNsURI, null);
+
+			Resource.Factory factory = new ToolingResourceFactory() {
+
+				@Override
+				public Resource createResource(URI uri) {
+					return new MigrationResource(uri) {
+						protected MigrationHelperDelegate createDelegate() {
+							MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {
+								{
+									registerNarrowReferenceType(myWidenedRef, myAttrNarrow.getEContainingClass());
+								}
+							};
+							return delegate;
+						}
+
+						protected Collection<String> getBackwardSupportedURIs() {
+							return Collections.<String>singleton(oldNsURI);
+						}
+
+						@Override
+						protected String getMetamodelNsURI() {
+							return newNsURI;
+						}
+					};
+				}
+				
+			};
+			
+			// try to load mm
+			Resource migrated = createLoadHelper(factory, uri).getLoadedResource();
+			assertNotNull(migrated);
+			assertTrue(migrated.getErrors().isEmpty());
+			assertFalse(migrated.getWarnings().isEmpty());
+			assertEquals(1, migrated.getContents().size());
+			EObject migratedObj = migrated.getContents().get(0);
+			assertEquals(testObject.eClass(), migratedObj.eClass());
+			
+			assertTrue(migratedObj.eIsSet(myWidenedRef));
+			Object narrowRefList = migratedObj.eGet(myWidenedRef, true);
+			assertTrue(narrowRefList instanceof EList);
+			EList narrowInstancesList = (EList) narrowRefList;
+			assertFalse(narrowInstancesList.isEmpty());
+			assertEquals(2, narrowInstancesList.size());
+			
+			Object narrowRefsFirst = narrowInstancesList.get(0);
+			assertTrue(narrowRefsFirst instanceof EObject);
+			EObject narrowInstance1 = (EObject) narrowRefsFirst;
+			assertFalse(narrowInstance1.eClass().isAbstract());
+			assertFalse(narrowInstance1.eClass().equals(myWidenedRef.getEType()));
+			assertEquals(narrowInstance1.eClass(), myAttrNarrow.getEContainingClass());
+			assertTrue(narrowInstance1.eIsSet(myAttrNarrow));
+			Object haveValue = narrowInstance1.eGet(myAttrNarrow, true);
+			assertEquals(attrValue, haveValue);
+
+			Object narrowRefsSecond = narrowInstancesList.get(1);
+			assertTrue(narrowRefsSecond instanceof EObject);
+			EObject narrowInstance2 = (EObject) narrowRefsSecond;
+			assertFalse(narrowInstance2.eClass().isAbstract());
+			assertFalse(narrowInstance2.eClass().equals(myWidenedRef.getEType()));
+			assertEquals(narrowInstance2.eClass(), myAttrNarrowChild.getEContainingClass());
+			assertTrue(narrowInstance2.eIsSet(myAttrNarrowChild));
+			Object haveChildValue = narrowInstance2.eGet(myAttrNarrowChild, true);
+			assertEquals(attrChildValue, haveChildValue);
+		} finally {
+			// clean-up, avoid any chances to affect other tests
+			EPackage.Registry.INSTANCE.put(oldNsURI, null);
+			EPackage.Registry.INSTANCE.put(newNsURI, null);
+		}
+	}
+
 	private static ModelLoadHelper createLoadHelper(final Resource.Factory factory, URI modelResourceURI) {
 		if(modelResourceURI == null) {
 			throw new IllegalArgumentException("null resource uri"); //$NON-NLS-1$