| /******************************************************************************* |
| * Copyright (c) 2007, 2018 IBM Corporation 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: |
| * IBM - Initial API and implementation |
| * E.D.Willink - Bugs 296409, 295166 |
| *******************************************************************************/ |
| |
| package org.eclipse.ocl.tests; |
| |
| import org.eclipse.emf.common.util.BasicEList; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| |
| /** |
| * Tests for usages of model features whose names coincide with "keywords" |
| * defined as reserved words by the OCL specification. |
| * |
| * @author Christian W. Damus (cdamus) |
| */ |
| @SuppressWarnings("nls") |
| public abstract class GenericKeywordsTest<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 GenericTestSuite<E, PK, T, C, CLS, DT, PT, ET, O, PM, P, PA, PR, EL, S, COA, SSA, CT> { |
| |
| PK smalltalk; |
| CLS collection; |
| CLS block; |
| protected CLS elseClass; |
| CLS clazz; |
| CLS property; |
| CLS constraint; |
| |
| @Override |
| protected void setUp() { |
| super.setUp(); |
| |
| // create a little test model for a Smalltalk-like collection class that |
| // defines operations corresponding to OCL iterators |
| smalltalk = reflection.createPackage("Smalltalk"); |
| registerPackage(smalltalk, "st", "foo://smalltalk"); |
| |
| CLS object = reflection.createOwnedClass(smalltalk, "Object", false); |
| collection = reflection.createOwnedClass(smalltalk, "Collection", false); |
| block = reflection.createOwnedClass(smalltalk, "Block", false); |
| clazz = reflection.createOwnedClass(smalltalk, "Class", false); |
| property = reflection.createOwnedClass(smalltalk, "Property", false); |
| constraint = reflection.createOwnedClass(smalltalk, "Constraint", false); |
| reflection.addSupertype(constraint, object); |
| reflection.addSupertype(property, object); |
| reflection.addSupertype(clazz, object); |
| reflection.addSupertype(block, object); |
| reflection.addSupertype(collection, object); |
| |
| ET visibilityKind = reflection.createOwnedEnumeration(smalltalk, "VisibilityKind"); |
| reflection.createOwnedLiteral(visibilityKind, "public"); |
| reflection.createOwnedLiteral(visibilityKind, "protected"); |
| reflection.createOwnedLiteral(visibilityKind, "package"); |
| reflection.createOwnedLiteral(visibilityKind, "private"); |
| |
| reflection.createOwnedAttribute(clazz, "name", reflection.getUMLString()); |
| reflection.createOwnedAttribute(clazz, "visibility", visibilityKind); |
| reflection.createOwnedReference(clazz, "package", object); |
| reflection.createOwnedAttribute(property, "isUnique", reflection.getUMLBoolean()); |
| reflection.createOwnedAttribute(property, "upper", reflection.getUMLInteger()); |
| reflection.createOwnedReference(constraint, "context", clazz); |
| |
| EList<String> names = new BasicEList<String>(1); |
| EList<T> types = new BasicEList<T>(1); |
| |
| names.add("object"); |
| types.add(object); |
| reflection.createOwnedOperation(block, "context", |
| names, types, clazz, true); |
| |
| names.set(0, "block"); |
| types.set(0, block); |
| reflection.createOwnedOperation(collection, "isUnique", |
| names, types, reflection.getUMLBoolean(), true); |
| reflection.createOwnedOperation(collection, "select", |
| names, types, collection, true); |
| |
| names.clear(); |
| types.clear(); |
| reflection.createOwnedOperation(collection, "isEmpty", |
| names, types, reflection.getUMLBoolean(), true); |
| |
| // create some qualified classifier and package names that need |
| // escaping of one or more segments. Likewise state names |
| PK nested = reflection.createNestedPackage(smalltalk, "runtime"); |
| PK contextPackage = reflection.createNestedPackage(nested, "context"); |
| |
| reflection.createOwnedClass(contextPackage, "language", false); |
| elseClass = reflection.createOwnedClass(contextPackage, "else", false); |
| reflection.createOwnedOperation(elseClass, "doIt", |
| null, null, null, false); |
| } |
| |
| public void test_isUnique_162300() { |
| assertInvariant(property, "self.isUnique implies self.upper > 1"); |
| assertInvariant(property, "isUnique implies self.upper > 1"); |
| } |
| |
| public void test_package_162300() { |
| assertInvariant(clazz, "self._package.oclIsUndefined() implies Set{VisibilityKind::protected, VisibilityKind::_package}->excludes(self.visibility)"); |
| assertInvariant(clazz, "_package.oclIsUndefined() implies Set{VisibilityKind::protected, VisibilityKind::_package}->excludes(self.visibility)"); |
| assertInvariant(clazz, "_'package'.oclIsUndefined() implies Set{VisibilityKind::protected, VisibilityKind::_package}->excludes(self.visibility)"); |
| } |
| |
| public void test_context_162300() { |
| assertInvariant(constraint, "self._context <> null implies _context.oclIsKindOf(Class)"); |
| assertInvariant(constraint, "_context <> null implies self._context.oclIsKindOf(Class)"); |
| assertInvariant(constraint, "_'con''te' 'x'\n't' <> null implies self._context.oclIsKindOf(Class)"); |
| } |
| |
| public void test_isUniqueOperation_162300() { |
| createVariableInEnvironment("aBlock", block); |
| assertInvariant(collection, "self.isUnique(aBlock)"); |
| assertInvariant(collection, "isUnique(aBlock)"); |
| } |
| |
| public void test_selectOperation_162300() { |
| createVariableInEnvironment("aBlock", block); |
| assertInvariant(collection, "self.select(aBlock).isEmpty()"); |
| assertInvariant(collection, "select(aBlock).isEmpty()"); |
| } |
| |
| public void test_contextOperation_162300() { |
| assertInvariant(block, "self._context(self).name = 'Block'"); |
| assertInvariant(block, "_context(self).name = 'Block'"); |
| assertInvariant(block, "_'context'(self).name = 'Block'"); |
| } |
| |
| public void test_reservedPackageName_183362() { |
| assertInvariant(block, "Smalltalk::runtime::_context::language.allInstances()->notEmpty()"); |
| } |
| |
| public void test_reservedPackageName_packageContext_183362() { |
| createDocument("package Smalltalk::runtime::_context context language inv: true endpackage"); |
| } |
| |
| public void test_reservedClassName_183362() { |
| assertInvariant(elseClass, "let e : _else = self in _else.allInstances()->forAll(oclIsKindOf(_else))"); |
| assertInvariant(elseClass, "self.oclIsKindOf(_context::_else)"); |
| } |
| |
| public void test_reservedClassName_operationContext_183362() { |
| createDocument("package Smalltalk context runtime::_context::_else::doIt() : pre: true endpackage"); |
| createDocument("package Smalltalk::runtime::_context context _else::doIt() : pre: true endpackage"); |
| } |
| |
| public void test_unexpectedCharacter_283509() { |
| helper.setContext(property); |
| |
| try { |
| helper.createInvariant("self = #self"); |
| fail("Missing exception"); |
| } catch (Exception e) { |
| assertEquals("2:6 \"#\" unexpected character ignored", e.getLocalizedMessage()); |
| } |
| } |
| } |