/*******************************************************************************
 * Copyright (c) 2011, 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
 *******************************************************************************/

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

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.examples.xtext.tests.TestUtil;
import org.eclipse.ocl.examples.xtext.tests.company.CompanyPackage;
import org.eclipse.ocl.pivot.ids.IdResolver;
import org.eclipse.ocl.pivot.ids.TypeId;
import org.eclipse.ocl.pivot.internal.messages.PivotMessagesInternal;
import org.eclipse.ocl.pivot.internal.values.BagImpl;
import org.eclipse.ocl.pivot.messages.PivotMessages;
import org.eclipse.ocl.pivot.utilities.ClassUtil;
import org.eclipse.ocl.pivot.utilities.OCL;
import org.eclipse.ocl.pivot.values.OrderedSetValue;
import org.eclipse.ocl.pivot.values.Value;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

/**
 * Tests for model access operations.
 */
@RunWith(value = Parameterized.class)
public class EvaluateModelOperationsTest4 extends PivotTestSuite
{
	@Parameters
	public static Collection<Object[]> data() {
		Object[][] data = new Object[][]{{false}, {true}};
		return Arrays.asList(data);
	}

	public EvaluateModelOperationsTest4(boolean useCodeGen) {
		super(useCodeGen);
	}

	protected @NonNull TestOCL createOCLWithProjectMap() {
		return new TestOCL(getTestFileSystem(), getTestPackageName(), getName(), getProjectMap());
	}

	@Override
	protected @NonNull String getTestPackageName() {
		return "EvaluateModelOperations";
	}

	@BeforeClass public static void resetCounter() throws Exception {
		PivotTestSuite.resetCounter();
	}

	@Override
	@Before public void setUp() throws Exception {
		TestUtil.doOCLinEcoreSetup();
		super.setUp();
	}

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

	@SuppressWarnings("unchecked")
	public void eAdd(@NonNull EObject eObject, @NonNull String featureName, @Nullable Object value) {
		EStructuralFeature eStructuralFeature = eObject.eClass().getEStructuralFeature(featureName);
		assert eStructuralFeature.isMany();
		if (eStructuralFeature instanceof EReference) {
			assert value instanceof EObject;
		}
		else {
			assert !(value instanceof EObject);
		}
		((List<Object>)eObject.eGet(eStructuralFeature)).add(value);
	}

	public @NonNull EObject eCreate(EClass cClass) {
		return ClassUtil.nonNullEMF(cClass.getEPackage().getEFactoryInstance().create(cClass));
	}

	public void eSet(@NonNull EObject eObject, @NonNull String featureName, @Nullable Object value) {
		EStructuralFeature eStructuralFeature = eObject.eClass().getEStructuralFeature(featureName);
		assert !eStructuralFeature.isMany();
		if (eStructuralFeature instanceof EReference) {
			assert value instanceof EObject;
		}
		else {
			assert !(value instanceof EObject);
		}
		eObject.eSet(eStructuralFeature, value);
	}

	/**
	 * Test that Ecore Data Types can be used. Inspired by Bug 358713.
	 */
	@Test public void test_ecoreDataTypes() throws Exception {
		TestOCL ocl = createOCL();
		String metamodelText =
				"import ecore : 'http://www.eclipse.org/emf/2002/Ecore#/';\n" +
						"package pkg : pkg = 'pkg' {\n" +
						"  class A {\n" +
						"    property anEBigDecimal : ecore::EBigDecimal;\n" +
						"    property anEBigInteger : ecore::EBigInteger;\n" +
						"    property anEBoolean : ecore::EBoolean;\n" +
						"    property anEBooleanObject : ecore::EBooleanObject;\n" +
						"    property anEByte : ecore::EByte;\n" +
						"    property anEByteObject : ecore::EByteObject;\n" +
						"    property anEChar : ecore::EChar;\n" +
						"    property anECharacterObject : ecore::ECharacterObject;\n" +
						"    property anEDouble : ecore::EDouble;\n" +
						"    property anEDoubleObject : ecore::EDoubleObject;\n" +
						"    property anEFloat : ecore::EFloat;\n" +
						"    property anEFloatObject : ecore::EFloatObject;\n" +
						"    property anEInt : ecore::EInt;\n" +
						"    property anEIntegerObject : ecore::EIntegerObject;\n" +
						"    property anELong : ecore::ELong;\n" +
						"    property anELongObject : ecore::ELongObject;\n" +
						"    property anEShort : ecore::EShort;\n" +
						"    property anEShortObject : ecore::EShortObject;\n" +
						"    property anEString : ecore::EString;\n" +
						"    property anEDate : ecore::EDate;\n" +
						"  }\n" +
						"}\n";
		Resource metamodel = cs2ecore(ocl, metamodelText, getTestFileURI("test.ecore"));
		EPackage ePackage = (EPackage) metamodel.getContents().get(0);
		EClass eClass = ClassUtil.nonNullState((EClass) ePackage.getEClassifiers().get(0));
		//        helper.setContext(metamodelManager.getIdResolver().getType(eClass));
		EObject eObject = eCreate(eClass);
		//
		Date nowDate = new Date();
		eSet(eObject, "anEDate", nowDate);
		ocl.assertQueryTrue(eObject, "anEDate = anEDate");
		ocl.assertQueryFalse(eObject, "anEDate = ecore::EDate{value='2345-12-23'}");
		//
		eSet(eObject, "anEBigDecimal", BigDecimal.valueOf(0));
		ocl.assertQueryEquals(eObject, 0, "anEBigDecimal");
		ocl.assertQueryEquals(eObject, 1, "anEBigDecimal + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEBigDecimal");
		ocl.assertQueryEquals(eObject, 1, "self.anEBigDecimal + 1");
		//
		eSet(eObject, "anEBigInteger", BigInteger.valueOf(0));
		ocl.assertQueryEquals(eObject, 0, "anEBigInteger");
		ocl.assertQueryEquals(eObject, 1, "anEBigInteger + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEBigInteger");
		ocl.assertQueryEquals(eObject, 1, "self.anEBigInteger + 1");
		//
		ocl.assertQueryEquals(eObject, false, "anEBoolean");
		ocl.assertQueryEquals(eObject, true, "anEBoolean or true");
		ocl.assertQueryEquals(eObject, false, "self.anEBoolean");
		ocl.assertQueryEquals(eObject, true, "self.anEBoolean or true");
		//
		eSet(eObject, "anEBooleanObject", false);
		ocl.assertQueryEquals(eObject, false, "anEBooleanObject");
		ocl.assertQueryEquals(eObject, true, "anEBooleanObject or true");
		ocl.assertQueryEquals(eObject, false, "self.anEBooleanObject");
		ocl.assertQueryEquals(eObject, true, "self.anEBooleanObject or true");
		//
		ocl.assertQueryEquals(eObject, 0, "anEByte");
		ocl.assertQueryEquals(eObject, 1, "anEByte + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEByte");
		ocl.assertQueryEquals(eObject, 1, "self.anEByte + 1");
		//
		eSet(eObject, "anEByteObject", (byte)0);
		ocl.assertQueryEquals(eObject, 0, "anEByteObject");
		ocl.assertQueryEquals(eObject, 1, "anEByteObject + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEByteObject");
		ocl.assertQueryEquals(eObject, 1, "self.anEByteObject + 1");
		//
		ocl.assertQueryEquals(eObject, 0, "anEChar");
		ocl.assertQueryEquals(eObject, 1, "anEChar + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEChar");
		ocl.assertQueryEquals(eObject, 1, "self.anEChar + 1");
		//
		eSet(eObject, "anECharacterObject", (char)0);
		ocl.assertQueryEquals(eObject, 0, "anECharacterObject");
		ocl.assertQueryEquals(eObject, 1, "anECharacterObject + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anECharacterObject");
		ocl.assertQueryEquals(eObject, 1, "self.anECharacterObject + 1");
		//
		ocl.assertQueryEquals(eObject, 0, "anEDouble");
		ocl.assertQueryEquals(eObject, 1, "anEDouble + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEDouble");
		ocl.assertQueryEquals(eObject, 1, "self.anEDouble + 1");
		//
		eSet(eObject, "anEDoubleObject", (double)0);
		ocl.assertQueryEquals(eObject, 0, "anEDoubleObject");
		ocl.assertQueryEquals(eObject, 1, "anEDoubleObject + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEDoubleObject");
		ocl.assertQueryEquals(eObject, 1, "self.anEDoubleObject + 1");
		//
		ocl.assertQueryEquals(eObject, 0, "anEFloat");
		ocl.assertQueryEquals(eObject, 1, "anEFloat + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEFloat");
		ocl.assertQueryEquals(eObject, 1, "self.anEFloat + 1");
		//
		eSet(eObject, "anEFloatObject", (float)0);
		ocl.assertQueryEquals(eObject, 0, "anEFloatObject");
		ocl.assertQueryEquals(eObject, 1, "anEFloatObject + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEFloatObject");
		ocl.assertQueryEquals(eObject, 1, "self.anEFloatObject + 1");
		//
		ocl.assertQueryEquals(eObject, 0, "anEInt");
		ocl.assertQueryEquals(eObject, 1, "anEInt + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEInt");
		ocl.assertQueryEquals(eObject, 1, "self.anEInt + 1");
		//
		eSet(eObject, "anEIntegerObject", 0);
		ocl.assertQueryEquals(eObject, 0, "anEIntegerObject");
		ocl.assertQueryEquals(eObject, 1, "anEIntegerObject + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEIntegerObject");
		ocl.assertQueryEquals(eObject, 1, "self.anEIntegerObject + 1");
		//
		ocl.assertQueryEquals(eObject, 0, "anELong");
		ocl.assertQueryEquals(eObject, 1, "anELong + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anELong");
		ocl.assertQueryEquals(eObject, 1, "self.anELong + 1");
		//
		eSet(eObject, "anELongObject", (long)0);
		ocl.assertQueryEquals(eObject, 0, "anELongObject");
		ocl.assertQueryEquals(eObject, 1, "anELongObject + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anELongObject");
		ocl.assertQueryEquals(eObject, 1, "self.anELongObject + 1");
		//
		ocl.assertQueryEquals(eObject, 0, "anEShort");
		ocl.assertQueryEquals(eObject, 1, "anEShort + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEShort");
		ocl.assertQueryEquals(eObject, 1, "self.anEShort + 1");
		//
		eSet(eObject, "anEShortObject", (short)0);
		ocl.assertQueryEquals(eObject, 0, "anEShortObject");
		ocl.assertQueryEquals(eObject, 1, "anEShortObject + 1");
		ocl.assertQueryEquals(eObject, 0, "self.anEShortObject");
		ocl.assertQueryEquals(eObject, 1, "self.anEShortObject + 1");
		//
		eSet(eObject, "anEString", "");
		ocl.assertQueryEquals(eObject, "", "anEString");
		ocl.assertQueryEquals(eObject, "1", "anEString + '1'");
		ocl.assertQueryEquals(eObject, "", "self.anEString");
		ocl.assertQueryEquals(eObject, "1", "self.anEString + '1'");
		ocl.dispose();
	}

	/**
	 * Test implicit collect and oclAsSet() therein. Inspired by Bug 351512.
	 */
	@Test public void test_oclAsSet_351512() throws Exception {
		TestOCL ocl = createOCL();
		IdResolver idResolver = ocl.getIdResolver();
		String metamodelText =
				"import ecore : 'http://www.eclipse.org/emf/2002/Ecore#/';\n" +
						"package pkg : pkg = 'pkg' {\n" +
						"  class A {\n" +
						"    property bs : B[*] {ordered,unique};\n" +
						"    attribute name : String;\n" +
						"  }\n" +
						"  class B {\n" +
						"    property c : C;\n" +
						"  }\n" +
						"  class C {\n" +
						"    attribute name : String;\n" +
						"  }\n" +
						"}\n";
		Resource metamodel = cs2ecore(ocl, metamodelText, getTestFileURI("test.ecore"));
		EPackage ePackage = (EPackage) metamodel.getContents().get(0);
		EClass aClass = ClassUtil.nonNullState((EClass) ePackage.getEClassifier("A"));
		EClass bClass = (EClass) ePackage.getEClassifier("B");
		EClass cClass = (EClass) ePackage.getEClassifier("C");
		EObject c1 = eCreate(cClass);
		eSet(c1, "name", "c1");
		EObject c2 = eCreate(cClass);
		eSet(c2, "name", "c2");
		EObject b1 = eCreate(bClass);
		eSet(b1, "c", c1);
		EObject b2 = eCreate(bClass);
		eSet(b2, "c", c2);
		EObject a = eCreate(aClass);
		eAdd(a, "bs", b1);
		eAdd(a, "bs", b2);
		//
		Object b1_value = idResolver.boxedValueOf(b1);
		Object b2_value = idResolver.boxedValueOf(b2);
		Object c1_value = idResolver.boxedValueOf(c1);
		Object c2_value = idResolver.boxedValueOf(c2);
		Value orderedSet_b1_b2 = idResolver.createOrderedSetOfEach(TypeId.ORDERED_SET.getSpecializedId(TypeId.OCL_ANY), b1_value, b2_value);
		Value sequence_c1_c2 = idResolver.createSequenceOfEach(TypeId.SEQUENCE.getSpecializedId(TypeId.OCL_ANY), c1_value, c2_value);
		//
		ocl.assertQueryEquals(a, orderedSet_b1_b2, "bs");
		ocl.assertQueryEquals(a, sequence_c1_c2, "bs?.c");
		ocl.assertQueryEquals(a, sequence_c1_c2, "bs?.c.oclAsSet()");
		ocl.assertQueryResults(a, "Sequence{'c1','c2'}", "bs?.c?.name");
		ocl.assertQueryResults(a, "Sequence{'c1','c2'}", "self.bs?.c?.name");
		ocl.assertQueryResults(a, "Sequence{'c1','c2'}", "bs?.c?.oclAsSet().name");
		ocl.assertQueryResults(a, "Sequence{'c1','c2'}", "bs?.c?.oclAsSet()->collect(name)");	// Test for Bug 351512
		ocl.assertQueryResults(a, "Sequence{'c1','c2'}", "bs?.c?->collect(oclAsSet()).name");
		ocl.assertQueryResults(a, "Sequence{'c1','c2'}", "bs?.c?->collect(j : C | j.oclAsSet()).name");
		ocl.assertQueryResults(a, "Sequence{'c1','c2'}", "bs?->collect(i : B | i.c)?->collect(j : C | j.oclAsSet())->collect(k : C | k.name)");
		ocl.dispose();
	}

	/**
	 * Test container/containment navigation.
	 */
	@Test public void test_containment_navigation() throws Exception {
		TestOCL ocl = createOCL();
		IdResolver idResolver = ocl.getIdResolver();
		String metamodelText =
				"package containment : pfx = 'http://containment'\n" +
						"{\n" +
						"	class Parent\n" +
						"	{\n" +
						"		property child1 : Child1[?] { ordered composes };\n" +
						"		property child2#parent : Child2[?] { ordered composes };\n" +
						"		property children1 : Children1[*] { ordered composes };\n" +
						"		property children2#parent : Children2[*] { ordered composes };\n" +
						"	}\n" +
						"	class Child1\n" +
						"	{\n" +
						"	}\n" +
						"	class Child2\n" +
						"	{\n" +
						"		property parent#child2 : Parent[?] { ordered };\n" +
						"	}\n" +
						"	class Children1\n" +
						"	{\n" +
						"	}\n" +
						"	class Children2\n" +
						"	{\n" +
						"		property parent#children2 : Parent[?] { ordered };\n" +
						"	}\n" +
						"}\n";
		OCL ocl1 = createOCL();
		Resource metamodel = cs2ecore(ocl1, metamodelText, getTestFileURI("test.ecore"));
		EPackage ePackage = (EPackage) metamodel.getContents().get(0);
		EClass parentClass = ClassUtil.nonNullState((EClass) ePackage.getEClassifier("Parent"));
		EClass child1Class = ClassUtil.nonNullState((EClass) ePackage.getEClassifier("Child1"));
		EClass child2Class = ClassUtil.nonNullState((EClass) ePackage.getEClassifier("Child2"));
		EClass children1Class = ClassUtil.nonNullState((EClass) ePackage.getEClassifier("Children1"));
		EClass children2Class = ClassUtil.nonNullState((EClass) ePackage.getEClassifier("Children2"));
		EObject parent = eCreate(parentClass);
		EObject child1 = eCreate(child1Class);
		EObject child2 = eCreate(child2Class);
		EObject children1 = eCreate(children1Class);
		EObject children2 = eCreate(children2Class);
		eSet(parent, "child1", child1);
		eSet(parent, "child2", child2);
		eAdd(parent, "children1", children1);
		eAdd(parent, "children2", children2);

		org.eclipse.ocl.pivot.Class parentType = idResolver.getType(parentClass);
		org.eclipse.ocl.pivot.Class child1Type = idResolver.getType(child1Class);
		org.eclipse.ocl.pivot.Class child2Type = idResolver.getType(child2Class);
		org.eclipse.ocl.pivot.Class children1Type = idResolver.getType(children1Class);
		org.eclipse.ocl.pivot.Class children2Type = idResolver.getType(children2Class);
		//
		OrderedSetValue kids1 = idResolver.createOrderedSetOfEach(TypeId.ORDERED_SET.getSpecializedId(children1Type.getTypeId()), children1);
		OrderedSetValue kids2 = idResolver.createOrderedSetOfEach(TypeId.ORDERED_SET.getSpecializedId(children2Type.getTypeId()), children2);
		//
		ocl.assertSemanticErrorQuery(parentType, "parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, "", "parent");
		ocl.assertSemanticErrorQuery(parentType, "self.parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, parentType, "parent");
		ocl.assertQueryEquals(parent, parentType, "Parent");
		ocl.assertSemanticErrorQuery(parentType, "self.Parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, parentType, "Parent");
		ocl.assertQueryEquals(parent, child1, "child1");
		ocl.assertQueryEquals(parent, child1, "self.child1");
		ocl.assertQueryEquals(parent, child1Type, "Child1");
		ocl.assertSemanticErrorQuery(parentType, "self.Child1", PivotMessagesInternal.UnresolvedProperty_ERROR_, parentType, "Child1");
		ocl.assertQueryEquals(parent, child2, "child2");
		ocl.assertQueryEquals(parent, child2, "self.child2");
		ocl.assertQueryEquals(parent, child2Type, "Child2");
		ocl.assertSemanticErrorQuery(parentType, "self.Child2", PivotMessagesInternal.UnresolvedProperty_ERROR_, parentType, "Child2");
		ocl.assertQueryEquals(parent, kids1, "children1");
		ocl.assertQueryEquals(parent, kids1, "self.children1");
		ocl.assertQueryEquals(parent, children1Type, "Children1");
		ocl.assertSemanticErrorQuery(parentType, "self.Children1", PivotMessagesInternal.UnresolvedProperty_ERROR_, parentType, "Children1");
		ocl.assertQueryEquals(parent, kids2, "children2");
		ocl.assertQueryEquals(parent, kids2, "self.children2");
		ocl.assertQueryEquals(parent, children2Type, "Children2");
		ocl.assertSemanticErrorQuery(parentType, "self.Children2", PivotMessagesInternal.UnresolvedProperty_ERROR_, parentType, "Children2");
		//
		ocl.assertSemanticErrorQuery(child1Type, "parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, "", "parent");
		ocl.assertQueryEquals(child2, parentType, "Parent");
		ocl.assertSemanticErrorQuery(child1Type, "self.parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, child1Type, "parent");
		ocl.assertQueryEquals(child1, parent, "self.Parent");
		//
		ocl.assertQueryEquals(child2, parent, "parent");
		ocl.assertQueryEquals(child2, parentType, "Parent");
		ocl.assertQueryEquals(child2, parent, "self.parent");
		ocl.assertSemanticErrorQuery(child2Type, "self.Parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, child2Type, "Parent");
		//
		ocl.assertSemanticErrorQuery(children1Type, "parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, "", "parent");
		ocl.assertQueryEquals(children1, parentType, "Parent");
		ocl.assertSemanticErrorQuery(children1Type, "self.parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, children1Type, "parent");
		ocl.assertQueryEquals(children1, parent, "self.Parent");
		//
		ocl.assertQueryEquals(children2, parent, "parent");
		ocl.assertQueryEquals(children2, parentType, "Parent");
		ocl.assertQueryEquals(children2, parent, "self.parent");
		ocl.assertSemanticErrorQuery(children2Type, "self.Parent", PivotMessagesInternal.UnresolvedProperty_ERROR_, children2Type, "Parent");
		//
		ocl.assertQueryTrue(parent, "child1 = child1");
		ocl1.dispose();
		ocl.dispose();
	}

	/**
	 * Tests that boxed Enumerations are navigable
	 */
	@Test public void test_enumeration_navigation() throws Exception {
		TestOCL ocl = createOCL();
		if (!useCodeGen) {			// FIXME BUG 458359
			ocl.assertQueryResults(CompanyPackage.Literals.COMPANY_SIZE_KIND, "Sequence{'small','medium','large'}", "self.eLiterals.name");
			// FIXME the following needs the full UML model to vbe loaded otherwise $uml$ is not a defined root package id.
			//		UML2AS.initialize(resourceSet);
			//		ocl.assertQueryResults(UMLPackage.Literals.AGGREGATION_KIND, "Sequence{'none','composite'}", "self.eLiterals.name");
		}
		ocl.dispose();
	}

	/**
	 * Test that Ecore Maps are loaded for MapValue evaluation.
	 */
	@Test public void test_maps() throws Exception {
		TestOCL ocl = createOCLWithProjectMap();
		URI uri = URI.createPlatformResourceURI("org.eclipse.emf.ecore/model/Ecore.ecore", true);
		EObject ePackage = ocl.getResourceSet().getEObject(uri.appendFragment("/"), true);
		//
		ocl.assertQueryResults(ePackage, "Set{'baseType','constraints','name'}",
				"self.eClassifiers->collect(c | c.eAnnotations)->collect(a | a.details)->collect(m | m->collect(k <- v | k))->asSet()");
		//	ocl.assertQueryResults(ePackage, "Set{'baseType','constraints','name','suppressedIsSetVisibility','suppressedUnsetVisibility'}",
		//	"ecore::EAnnotation.allInstances().details->collect(m | m->collect(k <- v | k))->asSet()");
		ocl.dispose();
	}

	/**
	 * Test multi-container navigation inspired by Bug 394152.
	 */
	@Test public void test_multi_container_394152() throws Exception {
		TestOCL ocl = createOCL();
		String metamodelText =
				"package bug394152 : pfx = 'http://bug394152'\n" +
						"{\n" +
						"	class Parent\n" +
						"	{\n" +
						"		property left#left : Child[+] { ordered composes };\n" +
						"		property right#right : Child[+] { ordered composes };\n" +
						"	}\n" +
						"	class Child\n" +
						"	{\n" +
						"		property left#left : Parent[?] { ordered };\n" +
						"		property right#right : Parent[?] { ordered };\n" +
						"	}\n" +
						"}\n";
		Resource metamodel = cs2ecore(ocl, metamodelText, getTestFileURI("test.ecore"));
		EPackage ePackage = (EPackage) metamodel.getContents().get(0);
		EClass parentClass = (EClass) ePackage.getEClassifier("Parent");
		EClass childClass = ClassUtil.nonNullState((EClass) ePackage.getEClassifier("Child"));
		EObject parent = eCreate(parentClass);
		EObject leftChild = eCreate(childClass);
		EObject rightChild = eCreate(childClass);
		eAdd(parent, "left", leftChild);
		eAdd(parent, "right", rightChild);
		//
		ocl.assertQueryEquals(leftChild, parent, "left");
		ocl.assertQueryEquals(leftChild, null, "right");
		ocl.assertQueryEquals(rightChild, null, "left");
		ocl.assertQueryEquals(rightChild, parent, "right");
		ocl.dispose();
	}

	@Test public void test_unified_types_411441() throws Exception {
		TestOCL ocl = createOCL();
		ocl.assertQueryTrue(null, "let x : Collection(Type) = Set{Integer,Real} in x?->forAll(x : Type | x.name.indexOf('e') > 0)");
		ocl.assertQueryTrue(null, "let x : Type[*] = Bag{Integer,Real} in x?->forAll(x : Type | x.name.indexOf('e') > 0)");
		ocl.assertValidationErrorQuery(null, "let x : Type[*] = Set{Integer,Real} in x?->forAll(x : Type | x.name.indexOf('e') > 0)",
			PivotMessages.ValidationConstraintIsNotSatisfied_ERROR_, "LetVariable::CompatibleTypeForInitializer", "x : Bag(Type[*|?]) = Set{Integer, Real}");
		ocl.assertQueryTrue(null, "let x : Collection(Collection(Type[*])) = Set{Bag{Integer,Real},Bag{Boolean}} in x?->forAll(x : Collection(Type[*]) | x->size() > 0)");
		ocl.assertValidationErrorQuery(null, "let x : Collection(Collection(Type[*])) = Set{Bag{Integer,Real},Bag{Boolean}} in x?->forAll(x : Type | x->size() > 0)",
			PivotMessages.ValidationConstraintIsNotSatisfied_ERROR_, "IteratorExp::IteratorTypeIsSourceElementType", "x?->forAll(x : Type[1] | x.oclAsSet()->size().>(0))");
		ocl.assertValidationErrorQuery(null, "let x : Collection(Type) = Set{Integer,Real} in x?->forAll(x : Type[*] | x->size() > 0)",
			PivotMessages.ValidationConstraintIsNotSatisfied_ERROR_, "IteratorExp::IteratorTypeIsSourceElementType", "x?->forAll(x : Bag(Type[*|?]) | x->size().>(0))");
		ocl.dispose();
	}

	@Test
	public void test_ecore_collection_equality() throws Exception {
		TestOCL ocl = createOCL();
		//
		EList<EStructuralFeature> eStructuralFeatures = EcorePackage.Literals.ECLASS.getEStructuralFeatures();
		ocl.assertQueryOCLEquals(EcorePackage.Literals.ECLASS, eStructuralFeatures, "self.eStructuralFeatures");
		//
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, eStructuralFeatures, "self.eStructuralFeatures->asBag()");
		ocl.assertQueryOCLEquals(EcorePackage.Literals.ECLASS, eStructuralFeatures, "self.eStructuralFeatures->asOrderedSet()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, eStructuralFeatures, "self.eStructuralFeatures->asSequence()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, eStructuralFeatures, "self.eStructuralFeatures->asSet()");
		//
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new HashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asBag()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new HashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asOrderedSet()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new HashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asSequence()");
		ocl.assertQueryOCLEquals(EcorePackage.Literals.ECLASS, new HashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asSet()");
		//
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new ArrayList<>(eStructuralFeatures), "self.eStructuralFeatures->asBag()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new ArrayList<>(eStructuralFeatures), "self.eStructuralFeatures->asOrderedSet()");
		ocl.assertQueryOCLEquals(EcorePackage.Literals.ECLASS, new ArrayList<>(eStructuralFeatures), "self.eStructuralFeatures->asSequence()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new ArrayList<>(eStructuralFeatures), "self.eStructuralFeatures->asSequence()->reverse()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new ArrayList<>(eStructuralFeatures), "self.eStructuralFeatures->asSet()");
		//
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new LinkedHashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asBag()");
		ocl.assertQueryOCLEquals(EcorePackage.Literals.ECLASS, new LinkedHashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asOrderedSet()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new LinkedHashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asOrderedSet()->reverse()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new LinkedHashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asSequence()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new LinkedHashSet<>(eStructuralFeatures), "self.eStructuralFeatures->asSet()");
		//
		Iterable<@NonNull EStructuralFeature> eStructuralFeatures2 = ClassUtil.nullFree(eStructuralFeatures);
		ocl.assertQueryOCLEquals(EcorePackage.Literals.ECLASS, new BagImpl<>(eStructuralFeatures2), "self.eStructuralFeatures->asBag()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new BagImpl<>(eStructuralFeatures2), "self.eStructuralFeatures->asOrderedSet()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new BagImpl<>(eStructuralFeatures2), "self.eStructuralFeatures->asSequence()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, new BagImpl<>(eStructuralFeatures2), "self.eStructuralFeatures->asSet()");
		//
		ocl.assertQueryOCLEquals(EcorePackage.Literals.ECLASS, org.eclipse.ocl.util.CollectionUtil.createNewBag(eStructuralFeatures), "self.eStructuralFeatures->asBag()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, org.eclipse.ocl.util.CollectionUtil.createNewBag(eStructuralFeatures), "self.eStructuralFeatures->asOrderedSet()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, org.eclipse.ocl.util.CollectionUtil.createNewBag(eStructuralFeatures), "self.eStructuralFeatures->asSequence()");
		ocl.assertQueryOCLNotEquals(EcorePackage.Literals.ECLASS, org.eclipse.ocl.util.CollectionUtil.createNewBag(eStructuralFeatures), "self.eStructuralFeatures->asSet()");
		//
		ocl.dispose();
	}

	@Test
	public void test_ecore_number_equality() throws Exception {
		TestOCL ocl = createOCL();
		//
		ocl.assertQueryOCLEquals(null, Byte.valueOf((byte)255), "-1");
		ocl.assertQueryOCLEquals(null, Character.valueOf((char)255), "255");
		ocl.assertQueryOCLEquals(null, Short.valueOf((short)255), "255");
		ocl.assertQueryOCLEquals(null, Integer.valueOf(255), "255");
		ocl.assertQueryOCLEquals(null, Long.valueOf(255), "255");
		ocl.assertQueryOCLEquals(null, BigInteger.valueOf(255), "255");
		ocl.assertQueryOCLEquals(null, Float.valueOf(255), "255");
		ocl.assertQueryOCLEquals(null, Double.valueOf(255), "255");
		ocl.assertQueryOCLEquals(null, BigDecimal.valueOf(255), "255");
		//
		ocl.assertQueryOCLNotEquals(null, Byte.valueOf((byte)255), "254");
		ocl.assertQueryOCLNotEquals(null, Character.valueOf((char)255), "254");
		ocl.assertQueryOCLNotEquals(null, Short.valueOf((short)255), "254");
		ocl.assertQueryOCLNotEquals(null, Integer.valueOf(255), "254");
		ocl.assertQueryOCLNotEquals(null, Long.valueOf(255), "254");
		ocl.assertQueryOCLNotEquals(null, BigInteger.valueOf(255), "254");
		ocl.assertQueryOCLNotEquals(null, Float.valueOf(255), "255.1");
		ocl.assertQueryOCLNotEquals(null, Double.valueOf(255), "255.1");
		ocl.assertQueryOCLNotEquals(null, BigDecimal.valueOf(255), "255.1");
		//
		ocl.dispose();
	}
}