tests/org.eclipse.ocl.ecore.tests/src/org/eclipse/ocl/ecore/tests/CollectionsTest.java

/*******************************************************************************
 * Copyright (c) 2006, 2011, 2011 IBM Corporation, Zeligsoft Inc., Open Canarias S.L. 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:
 *   IBM - Initial API and implementation
 *   Zeligsoft - Bug 244946
 *   Adolfo Sanchez-Barbudo Herrera - Bug 260403
 *   Axel Uhl (SAP AG) - Bug 342644
 *******************************************************************************/

package org.eclipse.ocl.ecore.tests;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EParameter;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.ETypedElement;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.ocl.TypeResolver;
import org.eclipse.ocl.ecore.TupleType;
import org.eclipse.ocl.expressions.CollectionKind;
import org.eclipse.ocl.expressions.ExpressionsFactory;
import org.eclipse.ocl.expressions.ExpressionsPackage;
import org.eclipse.ocl.expressions.OCLExpression;
import org.eclipse.ocl.expressions.Variable;
import org.eclipse.ocl.options.ParsingOptions;
import org.eclipse.ocl.types.CollectionType;
import org.eclipse.ocl.types.OCLStandardLibrary;
import org.eclipse.ocl.util.Tuple;
import org.eclipse.ocl.util.TypeUtil;

/**
 * Tests for collection types.
 * 
 * @author Christian W. Damus (cdamus)
 */
@SuppressWarnings("nls")
public class CollectionsTest
		extends AbstractTestSuite {

	/**
	 * Tests the insertAt() operation for sequences.
	 */
	public void test_insertAt_sequence_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Sequence{'a', 'b', 'd', 'e'}->insertAt(3, 'c')");

			List<?> result = (List<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{
				"a", "b", "c", "d", "e"});

			assertEquals(expected, result);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the insertAt() operation for ordered sets.
	 */
	public void test_insertAt_orderedSet_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("OrderedSet{'a', 'b', 'd', 'e'}->insertAt(3, 'c')");

			Set<?> result = (Set<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{
				"a", "b", "c", "d", "e"});

			assertEquals(expected, new java.util.ArrayList<Object>(result));

			// no duplicates; result is exactly equivalent (order preserved)

			expr = helper
				.createQuery("OrderedSet{'a', 'b', 'c', 'd', 'e'}->insertAt(5, 'c')");

			result = (Set<?>) ocl.evaluate("", expr);

			expected = Arrays.asList(new Object[]{"a", "b", "c", "d", "e"});

			assertEquals(expected, new java.util.ArrayList<Object>(result));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the prepend() operation for sequences.
	 */
	public void test_prepend_sequence_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Sequence{'a', 'b', 'd', 'e'}->prepend('c')");

			List<?> result = (List<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{
				"c", "a", "b", "d", "e"});

			assertEquals(expected, result);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the prepend() operation for ordered sets.
	 */
	public void test_prepend_orderedSet_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("OrderedSet{'a', 'b', 'd', 'e'}->prepend('c')");

			Set<?> result = (Set<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{
				"c", "a", "b", "d", "e"});

			assertEquals(expected, new java.util.ArrayList<Object>(result));

			// no duplicates; result has prepended element first

			expr = helper
				.createQuery("OrderedSet{'a', 'b', 'c', 'd', 'e'}->prepend('c')");

			result = (Set<?>) ocl.evaluate("", expr);

			expected = Arrays.asList(new Object[]{"c", "a", "b", "d", "e"});

			assertEquals(expected, new java.util.ArrayList<Object>(result));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the append() operation for sequences.
	 */
	public void test_append_sequence_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Sequence{'a', 'b', 'd', 'e'}->append('c')");

			List<?> result = (List<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{
				"a", "b", "d", "e", "c"});

			assertEquals(expected, result);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the append() operation for ordered sets.
	 */
	public void test_append_orderedSet_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("OrderedSet{'a', 'b', 'd', 'e'}->append('c')");

			Set<?> result = (Set<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{
				"a", "b", "d", "e", "c"});

			assertEquals(expected, new java.util.ArrayList<Object>(result));

			// no duplicates; appended element is at end

			expr = helper
				.createQuery("OrderedSet{'a', 'b', 'c', 'd', 'e'}->append('c')");

			result = (Set<?>) ocl.evaluate("", expr);

			expected = Arrays.asList(new Object[]{"a", "b", "d", "e", "c"});

			assertEquals(expected, new java.util.ArrayList<Object>(result));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the including() operation for sequences.
	 */
	public void test_including_sequence_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Sequence{'a', 'b', 'd', 'e'}->including('c')");

			List<?> result = (List<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{
				"a", "b", "d", "e", "c"});

			assertEquals(expected, result);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the including() operation for ordered sets.
	 */
	public void test_including_orderedSet_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("OrderedSet{'a', 'b', 'd', 'e'}->including('c')");

			Set<?> result = (Set<?>) ocl.evaluate("", expr);

			Set<?> expected = new java.util.HashSet<Object>(Arrays
				.asList(new Object[]{"a", "b", "d", "e", "c"}));

			assertEquals(expected, result);

			// no duplicates

			expr = helper
				.createQuery("OrderedSet{'a', 'b', 'c', 'd', 'e'}->including('c')");

			result = (Set<?>) ocl.evaluate("", expr);

			expected = new java.util.HashSet<Object>(Arrays
				.asList(new Object[]{"a", "b", "c", "d", "e"}));

			assertEquals(expected, result);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the excluding() operation for sequences.
	 */
	public void test_excluding_sequence_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Sequence{'a', 'b', 'c', 'd', 'e'}->excluding('c')");

			List<?> result = (List<?>) ocl.evaluate("", expr);

			List<?> expected = Arrays.asList(new Object[]{"a", "b", "d", "e"});

			assertEquals(expected, result);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the excluding() operation for ordered sets.
	 */
	public void test_excluding_orderedSet_126722() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("OrderedSet{'a', 'b', 'c', 'd', 'e'}->excluding('c')");

			Set<?> result = (Set<?>) ocl.evaluate("", expr);

			Set<?> expected = new java.util.HashSet<Object>(Arrays
				.asList(new Object[]{"a", "b", "d", "e"}));

			assertEquals(expected, result);

			// just for fun, try excluding an already excluded element

			expr = helper
				.createQuery("OrderedSet{'a', 'b', 'd', 'e'}->excluding('c')");

			result = (Set<?>) ocl.evaluate("", expr);

			expected = new java.util.HashSet<Object>(Arrays
				.asList(new Object[]{"a", "b", "d", "e"}));

			assertEquals(expected, result);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_first() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Sequence{'a', 'b', 'c', 'd', 'e'}->first() = 'a'"));

			assertTrue(check(helper, "",
				"OrderedSet{'a', 'b', 'c', 'd', 'e'}->first() = 'a'"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_last() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Sequence{'a', 'b', 'c', 'd', 'e'}->last() = 'e'"));

			assertTrue(check(helper, "",
				"OrderedSet{'a', 'b', 'c', 'd', 'e'}->last() = 'e'"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_at() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Sequence{'a', 'b', 'c', 'd', 'e'}->at(3) = 'c'"));

			assertTrue(check(helper, "",
				"OrderedSet{'a', 'b', 'c', 'd', 'e'}->at(3)= 'c'"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_indexOf() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Sequence{'a', 'b', 'c', 'd', 'e'}->indexOf('c') = 3"));

			assertTrue(check(helper, "",
				"OrderedSet{'a', 'b', 'c', 'd', 'e'}->indexOf('c')= 3"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_subsequence_suborderedset() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Sequence{'a', 'b', 'c', 'd', 'e'}->subSequence(2, 4)" +
					" = Sequence{'b', 'c', 'd'}"));

			assertTrue(check(helper, "",
				"OrderedSet{'a', 'b', 'c', 'd', 'e'}->subOrderedSet(2, 4)" +
					" = OrderedSet{'b', 'c', 'd'}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Test the flatten() operation on a single level of collection nesting.
	 */
	public void test_flatten() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Set{Sequence{'a', 'b'}, Sequence{'b', 'c', 'd'}}->flatten()" +
					" = Set{'b', 'c', 'a', 'd'}"));

			assertTrue(check(helper,
				"",
				"OrderedSet{Sequence{'a', 'b'}, Sequence{'b', 'c', 'd'}}->flatten()" +
					" = OrderedSet{'a', 'b', 'c', 'd'}"));

			assertTrue(check(helper,
				"",
				"Sequence{OrderedSet{'a', 'b', 'd'}, OrderedSet{'b', 'c', 'd'}}->flatten()" +
					" = Sequence{'a', 'b', 'd', 'b', 'c', 'd'}"));

			assertTrue(check(helper, "",
				"Bag{Bag{'b', 'a', 'b'}, Bag{'b', 'a', 'c', 'd'}}->flatten()" +
					" = Bag{'a', 'a', 'b', 'b', 'b', 'c', 'd'}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Test the flatten() operation on collections not containing collections.
	 */
	public void test_flatten_notNested() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Set{'a', 'b', 'c', 'd'}->flatten()" +
					" = Set{'b', 'c', 'a', 'd'}"));

			// Collections of different kind are not equal. Our
			// implementation chooses to flatten an OrderedSet into an OrderedSet
			// as Section A.2.5.8 of OCL 2.3 (OMG 10-11-42) leaves it
			// unclear.
			assertFalse(check(helper, "",
				"OrderedSet{'a', 'b', 'b', 'c', 'd'}->flatten()" +
					" = Set{'b', 'c', 'a', 'd'}"));
			assertTrue(check(helper, "",
				"OrderedSet{'a', 'b', 'b', 'c', 'd'}->flatten()" +
					" = OrderedSet{'a', 'b', 'c', 'd'}"));

			assertTrue(check(helper, "",
				"Sequence{'a', 'b', 'd', 'b', 'c', 'd'}->flatten()" +
					" = Sequence{'a', 'b', 'd', 'b', 'c', 'd'}"));

			assertTrue(check(helper, "",
				"Bag{'b', 'a', 'b', 'b', 'a', 'c', 'd'}->flatten()" +
					" = Bag{'a', 'a', 'b', 'b', 'b', 'c', 'd'}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the flatten() operation on an empty source collection.
	 */
	public void test_flatten_emptySource_195252() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Set{}->flatten()" +
					" = Set{}"));

			// Collections of different kind are not equal. The behavior
			// of the flatten() operation on OrderedSet is unspecified
			// in OCL 2.3 (OMG 10-11-42) section A.2.5.8, and we choose
			// to flatten an OrderedSet into an OrderedSet.
			assertFalse(check(helper, "",
				"OrderedSet{}->flatten()" +
					" = Set{}"));
			assertTrue(check(helper, "",
				"OrderedSet{}->flatten()" +
					" = OrderedSet{}"));

			assertTrue(check(helper, "",
				"Sequence{}->flatten()" +
					" = Sequence{}"));

			assertTrue(check(helper, "",
				"Bag{}->flatten()" +
					" = Bag{}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the flatten() operation on a source collection that contains empty
	 * collections.
	 */
	public void test_flatten_emptyChildren() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Set{Set{}, Set{}}->flatten()" +
					" = Set{}"));

			assertTrue(check(helper, "",
				"OrderedSet{OrderedSet{}, OrderedSet{}}->flatten()" +
					" = OrderedSet{}"));

			assertTrue(check(helper, "",
				"Sequence{Sequence{}, Sequence{}}->flatten()" +
					" = Sequence{}"));

			assertTrue(check(helper, "",
				"Bag{Bag{}, Bag{}}->flatten()" +
					" = Bag{}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Test that the flatten() operation is recursive.
	 */
	public void test_flatten_recursive_217461() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper,
				"",
				"Set{Sequence{Set{'a'}, Set{'b'}}, Sequence{Set{'b', 'c'}, Set{'d'}}}->flatten()" +
					" = Set{'b', 'c', 'a', 'd'}"));

			assertTrue(check(helper,
				"",
				"OrderedSet{Sequence{Set{'a'}, Set{'b'}}, Sequence{Set{'b', 'c'}, Set{'d'}}}->flatten()" +
					" = OrderedSet{'a', 'b', 'c', 'd'}"));

			assertTrue(check(helper,
				"",
				"Sequence{OrderedSet{Sequence{'a', 'b'}, Sequence{'d'}}, OrderedSet{Sequence{'b', 'c'}, Sequence{'d'}}}->flatten()" +
					" = Sequence{'a', 'b', 'd', 'b', 'c', 'd'}"));

			assertTrue(check(helper,
				"",
				"Bag{Bag{Set{'b', 'a'}, Set{'b'}}, Bag{Set{'b', 'a'}, Set{'c', 'd'}}}->flatten()" +
					" = Bag{'a', 'a', 'b', 'b', 'b', 'c', 'd'}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the flatten() operation on a source collection that contains empty
	 * collections at a greater level of nesting than the first.
	 */
	public void test_flatten_emptyChildrenRecursive_217461() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Set{Set{Sequence{}}, Set{Sequence{}, Sequence{}}}->flatten()" +
					" = Set{}"));

			assertTrue(check(helper,
				"",
				"OrderedSet{OrderedSet{Sequence{}, Sequence{}}, OrderedSet{Sequence{}, Sequence{}}}->flatten()" +
					" = OrderedSet{}"));

			assertTrue(check(helper,
				"",
				"Sequence{Sequence{Sequence{}, Sequence{}}, Sequence{Sequence{}, Sequence{}}}->flatten()" +
					" = Sequence{}"));

			assertTrue(check(helper,
				"",
				"Bag{Bag{Sequence{}, Sequence{}}, Bag{Sequence{}, Sequence{}}}->flatten()" +
					" = Bag{}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_count() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Sequence{1, 2, 3, 3, 4, 5}->count(3) = 2"));

			assertTrue(check(helper, "",
				"Sequence{1, 2, 3, 3, 4, 5}->count(6) = 0"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3, 3, 4, 5}->count(3) = 1"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3, 3, 4, 5}->count(6) = 0"));

			assertTrue(check(helper, "",
				"Set{1, 2, 3, 3, 4, 5}->count(3) = 1"));

			assertTrue(check(helper, "",
				"Set{1, 2, 3, 3, 4, 5}->count(6) = 0"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 3, 3, 4, 5}->count(3) = 2"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 3, 3, 4, 5}->count(6) = 0"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_sum() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Sequence{1, 2, 3, 3, 4, 5}->sum() = 18"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3, 3, 4, 5}->sum() = 15"));

			assertTrue(check(helper, "",
				"Set{1, 2, 3, 3, 4, 5}->sum() = 15"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 3, 3, 4, 5}->sum() = 18"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that the sum() iterator returns integer zero for an empty
	 * collection of integers.
	 */
	public void test_sum_emptyIntegerCollection_204753() {
		helper.setContext(EcorePackage.Literals.EINT);

		Integer zero = new Integer(0);

		try {
			assertEquals(zero, evaluate(helper, "",
				"let s : Sequence(Integer) = Sequence{} in s->sum()"));

			assertEquals(zero, evaluate(helper, "",
				"let s : OrderedSet(Integer) = OrderedSet{} in s->sum()"));

			assertEquals(zero, evaluate(helper, "",
				"let s : Set(Integer) = Set{} in s->sum()"));

			assertEquals(zero, evaluate(helper, "",
				"let s : Bag(Integer) = Bag{} in s->sum()"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that the sum() iterator returns integer zero for an empty
	 * collection of reals.
	 */
	public void test_sum_emptyRealCollection_204753() {
		helper.setContext(EcorePackage.Literals.EINT);

		Double zero = new Double(0.0);

		try {
			assertEquals(zero, evaluate(helper, "",
				"let s : Sequence(Real) = Sequence{} in s->sum()"));

			assertEquals(zero, evaluate(helper, "",
				"let s : OrderedSet(Real) = OrderedSet{} in s->sum()"));

			assertEquals(zero, evaluate(helper, "",
				"let s : Set(Real) = Set{} in s->sum()"));

			assertEquals(zero, evaluate(helper, "",
				"let s : Bag(Real) = Bag{} in s->sum()"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_includes() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Sequence{1, 2, 3, 3, 4, 5}->includes(3)"));

			assertFalse(check(helper, "",
				"Sequence{1, 2, 3, 3, 4, 5}->includes(6)"));

			assertTrue(check(helper, "",
				"Set{1, 2, 3, 3, 4, 5}->includes(3)"));

			assertFalse(check(helper, "",
				"Set{1, 2, 3, 3, 4, 5}->includes(6)"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3, 3, 4, 5}->includes(3)"));

			assertFalse(check(helper, "",
				"OrderedSet{1, 2, 3, 3, 4, 5}->includes(6)"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 3, 3, 4, 5}->includes(3)"));

			assertFalse(check(helper, "",
				"Bag{1, 2, 3, 3, 4, 5}->includes(6)"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_includesAll() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Sequence{1, 2, 3, 3, 4, 5}->includesAll(Sequence{1, 3})"));

			assertFalse(check(helper, "",
				"Sequence{1, 2, 3, 3, 4, 5}->includesAll(Sequence{1, 6})"));

			assertTrue(check(helper, "",
				"Set{1, 2, 3, 3, 4, 5}->includesAll(Set{1, 3})"));

			assertFalse(check(helper, "",
				"Set{1, 2, 3, 3, 4, 5}->includesAll(Set{1, 6})"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3, 3, 4, 5}->includesAll(OrderedSet{1, 3})"));

			assertFalse(check(helper, "",
				"OrderedSet{1, 2, 3, 3, 4, 5}->includesAll(OrderedSet{1, 6})"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 3, 3, 4, 5}->includesAll(Bag{1, 3})"));

			assertFalse(check(helper, "",
				"Bag{1, 2, 3, 3, 4, 5}->includesAll(Bag{1, 6})"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_union() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Set{1, 2, 3}->union(Set{3, 4, 5})" +
					" = Set{1, 2, 3, 4, 5}"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3}->union(Set{3, 4, 5})" +
					" = Set{1, 2, 3, 4, 5}"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 2, 3}->union(Set{3, 4, 5})" +
					" = Bag{1, 2, 2, 3, 3, 4, 5}"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 3}->union(Bag{3, 3, 4, 5})" +
					" = Bag{1, 2, 3, 3, 3, 4, 5}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_intersection() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Set{1, 2, 3}->intersection(Set{3, 4, 5})" +
					" = Set{3}"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3}->intersection(Set{3, 4, 5})" +
					" = Set{3}"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 2, 3, 3, 3}->intersection(Bag{3, 3, 4, 5})" +
					" = Bag{3, 3}"));

			assertTrue(check(helper, "",
				"Bag{1, 2, 2, 3, 3, 3}->intersection(Set{3, 4, 5})" +
					" = Set{3}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_difference() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Set{1, 2, 3} - Set{3, 4, 5}" +
					" = Set{1, 2}"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3} - Set{3, 4, 5}" +
					" = Set{1, 2}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	public void test_symmetricDifference() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			assertTrue(check(helper, "",
				"Set{1, 2, 3}->symmetricDifference(Set{3, 4, 5})" +
					" = Set{1, 2, 4, 5}"));

			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3}->symmetricDifference(Set{3, 4, 5})" +
					" = Set{1, 2, 4, 5}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that dot notation can be used successively to navigate multiple
	 * collection-type references.
	 */
	public void test_dotNavigationOfReferenceCollections_130239() {
		helper.setContext(EcorePackage.Literals.EPACKAGE);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("self.eClassifiers->union(self.eSubpackages.eClassifiers->asSet())->asSet()");

			assertEquals(new java.util.HashSet<EClassifier>(
				ExpressionsPackage.eINSTANCE.getEClassifiers()), ocl.evaluate(
				ExpressionsPackage.eINSTANCE, expr));
		} catch (Exception exc) {
			fail("Failed to parse or evaluate: " + exc.getLocalizedMessage());
		}
	}

	/**
	 * Tests that dot notation can be used successively to navigate multiple
	 * collection-type operations.
	 */
	public void test_dotNavigationOfOperationCollections_130239() {
		EPackage fakePkg = EcoreFactory.eINSTANCE.createEPackage();
		fakePkg.setName("fake");
		EClass fake = EcoreFactory.eINSTANCE.createEClass();
		fake.setName("Fake");
		fakePkg.getEClassifiers().add(fake);
		EOperation getFakes = EcoreFactory.eINSTANCE.createEOperation();
		getFakes.setName("getFakes");
		getFakes.setEType(fake);
		getFakes.setUpperBound(ETypedElement.UNBOUNDED_MULTIPLICITY);
		fake.getEOperations().add(getFakes);

		helper.setContext(fake);

		try {
			helper
				.createQuery("self.getFakes()->union(self.getFakes().getFakes()->asSet())");
		} catch (Exception exc) {
			fail("Failed to parse or evaluate: " + exc.getLocalizedMessage());
		}
	}

	/**
	 * Tests that the syntax for collection ranges is supported.
	 */
	public void test_collectionRange_152208() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			Collection<?> result = (Collection<?>) evaluate(helper,
				new Integer(1), "Sequence{1 .. 10}");

			for (int i = 1; i <= 10; i++) {
				assertTrue(result.contains(new Integer(i)));
			}

			result = (Collection<?>) evaluate(helper, new Integer(1),
				"Sequence{1, (2+1)..(3+4), 10}");

			assertTrue(result.contains(new Integer(1)));
			for (int i = 3; i <= 7; i++) {
				assertTrue(result.contains(new Integer(i)));
			}
			assertTrue(result.contains(new Integer(10)));

			// try the first expression without spaces (needed a grammar change)
			result = (Collection<?>) evaluate(helper, new Integer(1),
				"Sequence{1..10}");

			for (int i = 1; i <= 10; i++) {
				assertTrue(result.contains(new Integer(i)));
			}

			// and a negation, too (the same grammar change)
			result = (Collection<?>) evaluate(helper, new Integer(1),
				"Sequence{-20, -10..-1, 1}");

			assertTrue(result.contains(new Integer(-20)));
			for (int i = -10; i <= -1; i++) {
				assertTrue(result.contains(new Integer(i)));
			}
			assertTrue(result.contains(new Integer(1)));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}


	/**
	 * Tests that the a singleton collection range is iterable.
	 */
	public void test_collectionRange_330489() {
		helper.setContext(EcorePackage.Literals.EINT);

		try {
			Collection<?> result = (Collection<?>) evaluate(helper,
				new Integer(1), "Sequence{1 .. 1}");
			assertEquals(1, result.size());
			assertTrue(result.contains(new Integer(1)));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests the support for tuples whose parts are collections that are not
	 * collection literals.
	 */
	public void test_tupleWithCollectionPart_175490() {
		helper.setContext(EcorePackage.Literals.EPACKAGE);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Tuple{a = self.eClassifiers}");

			assertTrue(expr.getType() instanceof TupleType);
			TupleType tt = (TupleType) expr.getType();

			assertEquals(1, tt.getEStructuralFeatures().size());
			EStructuralFeature part = tt.getEStructuralFeature("a");

			assertNotNull(part);
			assertTrue(part.getEType() instanceof CollectionType<?, ?>);

			@SuppressWarnings("unchecked")
			CollectionType<EClassifier, EOperation> collType = (CollectionType<EClassifier, EOperation>) part
				.getEType();
			assertSame(EcorePackage.Literals.ECLASSIFIER, collType
				.getElementType());

			Object result = ocl.evaluate(EcorePackage.eINSTANCE, expr);
			assertTrue(result instanceof Tuple<?, ?>);

			@SuppressWarnings("unchecked")
			Tuple<EOperation, EStructuralFeature> tuple = (Tuple<EOperation, EStructuralFeature>) result;

			assertTrue(tuple.getValue("a") instanceof Collection<?>);
			assertTrue(((Collection<?>) tuple.getValue("a")).contains(EcorePackage.Literals.ECLASSIFIER));
		} catch (Exception exc) {
			fail("Failed to parse or evaluate: " + exc.getLocalizedMessage());
		}
	}

	/**
	 * Tests the support for tuples whose parts are collections that are
	 * collection literals.
	 */
	public void test_tupleWithCollectionLiteralPart_175490() {
		helper.setContext(EcorePackage.Literals.EPACKAGE);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Tuple{a = Sequence{'a', 'b', 'c'}}");

			assertTrue(expr.getType() instanceof TupleType);
			TupleType tt = (TupleType) expr.getType();

			assertEquals(1, tt.getEStructuralFeatures().size());
			EStructuralFeature part = tt.getEStructuralFeature("a");

			assertNotNull(part);
			assertTrue(part.getEType() instanceof CollectionType<?, ?>);

			@SuppressWarnings("unchecked")
			CollectionType<EClassifier, EOperation> collType = (CollectionType<EClassifier, EOperation>) part
				.getEType();
			assertSame(getOCLStandardLibrary().getString(), collType
				.getElementType());

			Object result = ocl.evaluate(EcorePackage.eINSTANCE, expr);
			assertTrue(result instanceof Tuple<?, ?>);

			@SuppressWarnings("unchecked")
			Tuple<EOperation, EStructuralFeature> tuple = (Tuple<EOperation, EStructuralFeature>) result;

			assertTrue(tuple.getValue("a") instanceof Collection<?>);
			assertTrue(((Collection<?>) tuple.getValue("a")).contains("b"));
		} catch (Exception exc) {
			fail("Failed to parse or evaluate: " + exc.getLocalizedMessage());
		}
	}

	/**
	 * Tests that passing OclInvalid to a collection operation results in
	 * OclInvalid, not a ClassCastException.
	 */
	public void test_passOclInvalidToCollectionOperation_183144() {
		helper.setContext(EcorePackage.Literals.EPACKAGE);

		Variable<EClassifier, EParameter> var = ExpressionsFactory.eINSTANCE
			.createVariable();
		var.setName("var");
		var.setType(TypeUtil.resolveSetType(ocl.getEnvironment(),
			getOCLStandardLibrary().getString()));

		ocl.getEnvironment().addElement(var.getName(), var, true);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Set{'a', 'b', 'c'}->union(var)");

			ocl.getEvaluationEnvironment().add("var", getInvalid());
			Object result = ocl.evaluate(EcorePackage.eINSTANCE, expr);
			assertInvalid(result);
		} catch (Exception exc) {
			fail("Failed to parse or evaluate: " + exc.getLocalizedMessage());
		}
	}

	/**
	 * Tests that passing null to a collection operation (for which null is not
	 * appropriate) results in OclInvalid, not a NullPointerException. For
	 * example, <code>includes(null)</code> is OK but <code>union(null)</code>
	 * is not.
	 */
	public void test_passNullToCollectionOperation_183144() {
		helper.setContext(EcorePackage.Literals.EPACKAGE);

		Variable<EClassifier, EParameter> var = ExpressionsFactory.eINSTANCE
			.createVariable();
		var.setName("var");
		var.setType(TypeUtil.resolveSetType(ocl.getEnvironment(),
			getOCLStandardLibrary().getString()));

		ocl.getEnvironment().addElement(var.getName(), var, true);

		try {
			OCLExpression<EClassifier> expr = helper
				.createQuery("Set{'a', 'b', 'c'}->union(var)");

			ocl.getEvaluationEnvironment().add("var", null);
			Object result = ocl.evaluate(EcorePackage.eINSTANCE, expr);
			assertInvalid(result);

			expr = helper.createQuery("Set{'a', 'b', 'c'}->includes(null)");
			result = ocl.evaluate(EcorePackage.eINSTANCE, expr);
			assertEquals(Boolean.FALSE, result);
		} catch (Exception exc) {
			fail("Failed to parse or evaluate: " + exc.getLocalizedMessage());
		}
	}

	/**
	 * Tests that the OCL Standard Library defines the correct signature for the
	 * <code>Sequence::&lt;&gt;(Sequence(T))</code> operation.
	 */
	public void test_sequenceNotEqualSignature_184327() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertTrue(check(helper, "",
				"Sequence{1, 2, 3} <> Sequence{3, 2, 1}"));

			assertFalse(check(helper, "",
				"Sequence{1, 2, 3} <> Sequence{1, 2, 3}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that in ordering of UnlimitedNatural::UNLIMITED is consider greatest element
	 */
	public void test_sortedByOverUnlimitedNatural() {
		helper.setContext(EcorePackage.Literals.ECLASS);

		try {
			assertTrue(check(helper, EcorePackage.Literals.ECLASS,
				"self.eAllStructuralFeatures->sortedBy(upperBound)->first().upperBound = 1"+
				" and self.eAllStructuralFeatures->sortedBy(upperBound)->last().upperBound = *"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that evaluating an EEList-typed operation call does not result in a
	 * scalar value.
	 */
	public void test_valueOfOperationTypedByEEList_202611() {
		ParsingOptions.setOption(ocl.getEnvironment(), ParsingOptions
			.implicitRootClass(ocl.getEnvironment()),
			EcorePackage.Literals.EOBJECT);
		helper.setContext(EcorePackage.Literals.EPACKAGE);

		try {
			OCLExpression<EClassifier> expr = helper
			.createQuery("self.eContents()");
			assertTrue(expr.getType() instanceof CollectionType<?, ?>);

			CollectionType<?, ?> actualType = (CollectionType<?, ?>) expr
				.getType();

			// should be a Sequence(OclAny)
			assertSame(CollectionKind.SEQUENCE_LITERAL, actualType.getKind());
			// assertSame(getOCLStandardLibrary().getOclAny(),
			// actualType.getElementType());

			// should be the right value
			Object value = ocl.evaluate(EcorePackage.eINSTANCE, expr);
			assertEquals(EcorePackage.eINSTANCE.eContents(), value);
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that generic collection types (those whose element type is
	 * <tt>T</tt>) resolve correctly to the OCL Standard Library types.
	 */
	public void test_resolutionOfGenericCollectionTypes_222581() {
		TypeResolver<EClassifier, EOperation, EStructuralFeature> resolver = ocl
			.getEnvironment().getTypeResolver();
		Resource resource = resolver.getResource();

		OCLStandardLibrary<EClassifier> stdlib = ocl.getEnvironment()
			.getOCLStandardLibrary();
		EClassifier t = stdlib.getT();

		CollectionType<EClassifier, EOperation> collectionType;

		collectionType = resolver.resolveCollectionType(
			CollectionKind.SET_LITERAL, t);
		assertNotSame(resource, collectionType.eResource());
		assertSame(stdlib.getSet(), collectionType);

		collectionType = resolver.resolveCollectionType(
			CollectionKind.ORDERED_SET_LITERAL, t);
		assertNotSame(resource, collectionType.eResource());
		assertSame(stdlib.getOrderedSet(), collectionType);

		collectionType = resolver.resolveCollectionType(
			CollectionKind.SEQUENCE_LITERAL, t);
		assertNotSame(resource, collectionType.eResource());
		assertSame(stdlib.getSequence(), collectionType);

		collectionType = resolver.resolveCollectionType(
			CollectionKind.BAG_LITERAL, t);
		assertNotSame(resource, collectionType.eResource());
		assertSame(stdlib.getBag(), collectionType);

		collectionType = resolver.resolveCollectionType(
			CollectionKind.COLLECTION_LITERAL, t);
		assertNotSame(resource, collectionType.eResource());
		assertSame(stdlib.getCollection(), collectionType);
	}

	/**
	 * Tests that an invalid "at" index results in OclInvalid, not null.
	 */
	public void test_invalidAtIndex_orderedSet_244946() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertInvalid(evaluate(helper, "",
				"OrderedSet{1, 2, 3}->at(0)"));

			assertInvalid(evaluate(helper, "",
				"OrderedSet{1, 2, 3}->at(4)"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that an invalid "at" index results in OclInvalid, not null.
	 */
	public void test_invalidAtIndex_sequence_244946() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertInvalid(evaluate(helper, "",
				"Sequence{1, 2, 3}->at(0)"));

			assertInvalid(evaluate(helper, "",
				"Sequence{1, 2, 3}->at(4)"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that an invalid "insertAt" index results in OclInvalid, not null.
	 */
	public void test_invalidInsertAtIndex_orderedSet_244946() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			// this is OK, as it effectively appends
			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3}->insertAt(4, 4) = OrderedSet{1, 2, 3, 4}"));
			// and this prepends
			assertTrue(check(helper, "",
				"OrderedSet{1, 2, 3}->insertAt(1, 0) = OrderedSet{0, 1, 2, 3}"));

			// this is not
			assertInvalid(evaluate(helper, "",
				"OrderedSet{1, 2, 3}->insertAt(5, 5)"));
			assertInvalid(evaluate(helper, "",
				"OrderedSet{1, 2, 3}->insertAt(0, 0)"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that an invalid "insertAt" index results in OclInvalid, not null.
	 */
	public void test_invalidInsertAtIndex_sequence_244946() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			// this is OK, as it effectively appends
			assertTrue(check(helper, "",
				"Sequence{1, 2, 3}->insertAt(4, 4) = Sequence{1, 2, 3, 4}"));
			// and this prepends
			assertTrue(check(helper, "",
				"Sequence{1, 2, 3}->insertAt(1, 0) = Sequence{0, 1, 2, 3}"));

			// this is not
			assertInvalid(evaluate(helper, "",
				"Sequence{1, 2, 3}->insertAt(5, 5)"));
			assertInvalid(evaluate(helper, "",
				"Sequence{1, 2, 3}->insertAt(0, 0)"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that an invalid "subOrderedSet" range results in OclInvalid, not
	 * null.
	 */
	public void test_invalidSubOrderedSetRange_244946() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertInvalid(evaluate(helper, "",
				"OrderedSet{1, 2, 3}->subOrderedSet(0, 2)"));

			assertInvalid(evaluate(helper, "",
				"OrderedSet{1, 2, 3}->subOrderedSet(2, 4)"));

			assertInvalid(evaluate(helper, "",
				"OrderedSet{1, 2, 3}->subOrderedSet(2, 1)"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Tests that an invalid "subSequence" range results in OclInvalid, not
	 * null.
	 */
	public void test_invalidSubSequenceRange_244946() {
		helper.setContext(EcorePackage.Literals.ESTRING);

		try {
			assertInvalid(evaluate(helper, "",
				"Sequence{1, 2, 3}->subSequence(0, 2)"));

			assertInvalid(evaluate(helper, "",
				"Sequence{1, 2, 3}->subSequence(2, 4)"));

			assertInvalid(evaluate(helper, "",
				"Sequence{1, 2, 3}->subSequence(2, 1)"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}

	/**
	 * Test to check the collections which are declared as OclAny type.
	 */
	public void test_oclAnyCollections_260403() {

		try {
			assertTrue(check("let aSeq : Sequence(OclAny) = Sequence {'aString'} in" +
				" aSeq->including(10) = Sequence {'aString',10}"));
		} catch (Exception e) {
			fail("Failed to parse or evaluate: " + e.getLocalizedMessage());
		}
	}
}