/*******************************************************************************
 * Copyright (c) 2012, 2019 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
 *   E.D.Willink (CEA LIST) - Bug 388529
 *******************************************************************************/

package org.eclipse.ocl.examples.pivot.tests;

import java.util.Collection;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.ocl.examples.xtext.tests.TestFileSystem;
import org.eclipse.ocl.pivot.ElementExtension;
import org.eclipse.ocl.pivot.Enumeration;
import org.eclipse.ocl.pivot.EnumerationLiteral;
import org.eclipse.ocl.pivot.Model;
import org.eclipse.ocl.pivot.Profile;
import org.eclipse.ocl.pivot.Stereotype;
import org.eclipse.ocl.pivot.ids.IdResolver;
import org.eclipse.ocl.pivot.internal.messages.PivotMessagesInternal;
import org.eclipse.ocl.pivot.internal.resource.ProjectMap;
import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal.EnvironmentFactoryInternalExtension;
import org.eclipse.ocl.pivot.internal.utilities.PivotObjectImpl;
import org.eclipse.ocl.pivot.messages.PivotMessages;
import org.eclipse.ocl.pivot.resource.ASResource;
import org.eclipse.ocl.pivot.uml.UMLStandaloneSetup;
import org.eclipse.ocl.pivot.uml.internal.es2as.UML2AS;
import org.eclipse.ocl.pivot.uml.internal.library.UMLElementExtension;
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.ParserException;
import org.eclipse.ocl.pivot.utilities.StringUtil;
import org.eclipse.ocl.pivot.values.InvalidValueException;
import org.eclipse.uml2.uml.util.UMLUtil;
import org.junit.After;
import org.junit.Before;

/**
 * Tests for stereotype expressions.
 */
@SuppressWarnings("null")
public class StereotypesTest extends PivotTestSuite
{
	public class InternationalizedProfile
	{
		org.eclipse.uml2.uml.Profile umlProfile;
		org.eclipse.uml2.uml.Stereotype umlInEnglishStereotype;
		org.eclipse.uml2.uml.Stereotype umlInFrenchStereotype;
		org.eclipse.uml2.uml.Stereotype umlInGermanStereotype;
		org.eclipse.uml2.uml.Enumeration umlFace;
		Profile asProfile;
		Stereotype asInEnglishStereotype;
		Stereotype asInFrenchStereotype;
		Stereotype asInGermanStereotype;
		Enumeration asFace;

		public InternationalizedProfile(@NonNull OCL ocl, org.eclipse.uml2.uml.Profile umlProfile) throws ParserException {
			this.umlProfile = umlProfile;
			umlInEnglishStereotype = umlProfile.getOwnedStereotype("InEnglish");
			umlInFrenchStereotype = umlProfile.getOwnedStereotype("InFrench");
			umlInGermanStereotype = umlProfile.getOwnedStereotype("InGerman");
			umlFace = (org.eclipse.uml2.uml.Enumeration) umlProfile.getOwnedType("Face");
			EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension)ocl.getEnvironmentFactory();
			asProfile = environmentFactory.getASOf(Profile.class, umlProfile);
			asInEnglishStereotype = environmentFactory.getASOf(Stereotype.class, umlInEnglishStereotype);
			asInFrenchStereotype = environmentFactory.getASOf(Stereotype.class, umlInFrenchStereotype);
			asInGermanStereotype = environmentFactory.getASOf(Stereotype.class, umlInGermanStereotype);
			asFace = environmentFactory.getASOf(Enumeration.class, umlFace);
		}
	}

	public class InternationalizedMetamodel
	{
		org.eclipse.uml2.uml.Package umlPackage;
		//		ASResource asResource;
		org.eclipse.uml2.uml.Type umlEnglishClass;
		org.eclipse.uml2.uml.Type umlFrenchClass;
		org.eclipse.uml2.uml.Type umlGermanClass;
		org.eclipse.uml2.uml.Type umlLanguageClass;
		org.eclipse.uml2.uml.Type umlPlainClass;
		org.eclipse.uml2.uml.Type umlString;
		UMLElementExtension umlEnglishClassInEnglish;
		org.eclipse.ocl.pivot.Class asEnglishClass;
		org.eclipse.ocl.pivot.Class asFrenchClass;
		org.eclipse.ocl.pivot.Class asGermanClass;
		ElementExtension asEnglishClassInEnglish;
		ElementExtension asFrenchClassInEnglish;
		ElementExtension asGermanClassInEnglish;

		public InternationalizedMetamodel(@NonNull OCL ocl, @NonNull InternationalizedProfile mmm, org.eclipse.uml2.uml.Package umlPackage) throws ParserException {
			EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension)ocl.getEnvironmentFactory();
			this.umlPackage = umlPackage;
			//	        umlMMM = metamodelManager.getPivotOf(Element.class, umlRoot.eClass());
			//	        asResource = ocl.uml2as(umlResource);
			//	        umlMMM = metamodelManager.getPivotOf(Element.class, umlPackage.eClass());
			//	        Root root = (Root) asResource.getContents().get(0);
			//	        assertNoResourceErrors("Loading models/uml/InternationalizedClasses.uml", asResource);
			//	        org.eclipse.ocl.pivot.Package modelPackage = ClassUtil.getNamedElement(root.getNestedPackage(), "Model");
			umlEnglishClass = umlPackage.getOwnedType("EnglishClass");
			umlFrenchClass = umlPackage.getOwnedType("FrenchClass");
			umlGermanClass = umlPackage.getOwnedType("GermanClass");
			umlLanguageClass = umlPackage.getOwnedType("LanguageClass");
			umlPlainClass = umlPackage.getOwnedType("PlainClass");
			umlString = umlPackage.getOwnedType("String");
			asEnglishClass = environmentFactory.getASOf(org.eclipse.ocl.pivot.Class.class, umlEnglishClass);
			asFrenchClass = environmentFactory.getASOf(org.eclipse.ocl.pivot.Class.class, umlFrenchClass);
			asGermanClass = environmentFactory.getASOf(org.eclipse.ocl.pivot.Class.class, umlGermanClass);
			//
			umlEnglishClassInEnglish = (UMLElementExtension) UMLElementExtension.getUMLElementExtension(mmm.asInEnglishStereotype, umlEnglishClass);
			asEnglishClassInEnglish = NameUtil.getNameable(asEnglishClass.getOwnedExtensions(), "EnglishClass$InEnglish");
			asFrenchClassInEnglish = NameUtil.getNameable(asFrenchClass.getOwnedExtensions(), "FrenchClass$InFrench");
			asGermanClassInEnglish = NameUtil.getNameable(asGermanClass.getOwnedExtensions(), "GermanClass$InGerman");
		}
	}

	public class InternationalizedModel
	{
		EClass eEnglishClass;
		EClass eFrenchClass;
		EClass eGermanClass;
		EObject eEnglishObject;
		EObject eFrenchObject;
		EObject eGermanObject;

		public InternationalizedModel(InternationalizedMetamodel mm, Resource ecoreModel, Resource model) throws ParserException {
			Collection<EPackage> ecorePackages = UMLUtil.convertToEcore(mm.umlPackage, null);
			ecoreModel.getContents().addAll(ecorePackages);
			for (EPackage ePackage : ecorePackages) {
				for (EClassifier eClassifier : ePackage.getEClassifiers()) {
					String name = eClassifier.getName();
					if ("EnglishClass".equals(name)) {
						eEnglishClass = (EClass)eClassifier;
					}
					else if ("FrenchClass".equals(name)) {
						eFrenchClass = (EClass)eClassifier;
					}
					else if ("GermanClass".equals(name)) {
						eGermanClass = (EClass)eClassifier;
					}
				}
			}
			EFactory eFactoryInstance = eEnglishClass.getEPackage().getEFactoryInstance();
			eEnglishObject = eFactoryInstance.create(eEnglishClass);
			model.getContents().add(eEnglishObject);
			eFrenchObject = eFactoryInstance.create(eFrenchClass);
			model.getContents().add(eFrenchObject);
			eGermanObject = eFactoryInstance.create(eGermanClass);
			model.getContents().add(eGermanObject);
		}
	}

	public class MyOCL extends TestOCL
	{
		InternationalizedProfile mmm = null;
		InternationalizedMetamodel mm = null;
		InternationalizedModel m = null;

		public MyOCL(@NonNull TestFileSystem testFileSystem, @NonNull String testPackageName, @NonNull String name) throws ParserException {
			super(testFileSystem, testPackageName, name, OCL.NO_PROJECTS);
			ResourceSet resourceSet = getResourceSet();
			ProjectMap.getAdapter(resourceSet);
			String problem = UML2AS.initialize(resourceSet);
			assertNull(problem);
			URI testModelURI = getTestModelURI("models/uml/InternationalizedClasses.uml");
			Resource umlResource = resourceSet.getResource(testModelURI, true);
			org.eclipse.uml2.uml.Package umlPackage = (org.eclipse.uml2.uml.Package) umlResource.getContents().get(0);
			URI testProfileURI = getTestModelURI("models/uml/Internationalized.profile.uml");
			org.eclipse.uml2.uml.Profile umlProfile = (org.eclipse.uml2.uml.Profile) resourceSet.getResource(testProfileURI, true).getContents().get(0);
			uml2as(umlResource);				// FIXME BUG 437826 must do full model conversion
			mmm = new InternationalizedProfile(this, umlProfile);
			mm = new InternationalizedMetamodel(this, mmm, umlPackage);
			URI ecoreURI = getTestModelURI("Languages.ecore");
			URI modelURI = getTestModelURI("Languages.xmi");
			Resource ecoreModel = resourceSet.createResource(ecoreURI);
			Resource model = resourceSet.createResource(modelURI);
			m = new InternationalizedModel(mm, ecoreModel, model);
		}

		public @NonNull ASResource uml2as(@NonNull Resource umlResource) throws ParserException {
			assert environmentFactory != null;
			UML2AS uml2as = UML2AS.getAdapter(umlResource, environmentFactory);
			Model pivotModel = uml2as.getASModel();
			ASResource asResource = (ASResource) pivotModel.eResource();
			return ClassUtil.nonNullModel(asResource);
		}
	}

	//	@Override
	//	protected @NonNull OCL createOCL() {
	//		return UMLOCL.newInstance();
	//	}

	@Override
	protected @NonNull MyOCL createOCL() throws ParserException {
		return new MyOCL(getTestFileSystem(), getTestPackageName(), getName());
	}

	@Override
	@Before public void setUp() throws Exception {
		//		UML2AS.ADD_ELEMENT_EXTENSION.setState(true);
		//		UML2AS.ADD_IMPORTED_RESOURCE.setState(true);
		//		UML2AS.ADD_PROFILE_APPLICATION.setState(true);
		//		UML2AS.ADD_TYPE_EXTENSION.setState(true);
		//		UML2AS.APPLICABLE_STEREOTYPES.setState(true);
		//		UML2AS.CONVERT_RESOURCE.setState(true);
		//		UML2AS.TYPE_EXTENSIONS.setState(true);
		//		AbstractTypeServer.ADD_BASE_PROPERTY.setState(true);
		//		AbstractTypeServer.ADD_EXTENSION_PROPERTY.setState(true);
		//		AbstractTypeServer.INIT_MEMBER_PROPERTIES.setState(true);
		//    	MetamodelManager.CREATE_MUTABLE_CLONE.setState(true);
		UMLStandaloneSetup.init();
		super.setUp();
	}

	@Override
	@After public void tearDown() throws Exception {
		super.tearDown();
	}

	/**
	 * Tests M1 parsing using base_XXX and extension_YYY.
	 */
	public void test_stereotypeM1Navigation() throws Exception {
		MyOCL ocl = createOCL();
		//		ocl.assertValidQuery(ocl.mm.englishClass, "self.oclType().extension_Internationalized");
		//		ocl.assertValidQuery(ocl.mm.englishClass, "self.extension_Internationalized");
		ocl.assertSemanticErrorQuery(ocl.mm.asEnglishClass, "self.extension_InEnglish", PivotMessagesInternal.UnresolvedProperty_ERROR_, "Model::EnglishClass", "extension_InEnglish");
		ocl.assertValidQuery(ocl.mm.asEnglishClass, "self.oclType().extension_Internationalized");
		//		ocl.assertValidQuery(ocl.mm.englishClass, "self.oclType().extension_InEnglish");
		ocl.assertValidQuery(ocl.mm.asEnglishClass, "self.extension_Internationalized.base_Class");
		ocl.assertSemanticErrorQuery(ocl.mm.asEnglishClass, "self.extension_InGerman", PivotMessagesInternal.UnresolvedProperty_ERROR_, "Model::EnglishClass", "extension_InGerman");
		//xx		ocl.assertValidQuery(ocl.mm.englishClassInEnglish, "self.base_Class");
		//xx		ocl.assertValidQuery(ocl.mm.englishClassInEnglish, "self.base_Class.extension_InEnglish");
		ocl.assertSemanticErrorQuery(ocl.mm.asEnglishClass, "self.getAllAppliedStereotypes()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "Model::EnglishClass", "getAllAppliedStereotypes");
		ocl.assertSemanticErrorQuery(ocl.mm.asEnglishClass, "self.getAppliedStereotypes()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "Model::EnglishClass", "getAppliedStereotypes");
		//xx		ocl.assertValidQuery(ocl.mm.asEnglishClass, "self.oclType().getAppliedStereotypes()");
		ocl.dispose();
	}

	/**
	 * Tests M2 navigations using base_XXX and extension_YYY.
	 */
	public void test_stereotypeM2Navigation() throws Exception {
		MyOCL ocl = createOCL();
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, "EnglishClass", "self.NamedElement::name");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, "EnglishClass", "self.name");
		//    	ocl.assertQueryEquals(ocl.mm.asEnglishClass, "EnglishClass", "self.NamedElement::name");	// FIXME fails because wrong NamedElement::name chosen
		//    	ocl.assertQueryEquals(ocl.mm.asEnglishClass, "EnglishClass", "self.name");
		ocl.assertSemanticErrorQuery(ocl.mm.asEnglishClass, "self.extension_InEnglish", PivotMessagesInternal.UnresolvedProperty_ERROR_, "Model::EnglishClass", "extension_InEnglish");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, ocl.mm.umlEnglishClassInEnglish, "self.extension_Internationalized");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, ocl.mmm.umlFace.getOwnedLiteral("NORMAL"), "self.extension_Internationalized.face");
		ocl.assertQueryEquals(ocl.mm.umlGermanClass, ocl.mmm.umlFace.getOwnedLiteral("BOLD"), "self.extension_Internationalized.face");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClassInEnglish, ocl.mm.umlEnglishClass, "self.base_Class");
		ocl.assertQueryEquals(ocl.mm.asEnglishClassInEnglish, ocl.mm.asEnglishClass, "self.base_Class");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, "InEnglish", "self.extension_Internationalized.oclType().name");
		//    	ocl.assertQueryEquals(ocl.mm.asEnglishClass, "InEnglish", "self.extension_Internationalized.oclType().name");
		//    	ocl.assertQueryEquals(ocl.mm.englishClass, "EnglishClass$InEnglish", "self.extension_Internationalized.oclType().instanceType.name");
		//    	ocl.assertQueryEquals(ocl.mm.englishClass, "EnglishClass$InEnglish", "self.extension_Internationalized.oclType().name");
		ocl.assertSemanticErrorQuery(ocl.mm.asEnglishClass, "self.extension_InGerman", PivotMessagesInternal.UnresolvedProperty_ERROR_, "Model::EnglishClass", "extension_InGerman");
		ocl.assertSemanticErrorQuery(ocl.getIdResolver().getStaticTypeOfValue(null, ocl.mm.umlEnglishClass), "self.extension_Internationalized.extension_InEnglish", PivotMessagesInternal.UnresolvedProperty_ERROR_, "InternationalizedProfile::Internationalized", "extension_InEnglish");
		ocl.assertSemanticErrorQuery(/*metamodelManager.getMetaclass(*/ocl.mm.asEnglishClass/*)*/, "self.extension_Internationalized.extension_InEnglish", PivotMessagesInternal.UnresolvedProperty_ERROR_, "InternationalizedProfile::Internationalized", "extension_InEnglish");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, ocl.mm.umlEnglishClassInEnglish, "self.extension_Internationalized");
		ocl.assertQueryEquals(ocl.mm.asEnglishClass, ocl.mm.asEnglishClassInEnglish, "self.extension_Internationalized");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, ocl.mm.umlEnglishClass, "self.extension_Internationalized.base_Class");
		ocl.assertQueryEquals(ocl.mm.asEnglishClass, ocl.mm.asEnglishClass, "self.extension_Internationalized.base_Class");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClassInEnglish, ocl.mm.umlEnglishClassInEnglish, "self.base_Class.extension_Internationalized");
		ocl.assertQueryEquals(ocl.mm.asEnglishClassInEnglish, ocl.mm.asEnglishClassInEnglish, "self.base_Class.extension_Internationalized");
		ocl.assertQueryTrue(ocl.mm.umlEnglishClass, "extension_Internationalized.base_Class = self");
		ocl.assertQueryTrue(ocl.mm.asEnglishClassInEnglish,  "base_Class.extension_Internationalized = self");
		ocl.assertSemanticErrorQuery(ocl.mm.asFrenchClass, "self.text", PivotMessagesInternal.UnresolvedProperty_ERROR_, "Model::FrenchClass", "text");
		//    	ocl.assertQueryEquals(ocl.mm.frenchClass, "Merci", "extension_InFrench.oclType().instanceType.ownedAttribute->any(name='text').default");
		//    	ocl.assertQueryTrue(ocl.mm.frenchClass, "extension_InFrench.oclType().instanceType.ownedAttribute->any(name='text').default = 'Merci'");
		ocl.dispose();
	}

	/**
	 * Tests allInstances in a stereotyped context.
	 * @throws ParserException
	 */
	public void test_stereotyped_allInstances_382981() throws ParserException {
		MyOCL ocl = createOCL();
		IdResolver idResolver = ocl.getIdResolver();
		//M0
		ocl.assertQueryEquals(ocl.m.eEnglishObject, idResolver.createSetOfEach(null, ocl.m.eEnglishObject), "EnglishClass.allInstances()");
		ocl.assertQueryEquals(ocl.m.eEnglishObject, idResolver.createSetOfEach(null, ocl.m.eGermanObject), "GermanClass.allInstances()");
		//M1
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, idResolver.createSetOfEach(null), "Model::EnglishClass.allInstances()");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, idResolver.createSetOfEach(null, ocl.mm.umlPlainClass, ocl.mm.umlEnglishClass, ocl.mm.umlLanguageClass, ocl.mm.umlFrenchClass, ocl.mm.umlGermanClass), "Class.allInstances()");
		ocl.assertQueryEquals(ocl.mm.asEnglishClass, idResolver.createSetOfEach(null, ocl.mm.asEnglishClassInEnglish, ocl.mm.asFrenchClassInEnglish, ocl.mm.asGermanClassInEnglish), "ocl::ElementExtension.allInstances()");
		//
		//    	ocl.assertQueryEquals(ocl.mm.umlMMM, metamodelManager.createSetValueOf(null, ocl.mm.string, ocl.mm.plainClass, ocl.mm.englishClass, ocl.mm.languageClass, ocl.mm.frenchClass, ocl.mm.germanClass), "uml::Stereotype.allInstances()");
		//    	ocl.assertQueryEquals(metamodelManager.getOclAnyType(), metamodelManager.createSetValueOf(null, ocl.mm.string, ocl.mm.plainClass, ocl.mm.englishClass, ocl.mm.languageClass, ocl.mm.frenchClass, ocl.mm.germanClass), "ocl::Stereotype.allInstances()");
		//    	ocl.assertQueryEquals(ocl.mm.englishClass, getEmptySetValue(), "InEnglish.allInstances()");
		ocl.dispose();
	}

	/**
	 * Tests getAppliedStereotypes.
	 * @throws ParserException
	 */
	public void test_MDT_UML2_operations_382978() throws ParserException {
		MyOCL ocl = createOCL();
		IdResolver idResolver = ocl.getIdResolver();
		//    	ocl.assertQueryEquals(ocl.mm.asEnglishClass, ocl.mm.asEnglishClassInEnglish, "self.extension_Internationalized");
		//    	org.eclipse.uml2.uml.Element uml_EnglishClass = (org.eclipse.uml2.uml.Element)((PivotObjectImpl)mm.umlEnglishClass).getETarget();
		//M0
		ocl.assertSemanticErrorQuery(ocl.mm.asEnglishClass, "self.getAppliedStereotypes()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "Model::EnglishClass", "getAppliedStereotypes");
		//    	ocl.assertQueryEquals(m.englishObject, idResolver.createSetOfEach(null, ((PivotObjectImpl)mm.inEnglishStereotype).getETarget()), "self.oclType().getAppliedStereotypes()");
		//    	ocl.assertQueryEquals(m.englishObject, idResolver.createSetOfEach(null, ((PivotObjectImpl)mm.inEnglishStereotype).getETarget()), "self.getAppliedStereotypes()");
		//M1
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, idResolver.createSetOfEach(null, ((PivotObjectImpl)ocl.mmm.asInEnglishStereotype).getESObject()), "self.getAppliedStereotypes()");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, ((PivotObjectImpl)ocl.mmm.asInEnglishStereotype).getESObject(), "self.getAppliedStereotype('InternationalizedProfile::InEnglish')");
		ocl.assertQueryEquals(ocl.mm.asEnglishClass, ocl.mm.asEnglishClassInEnglish, "self.extension_Internationalized");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, ocl.mm.umlEnglishClassInEnglish, "self.extension_Internationalized");
		ocl.assertQueryEquals(ocl.mm.umlEnglishClass, ocl.mm.umlEnglishClassInEnglish, "self.extension_Internationalized.oclAsType(InternationalizedProfile::InEnglish)");
		//    	ocl.assertQueryInvalid(ocl.mm.umlEnglishClass, "self.extension_Internationalized.oclAsType(InternationalizedProfile::InGerman)", ClassUtil.bind(EvaluatorMessages.IncompatibleOclAsTypeSourceType,
		//    		metamodelManager.getMetaclass(ocl.mm.asEnglishClassInEnglish), "InternationalizedProfile::InGerman"), InvalidValueException.class);
		ocl.assertQueryInvalid(ocl.mm.umlEnglishClass, "self.extension_Internationalized.oclAsType(InternationalizedProfile::InGerman)", StringUtil.bind(PivotMessages.IncompatibleOclAsTypeSourceType,
			ocl.mmm.asInEnglishStereotype, "InternationalizedProfile::InGerman"), InvalidValueException.class);
		ocl.dispose();
	}

	/**
	 * Tests M2 parsing and M1 evaluation using enumeration.
	 */
	public void test_uml_enums_412685() throws Exception {
		MyOCL ocl = createOCL();
		EnumerationLiteral asBold = ocl.mmm.asFace.getEnumerationLiteral("BOLD");
		org.eclipse.uml2.uml.EnumerationLiteral umlBold = ocl.mmm.umlFace.getOwnedLiteral("BOLD");
		//
		ocl.assertQueryEquals(ocl.mm.asGermanClass, asBold, "InternationalizedProfile::Face::BOLD");
		ocl.assertQueryEquals(ocl.mm.umlGermanClass, umlBold, "InternationalizedProfile::Face::BOLD");
		ocl.assertQueryEquals(ocl.mm.asGermanClass, asBold, "self.extension_Internationalized.face");
		ocl.assertQueryEquals(ocl.mm.umlGermanClass, umlBold, "self.extension_Internationalized.face");
		ocl.assertQueryTrue(ocl.mm.asFrenchClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::ITALIC)");
		ocl.assertQueryTrue(ocl.mm.umlFrenchClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::ITALIC)");
		ocl.assertQueryTrue(ocl.mm.asEnglishClass, "self.extension_Internationalized.face() = InternationalizedProfile::Face::NORMAL");
		ocl.assertQueryTrue(ocl.mm.umlEnglishClass, "self.extension_Internationalized.face() = InternationalizedProfile::Face::NORMAL");
		ocl.assertQueryTrue(ocl.mm.asEnglishClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::NORMAL)");
		ocl.assertQueryTrue(ocl.mm.umlEnglishClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::NORMAL)");
		ocl.assertQueryFalse(ocl.mm.asEnglishClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::BOLD)");
		ocl.assertQueryFalse(ocl.mm.umlEnglishClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::BOLD)");
		ocl.assertQueryTrue(ocl.mm.asEnglishClass, "self.extension_Internationalized.face = InternationalizedProfile::Face::NORMAL");
		ocl.assertQueryTrue(ocl.mm.umlEnglishClass, "self.extension_Internationalized.face = InternationalizedProfile::Face::NORMAL");
		ocl.assertQueryFalse(ocl.mm.asFrenchClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::BOLD)");
		ocl.assertQueryFalse(ocl.mm.umlFrenchClass, "self.extension_Internationalized.isFace(InternationalizedProfile::Face::BOLD)");
		ocl.assertQueryEquals(ocl.mm.asGermanClass, asBold/*umlBold*/, "self.extension_Internationalized.face");
		ocl.assertQueryEquals(ocl.mm.umlGermanClass, umlBold, "self.extension_Internationalized.face");
		ocl.assertQueryEquals(ocl.mm.asGermanClass, asBold/*umlBold*/, "self.extension_Internationalized.face()");
		ocl.assertQueryEquals(ocl.mm.umlGermanClass, umlBold, "self.extension_Internationalized.face()");
		ocl.dispose();
	}
}