| /******************************************************************************* |
| * Copyright (c) 2010, 2018 Willink Transformations and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * E.D.Willink - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ocl.examples.xtext.tests; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.StringWriter; |
| import java.io.Writer; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.emf.common.EMFPlugin; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EAnnotation; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.EDataType; |
| import org.eclipse.emf.ecore.EModelElement; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EOperation; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.ETypedElement; |
| import org.eclipse.emf.ecore.plugin.EcorePlugin; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.resource.URIConverter; |
| import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecore.xmi.XMLResource; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.examples.pivot.tests.PivotTestCaseWithAutoTearDown; |
| import org.eclipse.ocl.pivot.Element; |
| import org.eclipse.ocl.pivot.ExpressionInOCL; |
| import org.eclipse.ocl.pivot.LambdaType; |
| import org.eclipse.ocl.pivot.LoopExp; |
| import org.eclipse.ocl.pivot.NamedElement; |
| import org.eclipse.ocl.pivot.OperationCallExp; |
| import org.eclipse.ocl.pivot.Property; |
| import org.eclipse.ocl.pivot.TemplateableElement; |
| import org.eclipse.ocl.pivot.TupleType; |
| import org.eclipse.ocl.pivot.Type; |
| import org.eclipse.ocl.pivot.Variable; |
| import org.eclipse.ocl.pivot.VariableExp; |
| import org.eclipse.ocl.pivot.internal.context.ModelContext; |
| import org.eclipse.ocl.pivot.internal.delegate.OCLDelegateDomain; |
| import org.eclipse.ocl.pivot.internal.ecore.as2es.AS2Ecore; |
| import org.eclipse.ocl.pivot.internal.manager.MetamodelManagerInternal; |
| import org.eclipse.ocl.pivot.internal.resource.ProjectMap; |
| import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal; |
| import org.eclipse.ocl.pivot.internal.utilities.OCLInternal; |
| import org.eclipse.ocl.pivot.internal.values.BagImpl; |
| import org.eclipse.ocl.pivot.model.OCLstdlib; |
| import org.eclipse.ocl.pivot.resource.ASResource; |
| import org.eclipse.ocl.pivot.utilities.ClassUtil; |
| import org.eclipse.ocl.pivot.utilities.NameUtil; |
| import org.eclipse.ocl.pivot.utilities.OCL; |
| import org.eclipse.ocl.pivot.utilities.PivotConstants; |
| import org.eclipse.ocl.pivot.utilities.XMIUtil; |
| import org.eclipse.ocl.pivot.values.Bag; |
| import org.eclipse.ocl.xtext.base.utilities.BaseCSResource; |
| import org.eclipse.ocl.xtext.base.utilities.ElementUtil; |
| import org.eclipse.ocl.xtext.basecs.ModelElementCS; |
| import org.eclipse.ocl.xtext.basecs.TuplePartCS; |
| import org.eclipse.ocl.xtext.basecs.TupleTypeCS; |
| import org.eclipse.ocl.xtext.basecs.TypeRefCS; |
| import org.eclipse.ocl.xtext.essentialocl.attributes.NavigationUtil; |
| import org.eclipse.ocl.xtext.essentialoclcs.CollectionTypeCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.CurlyBracketedClauseCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.InfixExpCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.NavigatingArgCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.NestedExpCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.PrefixExpCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.RoundBracketedClauseCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.SquareBracketedClauseCS; |
| import org.eclipse.ocl.xtext.essentialoclcs.TypeNameExpCS; |
| import org.eclipse.ocl.xtext.oclstdlib.scoping.JavaClassScope; |
| |
| public class XtextTestCase extends PivotTestCaseWithAutoTearDown |
| { |
| public static interface Normalizer { |
| void denormalize(); |
| void normalize(); |
| } |
| |
| public static class EAnnotationsNormalizer implements Normalizer |
| { |
| protected final @NonNull EModelElement eModelElement; |
| protected final List<EAnnotation> oldOrder; |
| |
| public EAnnotationsNormalizer(@NonNull EModelElement eModelElement) { |
| this.eModelElement = eModelElement; |
| this.oldOrder = new ArrayList<EAnnotation>(eModelElement.getEAnnotations()); |
| } |
| |
| @Override |
| public void denormalize() { |
| EList<EAnnotation> eList = eModelElement.getEAnnotations(); |
| eList.clear(); |
| eList.addAll(oldOrder); |
| } |
| |
| @Override |
| public void normalize() { |
| EList<EAnnotation> eList = eModelElement.getEAnnotations(); |
| List<EAnnotation> newOrder = new ArrayList<EAnnotation>(eList); |
| Collections.sort(newOrder, NameUtil.EAnnotationComparator.INSTANCE); |
| eList.clear(); |
| eList.addAll(newOrder); |
| } |
| } |
| |
| public static class EAnnotationConstraintsNormalizer implements Normalizer |
| { |
| protected final @NonNull EAnnotation eAnnotation; |
| protected final @Nullable String oldConstraints; |
| |
| public EAnnotationConstraintsNormalizer(@NonNull EAnnotation eAnnotation) { |
| this.eAnnotation = eAnnotation; |
| this.oldConstraints = eAnnotation.getDetails().get("constraints"); |
| } |
| |
| @Override |
| public void denormalize() { |
| eAnnotation.getDetails().put("constraints", oldConstraints); |
| } |
| |
| @Override |
| public void normalize() { |
| StringBuilder s1 = new StringBuilder(); |
| if (oldConstraints != null) { |
| String[] s = oldConstraints.split(" "); |
| Arrays.sort(s); |
| for (int i = 0; i < s.length; i++) { |
| if (i > 0) { |
| s1.append(" "); |
| } |
| s1.append(s[i]); |
| } |
| } |
| eAnnotation.getDetails().put("constraints", s1.toString()); |
| } |
| } |
| |
| public static class EDetailsNormalizer implements Normalizer |
| { |
| protected final @NonNull EAnnotation eAnnotation; |
| protected final List<Map.Entry<String, String>> oldOrder; |
| |
| public EDetailsNormalizer(@NonNull EAnnotation eAnnotation) { |
| this.eAnnotation = eAnnotation; |
| this.oldOrder = new ArrayList<Map.Entry<String, String>>(eAnnotation.getDetails()); |
| } |
| |
| @Override |
| public void denormalize() { |
| EList<Map.Entry<String, String>> eDetails = eAnnotation.getDetails(); |
| eDetails.clear(); |
| eDetails.addAll(oldOrder); |
| } |
| |
| @Override |
| public void normalize() { |
| List<Map.Entry<String, String>> eDetails = eAnnotation.getDetails(); |
| List<Map.Entry<String, String>> newOrder = new ArrayList<Map.Entry<String, String>>(eDetails); |
| Collections.sort(newOrder, new Comparator<Map.Entry<String, String>>() |
| { |
| @Override |
| public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) { |
| String n1 = o1.getKey(); |
| String n2 = o2.getKey(); |
| return n1.compareTo(n2); |
| } |
| } |
| ); |
| eDetails.clear(); |
| eDetails.addAll(newOrder); |
| } |
| } |
| |
| /* public static class ENamedElementNormalizer implements Normalizer |
| { |
| protected final @NonNull ENamedElement eNamedElement; |
| |
| public ENamedElementNormalizer(@NonNull ENamedElement eNamedElement) { |
| this.eNamedElement = eNamedElement; |
| } |
| |
| @Override |
| public void denormalize() { |
| eNamedElement.setName(eNamedElement.getName().substring(1)); |
| } |
| |
| @Override |
| public void normalize() { |
| eNamedElement.setName("#" + eNamedElement.getName()); |
| } |
| } */ |
| |
| public static class EOperationsNormalizer implements Normalizer |
| { |
| protected final @NonNull EClass eClass; |
| protected final List<EOperation> oldOrder; |
| |
| public EOperationsNormalizer(@NonNull EClass eClass) { |
| this.eClass = eClass; |
| this.oldOrder = new ArrayList<EOperation>(eClass.getEOperations()); |
| } |
| |
| @Override |
| public void denormalize() { |
| EList<EOperation> eOperations = eClass.getEOperations(); |
| eOperations.clear(); |
| eOperations.addAll(oldOrder); |
| } |
| |
| @Override |
| public void normalize() { |
| EList<EOperation> eOperations = eClass.getEOperations(); |
| List<EOperation> newOrder = new ArrayList<EOperation>(eOperations); |
| Collections.sort(newOrder, new Comparator<EOperation>() |
| { |
| @Override |
| public int compare(EOperation o1, EOperation o2) { |
| String n1 = o1.getName(); |
| String n2 = o2.getName(); |
| return n1.compareTo(n2); |
| } |
| } |
| ); |
| eOperations.clear(); |
| eOperations.addAll(newOrder); |
| } |
| } |
| |
| public static class ETypedElementNormalizer implements Normalizer |
| { |
| protected final @NonNull ETypedElement eTypedElement; |
| protected final EClassifier wasType; |
| protected final int wasLower; |
| protected final boolean wasOrdered; |
| protected final boolean wasUnique; |
| |
| public ETypedElementNormalizer(@NonNull ETypedElement eTypedElement) { |
| this.eTypedElement = eTypedElement; |
| this.wasType = eTypedElement.getEType(); |
| this.wasLower = eTypedElement.getLowerBound(); |
| this.wasOrdered = eTypedElement.isOrdered(); |
| this.wasUnique = eTypedElement.isUnique(); |
| } |
| |
| @Override |
| public void denormalize() { |
| if (wasType == null) { |
| eTypedElement.setLowerBound(wasLower); |
| } |
| eTypedElement.setOrdered(wasOrdered); |
| eTypedElement.setUnique(wasUnique); |
| } |
| |
| @Override |
| public void normalize() { |
| EClassifier wasType2 = wasType; |
| if (wasType2 == null) { |
| eTypedElement.setLowerBound(0); |
| } |
| else if ((wasType2 instanceof EDataType) && ElementUtil.isPrimitiveInstanceClass((EDataType) wasType2)) { |
| eTypedElement.setLowerBound(1); |
| } |
| eTypedElement.setOrdered(true); |
| eTypedElement.setUnique(true); |
| } |
| } |
| |
| @SuppressWarnings("null") |
| protected void assertPivotIsValid(URI pivotURI) { |
| OCL ocl = OCL.newInstance(getProjectMap()); |
| ResourceSet reloadResourceSet = ocl.getMetamodelManager().getASResourceSet(); |
| // reloadResourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap().put("pivot", new EcoreResourceFactoryImpl()); |
| Resource reloadedPivotResource = reloadResourceSet.getResource(pivotURI, true); |
| // MetamodelManager metamodelManager = PivotUtilInternal.getMetamodelManager(reloadedPivotResource); |
| assertNoValidationErrors("Pivot reload validation problems", reloadedPivotResource); |
| unloadResourceSet(reloadResourceSet); |
| ocl.dispose(); |
| } |
| |
| @Deprecated |
| public static void assertSameModel(@NonNull Resource expectedResource, @NonNull Resource actualResource) throws IOException, InterruptedException { |
| TestUtil.assertSameModel(expectedResource, actualResource); |
| } |
| |
| protected void doBadLoadFromString(@NonNull OCLInternal ocl, @NonNull String fileName, @NonNull String testContents, @NonNull Bag<String> expectedErrorMessages) throws Exception { |
| MetamodelManagerInternal metamodelManager = ocl.getMetamodelManager(); |
| metamodelManager.addClassLoader(ClassUtil.nonNullState(getClass().getClassLoader())); |
| InputStream inputStream = new URIConverter.ReadableInputStream(testContents, "UTF-8"); |
| URI libraryURI = getTestFileURI(fileName, inputStream); |
| @SuppressWarnings("null")@NonNull BaseCSResource xtextResource = (BaseCSResource) ocl.getResourceSet().createResource(libraryURI); |
| @SuppressWarnings("null")@NonNull ClassLoader classLoader = getClass().getClassLoader(); |
| JavaClassScope.getAdapter(xtextResource, classLoader); |
| xtextResource.load(null); |
| Bag<String> actualErrorMessages = new BagImpl<String>(); |
| for (Resource.Diagnostic actualError : xtextResource.getErrors()) { |
| actualErrorMessages.add(actualError.getMessage()); |
| } |
| String s = formatMessageDifferences(expectedErrorMessages, actualErrorMessages); |
| if (s != null) { |
| fail("Inconsistent load errors (expected/actual) message" + s); |
| } |
| } |
| |
| protected void doLoadFromString(@NonNull OCL ocl, @NonNull String fileName, @NonNull String testContents) throws Exception { |
| InputStream inputStream = new URIConverter.ReadableInputStream(testContents, "UTF-8"); |
| URI libraryURI = getTestFileURI(fileName, inputStream); |
| ResourceSet resourceSet = ocl.getResourceSet(); |
| BaseCSResource xtextResource = (BaseCSResource) resourceSet.createResource(libraryURI); |
| xtextResource.load(null); |
| assertNoResourceErrors("Load failed", xtextResource); |
| Resource asResource = xtextResource.getASResource(); |
| assert asResource != null; |
| assertNoResourceErrors("File Model", asResource); |
| assertNoUnresolvedProxies("File Model", asResource); |
| assertNoValidationErrors("File Model", asResource); |
| } |
| |
| protected ASResource doLoadASResourceFromString(@NonNull OCL ocl, @NonNull String fileName, @NonNull String testContents) throws Exception { |
| InputStream inputStream = new URIConverter.ReadableInputStream(testContents, "UTF-8"); |
| URI libraryURI = getTestFileURI(fileName, inputStream); |
| EnvironmentFactoryInternal environmentFactory = (EnvironmentFactoryInternal) ocl.getEnvironmentFactory(); |
| ModelContext modelContext = new ModelContext(environmentFactory, libraryURI); |
| BaseCSResource xtextResource = (BaseCSResource) modelContext.createBaseResource(null); |
| assertNoResourceErrors("Load failed", xtextResource); |
| ASResource asResource = xtextResource.getASResource(); |
| assert asResource != null; |
| assertNoResourceErrors("File Model", asResource); |
| assertNoUnresolvedProxies("File Model", asResource); |
| assertNoValidationErrors("File Model", asResource); |
| return asResource; |
| } |
| |
| protected static boolean hasCorrespondingCS(Element pivotElement) { |
| if (!isValidPivot(pivotElement)) { |
| return false; |
| } |
| if (pivotElement instanceof ExpressionInOCL) { |
| return false; |
| } |
| if ((pivotElement instanceof Variable) && (pivotElement.eContainer() instanceof ExpressionInOCL)) { |
| return false; |
| } |
| if ((pivotElement instanceof Variable) && (pivotElement.eContainer() instanceof LoopExp) |
| && Character.isDigit((((Variable)pivotElement).getName().charAt(0)))) { |
| return false; |
| } |
| // if (pivotElement instanceof TemplateBinding) { |
| // return false; |
| // } |
| // if ((pivotElement instanceof TemplateableElement) && (((TemplateableElement)pivotElement).getTemplateBinding().size() > 0)) { |
| // return false; |
| // } |
| return true; |
| } |
| |
| // protected static boolean hasOptionalCS(MonikeredElement pivotElement) { |
| // if ((pivotElement instanceof LetExp) && (pivotElement.eContainer() instanceof LetExp)) { |
| // return false; |
| // } |
| // return true; |
| // } |
| |
| public static boolean hasCorrespondingPivot(ModelElementCS csElement) { |
| if (csElement instanceof TupleTypeCS) { |
| return true; |
| } |
| if (csElement instanceof TuplePartCS) { // FIXME orphanage ambiguity |
| return false; |
| } |
| // if (csElement instanceof TypeRefCS) { |
| // return false; |
| // } |
| if (csElement instanceof InfixExpCS) { |
| return false; |
| } |
| if (csElement instanceof NestedExpCS) { |
| return false; |
| } |
| if (csElement instanceof PrefixExpCS) { |
| return false; |
| } |
| if (csElement instanceof NavigatingArgCS) { |
| return false; |
| } |
| if (csElement instanceof CurlyBracketedClauseCS) { |
| return false; |
| } |
| if (csElement instanceof RoundBracketedClauseCS) { |
| return false; |
| } |
| if (csElement instanceof SquareBracketedClauseCS) { |
| return false; |
| } |
| if (NavigationUtil.isNavigationInfixExp(csElement)) { |
| return false; |
| } |
| if (csElement instanceof CollectionTypeCS) { |
| return false; |
| } |
| if (csElement instanceof TypeNameExpCS) { |
| return false; |
| } |
| return true; |
| } |
| |
| public static boolean hasUniqueMoniker(ModelElementCS csElement) { |
| if (csElement instanceof TupleTypeCS) { |
| return false; |
| } |
| if (csElement instanceof TypeRefCS) { |
| return false; |
| } |
| if (csElement instanceof InfixExpCS) { |
| return false; |
| } |
| if (csElement instanceof NestedExpCS) { |
| return false; |
| } |
| if (csElement instanceof PrefixExpCS) { |
| return false; |
| } |
| if (csElement instanceof CurlyBracketedClauseCS) { |
| return false; |
| } |
| if (csElement instanceof RoundBracketedClauseCS) { |
| return false; |
| } |
| if (csElement instanceof SquareBracketedClauseCS) { |
| return false; |
| } |
| if (NavigationUtil.isNavigationInfixExp(csElement)) { |
| return false; |
| } |
| if (csElement instanceof CollectionTypeCS) { |
| return false; |
| } |
| return true; |
| } |
| |
| protected static boolean isValidPivot(Element pivotElement) { |
| if (pivotElement instanceof org.eclipse.ocl.pivot.Package) { |
| if ((pivotElement.eContainer() == null) && PivotConstants.ORPHANAGE_NAME.equals(((NamedElement) pivotElement).getName())) { |
| return false; |
| } |
| } |
| if ((pivotElement instanceof TemplateableElement) && (((TemplateableElement)pivotElement).getOwnedBindings().size() > 0)) { |
| return false; |
| } |
| if (pivotElement instanceof LambdaType) { |
| return false; |
| } |
| if (pivotElement instanceof TupleType) { |
| return false; |
| } |
| if (pivotElement instanceof Type) { |
| EObject eContainer = pivotElement.eContainer(); |
| if ((eContainer instanceof org.eclipse.ocl.pivot.Package) && (eContainer.eContainer() == null) |
| && PivotConstants.ORPHANAGE_NAME.equals(((NamedElement) pivotElement).getName()) |
| && PivotConstants.ORPHANAGE_NAME.equals(((NamedElement) eContainer).getName())) { |
| return false; |
| } |
| } |
| if ((pivotElement instanceof Property) && (pivotElement.eContainer() instanceof TupleType)) { |
| return false; |
| } |
| if ((pivotElement instanceof VariableExp) && (pivotElement.eContainer() instanceof OperationCallExp)) { |
| return false; |
| } |
| return true; |
| } |
| |
| public @NonNull String createEcoreString(@NonNull OCL ocl, @NonNull String fileName, @NonNull String fileContent, boolean assignIds) throws IOException { |
| String inputName = fileName + ".oclinecore"; |
| createOCLinEcoreFile(inputName, fileContent); |
| URI inputURI = getTestFileURI(inputName); |
| URI ecoreURI = getTestFileURI(fileName + ".ecore"); |
| BaseCSResource xtextResource = null; |
| try { |
| ResourceSet resourceSet2 = ocl.getResourceSet(); |
| xtextResource = ClassUtil.nonNullState((BaseCSResource) resourceSet2.getResource(inputURI, true)); |
| assertNoResourceErrors("Load failed", xtextResource); |
| // adapter = xtextResource.getCS2ASAdapter(null); |
| Resource asResource = xtextResource.getASResource(); |
| assertNoUnresolvedProxies("Unresolved proxies", xtextResource); |
| assertNoValidationErrors("Pivot validation errors", asResource.getContents().get(0)); |
| XMLResource ecoreResource = AS2Ecore.createResource((EnvironmentFactoryInternal) ocl.getEnvironmentFactory(), asResource, ecoreURI, null); |
| assertNoResourceErrors("To Ecore errors", ecoreResource); |
| if (assignIds) { |
| for (TreeIterator<EObject> tit = ecoreResource.getAllContents(); tit.hasNext(); ) { |
| EObject eObject = tit.next(); |
| ecoreResource.setID(eObject, EcoreUtil.generateUUID()); |
| } |
| } |
| Writer writer = new StringWriter(); |
| ecoreResource.save(writer, XMIUtil.createSaveOptions()); |
| return ClassUtil.nonNullState(writer.toString()); |
| } |
| finally { |
| if (xtextResource != null) { |
| xtextResource.dispose(); |
| } |
| } |
| } |
| |
| @SuppressWarnings("deprecation") |
| protected @NonNull Resource loadEcore(@NonNull URI inputURI) { |
| ResourceSet resourceSet = new ResourceSetImpl(); |
| ProjectMap.initializeURIResourceMap(resourceSet); |
| Map<URI, URI> uriMap = resourceSet.getURIConverter().getURIMap(); |
| if (EMFPlugin.IS_ECLIPSE_RUNNING) { |
| uriMap.putAll(EcorePlugin.computePlatformURIMap()); |
| } |
| Resource ecoreResource = ClassUtil.nonNullState(resourceSet.getResource(inputURI, true)); |
| mapOwnURI(ecoreResource); |
| // List<String> conversionErrors = new ArrayList<String>(); |
| // RootPackageCS documentCS = Ecore2OCLinEcore.importFromEcore(resourceSet, null, ecoreResource); |
| // Resource eResource = documentCS.eResource(); |
| assertNoResourceErrors("Load failed", ecoreResource); |
| // Resource xtextResource = resourceSet.createResource(outputURI, OCLinEcoreCSPackage.eCONTENT_TYPE); |
| // XtextResource xtextResource = (XtextResource) resourceSet.createResource(outputURI); |
| // xtextResource.getContents().add(documentCS); |
| return ecoreResource; |
| } |
| |
| /** |
| * Some example files have inconsistent self references so map the URI back to |
| * the resource. |
| */ |
| protected void mapOwnURI(Resource resource) { |
| List<EObject> contents = resource.getContents(); |
| if (contents.size() == 1) { |
| EObject root = contents.get(0); |
| if (root instanceof EPackage) { |
| EPackage rootPackage = (EPackage) root; |
| String nsURI = rootPackage.getNsURI(); |
| if (nsURI != null) { |
| ResourceSet resourceSet = resource.getResourceSet(); |
| Map<URI, Resource> uriResourceMap = ((ResourceSetImpl)resourceSet).getURIResourceMap(); |
| if (uriResourceMap == null) { |
| uriResourceMap = new HashMap<URI, Resource>(); |
| ((ResourceSetImpl)resourceSet).setURIResourceMap(uriResourceMap); |
| } |
| uriResourceMap.put(URI.createURI(nsURI), resource); |
| } |
| } |
| } |
| } |
| |
| @SuppressWarnings("deprecation") |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| TestCaseAppender.INSTANCE.install(); |
| TestUtil.doCompleteOCLSetup(); |
| TestUtil.doOCLinEcoreSetup(); |
| TestUtil.doOCLstdlibSetup(); |
| ResourceSet resourceSet = new ResourceSetImpl(); |
| ProjectMap.initializeURIResourceMap(resourceSet); |
| Map<URI, URI> uriMap = resourceSet.getURIConverter().getURIMap(); |
| if (EMFPlugin.IS_ECLIPSE_RUNNING) { |
| uriMap.putAll(EcorePlugin.computePlatformURIMap()); |
| } |
| // for (Map.Entry<URI,URI> entry : uriMap.entrySet()) { |
| // System.out.println(entry.getKey() + " => " + entry.getValue()); |
| // } |
| // URI platformOCLstdlibURI = URI.createURI(StandardDocumentAttribution.OCLSTDLIB_URI); |
| // URI projectURI = getProjectFileURI("dummy"); |
| // URI projectOCLstdlibURI = URI.createURI("oclstdlib.oclstdlib").resolve(projectURI); |
| // uriMap.put(platformOCLstdlibURI, projectOCLstdlibURI); |
| OCLstdlib.install(); |
| OCLDelegateDomain.initialize(null); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| } |
