/**
 * <copyright>
 * 
 * Copyright (c) 2009,2011 E.D.Willink and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   L.Goubet, E.D.Willink - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: EvaluateOclAnyOperationsTest.java,v 1.13 2011/05/20 15:27:16 ewillink Exp $
 */

package org.eclipse.ocl.examples.pivot.tests;

import java.util.Collections;

import org.eclipse.ocl.examples.pivot.ClassifierType;
import org.eclipse.ocl.examples.pivot.PrimitiveType;
import org.eclipse.ocl.examples.pivot.TupleType;
import org.eclipse.ocl.examples.pivot.Type;
import org.eclipse.ocl.examples.pivot.messages.OCLMessages;
import org.eclipse.ocl.examples.pivot.utilities.PivotConstants;
import org.eclipse.ocl.examples.pivot.utilities.TypeManager;

/**
 * Tests for OclAny operations.
 */
@SuppressWarnings("nls")
public class EvaluateOclAnyOperationsTest extends PivotSimpleTestSuite
{
    @Override
    protected void setUp() {
        super.setUp();
        helper.setContext(getMetaclass("OclAny"));
    }

    public void testEqualInvalid() {
		assertQueryInvalid(null, "invalid = 3");
		assertQueryInvalid(null, "3 = invalid");
		assertQueryInvalid(null, "invalid = 3.0");
		assertQueryInvalid(null, "3.0 = invalid");

		assertQueryInvalid(null, "invalid = 'test'");
		assertQueryInvalid(null, "'test' = invalid");
		assertQueryInvalid(null, "invalid = true");
		assertQueryInvalid(null, "false = invalid");
		assertQueryInvalid(null, "invalid = Sequence{}");
		assertQueryInvalid(null, "Sequence{} = invalid");

		assertQueryInvalid(null, "invalid = invalid");
	}

	public void testEqualNull() {
		assertQueryFalse(null, "null = 3");
		assertQueryFalse(null, "3 = null");
		assertQueryFalse(null, "null = 3.0");
		assertQueryFalse(null, "3.0 = null");

		assertQueryFalse(null, "null = 'test'");
		assertQueryFalse(null, "'test' = null");
		assertQueryFalse(null, "null = true");
		assertQueryFalse(null, "false = null");
		assertQueryFalse(null, "null = Sequence{}");
		assertQueryFalse(null, "Sequence{} = null");

		assertQueryTrue(null, "null = null");
	}

	public void testEqualType() {
		assertQueryTrue(null, "Boolean = Boolean");
		assertQueryFalse(null, "Boolean = Integer");
		assertQueryTrue(null, "OclVoid = OclVoid");
		assertQueryTrue(null, "OclInvalid = OclInvalid");
		assertQueryFalse(null, "OclInvalid = OclVoid");
		assertQueryTrue(null, "Set(String) = Set(String)");
		assertQueryFalse(null, "Set(String) = Set(Integer)");
		assertQueryFalse(null, "Set(String) = Sequence(String)");
	}

	public void testEqualEnumeration() {
		assertQueryTrue(null, "ocl::CollectionKind::_'Collection' = ocl::CollectionKind::_'Collection'");
		assertQueryFalse(null, "ocl::CollectionKind::_'Collection' = ocl::CollectionKind::_'Set'");
	}
	
	public void testGreaterThanInvalid() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "invalid > 0");
//		assertSemanticErrorQuery("0 > invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OPERATOR);
		assertQueryInvalid(null, "0 > invalid");
		assertSemanticErrorQuery("invalid > invalid", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.GREATER_THAN_OPERATOR, typeManager.getOclInvalidType(), typeManager.getOclInvalidType());
	}
//    protected void assertBadQuery(Class<?> exception, int severity,
//   		 String expression, String messageTemplate, String... bindings) {

	public void testGreaterThanNull() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "null > 0");
//		assertSemanticErrorQuery("0 > null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OPERATOR);
		assertQueryInvalid(null, "0 > null");
		assertSemanticErrorQuery("null > null", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.GREATER_THAN_OPERATOR, typeManager.getOclVoidType(), typeManager.getOclVoidType());
	}

	public void testGreaterThanOrEqualInvalid() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "invalid >= 0");
//		assertSemanticErrorQuery("0 >= invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR);
		assertQueryInvalid(null, "0 >= invalid");
		assertSemanticErrorQuery("invalid >= invalid", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR, typeManager.getOclInvalidType(), typeManager.getOclInvalidType());
	}

	public void testGreaterThanOrEqualNull() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "null >= 0");
//		assertSemanticErrorQuery("0 >= null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR);
		assertQueryInvalid(null, "0 >= null");
		assertSemanticErrorQuery("null >= null", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.GREATER_THAN_OR_EQUAL_OPERATOR, typeManager.getOclVoidType(), typeManager.getOclVoidType());
	}

	public void testLessThanInvalid() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "invalid < 0");
//		assertSemanticErrorQuery("0 < invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OPERATOR);
		assertQueryInvalid(null, "0 < invalid");
		assertSemanticErrorQuery("invalid < invalid", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.LESS_THAN_OPERATOR, typeManager.getOclInvalidType(), typeManager.getOclInvalidType());
	}

	public void testLessThanNull() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "null < 0");
//		assertSemanticErrorQuery("0 < null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OPERATOR);
		assertQueryInvalid(null, "0 < null");
		assertSemanticErrorQuery("null < null", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.LESS_THAN_OPERATOR, typeManager.getOclVoidType(), typeManager.getOclVoidType());
	}

	public void testLessThanOrEqualInvalid() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "invalid <= 0");
//		assertSemanticErrorQuery("0 <= invalid", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR);
		assertQueryInvalid(null, "0 <= invalid");
		assertSemanticErrorQuery("invalid <= invalid", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR, typeManager.getOclInvalidType(), typeManager.getOclInvalidType());
	}

	public void testLessThanOrEqualNull() {
		// FIXME Analyzer-extraOperation OclAny::< should not be defined
		assertQueryInvalid(null, "null <= 0");
//		assertSemanticErrorQuery("0 <= null", OCLMessages.OperationCallNotFound_ERROR_, PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR);
		assertQueryInvalid(null, "0 <= null");
		assertSemanticErrorQuery("null <= null", OCLMessages.UnresolvedOperationCall_ERROR_, PivotConstants.LESS_THAN_OR_EQUAL_OPERATOR, typeManager.getOclVoidType(), typeManager.getOclVoidType());
	}

	public void testNotEqualInvalid() {
		assertQueryInvalid(null, "invalid <> 3");
		assertQueryInvalid(null, "3 <> invalid");
		assertQueryInvalid(null, "invalid <> 3.0");
		assertQueryInvalid(null, "3.0 <> invalid");

		assertQueryInvalid(null, "invalid <> 'test'");
		assertQueryInvalid(null, "'test' <> invalid");
		assertQueryInvalid(null, "invalid <> true");
		assertQueryInvalid(null, "false <> invalid");
		assertQueryInvalid(null, "invalid <> Sequence{}");
		assertQueryInvalid(null, "Sequence{} <> invalid");

		assertQueryInvalid(null, "invalid <> invalid");
	}

	public void testNotEqualNull() {
		assertQueryTrue(null, "null <> 3");
		assertQueryTrue(null, "3 <> null");
		assertQueryTrue(null, "null <> 3.0");
		assertQueryTrue(null, "3.0 <> null");

		assertQueryTrue(null, "null <> 'test'");
		assertQueryTrue(null, "'test' <> null");
		assertQueryTrue(null, "null <> true");
		assertQueryTrue(null, "false <> null");
		assertQueryTrue(null, "null <> Sequence{}");
		assertQueryTrue(null, "Sequence{} <> null");

		assertQueryFalse(null, "null <> null");
	}

	public void testNotEqualEnumeration() {
		assertQueryFalse(null, "ocl::CollectionKind::_'Collection' <> ocl::CollectionKind::_'Collection'");
		assertQueryTrue(null, "ocl::CollectionKind::_'Collection' <> ocl::CollectionKind::_'Set'");
	}
	
    /**
     * Tests the explicit oclAsSet() operator.
     */
	public void test_oclAsSet_explicit() {
		assertQueryResults(null, "Set{true}", "true.oclAsSet()");
		assertQueryResults(null, "Set{}", "null.oclAsSet()");
		assertQueryInvalid(null, "invalid.oclAsSet()");
		assertQueryResults(null, "Set{Set{1..4}}", "Set{1..4}->oclAsSet()");
	}
	
    /**
     * Tests the implicit oclAsSet() operator.
     */
	public void test_oclAsSet_implicit() {
		assertQueryResults(null, "Set{true}", "true->select(true)");
		assertQueryResults(null, "Set{true}", "Set{true}->select(true)");
		assertQueryResults(null, "Set{}", "null->select(true)");
		assertQueryResults(null, "Set{}", "Set{}->select(true)");
		assertQueryResults(null, "Set{null}", "Set{null}->select(true)");
		assertQueryInvalid(null, "invalid->select(true)");
		//
		assertQueryResults(null, "false", "true.oclIsUndefined()");
		assertQueryResults(null, "false", "true->oclIsUndefined()");	// Set{true}
		assertQueryResults(null, "true", "null.oclIsUndefined()");
		assertQueryResults(null, "false", "null->oclIsUndefined()");	// Set{}
		assertQueryResults(null, "true", "invalid.oclIsUndefined()");
		assertQueryResults(null, "true", "invalid->oclIsUndefined()");	// invalid
		//
		assertQueryEquals(null, 4, "'1234'.size()");
		assertQueryEquals(null, 1, "'1234'->size()");
		//
		PrimitiveType booleanType = typeManager.getBooleanType();
		assertQueryEquals(null, getClassifierType(booleanType), "true.oclType()");
		Type collectionType = getCollectionType("Set", booleanType);
		assertQueryEquals(null, getClassifierType(collectionType), "true->oclType()");		// Set{true}
	}
	
    /**
     * Tests the oclAsType() operator.
     */
	public void test_oclAsType() {
		assertQueryInvalid(null, "invalid.oclAsType(String)");
		assertQueryInvalid(null, "invalid.oclAsType(Integer)");
		assertQueryInvalid(null, "invalid.oclAsType(Classifier)");
		assertQueryInvalid(null, "invalid.oclAsType(OclVoid)");
		assertQueryInvalid(null, "invalid.oclAsType(OclInvalid)");
		assertQueryInvalid(null, "invalid.oclAsType(Classifier)");
		assertQueryInvalid(null, "invalid.oclAsType(Set<String>)");
		assertQueryInvalid(null, "invalid.oclAsType(Tuple<a:String>)");
		assertQueryInvalid(null, "invalid.oclAsType(ocl::Package)");
		//
		assertQueryNull(null, "null.oclAsType(String)");
		assertQueryNull(null, "null.oclAsType(Integer)");
		assertQueryNull(null, "null.oclAsType(Classifier)");
		assertQueryNull(null, "null.oclAsType(OclVoid)");
		assertQueryInvalid(null, "null.oclAsType(OclInvalid)");
		assertQueryNull(null, "null.oclAsType(Classifier)");
		assertQueryNull(null, "null.oclAsType(Set<String>)");
		assertQueryNull(null, "null.oclAsType(Tuple<a:String>)");
		assertQueryNull(null, "null.oclAsType(ocl::Package)");
		//
		assertQueryInvalid(null, "true.oclAsType(Integer)");
		assertQueryInvalid(null, "true.oclAsType(String)");
		assertQueryTrue(null, "true.oclAsType(Boolean)");
		assertQueryTrue(null, "true.oclAsType(OclAny)");
		assertQueryInvalid(null, "true.oclAsType(OclVoid)");
		assertQueryInvalid(null, "true.oclAsType(OclInvalid)");
		//
		assertQueryEquals(null, 3, "3.oclAsType(Integer)");
		assertQueryEquals(null, 3.0, "3.oclAsType(Real)");
//		assertQueryEquals(null, 3, "3.0.oclAsType(Integer)");
		assertQueryInvalid(null, "3.0.oclAsType(Integer)");
		assertQueryEquals(null, 3.0, "3.0.oclAsType(Real)");
		assertQueryInvalid(null, "3.oclAsType(String)");
		assertQueryEquals(null, 3, "3.oclAsType(OclAny)");
		assertQueryInvalid(null, "3.oclAsType(OclVoid)");
		assertQueryInvalid(null, "3.oclAsType(OclInvalid)");
		//
		assertQueryInvalid(null, "3.14.oclAsType(Integer)");
		assertQueryEquals(null, 3.14, "3.14.oclAsType(Real)");
		assertQueryInvalid(null, "3.14.oclAsType(String)");
		assertQueryEquals(null, 3.14, "3.14.oclAsType(OclAny)");
		assertQueryInvalid(null, "3.14.oclAsType(OclVoid)");
		assertQueryInvalid(null, "3.14.oclAsType(OclInvalid)");
		//
		assertQueryInvalid(null, "*.oclAsType(Integer)");
		assertQueryInvalid(null, "*.oclAsType(Real)");
		assertQueryUnlimited(null, "*.oclAsType(UnlimitedNatural)");
		assertQueryInvalid(null, "*.oclAsType(String)");
		assertQueryUnlimited(null, "*.oclAsType(OclAny)");
		assertQueryInvalid(null, "*.oclAsType(OclVoid)");
		assertQueryInvalid(null, "*.oclAsType(OclInvalid)");
		//
		assertQueryResults(null, "Set{1,2}", "Set{1,2}->oclAsType(Set<UnlimitedNatural>)");
		assertQueryResults(null, "Set{1,2}", "Set{1,2}->oclAsType(Set<Integer>)");
		assertQueryResults(null, "Set{1,2}", "Set{1,2}->oclAsType(Collection<UnlimitedNatural>)");
//BUG 344931		assertQueryResults(null, "Set{1,2}", "Set{1.0,2}->oclAsType(Collection<UnlimitedNatural>)");
//BUG 344931		assertQueryResults(null, "Set{1,2}", "Set{1.0,2.0}->oclAsType(Collection<UnlimitedNatural>)");
		assertQueryInvalid(null, "Set{1,2}->oclAsType(Sequence<UnlimitedNatural>)");
		assertQueryInvalid(null, "Set{1,2}.oclAsType(Set<UnlimitedNatural>)");
		assertQueryResults(null, "Bag{1,2}", "Set{1,2}.oclAsType(UnlimitedNatural)");
		assertQueryInvalid(null, "Set{1,2}.oclAsType(Set<Integer>)");
		assertQueryResults(null, "Bag{1,2}", "Set{1,2}.oclAsType(Integer)");
		assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Set<Set<UnlimitedNatural>>)");
		assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Set<Collection<UnlimitedNatural>>)");
		assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Collection<Set<UnlimitedNatural>>)");
		assertQueryResults(null, "Set{Set{1,2},Set{3,4}}", "Set{Set{1,2},Set{3,4}}->oclAsType(Set<Set<Integer>>)");
		assertQueryInvalid(null, "Set{Set{1,2},Set{3,4}}->oclAsType(Set<Sequence<UnlimitedNatural>>)");
		assertQueryInvalid(null, "Set{Set{1,2},Set{3,4}}->oclAsType(Sequence<Set<UnlimitedNatural>>)");
		//
		assertSemanticErrorQuery("3.oclAsType(OclAny).abs()", OCLMessages.UnresolvedOperation_ERROR_, "abs", "OclAny");
		assertSemanticErrorQuery("let v : OclAny = 3 in v.abs()", OCLMessages.UnresolvedOperation_ERROR_, "abs", "OclAny");
		assertQueryEquals(null, 3, "let v : OclAny = 3 in v.oclAsType(Integer).abs()");
		assertQueryInvalid(null, "Integer.oclAsType(Real)");
	}

    /**
     * Tests the oclIsInvalid() operator.
     */
    public void test_oclIsInvalid() {
        assertQueryTrue(null, "invalid.oclIsInvalid()");
        assertQueryFalse(null, "null.oclIsInvalid()");
        assertQueryFalse(null, "true.oclIsInvalid()");
        assertQueryFalse(null, "false.oclIsInvalid()");
        assertQueryFalse(null, "3.14.oclIsInvalid()");
        assertQueryFalse(null, "1.oclIsInvalid()");
        assertQueryFalse(null, "*.oclIsInvalid()");
        assertQueryFalse(null, "'invalid'.oclIsInvalid()");
        assertQueryFalse(pkg1, "self.oclIsInvalid()");
		assertQueryTrue(null, "invalid.oclIsInvalid()");
		assertQueryTrue(null, "('123a'.toInteger()).oclIsInvalid()");	// Bug 342561 for old evaluator
		assertQueryTrue(null, "let a:Integer='123a'.toInteger() in a.oclIsInvalid()");	// Bug 342561 for old evaluator
    }

    /**
     * Tests the oclIsKindOf() operator.
     */
    public void test_oclIsKindOf() {
        assertQueryTrue(null, "invalid.oclIsKindOf(OclInvalid)");
        assertQueryTrue(null, "invalid.oclIsKindOf(OclVoid)");
        assertQueryTrue(null, "invalid.oclIsKindOf(OclAny)");
		assertQueryTrue(null, "invalid.oclIsKindOf(String)");
		assertQueryTrue(null, "invalid.oclIsKindOf(Integer)");
		assertQueryTrue(null, "invalid.oclIsKindOf(Classifier)");
		assertQueryTrue(null, "invalid.oclIsKindOf(Bag<Boolean>)");
		assertQueryTrue(null, "invalid.oclIsKindOf(Tuple(a:Integer))");
        assertQueryTrue(null, "invalid.oclIsKindOf(ocl::Package)");
        //
        assertQueryFalse(null, "null.oclIsKindOf(OclInvalid)");
        assertQueryTrue(null, "null.oclIsKindOf(OclVoid)");
        assertQueryTrue(null, "null.oclIsKindOf(OclAny)");
		assertQueryTrue(null, "null.oclIsKindOf(String)");
		assertQueryTrue(null, "null.oclIsKindOf(Integer)");
		assertQueryTrue(null, "null.oclIsKindOf(Classifier)");
		assertQueryTrue(null, "null.oclIsKindOf(Bag<Boolean>)");
		assertQueryTrue(null, "null.oclIsKindOf(Tuple(a:Integer))");
        assertQueryTrue(null, "null.oclIsKindOf(ocl::Package)");
        //
        assertQueryFalse(null, "true.oclIsKindOf(OclInvalid)");
        assertQueryFalse(null, "true.oclIsKindOf(OclVoid)");
        assertQueryTrue(null, "true.oclIsKindOf(Boolean)");
        assertQueryFalse(null, "true.oclIsKindOf(Integer)");
        assertQueryFalse(null, "true.oclIsKindOf(String)");
        assertQueryTrue(null, "true.oclIsKindOf(OclAny)");
        assertQueryFalse(null, "true.oclIsKindOf(ocl::Package)");
        //
        assertQueryFalse(null, "3.14.oclIsKindOf(OclInvalid)");
        assertQueryFalse(null, "3.14.oclIsKindOf(OclVoid)");
        assertQueryFalse(null, "3.14.oclIsKindOf(Boolean)");
        assertQueryTrue(null, "3.14.oclIsKindOf(Real)");
        assertQueryFalse(null, "3.14.oclIsKindOf(Integer)");
        assertQueryFalse(null, "3.14.oclIsKindOf(String)");
        assertQueryTrue(null, "3.14.oclIsKindOf(OclAny)");
        assertQueryFalse(null, "3.14.oclIsKindOf(ocl::Package)");
        //
        assertQueryFalse(null, "1.oclIsKindOf(OclInvalid)");
        assertQueryFalse(null, "1.oclIsKindOf(OclVoid)");
        assertQueryFalse(null, "1.oclIsKindOf(Boolean)");
        assertQueryTrue(null, "1.oclIsKindOf(Real)");
        assertQueryTrue(null, "1.oclIsKindOf(Integer)");
        assertQueryTrue(null, "(-1).oclIsKindOf(Integer)");
        assertQueryTrue(null, "1.oclIsKindOf(UnlimitedNatural)");
        assertQueryFalse(null, "1.oclIsKindOf(String)");
        assertQueryTrue(null, "1.oclIsKindOf(OclAny)");
        assertQueryFalse(null, "1.oclIsKindOf(ocl::Package)");
        //
        assertQueryFalse(null, "*.oclIsKindOf(OclInvalid)");
        assertQueryFalse(null, "*.oclIsKindOf(OclVoid)");
        assertQueryFalse(null, "*.oclIsKindOf(Boolean)");
        assertQueryTrue(null, "*.oclIsKindOf(Real)");
        assertQueryTrue(null, "*.oclIsKindOf(Integer)");
        assertQueryTrue(null, "*.oclIsKindOf(UnlimitedNatural)");
        assertQueryFalse(null, "*.oclIsKindOf(String)");
        assertQueryTrue(null, "*.oclIsKindOf(OclAny)");
        assertQueryFalse(null, "*.oclIsKindOf(ocl::Package)");
        //
        assertQueryFalse(null, "'invalid'.oclIsKindOf(OclInvalid)");
        assertQueryFalse(null, "'null'.oclIsKindOf(OclVoid)");
        assertQueryFalse(null, "'true'.oclIsKindOf(Boolean)");
        assertQueryFalse(null, "'3.14'.oclIsKindOf(Real)");
        assertQueryFalse(null, "'1'.oclIsKindOf(Integer)");
        assertQueryFalse(null, "'*'.oclIsKindOf(UnlimitedNatural)");
        assertQueryTrue(null, "'string'.oclIsKindOf(String)");
        assertQueryTrue(null, "'any'.oclIsKindOf(OclAny)");
        assertQueryFalse(pkg1, "'self'.oclIsKindOf(ocl::Package)");
        //
        assertQueryFalse(pkg1, "self.oclIsKindOf(OclInvalid)");
        assertQueryFalse(pkg1, "self.oclIsKindOf(OclVoid)");
        assertQueryFalse(pkg1, "self.oclIsKindOf(Boolean)");
        assertQueryFalse(pkg1, "self.oclIsKindOf(Real)");
        assertQueryFalse(pkg1, "self.oclIsKindOf(Integer)");
        assertQueryFalse(pkg1, "self.oclIsKindOf(UnlimitedNatural)");
        assertQueryFalse(pkg1, "self.oclIsKindOf(String)");
        assertQueryTrue(pkg1, "self.oclIsKindOf(OclAny)");
        assertQueryTrue(pkg1, "self.oclIsKindOf(ocl::Package)");
    }

	/**
     * Tests the oclIsTypeOf() operator.
     */
    public void test_oclIsTypeOf() {
        assertQueryTrue(null, "invalid.oclIsTypeOf(OclInvalid)");
        assertQueryFalse(null, "invalid.oclIsTypeOf(OclVoid)");
        assertQueryFalse(null, "invalid.oclIsTypeOf(OclAny)");
		assertQueryFalse(null, "invalid.oclIsTypeOf(Integer)");
		assertQueryFalse(null, "invalid.oclIsTypeOf(String)");
		assertQueryFalse(null, "invalid.oclIsTypeOf(Classifier)");
		assertQueryFalse(null, "invalid.oclIsTypeOf(Set<String>)");
        assertQueryFalse(null, "invalid.oclIsTypeOf(ocl::Package)");
        //
        assertQueryFalse(null, "null.oclIsTypeOf(OclInvalid)");
        assertQueryTrue(null, "null.oclIsTypeOf(OclVoid)");
        assertQueryFalse(null, "null.oclIsTypeOf(OclAny)");
		assertQueryFalse(null, "null.oclIsTypeOf(Integer)");
		assertQueryFalse(null, "null.oclIsTypeOf(String)");
		assertQueryFalse(null, "null.oclIsTypeOf(Classifier)");
		assertQueryFalse(null, "null.oclIsTypeOf(Set<String>)");
        assertQueryFalse(null, "null.oclIsTypeOf(ocl::Package)");
        //
        assertQueryFalse(null, "true.oclIsTypeOf(OclInvalid)");
        assertQueryFalse(null, "true.oclIsTypeOf(OclVoid)");
        assertQueryTrue(null, "true.oclIsTypeOf(Boolean)");
        assertQueryFalse(null, "true.oclIsTypeOf(String)");
        assertQueryFalse(null, "true.oclIsTypeOf(OclAny)");
        assertQueryFalse(null, "true.oclIsTypeOf(ocl::Package)");
        //
        assertQueryFalse(null, "3.14.oclIsTypeOf(OclInvalid)");
        assertQueryFalse(null, "3.14.oclIsTypeOf(OclVoid)");
        assertQueryFalse(null, "3.14.oclIsTypeOf(Boolean)");
        assertQueryTrue(null, "3.14.oclIsTypeOf(Real)");
        assertQueryFalse(null, "3.14.oclIsTypeOf(Integer)");
        assertQueryFalse(null, "3.14.oclIsTypeOf(String)");
        assertQueryFalse(null, "3.14.oclIsTypeOf(OclAny)");
        assertQueryFalse(null, "3.14.oclIsTypeOf(ocl::Package)");
        //
        assertQueryFalse(null, "1.oclIsTypeOf(OclInvalid)");
        assertQueryFalse(null, "1.oclIsTypeOf(OclVoid)");
        assertQueryFalse(null, "1.oclIsTypeOf(Boolean)");
        assertQueryFalse(null, "1.oclIsTypeOf(Real)");
        assertQueryFalse(null, "1.oclIsTypeOf(Integer)");
        assertQueryTrue(null, "(-1).oclIsTypeOf(Integer)");
        assertQueryTrue(null, "1.oclIsTypeOf(UnlimitedNatural)");
        assertQueryFalse(null, "1.oclIsTypeOf(String)");
        assertQueryFalse(null, "1.oclIsTypeOf(OclAny)");
        assertQueryFalse(null, "1.oclIsTypeOf(ocl::Package)");
        //
        assertQueryFalse(null, "*.oclIsTypeOf(OclInvalid)");
        assertQueryFalse(null, "*.oclIsTypeOf(OclVoid)");
        assertQueryFalse(null, "*.oclIsTypeOf(Boolean)");
        assertQueryFalse(null, "*.oclIsTypeOf(Real)");
        assertQueryFalse(null, "*.oclIsTypeOf(Integer)");
        assertQueryTrue(null, "*.oclIsTypeOf(UnlimitedNatural)");
        assertQueryFalse(null, "*.oclIsTypeOf(String)");
        assertQueryFalse(null, "*.oclIsTypeOf(OclAny)");
        assertQueryFalse(null, "*.oclIsTypeOf(ocl::Package)");
        //
        assertQueryFalse(null, "'invalid'.oclIsTypeOf(OclInvalid)");
        assertQueryFalse(null, "'null'.oclIsTypeOf(OclVoid)");
        assertQueryFalse(null, "'true'.oclIsTypeOf(Boolean)");
        assertQueryFalse(null, "'3.14'.oclIsTypeOf(Real)");
        assertQueryFalse(null, "'1'.oclIsTypeOf(Integer)");
        assertQueryFalse(null, "'*'.oclIsTypeOf(UnlimitedNatural)");
        assertQueryTrue(null, "'string'.oclIsTypeOf(String)");
        assertQueryFalse(null, "'any'.oclIsTypeOf(OclAny)");
        assertQueryFalse(pkg1, "'self'.oclIsTypeOf(ocl::Package)");
        //
        assertQueryFalse(pkg1, "self.oclIsTypeOf(OclInvalid)");
        assertQueryFalse(pkg1, "self.oclIsTypeOf(OclVoid)");
        assertQueryFalse(pkg1, "self.oclIsTypeOf(Boolean)");
        assertQueryFalse(pkg1, "self.oclIsTypeOf(Real)");
        assertQueryFalse(pkg1, "self.oclIsTypeOf(Integer)");
        assertQueryFalse(pkg1, "self.oclIsTypeOf(UnlimitedNatural)");
        assertQueryFalse(pkg1, "self.oclIsTypeOf(String)");
        assertQueryFalse(pkg1, "self.oclIsTypeOf(OclAny)");
        assertQueryTrue(pkg1, "self.oclIsTypeOf(ocl::Package)");
    }

    /**
     * Tests the oclIsUndefined() operator.
     */
    public void test_oclIsUndefined() {
        assertQueryTrue(null, "invalid.oclIsUndefined()");
        assertQueryTrue(null, "null.oclIsUndefined()");
        assertQueryFalse(null, "true.oclIsUndefined()");
        assertQueryFalse(null, "false.oclIsUndefined()");
        assertQueryFalse(null, "3.14.oclIsUndefined()");
        assertQueryFalse(null, "1.oclIsUndefined()");
        assertQueryFalse(null, "*.oclIsUndefined()");
        assertQueryFalse(null, "'null'.oclIsUndefined()");
        assertQueryFalse(pkg1, "self.oclIsUndefined()");
    }

    /**
     * Tests the oclType() operator for Booleans.
     */
    public void test_oclType_Boolean() {
    	ClassifierType classifierType = getClassifierType(typeManager.getBooleanType());
    	assertQueryEquals(null, classifierType, "true.oclType()");
    	assertQueryEquals(null, "Boolean", "true.oclType().name");
		assertQueryEquals(null, classifierType, "Boolean");
    	assertQueryEquals(null, "Boolean", "Boolean.name");
    	assertQueryEquals(null, getClassifierType(classifierType), "Boolean.oclType()");
    	assertQueryResults(null, "Set{false,true}", "Boolean.allInstances()");
    	assertQueryResults(null, "Set{false,true}", "true.oclType().allInstances()");
    	assertQueryResults(null, "Set{}", "Boolean.oclType().allInstances()");
    	assertQueryEquals(null, 1, "true.oclType().ownedOperation->select(name = 'xor')->any(true).ownedParameter->size()");
    }

    /**
     * Tests the oclType() operator for Classifiers.
     */
    public void test_oclType_Classifier() {
    	ClassifierType classifierType = getClassifierType(typeManager.getPivotType("Package"));
       	assertQueryEquals(pkg1, classifierType, "self.oclType()");
    	assertQueryEquals(pkg1, "Package", "self.oclType().name");
		assertQueryEquals(null, classifierType, "Package");
    	assertQueryEquals(null, "Package", "Package.name");
    	assertQueryEquals(null, getClassifierType(classifierType), "Package.oclType()");
    	assertQueryResults(null, "Set{}", "Package.allInstances()");
    	assertQueryEquals(pkg1, 8, "Package.allInstances()->size()");
       	assertQueryResults(pkg1, "self->closure(nestedPackage)->including(self)", "Package.allInstances()");
       	assertQueryEquals(pkg1, 8, "self.oclType().allInstances()->size()");
       	assertQueryEquals(pkg1, 0, "Package.oclType().allInstances()->size()");
    }

    /**
     * Tests the oclType() operator for Collections.
     */
    public void test_oclType_Collection() {   	
    	assertQueryEquals(null, 1, "Set{1}->oclType().ownedOperation->select(name = 'flatten')->size()");
    	assertQueryEquals(null, getClassifierType(typeManager.getSetType(typeManager.getOclAnyType())), "Set{}->oclType()");
    	assertQueryEquals(null, getClassifierType(typeManager.getSetType(typeManager.getUnlimitedNaturalType())), "Set{1}->oclType()");
    	assertQueryResults(null, "Bag{'UnlimitedNatural'}", "Set{1}.oclType().name");
    	assertQueryEquals(null, "Set", "Set{1}->oclType().name");
    	assertSemanticErrorQuery("Set{1}.allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Set<UnlimitedNatural>");
    	assertSemanticErrorQuery("Set{1}->allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Set<UnlimitedNatural>");
    	assertSemanticErrorQuery("Set{1}.oclType().allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Bag<Classifier<UnlimitedNatural>>");
    	assertSemanticErrorQuery("Set{1}->oclType().allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Classifier<Set<UnlimitedNatural>>");
    	assertQueryResults(null, "Set{}", "Set.oclType().allInstances()");
    	assertQueryEquals(null, typeManager.getUnlimitedNaturalType(), "Set{1}->oclType().elementType");
    }

    /**
     * Tests the oclType() operator for Enumerations.
     */
    public void test_oclType_Enumeration() {
    	ClassifierType classifierType = getClassifierType(typeManager.getPivotType("CollectionKind"));
    	assertQueryEquals(null, getClassifierType(typeManager.getPivotType("EnumerationLiteral")), "CollectionKind::Set.oclType()");
    	assertQueryEquals(null, "EnumerationLiteral", "CollectionKind::Set.oclType().name");
    	assertQueryEquals(null, classifierType, "CollectionKind");
    	assertQueryEquals(null, "CollectionKind", "CollectionKind.name");
    	assertQueryEquals(null, getClassifierType(classifierType), "CollectionKind.oclType()");
    	assertQueryEquals(null, 5, "CollectionKind.ownedLiteral->size()");
    	assertSemanticErrorQuery("CollectionKind.oclType().ownedLiteral", OCLMessages.UnresolvedProperty_ERROR_, "ownedLiteral", "Classifier<Classifier<CollectionKind>>");
    	assertQueryResults(null, "Set{CollectionKind::Bag,CollectionKind::Collection,CollectionKind::_'OrderedSet',CollectionKind::_'Sequence',CollectionKind::_'Set'}", "CollectionKind.allInstances()");
    	assertQueryResults(null, "Set{}", "CollectionKind::Set.oclType().allInstances()");
    	assertQueryResults(null, "Set{}", "CollectionKind.oclType().allInstances()");
    }

    /**
     * Tests the oclType() operator for Numerics.
     */
    public void test_oclType_Numeric() {
//
    	ClassifierType classifierType = getClassifierType(typeManager.getIntegerType());
    	assertQueryEquals(null, getClassifierType(typeManager.getUnlimitedNaturalType()), "3.oclType()");
    	assertQueryEquals(null, getClassifierType(typeManager.getRealType()), "3.0.oclType()");
    	assertQueryEquals(null, getClassifierType(typeManager.getUnlimitedNaturalType()), "*.oclType()");
		assertQueryEquals(null, getClassifierType(classifierType), "Integer.oclType()");
    	assertQueryEquals(null, classifierType, "Integer");
    	assertSemanticErrorQuery("Integer.allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Classifier<Integer>");
    	assertSemanticErrorQuery("3.oclType().allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Classifier<UnlimitedNatural>");
    	assertQueryResults(null, "Set{}", "Integer.oclType().allInstances()");
     }

    /**
     * Tests the oclType() operator for OclAny.
     */
    public void test_oclType_OclAny() {
    	ClassifierType classifierType = getClassifierType(typeManager.getOclAnyType());
    	assertQueryEquals(null, classifierType, "null.oclAsType(OclAny).oclType()");
//    	assertQueryEquals(null, "OclAny", "null.oclAsType(OclAny).name");
		assertQueryEquals(null, classifierType, "OclAny");
    	assertQueryEquals(null, "OclAny", "OclAny.name");
    	assertQueryEquals(null, getClassifierType(classifierType), "OclAny.oclType()");
    	assertSemanticErrorQuery("OclAny.allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Classifier<OclAny>");
    	assertSemanticErrorQuery("null.oclAsType(OclAny).oclType().allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Classifier<OclAny>");
    	assertQueryResults(null, "Set{}", "OclAny.oclType().allInstances()");
    }

    /**
     * Tests the oclType() operator for OclInvalid.
     */
    public void test_oclType_OclInvalid() {
    	ClassifierType classifierType = getClassifierType(typeManager.getOclInvalidType());
    	assertQueryEquals(null, classifierType, "invalid.oclType()");
    	assertQueryEquals(null, "OclInvalid", "invalid.oclType().name");
		assertQueryEquals(null, classifierType, "OclInvalid");
    	assertQueryEquals(null, "OclInvalid", "OclInvalid.name");
    	assertQueryEquals(null, getClassifierType(classifierType), "OclInvalid.oclType()");
    	assertQueryInvalid(null, "OclInvalid.allInstances()");
    	assertQueryInvalid(null, "invalid.oclType().allInstances()");
    	assertQueryResults(null, "Set{}", "OclInvalid.oclType().allInstances()");
    	assertQueryEquals(null, 1, "invalid.oclType().ownedOperation->select(name = '=')->any(true).ownedParameter->size()");
    }

    /**
     * Tests the oclType() operator for OclVoid.
     */
    public void test_oclType_OclVoid() {
    	ClassifierType classifierType = getClassifierType(typeManager.getOclVoidType());
    	assertQueryEquals(null, classifierType, "null.oclType()");
    	assertQueryEquals(null, "OclVoid", "null.oclType().name");
		assertQueryEquals(null, classifierType, "OclVoid");
    	assertQueryEquals(null, "OclVoid", "OclVoid.name");
    	assertQueryEquals(null, getClassifierType(classifierType), "OclVoid.oclType()");
    	assertQueryResults(null, "Set{null}", "OclVoid.allInstances()");
    	assertQueryResults(null, "Set{null}", "null.oclType().allInstances()");
    	assertQueryResults(null, "Set{}", "OclVoid.oclType().allInstances()");
    	assertQueryEquals(null, 1, "null.oclType().ownedOperation->select(name = '=')->any(true).ownedParameter->size()");
    }

    /**
     * Tests the oclType() operator for Tuples.
     */
    public void test_oclType_Tuple() {
    	TypeManager.TuplePart part = new TypeManager.TuplePart("a", typeManager.getIntegerType());
    	TupleType tupleType = typeManager.getTupleType("Tuple", Collections.singletonList(part), null, null);
    	ClassifierType tupleClassifierType = getClassifierType(tupleType);
		assertQueryEquals(null, tupleClassifierType, "Tuple{a:Integer=3}.oclType()");
    	assertQueryEquals(null, tupleClassifierType, "Tuple(a:Integer)");
		assertQueryEquals(null, getClassifierType(tupleClassifierType), "Tuple(a:Integer).oclType()");
    	assertSemanticErrorQuery("Tuple(a:Integer).allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Classifier<Tuple(a:Integer)>");
    	assertSemanticErrorQuery("Tuple{a:Integer=3}.oclType().allInstances()", OCLMessages.UnresolvedOperation_ERROR_, "allInstances", "Classifier<Tuple(a:Integer)>");	// FIXME
    	assertQueryResults(null, "Set{}", "Tuple(a:Integer).oclType().allInstances()");
     }

    /**
     * Tests the oclType() operator.
     */
    public void test_oclType() {
		assertQueryEquals(null, getClassifierType(typeManager.getStringType()), "'string'.oclType()");
		assertQueryEquals(null, getClassifierType(typeManager.getOclAnyType()), "self.oclType()");
    	assertQueryEquals(null, getClassifierType(getClassifierType(typeManager.getUnlimitedNaturalType())), "3.oclType().oclType()");
    	assertQueryEquals(null, getClassifierType(getClassifierType(getClassifierType(typeManager.getUnlimitedNaturalType()))), "3.oclType().oclType().oclType()");
    	assertQueryEquals(null, getClassifierType(getClassifierType(typeManager.getBooleanType())), "Boolean.oclType()");
    	assertQueryEquals(null, "Classifier", "Boolean.oclType().name");
    	assertSemanticErrorQuery("3.oclType(OclAny)", OCLMessages.UnresolvedOperationCall_ERROR_, "oclType", "UnlimitedNatural", "Classifier<OclAny>");
    }

	public Type getCollectionType(String collectionName, Type type) {
		Type collectionType = typeManager.getCollectionType(collectionName, type);
		typeManager.addLockedElement(collectionType);
		return collectionType;
	}

}