/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
//
/**
* @author Prashant Baliga <prabalig@in.ibm.com>
*
*/
package org.apache.imperius.spl.tests;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Vector;
import java.util.logging.Logger;
import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.apache.imperius.spl.core.Expression;
import org.apache.imperius.spl.parser.exceptions.SPLException;
import org.apache.imperius.spl.parser.expressions.impl.BooleanConstant;
import org.apache.imperius.spl.parser.expressions.impl.DateTimeConstant;
import org.apache.imperius.spl.parser.expressions.impl.DoubleConstant;
import org.apache.imperius.spl.parser.expressions.impl.Equal;
import org.apache.imperius.spl.parser.expressions.impl.FloatConstant;
import org.apache.imperius.spl.parser.expressions.impl.Greater;
import org.apache.imperius.spl.parser.expressions.impl.GreaterOrEqual;
import org.apache.imperius.spl.parser.expressions.impl.IntegerConstant;
import org.apache.imperius.spl.parser.expressions.impl.Less;
import org.apache.imperius.spl.parser.expressions.impl.LessOrEqual;
import org.apache.imperius.spl.parser.expressions.impl.LogicalAnd;
import org.apache.imperius.spl.parser.expressions.impl.LogicalNot;
import org.apache.imperius.spl.parser.expressions.impl.LogicalOr;
import org.apache.imperius.spl.parser.expressions.impl.LogicalXor;
import org.apache.imperius.spl.parser.expressions.impl.LongConstant;
import org.apache.imperius.spl.parser.expressions.impl.NotEqual;
import org.apache.imperius.spl.parser.expressions.impl.ShortConstant;
import org.apache.imperius.spl.parser.expressions.impl.StringConstant;
import org.apache.imperius.spl.parser.expressions.impl.ToBoolean;
import org.apache.imperius.util.SPLLogger;
public class BooleanExpressionTest extends TestCase {
static final String CMVC_ID_BooleanExpressionTest = "$Header: /cvsroot/cimsplpegasus/trunk/modules/imperius-splcore/src/com/ibm/ac/spl/tests/BooleanExpressionTest.java,v 1.2 2007/12/20 13:07:37 prabalig Exp $";
static final String VERSION_BooleanExpressionTest = "File version $Revision: 1.2 $, last changed $Date: 2007/12/20 13:07:37 $";
private static Logger logger = SPLLogger.getSPLLogger().getLogger();
static Expression propertySensor1 =null;
//new ConstantExpression("propertySensor1");
static Expression propertySensor2 =null;
//new PropertySensor("propertySensor2");
static Expression propertySensor3 =null;
//new PropertySensor("propertySensor3");
static Expression propertySensor4 =null;
//new PropertySensor("propertySensor4");
static Expression propertySensor5 =null;
//new PropertySensor("propertySensor5");
static Expression propertySensor6 =null;
//new PropertySensor("propertySensor6");
static Expression propertySensor7 =null;
//new PropertySensor("propertySensor7");
static Expression propertySensor8 =null;
//new PropertySensor("propertySensor8");
static Expression propertySensor9 =null;
//new PropertySensor("propertySensor9");
static Expression propertySensor10 =null;
//new PropertySensor("propertySensor10");
public BooleanExpressionTest(String arg0) {
super(arg0);
}
public static Test suite() {
TestSuite suite = new TestSuite(BooleanExpressionTest.class);
TestSetup wrapper = new TestSetup(suite) {
protected void setUp() throws Exception {
oneTimeSetUp();
}
protected void tearDown() throws Exception {
oneTimeTearDown();
}
};
return wrapper;
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
protected static void oneTimeSetUp() throws Exception {
}
protected static void oneTimeTearDown() throws Exception {
}
/*
* This will test equals for a variety of boolean arguments.
*/
public void testEqualExpressionWithBooleanArguments() {
/* When one is true and one is false. They should not be
* equal.
*/
////HashMap map = new HashMap();
propertySensor1=new BooleanConstant(true);
propertySensor2=new BooleanConstant(false);
propertySensor3=new BooleanConstant(true);
//propertySensor2=new BooleanConstant(false));
//propertySensor3=new BooleanConstant(true));
// //SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 == Property2 (true == false) = false
List v = new ArrayList();
v.add(propertySensor1);
v.add(propertySensor2);
Expression firstExpression = new Equal(v,true);
// Property1 == Property3 (true == true) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression secondExpression = new Equal(v,true);
// Property1 == ConstantTrue (true==true) = true
v.clear();
v.add(propertySensor1);
v.add(new BooleanConstant(true));
Expression thirdExpression = new Equal(v,true);
// ConstantFalse == ConstantTrue (false==true) = false
v.clear();
v.add(new BooleanConstant(false));
v.add(new BooleanConstant(true));
Expression fourthExpression = new Equal(v,true);
//System.out.println("((Boolean) firstExpression.evaluate()).booleanValue())"+ firstExpression.evaluate());
assertFalse(
((Boolean) firstExpression.evaluate()).booleanValue());
assertTrue(
((Boolean) secondExpression.evaluate()).booleanValue());
assertTrue(
((Boolean) thirdExpression.evaluate()).booleanValue());
assertFalse(
((Boolean) fourthExpression.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
/*
* This will test equals for a variety of numeric arguments.
*/
public void testEqualExpressionWithNumericArguments() {
checkEqualExpressionWithNumericArgumentsShortAgainstShort();
checkEqualExpressionWithNumericArgumentsShortAgainstInteger();
checkEqualExpressionWithNumericArgumentsShortAgainstLong();
checkEqualExpressionWithNumericArgumentsShortAgainstFloat();
checkEqualExpressionWithNumericArgumentsShortAgainstDouble();
checkEqualExpressionWithNumericArgumentsIntegerAgainstInteger();
checkEqualExpressionWithNumericArgumentsIntegerAgainstFloat();
checkEqualExpressionWithNumericArgumentsIntegerAgainstDouble();
checkEqualExpressionWithNumericArgumentsLongAgainstLong();
checkEqualExpressionWithNumericArgumentsLongAgainstFloat();
checkEqualExpressionWithNumericArgumentsLongAgainstDouble();
checkEqualExpressionWithNumericArgumentsFloatAgainstFloat();
checkEqualExpressionWithNumericArgumentsFloatAgainstDouble();
checkEqualExpressionWithNumericArgumentsDoubleAgainstDouble();
}
public void checkEqualExpressionWithNumericArgumentsShortAgainstShort() {
////HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 500);
propertySensor2=new ShortConstant((short) 500);
propertySensor3=new ShortConstant((short) 499);
propertySensor4=new ShortConstant((short) 501);
propertySensor5=new ShortConstant((short) - 500);
//propertySensor1=new Short((short) 500));
//propertySensor2=new Short((short) 500));
//propertySensor3=new Short((short) 499));
//propertySensor4=new Short((short) 501));
//propertySensor5=new Short((short) - 500));
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new ShortConstant((short) 500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new ShortConstant((short) - 100));
v.add(new ShortConstant((short) 100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsShortAgainstInteger() {
////HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 500);
propertySensor2=new IntegerConstant(500);
propertySensor3=new IntegerConstant(499);
propertySensor4=new IntegerConstant(501);
propertySensor5=new IntegerConstant(501);
//propertySensor1=new Short((short) 500));
//propertySensor2=new IntegerConstant(500));
//propertySensor3=new IntegerConstant(499));
//propertySensor4=new IntegerConstant(501));
//propertySensor5=new IntegerConstant(501));
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Constant (not equal)
v.clear();
v.add(new ShortConstant((short) - 100));
v.add(new IntegerConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsShortAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 500);
propertySensor2=new LongConstant(500);
propertySensor3=new LongConstant(499);
propertySensor4=new LongConstant(501);
propertySensor5=new LongConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new ShortConstant((short) - 100));
v.add(new LongConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsShortAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 500);
propertySensor2=new FloatConstant(500);
propertySensor3=new FloatConstant(499);
propertySensor4=new FloatConstant(501);
propertySensor5=new FloatConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Constant (not equal)
v.clear();
v.add(new ShortConstant((short) - 100));
v.add(new FloatConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsShortAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 500);
propertySensor2=new DoubleConstant(500);
propertySensor3=new DoubleConstant(499);
propertySensor4=new DoubleConstant(501);
propertySensor5=new DoubleConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new ShortConstant((short) - 100));
v.add(new DoubleConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsIntegerAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(500);
propertySensor2=new IntegerConstant(500);
propertySensor3=new IntegerConstant(499);
propertySensor4=new IntegerConstant(501);
propertySensor5=new IntegerConstant(-500);
////SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constant (not equal)
v.clear();
v.add(new IntegerConstant(-100));
v.add(new IntegerConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsIntegerAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(500);
propertySensor2=new LongConstant(500);
propertySensor3=new LongConstant(499);
propertySensor4=new LongConstant(501);
propertySensor5=new LongConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new IntegerConstant(-100));
v.add(new LongConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsIntegerAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(500);
propertySensor2=new FloatConstant(500);
propertySensor3=new FloatConstant(499);
propertySensor4=new FloatConstant(501);
propertySensor5=new FloatConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new IntegerConstant(-100));
v.add(new FloatConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsIntegerAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(500);
propertySensor2=new DoubleConstant(500);
propertySensor3=new DoubleConstant(499);
propertySensor4=new DoubleConstant(501);
propertySensor5=new DoubleConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new IntegerConstant(-100));
v.add(new DoubleConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsLongAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(500);
propertySensor2=new LongConstant(500);
propertySensor3=new LongConstant(499);
propertySensor4=new LongConstant(501);
propertySensor5=new LongConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new LongConstant(-100));
v.add(new LongConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsLongAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(500);
propertySensor2=new FloatConstant(500);
propertySensor3=new FloatConstant(499);
propertySensor4=new FloatConstant(501);
propertySensor5=new FloatConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new LongConstant(-100));
v.add(new FloatConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsLongAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(500);
propertySensor2=new DoubleConstant(500);
propertySensor3=new DoubleConstant(499);
propertySensor4=new DoubleConstant(501);
propertySensor5=new DoubleConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new LongConstant(-100));
v.add(new DoubleConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsFloatAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(500);
propertySensor2=new FloatConstant(500);
propertySensor3=new FloatConstant(499);
propertySensor4=new FloatConstant(501);
propertySensor5=new FloatConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constant (not equal)
v.clear();
v.add(new FloatConstant(-100));
v.add(new FloatConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsFloatAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(500);
propertySensor2=new DoubleConstant(500);
propertySensor3=new DoubleConstant(499);
propertySensor4=new DoubleConstant(501);
propertySensor5=new DoubleConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new FloatConstant(-100));
v.add(new DoubleConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkEqualExpressionWithNumericArgumentsDoubleAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new DoubleConstant(500);
propertySensor2=new DoubleConstant(500);
propertySensor3=new DoubleConstant(499);
propertySensor4=new DoubleConstant(501);
propertySensor5=new DoubleConstant(-500);
//SensorLookup lookup = new SensorLookupImpl(map);
Vector v = new Vector();
try {
//propertySensor1 == propertySensor2
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression12 = new Equal(v,true);
//propertySensor1 != propertySensor3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression13 = new Equal(v,true);
//propertySensor1 != propertySensor4
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression14 = new Equal(v,true);
//propertySensor1 != propertySensor5
v.clear();
v.add(propertySensor1);
v.add(propertySensor5);
Expression expression15 = new Equal(v,true);
//One sensor w/ one Constant (equal)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(500));
Expression expressionIntegerConstant1 = new Equal(v,true);
//Two Constants (not equal)
v.clear();
v.add(new DoubleConstant(-100));
v.add(new DoubleConstant(100));
Expression expressionIntegerConstant2 = new Equal(v,true);
assertTrue(
((Boolean) expression12.evaluate()).booleanValue());
assertFalse(
((Boolean) expression13.evaluate()).booleanValue());
assertFalse(
((Boolean) expression14.evaluate()).booleanValue());
assertFalse(
((Boolean) expression15.evaluate()).booleanValue());
assertTrue(
((Boolean) expressionIntegerConstant1.evaluate())
.booleanValue());
assertFalse(
((Boolean) expressionIntegerConstant2.evaluate())
.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
// TODO put code here
/*
* This will test equals for string arguments.
*/
public void testEqualExpressionWithStringArguments() {
//HashMap map = new HashMap();
propertySensor1=new StringConstant("test");
propertySensor2=new StringConstant("testing");
propertySensor3=new StringConstant("test");
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 != Property2
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression firstExpression = new Equal(v,true);
// Property1 == Property3
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression secondExpression = new Equal(v,true);
// Property1 == StringConstant("test");
v.clear();
v.add(propertySensor1);
v.add(new StringConstant("test"));
Expression thirdExpression = new Equal(v,true);
// StringConstant("test") != StringConstant("testing")
v.clear();
v.add(new StringConstant("test"));
v.add(new StringConstant("testing"));
Expression fourthExpression = new Equal(v,true);
assertFalse(
((Boolean) firstExpression.evaluate()).booleanValue());
assertTrue(
((Boolean) secondExpression.evaluate()).booleanValue());
assertTrue(
((Boolean) thirdExpression.evaluate()).booleanValue());
assertFalse(
((Boolean) fourthExpression.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
/*
* This will test greater for numeric arguments.
*/
public void testGreaterExpressionWithNumericArguments() {
checkGreaterExpressionWithNumericArgumentsShortAgainstShort();
checkGreaterExpressionWithNumericArgumentsShortAgainstInteger();
checkGreaterExpressionWithNumericArgumentsShortAgainstLong();
checkGreaterExpressionWithNumericArgumentsShortAgainstFloat();
checkGreaterExpressionWithNumericArgumentsShortAgainstDouble();
checkGreaterExpressionWithNumericArgumentsIntegerAgainstInteger();
checkGreaterExpressionWithNumericArgumentsIntegerAgainstLong();
checkGreaterExpressionWithNumericArgumentsIntegerAgainstFloat();
checkGreaterExpressionWithNumericArgumentsIntegerAgainstDouble();
checkGreaterExpressionWithNumericArgumentsLongAgainstLong();
checkGreaterExpressionWithNumericArgumentsLongAgainstFloat();
checkGreaterExpressionWithNumericArgumentsLongAgainstDouble();
checkGreaterExpressionWithNumericArgumentsFloatAgainstFloat();
checkGreaterExpressionWithNumericArgumentsFloatAgainstDouble();
checkGreaterExpressionWithNumericArgumentsDoubleAgainstDouble();
}
public void checkGreaterExpressionWithNumericArgumentsShortAgainstShort() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new ShortConstant((short) 5);
propertySensor3=new ShortConstant((short) - 20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new ShortConstant((short) 5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new ShortConstant((short) 20));
Expression expression4 = new Greater(v,true);
//TODO at least one comparison for each of the numeric types against another numeric type
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsShortAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new IntegerConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsShortAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new LongConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsShortAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new FloatConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsShortAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new DoubleConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsIntegerAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new IntegerConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsIntegerAgainstLong() {
////HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new LongConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsIntegerAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
// Property1 > Property2 (20 > 5) = true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new FloatConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsIntegerAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsLongAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new LongConstant(-20));
v.add(new LongConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsLongAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new LongConstant(-20));
v.add(new FloatConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsLongAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new LongConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsFloatAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new FloatConstant(-20));
v.add(new FloatConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsFloatAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new FloatConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterExpressionWithNumericArgumentsDoubleAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new DoubleConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new Greater(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new Greater(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Greater(v,true);
v.clear();
v.add(new DoubleConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Greater(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
/*
* This will test GeaterEqual with numeric arguments.
*/
public void testGreaterOrEqualExpressionWithNumericArguments() {
checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstShort();
checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstInteger();
checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstLong();
checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstFloat();
checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstDouble();
checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstInteger();
checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstLong();
checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstFloat();
checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstDouble();
checkGreaterOrEqualExpressionWithNumericArgumentsLongAgainstLong();
checkGreaterOrEqualExpressionWithNumericArgumentsLongAgainstFloat();
checkGreaterOrEqualExpressionWithNumericArgumentsLongAgainstDouble();
checkGreaterOrEqualExpressionWithNumericArgumentsFloatAgainstFloat();
checkGreaterOrEqualExpressionWithNumericArgumentsFloatAgainstDouble();
checkGreaterOrEqualExpressionWithNumericArgumentsDoubleAgainstDouble();
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstShort() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new ShortConstant((short) 5);
propertySensor3=new ShortConstant((short) - 20);
propertySensor4=new ShortConstant((short) 20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new ShortConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new ShortConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new ShortConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
propertySensor4=new IntegerConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new IntegerConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
propertySensor4=new LongConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new LongConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new FloatConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsShortAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new DoubleConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
propertySensor4=new IntegerConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new IntegerConstant((short) - 20));
v.add(new IntegerConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
propertySensor4=new LongConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new IntegerConstant((short) - 20));
v.add(new LongConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new IntegerConstant((short) - 20));
v.add(new FloatConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsIntegerAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant((short) 5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant((short) 20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new IntegerConstant((short) - 20));
v.add(new DoubleConstant((short) 20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsLongAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
propertySensor4=new LongConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new LongConstant(-20));
v.add(new LongConstant(20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsLongAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new LongConstant(-20));
v.add(new FloatConstant(20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsLongAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new LongConstant(-20));
v.add(new DoubleConstant(20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsFloatAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new FloatConstant(-20));
v.add(new FloatConstant(20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsFloatAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new FloatConstant(-20));
v.add(new DoubleConstant(20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkGreaterOrEqualExpressionWithNumericArgumentsDoubleAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new DoubleConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 > Property2 (20 > 5) = true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new GreaterOrEqual(v,true);
// Property3 > Property1 (-20 > 20) = false
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new GreaterOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new GreaterOrEqual(v,true);
// Property1 > 5 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new GreaterOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new GreaterOrEqual(v,true);
//-20 > 20 (false)
v.clear();
v.add(new DoubleConstant(-20));
v.add(new DoubleConstant(20));
Expression expression6 = new GreaterOrEqual(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertFalse(
((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
/*
* This will test Less with numeric arguments.
*/
public void testLessExpressionWithNumericArguments() {
checkLessExpressionWithNumericArgumentsShortAgainstShort();
checkLessExpressionWithNumericArgumentsShortAgainstInteger();
checkLessExpressionWithNumericArgumentsShortAgainstLong();
checkLessExpressionWithNumericArgumentsShortAgainstFloat();
checkLessExpressionWithNumericArgumentsShortAgainstDouble();
checkLessExpressionWithNumericArgumentsIntegerAgainstInteger();
checkLessExpressionWithNumericArgumentsIntegerAgainstLong();
checkLessExpressionWithNumericArgumentsIntegerAgainstFloat();
checkLessExpressionWithNumericArgumentsIntegerAgainstDouble();
checkLessExpressionWithNumericArgumentsLongAgainstLong();
checkLessExpressionWithNumericArgumentsLongAgainstFloat();
checkLessExpressionWithNumericArgumentsLongAgainstDouble();
checkLessExpressionWithNumericArgumentsFloatAgainstFloat();
checkLessExpressionWithNumericArgumentsFloatAgainstDouble();
checkLessExpressionWithNumericArgumentsDoubleAgainstDouble();
}
public void checkLessExpressionWithNumericArgumentsShortAgainstShort() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new ShortConstant((short) 5);
propertySensor3=new ShortConstant((short) - 20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new ShortConstant((short) 5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new ShortConstant((short) -20));
v.add(new ShortConstant((short) 20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsShortAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new IntegerConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsShortAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new LongConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsShortAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new FloatConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsShortAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new DoubleConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsIntegerAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new IntegerConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsIntegerAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new LongConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsIntegerAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new FloatConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsIntegerAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new IntegerConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsLongAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new LongConstant(-20));
v.add(new LongConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsLongAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new LongConstant(-20));
v.add(new FloatConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsLongAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new LongConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsFloatAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new FloatConstant(-20));
v.add(new FloatConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsFloatAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new FloatConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessExpressionWithNumericArgumentsDoubleAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new DoubleConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = true
try {
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression1 = new Less(v,true);
// Property1 < Property3 (20 < -20) = false
v.clear();
v.add(propertySensor1);
v.add(propertySensor3);
Expression expression2 = new Less(v,true);
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression3 = new Less(v,true);
v.clear();
v.add(new DoubleConstant(-20));
v.add(new DoubleConstant(20));
Expression expression4 = new Less(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
/*
* This will test LessOrEqual with numeric arguments.
*/
public void testLessOrEqualExpressionWithNumericArguments() {
checkLessOrEqualExpressionWithNumericArgumentsShortAgainstShort();
checkLessOrEqualExpressionWithNumericArgumentsShortAgainstInteger();
checkLessOrEqualExpressionWithNumericArgumentsShortAgainstLong();
checkLessOrEqualExpressionWithNumericArgumentsShortAgainstFloat();
checkLessOrEqualExpressionWithNumericArgumentsShortAgainstDouble();
checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstInteger();
checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstLong();
checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstFloat();
checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstDouble();
checkLessOrEqualExpressionWithNumericArgumentsLongAgainstLong();
checkLessOrEqualExpressionWithNumericArgumentsLongAgainstFloat();
checkLessOrEqualExpressionWithNumericArgumentsLongAgainstDouble();
checkLessOrEqualExpressionWithNumericArgumentsFloatAgainstFloat();
checkLessOrEqualExpressionWithNumericArgumentsFloatAgainstDouble();
checkLessOrEqualExpressionWithNumericArgumentsDoubleAgainstDouble();
}
public void checkLessOrEqualExpressionWithNumericArgumentsShortAgainstShort() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new ShortConstant((short) 5);
propertySensor3=new ShortConstant((short) - 20);
propertySensor4=new ShortConstant((short) 20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new ShortConstant((short) 5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new ShortConstant((short) 20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new ShortConstant((short) 20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsShortAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
propertySensor4=new IntegerConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new IntegerConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsShortAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
propertySensor4=new LongConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new LongConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsShortAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new FloatConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsShortAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new ShortConstant((short) 20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new ShortConstant((short) - 20));
v.add(new DoubleConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstInteger() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new IntegerConstant(5);
propertySensor3=new IntegerConstant(-20);
propertySensor4=new IntegerConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new IntegerConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new IntegerConstant(-20));
v.add(new IntegerConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
propertySensor4=new LongConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new IntegerConstant(-20));
v.add(new LongConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new IntegerConstant(-20));
v.add(new FloatConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsIntegerAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new IntegerConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new IntegerConstant(-20));
v.add(new DoubleConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsLongAgainstLong() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new LongConstant(5);
propertySensor3=new LongConstant(-20);
propertySensor4=new LongConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new LongConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new LongConstant(-20));
v.add(new LongConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsLongAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new LongConstant(-20));
v.add(new FloatConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsLongAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new LongConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new LongConstant(-20));
v.add(new DoubleConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsFloatAgainstFloat() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new FloatConstant(5);
propertySensor3=new FloatConstant(-20);
propertySensor4=new FloatConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new FloatConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new FloatConstant(-20));
v.add(new FloatConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsFloatAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new FloatConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new FloatConstant(-20));
v.add(new DoubleConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void checkLessOrEqualExpressionWithNumericArgumentsDoubleAgainstDouble() {
//HashMap map = new HashMap();
propertySensor1=new DoubleConstant(20);
propertySensor2=new DoubleConstant(5);
propertySensor3=new DoubleConstant(-20);
propertySensor4=new DoubleConstant(20);
//SensorLookup lookup = new SensorLookupImpl(map);
// Property1 < Property2 (20 < 5) = false
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LessOrEqual(v,true);
// Property3 < Property1 (-20 < 20) = true
v.clear();
v.add(propertySensor3);
v.add(propertySensor1);
Expression expression2 = new LessOrEqual(v,true);
// Property1 == Property4 (20 == 20) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor4);
Expression expression3 = new LessOrEqual(v,true);
// Property1 < 5 (false)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(5));
Expression expression4 = new LessOrEqual(v,true);
//Property1 == 20 (true)
v.clear();
v.add(propertySensor1);
v.add(new DoubleConstant(20));
Expression expression5 = new LessOrEqual(v,true);
//-20 < 20 (true)
v.clear();
v.add(new DoubleConstant(-20));
v.add(new DoubleConstant(20));
Expression expression6 = new LessOrEqual(v,true);
assertFalse(
((Boolean) expression1.evaluate()).booleanValue());
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertTrue(((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
/*
* This will test Not for a variety of boolean arguments.
*/
// public void testNotExpressionWithBooleanArguments() {
// /* When one is true and one is false. They should not be
// * equal.
// */
// //HashMap map = new HashMap();
// propertySensor1=new BooleanConstant(true));
// propertySensor2=new BooleanConstant(false));
// //SensorLookup lookup = new SensorLookupImpl(map);
//
// //!propertySensor1 = false
// Expression expression1 = new Not(propertySensor1);
//
// // !propertySensor2 = true
// Expression expression2 = new Not(propertySensor2);
//
// //!BooleanConstant(true) = false
// Expression expression3 = new Not(new BooleanConstant(true));
//
// //!BooleanConstant(false) = true
// Expression expression4 = new Not(new BooleanConstant(false));
//
// try {
// boolean value1 =((Boolean) expression1.evaluate()).booleanValue();
// boolean value2 =((Boolean) expression2.evaluate()).booleanValue();
// boolean value3 =((Boolean) expression3.evaluate()).booleanValue();
// boolean value4 =((Boolean) expression4.evaluate()).booleanValue();
// assertFalse(value1);
// assertTrue(value2);
// assertFalse(value3);
// assertTrue(value4);
// } catch (SPLException e) { logger.severe("Received evaluation exception " + e.getMessage());
// fail("Received evaluation exception " + e.getMessage());
// }
// }
/*
* This will test Or for a variety of boolean arguments.
*/
public void testOrExpressionWithBooleanArguments() throws SPLException {
/* When one is true and one is false. They should not be
* equal.
*/
//HashMap map = new HashMap();
propertySensor1=new BooleanConstant(true);
propertySensor2=new BooleanConstant(true);
propertySensor3=new BooleanConstant(true);
propertySensor4=new BooleanConstant(true);
propertySensor5=new BooleanConstant(true);
propertySensor6=new BooleanConstant(false);
propertySensor7=new BooleanConstant(false);
propertySensor8=new BooleanConstant(false);
propertySensor9=new BooleanConstant(false);
propertySensor10=new BooleanConstant(false);
//SensorLookup lookup = new SensorLookupImpl(map);
//true
try {
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LogicalOr(v,true);
//false
v.clear();
v.add(propertySensor6);
v.add(propertySensor7);
Expression expression2 = new LogicalOr(v,true);
//true
v.clear();
v.add(propertySensor1);
v.add(propertySensor6);
Expression expression3 = new LogicalOr(v,true);
//true
v.clear();
v.add(propertySensor1);
v.add(new BooleanConstant(false));
Expression expression4 = new LogicalOr(v,true);
//false
v.clear();
v.add(new BooleanConstant(false));
v.add(new BooleanConstant(false));
Expression expression5 = new LogicalOr(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(((Boolean) expression3.evaluate()).booleanValue());
assertTrue(((Boolean) expression4.evaluate()).booleanValue());
assertFalse(
((Boolean) expression5.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
/*
* This will test And for a variety of boolean arguments.
*/
public void testAndExpressionWithBooleanArguments() {
/* When one is true and one is false. They should not be
* equal.
*/
//HashMap map = new HashMap();
propertySensor1=new BooleanConstant(true);
propertySensor2=new BooleanConstant(true);
propertySensor3=new BooleanConstant(true);
propertySensor4=new BooleanConstant(true);
propertySensor5=new BooleanConstant(true);
propertySensor6=new BooleanConstant(false);
propertySensor7=new BooleanConstant(false);
propertySensor8=new BooleanConstant(false);
propertySensor9=new BooleanConstant(false);
propertySensor10=new BooleanConstant(false);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
//true
Vector v = new Vector();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression1 = new LogicalAnd(v,true);
//false
v.clear();
v.add(propertySensor6);
v.add(propertySensor7);
Expression expression2 = new LogicalAnd(v,true);
//false
v.clear();
v.add(propertySensor1);
v.add(propertySensor6);
Expression expression3 = new LogicalAnd(v,true);
//false
v.clear();
v.add(propertySensor1);
v.add(new BooleanConstant(false));
Expression expression4 = new LogicalAnd(v,true);
//false
v.clear();
v.add(new BooleanConstant(true));
v.add(new BooleanConstant(false));
Expression expression5 = new LogicalAnd(v,true);
//true
v.clear();
v.add(new BooleanConstant(true));
v.add(new BooleanConstant(true));
Expression expression6 = new LogicalAnd(v,true);
assertTrue(((Boolean) expression1.evaluate()).booleanValue());
assertFalse(
((Boolean) expression2.evaluate()).booleanValue());
assertFalse(
((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
assertFalse(
((Boolean) expression5.evaluate()).booleanValue());
assertTrue(((Boolean) expression6.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void testNotExpressionWithBooleanArguments() {
/* When one is true and one is false. They should not be
* equal.
*/
//HashMap map = new HashMap();
propertySensor1=new BooleanConstant(true);
propertySensor2=new BooleanConstant(false);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
//true
Vector v = new Vector();
v.add(propertySensor1);
Expression expression1 = new LogicalNot(v,true);
//false
v.clear();
v.add(propertySensor6);
Expression expression2 = new LogicalNot(v,true);
assertTrue(((Boolean) expression2.evaluate()).booleanValue());
assertFalse(((Boolean) expression1.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void testXorExpressionWithBooleanArguments() {
/* When one is true and one is false. They should not be
* equal.
*/
//HashMap map = new HashMap();
propertySensor1=new BooleanConstant(true);
propertySensor2=new BooleanConstant(false);
//SensorLookup lookup = new SensorLookupImpl(map);
try {
//true
Vector v = new Vector();
v.add(propertySensor2);
v.add(propertySensor2);
Expression expression1 = new LogicalXor(v,true);
//false
v.clear();
v.add(propertySensor2);
v.add(propertySensor1);
Expression expression2 = new LogicalXor(v,true);
//false
v.clear();
v.add(propertySensor1);
v.add(propertySensor2);
Expression expression3 = new LogicalXor(v,true);
//false
v.clear();
v.add(propertySensor1);
v.add(propertySensor1);
Expression expression4 = new LogicalXor(v,true);
assertFalse(((Boolean) expression1.evaluate()).booleanValue());
assertTrue(
((Boolean) expression2.evaluate()).booleanValue());
assertTrue(
((Boolean) expression3.evaluate()).booleanValue());
assertFalse(
((Boolean) expression4.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void testToBoolean() {
propertySensor1=new IntegerConstant(243);
propertySensor2=new StringConstant("\"false\"");
try {
Vector v = new Vector();
v.add(propertySensor1);
Expression es1 = new ToBoolean(v,true);
v.clear();
v.add(propertySensor2);
Expression es2 = new ToBoolean(v,true);
Boolean x=(Boolean)es1.evaluate();
assertTrue(x.booleanValue());
x=(Boolean)es2.evaluate();
assertFalse(x.booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
fail("Received expression exception " + e.getMessage());
}
}
public void testNotEqual() {
/* When one is true and one is false. They should not be
* equal.
*/
////HashMap map = new HashMap();
Calendar c1 = Calendar.getInstance();
c1.setTime(Calendar.getInstance().getTime());
Calendar c2 = Calendar.getInstance();
c2.setTime(Calendar.getInstance().getTime());
c2.set(1990, 10, 12);
try {
propertySensor1=new BooleanConstant(true);
propertySensor2=new BooleanConstant(false);
propertySensor3=new BooleanConstant(true);
propertySensor4=new DateTimeConstant(c1);
propertySensor5=new DateTimeConstant(c2);
// Property1 == Property2 (true == false) = false
List v = new ArrayList();
v.add(propertySensor1);
v.add(propertySensor3);
Expression firstExpression = new NotEqual(v,true);
// Property1 == Property3 (true == true) = true
v.clear();
v.add(propertySensor1);
v.add(propertySensor2);
Expression secondExpression = new NotEqual(v,true);
v.clear();
v.add(propertySensor4);
v.add(propertySensor5);
Expression thirdExpression = new NotEqual(v,true);
// Property1 == ConstantTrue (true==true) = true
//System.out.println("c1 c2 :"+ c1.toString() + " "+c2.toString());
assertFalse(
((Boolean) firstExpression.evaluate()).booleanValue());
assertTrue(
((Boolean) secondExpression.evaluate()).booleanValue());
assertTrue(
((Boolean) thirdExpression.evaluate()).booleanValue());
} catch (SPLException e) {
logger.severe("Received evaluation exception " + e.getMessage());
e.printStackTrace();
fail("Received evaluation exception " + e.getMessage());
} catch (Exception e) {
logger.severe("Received evaluation exception " + e.getMessage());
e.printStackTrace();
fail("Received expression exception " + e.getMessage());
}
}
}