/*******************************************************************************
* 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()" +
" = Set{'b', 'c', 'a', '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());
}
}
}