/*******************************************************************************
* Copyright (c) 2005, 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
* Zeligsoft - Bug 248869
* E.D.Willink - Bug 288040 xor/or/and
*******************************************************************************/
package org.eclipse.ocl.uml.tests;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
import org.eclipse.ocl.ParserException;
import org.eclipse.ocl.SemanticException;
import org.eclipse.ocl.expressions.LetExp;
import org.eclipse.ocl.expressions.OCLExpression;
import org.eclipse.ocl.expressions.OperationCallExp;
import org.eclipse.ocl.expressions.PropertyCallExp;
import org.eclipse.ocl.internal.l10n.OCLMessages;
import org.eclipse.ocl.lpg.ProblemHandler;
import org.eclipse.ocl.options.ParsingOptions;
import org.eclipse.ocl.options.ProblemOption;
import org.eclipse.ocl.util.OCLUtil;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.Package;
import org.eclipse.uml2.uml.UMLFactory;
/**
* Operator precedence tests.
*
* @author Christian W. Damus (cwdamus)
*/
@SuppressWarnings("nls")
public class PrecedenceTest
extends AbstractTestSuite {
Resource res;
Package pkg;
Class class1;
/**
* Test that let expressions require parenthesis when embedding them in
* other expressions.
*/
public void test_let() {
helper.setContext(class1);
try {
helper.createInvariant(
"self.base_Property.redefinedProperty->isEmpty() = false implies \n" +
" self.base_Property.redefinedProperty->size() = 1 and\n" +
" let rp : UML::Property =\n" +
" self.base_Property.redefinedProperty->asSequence()->at(1) in \n" +
" self.base_Property.name = rp.name and\n" +
" self.base_Property.type = rp.type");
} catch (Exception e) {
fail("Failed to parse: " + e.getLocalizedMessage());
}
helper.setContext(getMetaclass("NamedElement"));
try {
helper.createInvariant(
"namespace.getNamesOfMember(\n" +
" let ne : NamedElement = self in ne)->exists(n |\n" +
" let len : Integer = n.size() in len = 1)");
} catch (Exception e) {
fail("Failed to parse: " + e.getLocalizedMessage());
}
}
/**
* Test that the "in" expression part of a let expression consumes as much
* of the input as possible, so that
* <blockquote><code>let a = ... in a.b</code></blockquote>
* parses as
* <blockquote><code>let a = ... in (a.b)</code></blockquote>
* not as
* <blockquote><code>(let a = ... in a).b</code></blockquote>
*/
@SuppressWarnings("unchecked")
public void test_let_inExpression_182201() {
helper.setContext(getMetaclass("NamedElement"));
OCLExpression<Classifier> expr = null;
try {
expr = helper.createQuery("let ne : NamedElement = self in ne.name");
} catch (Exception e) {
fail("Failed to parse: " + e.getLocalizedMessage());
}
assertNotNull(expr);
assertTrue(expr instanceof LetExp<?, ?>); // not a PropertyCallExp
LetExp<Classifier, ?> letExp = (LetExp<Classifier, ?>) expr;
assertTrue(letExp.getIn() instanceof PropertyCallExp<?, ?>);
try {
expr = helper.createQuery(
"let n : String = let ne : NamedElement = self in ne.name in n.size()");
} catch (Exception e) {
fail("Failed to parse: " + e.getLocalizedMessage());
}
assertNotNull(expr);
assertTrue(expr instanceof LetExp<?, ?>); // not a PropertyCallExp
letExp = (LetExp<Classifier, ?>) expr;
assertTrue(letExp.getIn() instanceof OperationCallExp<?, ?>);
OperationCallExp<Classifier, Operation> opCall =
(OperationCallExp<Classifier, Operation>) letExp.getIn();
assertEquals("size", opCall.getReferredOperation().getName());
expr = letExp.getVariable().getInitExpression();
assertTrue(expr instanceof LetExp<?, ?>);
letExp = (LetExp<Classifier, ?>) letExp.getVariable().getInitExpression();
assertTrue(letExp.getIn() instanceof PropertyCallExp<?, ?>);
// a different nesting
try {
expr = helper.createQuery(
"let ne : NamedElement = self in let n : String = ne.name in n.size()");
} catch (Exception e) {
fail("Failed to parse: " + e.getLocalizedMessage());
}
assertNotNull(expr);
assertTrue(expr instanceof LetExp<?, ?>); // not a PropertyCallExp
letExp = (LetExp<Classifier, ?>) expr;
assertTrue(letExp.getIn() instanceof LetExp<?, ?>);
letExp = (LetExp<Classifier, ?>) letExp.getIn();
assertTrue(letExp.getIn() instanceof OperationCallExp<?, ?>);
OperationCallExp<Classifier, Operation> opCall2 =
(OperationCallExp<Classifier, Operation>) letExp.getIn();
assertEquals("size", opCall2.getReferredOperation().getName());
}
public void test_equality_relational_179249() {
helper.setContext(class1);
try {
// this should parse, because "1 < 2" has higher precedence.
// If it hadn't, then we would fail to parse because
// Integer has no "< Boolean" operation (we would parse this
// expression as "1 < (2 = true)"
helper.createInvariant("1 < 2 = true");
} catch (Exception e) {
fail("Failed to parse: " + e.getLocalizedMessage());
}
}
public void test_or_and_precedence() throws ParserException {
ParsingOptions.setOption(helper.getEnvironment(), ProblemOption.ELEMENT_NAME_QUOTE_ESCAPE, ProblemHandler.Severity.OK);
helper.setContext(class1);
assertTrueWithoutWarning("(true or (false and false)) = true");
assertTrueWithoutWarning("(true or false.\"and\"(false)) = true");
assertTrueWithoutWarning("((true or false) and false) = false");
assertTrueWithoutWarning("(true or false and false) = true");
ParsingOptions.setOption(helper.getEnvironment(), ParsingOptions.WARN_OF_XOR_OR_AND_PRECEDENCE_CHANGE, true);
assertTrueWithoutWarning("(true or (false and false)) = true");
assertTrueWithoutWarning("(true or false.\"and\"(false)) = true");
assertTrueWithoutWarning("((true or false) and false) = false");
//1.x assertTrue(check(helper, class1, "(true or false and false) = false"));
assertTrueWithWarning("(true or false and false) = true", OCLMessages.XorOrAndPrecedence_WARNING);
}
public void test_xor_or_precedence() throws ParserException {
ParsingOptions.setOption(helper.getEnvironment(), ProblemOption.ELEMENT_NAME_QUOTE_ESCAPE, ProblemHandler.Severity.OK);
helper.setContext(class1);
assertTrueWithoutWarning("(true xor (false or false)) = true");
assertTrueWithoutWarning("(true xor false.\"or\"(false)) = true");
assertTrueWithoutWarning("((true xor false) or true) = true");
assertTrueWithoutWarning("(true xor false or true) = false");
ParsingOptions.setOption(helper.getEnvironment(), ParsingOptions.WARN_OF_XOR_OR_AND_PRECEDENCE_CHANGE, true);
assertTrueWithoutWarning("(true xor (false or false)) = true");
assertTrueWithoutWarning("(true xor false.\"or\"(false)) = true");
assertTrueWithoutWarning("((true xor false) or true) = true");
//1.x assertTrue(check(helper, class1, "(true xor false or true) = true"));
assertTrueWithWarning("(true xor false or true) = false", OCLMessages.XorOrAndPrecedence_WARNING);
}
protected void assertTrueWithWarning(String expression, String warning)throws ParserException {
helper.createInvariant(expression);
try {
OCLUtil.checkForErrorsOrWarnings(helper.getEnvironment());
fail("Missing warning: " + warning);
} catch (SemanticException e) {
System.out.println("Got expected warning: " + e.getLocalizedMessage());
assertEquals(warning, e.getMessage());
}
}
protected void assertTrueWithoutWarning(String expression)throws ParserException {
helper.createInvariant(expression);
OCLUtil.checkForErrorsOrWarnings(helper.getEnvironment());
}
//
// Framework methods
//
@Override
protected void setUp() {
super.setUp();
// create a little test model for a Smalltalk-like collection class that
// defines operations corresponding to OCL iterators
res = new ResourceImpl(URI.createURI("foo://uml"));
pkg = UMLFactory.eINSTANCE.createPackage();
pkg.setName("testpkg");
res.getContents().add(pkg);
class1 = pkg.createOwnedClass("Class1", false);
class1.createOwnedAttribute("base_Property", getMetaclass("Property"));
}
}