incubator-imperius-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jnee...@apache.org
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 GMT
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 <prabalig@in.ibm.com>
+ *
+ */
+
+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 ...]


Mime
View raw message