Attachment #68152 for bug #187811

Lines 13-20 Link Here

(-)src/org/eclipse/gmf/tests/migration/GenericMigrationTest.java (-356 / +400 lines)
13		13
14	import java.io.File;	14	import java.io.File;
15	import java.io.IOException;	15	import java.io.IOException;
		16	import java.util.ArrayList;
		17	import java.util.Arrays;
16	import java.util.Collection;	18	import java.util.Collection;
17	import java.util.Collections;	19	import java.util.Collections;
		20	import java.util.Iterator;
		21	import java.util.List;
18		22
19	import junit.framework.TestCase;	23	import junit.framework.TestCase;
20		24
Lines 26-41 Link Here
26	import org.eclipse.emf.ecore.EObject;	30	import org.eclipse.emf.ecore.EObject;
27	import org.eclipse.emf.ecore.EPackage;	31	import org.eclipse.emf.ecore.EPackage;
28	import org.eclipse.emf.ecore.EReference;	32	import org.eclipse.emf.ecore.EReference;
		33	import org.eclipse.emf.ecore.EStructuralFeature;
29	import org.eclipse.emf.ecore.EcoreFactory;	34	import org.eclipse.emf.ecore.EcoreFactory;
30	import org.eclipse.emf.ecore.EcorePackage;	35	import org.eclipse.emf.ecore.EcorePackage;
31	import org.eclipse.emf.ecore.resource.Resource;	36	import org.eclipse.emf.ecore.resource.Resource;
32	import org.eclipse.emf.ecore.resource.impl.ResourceFactoryRegistryImpl;
33	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;	37	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
34	import org.eclipse.gmf.internal.common.ToolingResourceFactory;	38	import org.eclipse.emf.ecore.util.EcoreValidator;
35	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;	39	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;
36	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegateImpl;	40	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegateImpl;
37	import org.eclipse.gmf.internal.common.migrate.MigrationResource;	41	import org.eclipse.gmf.internal.common.migrate.MigrationResource;
38	import org.eclipse.gmf.internal.common.migrate.ModelLoadHelper;
39		42
40	/**	43	/**
41	* @author artem	44	* @author artem
Lines 43-49 Link Here
43	public class GenericMigrationTest extends TestCase {	46	public class GenericMigrationTest extends TestCase {
44	private EAttribute myAttrToRemove;	47	private EAttribute myAttrToRemove;
45	private EAttribute myAttrToRename;	48	private EAttribute myAttrToRename;
46	private EReference myWidenedRef;	49	private EReference myWidenedRef1;
		50	private EReference myWidenedRef2;
47	private EAttribute myAttrNarrow;	51	private EAttribute myAttrNarrow;
48	private EAttribute myAttrNarrowChild;	52	private EAttribute myAttrNarrowChild;
49		53
Lines 57-68 Link Here
57	createMetaModel();	61	createMetaModel();
58	}	62	}
59		63
60	private void createMetaModel() {	64	private EPackage createMetaModel() {
61	EPackage mmPackage = EcoreFactory.eINSTANCE.createEPackage();	65	EPackage mmPackage = EcoreFactory.eINSTANCE.createEPackage();
62	EClass mClass = EcoreFactory.eINSTANCE.createEClass();	66	EClass mClass = EcoreFactory.eINSTANCE.createEClass();
63	myAttrToRemove = EcoreFactory.eINSTANCE.createEAttribute();	67	myAttrToRemove = EcoreFactory.eINSTANCE.createEAttribute();
64	myAttrToRename = EcoreFactory.eINSTANCE.createEAttribute();	68	myAttrToRename = EcoreFactory.eINSTANCE.createEAttribute();
65	myWidenedRef = EcoreFactory.eINSTANCE.createEReference();	69	myWidenedRef1 = EcoreFactory.eINSTANCE.createEReference();
		70	myWidenedRef2 = EcoreFactory.eINSTANCE.createEReference();
66	myAttrNarrow = EcoreFactory.eINSTANCE.createEAttribute();	71	myAttrNarrow = EcoreFactory.eINSTANCE.createEAttribute();
67	myAttrNarrowChild = EcoreFactory.eINSTANCE.createEAttribute();	72	myAttrNarrowChild = EcoreFactory.eINSTANCE.createEAttribute();
68	EClass mNarrowClass = EcoreFactory.eINSTANCE.createEClass();	73	EClass mNarrowClass = EcoreFactory.eINSTANCE.createEClass();
Lines 73-79 Link Here
73	mmPackage.getEClassifiers().add(mNarrowClassChild);	78	mmPackage.getEClassifiers().add(mNarrowClassChild);
74	mClass.getEStructuralFeatures().add(myAttrToRemove);	79	mClass.getEStructuralFeatures().add(myAttrToRemove);
75	mClass.getEStructuralFeatures().add(myAttrToRename);	80	mClass.getEStructuralFeatures().add(myAttrToRename);
76	mClass.getEStructuralFeatures().add(myWidenedRef);	81	mClass.getEStructuralFeatures().add(myWidenedRef1);
		82	mClass.getEStructuralFeatures().add(myWidenedRef2);
77	mNarrowClass.getEStructuralFeatures().add(myAttrNarrow);	83	mNarrowClass.getEStructuralFeatures().add(myAttrNarrow);
78	mNarrowClassChild.getEStructuralFeatures().add(myAttrNarrowChild);	84	mNarrowClassChild.getEStructuralFeatures().add(myAttrNarrowChild);
79	mmPackage.setName("MM1");	85	mmPackage.setName("MM1");
Lines 86-99 Link Here
86	myAttrToRemove.setEType(EcorePackage.eINSTANCE.getEString());	92	myAttrToRemove.setEType(EcorePackage.eINSTANCE.getEString());
87	myAttrToRename.setName("myRenamedAttr");	93	myAttrToRename.setName("myRenamedAttr");
88	myAttrToRename.setEType(EcorePackage.eINSTANCE.getEString());	94	myAttrToRename.setEType(EcorePackage.eINSTANCE.getEString());
89	myWidenedRef.setName("myWidenedRef");	95	myWidenedRef1.setName("myWidenedRef1");
90	myWidenedRef.setUpperBound(-1);	96	myWidenedRef1.setUpperBound(-1);
91	myWidenedRef.setContainment(true);	97	myWidenedRef1.setContainment(true);
92	myWidenedRef.setEType(mNarrowClass);	98	myWidenedRef1.setEType(mNarrowClass);
		99	myWidenedRef2.setName("myWidenedRef2");
		100	myWidenedRef2.setUpperBound(-1);
		101	myWidenedRef2.setContainment(true);
		102	myWidenedRef2.setEType(mNarrowClass);
93	myAttrNarrow.setName("myNarrowAttr");	103	myAttrNarrow.setName("myNarrowAttr");
94	myAttrNarrow.setEType(EcorePackage.eINSTANCE.getEString());	104	myAttrNarrow.setEType(EcorePackage.eINSTANCE.getEString());
95	myAttrNarrowChild.setName("myNarrowChildAttr");	105	myAttrNarrowChild.setName("myNarrowChildAttr");
		106	myAttrNarrowChild.setLowerBound(1);
96	myAttrNarrowChild.setEType(EcorePackage.eINSTANCE.getEString());	107	myAttrNarrowChild.setEType(EcorePackage.eINSTANCE.getEString());
		108	return mmPackage;
97	}	109	}
98		110
99	private EObject newInstance() {	111	private EObject newInstance() {
Lines 101-107 Link Here
101	}	113	}
102		114
103	private EObject newNarrowInstance() {	115	private EObject newNarrowInstance() {
104	return getMetaModel().getEFactoryInstance().create(myWidenedRef.getEReferenceType());	116	return getMetaModel().getEFactoryInstance().create(myAttrNarrow.getEContainingClass());
105	}	117	}
106		118
107	private EObject newNarrowChildInstance() {	119	private EObject newNarrowChildInstance() {
Lines 109-506 Link Here
109	}	121	}
110		122
111	private EPackage getMetaModel() {	123	private EPackage getMetaModel() {
112	return myAttrToRemove.getEContainingClass().getEPackage();	124	return myWidenedRef1.getEContainingClass().getEPackage();
113	}	125	}
114		126
115	public void oldTestRemovedAttribute() {	127	private boolean checkResourceHasNoProblems(Resource migratedResource) {
116	final EObject testObject = newInstance();	128	assertNotNull(migratedResource);
117	testObject.eSet(myAttrToRemove, "value");	129	assertTrue(migratedResource.getErrors().isEmpty());
		130	if (migratedResource instanceof MigrationResource) {
		131	assertFalse(migratedResource.getWarnings().isEmpty());
		132	assertEquals(1, migratedResource.getWarnings().size());
		133	assertTrue(migratedResource.getWarnings().get(0) instanceof MigrationResource.Diagnostic);
		134	} else {
		135	assertTrue(migratedResource.getWarnings().isEmpty());
		136	}
		137	boolean validate = true;
		138	for (Iterator<EObject> it=migratedResource.getAllContents(); it.hasNext() && validate;) {
		139	validate = EcoreValidator.INSTANCE.validate(it.next(), null, null);
		140	}
		141	return validate;
		142	}
		143
		144	private String assertLoadingProblemsAfterMetamodelChanges(EPackage metamodel, URI modelResource) {
		145	String errorMessage = null;
		146	// try to load mm
		147	try {
		148	ResourceSetImpl rset = new ResourceSetImpl();
		149	rset.getPackageRegistry().put(metamodel.getNsURI(), metamodel);
		150	Resource resource = rset.createResource(modelResource);
		151	resource.load(null);
		152	fail("Load should fail because of metamodel changes");
		153	} catch (RuntimeException ex) {
		154	// expected
		155	assertNotNull(ex.getMessage());
		156	errorMessage = ex.getMessage();
		157	} catch (IOException ex) {
		158	// expected
		159	assertNotNull(ex.getMessage());
		160	errorMessage = ex.getMessage();
		161	}
118		162
119	final String oldNsURI = getMetaModel().getNsURI();	163	return errorMessage;
120	EPackage.Registry.INSTANCE.put(oldNsURI, getMetaModel());	164	}
121	final String newNsURI = oldNsURI + "/2";
122	EPackage.Registry.INSTANCE.put(newNsURI, getMetaModel());
123		165
		166	private URI saveToResource(EPackage metamodel, String filenameStart, String fileextension, EObject... rootObjects) {
		167	URI uri = null;
		168	Collection<EObject> roots = Arrays.asList(rootObjects);
124	try {	169	try {
125	URI uri = null;	170	uri = URI.createFileURI(File.createTempFile(filenameStart, fileextension.startsWith(".") ? fileextension : "."+fileextension).getAbsolutePath());
126	try {	171	ResourceSetImpl resourceSetImpl = new ResourceSetImpl();
127	uri = URI.createFileURI(File.createTempFile("removed", ".tests").getAbsolutePath());	172	resourceSetImpl.getPackageRegistry().put(metamodel.getNsURI(), metamodel);
128	final ResourceSetImpl resourceSetImpl = new ResourceSetImpl();	173	Resource res = resourceSetImpl.createResource(uri);
129	final Resource res = resourceSetImpl.createResource(uri);	174	res.getContents().addAll(roots);
130	res.getContents().add(testObject);	175	res.save(null);
131	res.save(null);	176	resourceSetImpl.getResources().removeAll(roots);
132	resourceSetImpl.getResources().remove(testObject);	177	} catch (IOException ex) {
133	} catch (IOException ex) {	178	fail(ex.toString());
134	fail(ex.toString());	179	}
135	}	180	return uri;
136	// remove attr from metamodel	181	}
137	myAttrToRemove.getEContainingClass().getEStructuralFeatures().remove(myAttrToRemove);
138		182
139	// try to load mm	183	protected void checkNarrowedInstanceAttribute(EObject narrowInstance, EAttribute attribute, String attrValue) {
140	try {	184	assertEquals(narrowInstance.eClass(), attribute.getEContainingClass());
141	new ResourceSetImpl().createResource(uri).load(null);	185	assertTrue(narrowInstance.eIsSet(attribute));
142	fail("Load should fail because of missing meta-model attribute");	186	Object haveValue = narrowInstance.eGet(attribute, true);
143	} catch (IOException ex) {	187	assertEquals(attrValue, haveValue);
144	// expected	188	}
145	assertNotNull(ex.getMessage());	189
146	assertTrue(ex.getMessage().contains(myAttrToRemove.getName()));	190	protected List<EObject> checkReferenceIsNarrowed(EObject migratedObj, EReference widenedRef) {
		191	List<EObject> result = null;
		192	assertTrue(migratedObj.eIsSet(widenedRef));
		193	Object narrowRef = migratedObj.eGet(widenedRef, true);
		194	if (widenedRef.isMany()) {
		195	result = new ArrayList<EObject>();
		196	assertTrue(narrowRef instanceof EList);
		197	EList narrowRefs = (EList) narrowRef;
		198	assertFalse(narrowRefs.isEmpty());
		199	for (int i=0; i<narrowRefs.size(); i++) {
		200	Object migratedNarrowRefs = narrowRefs.get(i);
		201	assertTrue(migratedNarrowRefs instanceof EObject);
		202	EObject narrowInstance = (EObject) migratedNarrowRefs;
		203	result.add(narrowInstance);
147	}	204	}
		205	} else {
		206	assertTrue(narrowRef instanceof EObject);
		207	EObject narrowInstance = (EObject) narrowRef;
		208	result = Collections.singletonList(narrowInstance);
		209	}
		210	return result;
		211	}
		212
		213	private void checkInstanceClassChanged(EObject narrowInstance, EReference widenedReference) {
		214	assertFalse(narrowInstance.eClass().isAbstract());
		215	assertFalse(narrowInstance.eClass().equals(widenedReference.getEType()));
		216	}
		217
		218	private void widenReferenceTypeFrom(EReference refToBeWiden, EClass containingClass, EPackage metamodel) {
		219	EClass mWideClass = EcoreFactory.eINSTANCE.createEClass();
		220	refToBeWiden.getEContainingClass().getEPackage().getEClassifiers().add(mWideClass);
		221	mWideClass.setName("WideClass");
		222	mWideClass.setAbstract(true);
		223	refToBeWiden.setEType(mWideClass);
		224	EList<EClass> supertypes = containingClass.getESuperTypes();
		225	if (!supertypes.contains(mWideClass)) {
		226	supertypes.add(mWideClass);
		227	}
		228	}
148		229
149	EPackage.Registry.INSTANCE.put(oldNsURI, null);	230	private EList<EObject> create2DifferentReferences(String attrValue, String attrChildValue) {
		231	final EList<EObject> narrowInstances = new BasicEList<EObject>();
		232	if (attrValue != null) {
		233	EObject narrowInstance = newNarrowInstance();
		234	narrowInstance.eSet(myAttrNarrow, attrValue);
		235	narrowInstances.add(narrowInstance);
		236	}
		237	if (attrChildValue != null) {
		238	EObject narrowChildInstance = newNarrowChildInstance();
		239	narrowChildInstance.eSet(myAttrNarrowChild, attrChildValue);
		240	narrowInstances.add(narrowChildInstance);
		241	}
		242	return narrowInstances;
		243	}
150		244
151	// MigrationConfig.Registry.INSTANCE.register(new MigrationConfig.Descriptor() {	245	private EList<EObject> createNarrowReferences(String attrValue) {
152	// private final MigrationConfig cfg = new MigrationConfig(newNsURI, new String[] { oldNsURI });	246	final EList<EObject> narrowInstances = new BasicEList<EObject>();
153	// {	247	if (attrValue != null) {
154	// cfg.registerDeletedAttribute(testObject.eClass(), myAttrToRemove.getName());	248	EObject narrowInstance = newNarrowInstance();
155	// }	249	narrowInstance.eSet(myAttrNarrow, attrValue);
156	//	250	narrowInstances.add(narrowInstance);
157	// public MigrationConfig getConfig() {
158	// return cfg;
159	// }
160	//
161	// public String getExtension() {
162	// return "tests";
163	// }
164	//
165	// });
166	// Resource migrated = MigrationUtil.migrateModel(uri).getLoadedResource();
167	// assertNotNull(migrated);
168	// assertTrue(migrated.getErrors().isEmpty() && migrated.getWarnings().isEmpty());
169	// assertEquals(1, migrated.getContents().size());
170	// EObject migratedObj = migrated.getContents().get(0);
171	// assertEquals(testObject.eClass(), migratedObj.eClass());
172	} finally {
173	// clean-up, avoid any chances to affect other tests
174	// XXX MigrationConfig should be cleaned as well.
175	EPackage.Registry.INSTANCE.put(oldNsURI, null);
176	EPackage.Registry.INSTANCE.put(newNsURI, null);
177	}	251	}
		252	return narrowInstances;
		253	}
		254
		255	private EObject createRootWithReferences(EReference reference, EList<EObject> referenceValues) {
		256	final EObject testObject1 = newInstance();
		257	testObject1.eSet(reference, referenceValues);
		258	return testObject1;
178	}	259	}
179		260
180	public void testRemovedAttribute() {	261	public void testRemovedAttribute() {
181	final EObject testObject = newInstance();	262	final EObject testObject = newInstance();
182	testObject.eSet(myAttrToRemove, "value");	263	testObject.eSet(myAttrToRemove, "value");
183		264
184	final String oldNsURI = getMetaModel().getNsURI();	265	EPackage metamodel = getMetaModel();
185	EPackage.Registry.INSTANCE.put(oldNsURI, getMetaModel());	266	URI uri = saveToResource(metamodel, "removed", "tests", testObject);
186	final String newNsURI = oldNsURI + "/2";	267
187	EPackage.Registry.INSTANCE.put(newNsURI, getMetaModel());	268	// remove attr from metamodel
188		269	myAttrToRemove.getEContainingClass().getEStructuralFeatures().remove(myAttrToRemove);
189	try {
190	URI uri = null;
191	try {
192	uri = URI.createFileURI(File.createTempFile("removed", ".tests").getAbsolutePath());
193	final ResourceSetImpl resourceSetImpl = new ResourceSetImpl();
194	final Resource res = resourceSetImpl.createResource(uri);
195	res.getContents().add(testObject);
196	res.save(null);
197	resourceSetImpl.getResources().remove(testObject);
198	} catch (IOException ex) {
199	fail(ex.toString());
200	}
201	// remove attr from metamodel
202	myAttrToRemove.getEContainingClass().getEStructuralFeatures().remove(myAttrToRemove);
203
204	// try to load mm
205	try {
206	new ResourceSetImpl().createResource(uri).load(null);
207	fail("Load should fail because of missing meta-model attribute");
208	} catch (IOException ex) {
209	// expected
210	assertNotNull(ex.getMessage());
211	assertTrue(ex.getMessage().contains(myAttrToRemove.getName()));
212	}
213
214	EPackage.Registry.INSTANCE.put(oldNsURI, null);
215
216	Resource.Factory factory = new ToolingResourceFactory() {
217		270
218	@Override	271	String errorMessage = assertLoadingProblemsAfterMetamodelChanges(metamodel, uri);
219	public Resource createResource(URI uri) {	272	assertTrue(errorMessage.contains(myAttrToRemove.getName()));
220	return new MigrationResource(uri) {
221	protected MigrationHelperDelegate createDelegate() {
222	MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {
223	{
224	registerDeletedAttributes(testObject.eClass(), myAttrToRemove.getName());
225	}
226	};
227	return delegate;
228	}
229		273
230	protected Collection<String> getBackwardSupportedURIs() {	274	final MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {{
231	return Collections.singleton(oldNsURI);	275	registerDeletedAttributes(testObject.eClass(), myAttrToRemove.getName());
232	}	276	}};
		277	Resource migrated = loadMigrationResource(metamodel, delegate, uri);
		278	checkResourceHasNoProblems(migrated);
		279
		280	assertEquals(1, migrated.getContents().size());
		281	EObject migratedObj = migrated.getContents().get(0);
		282	assertEquals(testObject.eClass(), migratedObj.eClass());
233		283
234	protected String getMetamodelNsURI() {
235	return newNsURI;
236	}
237	};
238	}
239
240	};
241	Resource migrated = createLoadHelper(factory, uri).getLoadedResource();
242	assertNotNull(migrated);
243	assertTrue(migrated.getErrors().isEmpty());
244	assertFalse(migrated.getWarnings().isEmpty());
245	assertEquals(1, migrated.getContents().size());
246	EObject migratedObj = migrated.getContents().get(0);
247	assertEquals(testObject.eClass(), migratedObj.eClass());
248	} finally {
249	// clean-up, avoid any chances to affect other tests
250	// XXX MigrationConfig should be cleaned as well.
251	EPackage.Registry.INSTANCE.put(oldNsURI, null);
252	EPackage.Registry.INSTANCE.put(newNsURI, null);
253	}
254	}	284	}
255		285
256	public void testWidenedReference() {	286	public void testWidenedReference() {
257	final EObject testObject = newInstance();	287	final String attrValue = "narrow value";
258	EObject narrowValue = newNarrowInstance();	288	final EList<EObject> narrowValues = createNarrowReferences(attrValue);
259	String attrValue = "narrow value";	289	final EObject testObject = createRootWithReferences(myWidenedRef1, narrowValues);
260
261	narrowValue.eSet(myAttrNarrow, attrValue);
262	EList narrowValues = new BasicEList();
263	narrowValues.add(narrowValue);
264	testObject.eSet(myWidenedRef, narrowValues);
265		290
266	EPackage metamodel = getMetaModel();	291	EPackage metamodel = getMetaModel();
		292	URI uri = saveToResource(metamodel, "widened", "tests", testObject);
		293
		294	// widen reference in metamodel
		295	widenReferenceTypeFrom(myWidenedRef1, myAttrNarrow.getEContainingClass(), metamodel);
		296
		297	// try to load mm
		298	String errorMessage = assertLoadingProblemsAfterMetamodelChanges(getMetaModel(), uri);
		299	//assertTrue(errorMessage.contains(myWidenedRef1.getEType().getName())); //XXX check
267		300
268	final String oldNsURI = metamodel.getNsURI();	301	MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {{
269	EPackage.Registry.INSTANCE.put(oldNsURI, metamodel);	302	registerNarrowReferenceType(myWidenedRef1, myAttrNarrow.getEContainingClass());
270	final String newNsURI = oldNsURI + "/2";	303	}};
271	EPackage.Registry.INSTANCE.put(newNsURI, metamodel);	304
		305	// try to load mm
		306	Resource migrated = loadMigrationResource(metamodel, delegate, uri);
		307	checkResourceHasNoProblems(migrated);
		308
		309	assertEquals(1, migrated.getContents().size());
		310	EObject migratedObj = migrated.getContents().get(0);
		311	assertEquals(testObject.eClass(), migratedObj.eClass());
		312
		313	List<EObject> narrowed = checkReferenceIsNarrowed(migratedObj, myWidenedRef1);
		314	assertEquals(1, narrowed.size());
		315
		316	EObject narrowInstance = narrowed.get(0);
		317	checkInstanceClassChanged(narrowInstance, myWidenedRef1);
		318	checkNarrowedInstanceAttribute(narrowInstance, myAttrNarrow, attrValue);
		319	}
272		320
273	try {	321	public void testWidenedReferenceWith2Types() {
274	URI uri = null;	322	final String attrValue = "narrow value";
275	try {	323	final String attrChildValue = "narrow child value";
276	uri = URI.createFileURI(File.createTempFile("widened", ".tests").getAbsolutePath());	324	final EList<EObject> narrowValues = create2DifferentReferences(attrValue, attrChildValue);
277	final ResourceSetImpl resourceSetImpl = new ResourceSetImpl();	325	final EObject testObject = createRootWithReferences(myWidenedRef1, narrowValues);
278	final Resource res = resourceSetImpl.createResource(uri);
279	res.getContents().add(testObject);
280	res.save(null);
281	resourceSetImpl.getResources().remove(testObject);
282	} catch (IOException ex) {
283	fail(ex.toString());
284	}
285
286	// widen reference in metamodel
287
288	EClass mWideClass = EcoreFactory.eINSTANCE.createEClass();
289	myWidenedRef.getEContainingClass().getEPackage().getEClassifiers().add(mWideClass);
290	mWideClass.setName("WideClass");
291	mWideClass.setAbstract(true);
292	myWidenedRef.setEType(mWideClass);
293	myAttrNarrow.getEContainingClass().getESuperTypes().add(mWideClass);
294
295	// try to load mm
296	try {
297	new ResourceSetImpl().createResource(uri).load(null);
298	fail("Load should fail because of unknown meta-model attribute");
299	} catch (RuntimeException ex) {
300	// expected
301	assertNotNull(ex.getMessage());
302	} catch (IOException ex) {
303	// expected
304	assertNotNull(ex.getMessage());
305	}
306		326
307	EPackage.Registry.INSTANCE.put(oldNsURI, null);	327	EPackage metamodel = getMetaModel();
		328	URI uri = saveToResource(metamodel, "widened2Types", "tests", testObject);
308		329
309	Resource.Factory factory = new ToolingResourceFactory() {	330	// widen reference in metamodel
		331	widenReferenceTypeFrom(myWidenedRef1, myAttrNarrow.getEContainingClass(), metamodel);
310		332
311	@Override	333	// try to load mm
312	public Resource createResource(URI uri) {	334	String errorMessage = assertLoadingProblemsAfterMetamodelChanges(metamodel, uri);
313	return new MigrationResource(uri) {	335	// assertTrue(errorMessage.contains(myWidenedRef1.getEType().getName())); //XXX
314	protected MigrationHelperDelegate createDelegate() {	336
315	MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {	337	MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {{
316	{	338	registerNarrowReferenceType(myWidenedRef1, myAttrNarrow.getEContainingClass());
317	registerNarrowReferenceType(myWidenedRef, myAttrNarrow.getEContainingClass());	339	}};
318	}	340
319	};	341	// try to load mm
320	return delegate;	342	Resource migrated = loadMigrationResource(metamodel, delegate, uri);
321	}	343	checkResourceHasNoProblems(migrated);
		344
		345	assertEquals(1, migrated.getContents().size());
		346	EObject migratedObj = migrated.getContents().get(0);
		347	assertEquals(testObject.eClass(), migratedObj.eClass());
		348
		349	List<EObject> narrowed = checkReferenceIsNarrowed(migratedObj, myWidenedRef1);
		350	assertEquals(2, narrowed.size());
		351
		352	EObject narrowInstance1 = narrowed.get(0);
		353	checkInstanceClassChanged(narrowInstance1, myWidenedRef1);
		354	checkNarrowedInstanceAttribute(narrowInstance1, myAttrNarrow, attrValue);
		355
		356	EObject narrowInstance2 = narrowed.get(1);
		357	checkInstanceClassChanged(narrowInstance2, myWidenedRef1);
		358	checkNarrowedInstanceAttribute(narrowInstance2, myAttrNarrowChild, attrChildValue);
		359	}
		360
		361	public void test2WidenedReferences() {
		362	final String attrValue1 = "narrow value 1";
		363	final EList<EObject> narrowValues1 = createNarrowReferences(attrValue1);
		364	final EObject testObject1 = createRootWithReferences(myWidenedRef1, narrowValues1);
		365	final String attrValue2 = "narrow value 2";
		366	final String attrChildValue2 = "narrow child value 2";
		367	final EList<EObject> narrowValues2 = create2DifferentReferences(attrValue2, attrChildValue2);
		368	final EObject testObject2 = createRootWithReferences(myWidenedRef2, narrowValues2);
		369	final String attrValue3 = "narrow value 3";
		370	final EList<EObject> narrowValues3 = createNarrowReferences(attrValue3);
		371	final EObject testObject3 = createRootWithReferences(myWidenedRef1, narrowValues3);
		372	final String attrValue4 = "narrow value 4";
		373	final EList<EObject> narrowValues4 = createNarrowReferences(attrValue4);
		374	final EObject testObject4 = createRootWithReferences(myWidenedRef2, narrowValues4);
322		375
323	protected Collection<String> getBackwardSupportedURIs() {	376	EPackage metamodel = getMetaModel();
324	return Collections.<String>singleton(oldNsURI);	377	URI uri = saveToResource(metamodel, "widened2Refs", "tests", testObject1, testObject2, testObject3, testObject4);
325	}
326		378
327	@Override	379	// widen reference in metamodel
328	protected String getMetamodelNsURI() {	380	widenReferenceTypeFrom(myWidenedRef1, myAttrNarrow.getEContainingClass(), metamodel);
329	return newNsURI;	381	widenReferenceTypeFrom(myWidenedRef2, myAttrNarrow.getEContainingClass(), metamodel);
330	}	382
331	};	383	// try to load mm
332	}	384	String errorMessage = assertLoadingProblemsAfterMetamodelChanges(metamodel, uri);
333		385	// assertTrue(errorMessage.contains(myAttrNarrow.getName())); //XXX
334	};	386
335		387	MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {{
336	// try to load mm	388	registerNarrowReferenceType(myWidenedRef1, myAttrNarrow.getEContainingClass());
337	Resource migrated = createLoadHelper(factory, uri).getLoadedResource();	389	registerNarrowReferenceType(myWidenedRef2, myAttrNarrow.getEContainingClass());
338	assertNotNull(migrated);	390	}};
339	assertTrue(migrated.getErrors().isEmpty());	391
340	assertFalse(migrated.getWarnings().isEmpty());	392	// try to load mm
341	assertEquals(1, migrated.getContents().size());	393	Resource migrated = loadMigrationResource(metamodel, delegate, uri);
342	EObject migratedObj = migrated.getContents().get(0);	394	checkResourceHasNoProblems(migrated);
343	assertEquals(testObject.eClass(), migratedObj.eClass());	395
344		396	assertEquals(4, migrated.getContents().size());
345	assertTrue(migratedObj.eIsSet(myWidenedRef));	397
346	Object narrowRef = migratedObj.eGet(myWidenedRef, true);	398	EObject migratedObj1 = migrated.getContents().get(0);
347	assertTrue(narrowRef instanceof EList);	399	assertEquals(testObject1.eClass(), migratedObj1.eClass());
348	EList narrowRefs = (EList) narrowRef;	400
349	assertFalse(narrowRefs.isEmpty());	401	List<EObject> narrowed1 = checkReferenceIsNarrowed(migratedObj1, myWidenedRef1);
350	assertEquals(1, narrowRefs.size());	402	assertEquals(1, narrowed1.size());
351	Object narrowRefsFirst = narrowRefs.get(0);	403	checkReferenceIsNarrowed(migratedObj1, myWidenedRef1);
352	assertTrue(narrowRefsFirst instanceof EObject);	404
353	EObject narrowInstance = (EObject) narrowRefsFirst;	405	EObject narrowed1first = narrowed1.get(0);
354	assertFalse(narrowInstance.eClass().isAbstract());	406	checkNarrowedInstanceAttribute(narrowed1first, myAttrNarrow, attrValue1);
355	assertFalse(narrowInstance.eClass().equals(myWidenedRef.getEType()));	407
356	assertEquals(narrowInstance.eClass(), myAttrNarrow.getEContainingClass());	408	EObject migratedObj2 = migrated.getContents().get(1);
357	assertTrue(narrowInstance.eIsSet(myAttrNarrow));	409	assertEquals(testObject2.eClass(), migratedObj2.eClass());
358	Object haveValue = narrowInstance.eGet(myAttrNarrow, true);	410
359	assertEquals(attrValue, haveValue);	411	List<EObject> narrowed2 = checkReferenceIsNarrowed(migratedObj2, myWidenedRef2);
360	} finally {	412	assertEquals(2, narrowed2.size());
361	// clean-up, avoid any chances to affect other tests	413	checkReferenceIsNarrowed(migratedObj2, myWidenedRef2);
362	EPackage.Registry.INSTANCE.put(oldNsURI, null);	414
363	EPackage.Registry.INSTANCE.put(newNsURI, null);	415	EObject narrowed2first = narrowed2.get(0);
364	}	416	checkNarrowedInstanceAttribute(narrowed2first, myAttrNarrow, attrValue2);
		417
		418	EObject narrowed2second = narrowed2.get(1);
		419	checkNarrowedInstanceAttribute(narrowed2second, myAttrNarrowChild, attrChildValue2);
		420
		421	EObject migratedObj3 = migrated.getContents().get(2);
		422	assertEquals(testObject3.eClass(), migratedObj3.eClass());
		423
		424	List<EObject> narrowed3 = checkReferenceIsNarrowed(migratedObj3, myWidenedRef1);
		425	assertEquals(1, narrowed3.size());
		426	checkReferenceIsNarrowed(migratedObj3, myWidenedRef1);
		427
		428	EObject narrowed3first = narrowed3.get(0);
		429	checkNarrowedInstanceAttribute(narrowed3first, myAttrNarrow, attrValue3);
		430
		431	EObject migratedObj4 = migrated.getContents().get(3);
		432	assertEquals(testObject4.eClass(), migratedObj4.eClass());
		433
		434	List<EObject> narrowed4 = checkReferenceIsNarrowed(migratedObj4, myWidenedRef2);
		435	assertEquals(1, narrowed3.size());
		436	checkReferenceIsNarrowed(migratedObj4, myWidenedRef2);
		437
		438	EObject narrowed4first = narrowed4.get(0);
		439	checkNarrowedInstanceAttribute(narrowed4first, myAttrNarrow, attrValue4);
365	}	440	}
366		441
367	public void testWidenedReferenceWith2Types() {	442	public void testWidenedReferenceWithDifferentDefaults() {
368	final EObject testObject = newInstance();	443	// create model based on current metamodel
369	EObject narrowValue = newNarrowInstance();
370	String attrValue = "narrow value";	444	String attrValue = "narrow value";
371	EObject narrowChildValue = newNarrowChildInstance();
372	String attrChildValue = "narrow child value";	445	String attrChildValue = "narrow child value";
373		446	final EList<EObject> narrowValues = create2DifferentReferences(attrValue, attrChildValue);
374	narrowValue.eSet(myAttrNarrow, attrValue);	447	final EObject testObject = createRootWithReferences(myWidenedRef1, narrowValues);
375	narrowChildValue.eSet(myAttrNarrowChild, attrChildValue);
376	EList narrowValues = new BasicEList();
377	narrowValues.add(narrowValue);
378	narrowValues.add(narrowChildValue);
379	testObject.eSet(myWidenedRef, narrowValues);
380		448
381	EPackage metamodel = getMetaModel();	449	EPackage metamodel = getMetaModel();
382		450	URI uri = saveToResource(metamodel, "widened2Defaults", "tests", testObject);
383	final String oldNsURI = metamodel.getNsURI();
384	EPackage.Registry.INSTANCE.put(oldNsURI, metamodel);
385	final String newNsURI = oldNsURI + "/2";
386	EPackage.Registry.INSTANCE.put(newNsURI, metamodel);
387		451
		452	// try to load mm
388	try {	453	try {
389	URI uri = null;	454	ResourceSetImpl resourceSetImpl = new ResourceSetImpl();
390	try {	455	resourceSetImpl.getPackageRegistry().put(metamodel.getNsURI(), metamodel);
391	uri = URI.createFileURI(File.createTempFile("widened2Types", ".tests").getAbsolutePath());	456	Resource ordinaryResource = resourceSetImpl.createResource(uri);
392	final ResourceSetImpl resourceSetImpl = new ResourceSetImpl();	457	ordinaryResource.load(null);
393	final Resource res = resourceSetImpl.createResource(uri);	458	boolean validate = checkResourceHasNoProblems(ordinaryResource);
394	res.getContents().add(testObject);	459	assertTrue("Should not fail with obligatory metamodel attribute not set", validate);
395	res.save(null);	460	} catch (RuntimeException ex) {
396	resourceSetImpl.getResources().remove(testObject);	461	fail();
397	} catch (IOException ex) {	462	} catch (IOException ex) {
398	fail(ex.toString());	463	fail();
399	}	464	}
400		465	MigrationHelperDelegate badDelegate = new MigrationHelperDelegateImpl() {{
401	// widen reference in metamodel	466	registerNarrowReferenceType(myWidenedRef1, myAttrNarrowChild.getEContainingClass());
402		467	}};
403	EClass mWideClass = EcoreFactory.eINSTANCE.createEClass();	468
404	myWidenedRef.getEContainingClass().getEPackage().getEClassifiers().add(mWideClass);	469	// try to load mm
405	mWideClass.setName("WideClass");	470	Resource badMigrated = loadMigrationResource(getMetaModel(), badDelegate, uri);
406	mWideClass.setAbstract(true);	471	checkResourceHasNoProblems(badMigrated);
407	myWidenedRef.setEType(mWideClass);	472	boolean validateBad = checkResourceHasNoProblems(badMigrated);
408	myAttrNarrow.getEContainingClass().getESuperTypes().add(mWideClass);	473	assertFalse("Should fail with obligatory metamodel attribute not set", validateBad);
409		474
410	// try to load mm	475	MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {
411	try {	476	{
412	new ResourceSetImpl().createResource(uri).load(null);	477	registerNarrowReferenceType(myWidenedRef1, myAttrNarrowChild.getEContainingClass());
413	fail("Load should fail because of unknown meta-model attribute");
414	} catch (RuntimeException ex) {
415	// expected
416	assertNotNull(ex.getMessage());
417	} catch (IOException ex) {
418	// expected
419	assertNotNull(ex.getMessage());
420	}	478	}
		479	private Collection<EObject> myToBeChecked = new ArrayList<EObject>();
421		480
422	EPackage.Registry.INSTANCE.put(oldNsURI, null);	481	@Override
423		482	public void processObject(EObject result) {
424	Resource.Factory factory = new ToolingResourceFactory() {	483	super.processObject(result);
425		484	if (myAttrNarrowChild.getEContainingClass().equals(result.eClass())) {
426	@Override	485	myToBeChecked.add(result);
427	public Resource createResource(URI uri) {	486	}
428	return new MigrationResource(uri) {	487	}
429	protected MigrationHelperDelegate createDelegate() {
430	MigrationHelperDelegate delegate = new MigrationHelperDelegateImpl() {
431	{
432	registerNarrowReferenceType(myWidenedRef, myAttrNarrow.getEContainingClass());
433	}
434	};
435	return delegate;
436	}
437
438	protected Collection<String> getBackwardSupportedURIs() {
439	return Collections.<String>singleton(oldNsURI);
440	}
441		488
442	@Override	489	@Override
443	protected String getMetamodelNsURI() {	490	public void postProcess() {
444	return newNsURI;	491	super.postProcess();
		492	for (EObject narrowed : myToBeChecked) {
		493	if (!narrowed.eIsSet(myAttrNarrowChild)) {
		494	EObject defaultTyped = narrowed.eClass().getEPackage().getEFactoryInstance().create((EClass) myWidenedRef1.getEType());
		495	for (EStructuralFeature feature : narrowed.eClass().getEAllStructuralFeatures()) {
		496	if (narrowed.eIsSet(feature)) {
		497	defaultTyped.eSet(feature, narrowed.eGet(feature));
		498	}
445	}	499	}
446	};	500	EObject parent = narrowed.eContainer();
		501	EList children = (EList) parent.eGet(myWidenedRef1);
		502	int index = children.indexOf(narrowed);
		503	children.remove(narrowed);
		504	children.add(index, defaultTyped);
		505	}
447	}	506	}
448		507	}
449	};	508	};
450
451	// try to load mm
452	Resource migrated = createLoadHelper(factory, uri).getLoadedResource();
453	assertNotNull(migrated);
454	assertTrue(migrated.getErrors().isEmpty());
455	assertFalse(migrated.getWarnings().isEmpty());
456	assertEquals(1, migrated.getContents().size());
457	EObject migratedObj = migrated.getContents().get(0);
458	assertEquals(testObject.eClass(), migratedObj.eClass());
459
460	assertTrue(migratedObj.eIsSet(myWidenedRef));
461	Object narrowRefList = migratedObj.eGet(myWidenedRef, true);
462	assertTrue(narrowRefList instanceof EList);
463	EList narrowInstancesList = (EList) narrowRefList;
464	assertFalse(narrowInstancesList.isEmpty());
465	assertEquals(2, narrowInstancesList.size());
466
467	Object narrowRefsFirst = narrowInstancesList.get(0);
468	assertTrue(narrowRefsFirst instanceof EObject);
469	EObject narrowInstance1 = (EObject) narrowRefsFirst;
470	assertFalse(narrowInstance1.eClass().isAbstract());
471	assertFalse(narrowInstance1.eClass().equals(myWidenedRef.getEType()));
472	assertEquals(narrowInstance1.eClass(), myAttrNarrow.getEContainingClass());
473	assertTrue(narrowInstance1.eIsSet(myAttrNarrow));
474	Object haveValue = narrowInstance1.eGet(myAttrNarrow, true);
475	assertEquals(attrValue, haveValue);
476
477	Object narrowRefsSecond = narrowInstancesList.get(1);
478	assertTrue(narrowRefsSecond instanceof EObject);
479	EObject narrowInstance2 = (EObject) narrowRefsSecond;
480	assertFalse(narrowInstance2.eClass().isAbstract());
481	assertFalse(narrowInstance2.eClass().equals(myWidenedRef.getEType()));
482	assertEquals(narrowInstance2.eClass(), myAttrNarrowChild.getEContainingClass());
483	assertTrue(narrowInstance2.eIsSet(myAttrNarrowChild));
484	Object haveChildValue = narrowInstance2.eGet(myAttrNarrowChild, true);
485	assertEquals(attrChildValue, haveChildValue);
486	} finally {
487	// clean-up, avoid any chances to affect other tests
488	EPackage.Registry.INSTANCE.put(oldNsURI, null);
489	EPackage.Registry.INSTANCE.put(newNsURI, null);
490	}
491	}
492		509
493	private static ModelLoadHelper createLoadHelper(final Resource.Factory factory, URI modelResourceURI) {	510	// try to load mm
		511	Resource migrated = loadMigrationResource(getMetaModel(), delegate, uri);
		512	checkResourceHasNoProblems(migrated);
		513	boolean validate = checkResourceHasNoProblems(migrated);
		514	assertTrue("Should not fail with obligatory metamodel attribute not set", validate);
		515
		516	assertEquals(1, migrated.getContents().size());
		517	EObject migratedObj = migrated.getContents().get(0);
		518	assertEquals(testObject.eClass(), migratedObj.eClass());
		519
		520	List<EObject> narrowed = checkReferenceIsNarrowed(migratedObj, myWidenedRef1);
		521	assertEquals(2, narrowed.size());
		522
		523	EObject narrowInstance1 = narrowed.get(0);
		524	assertFalse(narrowInstance1.eClass().isAbstract());
		525	assertTrue(narrowInstance1.eClass().equals(myWidenedRef1.getEType()));
		526	checkNarrowedInstanceAttribute(narrowInstance1, myAttrNarrow, attrValue);
		527
		528	EObject narrowInstance2 = narrowed.get(1);
		529	checkInstanceClassChanged(narrowInstance2, myWidenedRef1);
		530	checkNarrowedInstanceAttribute(narrowInstance2, myAttrNarrowChild, attrChildValue);
		531	}
		532
		533	private Resource loadMigrationResource(EPackage metamodel, MigrationHelperDelegate delegate, URI modelResourceURI) {
494	if(modelResourceURI == null) {	534	if(modelResourceURI == null) {
495	throw new IllegalArgumentException("null resource uri"); //$NON-NLS-1$	535	throw new IllegalArgumentException("null resource uri"); //$NON-NLS-1$
496	}	536	}
497	ResourceSetImpl rset = new ResourceSetImpl();	537	ResourceSetImpl rset = new ResourceSetImpl();
498	rset.setResourceFactoryRegistry(new ResourceFactoryRegistryImpl() {	538	rset.getResources().add(createMigrationResource(delegate, modelResourceURI));
499	public Resource.Factory getFactory(URI uri) {	539	rset.getPackageRegistry().put(metamodel.getNsURI(), metamodel);
500	return factory;	540	return rset.getResource(modelResourceURI, true);
		541	}
		542
		543	private Resource createMigrationResource(final MigrationHelperDelegate delegate, URI modelResourceURI) {
		544	return new MigrationResource(modelResourceURI) {
		545	protected MigrationHelperDelegate createDelegate() {
		546	return delegate;
501	}	547	}
502	});	548	};
503		549	}
504	return new ModelLoadHelper(rset, modelResourceURI);
505	}
506	}	550	}

Lines 26-31 Link Here

(-)src/org/eclipse/gmf/tests/migration/MigrationPatchesTest.java (+61 lines)
26	import org.eclipse.emf.ecore.resource.Resource;	26	import org.eclipse.emf.ecore.resource.Resource;
27	import org.eclipse.emf.ecore.resource.ResourceSet;	27	import org.eclipse.emf.ecore.resource.ResourceSet;
28	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;	28	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
		29	import org.eclipse.gmf.codegen.gmfgen.FeatureLabelModelFacet;
29	import org.eclipse.gmf.codegen.gmfgen.GenAuditContainer;	30	import org.eclipse.gmf.codegen.gmfgen.GenAuditContainer;
30	import org.eclipse.gmf.codegen.gmfgen.GenAuditRoot;	31	import org.eclipse.gmf.codegen.gmfgen.GenAuditRoot;
31	import org.eclipse.gmf.codegen.gmfgen.GenAuditRule;	32	import org.eclipse.gmf.codegen.gmfgen.GenAuditRule;
Lines 33-38 Link Here
33	import org.eclipse.gmf.internal.common.ToolingResourceFactory;	34	import org.eclipse.gmf.internal.common.ToolingResourceFactory;
34	import org.eclipse.gmf.internal.common.migrate.MigrationResource;	35	import org.eclipse.gmf.internal.common.migrate.MigrationResource;
35	import org.eclipse.gmf.internal.common.migrate.ModelLoadHelper;	36	import org.eclipse.gmf.internal.common.migrate.ModelLoadHelper;
		37	import org.eclipse.gmf.mappings.FeatureLabelMapping;
		38	import org.eclipse.gmf.mappings.LabelMapping;
		39	import org.eclipse.gmf.mappings.MappingEntry;
36	import org.eclipse.gmf.tests.Plugin;	40	import org.eclipse.gmf.tests.Plugin;
37		41
38	public class MigrationPatchesTest extends TestCase {	42	public class MigrationPatchesTest extends TestCase {
Lines 171-181 Link Here
171	assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$	175	assertTrue("expected diagnostic exception", caughtGenException != null); //$NON-NLS-1$
172		176
173	assertOnLoadModelMigrationSuccess(genmodelFileName);	177	assertOnLoadModelMigrationSuccess(genmodelFileName);
		178	checkFeatureLabelModelFacetsMigrated(genmodelFileName);
174		179
175	URI newUri = temporarySaveMigratedModel(genmodelFileName, "testFeatureLabelModelFacet", "gmfgen");	180	URI newUri = temporarySaveMigratedModel(genmodelFileName, "testFeatureLabelModelFacet", "gmfgen");
176	changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");	181	changeNsUriToOldOne(newUri, "gmfgen", "http://www.eclipse.org/gmf/2005/GenModel/2.0");
177		182
178	assertOnLoadModelMigrationSuccess(newUri);	183	assertOnLoadModelMigrationSuccess(newUri);
		184	checkFeatureLabelModelFacetsMigrated(newUri);
179	}	185	}
180		186
181	// /*	187	// /*
Lines 317-320 Link Here
317	assertEquals(8, allContentsSize);	323	assertEquals(8, allContentsSize);
318	}	324	}
319		325
		326	public void testNotChangingOrderOfLabelMappings() throws Exception {
		327	URI gmfmapmodelFileName = createURI("testNotChangingOrderOfLabelMappings.gmfmap"); //$NON-NLS-1$
		328	Exception caughtMapException = assertOrdinaryLoadModelProblems(gmfmapmodelFileName);
		329	assertTrue("expected diagnostic exception", caughtMapException != null); //$NON-NLS-1$
		330
		331	assertOnLoadModelMigrationSuccess(gmfmapmodelFileName);
		332	checkOrderOfLabelMappings(gmfmapmodelFileName);
		333
		334	URI newMapUri = temporarySaveMigratedModel(gmfmapmodelFileName, "testNotChangingOrderOfLabelMappings", "gmfmap"); //$NON-NLS-1$ //$NON-NLS-2$
		335	changeNsUriToOldOne(newMapUri, "gmfmap", "http://www.eclipse.org/gmf/2005/mappings/2.0"); //$NON-NLS-1$ //$NON-NLS-2$
		336
		337	assertOnLoadModelMigrationSuccess(newMapUri);
		338	checkOrderOfLabelMappings(newMapUri);
		339	}
		340
		341	private void checkOrderOfLabelMappings(URI modelURI) {
		342	ModelLoadHelper loadHelper = new ModelLoadHelper(new ResourceSetImpl(), modelURI);
		343	Resource res = loadHelper.getLoadedResource();
		344	for (Iterator<EObject> it = res.getAllContents(); it.hasNext();) {
		345	EObject next = it.next();
		346	if (next instanceof MappingEntry) {
		347	MappingEntry nextEntry = (MappingEntry) next;
		348	EList<LabelMapping> labelMappings = nextEntry.getLabelMappings();
		349	assertFalse(labelMappings.isEmpty());
		350	assertEquals(5, labelMappings.size());
		351	checkMapping(labelMappings.get(0), false);
		352	checkMapping(labelMappings.get(1), true);
		353	checkMapping(labelMappings.get(2), false);
		354	checkMapping(labelMappings.get(3), true);
		355	checkMapping(labelMappings.get(4), false);
		356	}
		357	}
		358	}
		359
		360	private void checkMapping(LabelMapping mapping, boolean shouldBeNarrowed) {
		361	assertEquals(shouldBeNarrowed, mapping instanceof FeatureLabelMapping);
		362	assertNotNull(mapping.getDiagramLabel());
		363	if (shouldBeNarrowed) {
		364	assertFalse(((FeatureLabelMapping)mapping).getFeatures().isEmpty());
		365	}
		366	}
		367
		368	private void checkFeatureLabelModelFacetsMigrated(URI uri) {
		369	ModelLoadHelper loadHelper = new ModelLoadHelper(new ResourceSetImpl(), uri);
		370	Resource resource = loadHelper.getLoadedResource();
		371	assertEquals(2, resource.getContents().size());
		372	Object first = resource.getContents().get(0);
		373	assertTrue(first instanceof FeatureLabelModelFacet);
		374	FeatureLabelModelFacet firstFeatureLabelModelFacet = (FeatureLabelModelFacet) first;
		375	assertEquals(1, firstFeatureLabelModelFacet.getMetaFeatures().size());
		376	Object second = resource.getContents().get(1);
		377	assertTrue(second instanceof FeatureLabelModelFacet);
		378	FeatureLabelModelFacet secondFeatureLabelModelFacet = (FeatureLabelModelFacet) second;
		379	assertEquals(2, secondFeatureLabelModelFacet.getMetaFeatures().size());
		380	}
320	}	381	}




<?xml version="1.0" encoding="UTF-8"?>
<xmi:XMI xmi:version="2.0"
    xmlns:xmi="http://www.omg.org/XMI"
    xmlns:gmfgen="http://www.eclipse.org/gmf/2005/GenModel">
  <gmfgen:FeatureLabelModelFacet
      viewPattern="{0}:{1}"
      editPattern="{0}:{1}">
    <metaFeature
        href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore/ENamedElement/name"/>
  </gmfgen:FeatureLabelModelFacet>
  <gmfgen:CompositeFeatureLabelModelFacet
      viewPattern="{0}:{1}"
      editPattern="{0}:{1}">
    <metaFeatures
        href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore/ENamedElement/name"/>
    <metaFeatures
        href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore/EClassifier/defaultValue"/>
  </gmfgen:CompositeFeatureLabelModelFacet>
</xmi:XMI>




<?xml version="1.0" encoding="UTF-8"?>
<gmfmap:Mapping xmi:version="2.0"
    xmlns:xmi="http://www.omg.org/XMI"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:gmfmap="http://www.eclipse.org/gmf/2005/mappings"
    xmlns:gmftool="http://www.eclipse.org/gmf/2005/ToolDefinition">
  <nodes>
    <containmentFeature
        href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EPackage/eClassifiers"/>
    <ownedChild>
      <domainMetaElement
          href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EClass"/>
      <labelMappings>
        <diagramLabel
            href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
      </labelMappings>
      <labelMappings>
        <diagramLabel
            href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
        <features
            href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//ENamedElement/name"/>
      </labelMappings>
      <labelMappings>
        <diagramLabel
            href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
      </labelMappings>
      <labelMappings
          viewPattern="{0}:{1}"
          editPattern="{0}:{1}">
        <diagramLabel
            href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
        <features
            href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//ENamedElement/name"/>
        <features
            href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EClassifier/defaultValue"/>
      </labelMappings>
      <labelMappings>
        <diagramLabel
            href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
      </labelMappings>
    </ownedChild>
  </nodes>
</gmfmap:Mapping>

Lines 8-13 Link Here

(-)plugin.xml (+4 lines)
8	class = "org.eclipse.gmf.codegen.gmfgen.GMFGenPackage"	8	class = "org.eclipse.gmf.codegen.gmfgen.GMFGenPackage"
9	genModel = "models/gmfgen.genmodel" />	9	genModel = "models/gmfgen.genmodel" />
10	<package	10	<package
		11	uri = "http://www.eclipse.org/gmf/2005/GenModel/2.0"
		12	class = "org.eclipse.gmf.codegen.gmfgen.GMFGenPackage"
		13	genModel = "models/gmfgen.genmodel" />
		14	<package
11	uri = "http://www.eclipse.org/gmf/2006/GenModel"	15	uri = "http://www.eclipse.org/gmf/2006/GenModel"
12	class = "org.eclipse.gmf.codegen.gmfgen.GMFGenPackage"	16	class = "org.eclipse.gmf.codegen.gmfgen.GMFGenPackage"
13	genModel = "models/gmfgen.genmodel" />	17	genModel = "models/gmfgen.genmodel" />




 */
package org.eclipse.gmf.internal.codegen.util;

import java.util.Arrays;
import java.util.Collection;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.gmf.codegen.gmfgen.GMFGenPackage;
import org.eclipse.gmf.internal.common.ToolingResourceFactory;
import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;
import org.eclipse.gmf.internal.common.migrate.MigrationResource;

public class GMFGenResource extends MigrationResource {
	private Collection<String> myBackwardSupportedURIs;

	public static class Factory extends ToolingResourceFactory {
		@Override

		migrationHelper.init();
		return migrationHelper;
	}

	@Override
	protected Collection<String> getBackwardSupportedURIs() {
		if (myBackwardSupportedURIs == null) {
			myBackwardSupportedURIs = Arrays.asList(new String[] {
					"http://www.eclipse.org/gmf/2005/GenModel", //$NON-NLS-1$
					"http://www.eclipse.org/gmf/2005/GenModel/2.0" //$NON-NLS-1$
			});
		}
		return myBackwardSupportedURIs;
	}

	@Override
	protected String getMetamodelNsURI() {
		return GMFGenPackage.eNS_URI;
	}

}




 */
package org.eclipse.gmf.internal.codegen.util;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.emf.ecore.EAttribute;
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.internal.common.migrate.MigrationHelperDelegateImpl;

class MigrationDelegate extends MigrationHelperDelegateImpl {
	private EReference myGenAuditContainer_ChildContainers;
	private EReference myGenAuditContainer_Audits;
	private EAttribute myGenAuditRoot_Id;
	private EAttribute myGenAuditRoot_Name;
	private EAttribute myGenAuditRoot_Description;
	private GenAuditContainer myRootContainer;
	private Collection<String> myBackwardSupportedURIs;
	
	MigrationDelegate() {
	}

						"diagramFileCreatorClassName", //$NON-NLS-1$
						"preferenceInitializerClassName" //$NON-NLS-1$
		);
		registerDeletedAttributes(GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet(), "metaFeature"); //$NON-NLS-1$
		registerDeletedAttributes(GMFGenPackage.eINSTANCE.getProviderClassNames(), 
						"abstractParserClassName", //$NON-NLS-1$
						"structuralFeatureParserClassName", //$NON-NLS-1$

			renamings.put("metaFeature", GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet_MetaFeatures()); //$NON-NLS-1$
			registerRenamedAttributes(GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet(), renamings);
		}
		registerRenamedType("CompositeFeatureLabelModelFacet", GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet()); //$NON-NLS-1$
		myGenAuditContainer_ChildContainers = createNewReference("childContainers", GMFGenPackage.eINSTANCE.getGenAuditContainer(), true); //$NON-NLS-1$
		myGenAuditContainer_Audits = createNewReference("audits", GMFGenPackage.eINSTANCE.getGenAuditRule(), true); //$NON-NLS-1$
		myGenAuditRoot_Id = (EAttribute) EcoreUtil.copy(GMFGenPackage.eINSTANCE.getGenAuditContainer_Id());
		myGenAuditRoot_Name = (EAttribute) EcoreUtil.copy(GMFGenPackage.eINSTANCE.getGenAuditContainer_Name());
		myGenAuditRoot_Description = (EAttribute) EcoreUtil.copy(GMFGenPackage.eINSTANCE.getGenAuditContainer_Description());
		ourGenAuditContainer_Audits = new EReferenceImpl() {};
		ourGenAuditContainer_Audits.setName("audits"); //$NON-NLS-1$
		ourGenAuditContainer_Audits.setEType(GMFGenPackage.eINSTANCE.getGenAuditRule());
		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(myGenAuditContainer_Audits.getName(), myGenAuditContainer_Audits);
			renamings.put(myGenAuditContainer_ChildContainers.getName(), myGenAuditContainer_ChildContainers);
			registerRenamedAttributes(GMFGenPackage.eINSTANCE.getGenAuditContainer(), renamings);
		}
		{
			Map<String, EStructuralFeature> renamings = new HashMap<String, EStructuralFeature>();
			renamings.put(myGenAuditContainer_Audits.getName(), myGenAuditContainer_Audits);
			renamings.put(myGenAuditContainer_ChildContainers.getName(), myGenAuditContainer_ChildContainers);
			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 isOldVersionDetected(String uriString) {
		return !getMetamodelNsURI().equals(uriString) && getBackwardSupportedURIs().contains(uriString);
	}

	@Override
	public boolean setValue(EObject object, EStructuralFeature feature, Object value, int position) {
		if (myGenAuditRoot_Id.equals(feature)) {

			String description = (String) value;
			GenAuditContainer rootContainer = getOrCreateRootContainerOnce(root);
			rootContainer.setDescription(description);
		} else if (myGenAuditContainer_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 (myGenAuditContainer_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 (myGenAuditContainer_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 (myGenAuditContainer_Audits.equals(feature) && object instanceof GenAuditContainer) {
			GenAuditContainer container = (GenAuditContainer)object;
			GenAuditRule rule = (GenAuditRule)value;
			rule.setCategory(container);

		return result;
	}

	protected Collection<String> getBackwardSupportedURIs() {
		if (myBackwardSupportedURIs == null) {
			myBackwardSupportedURIs = Arrays.asList(new String[] {
					"http://www.eclipse.org/gmf/2005/GenModel", //$NON-NLS-1$
					"http://www.eclipse.org/gmf/2005/GenModel/2.0" //$NON-NLS-1$
			});
		}
		return myBackwardSupportedURIs;
	}

	protected String getMetamodelNsURI() {
		return GMFGenPackage.eNS_URI;
	}
}

Lines 8-13 Link Here

(-)plugin.xml (+4 lines)
8	class = "org.eclipse.gmf.mappings.GMFMapPackage"	8	class = "org.eclipse.gmf.mappings.GMFMapPackage"
9	genModel = "models/gmfmap.genmodel" />	9	genModel = "models/gmfmap.genmodel" />
10	<package	10	<package
		11	uri = "http://www.eclipse.org/gmf/2005/mappings/2.0"
		12	class = "org.eclipse.gmf.mappings.GMFMapPackage"
		13	genModel = "models/gmfmap.genmodel" />
		14	<package
11	uri = "http://www.eclipse.org/gmf/2006/mappings"	15	uri = "http://www.eclipse.org/gmf/2006/mappings"
12	class = "org.eclipse.gmf.mappings.GMFMapPackage"	16	class = "org.eclipse.gmf.mappings.GMFMapPackage"
13	genModel = "models/gmfmap.genmodel" />	17	genModel = "models/gmfmap.genmodel" />




 */
package org.eclipse.gmf.internal.map.util;

import java.util.Arrays;
import java.util.Collection;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.gmf.internal.common.ToolingResourceFactory;
import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;
import org.eclipse.gmf.internal.common.migrate.MigrationResource;
import org.eclipse.gmf.mappings.GMFMapPackage;

public class GMFMapResource extends MigrationResource {
	private Collection<String> myBackwardSupportedURIs;
	
	public static class Factory extends ToolingResourceFactory {
		@Override
		public Resource createResource(URI uri) {

		migrationHelper.init();
		return migrationHelper;
	}

	@Override
	protected Collection<String> getBackwardSupportedURIs() {
		if (myBackwardSupportedURIs == null) {
			myBackwardSupportedURIs = Arrays.asList(new String[] {
					"http://www.eclipse.org/gmf/2005/mappings", //$NON-NLS-1$
					"http://www.eclipse.org/gmf/2005/mappings/2.0" //$NON-NLS-1$
			});
		}
		return myBackwardSupportedURIs;
	}

	@Override
	protected String getMetamodelNsURI() {
		return GMFMapPackage.eNS_URI;
	}

}




package org.eclipse.gmf.internal.map.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegateImpl;
import org.eclipse.gmf.mappings.FeatureLabelMapping;


class MigrationDelegate extends MigrationHelperDelegateImpl {
	private Collection<FeatureLabelMapping> myFeatureLabelMappings;
	private Collection<String> myBackwardSupportedURIs;
	
	MigrationDelegate() {
	}

	void init() {
		registerNarrowReferenceType(GMFMapPackage.eINSTANCE.getFeatureSeqInitializer_Initializers(), GMFMapPackage.eINSTANCE.getFeatureValueSpec());
		registerNarrowReferenceType(GMFMapPackage.eINSTANCE.getMappingEntry_LabelMappings(), GMFMapPackage.eINSTANCE.getFeatureLabelMapping());
		myFeatureLabelMappings = null;
	}

	@Override
	public boolean isOldVersionDetected(String uriString) {
		return !getMetamodelNsURI().equals(uriString) && getBackwardSupportedURIs().contains(uriString);
	}

	@Override
	public void postProcess() {
		if (myFeatureLabelMappings == null) {
			return;
		}
		for (FeatureLabelMapping mapping : getSavedFeatureLabelMappings()) {
			if (mapping.getFeatures().isEmpty()) {
				MappingEntry entry = mapping.getMapEntry();
				EList<LabelMapping> labelMappings = entry.getLabelMappings();
				int originalIndex = labelMappings.indexOf(mapping);
				if (originalIndex != -1) {
					LabelMapping newMapping = GMFMapPackage.eINSTANCE.getGMFMapFactory().createLabelMapping();
					newMapping.setDiagramLabel(mapping.getDiagramLabel());
					if (mapping.isReadOnly()) {
						newMapping.setReadOnly(true);
					}
					labelMappings.set(originalIndex, newMapping);
				}
				entry.getLabelMappings().add(newMapping);
			}
		}
	}

		}
		return myFeatureLabelMappings;
	}

	protected Collection<String> getBackwardSupportedURIs() {
		if (myBackwardSupportedURIs == null) {
			myBackwardSupportedURIs = Arrays.asList(new String[] {
					"http://www.eclipse.org/gmf/2005/mappings", //$NON-NLS-1$
					"http://www.eclipse.org/gmf/2005/mappings/2.0" //$NON-NLS-1$
			});
		}
		return myBackwardSupportedURIs;
	}

	protected String getMetamodelNsURI() {
		return GMFMapPackage.eNS_URI;
	}
}

Lines 37-42 Link Here

(-)src/org/eclipse/gmf/internal/common/migrate/MigrationHelper.java (-4 / +13 lines)
37	myIsDelegateDisabled = !enabled;	37	myIsDelegateDisabled = !enabled;
38	}	38	}
39		39
		40	boolean isEnabled() {
		41	return !myIsDelegateDisabled;
		42	}
		43
40	@Override	44	@Override
41	public EObject createObject(EFactory factory, EClassifier type) {	45	public EObject createObject(EFactory factory, EClassifier type) {
42	if (myIsDelegateDisabled) {	46	if (myIsDelegateDisabled) {
Lines 104-114 Link Here
104	myDelegate.postProcess();	108	myDelegate.postProcess();
105	}	109	}
106		110
107	protected EStructuralFeature getOriginalFeature(EStructuralFeature feature) {	111	@Override
108	if (myNarrowedFeatureTypes == null) {	112	public void addPrefix(String prefix, String uri) {
109	myNarrowedFeatureTypes = new HashMap<EStructuralFeature, EStructuralFeature>();	113	super.addPrefix(prefix, uri);
		114	if (myDelegate.isOldVersionDetected(uri)) {
		115	enableDelegate(true);
110	}	116	}
111	return myNarrowedFeatureTypes.get(feature);	117	}
		118
		119	protected EStructuralFeature getOriginalFeature(EStructuralFeature feature) {
		120	return myNarrowedFeatureTypes == null ? null : myNarrowedFeatureTypes.get(feature);
112	}	121	}
113		122
114	protected EStructuralFeature addNarrowedFeature(EStructuralFeature originalFeature) {	123	protected EStructuralFeature addNarrowedFeature(EStructuralFeature originalFeature) {




import org.eclipse.emf.ecore.EcorePackage;

public class MigrationHelperDelegateImpl implements MigrationHelperDelegate {
	private final EStructuralFeature myDeletedAttribute = EcoreFactory.eINSTANCE.createEAttribute();

	public MigrationHelperDelegateImpl() {
		super();
		myDeletedAttribute.setName("attributeIsDeleted"); //$NON-NLS-1$
		myDeletedAttribute.setEType(EcorePackage.eINSTANCE.getEString());
	private static EStructuralFeature ourDeletedAttribute = EcoreFactory.eINSTANCE.createEAttribute();
	static {
		ourDeletedAttribute.setName("attributeIsDeleted"); //$NON-NLS-1$
		ourDeletedAttribute.setEType(EcorePackage.eINSTANCE.getEString());
	}

	private Map<EClassifier, Collection<String>> myDeletedAttributes = new HashMap<EClassifier, Collection<String>>();

	}

	public boolean setValue(EObject object, EStructuralFeature feature, Object value, int position) {
		return myDeletedAttribute.equals(feature);
	}

	public EStructuralFeature getFeature(EClass eClass, String namespaceURI, String name, boolean isElement) {
		EStructuralFeature result = null;
		EStructuralFeature rename = null;
		if ((rename = getRenamedFeatureFor(eClass, name)) != null) {
			result = ourDeletedAttribute;
		} else if ((rename = getRenamedFeatureFor(eClass, name)) != null) {
			result = rename;
		} else if (isAttributeDeleted(eClass, name)) {
			result = myDeletedAttribute;
		}
		return result;
	}


	public void processObject(EObject result) {
	}

	public boolean isOldVersionDetected(String uriString) {
		return true;
	}
	
	protected static EReference createNewReference(String name, EClass eType, boolean isContainment) {
		EReference ref = EcoreFactory.eINSTANCE.createEReference();
		ref.setName(name);
		ref.setEType(eType);
		ref.setContainment(isContainment);
		ref.setLowerBound(0);
		ref.setUpperBound(-1);
		return ref;
	}
}

Lines 31-34 Link Here

(-)src/org/eclipse/gmf/internal/common/migrate/MigrationHelperDelegate.java (+2 lines)
31	public void postProcess();	31	public void postProcess();
32		32
33	public void processObject(EObject result);	33	public void processObject(EObject result);
		34
		35	public boolean isOldVersionDetected(String uriString);
34	}	36	}





import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.Map;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.xmi.XMLHelper;
import org.eclipse.emf.ecore.xmi.XMLLoad;
import org.eclipse.emf.ecore.xmi.impl.SAXXMIHandler;
import org.eclipse.emf.ecore.xmi.impl.XMILoadImpl;
import org.eclipse.gmf.internal.common.ToolingResourceFactory.ToolResource;
import org.xml.sax.helpers.DefaultHandler;

public abstract class MigrationResource extends ToolResource {

	private boolean isOldVersionDetected;
	private MigrationHelper myMigrationHelper;

	protected MigrationResource(URI uri) {

	@Override
	public final void doLoad(InputStream inputStream, Map<?,?> options) throws IOException {
		try {
			isOldVersionDetected = false;
			super.doLoad(inputStream, options);
			handlePostLoadSuccess();
		} catch (IOException e) {

		}
	}

	@Override
	protected XMLLoad createXMLLoad() {
		return new XMILoadImpl(createXMLHelper()) {

			@Override
			protected DefaultHandler makeDefaultHandler() {
				return new SAXXMIHandler(resource, helper, options) {
					@Override
					protected EPackage getPackageForURI(String uriString) {
						// FIXME move the check to delegate
						if (!getMetamodelNsURI().equals(uriString) && getBackwardSupportedURIs().contains(uriString)) {
							handleOldVersionDetected();
							return super.getPackageForURI(getMetamodelNsURI());
						}
						return super.getPackageForURI(uriString);
					}
				};
			}
		};
	}

	private void handleOldVersionDetected() {
		if (myMigrationHelper != null) {
			myMigrationHelper.enableDelegate(true);
		}
		isOldVersionDetected = true;
	}

	protected void handlePostLoadSuccess() {
		if (myMigrationHelper != null && myMigrationHelper.isEnabled()) {
			Diagnostic diagnostic = MigrationResource.createMessageDiagnostic(this, Messages.oldModelVersionLoadedMigrationRequired);
			getWarnings().add(0, diagnostic);
		}

		return myMigrationHelper;
	}

	protected abstract Collection<String> getBackwardSupportedURIs();
	protected abstract MigrationHelperDelegate createDelegate();
	protected abstract String getMetamodelNsURI();

	
	/**
	 * Creates resource diagnostic wrapping the given message.
	 * @param resource the resource associated with the created diagnostic

Return to bug 187811

Lines 1-7 Link Here

(-)models/migration/testFeatureLabelModelFacet.gmfgen (-5 / +17 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<gmfgen:FeatureLabelModelFacet xmi:version="2.0"	2	<xmi:XMI xmi:version="2.0"
3	xmlns:xmi="http://www.omg.org/XMI"	3	xmlns:xmi="http://www.omg.org/XMI"
4	xmlns:gmfgen="http://www.eclipse.org/gmf/2005/GenModel">	4	xmlns:gmfgen="http://www.eclipse.org/gmf/2005/GenModel">
5	<metaFeature name="DeletedFeature">	5	<gmfgen:FeatureLabelModelFacet
6	</metaFeature>	6	viewPattern="{0}:{1}"
7	</gmfgen:FeatureLabelModelFacet>	7	editPattern="{0}:{1}">
		8	<metaFeature
		9	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore/ENamedElement/name"/>
		10	</gmfgen:FeatureLabelModelFacet>
		11	<gmfgen:CompositeFeatureLabelModelFacet
		12	viewPattern="{0}:{1}"
		13	editPattern="{0}:{1}">
		14	<metaFeatures
		15	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore/ENamedElement/name"/>
		16	<metaFeatures
		17	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore/EClassifier/defaultValue"/>
		18	</gmfgen:CompositeFeatureLabelModelFacet>
		19	</xmi:XMI>

Added Link Here

(-)models/migration/testNotChangingOrderOfLabelMappings.gmfmap (+43 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<gmfmap:Mapping xmi:version="2.0"
3	xmlns:xmi="http://www.omg.org/XMI"
4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5	xmlns:gmfmap="http://www.eclipse.org/gmf/2005/mappings"
6	xmlns:gmftool="http://www.eclipse.org/gmf/2005/ToolDefinition">
7	<nodes>
8	<containmentFeature
9	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EPackage/eClassifiers"/>
10	<ownedChild>
11	<domainMetaElement
12	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EClass"/>
13	<labelMappings>
14	<diagramLabel
15	href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
16	</labelMappings>
17	<labelMappings>
18	<diagramLabel
19	href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
20	<features
21	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//ENamedElement/name"/>
22	</labelMappings>
23	<labelMappings>
24	<diagramLabel
25	href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
26	</labelMappings>
27	<labelMappings
28	viewPattern="{0}:{1}"
29	editPattern="{0}:{1}">
30	<diagramLabel
31	href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
32	<features
33	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//ENamedElement/name"/>
34	<features
35	href="../../../plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EClassifier/defaultValue"/>
36	</labelMappings>
37	<labelMappings>
38	<diagramLabel
39	href="../../../plugin/org.eclipse.gmf.graphdef/models/basic.gmfgraph#Label"/>
40	</labelMappings>
41	</ownedChild>
42	</nodes>
43	</gmfmap:Mapping>

Lines 10-27 Link Here

(-)src/org/eclipse/gmf/internal/codegen/util/GMFGenResource.java (-22 lines)
10	*/	10	*/
11	package org.eclipse.gmf.internal.codegen.util;	11	package org.eclipse.gmf.internal.codegen.util;
12		12
13	import java.util.Arrays;
14	import java.util.Collection;
15
16	import org.eclipse.emf.common.util.URI;	13	import org.eclipse.emf.common.util.URI;
17	import org.eclipse.emf.ecore.resource.Resource;	14	import org.eclipse.emf.ecore.resource.Resource;
18	import org.eclipse.gmf.codegen.gmfgen.GMFGenPackage;
19	import org.eclipse.gmf.internal.common.ToolingResourceFactory;	15	import org.eclipse.gmf.internal.common.ToolingResourceFactory;
20	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;	16	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;
21	import org.eclipse.gmf.internal.common.migrate.MigrationResource;	17	import org.eclipse.gmf.internal.common.migrate.MigrationResource;
22		18
23	public class GMFGenResource extends MigrationResource {	19	public class GMFGenResource extends MigrationResource {
24	private Collection<String> myBackwardSupportedURIs;
25		20
26	public static class Factory extends ToolingResourceFactory {	21	public static class Factory extends ToolingResourceFactory {
27	@Override	22	@Override
Lines 40-60 Link Here
40	migrationHelper.init();	35	migrationHelper.init();
41	return migrationHelper;	36	return migrationHelper;
42	}	37	}
43
44	@Override
45	protected Collection<String> getBackwardSupportedURIs() {
46	if (myBackwardSupportedURIs == null) {
47	myBackwardSupportedURIs = Arrays.asList(new String[] {
48	"http://www.eclipse.org/gmf/2005/GenModel", //$NON-NLS-1$
49	"http://www.eclipse.org/gmf/2005/GenModel/2.0" //$NON-NLS-1$
50	});
51	}
52	return myBackwardSupportedURIs;
53	}
54
55	@Override
56	protected String getMetamodelNsURI() {
57	return GMFGenPackage.eNS_URI;
58	}
59
60	}	38	}

Lines 10-28 Link Here

(-)src/org/eclipse/gmf/internal/map/util/GMFMapResource.java (-23 lines)
10	*/	10	*/
11	package org.eclipse.gmf.internal.map.util;	11	package org.eclipse.gmf.internal.map.util;
12		12
13	import java.util.Arrays;
14	import java.util.Collection;
15
16	import org.eclipse.emf.common.util.URI;	13	import org.eclipse.emf.common.util.URI;
17	import org.eclipse.emf.ecore.resource.Resource;	14	import org.eclipse.emf.ecore.resource.Resource;
18	import org.eclipse.gmf.internal.common.ToolingResourceFactory;	15	import org.eclipse.gmf.internal.common.ToolingResourceFactory;
19	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;	16	import org.eclipse.gmf.internal.common.migrate.MigrationHelperDelegate;
20	import org.eclipse.gmf.internal.common.migrate.MigrationResource;	17	import org.eclipse.gmf.internal.common.migrate.MigrationResource;
21	import org.eclipse.gmf.mappings.GMFMapPackage;
22		18
23	public class GMFMapResource extends MigrationResource {	19	public class GMFMapResource extends MigrationResource {
24	private Collection<String> myBackwardSupportedURIs;
25
26	public static class Factory extends ToolingResourceFactory {	20	public static class Factory extends ToolingResourceFactory {
27	@Override	21	@Override
28	public Resource createResource(URI uri) {	22	public Resource createResource(URI uri) {
Lines 40-60 Link Here
40	migrationHelper.init();	34	migrationHelper.init();
41	return migrationHelper;	35	return migrationHelper;
42	}	36	}
43
44	@Override
45	protected Collection<String> getBackwardSupportedURIs() {
46	if (myBackwardSupportedURIs == null) {
47	myBackwardSupportedURIs = Arrays.asList(new String[] {
48	"http://www.eclipse.org/gmf/2005/mappings", //$NON-NLS-1$
49	"http://www.eclipse.org/gmf/2005/mappings/2.0" //$NON-NLS-1$
50	});
51	}
52	return myBackwardSupportedURIs;
53	}
54
55	@Override
56	protected String getMetamodelNsURI() {
57	return GMFMapPackage.eNS_URI;
58	}
59
60	}	37	}