/*******************************************************************************
 * Copyright (c) 2010, 2021 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:
 *   L.Goubet, E.D.Willink - Initial API and implementation
 *   E.D.Willink - Bug 400448
 *******************************************************************************/

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

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

import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.examples.xtext.tests.TestFileSystem;
import org.eclipse.ocl.pivot.CompleteEnvironment;
import org.eclipse.ocl.pivot.Model;
import org.eclipse.ocl.pivot.StandardLibrary;
import org.eclipse.ocl.pivot.TupleType;
import org.eclipse.ocl.pivot.Type;
import org.eclipse.ocl.pivot.ids.CollectionTypeId;
import org.eclipse.ocl.pivot.ids.IdManager;
import org.eclipse.ocl.pivot.ids.TuplePartId;
import org.eclipse.ocl.pivot.ids.TupleTypeId;
import org.eclipse.ocl.pivot.ids.TypeId;
import org.eclipse.ocl.pivot.internal.manager.MetamodelManagerInternal;
import org.eclipse.ocl.pivot.internal.messages.PivotMessagesInternal;
import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal.EnvironmentFactoryInternalExtension;
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.utilities.PivotConstants;
import org.eclipse.ocl.pivot.utilities.PivotUtil;
import org.eclipse.ocl.pivot.utilities.ValueUtil;
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 OclAny operations.
 */
@RunWith(value = Parameterized.class)
public class EvaluateOclAnyOperationsTest4 extends PivotTestSuite
{
	public static class MyOCL extends TestOCL
	{
		// need a metamodel that has a reflexive EReference.
		// Ecore will do nicely. Create the following structure:
		// pkg1
		// pkg1::pkg2
		// pkg1::pkg2::jim
		// pkg1::bob
		// pkg1::pkg3
		// pkg1::pkg3::pkg4
		// pkg1::pkg3::pkg5
		// pkg1::pkg3::pkg5::george
		@NonNull Model root = PivotUtil.createModel(null);
		org.eclipse.ocl.pivot.@NonNull Package pkg1 = PivotUtil.createOwnedPackage(root, "pkg1");
		org.eclipse.ocl.pivot.@NonNull Package pkg2 = PivotUtil.createOwnedPackage(pkg1, "pkg2");
		org.eclipse.ocl.pivot.@NonNull Package jim = PivotUtil.createOwnedPackage(pkg2, "jim");
		org.eclipse.ocl.pivot.@NonNull Package bob = PivotUtil.createOwnedPackage(pkg1, "bob");
		org.eclipse.ocl.pivot.@NonNull Package pkg3 = PivotUtil.createOwnedPackage(pkg1, "pkg3");
		org.eclipse.ocl.pivot.@NonNull Package pkg4 = PivotUtil.createOwnedPackage(pkg3, "pkg4");
		org.eclipse.ocl.pivot.@NonNull Package pkg5 = PivotUtil.createOwnedPackage(pkg3, "pkg5");
		org.eclipse.ocl.pivot.@NonNull Package george = PivotUtil.createOwnedPackage(pkg5, "george");

		public MyOCL(@NonNull TestFileSystem testFileSystem, @NonNull String testPackageName, @NonNull String name, @Nullable ResourceSet externalResourceSet) {
			super(testFileSystem, testPackageName, name, useCodeGen ? getProjectMap() : OCL.NO_PROJECTS, externalResourceSet);
			MetamodelManagerInternal metamodelManager = getMetamodelManager();
			//			metamodelManager.addGlobalNamespace(PivotConstants.OCL_NAME, ClassUtil.nonNullState(metamodelManager.getASmetamodel()));

			metamodelManager.installRoot(ClassUtil.nonNullState(root));
			//	        helper.setContext(ClassUtil.nonNullState(metamodelManager.getPivotType("Package")));
		}
	}

	@Parameters
	public static Collection<Object[]> data() {
		Object[][] data = new Object[][]{{false}, {true}};
		return Arrays.asList(data);
	}

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

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

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

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

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

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

	@Test public void testEqual() {
		MyOCL ocl = createOCL();
		ocl.assertQueryTrue(null, "Boolean = Boolean");
		ocl.assertQueryFalse(null, "Boolean = Integer");
		ocl.assertQueryTrue(null, "OclVoid = OclVoid");
		ocl.assertQueryTrue(null, "OclInvalid = OclInvalid");
		ocl.assertQueryFalse(null, "OclInvalid = OclVoid");
		ocl.assertQueryTrue(null, "Set(String) = Set(String)");
		ocl.assertQueryFalse(null, "Set(String) = Set(Integer)");
		ocl.assertQueryFalse(null, "Set(String) = Sequence(String)");
		//
		ocl.assertQueryTrue(null, "ocl::CollectionKind::_'Collection' = ocl::CollectionKind::_'Collection'");
		ocl.assertQueryFalse(null, "ocl::CollectionKind::_'Collection' = ocl::CollectionKind::_'Set'");
		//
		ocl.loadEPackage("ecore", EcorePackage.eINSTANCE);
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-25'} = ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryTrue(null, "ecore::EDate{value='2000-01-24'} = ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-23'} = ecore::EDate{value='2000-01-24'}");
		//
		// invalid
		//
		ocl.assertQueryInvalid(null, "invalid = 3");
		ocl.assertQueryInvalid(null, "3 = invalid");
		ocl.assertQueryInvalid(null, "invalid = 3.0");
		ocl.assertQueryInvalid(null, "3.0 = invalid");

		ocl.assertQueryInvalid(null, "invalid = 'test'");
		ocl.assertQueryInvalid(null, "'test' = invalid");
		ocl.assertQueryInvalid(null, "invalid = true");
		ocl.assertQueryInvalid(null, "false = invalid");
		ocl.assertQueryInvalid(null, "invalid = Sequence{}");
		ocl.assertQueryInvalid(null, "Sequence{} = invalid");

		ocl.assertQueryInvalid(null, "invalid = invalid");
		//
		// null
		//
		ocl.assertQueryFalse(null, "null = 3");
		ocl.assertQueryFalse(null, "3 = null");
		ocl.assertQueryFalse(null, "null = 3.0");
		ocl.assertQueryFalse(null, "3.0 = null");

		ocl.assertQueryFalse(null, "null = 'test'");
		ocl.assertQueryFalse(null, "'test' = null");
		ocl.assertQueryFalse(null, "null = true");
		ocl.assertQueryFalse(null, "false = null");
		ocl.assertQueryFalse(null, "null = Sequence{}");
		ocl.assertQueryFalse(null, "Sequence{} = null");

		ocl.assertQueryTrue(null, "null = null");
		ocl.dispose();
	}

	@Test public void testGreaterThan() {
		MyOCL ocl = createOCL();
		StandardLibrary standardLibrary = ocl.getStandardLibrary();
		ocl.loadEPackage("ecore", EcorePackage.eINSTANCE);
		ocl.assertQueryTrue(null, "ecore::EDate{value='2000-01-25'} > ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-24'} > ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-23'} > ecore::EDate{value='2000-01-24'}");
		//
		// invalid
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "invalid > 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.GREATER_THAN_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "invalid > 0");
		//		assertSemanticErrorQuery2(null, "0 > invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OPERATOR);
		ocl.assertQueryInvalid(null, "0 > invalid");
		ocl.assertSemanticErrorQuery(null, "invalid > invalid", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.GREATER_THAN_OPERATOR, standardLibrary.getOclInvalidType());
		//
		// null
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "null > 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.GREATER_THAN_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "null > 0");
		//		assertSemanticErrorQuery2(null, "0 > null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OPERATOR);
		ocl.assertQueryInvalid(null, "0 > null");
		ocl.assertSemanticErrorQuery(null, "null > null", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.GREATER_THAN_OPERATOR, standardLibrary.getOclVoidType());
		ocl.dispose();
	}

	@Test public void testGreaterThanOrEqual() {
		MyOCL ocl = createOCL();
		StandardLibrary standardLibrary = ocl.getStandardLibrary();
		ocl.loadEPackage("ecore", EcorePackage.eINSTANCE);
		ocl.assertQueryTrue(null, "ecore::EDate{value='2000-01-25'} >= ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryTrue(null, "ecore::EDate{value='2000-01-24'} >= ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-23'} >= ecore::EDate{value='2000-01-24'}");
		//
		// invalid
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "invalid >= 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "invalid >= 0");
		//		assertSemanticErrorQuery2(null, "0 >= invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR);
		ocl.assertQueryInvalid(null, "0 >= invalid");
		ocl.assertSemanticErrorQuery(null, "invalid >= invalid", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR, standardLibrary.getOclInvalidType());
		//
		// null
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "null >= 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "null >= 0");
		//		assertSemanticErrorQuery2(null, "0 >= null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR);
		ocl.assertQueryInvalid(null, "0 >= null");
		ocl.assertSemanticErrorQuery(null, "null >= null", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR, standardLibrary.getOclVoidType());
		ocl.dispose();
	}

	@Test public void testLessThan() {
		MyOCL ocl = createOCL();
		StandardLibrary standardLibrary = ocl.getStandardLibrary();
		ocl.loadEPackage("ecore", EcorePackage.eINSTANCE);
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-25'} < ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-24'} < ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryTrue(null, "ecore::EDate{value='2000-01-23'} < ecore::EDate{value='2000-01-24'}");
		//
		// invalid
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "invalid < 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.LESS_THAN_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "invalid < 0");
		//		assertSemanticErrorQuery2(null, "0 < invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OPERATOR);
		ocl.assertQueryInvalid(null, "0 < invalid");
		ocl.assertSemanticErrorQuery(null, "invalid < invalid", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.LESS_THAN_OPERATOR, standardLibrary.getOclInvalidType());
		//
		// null
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "null < 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.LESS_THAN_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "null < 0");
		//		assertSemanticErrorQuery2(null, "0 < null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OPERATOR);
		ocl.assertQueryInvalid(null, "0 < null");
		ocl.assertSemanticErrorQuery(null, "null < null", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.LESS_THAN_OPERATOR, standardLibrary.getOclVoidType());
		ocl.dispose();
	}

	@Test public void testLessThanOrEqual() {
		MyOCL ocl = createOCL();
		StandardLibrary standardLibrary = ocl.getStandardLibrary();
		ocl.loadEPackage("ecore", EcorePackage.eINSTANCE);
		ocl.assertQueryFalse(null, "ecore::EDate{'2000-01-25'} <= ecore::EDate{'2000-01-24'}");
		ocl.assertQueryTrue(null, "ecore::EDate{'2000-01-24'} <= ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryTrue(null, "ecore::EDate{value='2000-01-23'} <= ecore::EDate{value='2000-01-24'}");
		//
		// invalid
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "invalid <= 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "invalid <= 0");
		//		ocl.assertSemanticErrorQuery2(null, "0 <= invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR);
		ocl.assertQueryInvalid(null, "0 <= invalid");
		ocl.assertSemanticErrorQuery(null, "invalid <= invalid", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclInvalidType(), PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR, standardLibrary.getOclInvalidType());
		//
		// null
		//
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		ocl.assertSemanticErrorQuery(null, "null <= 0", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR, standardLibrary.getIntegerType());
		//		ocl.assertQueryInvalid(null, "null <= 0");
		//		ocl.assertSemanticErrorQuery2(null, "0 <= null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR);
		ocl.assertQueryInvalid(null, "0 <= null");
		ocl.assertSemanticErrorQuery(null, "null <= null", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, standardLibrary.getOclVoidType(), PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR, standardLibrary.getOclVoidType());
		ocl.dispose();
	}

	@Test public void testNotEqual() {
//		BaseLinkingService.DEBUG_RETRY.setState(true);
		MyOCL ocl = createOCL();
		ocl.assertQueryFalse(null, "Boolean <> Boolean");
		ocl.assertQueryTrue(null, "Boolean <> Integer");
		ocl.assertQueryFalse(null, "OclVoid <> OclVoid");
		ocl.assertQueryFalse(null, "OclInvalid <> OclInvalid");
		ocl.assertQueryTrue(null, "OclInvalid <> OclVoid");
		ocl.assertQueryFalse(null, "Set(String) <> Set(String)");
		ocl.assertQueryTrue(null, "Set(String) <> Set(Integer)");
		ocl.assertQueryTrue(null, "Set(String) <> Sequence(String)");
		//
		ocl.assertQueryFalse(null, "ocl::CollectionKind::_'Collection' <> ocl::CollectionKind::_'Collection'");
		ocl.assertQueryTrue(null, "ocl::CollectionKind::_'Collection' <> ocl::CollectionKind::_'Set'");
		//
		ocl.loadEPackage("ecore", EcorePackage.eINSTANCE);
		ocl.assertQueryTrue(null, "ecore::EDate{value='2000-01-25'} <> ecore::EDate{value='2000-01-24'}");
		ocl.assertQueryFalse(null, "ecore::EDate{value='2000-01-24'} <> ecore::EDate{'2000-01-24'}");
		ocl.assertQueryTrue(null, "ecore::EDate{'2000-01-23'} <> ecore::EDate{'2000-01-24'}");
		//
		// invalid
		//
		ocl.assertQueryInvalid(null, "invalid <> 3");
		ocl.assertQueryInvalid(null, "3 <> invalid");
		ocl.assertQueryInvalid(null, "invalid <> 3.0");
		ocl.assertQueryInvalid(null, "3.0 <> invalid");

		ocl.assertQueryInvalid(null, "invalid <> 'test'");
		ocl.assertQueryInvalid(null, "'test' <> invalid");
		ocl.assertQueryInvalid(null, "invalid <> true");
		ocl.assertQueryInvalid(null, "false <> invalid");
		ocl.assertQueryInvalid(null, "invalid <> Sequence{}");
		ocl.assertQueryInvalid(null, "Sequence{} <> invalid");

		ocl.assertQueryInvalid(null, "invalid <> invalid");
		//
		// null
		//
		ocl.assertQueryTrue(null, "null <> 3");
		ocl.assertQueryTrue(null, "3 <> null");
		ocl.assertQueryTrue(null, "null <> 3.0");
		ocl.assertQueryTrue(null, "3.0 <> null");

		ocl.assertQueryTrue(null, "null <> 'test'");
		ocl.assertQueryTrue(null, "'test' <> null");
		ocl.assertQueryTrue(null, "null <> true");
		ocl.assertQueryTrue(null, "false <> null");
		ocl.assertQueryTrue(null, "null <> Sequence{}");
		ocl.assertQueryTrue(null, "Sequence{} <> null");

		ocl.assertQueryFalse(null, "null <> null");
		ocl.dispose();
	}

	/**
	 * Tests the oclAsModelType() operator.
	 */
	@Test public void test_oclAsModelType() {
		MyOCL ocl = createOCL();
		ocl.assertSemanticErrorQuery(null, "invalid.oclAsModelType(OclAny)", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, "OclInvalid", "oclAsModelType", "OclAny");
		ocl.assertQueryInvalid(ocl.pkg1, "self.oclAsModelType(OclAny)");
		// See test_umlValidation_Bug458394 for some real usage
		ocl.dispose();
	}

	/**
	 * Tests the explicit oclAsSet() operator.
	 */
	@Test public void test_oclAsSet_explicit() {
		MyOCL ocl = createOCL();
		ocl.assertQueryResults(null, "Set{true}", "true.oclAsSet()");
		ocl.assertQueryResults(null, "Set{}", "null.oclAsSet()");
		ocl.assertQueryInvalid(null, "invalid.oclAsSet()");
		ocl.assertQueryResults(null, "Set{Set{1..4}}", "Set{1..4}->oclAsSet()");
		ocl.dispose();
	}

	/**
	 * Tests the implicit oclAsSet() operator.
	 */
	@Test public void test_oclAsSet_implicit() {
		MyOCL ocl = createOCL();
		StandardLibrary standardLibrary = ocl.getStandardLibrary();
		ocl.assertQueryResults(null, "Set{true}", "true->select(true)");
		ocl.assertQueryResults(null, "Set{true}", "Set{true}->select(true)");
		ocl.assertQueryResults(null, "Set{}", "null->select(true)");
		ocl.assertQueryResults(null, "Set{}", "Set{}->select(true)");
		ocl.assertQueryResults(null, "Set{null}", "Set{null}->select(true)");
		ocl.assertQueryInvalid(null, "invalid->select(true)");
		//
		ocl.assertQueryResults(null, "false", "true.oclIsUndefined()");
		ocl.assertQueryResults(null, "false", "true->oclIsUndefined()");	// Set{true}
		ocl.assertQueryResults(null, "true", "null.oclIsUndefined()");
		ocl.assertQueryResults(null, "false", "null->oclIsUndefined()");	// Set{}
		ocl.assertQueryResults(null, "true", "invalid.oclIsUndefined()");
		ocl.assertQueryResults(null, "true", "invalid->oclIsUndefined()");	// invalid
		//
		ocl.assertQueryEquals(null, 4, "'1234'.size()");
		ocl.assertQueryEquals(null, 1, "'1234'->size()");
		//
		org.eclipse.ocl.pivot.Class booleanType = standardLibrary.getBooleanType();
		ocl.assertQueryEquals(null, booleanType, "true.oclType()");
		Type collectionType = ocl.getCollectionType("Set", booleanType, false);
		ocl.assertQueryEquals(null, collectionType, "true->oclType()");		// Set{true}
		ocl.dispose();
	}

	/**
	 * Tests the oclAsType() operator.
	 */
	@Test public void test_oclAsType() {
		MyOCL ocl = createOCL();
		ocl.assertQueryInvalid(null, "invalid.oclAsType(String)");
		ocl.assertQueryInvalid(null, "invalid.oclAsType(Integer)");
		ocl.assertQueryInvalid(null, "invalid.oclAsType(Class)");
		ocl.assertQueryInvalid(null, "invalid.oclAsType(OclVoid)");
		ocl.assertQueryInvalid(null, "invalid.oclAsType(OclInvalid)");
		ocl.assertQueryInvalid(null, "invalid.oclAsType(Set(String))");
		ocl.assertQueryInvalid(null, "invalid.oclAsType(Tuple(a:String))");
		ocl.assertQueryInvalid(null, "invalid.oclAsType(ocl::Package)");
		//
		ocl.assertQueryNull(null, "let s : String = null.oclAsType(String) in s");
		ocl.assertQueryNull(null, "null.oclAsType(Integer)");
		ocl.assertQueryNull(null, "null.oclAsType(Class)");
		ocl.assertQueryNull(null, "null.oclAsType(OclVoid)");
		ocl.assertValidationErrorQuery(null, "null.oclAsType(OclInvalid)",
			PivotMessages.ValidationConstraintIsNotSatisfied_ERROR_, "CallExp::TypeIsNotInvalid", "null.oclAsType(OclInvalid)");
		ocl.assertQueryNull(null, "null.oclAsType(Set(String))");
		ocl.assertQueryNull(null, "null.oclAsType(Tuple(a:String))");
		ocl.assertQueryNull(null, "null.oclAsType(ocl::Package)");
		//
		ocl.assertQueryInvalid(null, "true.oclAsType(Integer)");
		ocl.assertQueryInvalid(null, "true.oclAsType(String)");
		ocl.assertQueryTrue(null, "true.oclAsType(Boolean)");
		ocl.assertQueryTrue(null, "true.oclAsType(OclAny)");
		ocl.assertQueryInvalid(null, "true.oclAsType(OclVoid)");
		ocl.assertQueryInvalid(null, "true.oclAsType(OclInvalid)");
		//
		ocl.assertQueryEquals(null, 3, "3.oclAsType(Integer)");
		ocl.assertQueryEquals(null, 3.0, "3.oclAsType(Real)");
		ocl.assertQueryInvalid(null, "3.0.oclAsType(Integer)");		// Cannot downcast
		ocl.assertQueryEquals(null, 3.0, "3.0.oclAsType(Real)");
		ocl.assertQueryInvalid(null, "3.oclAsType(String)");
		ocl.assertQueryEquals(null, 3, "3.oclAsType(OclAny)");
		ocl.assertQueryInvalid(null, "3.oclAsType(OclVoid)");
		ocl.assertQueryInvalid(null, "3.oclAsType(OclInvalid)");
		//
		ocl.assertQueryInvalid(null, "3.14.oclAsType(Integer)");
		ocl.assertQueryEquals(null, 3.14, "3.14.oclAsType(Real)");
		ocl.assertQueryInvalid(null, "3.14.oclAsType(String)");
		ocl.assertQueryEquals(null, 3.14, "3.14.oclAsType(OclAny)");
		ocl.assertQueryInvalid(null, "3.14.oclAsType(OclVoid)");
		ocl.assertQueryInvalid(null, "3.14.oclAsType(OclInvalid)");
		//
		ocl.assertQueryInvalid(null, "*.oclAsType(Integer)");
		ocl.assertQueryInvalid(null, "*.oclAsType(Real)");
		ocl.assertQueryUnlimited(null, "*.oclAsType(UnlimitedNatural)");
		ocl.assertQueryInvalid(null, "*.oclAsType(String)");
		ocl.assertQueryUnlimited(null, "*.oclAsType(OclAny)");
		ocl.assertQueryInvalid(null, "*.oclAsType(OclVoid)");
		ocl.assertQueryInvalid(null, "*.oclAsType(OclInvalid)");
		//
		ocl.assertQueryInvalid(null, "Set{1,2}->oclAsType(Set(UnlimitedNatural))");
		ocl.assertQueryResults(null, "Set{1,2}", "Set{1,2}->oclAsType(Set(Integer))");
		ocl.assertQueryResults(null, "Set{1,2}", "Set{1,2}->oclAsType(Collection(Real))");
		ocl.assertQueryInvalid(null, "Set{1,2}->oclAsType(Collection(UnlimitedNatural))");
		ocl.assertQueryInvalid(null, "Set{1.0,2}->oclAsType(Collection(UnlimitedNatural))");
		ocl.assertQueryInvalid(null, "Set{1,2}->oclAsType(Sequence(UnlimitedNatural))");
		if (!useCodeGen) {				// FIXME CG UOE on getDepth()
			ocl.assertQueryInvalid(null, "Set{1,2}.oclAsType(Set(UnlimitedNatural))");		// Cannot cast non-collection (elements) to collection
		}
		ocl.assertQueryResults(null, "Bag{1,2}", "Set{1,2}.oclAsType(Integer)");
		if (!useCodeGen) {				// FIXME CG UOE on getDepth()
			ocl.assertQueryInvalid(null, "Set{1,2}.oclAsType(Set(Integer))");				// Cannot cast non-collection (elements) to collection
		}
		ocl.assertQueryResults(null, "Bag{1,2}", "Set{1,2}.oclAsType(Integer)");
		ocl.assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Set(Set(Integer)))");
		ocl.assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Set(Collection(Integer)))");
		ocl.assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Collection(Set(Integer)))");
		ocl.assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Set(Set(Real)))");
		ocl.assertQueryInvalid(null, "Set{Set{1,2},Set{3,4}}->oclAsType(Set(Sequence(Integer)))");
		ocl.assertQueryInvalid(null, "Set{Set{1,2},Set{3,4}}->oclAsType(Sequence(Set(Integer)))");
		//
		ocl.assertSemanticErrorQuery(null, "3.oclAsType(OclAny).abs()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "OclAny", "abs");
		ocl.assertSemanticErrorQuery(null, "let v : OclAny = 3 in v.abs()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "OclAny", "abs");
		ocl.assertQueryEquals(null, 3, "let v : OclAny = 3 in v.oclAsType(Integer).abs()");
		ocl.assertQueryInvalid(null, "Integer.oclAsType(Real)");
		ocl.dispose();
	}

	/**
	 * Tests the oclIsInvalid() operator.
	 */
	@Test public void test_oclIsInvalid() {
		MyOCL ocl = createOCL();
		ocl.assertQueryTrue(null, "invalid.oclIsInvalid()");
		ocl.assertQueryFalse(null, "null.oclIsInvalid()");
		ocl.assertQueryFalse(null, "true.oclIsInvalid()");
		ocl.assertQueryFalse(null, "false.oclIsInvalid()");
		ocl.assertQueryFalse(null, "3.14.oclIsInvalid()");
		ocl.assertQueryFalse(null, "1.oclIsInvalid()");
		ocl.assertQueryFalse(null, "*.oclIsInvalid()");
		ocl.assertQueryFalse(null, "'invalid'.oclIsInvalid()");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsInvalid()");
		ocl.assertQueryTrue(null, "('123a'.toInteger()).oclIsUndefined()");	// Bug 342561 for old evaluator
		ocl.assertQueryTrue(null, "let a:Integer='123a'.toInteger() in a.oclIsUndefined()");	// Bug 342561 for old evaluator
		ocl.dispose();
	}

	/**
	 * Tests the oclIsKindOf() operator.
	 */
	@Test public void test_oclIsKindOf() {
		MyOCL ocl = createOCL();
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(OclInvalid)");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(OclVoid)");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(OclAny)");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(String)");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(Integer)");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(Class)");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(Bag(Boolean))");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(Tuple(a:Integer))");
		ocl.assertQueryInvalid(null, "invalid.oclIsKindOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "null.oclIsKindOf(OclInvalid)");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(OclVoid)");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(OclAny)");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(String)");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(Integer)");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(Class)");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(Bag(Boolean))");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(Tuple(a:Integer))");
		ocl.assertQueryTrue(null, "null.oclIsKindOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "true.oclIsKindOf(OclInvalid)");
		ocl.assertQueryFalse(null, "true.oclIsKindOf(OclVoid)");
		ocl.assertQueryTrue(null, "true.oclIsKindOf(Boolean)");
		ocl.assertQueryFalse(null, "true.oclIsKindOf(Integer)");
		ocl.assertQueryFalse(null, "true.oclIsKindOf(String)");
		ocl.assertQueryTrue(null, "true.oclIsKindOf(OclAny)");
		ocl.assertQueryFalse(null, "true.oclIsKindOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "3.14.oclIsKindOf(OclInvalid)");
		ocl.assertQueryFalse(null, "3.14.oclIsKindOf(OclVoid)");
		ocl.assertQueryFalse(null, "3.14.oclIsKindOf(Boolean)");
		ocl.assertQueryTrue(null, "3.14.oclIsKindOf(Real)");
		ocl.assertQueryFalse(null, "3.14.oclIsKindOf(Integer)");
		ocl.assertQueryFalse(null, "3.14.oclIsKindOf(String)");
		ocl.assertQueryTrue(null, "3.14.oclIsKindOf(OclAny)");
		ocl.assertQueryFalse(null, "3.14.oclIsKindOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "1.oclIsKindOf(OclInvalid)");
		ocl.assertQueryFalse(null, "1.oclIsKindOf(OclVoid)");
		ocl.assertQueryFalse(null, "1.oclIsKindOf(Boolean)");
		ocl.assertQueryTrue(null, "1.oclIsKindOf(Real)");
		ocl.assertQueryTrue(null, "1.oclIsKindOf(Integer)");
		ocl.assertQueryTrue(null, "(-1).oclIsKindOf(Integer)");
		ocl.assertQueryTrue(null, "1.oclIsKindOf(Integer)");
		ocl.assertQueryFalse(null, "1.oclIsKindOf(String)");
		ocl.assertQueryTrue(null, "1.oclIsKindOf(OclAny)");
		ocl.assertQueryFalse(null, "1.oclIsKindOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "*.oclIsKindOf(OclInvalid)");
		ocl.assertQueryFalse(null, "*.oclIsKindOf(OclVoid)");
		ocl.assertQueryFalse(null, "*.oclIsKindOf(Boolean)");
		ocl.assertQueryFalse(null, "*.oclIsKindOf(Real)");
		ocl.assertQueryFalse(null, "*.oclIsKindOf(Integer)");
		ocl.assertQueryTrue(null, "*.oclIsKindOf(UnlimitedNatural)");
		ocl.assertQueryFalse(null, "*.oclIsKindOf(String)");
		ocl.assertQueryTrue(null, "*.oclIsKindOf(OclAny)");
		ocl.assertQueryFalse(null, "*.oclIsKindOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "'invalid'.oclIsKindOf(OclInvalid)");
		ocl.assertQueryFalse(null, "'null'.oclIsKindOf(OclVoid)");
		ocl.assertQueryFalse(null, "'true'.oclIsKindOf(Boolean)");
		ocl.assertQueryFalse(null, "'3.14'.oclIsKindOf(Real)");
		ocl.assertQueryFalse(null, "'1'.oclIsKindOf(Integer)");
		ocl.assertQueryFalse(null, "'*'.oclIsKindOf(UnlimitedNatural)");
		ocl.assertQueryTrue(null, "'string'.oclIsKindOf(String)");
		ocl.assertQueryTrue(null, "'any'.oclIsKindOf(OclAny)");
		ocl.assertQueryFalse(ocl.pkg1, "'self'.oclIsKindOf(ocl::Package)");
		//
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsKindOf(OclInvalid)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsKindOf(OclVoid)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsKindOf(Boolean)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsKindOf(Real)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsKindOf(Integer)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsKindOf(UnlimitedNatural)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsKindOf(String)");
		ocl.assertQueryTrue(ocl.pkg1, "self.oclIsKindOf(OclAny)");
		ocl.assertQueryTrue(ocl.pkg1, "self.oclIsKindOf(ocl::Package)");
		ocl.dispose();
	}

	/**
	 * Tests the oclIsModelKindOf() operator.
	 */
	@Test public void test_oclIsModelKindOf() {
		MyOCL ocl = createOCL();
		ocl.assertSemanticErrorQuery(null, "invalid.oclIsModelKindOf(OclAny)", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, "OclInvalid", "oclIsModelKindOf", "OclAny");
		ocl.assertQueryInvalid(ocl.pkg1, "self.oclIsModelKindOf(OclAny)");
		// See test_umlValidation_Bug458394 for some real usage
		ocl.dispose();
	}

	/**
	 * Tests the oclIsTypeOf() operator.
	 */
	@Test public void test_oclIsTypeOf() {
		MyOCL ocl = createOCL();
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(OclVoid)");
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(OclAny)");
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(Integer)");
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(String)");
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(Class)");
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(Set(String))");
		ocl.assertQueryInvalid(null, "invalid.oclIsTypeOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "null.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryTrue(null, "null.oclIsTypeOf(OclVoid)");
		ocl.assertQueryFalse(null, "null.oclIsTypeOf(OclAny)");
		ocl.assertQueryFalse(null, "null.oclIsTypeOf(Integer)");
		ocl.assertQueryFalse(null, "null.oclIsTypeOf(String)");
		ocl.assertQueryFalse(null, "null.oclIsTypeOf(Class)");
		ocl.assertQueryFalse(null, "null.oclIsTypeOf(Set(String))");
		ocl.assertQueryFalse(null, "null.oclIsTypeOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "true.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryFalse(null, "true.oclIsTypeOf(OclVoid)");
		ocl.assertQueryTrue(null, "true.oclIsTypeOf(Boolean)");
		ocl.assertQueryFalse(null, "true.oclIsTypeOf(String)");
		ocl.assertQueryFalse(null, "true.oclIsTypeOf(OclAny)");
		ocl.assertQueryFalse(null, "true.oclIsTypeOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "3.14.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryFalse(null, "3.14.oclIsTypeOf(OclVoid)");
		ocl.assertQueryFalse(null, "3.14.oclIsTypeOf(Boolean)");
		ocl.assertQueryTrue(null, "3.14.oclIsTypeOf(Real)");
		ocl.assertQueryFalse(null, "3.14.oclIsTypeOf(Integer)");
		ocl.assertQueryFalse(null, "3.14.oclIsTypeOf(String)");
		ocl.assertQueryFalse(null, "3.14.oclIsTypeOf(OclAny)");
		ocl.assertQueryFalse(null, "3.14.oclIsTypeOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(OclVoid)");
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(Boolean)");
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(Real)");
		ocl.assertQueryTrue(null, "1.oclIsTypeOf(Integer)");
		ocl.assertQueryTrue(null, "(-1).oclIsTypeOf(Integer)");
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(UnlimitedNatural)");
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(String)");
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(OclAny)");
		ocl.assertQueryFalse(null, "1.oclIsTypeOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(OclVoid)");
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(Boolean)");
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(Real)");
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(Integer)");
		ocl.assertQueryTrue(null, "*.oclIsTypeOf(UnlimitedNatural)");
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(String)");
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(OclAny)");
		ocl.assertQueryFalse(null, "*.oclIsTypeOf(ocl::Package)");
		//
		ocl.assertQueryFalse(null, "'invalid'.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryFalse(null, "'null'.oclIsTypeOf(OclVoid)");
		ocl.assertQueryFalse(null, "'true'.oclIsTypeOf(Boolean)");
		ocl.assertQueryFalse(null, "'3.14'.oclIsTypeOf(Real)");
		ocl.assertQueryFalse(null, "'1'.oclIsTypeOf(Integer)");
		ocl.assertQueryFalse(null, "'*'.oclIsTypeOf(UnlimitedNatural)");
		ocl.assertQueryTrue(null, "'string'.oclIsTypeOf(String)");
		ocl.assertQueryFalse(null, "'any'.oclIsTypeOf(OclAny)");
		ocl.assertQueryFalse(ocl.pkg1, "'self'.oclIsTypeOf(ocl::Package)");
		//
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(OclInvalid)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(OclVoid)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(Boolean)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(Real)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(Integer)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(UnlimitedNatural)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(String)");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsTypeOf(OclAny)");
		ocl.assertQueryTrue(ocl.pkg1, "self.oclIsTypeOf(ocl::Package)");
		ocl.dispose();
	}

	/**
	 * Tests the oclIsUndefined() operator.
	 */
	@Test public void test_oclIsUndefined() {
		MyOCL ocl = createOCL();
		ocl.assertQueryTrue(null, "invalid.oclIsUndefined()");
		ocl.assertQueryTrue(null, "null.oclIsUndefined()");
		ocl.assertQueryFalse(null, "true.oclIsUndefined()");
		ocl.assertQueryFalse(null, "false.oclIsUndefined()");
		ocl.assertQueryFalse(null, "3.14.oclIsUndefined()");
		ocl.assertQueryFalse(null, "1.oclIsUndefined()");
		ocl.assertQueryFalse(null, "*.oclIsUndefined()");
		ocl.assertQueryFalse(null, "'null'.oclIsUndefined()");
		ocl.assertQueryFalse(ocl.pkg1, "self.oclIsUndefined()");
		ocl.dispose();
	}

	/**
	 * Tests the oclModelType() operator.
	 */
	@Test public void test_oclModelType() {
		MyOCL ocl = createOCL();
		ocl.assertSemanticErrorQuery(null, "invalid.oclModelType()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "OclInvalid", "oclModelType");
		ocl.assertQueryInvalid(ocl.pkg1, "self.oclModelType()");
		// See test_umlValidation_Bug458394 for some real usage
		ocl.dispose();
	}

	/**
	 * Tests the oclModelTypes() operator.
	 */
	@Test public void test_oclModelTypes() {
		MyOCL ocl = createOCL();
		ocl.assertSemanticErrorQuery(null, "invalid.oclModelTypes()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "OclInvalid", "oclModelTypes");
		ocl.assertQueryInvalid(ocl.pkg1, "self.oclModelTypes()");
		// See test_umlValidation_Bug458394 for some real usage
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for Booleans.
	 */
	@Test public void test_oclType_Boolean() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class booleanType = standardLibrary.getBooleanType();
		org.eclipse.ocl.pivot.Class classType = standardLibrary.getClassType();
		org.eclipse.ocl.pivot.Class primitiveType = useCodeGen ? classType : environmentFactory.getASClass("PrimitiveType");
		org.eclipse.ocl.pivot.Class booleanMetaType = useCodeGen ? classType : environmentFactory.getASClass("BooleanType");
		assert primitiveType != null;
		ocl.assertQueryEquals(null, booleanType, "true.oclType()");
		ocl.assertQueryEquals(null, "Boolean", "true.oclType().name");
		ocl.assertQueryEquals(null, booleanType, "Boolean");
		ocl.assertQueryEquals(null, "Boolean", "Boolean.name");
		ocl.assertQueryEquals(null, booleanMetaType, "true.oclType().oclType()");
		ocl.assertQueryEquals(null, booleanMetaType.getName(), "true.oclType().oclType().name");
		ocl.assertQueryEquals(null, booleanMetaType, "Boolean.oclType()");
		ocl.assertQueryEquals(null, booleanMetaType.getName(), "Boolean.oclType().name");
		ocl.assertQueryEquals(null, classType, "true.oclType().oclType().oclType()");
		ocl.assertQueryEquals(null, "Class", "true.oclType().oclType().oclType().name");
		ocl.assertQueryResults(null, "Set{false,true}", "Boolean.allInstances()");
		ocl.assertQueryResults(null, "Set{false,true}", "true.oclType().allInstances()");
		ocl.assertQueryResults(null, "Set{}", "Boolean.oclType().allInstances()");
		ocl.assertQueryEquals(null, 1, "true.oclType().ownedOperations?->select(name = 'xor')->any(true)?.ownedParameters->size()");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for Classifiers.
	 */
	@Test public void test_oclType_Classifier() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		@NonNull Type packageType = ClassUtil.nonNullState(environmentFactory.getASClass("Package"));
		ocl.assertQueryEquals(ocl.pkg1, packageType, "self.oclType()");
		ocl.assertQueryEquals(ocl.pkg1, "Package", "self.oclType().name");
		ocl.assertQueryEquals(null, packageType, "Package");
		ocl.assertQueryEquals(null, "Package", "Package.name");
		ocl.assertQueryEquals(null, standardLibrary.getClassType(), "Package.oclType()");
	//	ocl.assertQueryTrue(null, "Package.allInstances()->size() > 1"); //.name->includes('pivot')");
		ocl.assertQueryResults(null, "Set{}", "Package.allInstances()"); // new empty ModelManager
		ocl.assertQueryEquals(ocl.pkg1, 8, "Package.allInstances()->size()");
		ocl.assertQueryResults(ocl.pkg1, "self.oclAsType(Package)->closure(ownedPackages)->including(self)", "Package.allInstances()");
		ocl.assertQueryEquals(ocl.pkg1, 8, "self.oclType().allInstances()->size()");
		ocl.assertQueryEquals(ocl.pkg1, 0, "Package.oclType().allInstances()->size()");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for Collections.
	 */
	@Test public void test_oclType_Collection() {
		MyOCL ocl = createOCL();
		CompleteEnvironment completeEnvironment = ocl.getCompleteEnvironment();
		StandardLibrary standardLibrary = ocl.getStandardLibrary();
		ocl.assertQueryEquals(null, 1, "Set{1}->oclType().ownedOperations?->select(name = 'flatten')->size()");
		ocl.assertQueryEquals(null, completeEnvironment.getSetType(standardLibrary.getOclVoidType(), false, null, null), "Set{}->oclType()");
		ocl.assertQueryEquals(null, completeEnvironment.getSetType(standardLibrary.getIntegerType(), false, null, null), "Set{1}->oclType()");
		ocl.assertQueryResults(null, "Bag{'Integer'}", "Set{1}.oclType().name");
		ocl.assertQueryEquals(null, "Set", "Set{1}->oclType().name");
		ocl.assertSemanticErrorQuery(null, "Set{1}.allInstances()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "Integer", "allInstances");
		ocl.assertSemanticErrorQuery(null, "Set{1}->allInstances()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "Set(Integer)", "allInstances");
	//	ocl.assertSemanticErrorQuery(null, "Set{1}.oclType().allInstances()", PivotMessagesInternal.UnresolvedOperation_ERROR_, "Bag(Class)", "allInstances");
		ocl.assertQueryResults(null, "Bag{}", "Set{1}.oclType().allInstances()");
	//	ocl.assertSemanticErrorQuery(null, "Set{1}->oclType().allInstances()", PivotMessagesInternal.UnresolvedStaticOperationCall_ERROR_, "Set(Integer)", "allInstances", "");
		ocl.assertQueryResults(null, "Set{}", "Set{1}->oclType().allInstances()");
	//	ocl.assertQueryResults(null, "Set{}", "Set.oclType().allInstances()");
	//	ocl.assertQueryTrue(null, "Set.oclType().allInstances()->size() > 30");		// currently 33 distinct Set specializatons.
		ocl.assertQueryResults(null, "Set{}", "Set.oclType().allInstances()");
		ocl.assertQueryEquals(null, standardLibrary.getIntegerType(), "Set{1}->oclType().elementType");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for Enumerations.
	 */
	@Test public void test_oclType_Enumeration() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		@NonNull Type collectionKindType = ClassUtil.nonNullState(environmentFactory.getASClass("CollectionKind"));
		org.eclipse.ocl.pivot.Class enumerationType = useCodeGen ? standardLibrary.getClassType() : standardLibrary.getEnumerationType();
		ocl.assertQueryEquals(null, environmentFactory.getASClass("CollectionKind"), "CollectionKind::Set.oclType()");
		ocl.assertQueryEquals(null, "CollectionKind", "CollectionKind::Set.oclType().name");
		ocl.assertQueryEquals(null, collectionKindType, "CollectionKind");
		ocl.assertQueryEquals(null, "CollectionKind", "CollectionKind.name");
		ocl.assertQueryEquals(null, enumerationType, "CollectionKind.oclType()");
		ocl.assertQueryEquals(null, 5, "CollectionKind.allInstances()->size()");
		ocl.assertSemanticErrorQuery(null, "CollectionKind.oclType().ownedLiteral", PivotMessagesInternal.UnresolvedProperty_ERROR_, "Enumeration", "ownedLiteral");
		ocl.assertQueryResults(null, "Set{CollectionKind::Bag,CollectionKind::Collection,CollectionKind::_'OrderedSet',CollectionKind::_'Sequence',CollectionKind::_'Set'}", "CollectionKind.allInstances()");
		ocl.assertQueryResults(null, "Set{CollectionKind::Bag,CollectionKind::Collection,CollectionKind::OrderedSet,CollectionKind::Sequence,CollectionKind::Set}", "CollectionKind::Set.oclType().allInstances()");
	//	ocl.assertQueryResults(null, "Set{AssociativityKind,CollectionKind,PseudostateKind,TransitionKind}", "CollectionKind.oclType().allInstances()");
		ocl.assertQueryResults(null, "Set{}", "CollectionKind.oclType().allInstances()");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for Numerics.
	 */
	@Test public void test_oclType_Numeric() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class primitiveType = useCodeGen ? standardLibrary.getClassType() : environmentFactory.getASClass("PrimitiveType");
		org.eclipse.ocl.pivot.Class integerType = standardLibrary.getIntegerType();
		ocl.assertQueryEquals(null, standardLibrary.getIntegerType(), "3.oclType()");
		ocl.assertQueryEquals(null, standardLibrary.getRealType(), "3.0.oclType()");
		ocl.assertQueryEquals(null, standardLibrary.getUnlimitedNaturalType(), "*.oclType()");
		ocl.assertQueryEquals(null, primitiveType, "Integer.oclType()");
		ocl.assertQueryEquals(null, integerType, "Integer");
	//	ocl.assertSemanticErrorQuery(null, "Integer.allInstances()", PivotMessagesInternal.UnresolvedStaticOperationCall_ERROR_, "Integer", "allInstances", "");
		ocl.assertQueryResults(null, "Set{}", "Integer.allInstances()");
	//	ocl.assertSemanticErrorQuery(null, "3.oclType().allInstances()", PivotMessagesInternal.UnresolvedStaticOperationCall_ERROR_, "Integer", "allInstances", "");
		ocl.assertQueryResults(null, "Set{}", "3.oclType().allInstances()");
		ocl.assertQueryResults(null, "Set{}", "Integer.oclType().allInstances()");
		ocl.assertQueryEquals(null, "Integer", "4.oclType().name");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for OclAny.
	 */
	@Test public void test_oclType_OclAny() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class anyType = standardLibrary.getOclAnyType();
		org.eclipse.ocl.pivot.Class anyTypeClass = useCodeGen ? standardLibrary.getClassType() : environmentFactory.getASClass("AnyType");
		ocl.assertQueryResults(null, "Set{null}", "null.oclAsType(OclAny).oclType().allInstances()");
// XXX
		ocl.assertQueryEquals(null, standardLibrary.getOclVoidType(), "null.oclType()");
		//    	ocl.assertQueryEquals(null, standardLibrary.getOclVoidType(), "null.oclAsType(OclAny).oclType()");		// Cast does not change the dynamic type
		//    	ocl.assertQueryEquals(null, "OclAny", "null.oclAsType(OclAny).name");
		ocl.assertQueryEquals(null, anyType, "OclAny");
		ocl.assertQueryEquals(null, "OclAny", "OclAny.name");
		ocl.assertQueryEquals(null, anyTypeClass, "OclAny.oclType()");
	//	ocl.assertSemanticErrorQuery(null, "OclAny.allInstances()", PivotMessagesInternal.UnresolvedStaticOperationCall_ERROR_, "OclAny", "allInstances", "");
		ocl.assertQueryResults(null, "Set{}", "OclAny.allInstances()");
	//	ocl.assertSemanticErrorQuery(null, "null.oclAsType(OclAny).oclType().allInstances()", PivotMessagesInternal.UnresolvedStaticOperationCall_ERROR_, "OclAny", "allInstances", "");
		ocl.assertQueryResults(null, "Set{null}", "null.oclAsType(OclAny).oclType().allInstances()");
		ocl.assertQueryResults(null, "Set{}", "OclAny.oclType().allInstances()");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for OclInvalid.
	 */
	@Test public void test_oclType_OclInvalid() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class invalidType = standardLibrary.getOclInvalidType();
		org.eclipse.ocl.pivot.Class invalidTypeClass = useCodeGen ? standardLibrary.getClassType() : environmentFactory.getASClass("InvalidType");
		ocl.assertQueryInvalid(null, "invalid.oclType()");
		ocl.assertQueryInvalid(null, "invalid.oclType().name");
		ocl.assertQueryEquals(null, invalidType, "OclInvalid");
		ocl.assertQueryEquals(null, "OclInvalid", "OclInvalid.name");
		ocl.assertQueryEquals(null, invalidTypeClass, "OclInvalid.oclType()");
		ocl.assertQueryInvalid(null, "OclInvalid.allInstances()");
		ocl.assertQueryInvalid(null, "invalid.oclType().allInstances()");
		ocl.assertQueryResults(null, "Set{}", "OclInvalid.oclType().allInstances()");
		ocl.assertQueryInvalid(null, "invalid.oclType().ownedOperations->select(name = '=')->any(true).ownedParameters->size()");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for OclVoid.
	 */
	@Test public void test_oclType_OclVoid() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class voidTypeClass = useCodeGen ? standardLibrary.getClassType() : environmentFactory.getASClass("VoidType");
		org.eclipse.ocl.pivot.Class nullType = standardLibrary.getOclVoidType();
		ocl.assertQueryEquals(null, nullType, "null.oclType()");
		ocl.assertQueryEquals(null, "OclVoid", "null.oclType().name");
		ocl.assertQueryEquals(null, nullType, "OclVoid");
		ocl.assertQueryEquals(null, "OclVoid", "OclVoid.name");
		ocl.assertQueryEquals(null, voidTypeClass, "OclVoid.oclType()");
		ocl.assertQueryResults(null, "Set{null}", "OclVoid.allInstances()");
		ocl.assertQueryResults(null, "Set{null}", "null.oclType().allInstances()");
		ocl.assertQueryResults(null, "Set{}", "OclVoid.oclType().allInstances()");
		ocl.assertQueryEquals(null, 1, "null.oclType().ownedOperations?->select(name = '=')->any(true)?.ownedParameters->size()");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator for Tuples.
	 */
	@Test public void test_oclType_Tuple() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class tupleTypeClass = useCodeGen ? standardLibrary.getClassType() : environmentFactory.getASClass("TupleType");
		TuplePartId partId = IdManager.getTuplePartId(0, "a", TypeId.INTEGER);
		TupleTypeId tupleId = IdManager.getTupleTypeId("Tuple", partId);
		TupleType tupleType = ocl.getIdResolver().getTupleType(tupleId);
		ocl.assertQueryEquals(null, tupleType, "Tuple{a:Integer=3}.oclType()");
		ocl.assertQueryEquals(null, tupleType, "Tuple(a:Integer)");
		ocl.assertQueryEquals(null, tupleTypeClass, "Tuple(a:Integer).oclType()");
	//	ocl.assertSemanticErrorQuery(null, "Tuple(a:Integer).allInstances()", PivotMessagesInternal.UnresolvedStaticOperationCall_ERROR_, "Tuple(a:Integer[1])", "allInstances", "");
		ocl.assertQueryResults(null, "Set{}", "Tuple(a:Integer).allInstances()");
	//	ocl.assertSemanticErrorQuery(null, "Tuple{a:Integer=3}.oclType().allInstances()", PivotMessagesInternal.UnresolvedStaticOperationCall_ERROR_, "Tuple(a:Integer[1])", "allInstances", "");	// FIXME
		ocl.assertQueryResults(null, "Set{}", "Tuple{a:Integer=3}.oclType().allInstances()");	// FIXME
		ocl.assertQueryResults(null, "Set{}", "Tuple(a:Integer).oclType().allInstances()");
		ocl.assertQueryEquals(null, "Tuple", "Tuple{a:Integer=3}.oclType().name");
		ocl.dispose();
	}

	/**
	 * Tests the oclType() operator.
	 */
	@Test public void test_oclType() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class classType = standardLibrary.getClassType();
		org.eclipse.ocl.pivot.Class primitiveType = useCodeGen ? classType : environmentFactory.getASClass("PrimitiveType");
		org.eclipse.ocl.pivot.Class booleanMetaType = useCodeGen ? classType : environmentFactory.getASClass("BooleanType");
		assert primitiveType != null;
		ocl.assertQueryEquals(null, standardLibrary.getStringType(), "'string'.oclType()");
		ocl.assertQueryEquals(null, standardLibrary.getOclVoidType(), "self.oclType()");
		ocl.assertQueryEquals(null, primitiveType, "3.oclType().oclType()");
		ocl.assertQueryEquals(null, classType, "3.oclType().oclType().oclType()");
		ocl.assertQueryEquals(null, booleanMetaType, "Boolean.oclType()");
		ocl.assertQueryEquals(null, booleanMetaType.getName(), "Boolean.oclType().name");
		ocl.assertSemanticErrorQuery(null, "3.oclType(OclAny)", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, "Integer", "oclType", "OclAny");
		ocl.dispose();
	}

	/**
	 * Tests the oclTypes() operator.
	 */
	@Test public void test_oclTypes() {
		MyOCL ocl = createOCL();
		EnvironmentFactoryInternalExtension environmentFactory = (EnvironmentFactoryInternalExtension) ocl.getEnvironmentFactory();
		StandardLibrary standardLibrary = environmentFactory.getStandardLibrary();
		org.eclipse.ocl.pivot.Class primitiveType = useCodeGen ? standardLibrary.getClassType() : environmentFactory.getASClass("PrimitiveType");
		org.eclipse.ocl.pivot.Class classType = useCodeGen ? standardLibrary.getClassType() : environmentFactory.getASClass("Class");
		org.eclipse.ocl.pivot.Class booleanMetaType = useCodeGen ? classType : environmentFactory.getASClass("BooleanType");
		assert primitiveType != null;
		CollectionTypeId bagTypeId = TypeId.BAG.getSpecializedId(TypeId.OCL_ANY);
		CollectionTypeId setTypeId = TypeId.SET.getSpecializedId(TypeId.OCL_ANY);
		if (!useCodeGen) {				// FIXME Bad CG Set equals
			ocl.assertQueryEquals(null, ValueUtil.createSetOfEach(setTypeId, standardLibrary.getStringType()), "'string'.oclTypes()");
			ocl.assertQueryEquals(null, ValueUtil.createSetOfEach(setTypeId, standardLibrary.getOclVoidType()), "self.oclTypes()");
			ocl.assertQueryEquals(null, ValueUtil.createBagOfEach(bagTypeId, primitiveType), "3.oclTypes().oclType()");
			ocl.assertQueryEquals(null, ValueUtil.createBagOfEach(bagTypeId, classType), "3.oclTypes().oclType().oclType()");
			ocl.assertQueryEquals(null, ValueUtil.createSetOfEach(setTypeId, booleanMetaType), "Boolean.oclTypes()");
			//    	ocl.assertQueryEquals(null, ValueUtil.createSetOfEach(setTypeId, primitiveType.getName()), "Boolean.oclTypes().name");
		}
		ocl.assertSemanticErrorQuery(null, "3.oclTypes(OclAny)", PivotMessagesInternal.UnresolvedOperationCall_ERROR_, "Integer", "oclTypes", "OclAny");
		ocl.dispose();
	}

	//	@Test public void testMetaclassInstanceType() {
	//		ocl.assertQueryEquals(null, metamodelManager.getSequenceType(metamodelManager.getIntegerType()), "Sequence(Integer).oclType().instanceType");
	//	}

	@Test public void testToString() {
		MyOCL ocl = createOCL();
		ocl.loadEPackage("ecore", EcorePackage.eINSTANCE);
		@SuppressWarnings("null") @NonNull String emfString = EcoreFactory.eINSTANCE.createFromString(EcorePackage.Literals.EDATE, "2000-01-24").toString();
		ocl.assertQueryEquals(null, emfString, "ecore::EDate{value='2000-01-24'}.toString()");
		ocl.dispose();
	}
}