| /******************************************************************************* |
| * Copyright (c) 2006, 2011, 2011 IBM Corporation 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 |
| * Axel Uhl (SAP AG) - Bug 342644 |
| *******************************************************************************/ |
| |
| package org.eclipse.ocl.uml.tests; |
| |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.ocl.expressions.OCLExpression; |
| import org.eclipse.ocl.types.CollectionType; |
| import org.eclipse.ocl.uml.TupleType; |
| import org.eclipse.ocl.util.Tuple; |
| import org.eclipse.uml2.uml.Class; |
| import org.eclipse.uml2.uml.Classifier; |
| import org.eclipse.uml2.uml.LiteralUnlimitedNatural; |
| import org.eclipse.uml2.uml.Operation; |
| import org.eclipse.uml2.uml.Package; |
| import org.eclipse.uml2.uml.Property; |
| import org.eclipse.uml2.uml.Type; |
| import org.eclipse.uml2.uml.UMLFactory; |
| |
| /** |
| * 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| try { |
| OCLExpression<Classifier> 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(getUMLString()); |
| |
| 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(getUMLString()); |
| |
| 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(getUMLString()); |
| |
| 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(getUMLString()); |
| |
| 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(getUMLString()); |
| |
| 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. In particular, that it is not recursive |
| * (only flattens one level). |
| */ |
| public void test_flatten() { |
| helper.setContext(getUMLString()); |
| |
| 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(getUMLString()); |
| |
| try { |
| assertTrue(check(helper, "", |
| "Set{'a', 'b', 'c', 'd'}->flatten()" + |
| " = Set{'b', 'c', 'a', 'd'}")); |
| |
| // 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{'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()); |
| } |
| } |
| |
| public void test_count() { |
| helper.setContext(getUMLInteger()); |
| |
| 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(getUMLInteger()); |
| |
| 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()); |
| } |
| } |
| |
| public void test_includes() { |
| helper.setContext(getUMLInteger()); |
| |
| 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(getUMLInteger()); |
| |
| 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(getUMLInteger()); |
| |
| 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(getUMLInteger()); |
| |
| 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(getUMLInteger()); |
| |
| 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(getUMLInteger()); |
| |
| 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(getMetaclass("Package")); |
| |
| try { |
| OCLExpression<Classifier> expr = helper |
| .createQuery("self.ownedType->union(self.nestedPackage.ownedType->asSet())->asSet()"); |
| |
| assertEquals(new java.util.HashSet<Type>(fruitPackage |
| .getOwnedTypes()), ocl.evaluate(fruitPackage, 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() { |
| Package fakePkg = umlf.createPackage(); |
| fakePkg.setName("fake"); |
| Class fake = fakePkg.createOwnedClass("Fake", false); |
| Operation getFakes = fake.createOwnedOperation( |
| "getFakes", null, null, fake); |
| getFakes.setUpper(LiteralUnlimitedNatural.UNLIMITED); |
| getFakes.setIsQuery(true); |
| |
| 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(getUMLInteger()); |
| |
| 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(getUMLInteger()); |
| |
| 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(getMetaclass("Package")); |
| |
| try { |
| OCLExpression<Classifier> expr = helper |
| .createQuery("Tuple{a = self.ownedType}"); |
| |
| assertTrue(expr.getType() instanceof TupleType); |
| TupleType tt = (TupleType) expr.getType(); |
| |
| assertEquals(1, tt.getOwnedAttributes().size()); |
| Property part = tt.getOwnedAttribute("a", null); |
| |
| assertNotNull(part); |
| assertTrue(part.getType() instanceof CollectionType<?, ?>); |
| |
| @SuppressWarnings("unchecked") |
| CollectionType<Classifier, Operation> collType = (CollectionType<Classifier, Operation>) part |
| .getType(); |
| assertSame(getMetaclass("Type"), collType.getElementType()); |
| |
| Object result = ocl.evaluate(getUMLMetamodel(), expr); |
| assertTrue(result instanceof Tuple<?, ?>); |
| |
| @SuppressWarnings("unchecked") |
| Tuple<Operation, Property> tuple = (Tuple<Operation, Property>) result; |
| |
| assertTrue(tuple.getValue("a") instanceof Collection<?>); |
| assertTrue(((Collection<?>) tuple.getValue("a")).contains(getMetaclass("Classifier"))); |
| } 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(getMetaclass("Package")); |
| |
| try { |
| OCLExpression<Classifier> expr = helper |
| .createQuery("Tuple{a = Sequence{'a', 'b', 'c'}}"); |
| |
| assertTrue(expr.getType() instanceof TupleType); |
| TupleType tt = (TupleType) expr.getType(); |
| |
| assertEquals(1, tt.getOwnedAttributes().size()); |
| Property part = tt.getOwnedAttribute("a", null); |
| |
| assertNotNull(part); |
| assertTrue(part.getType() instanceof CollectionType<?, ?>); |
| |
| @SuppressWarnings("unchecked") |
| CollectionType<Classifier, Operation> collType = (CollectionType<Classifier, Operation>) part |
| .getType(); |
| assertSame(getOCLStandardLibrary().getString(), collType |
| .getElementType()); |
| |
| Object result = ocl.evaluate(getUMLMetamodel(), expr); |
| assertTrue(result instanceof Tuple<?, ?>); |
| |
| @SuppressWarnings("unchecked") |
| Tuple<Operation, Property> tuple = (Tuple<Operation, Property>) 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 the values of operation calls of collection type are |
| * collections of the correct type. |
| */ |
| public void test_operationValueCollectionType_183667() { |
| helper.setContext(getMetaclass("Element")); |
| |
| try { |
| OCLExpression<Classifier> expr = helper |
| .createQuery("self.getKeywords()"); |
| |
| // the UML Metamodel, itself, is an element. What are its keywords? |
| Object value = ocl.evaluate(getUMLMetamodel(), expr); |
| |
| // should be a set, not an EList |
| assertTrue(value instanceof Set<?>); |
| assertFalse(value instanceof EList<?>); |
| } catch (Exception exc) { |
| fail("Failed to parse or evaluate: " + exc.getLocalizedMessage()); |
| } |
| } |
| |
| /** |
| * Tests that the values of property navigations of collection type are |
| * collections of the correct type. |
| */ |
| public void test_propertyValueCollectionType_183667() { |
| helper.setContext(getMetaclass("Element")); |
| |
| try { |
| OCLExpression<Classifier> expr = helper |
| .createQuery("self.ownedComment"); |
| |
| // the UML Metamodel, itself, is an element. What are its comments? |
| Object value = ocl.evaluate(getUMLMetamodel(), expr); |
| |
| // should be a set, not an EList |
| assertTrue(value instanceof Set<?>); |
| assertFalse(value instanceof EList<?>); |
| } catch (Exception exc) { |
| fail("Failed to parse or evaluate: " + exc.getLocalizedMessage()); |
| } |
| } |
| |
| /** |
| * Tests that operation calls coerce collection-valued arguments to the |
| * Java <code>EList</code> type. |
| */ |
| public void test_coercionOfCollectionParameters_184789() { |
| Package pkg = UMLFactory.eINSTANCE.createPackage(); |
| pkg.createOwnedClass("Foo", false); |
| pkg.createOwnedClass("Foo", false); |
| pkg.createOwnedClass("Foo", false); |
| Class bar = pkg.createOwnedClass("Bar", false); |
| |
| helper.setContext(getMetaclass("Package")); |
| |
| try { |
| OCLExpression<Classifier> expr = helper.createQuery( |
| "self.excludeCollisions(ownedType)"); |
| |
| Object value = ocl.evaluate(pkg, expr); |
| |
| assertEquals(Collections.singleton(bar), value); |
| } 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::<>(Sequence(T))</code> operation. |
| */ |
| public void test_sequenceNotEqualSignature_184327() { |
| helper.setContext(getUMLString()); |
| |
| 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()); |
| } |
| } |
| } |
