/*******************************************************************************
* Copyright (c) 2009, 2012 SAP AG 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:
* SAP AG - initial API and implementation
******************************************************************************/
package org.eclipse.ocl.examples.impactanalyzer.tests.instanceScope;
import java.util.Collection;
import junit.framework.TestCase;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EParameter;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.ocl.ParserException;
import org.eclipse.ocl.SemanticException;
import org.eclipse.ocl.ecore.LoopExp;
import org.eclipse.ocl.ecore.OCL;
import org.eclipse.ocl.ecore.OCL.Helper;
import org.eclipse.ocl.ecore.OCLExpression;
import org.eclipse.ocl.util.Bag;
import org.junit.Before;
import org.junit.Test;
import company.CompanyFactory;
import company.CompanyPackage;
import data.classes.ClassTypeDefinition;
import data.classes.ClassesFactory;
import data.classes.ClassesPackage;
import data.classes.MethodSignature;
import data.classes.Parameter;
import data.classes.SapClass;
public class QuickOclParseAndEvalTest extends TestCase
{
private SapClass class1;
private SapClass class2;
private Parameter param;
private ClassTypeDefinition ctd;
private MethodSignature signature;
private OCL ocl;
private Helper oclHelper;
private void assertInvalid(Object object) {
assertEquals(ocl.getEnvironment().getOCLStandardLibrary().getInvalid(), object);
}
@Before
public void setUp()
{
class1 = ClassesFactory.eINSTANCE.createSapClass();
class1.setName("class1");
class2 = ClassesFactory.eINSTANCE.createSapClass();
class2.setName("class2");
signature = ClassesFactory.eINSTANCE.createMethodSignature();
signature.setName("context");
param = ClassesFactory.eINSTANCE.createParameter();
param.setName("p");
ctd = ClassesFactory.eINSTANCE.createClassTypeDefinition();
ctd.setClazz(class1);
param.setOwnedTypeDefinition(ctd);
signature.setOwner(class2);
ocl = org.eclipse.ocl.examples.impactanalyzer.util.OCL.newInstance();
oclHelper = ocl.createOCLHelper();
oclHelper.setContext(ClassesPackage.eINSTANCE.getParameter());
}
/**
* Check if it is possible to create an expression in context Boolean
*/
@Test
public void testParseAndEvaluateOclExpressionInContextBoolean() throws ParserException {
oclHelper.setContext(EcorePackage.eINSTANCE.getEBoolean());
{
OCLExpression expression4 = oclHelper.createQuery("self");
Object result4 = ocl.evaluate(true, expression4);
assertTrue((Boolean) result4);
Object result5 = ocl.evaluate(false, expression4);
assertFalse((Boolean) result5);
}
{
OCLExpression expression4 = oclHelper.createQuery("not self");
Object result4 = ocl.evaluate(true, expression4);
assertFalse((Boolean) result4);
Object result5 = ocl.evaluate(false, expression4);
assertTrue((Boolean) result5);
}
}
/**
* Check if a type name parses as a type literal
*/
@Test
public void testParseAndEvaluateOclExpressionWithTypeLiteral() throws ParserException {
oclHelper.setContext(CompanyPackage.eINSTANCE.getDepartment());
OCLExpression expression4 = oclHelper.createQuery("company::Division");
Object result4 = ocl.evaluate(null, expression4);
assertTrue(result4 instanceof EClass);
assertEquals(CompanyPackage.eINSTANCE.getDivision(), result4);
OCLExpression expression5 = oclHelper.createQuery("Division");
Object result5 = ocl.evaluate(null, expression5);
assertTrue(result5 instanceof EClass);
assertEquals(CompanyPackage.eINSTANCE.getDivision(), result5);
}
/**
* Check what happens when ->at(...) argument is out of bounds
*/
@Test
public void testParseAndEvaluateOclExpressionWithOutOfBoundsAtArgument() throws ParserException {
oclHelper.setContext(CompanyPackage.eINSTANCE.getDepartment());
OCLExpression expression4 = oclHelper.createQuery("Sequence{1..2}->at(3)");
Object result4 = ocl.evaluate(CompanyFactory.eINSTANCE.createDepartment(), expression4);
assertInvalid(result4);
}
/**
* Check what happens when last value of a range is invalid instead of an Integer. Interestingly, this aborts the whole
* evaluation and even "bypasses" a trailing oclIsInvalid().
*/
@Test
public void testParseAndEvaluateOclExpressionWithInvalidAsLastPartOfRange() throws ParserException {
oclHelper.setContext(CompanyPackage.eINSTANCE.getDepartment());
OCLExpression expression4 = oclHelper.createQuery("(Sequence{1..(self.parentDepartment.subDepartment->size())}->select(i | i>0)).oclIsInvalid()");
Object result4 = ocl.evaluate(CompanyFactory.eINSTANCE.createDepartment(), expression4);
assertInvalid(result4);
}
/**
* Check if invalid can be passed into an operation as argument
*/
@Test
public void testParseAndEvaluateOclExpressionWithMixOfPrimitiveAndObjectTypesInCollectionLiteral() throws ParserException {
OCLExpression expression4 = oclHelper.createQuery("Set{1, 2, self}->select(i | i.oclIsKindOf(Integer))");
Object result4 = ocl.evaluate(CompanyFactory.eINSTANCE.createDepartment(), expression4);
assertTrue(result4 instanceof Collection);
assertTrue(((Collection<?>) result4).contains(1));
assertTrue(((Collection<?>) result4).contains(2));
}
/**
* Check if invalid can be passed into an operation as argument
*/
@Test
public void testParseAndEvaluateOclExpressionWithInvalidInOperationArgument() throws ParserException {
EClass cl = CompanyPackage.eINSTANCE.getDepartment();
EOperation op = EcoreFactory.eINSTANCE.createEOperation();
try {
op.setName("myOp");
op.setEType(EcorePackage.eINSTANCE.getEBoolean());
EParameter param = EcoreFactory.eINSTANCE.createEParameter();
param.setName("humba");
param.setEType(org.eclipse.emf.ecore.EcorePackage.eINSTANCE
.getEClassifier());
op.getEParameters().add(param);
cl.getEOperations().add(op);
oclHelper.setOperationContext(cl, op);
oclHelper.createBodyCondition("humba.oclIsInvalid()");
oclHelper.setContext(cl);
OCLExpression expression4 = oclHelper
.createQuery("self.myOp(invalid)");
Object result4 = ocl.evaluate(
CompanyFactory.eINSTANCE.createDepartment(), expression4);
assertEquals(true, result4);
} finally {
cl.getEOperations().remove(op);
}
}
/**
* Ensure that "or" and "and" do shortcut evaluation for invalid arguments
*/
@Test
public void testParseAndEvaluateOclExpressionWithInvalidInBooleanShortcutEval() throws ParserException {
OCLExpression expression4 = oclHelper.createQuery("false and invalid");
Object result4 = ocl.evaluate(null, expression4);
assertEquals(false, result4);
OCLExpression expression5 = oclHelper.createQuery("true or invalid");
Object result5 = ocl.evaluate(null, expression5);
assertEquals(true, result5);
OCLExpression expression6 = oclHelper.createQuery("(invalid or true).oclIsInvalid()");
Object result6 = ocl.evaluate(null, expression6);
assertEquals(false, result6);
OCLExpression expression7 = oclHelper.createQuery("(invalid and false).oclIsInvalid()");
Object result7 = ocl.evaluate(null, expression7);
assertEquals(false, result7);
OCLExpression expression8 = oclHelper.createQuery("(invalid or true)");
Object result8 = ocl.evaluate(null, expression8);
assertEquals(true, result8);
OCLExpression expression9 = oclHelper.createQuery("(invalid and false)");
Object result9 = ocl.evaluate(null, expression9);
assertEquals(false, result9);
}
/**
* Testing if a let-expression evaluates to OclInvalid if the initExpression evaluates to OclInvalid although
* the variable is not used in the "in" expression.
*/
@Test
public void testParseAndEvaluateOclExpressionWithInvalidLetInitExpression() throws ParserException {
OCLExpression expression4 = oclHelper
.createQuery("let x:Integer=self.name.size() in 1+2");
Object result4 = ocl.evaluate(null, expression4);
assertEquals(3, result4);
}
/**
* Testing if two iterator variables appear as such
*/
@Test
public void testParseAndEvaluateOclExpressionForAllWithTwoIterators() throws ParserException {
OCLExpression expression4 = oclHelper
.createQuery("Set{1, 2, 3}->forAll(i, j | i+j <> 7)");
assertEquals(2, ((LoopExp) expression4).getIterator().size());
Object result4 = ocl.evaluate(param, expression4);
assertEquals(true, result4);
}
/**
* Testing if an iterate's accumulator expression is really evaluated even when the iterate is applied to an empty collection
*/
@Test
public void testParseAndEvaluateOclExpressionAccumulatorForIterateOnEmptyCollection() throws ParserException {
OCLExpression expression4 = oclHelper
.createQuery("let s:Set(Integer)=Set{} in s->iterate(i:Integer; acc:Integer=1 | acc+1)");
Object result4 = ocl.evaluate(param, expression4);
assertEquals(1, result4);
}
/**
* Testing if shadowing a variable by an iterator leads to incorrect results because the shadowed
* variable is overwritten by the iterator values
*/
@Test
public void testParseAndEvaluateOclExpressionIteratorShadowingLetVariable() throws ParserException
{
param.setOwnedTypeDefinition(ctd);
ctd.setClazz(null);
try {
OCLExpression expression4 = oclHelper.createQuery("let i:Integer=1 in if self.ownedTypeDefinition->select(i|i.oclAsType(ClassTypeDefinition).clazz->notEmpty())->isEmpty() then i else 0 endif");
Object result4 = ocl.evaluate(param, expression4);
assertEquals(1, result4);
} catch (SemanticException e) {
// it's ok if the OCL implementation doesn't accept shadowing:
assertEquals("Variable name already used: (i)", e.getMessage());
}
}
/**
* Ensures that an OclInvalid value does not pass a select filter, yet the select iterator
* returns a valid result
*/
@Test
public void testParseAndEvaluateOclExpressionWithTupleWithNull() throws ParserException
{
param.setName(null);
OCLExpression expression5 = oclHelper.createQuery("Tuple{c:Tuple(d:String)=Tuple{d=self.name}}.c.d");
Object result5 = ocl.evaluate(param, expression5);
assertNull(result5);
}
/**
* Ensures that an OclInvalid value does not pass a select filter, yet the select iterator
* returns a valid result
*/
@Test
public void testParseAndEvaluateOclExpressionWithCollectOfNullValue() throws ParserException
{
OCLExpression expression5 = oclHelper.createQuery("Set{1, 2}->collect(null)");
Object result5 = ocl.evaluate(param, expression5);
assertEquals(2, ((Collection<?>) result5).size());
assertTrue(((Collection<?>) result5).contains(null));
}
/**
* Ensures that an OclInvalid value does not pass a select filter, yet the select iterator
* returns a valid result
*/
@Test
public void testParseAndEvaluateOclExpressionWithIncludingNullInSequence() throws ParserException
{
OCLExpression expression5 = oclHelper.createQuery("Sequence{1}->including(null)");
Object result5 = ocl.evaluate(param, expression5);
assertEquals(2, ((Collection<?>) result5).size());
assertTrue(((Collection<?>) result5).contains(null));
}
/**
* Ensures that an OclInvalid value does not pass a select filter, yet the select iterator
* returns a valid result
*/
@Test
public void testParseAndEvaluateOclExpressionWithSizeOverSequenceContainingNull() throws ParserException
{
OCLExpression expression5 = oclHelper.createQuery("Sequence{1}->including(null)->size()");
Object result5 = ocl.evaluate(param, expression5);
assertEquals(2, result5);
}
/**
* Ensures that an OclInvalid value does not pass a select filter, yet the select iterator
* returns a valid result
*/
@Test
public void testParseAndEvaluateOclExpressionWithCollectOverOclInvalid() throws ParserException
{
OCLExpression expression5 = oclHelper.createQuery("Set{self, invalid}->collect(i | i)");
Object result5 = ocl.evaluate(param, expression5);
assertInvalid(result5);
}
/**
* Ensures that an OclInvalid value propagates from a collection literal to the overall expression
*/
@Test
public void testParseAndEvaluateOclExpressionWithSelectOverOclInvalid() throws ParserException
{
OCLExpression expression5 = oclHelper.createQuery("Set{self, invalid}->select(i | i.name = 'p')");
Object result5 = ocl.evaluate(param, expression5);
assertInvalid(result5);
}
@Test
public void testParseAndEvaluateOclExpression() throws ParserException
{
OCLExpression expression = oclHelper.createQuery("self.ownedTypeDefinition.oclAsType(data::classes::ClassTypeDefinition).clazz");
Object result = ocl.evaluate(param, expression);
assertEquals(class1, result);
}
@Test
public void testParseAndEvaluateOclExpressionWithOperationCallOnNullValue() throws ParserException
{
param.setOwnedTypeDefinition(null);
OCLExpression expression2 = oclHelper.createQuery("self.ownedTypeDefinition.getInnermost()");
Object result = ocl.evaluate(param, expression2);
assertEquals(ocl.getEnvironment().getOCLStandardLibrary().getInvalid(), result);
}
@Test
public void testParseAndEvaluateOclExpressionWithPropertyCallOnNullValue() throws ParserException
{
param.setOwnedTypeDefinition(null);
OCLExpression expression2 = oclHelper.createQuery("self.ownedTypeDefinition.oclAsType(data::classes::ClassTypeDefinition).clazz.oclIsInvalid()");
Object result2 = ocl.evaluate(param, expression2);
assertTrue((Boolean)result2);
}
@Test
public void testParseAndEvaluateOclExpressionWithCollectOverNullValue() throws ParserException
{
param.setOwnedTypeDefinition(null);
OCLExpression expression3 = oclHelper.createQuery("self.ownedTypeDefinition.oclAsType(data::classes::ClassTypeDefinition)->collect(clazz)");
Object result3 = ocl.evaluate(param, expression3);
assertEquals(0, ((Collection< ? >)result3).size());
}
@Test
public void testParseAndEvaluateOclExpressionCollectWithBodyEvaluatingToNull() throws ParserException
{
param.setOwnedTypeDefinition(ctd);
ctd.setClazz(null);
OCLExpression expression4 = oclHelper.createQuery("self.ownedTypeDefinition.oclAsType(data::classes::ClassTypeDefinition)->collect(clazz)");
Object result4 = ocl.evaluate(param, expression4);
assertTrue(((Bag< ? >)result4).contains(null));
}
@Test
public void testParseAndEvaluateOclExpressionWithImplicitCollectOverOperationCallResult() throws ParserException
{
OCLExpression expression4 = oclHelper.createQuery("self.ownedTypeDefinition.oclAsType(data::classes::ClassTypeDefinition).clazz.getAssociationEnds().otherEnd()");
Object result4 = ocl.evaluate(param, expression4);
assertTrue(((Collection<?>) result4).isEmpty());
}
@Test
public void testParseAndEvaluateOclExpressionWithDelegatesToSimulation() throws ParserException
{
OCLExpression expression4 = oclHelper.createQuery("self.ownedTypeDefinition.oclAsType(data::classes::ClassTypeDefinition).clazz.getAssociationEnds().otherEnd()->select(delegation->notEmpty()).type.clazz->reject(c|c=self)->asSet()");
Object result4 = ocl.evaluate(param, expression4);
assertTrue(((Collection<?>) result4).isEmpty());
}
@Test
public void testParseAndEvaluateOclExpressionWithImplicitSetLiteral() throws ParserException
{
OCLExpression expression4 = oclHelper.createQuery("self.ownedTypeDefinition->isEmpty()");
Object result4 = ocl.evaluate(param, expression4);
assertFalse((Boolean) result4);
}
@Test
public void testParseAndEvaluateOclExpressionWithImplicitSetLiteralCheckingForIsEmpty() throws ParserException
{
param.setOwnedTypeDefinition(null);
OCLExpression expression5 = oclHelper.createQuery("self.ownedTypeDefinition->isEmpty()");
Object result5 = ocl.evaluate(param, expression5);
assertTrue((Boolean) result5);
}
@Test
public void testParseAndEvaluateOclExpressionWithNullInSetLiteral() throws ParserException
{
param.setOwnedTypeDefinition(null);
OCLExpression expression5 = oclHelper.createQuery("Set{null}->isEmpty()");
Object result5 = ocl.evaluate(param, expression5);
assertFalse((Boolean) result5);
OCLExpression expression6 = oclHelper.createQuery("null->isEmpty()");
Object result6 = ocl.evaluate(param, expression6);
assertTrue((Boolean) result6);
}
@Test
public void testParseAndEvaluateOclExpressionWithEmptySetLiteralIncludingNull() throws ParserException
{
OCLExpression expression4 = oclHelper.createQuery("Set{}->including(null)->isEmpty()");
Object result4 = ocl.evaluate(param, expression4);
assertFalse((Boolean) result4);
}
}