From imperius-commits-return-32-apmail-incubator-imperius-commits-archive=incubator.apache.org@incubator.apache.org Sat Dec 22 21:04:50 2007 Return-Path: Delivered-To: apmail-incubator-imperius-commits-archive@locus.apache.org Received: (qmail 45047 invoked from network); 22 Dec 2007 21:04:50 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.2) by minotaur.apache.org with SMTP; 22 Dec 2007 21:04:50 -0000 Received: (qmail 87359 invoked by uid 500); 22 Dec 2007 21:04:39 -0000 Delivered-To: apmail-incubator-imperius-commits-archive@incubator.apache.org Received: (qmail 87351 invoked by uid 500); 22 Dec 2007 21:04:39 -0000 Mailing-List: contact imperius-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: imperius-dev@incubator.apache.org Delivered-To: mailing list imperius-commits@incubator.apache.org Delivered-To: moderator for imperius-commits@incubator.apache.org Received: (qmail 39146 invoked by uid 99); 22 Dec 2007 19:35:46 -0000 X-ASF-Spam-Status: No, hits=-100.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r606479 [24/30] - in /incubator/imperius/trunk/trunk: ./ modules/ modules/imperius-javaspl/ modules/imperius-javaspl/resources/ modules/imperius-javaspl/resources/samples/ modules/imperius-javaspl/resources/samples/computersystem/ modules/i... Date: Sat, 22 Dec 2007 19:34:03 -0000 To: imperius-commits@incubator.apache.org From: jneeraj@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20071222193441.109481A9860@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/BooleanExpressionTest.java URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/BooleanExpressionTest.java?rev=606479&view=auto ============================================================================== --- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/BooleanExpressionTest.java (added) +++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/BooleanExpressionTest.java Sat Dec 22 11:33:46 2007 @@ -0,0 +1,5118 @@ +/* + * Licensed 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 + * + */ + +package org.apache.imperius.spl.tests; + + +import java.util.Calendar; +import java.util.Vector; +import java.util.List; +import java.util.ArrayList; +import java.util.logging.Logger; + +import org.apache.imperius.spl.external.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; + +import junit.extensions.TestSetup; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + + + +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); + [... 2948 lines stripped ...]