/**
 * Copyright (c) 2009, 2018 Obeo 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:
 *     Obeo - initial API and implementation
 *     Axel Uhl (SAP AG) - Bug 342644
 */
package org.eclipse.ocl.tests;

import java.math.BigInteger;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.ocl.expressions.UnlimitedNaturalLiteralExp;
import org.eclipse.ocl.options.ParsingOptions;

//FIXME we're missing oclIsNew and oclIsInState
/**
 * This unit test focuses on the Standard library's Integer and Real operations.
 * The unlimited natural will be considered as conforming to Integer. This will
 * need revisting once bug 261008 is fixed.
 *
 * @author Laurent Goubet (lgoubet)
 */
@SuppressWarnings("nls")
public abstract class GenericEvaluationNumberOperationTest<E extends EObject, PK extends E, T extends E, C extends T, CLS extends C, DT extends C, PT extends C, ET extends DT, O extends E, PM extends E, P extends E, PA extends P, PR extends P, EL, S, COA, SSA, CT>
extends GenericEvaluationTestSuite<E, PK, T, C, CLS, DT, PT, ET, O, PM, P, PA, PR, EL, S, COA, SSA, CT> {

	public void testNumberAbs() {
		// Integer::abs()
		assertResult(Integer.valueOf(3), "3.abs()");
		assertResult(Integer.valueOf(3), "(-3).abs()");

		assertResult(2147483647, "2147483647.abs()");
		assertParserError("2147483648.abs()", "For input string: \"{0}\"", "2147483648");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		assertResult(2147483648L, "2147483648.abs()");
		assertResult(2147483649L, "(-2147483649).abs()");
		assertResult(2147483648L, "(-2147483648).abs()");

		// Real::abs()
		assertResult(Double.valueOf(3d), "(3.0).abs()");
		assertResult(Double.valueOf(3d), "(-3.0).abs()");
		assertResult(Double.valueOf(3.1758d), "(3.1758).abs()");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberAbsInvalid() {
		assertResultInvalid("let i : Integer = invalid in i.abs()");
		assertResultInvalid("let r : Real = invalid in r.abs()");
	}

	public void testNumberAbsNull() {
		assertResultInvalid("let i : Integer = null in i.abs()");
		assertResultInvalid("let r : Real = null in r.abs()");
	}

	public void testNumberDiv() {
		assertResult(Integer.valueOf(1), "3.div(2)");
		assertResult(Integer.valueOf(-1), "(-3).div(2)");
		assertResult(Integer.valueOf(-1), "3.div(-2)");
		assertResult(Integer.valueOf(1), "(-3).div(-2)");
	}

	public void testNumberDivByZero() {
		assertResultInvalid("1.div(0)");
	}

	public void testNumberDivide() {
		// A.2.1.3 Contrary to other operations, "Integer x Integer -> Real"
		// Integer::/(Integer)
		assertResult(Double.valueOf(1d), "1 / 1");
		assertResult(Double.valueOf(-0.25d), "1 / -4");

		// Integer::/(Real)
		assertResult(Double.valueOf(1d), "1 / 1.0");
		assertResult(Double.valueOf(-0.25d), "1 / -4.0");

		// Real::/(Integer)
		assertResult(Double.valueOf(1d), "1.0 / 1");
		assertResult(Double.valueOf(-0.25d), "1.0 / -4");

		// Real::/(Real)
		assertResult(Double.valueOf(1d), "1.0 / 1.0");
		assertResult(Double.valueOf(1.11d / 1.12d), "1.11 / 1.12");
	}

	public void testNumberDivideByZero() {
		assertResultInvalid("1 / 0");
		assertResultInvalid("1.0 / 0");
		assertResultInvalid("1 / 0.0");
		assertResultInvalid("1.0 / 0.0");
	}

	public void testNumberDivideInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1 / i");
		assertResultInvalid("let i : Integer = invalid in i / 1");
		assertResultInvalid("let r : Real = invalid in 1 / r");
		assertResultInvalid("let r : Real = invalid in r / 1");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 / i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 / r2");
	}

	public void testNumberDivideNull() {
		assertResultInvalid("let i : Integer = null in 1 / i");
		assertResultInvalid("let i : Integer = null in i / 1");
		assertResultInvalid("let r : Real = null in 1 / r");
		assertResultInvalid("let r : Real = null in r / 1");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 / i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 / r2");
	}

	public void testNumberDivInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1.div(i)");
		assertResultInvalid("let i : Integer = invalid in i.div(1)");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1.div(i2)");
	}

	public void testNumberDivNull() {
		assertResultInvalid("let i : Integer = null in 1.div(i)");
		assertResultInvalid("let i : Integer = null in i.div(1)");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1.div(i2)");
	}

	public void testNumberEqual() {
		assertResultFalse("4 = 5");
		assertResultFalse("1 = 4.0");
		assertResultFalse("1.0 = 4");
		assertResultFalse("1.0 = 4.0");

		assertResultTrue("4 = 4");
		assertResultTrue("1 = 1.0");
		assertResultTrue("1.0 = 1");
		assertResultTrue("1.0 = 1.0");
	}

	public void testNumberEqualInvalid() {
		// operation invocations on invalid except for oclIsInvalid and oclIsUndefined yield invalid
		assertResultInvalid("let i : Integer = invalid in i = 0");
		assertResultInvalid("let i : Integer = invalid in -1 = i");
		assertResultInvalid("let r : Real = invalid in r = 0.0");
		assertResultInvalid("let r : Real = invalid in -1.0 = r");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 = i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 = r2");
	}

	public void testNumberEqualNull() {
		assertResultFalse("let i : Integer = null in i = 0");
		assertResultFalse("let i : Integer = null in -1 = i");
		assertResultFalse("let r : Real = null in r = 0.0");
		assertResultFalse("let r : Real = null in -1.0 = r");

		assertResultTrue("let i1 : Integer = null, i2 : Integer = null in i1 = i2");
		assertResultTrue("let r1 : Real = null, r2 : Real = null in r1 = r2");
	}

	public void testNumberFloor() {
		// Integer::floor()
		assertResult(Integer.valueOf(3), "3.floor()");
		assertResult(Integer.valueOf(-3), "(-3).floor()");

		// Real::floor()
		assertResult(Integer.valueOf(-2), "(-1.5).floor()");
		assertResult(Integer.valueOf(1), "(1.01).floor()");
		assertResult(Integer.valueOf(3), "(3.999).floor()");
	}

	public void testNumberFloorInvalid() {
		assertResultInvalid("let i : Integer = invalid in i.floor()");
		assertResultInvalid("let r : Real = invalid in r.floor()");
	}

	public void testNumberFloorNull() {
		assertResultInvalid("let i : Integer = null in i.floor()");
		assertResultInvalid("let r : Real = null in r.floor()");
	}

	public void testNumberGreaterThan() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::greaterThan(Integer)
		assertResultTrue("3 > 2");
		assertResultFalse("-3 > 2");
		assertResultTrue("3 > -2");
		assertResultFalse("-3 > -2");

		assertQueryTrue(null, "2147483648 > 2147483647");
		assertQueryFalse(null, "2147483647 > 2147483648");
		assertQueryFalse(null, "-2147483649 > -2147483648");
		assertQueryTrue(null, "-2147483648 > -2147483649");

		assertQueryTrue(null, "2147483648 >= 2147483647");
		assertQueryFalse(null, "2147483647 >= 2147483648");
		assertQueryFalse(null, "-2147483649 >= -2147483648");
		assertQueryTrue(null, "-2147483648 >= -2147483649");

		// Real::greaterThan(Real)
		assertResultTrue("3.0 > 2.0");
		assertResultFalse("-3.0 > 2.0");
		assertResultTrue("3.0 > -2.0");
		assertResultFalse("-3.0 > -2.0");

		// Real::greaterThan(Integer)
		assertResultFalse("3.0 > 3");
		assertResultFalse("-3.0 > 3");
		assertResultTrue("3.0 > -3");
		assertResultFalse("-3.0 > -3");

		// Integer::greaterThan(Real)
		assertResultFalse("3 > 3.0");
		assertResultFalse("-3 > 3.0");
		assertResultTrue("3 > -3.0");
		assertResultFalse("-3 > -3.0");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberGreaterThanInvalid() {
		assertResultInvalid("let i : Integer = invalid in i > 0");
		assertResultInvalid("let i : Integer = invalid in 0 > i");
		assertResultInvalid("let r : Real = invalid in r > 0");
		assertResultInvalid("let r : Real = invalid in 0 > r");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 > i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 > r2");
	}

	public void testNumberGreaterThanNull() {
		assertResultInvalid("let i : Integer = null in i > 0");
		assertResultInvalid("let i : Integer = null in 0 > i");
		assertResultInvalid("let r : Real = null in r > 0");
		assertResultInvalid("let r : Real = null in 0 > r");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 > i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 > r2");
	}

	public void testNumberGreaterThanOrEqual() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::greaterThanOrEqual(Integer)
		assertResultTrue("3 >= 2");
		assertResultFalse("-3 >= 2");
		assertResultTrue("3 >= -2");
		assertResultFalse("-3 >= -2");

		assertQueryTrue(null, "2147483648 >= 2147483647");
		assertQueryFalse(null, "2147483647 >= 2147483648");
		assertQueryFalse(null, "-2147483649 >= -2147483648");
		assertQueryTrue(null, "-2147483648 >= -2147483649");

		// Real::greaterThanOrEqual(Real)
		assertResultTrue("3.0 >= 2.0");
		assertResultFalse("-3.0 >= 2.0");
		assertResultTrue("3.0 >= -2.0");
		assertResultFalse("-3.0 >= -2.0");

		// Real::greaterThanOrEqual(Integer)
		assertResultTrue("3.0 >= 3");
		assertResultFalse("-3.0 >= 3");
		assertResultTrue("3.0 >= -3");
		assertResultTrue("-3.0 >= -3");

		// Integer::greaterThanOrEqual(Real)
		assertResultTrue("3 >= 3.0");
		assertResultFalse("-3 >= 3.0");
		assertResultTrue("3 >= -3.0");
		assertResultTrue("-3 >= -3.0");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
	}

	public void testNumberGreaterThanOrEqualInvalid() {
		assertResultInvalid("let i : Integer = invalid in i >= 0");
		assertResultInvalid("let i : Integer = invalid in 0 >= i");
		assertResultInvalid("let r : Real = invalid in r >= 0");
		assertResultInvalid("let r : Real = invalid in 0 >= r");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 >= i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 >= r2");
	}

	public void testNumberGreaterThanOrEqualNull() {
		assertResultInvalid("let i : Integer = null in i >= 0");
		assertResultInvalid("let i : Integer = null in 0 >= i");
		assertResultInvalid("let r : Real = null in r >= 0");
		assertResultInvalid("let r : Real = null in 0 >= r");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 >= i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 >= r2");
	}

	public void testNumberLessThan() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::lessThan(Integer)
		assertResultFalse("3 < 2");
		assertResultTrue("-3 < 2");
		assertResultFalse("3 < -2");
		assertResultTrue("-3 < -2");

		assertQueryFalse(null, "2147483648 < 2147483647");
		assertQueryTrue(null, "2147483647 < 2147483648");
		assertQueryTrue(null, "-2147483649 < -2147483648");
		assertQueryFalse(null, "-2147483648 < -2147483649");

		// Real::lessThan(Real)
		assertResultFalse("3.0 < 2.0");
		assertResultTrue("-3.0 < 2.0");
		assertResultFalse("3.0 < -2.0");
		assertResultTrue("-3.0 < -2.0");

		// Real::lessThan(Integer)
		assertResultFalse("3.0 < 3");
		assertResultTrue("-3.0 < 3");
		assertResultFalse("3.0 < -3");
		assertResultFalse("-3.0 < -3");

		// Integer::lessThan(Real)
		assertResultFalse("3 < 3.0");
		assertResultTrue("-3 < 3.0");
		assertResultFalse("3 < -3.0");
		assertResultFalse("-3 < -3.0");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberLessThanInvalid() {
		assertResultInvalid("let i : Integer = invalid in i < 0");
		assertResultInvalid("let i : Integer = invalid in 0 < i");
		assertResultInvalid("let r : Real = invalid in r < 0");
		assertResultInvalid("let r : Real = invalid in 0 < r");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 < i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 < r2");
	}

	public void testNumberLessThanNull() {
		assertResultInvalid("let i : Integer = null in i < 0");
		assertResultInvalid("let i : Integer = null in 0 < i");
		assertResultInvalid("let r : Real = null in r < 0");
		assertResultInvalid("let r : Real = null in 0 < r");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 < i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 < r2");
	}

	public void testNumberLessThanOrEqual() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::lessThanOrEqual(Integer)
		assertResultFalse("3 <= 2");
		assertResultTrue("-3 <= 2");
		assertResultFalse("3 <= -2");
		assertResultTrue("-3 <= -2");

		assertQueryFalse(null, "2147483648 <= 2147483647");
		assertQueryTrue(null, "2147483647 <= 2147483648");
		assertQueryTrue(null, "-2147483649 <= -2147483648");
		assertQueryFalse(null, "-2147483648 <= -2147483649");

		// Real::lessThanOrEqual(Real)
		assertResultFalse("3.0 <= 2.0");
		assertResultTrue("-3.0 <= 2.0");
		assertResultFalse("3.0 <= -2.0");
		assertResultTrue("-3.0 <= -2.0");

		// Real::lessThanOrEqual(Integer)
		assertResultTrue("3.0 <= 3");
		assertResultTrue("-3.0 <= 3");
		assertResultFalse("3.0 <= -3");
		assertResultTrue("-3.0 <= -3");

		// Integer::lessThanOrEqual(Real)
		assertResultTrue("3 <= 3.0");
		assertResultTrue("-3 <= 3.0");
		assertResultFalse("3 <= -3.0");
		assertResultTrue("-3 <= -3.0");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberLessThanOrEqualInvalid() {
		assertResultInvalid("let i : Integer = invalid in i <= 0");
		assertResultInvalid("let i : Integer = invalid in 0 <= i");
		assertResultInvalid("let r : Real = invalid in r <= 0");
		assertResultInvalid("let r : Real = invalid in 0 <= r");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 <= i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 <= r2");
	}

	public void testNumberLessThanOrEqualNull() {
		assertResultInvalid("let i : Integer = null in i <= 0");
		assertResultInvalid("let i : Integer = null in 0 <= i");
		assertResultInvalid("let r : Real = null in r <= 0");
		assertResultInvalid("let r : Real = null in 0 <= r");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 <= i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 <= r2");
	}

	public void testNumberMax() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::max(Integer)
		assertResult(Integer.valueOf(3), "3.max(2)");
		assertResult(Integer.valueOf(2), "(-3).max(2)");
		assertResult(Integer.valueOf(3), "3.max(-2)");
		assertResult(Integer.valueOf(-2), "(-3).max(-2)");

		assertResult(2147483648L, "2147483648.max(2147483647)");
		assertResult(2147483648L, "2147483647.max(2147483648)");
		assertResult(-2147483648, "(-2147483649).max(-2147483648)");
		assertResult(-2147483648, "(-2147483648).max(-2147483649)");

		// Integer::max(Real)
		assertResult(Double.valueOf(3d), "3.max(2.0)");
		assertResult(Double.valueOf(2d), "(-3).max(2.0)");
		assertResult(Double.valueOf(3d), "3.max(-2.0)");
		assertResult(Double.valueOf(-2d), "(-3).max(-2.0)");

		// Real::max(Integer)
		assertResult(Double.valueOf(3d), "(3.0).max(2)");
		assertResult(Double.valueOf(2d), "(-3.0).max(2)");
		assertResult(Double.valueOf(3d), "(3.0).max(-2)");
		assertResult(Double.valueOf(-2d), "(-3.0).max(-2)");

		// Real::max(Real)
		assertResult(Double.valueOf(3d), "(3.0).max(2.0)");
		assertResult(Double.valueOf(2d), "(-3.0).max(2.0)");
		assertResult(Double.valueOf(3d), "(3.0).max(-2.0)");
		assertResult(Double.valueOf(-2d), "(-3.0).max(-2.0)");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberMaxInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1.max(i)");
		assertResultInvalid("let i : Integer = invalid in i.max(1)");
		assertResultInvalid("let r : Real = invalid in 1.max(r)");
		assertResultInvalid("let r : Real = invalid in r.max(1)");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1.max(i2)");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1.max(r2)");
	}

	public void testNumberMaxNull() {
		assertResultInvalid("let i : Integer = null in 1.max(i)");
		assertResultInvalid("let i : Integer = null in i.max(1)");
		assertResultInvalid("let r : Real = null in 1.max(r)");
		assertResultInvalid("let r : Real = null in r.max(1)");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1.max(i2)");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1.max(r2)");
	}

	public void testNumberMin() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::min(Integer)
		assertResult(Integer.valueOf(2), "3.min(2)");
		assertResult(Integer.valueOf(-3), "(-3).min(2)");
		assertResult(Integer.valueOf(-2), "3.min(-2)");
		assertResult(Integer.valueOf(-3), "(-3).min(-2)");

		assertResult(2147483647, "2147483648.min(2147483647)");
		assertResult(2147483647, "2147483647.min(2147483648)");
		assertResult(-2147483649L, "(-2147483649).min(-2147483648)");
		assertResult(-2147483649L, "(-2147483648).min(-2147483649)");

		// Integer::min(Real)
		assertResult(Double.valueOf(2d), "3.min(2.0)");
		assertResult(Double.valueOf(-3d), "(-3).min(2.0)");
		assertResult(Double.valueOf(-2d), "3.min(-2.0)");
		assertResult(Double.valueOf(-3d), "(-3).min(-2.0)");

		// Real::min(Integer)
		assertResult(Double.valueOf(2d), "(3.0).min(2)");
		assertResult(Double.valueOf(-3d), "(-3.0).min(2)");
		assertResult(Double.valueOf(-2d), "(3.0).min(-2)");
		assertResult(Double.valueOf(-3d), "(-3.0).min(-2)");

		// Real::min(Real)
		assertResult(Double.valueOf(2d), "(3.0).min(2.0)");
		assertResult(Double.valueOf(-3d), "(-3.0).min(2.0)");
		assertResult(Double.valueOf(-2d), "(3.0).min(-2.0)");
		assertResult(Double.valueOf(-3d), "(-3.0).min(-2.0)");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberMinInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1.min(i)");
		assertResultInvalid("let i : Integer = invalid in i.min(1)");
		assertResultInvalid("let r : Real = invalid in 1.min(r)");
		assertResultInvalid("let r : Real = invalid in r.min(1)");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1.min(i2)");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1.min(r2)");
	}

	public void testNumberMinNull() {
		assertResultInvalid("let i : Integer = null in 1.min(i)");
		assertResultInvalid("let i : Integer = null in i.min(1)");
		assertResultInvalid("let r : Real = null in 1.min(r)");
		assertResultInvalid("let r : Real = null in r.min(1)");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1.min(i2)");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1.min(r2)");
	}

	public void testNumberMinus() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::-(Integer)
		assertResult(Integer.valueOf(0), "1 - 1");
		assertResult(Integer.valueOf(5), "1 - -4");

		assertResult(BigInteger.ONE.shiftLeft(31).subtract(BigInteger.ONE).intValue(), "2147483646 - -1");
		assertResult(BigInteger.ONE.shiftLeft(31).longValue(), "2147483647 - -1");
		assertResult(BigInteger.ONE.shiftLeft(63).subtract(BigInteger.ONE).longValue(), "9223372036854775806 - -1");
		assertResult(BigInteger.ONE.shiftLeft(63).longValue(), "9223372036854775807 - -1");

		assertResult(BigInteger.ONE.negate().shiftLeft(31).intValue(), "-2147483647 - 1");
		assertResult(BigInteger.ONE.negate().shiftLeft(31).subtract(BigInteger.ONE).longValue(), "-2147483648 - 1");
		assertResult(BigInteger.ONE.shiftLeft(63).negate().longValue(), "-9223372036854775807 - 1");

		// Integer::-(Real)
		assertResult(Double.valueOf(0d), "1 - 1.0");
		assertResult(Double.valueOf(5d), "1 - -4.0");

		// Real::-(Integer)
		assertResult(Double.valueOf(0d), "1.0 - 1");
		assertResult(Double.valueOf(5d), "1.0 - -4");

		// Real::-(Real)
		assertResult(Double.valueOf(0d), "1.0 - 1.0");
		assertResult(Double.valueOf(-0.01d), "1.11 - 1.12");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberMinusInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1 - i");
		assertResultInvalid("let i : Integer = invalid in i - 1");
		assertResultInvalid("let r : Real = invalid in 1 - r");
		assertResultInvalid("let r : Real = invalid in r - 1");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 - i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 - r2");
	}

	public void testNumberMinusNull() {
		assertResultInvalid("let i : Integer = null in 1 - i");
		assertResultInvalid("let i : Integer = null in i - 1");
		assertResultInvalid("let r : Real = null in 1 - r");
		assertResultInvalid("let r : Real = null in r - 1");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 - i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 - r2");
	}

	public void testNumberMod() {
		assertResult(Integer.valueOf(1), "3.mod(2)");
		assertResult(Integer.valueOf(-1), "(-3).mod(2)");
		assertResult(Integer.valueOf(1), "3.mod(-2)");
		assertResult(Integer.valueOf(-1), "(-3).mod(-2)");
	}

	public void testNumberModInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1.mod(i)");
		assertResultInvalid("let i : Integer = invalid in i.mod(1)");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1.mod(i2)");
	}

	public void testNumberModNull() {
		assertResultInvalid("let i : Integer = null in 1.mod(i)");
		assertResultInvalid("let i : Integer = null in i.mod(1)");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1.mod(i2)");
	}

	public void testNumberNegate() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		assertResult(-1, "-1");
		assertResult(-1.0, "-1.0");

		assertResult(-2147483647, "-2147483647");
		assertResult(-2147483648, "-2147483648");
		assertResult(2147483648L, "-(-2147483648)");
		assertResult(-2147483649L, "-2147483649");
		// invalid
		assertResultInvalid("let i : Integer = invalid in -i");
		assertResultInvalid("let r : Real = invalid in -r");
		// null
		assertResultInvalid("let i : Integer = null in -i");
		assertResultInvalid("let r : Real = null in -r");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberNotEqual() {
		assertResultTrue("4 <> 5");
		assertResultTrue("1 <> 4.0");
		assertResultTrue("1.0 <> 4");
		assertResultTrue("1.0 <> 4.0");

		assertResultFalse("4 <> 4");
		assertResultFalse("1 <> 1.0");
		assertResultFalse("1.0 <> 1");
		assertResultFalse("1.0 <> 1.0");
	}

	public void testNumberNotEqualInvalid() {
		assertResultInvalid("let i : Integer = invalid in i <> 0");
		assertResultInvalid("let i : Integer = invalid in -1 <> i");
		assertResultInvalid("let r : Real = invalid in r <> 0.0");
		assertResultInvalid("let r : Real = invalid in -1.0 <> r");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 <> i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 <> r2");
	}

	public void testNumberNotEqualNull() {
		assertResultTrue("let i : Integer = null in i <> 0");
		assertResultTrue("let i : Integer = null in -1 <> i");
		assertResultTrue("let r : Real = null in r <> 0.0");
		assertResultTrue("let r : Real = null in -1.0 <> r");

		assertResultFalse("let i1 : Integer = null, i2 : Integer = null in i1 <> i2");
		assertResultFalse("let r1 : Real = null, r2 : Real = null in r1 <> r2");
	}

	public void testNumberOclIsInvalid() {
		assertResultFalse("3.oclIsInvalid()");
		assertResultFalse("(3.0).oclIsInvalid()");
	}

	public void testNumberOclIsUndefined() {
		assertResultFalse("3.oclIsUndefined()");
		assertResultFalse("(3.0).oclIsUndefined()");
	}

	public void testNumberPlus() {
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, true);
		// Integer::+(Integer)
		assertResult(Integer.valueOf(2), "1 + 1");
		assertResult(Integer.valueOf(-3), "1 + -4");

		assertResult(BigInteger.ONE.shiftLeft(31).subtract(BigInteger.ONE).intValue(), "2147483646 + 1");
		assertResult(BigInteger.ONE.shiftLeft(31).longValue(), "2147483647 + 1");
		assertResult(BigInteger.ONE.shiftLeft(63).subtract(BigInteger.ONE).longValue(), "9223372036854775806 + 1");
		assertResult(BigInteger.ONE.shiftLeft(63).longValue(), "9223372036854775807 + 1");

		assertResult(BigInteger.ONE.negate().shiftLeft(31).intValue(), "-2147483647 + -1");
		assertResult(BigInteger.ONE.negate().shiftLeft(31).subtract(BigInteger.ONE).longValue(), "-2147483648 + -1");
		assertResult(BigInteger.ONE.negate().shiftLeft(63).longValue(), "-9223372036854775807 + -1");

		// Integer::+(Real)
		assertResult(Double.valueOf(2d), "1 + 1.0");
		assertResult(Double.valueOf(-3d), "1 + -4.0");

		// Real::+(Integer)
		assertResult(Double.valueOf(2d), "1.0 + 1");
		assertResult(Double.valueOf(-3d), "1.0 + -4");

		// Real::+(Real)
		assertResult(Double.valueOf(2d), "1.0 + 1.0");
		assertResult(Double.valueOf(2.23d), "1.11 + 1.12");
		ParsingOptions.setOption(helper.getOCL().getEnvironment(), ParsingOptions.USE_LONG_INTEGERS, false);
	}

	public void testNumberPlusInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1 + i");
		assertResultInvalid("let i : Integer = invalid in i + 1");
		assertResultInvalid("let r : Real = invalid in 1 + r");
		assertResultInvalid("let r : Real = invalid in r + 1");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 + i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 + r2");
	}

	public void testNumberPlusNull() {
		assertResultInvalid("let i : Integer = null in 1 + i");
		assertResultInvalid("let i : Integer = null in i + 1");
		assertResultInvalid("let r : Real = null in 1 + r");
		assertResultInvalid("let r : Real = null in r + 1");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 + i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 + r2");
	}

	public void testNumberRound() {
		// Integer::round()
		assertResult(Integer.valueOf(3), "3.round()");
		assertResult(Integer.valueOf(-3), "(-3).round()");

		// Real::round()
		assertResult(Integer.valueOf(-1), "(-1.5).round()");
		assertResult(Integer.valueOf(1), "(1.01).round()");
		assertResult(Integer.valueOf(4), "(3.999).round()");
	}

	public void testNumberRoundInvalid() {
		assertResultInvalid("let i : Integer = invalid in i.round()");
		assertResultInvalid("let r : Real = invalid in r.round()");
	}

	public void testNumberRoundNull() {
		assertResultInvalid("let i : Integer = null in i.round()");
		assertResultInvalid("let r : Real = null in r.round()");
	}

	public void testNumberTimes() {
		// Integer::*(Integer)
		assertResult(Integer.valueOf(1), "1 * 1");
		assertResult(Integer.valueOf(-4), "1 * -4");

		// Integer::*(Real)
		assertResult(Double.valueOf(1d), "1 * 1.0");
		assertResult(Double.valueOf(-4d), "1 * -4.0");

		// Real::*(Integer)
		assertResult(Double.valueOf(1d), "1.0 * 1");
		assertResult(Double.valueOf(-4d), "1.0 * -4");

		// Real::*(Real)
		assertResult(Double.valueOf(1d), "1.0 * 1.0");
		assertResult(Double.valueOf(1.11d * 1.12d), "1.11 * 1.12");
	}

	public void testNumberTimesInvalid() {
		assertResultInvalid("let i : Integer = invalid in 1 * i");
		assertResultInvalid("let i : Integer = invalid in i * 1");
		assertResultInvalid("let r : Real = invalid in 1 * r");
		assertResultInvalid("let r : Real = invalid in r * 1");

		assertResultInvalid("let i1 : Integer = invalid, i2 : Integer = invalid in i1 * i2");
		assertResultInvalid("let r1 : Real = invalid, r2 : Real = invalid in r1 * r2");
	}

	public void testNumberTimesNull() {
		assertResultInvalid("let i : Integer = null in 1 * i");
		assertResultInvalid("let i : Integer = null in i * 1");
		assertResultInvalid("let r : Real = null in 1 * r");
		assertResultInvalid("let r : Real = null in r * 1");

		assertResultInvalid("let i1 : Integer = null, i2 : Integer = null in i1 * i2");
		assertResultInvalid("let r1 : Real = null, r2 : Real = null in r1 * r2");
	}

	public void testNumberToString() {
		assertResult("1", "1.toString()");
		assertResult("3.0", "3.0.toString()");
		assertResult("4.0", "(1.0+3.0).toString()");
		assertResult("null", "null.toString()");
		assertResult("invalid", "invalid.toString()");
		assertResult("*", "*.toString()");
		assertResult("-1", "(-1).toString()");
	}

	public void testNumberUnaryMinus() {
		assertResult(Integer.valueOf(-1), "-1");
		assertResult(Double.valueOf(-1d), "-1.0");
	}

	public void testNumberUnaryMinusInvalid() {
		assertResultInvalid("let i : Integer = invalid in -i");
		assertResultInvalid("let r : Real = invalid in -r");
	}

	public void testNumberUnaryMinusNull() {
		assertResultInvalid("let i : Integer = null in -i");
		assertResultInvalid("let r : Real = null in -r");
	}

	public void testUnlimitedAbs() {
		assertResultInvalid("*.abs()");
	}

	public void testUnlimitedAbsInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u.abs()");
	}

	public void testUnlimitedAbsNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in u.abs()");
	}

	public void testUnlimitedDiv() {
		/*
		 * FIXME I'm expecting the UnlimitedNatural to conform to Integer, div
		 * and mod calls should then at least parse for them even though they
		 * return an invalid value.
		 */
		assertResultInvalid("1.div(*)");
		// FIXME UnlimitedNatural.div(Integer) currently not found; problem in analyzer?
		assertResultInvalid("*.div(1)");

		assertResultInvalid("*.div(*)");
	}

	public void testUnlimitedDivide() {
		assertResultInvalid("1 / *");
		assertResultInvalid("* / 1");

		assertResultInvalid("1.0 / *");
		assertResultInvalid("* / 1.0");

		assertResultInvalid("* / *");
	}

	public void testUnlimitedDivideByZero() {
		assertResultInvalid("* / 0");
		assertResultInvalid("* / 0.0");
	}

	public void testUnlimitedDivideInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in * / u");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u / *");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 / u2");
	}

	public void testUnlimitedDivideNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in * / u");
		assertResultInvalid("let u : UnlimitedNatural = null in u / *");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 / u2");
	}

	public void testUnlimitedDivInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in 1.div(u)");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u.div(1)");
	}

	public void testUnlimitedDivNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in 1.div(u)");
		assertResultInvalid("let u : UnlimitedNatural = null in u.div(1)");
	}

	public void testUnlimitedEqual() {
		assertResultFalse("* = 1");
		assertResultFalse("1 = *");
		assertResultFalse("* = 1.0");
		assertResultFalse("1.0 = *");
		// FIXME UNLIMIED is currently represented as -1, so no difference can be observed
		// assertResultFalse("* = -1");
		// assertResultFalse("-1 = *");
		// assertResultFalse("* = -1.0");
		// assertResultFalse("-1.0 = *");

		assertResultTrue("* = *");
	}

	public void testUnlimitedEqualInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u = *");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 = u2");
	}

	public void testUnlimitedEqualNull() {
		assertResultFalse("let u : UnlimitedNatural = null in u = *");

		assertResultTrue("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 = u2");
	}

	public void testUnlimitedFloor() {
		assertResultInvalid("*.floor()");
	}

	public void testUnlimitedFloorInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u.floor()");
	}

	public void testUnlimitedFloorNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in u.floor()");
	}

	public void testUnlimitedGreaterThan() {
		assertResultFalse("1 > *");
		assertResultTrue("* > 1");
		assertResultFalse("* > *");
	}

	public void testUnlimitedGreaterThanInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u > 0");
		assertResultInvalid("let u : UnlimitedNatural = invalid in 0 > u");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 > u2");
	}

	public void testUnlimitedGreaterThanNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in u > 0");
		assertResultInvalid("let u : UnlimitedNatural = null in 0 > u");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 > u2");
	}

	public void testUnlimitedGreaterThanOrEqual() {
		/*
		 * FIXME "(* = *) == true" but "(* >= *) == false" ? something's amiss
		 * and since this behavior isn't defined in the specification, we'll
		 * have to make an arbitrary choice. The "expected" here is Java's
		 * behavior with Double.POSITIVE_INFINITY.
		 */
		assertResultFalse("1 >= *");
		assertResultTrue("* >= 1");
		assertResultTrue("* >= *");
	}

	public void testUnlimitedGreaterThanOrEqualInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u >= 0");
		assertResultInvalid("let u : UnlimitedNatural = invalid in 0 >= u");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 >= u2");
	}

	public void testUnlimitedGreaterThanOrEqualNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in u >= 0");
		assertResultInvalid("let u : UnlimitedNatural = null in 0 >= u");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 >= u2");
	}

	public void testUnlimitedLessThan() {
		assertResultTrue("1 < *");
		assertResultFalse("* < 1");
		assertResultFalse("* < *");
	}

	public void testUnlimitedLessThanInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u < 0");
		assertResultInvalid("let u : UnlimitedNatural = invalid in 0 < u");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 < u2");
	}

	public void testUnlimitedLessThanNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in u < 0");
		assertResultInvalid("let u : UnlimitedNatural = null in 0 < u");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 < u2");
	}

	public void testUnlimitedLessThanOrEqual() {
		/*
		 * FIXME "(* = *) == true" but "(* <= *) == false" ? something's amiss
		 * and since this behavior isn't defined in the specification, we'll
		 * have to make an arbitrary choice. The "expected" here is Java's
		 * behavior with Double.POSITIVE_INFINITY.
		 */
		assertResultTrue("1 <= *");
		assertResultFalse("* <= 1");
		assertResultTrue("* <= *");
	}

	public void testUnlimitedLessThanOrEqualInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u <= 0");
		assertResultInvalid("let u : UnlimitedNatural = invalid in 0 <= u");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 <= u2");
	}

	public void testUnlimitedLessThanOrEqualNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in u <= 0");
		assertResultInvalid("let u : UnlimitedNatural = null in 0 <= u");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 <= u2");
	}

	public void testUnlimitedMax() {
		assertResultInvalid("1.max(*)");
		assertResultInvalid("*.max(1)");

		assertResultInvalid("(1.0).max(*)");
		assertResultInvalid("*.max(1.0)");

		assertResultInvalid("*.max(*)");
	}

	public void testUnlimitedMaxInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in *.max(u)");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u.max(*)");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1.max(u2)");
	}

	public void testUnlimitedMaxNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in *.max(u)");
		assertResultInvalid("let u : UnlimitedNatural = null in u.max(*)");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1.max(u2)");
	}

	public void testUnlimitedMin() {
		assertResultInvalid("1.min(*)");
		assertResultInvalid("*.min(1)");

		assertResultInvalid("(1.0).min(*)");
		assertResultInvalid("*.min(1.0)");

		assertResultInvalid("*.min(*)");
	}

	public void testUnlimitedMinInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in *.min(u)");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u.min(*)");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1.min(u2)");
	}

	public void testUnlimitedMinNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in *.min(u)");
		assertResultInvalid("let u : UnlimitedNatural = null in u.min(*)");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1.min(u2)");
	}

	public void testUnlimitedMinus() {
		assertResultInvalid("1 - *");
		assertResultInvalid("* - 1");

		assertResultInvalid("1.0 - *");
		assertResultInvalid("* - 1.0");

		assertResultInvalid("* - *");
	}

	public void testUnlimitedMinusInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in * - u");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u - *");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 - u2");
	}

	public void testUnlimitedMinusNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in * - u");
		assertResultInvalid("let u : UnlimitedNatural = null in u - *");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 - u2");
	}

	public void testUnlimitedMod() {
		/*
		 * FIXME I'm expecting the UnlimitedNatural to conform to Integer, div
		 * and mod calls should then at least parse for them even though they
		 * return an invalid value.
		 */
		assertResultInvalid("1.mod(*)");
		assertResultInvalid("*.mod(1)");

		assertResultInvalid("*.mod(*)");
	}

	public void testUnlimitedModInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in 1.mod(u)");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u.mod(1)");
	}

	public void testUnlimitedModNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in 1.mod(u)");
		assertResultInvalid("let u : UnlimitedNatural = null in u.mod(1)");
	}

	public void testUnlimitedNotEqual() {
		assertResultTrue("* <> 1");
		assertResultTrue("1 <> *");
		assertResultTrue("* <> 1.0");
		assertResultTrue("1.0 <> *");
		// FIXME currently, * is encoded as -1 and undistinguishable from it
		// assertResultTrue("* <> -1");
		// assertResultTrue("-1 <> *");
		// assertResultTrue("* <> -1.0");
		// assertResultTrue("-1.0 <> *");

		assertResultFalse("* <> *");
	}

	public void testUnlimitedNotEqualInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u <> *");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 <> u2");
	}

	public void testUnlimitedNotEqualNull() {
		assertResultTrue("let u : UnlimitedNatural = null in u <> *");

		assertResultFalse("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 <> u2");
	}

	public void testUnlimitedOclAsType() {
		// As demanded by the specification, OCL 2.3 (OMG 10-11-42), Section 8.2.1,
		// * when converted to Integer evaluates to invalid. As Integer conforms to
		// Real, * also has to evaluate to invalid when converted to Real.
		assertResultInvalid("*.oclAsType(Integer)");
		assertResultInvalid("*.oclAsType(Real)");
		assertResult(UnlimitedNaturalLiteralExp.UNLIMITED,
				"*.oclAsType(UnlimitedNatural)");
		assertResultInvalid("*.oclAsType(String)");
		assertResult(UnlimitedNaturalLiteralExp.UNLIMITED,
				"*.oclAsType(OclAny)");
		assertResultInvalid("*.oclAsType(OclVoid)");
		assertResultInvalid("*.oclAsType(OclInvalid)");
	}

	public void testUnlimitedOclIsInvalid() {
		assertResultFalse("*.oclIsInvalid()");
	}

	public void testUnlimitedOclIsTypeOf() {
		// From OCL 2.3 (11.5.1): "Note that UnlimitedNatural is a subclass
		// of Integer and that Integer is a subclass of Real"
		assertResultFalse("*.oclIsTypeOf(Integer)");
		assertResultFalse("*.oclIsTypeOf(Real)");
		assertResultTrue("*.oclIsTypeOf(UnlimitedNatural)");
		assertResultFalse("*.oclIsTypeOf(String)");
		assertResultFalse("*.oclIsTypeOf(OclAny)");
		assertResultFalse("*.oclIsTypeOf(OclVoid)");
		assertResultFalse("*.oclIsTypeOf(OclInvalid)");
	}

	public void testUnlimitedOclIsUndefined() {
		assertResultFalse("*.oclIsUndefined()");
	}

	public void testUnlimitedPlus() {
		assertResultInvalid("1 + *");
		assertResultInvalid("* + 1");

		assertResultInvalid("1.0 + *");
		assertResultInvalid("* + 1.0");

		assertResultInvalid("* + *");
	}

	public void testUnlimitedPlusInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in * + u");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u + *");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 + u2");
	}

	public void testUnlimitedPlusNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in * + u");
		assertResultInvalid("let u : UnlimitedNatural = null in u + *");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 + u2");
	}

	public void testUnlimitedRound() {
		assertResultInvalid("*.round()");
	}

	public void testUnlimitedRoundInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in u.round()");
	}

	public void testUnlimitedRoundNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in u.round()");
	}

	public void testUnlimitedTimes() {
		assertResultInvalid("1 * *");
		assertResultInvalid("* * 1");

		assertResultInvalid("1.0 * *");
		assertResultInvalid("* * 1.0");

		assertResultInvalid("* * *");
	}

	public void testUnlimitedTimesInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in * * u");
		assertResultInvalid("let u : UnlimitedNatural = invalid in u * *");

		assertResultInvalid("let u1 : UnlimitedNatural = invalid, u2 : UnlimitedNatural = invalid in u1 * u2");
	}

	public void testUnlimitedTimesNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in * * u");
		assertResultInvalid("let u : UnlimitedNatural = null in u * *");

		assertResultInvalid("let u1 : UnlimitedNatural = null, u2 : UnlimitedNatural = null in u1 * u2");
	}

	public void testUnlimitedToInteger() {
		assertResultInvalid("*.toInteger()");
	}

	public void testUnlimitedUnaryMinus() {
		/*
		 * FIXME OCL doesn't have a negative infinity, this should then be
		 * invalid
		 */
		assertResultInvalid("-*");
	}

	public void testUnlimitedUnaryMinusInvalid() {
		assertResultInvalid("let u : UnlimitedNatural = invalid in -u");
	}

	public void testUnlimitedUnaryMinusNull() {
		assertResultInvalid("let u : UnlimitedNatural = null in -u");
	}
}