tests/org.eclipse.ocl.uml.tests/src/org/eclipse/ocl/uml/tests/OperationConstraintsTest.java - ocl/org.eclipse.ocl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., 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
  *******************************************************************************/

 package org.eclipse.ocl.uml.tests;

 import java.util.Collections;
 import java.util.Iterator;

 import junit.framework.AssertionFailedError;

 import org.eclipse.emf.common.util.BasicEList;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.ocl.ParserException;
 import org.eclipse.ocl.expressions.IteratorExp;
 import org.eclipse.ocl.expressions.OCLExpression;
 import org.eclipse.ocl.expressions.OperationCallExp;
 import org.eclipse.ocl.expressions.PropertyCallExp;
 import org.eclipse.ocl.expressions.VariableExp;
 import org.eclipse.uml2.uml.Classifier;
 import org.eclipse.uml2.uml.Operation;
 import org.eclipse.uml2.uml.Parameter;
 import org.eclipse.uml2.uml.Property;
 import org.eclipse.uml2.uml.Type;


 /**
  * Tests support for operation constraints (pre/post/body).
  *
  * @author Christian W. Damus (cdamus)
  */
 @SuppressWarnings("nls")
 public class OperationConstraintsTest extends AbstractTestSuite {

 	/**
 	 * Tests a very simple precondition, with a package and operation context.
 	 */
 	public void test_simplePrecondition() {
 		parseConstraint(
 			"package ocltest context Fruit::ripen(color : Color) : Boolean " +
 			"pre: color <> Color::black " +
 			"endpackage");
 	}

 	/**
 	 * Tests a very simple postcondition, with a package and operation context
 	 * and using the "self" variable to disambiguate the name "color".
 	 */
 	public void test_simplePostcondition() {
 		parseConstraint(
 			"package ocltest context Fruit::ripen(color : Color) : Boolean " +
 			"post: self.color = color " +
 			"endpackage");
 	}

 	/**
 	 * Tests a postcondition containing the "@ pre" construct.
 	 */
 	public void test_postcondition_atPre() {
 		parseConstraint(
 			"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 			"post: color <> color@ pre implies color = c " +
 			"endpackage");
 	}

 	/**
 	 * Tests a postcondition containing the "@pre" construct on an operation call.
 	 */
 	public void test_postcondition_atPre_operation() {
 		parseConstraint(
 			"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 			"post: preferredColor() <> preferredColor@pre() implies color = c " +
 			"endpackage");
 	}

 	/**
 	 * Tests availability of the special "result" variable in postconditions.
 	 */
 	public void test_postcondition_result() {
 		parseConstraint(
 			"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 			"post: result implies color <> color@pre " +
 			"endpackage");
 	}

 	/**
 	 * Tests that in case of multiple constraints, each defines its own namespace
 	 * for local variables (we don't get errors on multiple declarations).
 	 */
 	public void test_namespaces() {
 		parseConstraint(
 			"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 			"pre notBlack: let ok : Boolean = c <> Color::black in " +
 			"  ok " +
 			"pre different: let ok : Boolean = c <> color in " +
 			"  ok " +
 			"body: let b : Boolean = c <> color in " +
 			"  result = b implies color <> Color::black " +
 			"post worked: result implies color <> color@pre " +
 			"endpackage");
 	}

 	/**
 	 * Checks that we correctly reject illegal use of "@pre" in precondition
 	 * constraints.
 	 */
 	public void test_illegalUseOfAtPre_precondition() {
 		AssertionFailedError err = null;

 		try {
 			parseConstraint(
 				"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 				"pre: c <> color@pre " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			// success
 			err = e;
 			System.out.println("Got expected error: " + e.getLocalizedMessage());
 		}

 		assertNotNull("Should not have succeeded in validating illegal @pre", err);
 	}

 	/**
 	 * Checks that we correctly reject illegal use of "@pre" in invariant
 	 * constraints.
 	 */
 	public void test_illegalUseOfAtPre_invariant() {
 		AssertionFailedError err = null;

 		try {
 			parseConstraint(
 				"package ocltest context Fruit " +
 				"inv: color@pre <> Color::black " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			// success
 			err = e;
 			System.out.println("Got expected error: " + e.getLocalizedMessage());
 		}

 		assertNotNull("Should not have succeeded in validating illegal @pre", err);
 	}

 	/**
 	 * Checks that we correctly reject illegal use of "@pre" in postcondition
 	 * constraints (where the "@pre" is not used on a model property expression).
 	 */
 	public void test_illegalUseOfAtPre_postcondition() {
 		AssertionFailedError err = null;

 		try {
 			parseConstraint(
 				"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 				"post: let oldColor : Color = color in c <> oldColor@pre " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			err = e;
 			System.out.println("Got expected error: " + e.getLocalizedMessage());
 		}

 		assertNotNull("Should not have succeeded in validating illegal @pre", err);
 	}

 	/**
 	 * Tests that local variables correctly hide attributes of the context
 	 * classifier.
 	 */
 	public void test_variablesHidingAttributes() {
 		parseConstraint(
 			"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 			"pre: let color : Boolean = (c = self.color) in " +
 			"  color implies c <> Color::black " +
 			"endpackage");
 	}

 	/**
 	 * Tests that parameters are in the same scope as local variables (cannot
 	 * use same names).
 	 */
 	public void test_parametersAreLocalVariables() {
 		AssertionFailedError err = null;

 		try {
 			parseConstraint(
 				"package ocltest context Fruit::ripen(c : Color) : Boolean " +
 				"pre: color : Boolean = (c = self.color) in " +
 				"  color implies c <> Color::black " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			err = e;
 			System.out.println("Got expected error: " + e.getLocalizedMessage());
 		}

 		assertNotNull(err);
 	}

 	/**
 	 * Tests that body conditions are correctly checked for conformance to the
 	 * operation type.
 	 */
 	public void test_bodyConditionConformance() {
 		AssertionFailedError err = null;

 		try {
 			// try a scenario with no common supertype
 			parseConstraint(
 				"package ocltest context Fruit::preferredColor() : Color " +
 				"body: result = (if true then 'red' else 'brown' endif) " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			err = e;
 			System.out.println("Got expected error: " + e.getLocalizedMessage());
 		}

 		assertNotNull(err);
 		err = null;

 		try {
 			// try a scenario with a common supertype
 			parseConstraint(
 				"package ocltest context Apple::newApple() : Apple " +
 				"body: result = self.newFruit() " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			err = e;
 			System.out.println("Got expected error: " + e.getLocalizedMessage());
 		}

 		assertNotNull(err);
 		err = null;

 		try {
 			// this scenario is OK
 			parseConstraint(
 				"package ocltest context Apple::newFruit() : Fruit " +
 				"body: result = self.newApple() " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			err = e;
 			System.err.println("Got unexpected error: " + e.getLocalizedMessage());
 		}

 		assertNull(err);
 	}

 	/**
 	 * Tests that body conditions are not allowed for void operations.
 	 */
 	public void test_bodyConditionVoidOperation() {
 		AssertionFailedError err = null;

 		try {
 			parseConstraint(
 				"package ocltest context Apple::label(newLabel : String) : " +
 				"body: result = (if true then 'Spy' else 'Spartan' endif) " +
 				"endpackage");
 		} catch (AssertionFailedError e) {
 			err = e;
 			System.out.println("Got expected error: " + e.getLocalizedMessage());
 		}

 		assertNotNull(err);
 	}

 	/**
 	 * Tests that when a parameter name (or any other local variable, for that
 	 * matter) coincides with an attribute name, we correctly distinguish
 	 * references to the variable from references to the attribute.
 	 */
 	public void test_parameterNameCoincidesWithAttributeName_140008() {
         expectModified = true;
 		Operation foo = apple.createOwnedOperation("foo",
 			new BasicEList<String>(Collections.singleton("str")),
 			new BasicEList<Type>(Collections.singleton((Type) getUMLString())),
 			getUMLString());
 		Property myStr = apple.createOwnedAttribute("str", getUMLString());

 		try {
 			OCLExpression<Classifier> expr = parseConstraint(
 				"package ocltest context Apple::foo(str : String) : String " +
 				"body: result = (if str = self.str then '' else str endif) " +
 				"endpackage");

 			int propertyCalls = 0;
 			int variableCalls = 0;
 			for (Iterator<?> iter = EcoreUtil.getAllContents(Collections.singleton(expr)); iter.hasNext();) {
 				Object next = iter.next();
 				if (next instanceof PropertyCallExp<?, ?>) {
 					@SuppressWarnings("unchecked")
 					PropertyCallExp<Classifier, Property> pc =
 						(PropertyCallExp<Classifier, Property>) next;
 					if ("str".equals(pc.getReferredProperty().getName())) {
 						propertyCalls++;
 					}
 				} else if (next instanceof VariableExp<?, ?>) {
 					@SuppressWarnings("unchecked")
 					VariableExp<Classifier, Parameter> v =
 						(VariableExp<Classifier, Parameter>) next;
 					if ("str".equals(v.getReferredVariable().getName())) {
 						variableCalls++;
 					}
 				}
 			}

 			assertEquals("property calls", 1, propertyCalls);
 			assertEquals("variable calls", 2, variableCalls);
 		} finally {
 			apple.getOwnedOperations().remove(foo);
 			apple.getOwnedAttributes().remove(myStr);
 		}
 	}

 	/**
 	 * Tests that an expression resolves the implicit source of a property call
 	 * correctly when the environment has additional variable names such as
 	 * parameters that define the same property.  This test parses raw OCL.
 	 */
 	@SuppressWarnings("unchecked")
 	public void test_implicitPropertySourceLookup_raw_151234() {
 		OCLExpression<Classifier> expr = parseConstraint(
 			"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
 			"pre: color <> newColor " +
 			"endpackage");

 		assertTrue(expr instanceof OperationCallExp<?, ?>);
 		OperationCallExp<Classifier, Operation> notEquals =
 			(OperationCallExp<Classifier, Operation>) expr;
 		assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
 		PropertyCallExp<Classifier, Property> propertyCall =
 			(PropertyCallExp<Classifier, Property>) notEquals.getSource();

 		assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
 		VariableExp<Classifier, Parameter> var =
 			(VariableExp<Classifier, Parameter>) propertyCall.getSource();

 		// we did not resolve against "fruit", which also has a color property
 		assertEquals("self", var.getReferredVariable().getName());

 		// now check the resolution of implicit iterator variables as sources
 		expr = parseConstraint(
 				"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
 				"pre: Fruit.allInstances()->forAll(color <> newColor) " +
 				"endpackage");

 		assertTrue(expr instanceof IteratorExp<?, ?>);
 		IteratorExp<Classifier, Parameter> forAll =
 			(IteratorExp<Classifier, Parameter>) expr;
 		assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
 		notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
 		assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
 		propertyCall = (PropertyCallExp<Classifier, Property>) notEquals.getSource();

 		assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
 		var = (VariableExp<Classifier, Parameter>) propertyCall.getSource();

 		// we did not resolve against "fruit", which also has a color property
 		assertTrue(var.getReferredVariable().getName().startsWith("temp"));
 	}

 	/**
 	 * Tests that an expression resolves the implicit source of a property call
 	 * correctly when the environment has additional variable names such as
 	 * parameters that define the same property.  This test uses a helper.
 	 */
 	@SuppressWarnings("unchecked")
 	public void test_implicitPropertySourceLookup_helper_151234() {
 		try {
 			helper.setOperationContext(fruit, fruit_setColor);
 			OCLExpression<Classifier> expr =
 				getBodyExpression(helper.createPrecondition("color <> newColor"));

 			assertTrue(expr instanceof OperationCallExp<?, ?>);
 			OperationCallExp<Classifier, Operation> notEquals =
 				(OperationCallExp<Classifier, Operation>) expr;
 			assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
 			PropertyCallExp<Classifier, Property> propertyCall =
 				(PropertyCallExp<Classifier, Property>) notEquals.getSource();

 			assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
 			VariableExp<Classifier, Parameter> var =
 				(VariableExp<Classifier, Parameter>) propertyCall.getSource();

 			// we did not resolve against "fruit", which also has a color property
 			assertEquals("self", var.getReferredVariable().getName());

 			// now check the resolution of implicit iterator variables as sources
 			expr = getBodyExpression(helper.createPrecondition(
 					"Fruit.allInstances()->forAll(color <> newColor)"));

 			assertTrue(expr instanceof IteratorExp<?, ?>);
 			IteratorExp<Classifier, Parameter> forAll = (IteratorExp<Classifier, Parameter>) expr;
 			assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
 			notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
 			assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
 			propertyCall = (PropertyCallExp<Classifier, Property>) notEquals.getSource();

 			assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
 			var = (VariableExp<Classifier, Parameter>) propertyCall.getSource();

 			// we did not resolve against "fruit", which also has a color property
 			assertTrue(var.getReferredVariable().getName().startsWith("temp"));
 		} catch (ParserException e) {
 			fail("Parse failed: " + e.getLocalizedMessage());
 		}
 	}

 	/**
 	 * Tests that an expression resolves the implicit source of an operation call
 	 * correctly when the environment has additional variable names such as
 	 * parameters that define the same property.  This test parses raw OCL.
 	 */
 	@SuppressWarnings("unchecked")
 	public void test_implicitOperationSourceLookup_raw_151234() {
 		OCLExpression<Classifier> expr = parseConstraint(
 			"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
 			"pre: preferredColor() <> newColor " +
 			"endpackage");

 		assertTrue(expr instanceof OperationCallExp<?, ?>);
 		OperationCallExp<Classifier, Operation> notEquals =
 			(OperationCallExp<Classifier, Operation>) expr;
 		assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
 		OperationCallExp<Classifier, Operation> operationCall =
 			(OperationCallExp<Classifier, Operation>) notEquals.getSource();

 		assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
 		VariableExp<Classifier, Parameter> var = (VariableExp<Classifier, Parameter>) operationCall.getSource();

 		// we did not resolve against "fruit", which also has a color property
 		assertEquals("self", var.getReferredVariable().getName());

 		// now check the resolution of implicit iterator variables as sources
 		expr = parseConstraint(
 				"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
 				"pre: Fruit.allInstances()->forAll(preferredColor() <> newColor) " +
 				"endpackage");

 		assertTrue(expr instanceof IteratorExp<?, ?>);
 		IteratorExp<Classifier, Parameter> forAll = (IteratorExp<Classifier, Parameter>) expr;
 		assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
 		notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
 		assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
 		operationCall = (OperationCallExp<Classifier, Operation>) notEquals.getSource();

 		assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
 		var = (VariableExp<Classifier, Parameter>) operationCall.getSource();

 		// we did not resolve against "fruit", which also has a color property
 		assertTrue(var.getReferredVariable().getName().startsWith("temp"));
 	}

 	/**
 	 * Tests that an expression resolves the implicit source of an operation call
 	 * correctly when the environment has additional variable names such as
 	 * parameters that define the same property.  This test uses a helper.
 	 */
 	@SuppressWarnings("unchecked")
 	public void test_implicitOperationSourceLookup_helper_151234() {
 		try {
 			helper.setOperationContext(fruit, fruit_setColor);
 			OCLExpression<Classifier> expr = getBodyExpression(
 					helper.createPrecondition("preferredColor() <> newColor"));

 			assertTrue(expr instanceof OperationCallExp<?, ?>);
 			OperationCallExp<Classifier, Operation> notEquals =
 				(OperationCallExp<Classifier, Operation>) expr;
 			assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
 			OperationCallExp<Classifier, Operation> operationCall =
 				(OperationCallExp<Classifier, Operation>) notEquals.getSource();

 			assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
 			VariableExp<Classifier, Parameter> var =
 				(VariableExp<Classifier, Parameter>) operationCall.getSource();

 			// we did not resolve against "fruit", which also has a color property
 			assertEquals("self", var.getReferredVariable().getName());

 			// now check the resolution of implicit iterator variables as sources
 			expr = getBodyExpression(helper.createPrecondition(
 					"Fruit.allInstances()->forAll(preferredColor() <> newColor)"));

 			assertTrue(expr instanceof IteratorExp<?, ?>);
 			IteratorExp<Classifier, Parameter> forAll = (IteratorExp<Classifier, Parameter>) expr;
 			assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
 			notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
 			assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
 			operationCall = (OperationCallExp<Classifier, Operation>) notEquals.getSource();

 			assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
 			var = (VariableExp<Classifier, Parameter>) operationCall.getSource();

 			// we did not resolve against "fruit", which also has a color property
 			assertTrue(var.getReferredVariable().getName().startsWith("temp"));
 		} catch (ParserException e) {
 			fail("Parse failed: " + e.getLocalizedMessage());
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2009 IBM Corporation, Zeligsoft Inc., 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
	*******************************************************************************/

	package org.eclipse.ocl.uml.tests;

	import java.util.Collections;
	import java.util.Iterator;

	import junit.framework.AssertionFailedError;

	import org.eclipse.emf.common.util.BasicEList;
	import org.eclipse.emf.ecore.util.EcoreUtil;
	import org.eclipse.ocl.ParserException;
	import org.eclipse.ocl.expressions.IteratorExp;
	import org.eclipse.ocl.expressions.OCLExpression;
	import org.eclipse.ocl.expressions.OperationCallExp;
	import org.eclipse.ocl.expressions.PropertyCallExp;
	import org.eclipse.ocl.expressions.VariableExp;
	import org.eclipse.uml2.uml.Classifier;
	import org.eclipse.uml2.uml.Operation;
	import org.eclipse.uml2.uml.Parameter;
	import org.eclipse.uml2.uml.Property;
	import org.eclipse.uml2.uml.Type;


	/**
	* Tests support for operation constraints (pre/post/body).
	*
	* @author Christian W. Damus (cdamus)
	*/
	@SuppressWarnings("nls")
	public class OperationConstraintsTest extends AbstractTestSuite {

	/**
	* Tests a very simple precondition, with a package and operation context.
	*/
	public void test_simplePrecondition() {
	parseConstraint(
	"package ocltest context Fruit::ripen(color : Color) : Boolean " +
	"pre: color <> Color::black " +
	"endpackage");
	}

	/**
	* Tests a very simple postcondition, with a package and operation context
	* and using the "self" variable to disambiguate the name "color".
	*/
	public void test_simplePostcondition() {
	parseConstraint(
	"package ocltest context Fruit::ripen(color : Color) : Boolean " +
	"post: self.color = color " +
	"endpackage");
	}

	/**
	* Tests a postcondition containing the "@ pre" construct.
	*/
	public void test_postcondition_atPre() {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"post: color <> color@ pre implies color = c " +
	"endpackage");
	}

	/**
	* Tests a postcondition containing the "@pre" construct on an operation call.
	*/
	public void test_postcondition_atPre_operation() {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"post: preferredColor() <> preferredColor@pre() implies color = c " +
	"endpackage");
	}

	/**
	* Tests availability of the special "result" variable in postconditions.
	*/
	public void test_postcondition_result() {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"post: result implies color <> color@pre " +
	"endpackage");
	}

	/**
	* Tests that in case of multiple constraints, each defines its own namespace
	* for local variables (we don't get errors on multiple declarations).
	*/
	public void test_namespaces() {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"pre notBlack: let ok : Boolean = c <> Color::black in " +
	" ok " +
	"pre different: let ok : Boolean = c <> color in " +
	" ok " +
	"body: let b : Boolean = c <> color in " +
	" result = b implies color <> Color::black " +
	"post worked: result implies color <> color@pre " +
	"endpackage");
	}

	/**
	* Checks that we correctly reject illegal use of "@pre" in precondition
	* constraints.
	*/
	public void test_illegalUseOfAtPre_precondition() {
	AssertionFailedError err = null;

	try {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"pre: c <> color@pre " +
	"endpackage");
	} catch (AssertionFailedError e) {
	// success
	err = e;
	System.out.println("Got expected error: " + e.getLocalizedMessage());
	}

	assertNotNull("Should not have succeeded in validating illegal @pre", err);
	}

	/**
	* Checks that we correctly reject illegal use of "@pre" in invariant
	* constraints.
	*/
	public void test_illegalUseOfAtPre_invariant() {
	AssertionFailedError err = null;

	try {
	parseConstraint(
	"package ocltest context Fruit " +
	"inv: color@pre <> Color::black " +
	"endpackage");
	} catch (AssertionFailedError e) {
	// success
	err = e;
	System.out.println("Got expected error: " + e.getLocalizedMessage());
	}

	assertNotNull("Should not have succeeded in validating illegal @pre", err);
	}

	/**
	* Checks that we correctly reject illegal use of "@pre" in postcondition
	* constraints (where the "@pre" is not used on a model property expression).
	*/
	public void test_illegalUseOfAtPre_postcondition() {
	AssertionFailedError err = null;

	try {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"post: let oldColor : Color = color in c <> oldColor@pre " +
	"endpackage");
	} catch (AssertionFailedError e) {
	err = e;
	System.out.println("Got expected error: " + e.getLocalizedMessage());
	}

	assertNotNull("Should not have succeeded in validating illegal @pre", err);
	}

	/**
	* Tests that local variables correctly hide attributes of the context
	* classifier.
	*/
	public void test_variablesHidingAttributes() {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"pre: let color : Boolean = (c = self.color) in " +
	" color implies c <> Color::black " +
	"endpackage");
	}

	/**
	* Tests that parameters are in the same scope as local variables (cannot
	* use same names).
	*/
	public void test_parametersAreLocalVariables() {
	AssertionFailedError err = null;

	try {
	parseConstraint(
	"package ocltest context Fruit::ripen(c : Color) : Boolean " +
	"pre: color : Boolean = (c = self.color) in " +
	" color implies c <> Color::black " +
	"endpackage");
	} catch (AssertionFailedError e) {
	err = e;
	System.out.println("Got expected error: " + e.getLocalizedMessage());
	}

	assertNotNull(err);
	}

	/**
	* Tests that body conditions are correctly checked for conformance to the
	* operation type.
	*/
	public void test_bodyConditionConformance() {
	AssertionFailedError err = null;

	try {
	// try a scenario with no common supertype
	parseConstraint(
	"package ocltest context Fruit::preferredColor() : Color " +
	"body: result = (if true then 'red' else 'brown' endif) " +
	"endpackage");
	} catch (AssertionFailedError e) {
	err = e;
	System.out.println("Got expected error: " + e.getLocalizedMessage());
	}

	assertNotNull(err);
	err = null;

	try {
	// try a scenario with a common supertype
	parseConstraint(
	"package ocltest context Apple::newApple() : Apple " +
	"body: result = self.newFruit() " +
	"endpackage");
	} catch (AssertionFailedError e) {
	err = e;
	System.out.println("Got expected error: " + e.getLocalizedMessage());
	}

	assertNotNull(err);
	err = null;

	try {
	// this scenario is OK
	parseConstraint(
	"package ocltest context Apple::newFruit() : Fruit " +
	"body: result = self.newApple() " +
	"endpackage");
	} catch (AssertionFailedError e) {
	err = e;
	System.err.println("Got unexpected error: " + e.getLocalizedMessage());
	}

	assertNull(err);
	}

	/**
	* Tests that body conditions are not allowed for void operations.
	*/
	public void test_bodyConditionVoidOperation() {
	AssertionFailedError err = null;

	try {
	parseConstraint(
	"package ocltest context Apple::label(newLabel : String) : " +
	"body: result = (if true then 'Spy' else 'Spartan' endif) " +
	"endpackage");
	} catch (AssertionFailedError e) {
	err = e;
	System.out.println("Got expected error: " + e.getLocalizedMessage());
	}

	assertNotNull(err);
	}

	/**
	* Tests that when a parameter name (or any other local variable, for that
	* matter) coincides with an attribute name, we correctly distinguish
	* references to the variable from references to the attribute.
	*/
	public void test_parameterNameCoincidesWithAttributeName_140008() {
	expectModified = true;
	Operation foo = apple.createOwnedOperation("foo",
	new BasicEList<String>(Collections.singleton("str")),
	new BasicEList<Type>(Collections.singleton((Type) getUMLString())),
	getUMLString());
	Property myStr = apple.createOwnedAttribute("str", getUMLString());

	try {
	OCLExpression<Classifier> expr = parseConstraint(
	"package ocltest context Apple::foo(str : String) : String " +
	"body: result = (if str = self.str then '' else str endif) " +
	"endpackage");

	int propertyCalls = 0;
	int variableCalls = 0;
	for (Iterator<?> iter = EcoreUtil.getAllContents(Collections.singleton(expr)); iter.hasNext();) {
	Object next = iter.next();
	if (next instanceof PropertyCallExp<?, ?>) {
	@SuppressWarnings("unchecked")
	PropertyCallExp<Classifier, Property> pc =
	(PropertyCallExp<Classifier, Property>) next;
	if ("str".equals(pc.getReferredProperty().getName())) {
	propertyCalls++;
	}
	} else if (next instanceof VariableExp<?, ?>) {
	@SuppressWarnings("unchecked")
	VariableExp<Classifier, Parameter> v =
	(VariableExp<Classifier, Parameter>) next;
	if ("str".equals(v.getReferredVariable().getName())) {
	variableCalls++;
	}
	}
	}

	assertEquals("property calls", 1, propertyCalls);
	assertEquals("variable calls", 2, variableCalls);
	} finally {
	apple.getOwnedOperations().remove(foo);
	apple.getOwnedAttributes().remove(myStr);
	}
	}

	/**
	* Tests that an expression resolves the implicit source of a property call
	* correctly when the environment has additional variable names such as
	* parameters that define the same property. This test parses raw OCL.
	*/
	@SuppressWarnings("unchecked")
	public void test_implicitPropertySourceLookup_raw_151234() {
	OCLExpression<Classifier> expr = parseConstraint(
	"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
	"pre: color <> newColor " +
	"endpackage");

	assertTrue(expr instanceof OperationCallExp<?, ?>);
	OperationCallExp<Classifier, Operation> notEquals =
	(OperationCallExp<Classifier, Operation>) expr;
	assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
	PropertyCallExp<Classifier, Property> propertyCall =
	(PropertyCallExp<Classifier, Property>) notEquals.getSource();

	assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
	VariableExp<Classifier, Parameter> var =
	(VariableExp<Classifier, Parameter>) propertyCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertEquals("self", var.getReferredVariable().getName());

	// now check the resolution of implicit iterator variables as sources
	expr = parseConstraint(
	"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
	"pre: Fruit.allInstances()->forAll(color <> newColor) " +
	"endpackage");

	assertTrue(expr instanceof IteratorExp<?, ?>);
	IteratorExp<Classifier, Parameter> forAll =
	(IteratorExp<Classifier, Parameter>) expr;
	assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
	notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
	assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
	propertyCall = (PropertyCallExp<Classifier, Property>) notEquals.getSource();

	assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
	var = (VariableExp<Classifier, Parameter>) propertyCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertTrue(var.getReferredVariable().getName().startsWith("temp"));
	}

	/**
	* Tests that an expression resolves the implicit source of a property call
	* correctly when the environment has additional variable names such as
	* parameters that define the same property. This test uses a helper.
	*/
	@SuppressWarnings("unchecked")
	public void test_implicitPropertySourceLookup_helper_151234() {
	try {
	helper.setOperationContext(fruit, fruit_setColor);
	OCLExpression<Classifier> expr =
	getBodyExpression(helper.createPrecondition("color <> newColor"));

	assertTrue(expr instanceof OperationCallExp<?, ?>);
	OperationCallExp<Classifier, Operation> notEquals =
	(OperationCallExp<Classifier, Operation>) expr;
	assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
	PropertyCallExp<Classifier, Property> propertyCall =
	(PropertyCallExp<Classifier, Property>) notEquals.getSource();

	assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
	VariableExp<Classifier, Parameter> var =
	(VariableExp<Classifier, Parameter>) propertyCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertEquals("self", var.getReferredVariable().getName());

	// now check the resolution of implicit iterator variables as sources
	expr = getBodyExpression(helper.createPrecondition(
	"Fruit.allInstances()->forAll(color <> newColor)"));

	assertTrue(expr instanceof IteratorExp<?, ?>);
	IteratorExp<Classifier, Parameter> forAll = (IteratorExp<Classifier, Parameter>) expr;
	assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
	notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
	assertTrue(notEquals.getSource() instanceof PropertyCallExp<?, ?>);
	propertyCall = (PropertyCallExp<Classifier, Property>) notEquals.getSource();

	assertTrue(propertyCall.getSource() instanceof VariableExp<?, ?>);
	var = (VariableExp<Classifier, Parameter>) propertyCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertTrue(var.getReferredVariable().getName().startsWith("temp"));
	} catch (ParserException e) {
	fail("Parse failed: " + e.getLocalizedMessage());
	}
	}

	/**
	* Tests that an expression resolves the implicit source of an operation call
	* correctly when the environment has additional variable names such as
	* parameters that define the same property. This test parses raw OCL.
	*/
	@SuppressWarnings("unchecked")
	public void test_implicitOperationSourceLookup_raw_151234() {
	OCLExpression<Classifier> expr = parseConstraint(
	"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
	"pre: preferredColor() <> newColor " +
	"endpackage");

	assertTrue(expr instanceof OperationCallExp<?, ?>);
	OperationCallExp<Classifier, Operation> notEquals =
	(OperationCallExp<Classifier, Operation>) expr;
	assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
	OperationCallExp<Classifier, Operation> operationCall =
	(OperationCallExp<Classifier, Operation>) notEquals.getSource();

	assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
	VariableExp<Classifier, Parameter> var = (VariableExp<Classifier, Parameter>) operationCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertEquals("self", var.getReferredVariable().getName());

	// now check the resolution of implicit iterator variables as sources
	expr = parseConstraint(
	"package ocltest context Apple::setColor(fruit : Fruit, newColor : Color) : " +
	"pre: Fruit.allInstances()->forAll(preferredColor() <> newColor) " +
	"endpackage");

	assertTrue(expr instanceof IteratorExp<?, ?>);
	IteratorExp<Classifier, Parameter> forAll = (IteratorExp<Classifier, Parameter>) expr;
	assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
	notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
	assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
	operationCall = (OperationCallExp<Classifier, Operation>) notEquals.getSource();

	assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
	var = (VariableExp<Classifier, Parameter>) operationCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertTrue(var.getReferredVariable().getName().startsWith("temp"));
	}

	/**
	* Tests that an expression resolves the implicit source of an operation call
	* correctly when the environment has additional variable names such as
	* parameters that define the same property. This test uses a helper.
	*/
	@SuppressWarnings("unchecked")
	public void test_implicitOperationSourceLookup_helper_151234() {
	try {
	helper.setOperationContext(fruit, fruit_setColor);
	OCLExpression<Classifier> expr = getBodyExpression(
	helper.createPrecondition("preferredColor() <> newColor"));

	assertTrue(expr instanceof OperationCallExp<?, ?>);
	OperationCallExp<Classifier, Operation> notEquals =
	(OperationCallExp<Classifier, Operation>) expr;
	assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
	OperationCallExp<Classifier, Operation> operationCall =
	(OperationCallExp<Classifier, Operation>) notEquals.getSource();

	assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
	VariableExp<Classifier, Parameter> var =
	(VariableExp<Classifier, Parameter>) operationCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertEquals("self", var.getReferredVariable().getName());

	// now check the resolution of implicit iterator variables as sources
	expr = getBodyExpression(helper.createPrecondition(
	"Fruit.allInstances()->forAll(preferredColor() <> newColor)"));

	assertTrue(expr instanceof IteratorExp<?, ?>);
	IteratorExp<Classifier, Parameter> forAll = (IteratorExp<Classifier, Parameter>) expr;
	assertTrue(forAll.getBody() instanceof OperationCallExp<?, ?>);
	notEquals = (OperationCallExp<Classifier, Operation>) forAll.getBody();
	assertTrue(notEquals.getSource() instanceof OperationCallExp<?, ?>);
	operationCall = (OperationCallExp<Classifier, Operation>) notEquals.getSource();

	assertTrue(operationCall.getSource() instanceof VariableExp<?, ?>);
	var = (VariableExp<Classifier, Parameter>) operationCall.getSource();

	// we did not resolve against "fruit", which also has a color property
	assertTrue(var.getReferredVariable().getName().startsWith("temp"));
	} catch (ParserException e) {
	fail("Parse failed: " + e.getLocalizedMessage());
	}
	}
	}