You are viewing a plain text version of this content. The canonical link for it is here.
Posted to imperius-commits@incubator.apache.org by jn...@apache.org on 2007/12/22 19:34:03 UTC
svn commit: r606479 [26/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...
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/NumericExpressionTest.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/NumericExpressionTest.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/NumericExpressionTest.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/tests/NumericExpressionTest.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,2466 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+
+
+package org.apache.imperius.spl.tests;
+
+
+import java.util.Vector;
+
+import org.apache.imperius.spl.external.Expression;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.expressions.impl.*;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+
+
+
+
+public class NumericExpressionTest extends TestCase {
+
+ static final String CMVC_ID_NumericExpressionTest = "$Header: /cvsroot/cimsplpegasus/trunk/modules/imperius-splcore/src/com/ibm/ac/spl/tests/NumericExpressionTest.java,v 1.2 2007/12/20 13:07:37 prabalig Exp $";
+ static final String VERSION_NumericExpressionTest = "File version $Revision: 1.2 $, last changed $Date: 2007/12/20 13:07:37 $";
+
+// private static Logger logger = SPLLogger.getCIMSPLLogger().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 NumericExpressionTest(String arg0) {
+ super(arg0);
+ }
+
+ public static Test suite() {
+ TestSuite suite = new TestSuite(NumericExpressionTest.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 {
+
+ }
+
+ /* public void testToUINT8() {
+ Byte sn1 = new Byte((byte)8);
+ Byte sn2 = new Byte((byte)9);
+ String s1 = "\""+sn1.toString()+"\"";
+ String s2 = "\""+sn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new ByteConstant(sn1.byteValue());
+ propertySensor4=new ByteConstant(sn2.byteValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToUINT8(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToUINT8(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn1.byteValue()));
+ Expression esn1 = new ToUINT8(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn2.byteValue()));
+ Expression esn2 = new ToUINT8(v,true);
+
+
+ UnsignedInt8 x=(UnsignedInt8)es1.evaluate();
+ assertTrue(x.byteValue()==(byte)8);
+ x=(UnsignedInt8)es2.evaluate();
+ assertTrue(x.byteValue()==(byte)9);
+ x=(UnsignedInt8)esn1.evaluate();
+ assertTrue(x.byteValue()==(byte)8);
+ x=(UnsignedInt8)esn2.evaluate();
+ assertTrue(x.byteValue()==(byte)9);
+
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ public void testToUINT16() {
+ Byte sn1 = new Byte((byte)8);
+ Byte sn2 = new Byte((byte)9);
+ String s1 = "\""+sn1.toString()+"\"";
+ String s2 = "\""+sn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new ByteConstant(sn1.byteValue());
+ propertySensor4=new ByteConstant(sn2.byteValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToUINT16(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToUINT16(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn1.byteValue()));
+ Expression esn1 = new ToUINT16(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn2.byteValue()));
+ Expression esn2 = new ToUINT16(v,true);
+
+
+ UnsignedInt16 x=(UnsignedInt16)es1.evaluate();
+ assertTrue(x.shortValue()==(short)8);
+ x=(UnsignedInt16)es2.evaluate();
+ assertTrue(x.shortValue()==(short)9);
+ x=(UnsignedInt16)esn1.evaluate();
+ assertTrue(x.shortValue()==(short)8);
+ x=(UnsignedInt16)esn2.evaluate();
+ assertTrue(x.shortValue()==(short)9);
+
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ public void testToUINT32() {
+ Byte sn1 = new Byte((byte)8);
+ Byte sn2 = new Byte((byte)9);
+ String s1 = "\""+sn1.toString()+"\"";
+ String s2 = "\""+sn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new ByteConstant(sn1.byteValue());
+ propertySensor4=new ByteConstant(sn2.byteValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToUINT32(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToUINT32(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn1.byteValue()));
+ Expression esn1 = new ToUINT32(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn2.byteValue()));
+ Expression esn2 = new ToUINT32(v,true);
+
+
+ UnsignedInt32 x=(UnsignedInt32)es1.evaluate();
+ assertTrue(x.intValue()==(int)8);
+ x=(UnsignedInt32)es2.evaluate();
+ assertTrue(x.intValue()==(int)9);
+ x=(UnsignedInt32)esn1.evaluate();
+ assertTrue(x.intValue()==(int)8);
+ x=(UnsignedInt32)esn2.evaluate();
+ assertTrue(x.intValue()==(int)9);
+
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ public void testToUINT64() {
+ Byte sn1 = new Byte((byte)8);
+ Byte sn2 = new Byte((byte)9);
+ String s1 = "\""+sn1.toString()+"\"";
+ String s2 = "\""+sn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new ByteConstant(sn1.byteValue());
+ propertySensor4=new ByteConstant(sn2.byteValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToUINT64(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToUINT64(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn1.byteValue()));
+ Expression esn1 = new ToUINT64(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn2.byteValue()));
+ Expression esn2 = new ToUINT64(v,true);
+
+
+ UnsignedInt64 x=(UnsignedInt64)es1.evaluate();
+ assertTrue(x.longValue()==(long)8);
+ x=(UnsignedInt64)es2.evaluate();
+ assertTrue(x.longValue()==(long)9);
+ x=(UnsignedInt64)esn1.evaluate();
+ assertTrue(x.longValue()==(long)8);
+ x=(UnsignedInt64)esn2.evaluate();
+ assertTrue(x.longValue()==(long)9);
+
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }*/
+
+ public void testToSINT8() {
+ Byte sn1 = new Byte(Byte.MAX_VALUE);
+ Byte sn2 = new Byte(Byte.MIN_VALUE);
+ String s1 = "\""+sn1.toString()+"\"";
+ String s2 = "\""+sn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new ByteConstant(sn1.byteValue());
+ propertySensor4=new ByteConstant(sn2.byteValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToSINT8(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToSINT8(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn1.byteValue()));
+ Expression esn1 = new ToSINT8(v,true);
+
+ v.clear();
+ v.add(new ByteConstant(sn2.byteValue()));
+ Expression esn2 = new ToSINT8(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ Expression eps1 = new ToSINT8(v,true);
+
+ v.clear();
+ v.add(propertySensor2);
+ Expression eps2 = new ToSINT8(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ Expression eps3 = new ToSINT8(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ Expression eps4 = new ToSINT8(v,true);
+
+ assertTrue(((Byte) es1.evaluate()).equals(sn1));
+ assertTrue(((Byte) es2.evaluate()).equals(sn2));
+ assertFalse(((Byte) es1.evaluate()).equals(sn2));
+ assertTrue(((Byte) esn1.evaluate()).equals(sn1));
+ assertTrue(((Byte) esn2.evaluate()).equals(sn2));
+ assertFalse(((Byte) esn1.evaluate()).equals(sn2));
+ s1 = s1.substring(1, s1.length()-1);
+ assertTrue(((Byte) eps1.evaluate()).equals(new Byte(s1)));
+ s2 = s2.substring(1, s2.length()-1);
+ assertTrue(((Byte) eps2.evaluate()).equals(new Byte(s2)));
+ assertTrue(((Byte) eps3.evaluate()).equals(sn1));
+ assertTrue(((Byte) eps4.evaluate()).equals(sn2));
+
+ assertSame(sn1.getClass(), (es1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test ToShort Expression
+ */
+ public void testToSINT16() {
+ Short sn1 = new Short(Short.MAX_VALUE);
+ Short sn2 = new Short(Short.MIN_VALUE);
+ String s1 = "\""+sn1.toString()+"\"";
+ String s2 = "\""+sn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new ShortConstant(sn1.shortValue());
+ propertySensor4=new ShortConstant(sn2.shortValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToSINT16(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToSINT16(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1.shortValue()));
+ Expression esn1 = new ToSINT16(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn2.shortValue()));
+ Expression esn2 = new ToSINT16(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ Expression eps1 = new ToSINT16(v,true);
+
+ v.clear();
+ v.add(propertySensor2);
+ Expression eps2 = new ToSINT16(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ Expression eps3 = new ToSINT16(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ Expression eps4 = new ToSINT16(v,true);
+
+ assertTrue(((Short) es1.evaluate()).equals(sn1));
+ assertTrue(((Short) es2.evaluate()).equals(sn2));
+ assertFalse(((Short) es1.evaluate()).equals(sn2));
+ assertTrue(((Short) esn1.evaluate()).equals(sn1));
+ assertTrue(((Short) esn2.evaluate()).equals(sn2));
+ assertFalse(((Short) esn1.evaluate()).equals(sn2));
+ s1 = s1.substring(1, s1.length()-1);
+ assertTrue(((Short) eps1.evaluate()).equals(new Short(s1)));
+ s2 = s2.substring(1, s2.length()-1);
+ assertTrue(((Short) eps2.evaluate()).equals(new Short(s2)));
+ assertTrue(((Short) eps3.evaluate()).equals(sn1));
+ assertTrue(((Short) eps4.evaluate()).equals(sn2));
+
+ assertSame(sn1.getClass(), (es1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test ToInt Expression
+ */
+ public void testToSINT32() {
+ Integer in1 = new Integer(Integer.MAX_VALUE);
+ Integer in2 = new Integer(Integer.MIN_VALUE);
+ String s1 = "\""+in1.toString()+"\"";
+ String s2 = "\""+in2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new IntegerConstant(in1.intValue());
+ propertySensor4=new IntegerConstant(in2.intValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToSINT32(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToSINT32(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1.intValue()));
+ Expression ein1 = new ToSINT32(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in2.intValue()));
+ Expression ein2 = new ToSINT32(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ Expression esp1 = new ToSINT32(v,true);
+
+ v.clear();
+ v.add(propertySensor2);
+ Expression esp2 = new ToSINT32(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ Expression esp3 = new ToSINT32(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ Expression esp4 = new ToSINT32(v,true);
+
+ assertTrue(((Integer) es1.evaluate()).equals(in1));
+ assertTrue(((Integer) es2.evaluate()).equals(in2));
+ assertFalse(((Integer) es1.evaluate()).equals(in2));
+ assertTrue(((Integer) ein1.evaluate()).equals(in1));
+ assertTrue(((Integer) ein2.evaluate()).equals(in2));
+ assertFalse(((Integer) ein1.evaluate()).equals(in2));
+ s1 = s1.substring(1, s1.length()-1);
+ assertTrue(
+ ((Integer) esp1.evaluate()).equals(new Integer(s1)));
+ s2 = s2.substring(1, s2.length()-1);
+ assertTrue(
+ ((Integer) esp2.evaluate()).equals(new Integer(s2)));
+ assertTrue(((Integer) esp3.evaluate()).equals(in1));
+ assertTrue(((Integer) esp4.evaluate()).equals(in2));
+
+ assertSame(in1.getClass(), (ein1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test ToSINT64 Expression
+ */
+ public void testToSINT64Expression() {
+ Long ln1 = new Long(Long.MAX_VALUE);
+ Long ln2 = new Long(Long.MIN_VALUE);
+ String s1 = "\""+ln1.toString()+"\"";
+ String s2 = "\""+ln2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new LongConstant(ln1.longValue());
+ propertySensor4=new LongConstant(ln2.longValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToSINT64(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToSINT64(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1.longValue()));
+ Expression eln1 = new ToSINT64(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln2.longValue()));
+ Expression eln2 = new ToSINT64(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ Expression eps1 = new ToSINT64(v,true);
+
+ v.clear();
+ v.add(propertySensor2);
+ Expression eps2 = new ToSINT64(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ Expression eps3 = new ToSINT64(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ Expression eps4 = new ToSINT64(v,true);
+
+ assertTrue(((Long) es1.evaluate()).equals(ln1));
+ assertTrue(((Long) es2.evaluate()).equals(ln2));
+ assertFalse(((Long) es1.evaluate()).equals(ln2));
+ assertTrue(((Long) eln1.evaluate()).equals(ln1));
+ assertTrue(((Long) eln2.evaluate()).equals(ln2));
+ assertFalse(((Long) eln1.evaluate()).equals(ln2));
+ s1 = s1.substring(1, s1.length()-1);
+ assertTrue(((Long) eps1.evaluate()).equals(new Long(s1)));
+ s2 = s2.substring(1, s2.length()-1);
+ assertTrue(((Long) eps2.evaluate()).equals(new Long(s2)));
+ assertTrue(((Long) eps3.evaluate()).equals(ln1));
+ assertTrue(((Long) eps4.evaluate()).equals(ln2));
+
+ //assertSame(ln1.getClass(), (eln1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test ToREAL32 Expression
+ */
+ public void testToREAL32Expression() {
+ Float fn1 = new Float(Float.MAX_VALUE);
+ Float fn2 = new Float(Float.MIN_VALUE);
+ String s1 = "\""+fn1.toString()+"\"";
+ String s2 = "\""+fn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new FloatConstant(fn1.floatValue());
+ propertySensor4=new FloatConstant(fn2.floatValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToREAL32(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToREAL32(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1.floatValue()));
+ Expression efn1 = new ToREAL32(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn2.floatValue()));
+ Expression efn2 = new ToREAL32(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ Expression eps1 = new ToREAL32(v,true);
+
+ v.clear();
+ v.add(propertySensor2);
+ Expression eps2 = new ToREAL32(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ Expression eps3 = new ToREAL32(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ Expression eps4 = new ToREAL32(v,true);
+
+ assertTrue(((Float) es1.evaluate()).equals(fn1));
+ assertTrue(((Float) es2.evaluate()).equals(fn2));
+ assertFalse(((Float) es1.evaluate()).equals(fn2));
+ assertTrue(((Float) efn1.evaluate()).equals(fn1));
+ assertTrue(((Float) efn2.evaluate()).equals(fn2));
+ assertFalse(((Float) efn1.evaluate()).equals(fn2));
+ s1 = s1.substring(1, s1.length()-1);
+ assertTrue(((Float) eps1.evaluate()).equals(new Float(s1)));
+ s2 = s2.substring(1, s2.length()-1);
+ assertTrue(((Float) eps2.evaluate()).equals(new Float(s2)));
+ assertTrue(((Float) eps3.evaluate()).equals(fn1));
+ assertTrue(((Float) eps4.evaluate()).equals(fn2));
+
+ //assertSame(fn1.getClass(), (efn1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test ToREAL64 Expression
+ */
+ public void testToREAL64Expression() {
+ Double dn1 = new Double(Double.MAX_VALUE);
+ Double dn2 = new Double(Double.MIN_VALUE);
+ String s1 = "\""+dn1.toString()+"\"";
+ String s2 = "\""+dn2.toString()+"\"";
+
+ //HashMap map = new HashMap();
+ propertySensor1=new StringConstant(s1.toString());
+ propertySensor2=new StringConstant(s2.toString());
+ propertySensor3=new DoubleConstant(dn1.doubleValue());
+ propertySensor4=new DoubleConstant(dn2.doubleValue());
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new StringConstant(s1));
+ Expression es1 = new ToREAL64(v,true);
+
+ v.clear();
+ v.add(new StringConstant(s2));
+ Expression es2 = new ToREAL64(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1.doubleValue()));
+ Expression edn1 = new ToREAL64(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn2.doubleValue()));
+ Expression edn2 = new ToREAL64(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ Expression eps1 = new ToREAL64(v,true);
+
+ v.clear();
+ v.add(propertySensor2);
+ Expression eps2 = new ToREAL64(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ Expression eps3 = new ToREAL64(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ Expression eps4 = new ToREAL64(v,true);
+
+ assertTrue(((Double) es1.evaluate()).equals(dn1));
+ assertTrue(((Double) es2.evaluate()).equals(dn2));
+ assertFalse(((Double) es1.evaluate()).equals(dn2));
+ assertTrue(((Double) edn1.evaluate()).equals(dn1));
+ assertTrue(((Double) edn2.evaluate()).equals(dn2));
+ assertFalse(((Double) edn1.evaluate()).equals(dn2));
+ s1 = s1.substring(1, s1.length()-1);
+ assertTrue(((Double) eps1.evaluate()).equals(new Double(s1)));
+ s2 = s2.substring(1, s2.length()-1);
+ assertTrue(((Double) eps2.evaluate()).equals(new Double(s2)));
+ assertTrue(((Double) eps3.evaluate()).equals(dn1));
+ assertTrue(((Double) eps4.evaluate()).equals(dn2));
+
+ assertSame(dn1.getClass(), (edn1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Addition Expression
+ */
+ public void testAdditionExpression() {
+ short sn1 = 300, sn2 = 500, sn3 = -100;
+ int in1 = 1000, in2 = -200, in3 = 300;
+ long ln1 = 2000L, ln2 = 5000L, ln3 = -10000L;
+ float fn1 = 505.1F, fn2 = 5.5F, fn3 = -1.1F;
+ double dn1 = 2.3, dn2 = -100.4, dn3 = 3.1415926;
+
+ //HashMap map = new HashMap();
+ propertySensor1=new ShortConstant(sn1);
+ propertySensor2=new ShortConstant(sn2);
+ propertySensor3=new IntegerConstant(in1);
+ propertySensor4=new IntegerConstant(in2);
+ propertySensor5=new LongConstant(ln1);
+ propertySensor6=new LongConstant(ln2);
+ propertySensor7=new FloatConstant(fn1);
+ propertySensor8=new FloatConstant(fn2);
+ propertySensor9=new DoubleConstant(dn1);
+ propertySensor10=new DoubleConstant(dn2);
+
+
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ v.add(new ShortConstant(sn2));
+
+ Expression es = new Addition(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new IntegerConstant(in2));
+
+ Expression ei = new Addition(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new LongConstant(ln2));
+
+ Expression el = new Addition(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new FloatConstant(fn2));
+
+ Expression ef = new Addition(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ v.add(new DoubleConstant(dn2));
+
+ Expression ed = new Addition(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new IntegerConstant(in1));
+
+ Expression emix1 = new Addition(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new FloatConstant(fn1));
+ Expression emix2 = new Addition(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix3 = new Addition(v,true);
+
+
+ v.clear();
+
+ v.add(propertySensor2);
+ v.add(new ShortConstant(sn3));
+ Expression eps1 = new Addition(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ v.add(new IntegerConstant(in3));
+ Expression eps2 = new Addition(v,true);
+
+ v.clear();
+
+ v.add(propertySensor6);
+ v.add(new LongConstant(ln3));
+ Expression eps3 = new Addition(v,true);
+
+ v.clear();
+
+ v.add(propertySensor8);
+ v.add(new FloatConstant(fn3));
+ Expression eps4 = new Addition(v,true);
+
+ v.clear();
+
+ v.add(propertySensor10);
+ v.add(new DoubleConstant(dn3));
+ Expression eps5 = new Addition(v,true);
+
+ assertTrue(
+ ((sn1 + sn2)
+ - ((Number) es.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in1 + in2) - ((Number) ei.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((ln1 + ln2)
+ - ((Number) el.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn1 + fn2)
+ - ((Number) ef.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn1 + dn2)
+ - ((Number) ed.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((sn1+in1)
+ - ((Number) emix1.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ (( ln1+fn1)
+ - ((Number) emix2.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((fn1+dn1)
+ - ((Number) emix3.evaluate()).doubleValue())
+ == 0);
+
+ assertTrue(
+ ((sn2 + sn3)
+ - ((Number) eps1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in2 + in3)
+ - ((Number) eps2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((ln2 + ln3)
+ - ((Number) eps3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn2 + fn3)
+ - ((Number) eps4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn2 + dn3)
+ - ((Number) eps5.evaluate()).doubleValue())
+ == 0);
+/*
+ assertSame(
+ (eps1.evaluate()).getClass(),
+ (new Integer(sn1)).getClass());
+ assertSame(
+ (eps2.evaluate()).getClass(),
+ (new Integer(in1)).getClass());
+ assertSame(
+ (eps3.evaluate()).getClass(),
+ (new Long(ln1)).getClass());
+ assertSame(
+ (eps4.evaluate()).getClass(),
+ (new Float(fn1)).getClass());
+ assertSame(
+ (eps5.evaluate()).getClass(),
+ (new Double(dn1)).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Subtraction Expression
+ * TODO: should Subtraction check the length of input vector?
+ */
+ public void testSubtractionExpression() {
+ short sn1 = 300, sn2 = 500;
+ int in1 = 1000, in2 = -200;
+ long ln1 = 2000L, ln2 = 5000L;
+ float fn1 = 505.1F, fn2 = -1.1F;
+ double dn1 = 2.3, dn2 = -3.1415926;
+
+ //HashMap map = new HashMap();
+ propertySensor1=new ShortConstant(sn1);
+ propertySensor2=new ShortConstant(sn2);
+ propertySensor3=new IntegerConstant(in1);
+ propertySensor4=new IntegerConstant(in2);
+ propertySensor5=new LongConstant(ln1);
+ propertySensor6=new LongConstant(ln2);
+ propertySensor7=new FloatConstant(fn1);
+ propertySensor8=new FloatConstant(fn2);
+ propertySensor9=new DoubleConstant(dn1);
+ propertySensor10=new DoubleConstant(dn2);
+
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ v.add(new ShortConstant(sn2));
+ Expression es = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new IntegerConstant(in2));
+ Expression ei = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new LongConstant(ln2));
+ Expression el = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new FloatConstant(fn2));
+ Expression ef = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ v.add(new DoubleConstant(dn2));
+ Expression ed = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new IntegerConstant(in1));
+ Expression emix1 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new LongConstant(ln1));
+ Expression emix2 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new FloatConstant(fn1));
+ Expression emix3 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix4 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new LongConstant(ln1));
+ Expression emix5 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new FloatConstant(fn1));
+ Expression emix6 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix7 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new FloatConstant(fn1));
+ Expression emix8 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix9 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix10 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ v.add(propertySensor2);
+ Expression eps1 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ v.add(propertySensor4);
+ Expression eps2 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(propertySensor5);
+ v.add(propertySensor6);
+ Expression eps3 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(propertySensor7);
+ v.add(propertySensor8);
+ Expression eps4 = new Subtraction(v,true);
+
+ v.clear();
+ v.add(propertySensor9);
+ v.add(propertySensor10);
+ Expression eps5 = new Subtraction(v,true);
+
+ assertTrue(
+ ((sn1 - sn2) - ((Number) es.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in1 - in2) - ((Number) ei.evaluate()).intValue()) == 0);
+ assertTrue(
+ ((ln1 - ln2) - ((Number) el.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn1 - fn2) - ((Number) ef.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn1 - dn2) - ((Number) ed.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((sn1 - in1) - ((Number) emix1.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((sn1 - ln1) - ((Number) emix2.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((sn1 - fn1) - ((Number) emix3.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((sn1 - dn1) - ((Number) emix4.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((in1 - ln1) - ((Number) emix5.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((in1 - fn1) - ((Number) emix6.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((in1 - dn1) - ((Number) emix7.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((ln1 - fn1) - ((Number) emix8.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((ln1 - dn1) - ((Number) emix9.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((fn1 - dn1)
+ - ((Number) emix10.evaluate()).doubleValue())
+ == 0);
+
+ assertTrue(
+ ((sn1 - sn2)
+ - ((Number) eps1.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((in1 - in2)
+ - ((Number) eps2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((ln1 - ln2)
+ - ((Number) eps3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn1 - fn2)
+ - ((Number) eps4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn1 - dn2)
+ - ((Number) eps5.evaluate()).doubleValue())
+ == 0);
+ /*
+// assertSame((new Integer(sn1 - sn2)).getClass(),
+// (eps1.evaluate()).getClass());
+ assertSame((new Integer(in1 - in2)).getClass(),
+ (eps2.evaluate()).getClass());
+ assertSame((new Long(ln1 - ln2)).getClass(),
+ (eps3.evaluate()).getClass());
+ assertSame((new Float(fn1 - fn2)).getClass(),
+ (eps4.evaluate()).getClass());
+ assertSame((new Double(dn1 - dn2)).getClass(),
+ (eps5.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Product Expression
+ */
+ public void testProductExpression() {
+ short sn1 = 30, sn2 = 5, sn3 = -10;
+ int in1 = 1000, in2 = -200, in3 = 300;
+ long ln1 = 2000L, ln2 = 5000L, ln3 = -10000;
+ float fn1 = 505.1F, fn2 = 5.5F, fn3 = -1.1F;
+ double dn1 = 2.3, dn2 = -100.4, dn3 = 3.1415926;
+
+ //HashMap map = new HashMap();
+ propertySensor1=new ShortConstant(sn1);
+ propertySensor2=new ShortConstant(sn2);
+ propertySensor3=new IntegerConstant(in1);
+ propertySensor4=new IntegerConstant(in2);
+ propertySensor5=new LongConstant(ln1);
+ propertySensor6=new LongConstant(ln2);
+ propertySensor7=new FloatConstant(fn1);
+ propertySensor8=new FloatConstant(fn2);
+ propertySensor9=new DoubleConstant(dn1);
+ propertySensor10=new DoubleConstant(dn2);
+
+
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+
+ v.add(new ShortConstant(sn2));
+ v.add(new ShortConstant(sn3));
+ Expression es = new Product(v,true);
+
+ v.clear();
+
+ v.add(new IntegerConstant(in2));
+ v.add(new IntegerConstant(in3));
+ Expression ei = new Product(v,true);
+
+ v.clear();
+
+ v.add(new LongConstant(ln2));
+ v.add(new LongConstant(ln3));
+ Expression el = new Product(v,true);
+
+ v.clear();
+
+ v.add(new FloatConstant(fn2));
+ v.add(new FloatConstant(fn3));
+ Expression ef = new Product(v,true);
+
+ v.clear();
+
+ v.add(new DoubleConstant(dn2));
+ v.add(new DoubleConstant(dn3));
+ Expression ed = new Product(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new IntegerConstant(in1));
+
+ Expression emix1 = new Product(v,true);
+
+ v.clear();
+
+ v.add(new LongConstant(ln1));
+ v.add(new FloatConstant(fn1));
+
+ Expression emix2 = new Product(v,true);
+
+ v.clear();
+
+ v.add(new FloatConstant(fn1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix3 = new Product(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ v.add(propertySensor2);
+ Expression eps1 = new Product(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ v.add(propertySensor4);
+ Expression eps2 = new Product(v,true);
+
+ v.clear();
+ v.add(propertySensor5);
+ v.add(propertySensor6);
+ Expression eps3 = new Product(v,true);
+
+ v.clear();
+ v.add(propertySensor7);
+ v.add(propertySensor8);
+ Expression eps4 = new Product(v,true);
+
+ v.clear();
+ v.add(propertySensor9);
+ v.add(propertySensor10);
+ Expression eps5 = new Product(v,true);
+
+ assertTrue(
+ ((sn2 * sn3)
+ - ((Number) es.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in2 * in3)
+ - ((Number) ei.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((ln2 * ln3)
+ - ((Number) el.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn2 * fn3)
+ - ((Number) ef.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn2 * dn3)
+ - ((Number) ed.evaluate()).doubleValue())
+ == 0);
+ assertTrue(((sn1*in1) - ((Number)emix1.evaluate()).doubleValue()) == 0);
+
+ assertTrue(((ln1*fn1) - ((Number)emix2.evaluate()).doubleValue()) == 0);
+ //System.out.println("(fn1*dn1) = "+(fn1*dn1));
+ //System.out.println("((Number)emix2.evaluate()).doubleValue()) = "+((Number)emix3.evaluate()).doubleValue());
+
+ assertTrue(((fn1*dn1) - ((Number)emix3.evaluate()).doubleValue()) == 0);
+
+ assertTrue(
+ ((sn1 * sn2)
+ - ((Number) eps1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in1 * in2) - ((Number) eps2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((ln1 * ln2)
+ - ((Number) eps3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn1 * fn2)
+ - ((Number) eps4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn1 * dn2)
+ - ((Number) eps5.evaluate()).doubleValue())
+ == 0);
+ /*
+ assertSame(
+ (new Integer(sn1 * sn2)).getClass(),
+ (eps1.evaluate()).getClass());
+ assertSame(
+ (new Integer(in1 * in2)).getClass(),
+ (eps2.evaluate()).getClass());
+ assertSame(
+ (new Long(ln1 * ln2)).getClass(),
+ (eps3.evaluate()).getClass());
+ assertSame(
+ (new Float(fn1 * fn2)).getClass(),
+ (eps4.evaluate()).getClass());
+ assertSame(
+ (new Double(dn1 * dn2)).getClass(),
+ (eps5.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ e.printStackTrace();
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ e.printStackTrace();
+
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Division Expression
+ */
+ public void testDivisionExpression() {
+ short sn1 = 30, sn2 = -10;
+ int in1 = 1000, in2 = -200;
+ long ln1 = 2000L, ln2 = 5000L;
+ float fn1 = 505.1F, fn2 = 5.5F;
+ double dn1 = 2.3, dn2 = -100.4;
+
+ //HashMap map = new HashMap();
+ propertySensor1=new ShortConstant(sn1);
+ propertySensor2=new ShortConstant(sn2);
+ propertySensor3=new IntegerConstant(in1);
+ propertySensor4=new IntegerConstant(in2);
+ propertySensor5=new LongConstant(ln1);
+ propertySensor6=new LongConstant(ln2);
+ propertySensor7=new FloatConstant(fn1);
+ propertySensor8=new FloatConstant(fn2);
+ propertySensor9=new DoubleConstant(dn1);
+ propertySensor10=new DoubleConstant(dn2);
+
+
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ v.add(new ShortConstant(sn2));
+ Expression es = new Division(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new IntegerConstant(in2));
+ Expression ei = new Division(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new LongConstant(ln2));
+ Expression el = new Division(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new FloatConstant(fn2));
+ Expression ef = new Division(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ v.add(new DoubleConstant(dn2));
+ Expression ed = new Division(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new IntegerConstant(in1));
+ Expression emix1 = new Division(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new LongConstant(ln1));
+ Expression emix2 = new Division(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new FloatConstant(fn1));
+ Expression emix3 = new Division(v,true);
+
+ v.clear();
+ v.add(new ShortConstant(sn1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix4 = new Division(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new LongConstant(ln1));
+ Expression emix5 = new Division(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new FloatConstant(fn1));
+ Expression emix6 = new Division(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix7 = new Division(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new FloatConstant(fn1));
+ Expression emix8 = new Division(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix9 = new Division(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new DoubleConstant(dn1));
+ Expression emix10 = new Division(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ v.add(propertySensor2);
+ Expression eps1 = new Division(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ v.add(propertySensor4);
+ Expression eps2 = new Division(v,true);
+
+ v.clear();
+ v.add(propertySensor5);
+ v.add(propertySensor6);
+ Expression eps3 = new Division(v,true);
+
+ v.clear();
+ v.add(propertySensor7);
+ v.add(propertySensor8);
+ Expression eps4 = new Division(v,true);
+
+ v.clear();
+ v.add(propertySensor9);
+ v.add(propertySensor10);
+ Expression eps5 = new Division(v,true);
+
+ assertTrue(
+ ((sn1 / sn2) - ((Number) es.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in1 / in2) - ((Number) ei.evaluate()).intValue()) == 0);
+ assertTrue(
+ ((ln1 / ln2) - ((Number) el.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn1 / fn2) - ((Number) ef.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn1 / dn2) - ((Number) ed.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((sn1 / in1) - ((Number) emix1.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ ((sn1 / ln1) - ((Number) emix2.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((sn1 / fn1) - ((Number) emix3.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((sn1 / dn1) - ((Number) emix4.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((in1 / ln1) - ((Number) emix5.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((in1 / fn1) - ((Number) emix6.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((in1 / dn1) - ((Number) emix7.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((ln1 / fn1) - ((Number) emix8.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((ln1 / dn1) - ((Number) emix9.evaluate()).doubleValue())
+ == 0);
+ assertTrue(
+ ((fn1 / dn1)
+ - ((Number) emix10.evaluate()).doubleValue())
+ == 0);
+
+ assertTrue(
+ ((sn1 / sn2) - ((Number) eps1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in1 / in2) - ((Number) eps2.evaluate()).intValue()) == 0);
+ assertTrue(
+ ((ln1 / ln2) - ((Number) eps3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn1 / fn2) - ((Number) eps4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn1 / dn2) - ((Number) eps5.evaluate()).doubleValue())
+ == 0);
+/*
+ assertSame(
+ (new Integer(sn1 / sn2)).getClass(),
+ (eps1.evaluate()).getClass());
+ assertSame(
+ (new Integer(in1 / in2)).getClass(),
+ (eps2.evaluate()).getClass());
+ assertSame(
+ (new Long(ln1 / ln2)).getClass(),
+ (eps3.evaluate()).getClass());
+ assertSame(
+ (new Float(fn1 / fn2)).getClass(),
+ (eps4.evaluate()).getClass());
+ assertSame(
+ (new Double(dn1 / dn2)).getClass(),
+ (eps5.evaluate()).getClass());*/
+
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Mod Expression
+ */
+ public void testModExpression() {
+ short sn1 = 30, sn2 = 5;
+ int in1 = 1000, in2 = -300;
+ long ln1 = 2000L, ln2 = 60L;
+ float fn1 = 505.1F, fn2 = 5.5F;
+ double dn1 = -100.4, dn2 = 3.1415926;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ v.add(new ShortConstant(sn2));
+ Expression es = new Mod(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new IntegerConstant(in2));
+ Expression ei = new Mod(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new LongConstant(ln2));
+ Expression el = new Mod(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new FloatConstant(fn2));
+ Expression ef = new Mod(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ v.add(new DoubleConstant(dn2));
+ Expression ed = new Mod(v,true);
+
+ assertTrue(
+ ((sn1 % sn2) - ((Number) es.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ ((in1 % in2) - ((Number) ei.evaluate()).intValue()) == 0);
+ assertTrue(
+ ((ln1 % ln2) - ((Number) el.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ ((fn1 % fn2) - ((Number) ef.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ ((dn1 % dn2) - ((Number) ed.evaluate()).doubleValue())
+ == 0);
+
+/* assertSame(
+ (new Integer(sn1 % sn2)).getClass(),
+ (es.evaluate()).getClass());
+ assertSame(
+ (new Integer(in1 % in2)).getClass(),
+ (ei.evaluate()).getClass());
+ assertSame(
+ (new Long(ln1 % ln2)).getClass(),
+ (el.evaluate()).getClass());
+ assertSame(
+ (new Float(fn1 % fn2)).getClass(),
+ (ef.evaluate()).getClass());
+ assertSame(
+ (new Double(dn1 % dn2)).getClass(),
+ (ed.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Max Expression
+ */
+ public void testMaxExpression() {
+ short sn1 = 30, sn2 = 5;
+ int in1 = 1000, in2 = -300;
+ long ln1 = 2000L, ln2 = 60L;
+ float fn1 = 505.1F, fn2 = 5.5F;
+ double dn1 = -100.4, dn2 = 3.1415926;
+
+ //HashMap map = new HashMap();
+ propertySensor1=new ShortConstant(sn1);
+ propertySensor2=new ShortConstant(sn2);
+ propertySensor3=new IntegerConstant(in1);
+ propertySensor4=new IntegerConstant(in2);
+ propertySensor5=new LongConstant(ln1);
+ propertySensor6=new LongConstant(ln2);
+ propertySensor7=new FloatConstant(fn1);
+ propertySensor8=new FloatConstant(fn2);
+ propertySensor9=new DoubleConstant(dn1);
+ propertySensor10=new DoubleConstant(dn2);
+
+
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ /*v.add(new ShortConstant(sn1));
+ v.add(new ShortConstant(sn2));
+ v.add(new IntegerConstant(in1));
+ v.add(new IntegerConstant(in2));
+ v.add(new LongConstant(ln1));
+ v.add(new LongConstant(ln2));
+ v.add(new FloatConstant(fn1));
+ v.add(new FloatConstant(fn2));
+ v.add(new DoubleConstant(dn1));
+ v.add(new DoubleConstant(dn2));
+ Expression e = new Max(v,true);*/
+
+ v.clear();
+ v.add(new ShortConstant(sn2));
+ v.add(new IntegerConstant(in1));
+ Expression emix1 = new Max(v,true);
+ v.clear();
+ v.add(new IntegerConstant(in2));
+ v.add(new LongConstant(ln1));
+ Expression emix2 = new Max(v,true);
+ v.clear();
+ v.add(new LongConstant(ln2));
+ v.add(new FloatConstant(fn1));
+ Expression emix3 = new Max(v,true);
+ v.clear();
+ v.add(new FloatConstant(fn2));
+ v.add(new DoubleConstant(dn1));
+ Expression emix4 = new Max(v,true);
+ v.clear();
+ v.add(new DoubleConstant(dn2));
+ v.add(new ShortConstant(sn1));
+ Expression emix5 = new Max(v,true);
+
+
+ v.clear();
+ v.add(propertySensor1);
+ v.add(propertySensor2);
+ Expression eps1 = new Max(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ v.add(propertySensor4);
+ Expression eps2 = new Max(v,true);
+
+ v.clear();
+ v.add(propertySensor5);
+ v.add(propertySensor6);
+ Expression eps3 = new Max(v,true);
+
+ v.clear();
+ v.add(propertySensor7);
+ v.add(propertySensor8);
+ Expression eps4 = new Max(v,true);
+
+ v.clear();
+ v.add(propertySensor9);
+ v.add(propertySensor10);
+ Expression eps5 = new Max(v,true);
+
+ assertTrue(Math.max(sn2, in1)- ((Number) emix1.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(in2, ln1)- ((Number) emix2.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(ln2, fn1)- ((Number) emix3.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(fn2, dn1)- ((Number) emix4.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(dn2, sn1)- ((Number) emix5.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(sn1, sn2)- ((Number) eps1.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(in1, in2)- ((Number) eps2.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(ln1, ln2)- ((Number) eps3.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(fn1, fn2)- ((Number) eps4.evaluate()).doubleValue()== 0);
+ assertTrue(Math.max(dn1, dn2)- ((Number) eps5.evaluate()).doubleValue()== 0);
+/*
+ assertSame((new Short(sn1).getClass()), (eps1.evaluate()).getClass());
+ assertSame((new Integer(in1).getClass()), (eps2.evaluate()).getClass());
+ assertSame((new Long(ln1).getClass()), (eps3.evaluate()).getClass());
+ assertSame((new Float(fn1).getClass()), (eps4.evaluate()).getClass());
+ assertSame((new Double(dn1).getClass()), (eps5.evaluate()).getClass()); */
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Min Expression
+ */
+ public void testMinExpression() {
+ short sn1 = 30, sn2 = 5;
+ int in1 = 1000, in2 = -300;
+ long ln1 = 2000L, ln2 = 60L;
+ float fn1 = 505.1F, fn2 = 5.5F;
+ double dn1 = -100.4, dn2 = 3.1415926;
+
+ //HashMap map = new HashMap();
+ propertySensor1=new ShortConstant(sn1);
+ propertySensor2=new ShortConstant(sn2);
+ propertySensor3=new IntegerConstant(in1);
+ propertySensor4=new IntegerConstant(in2);
+ propertySensor5=new LongConstant(ln1);
+ propertySensor6=new LongConstant(ln2);
+ propertySensor7=new FloatConstant(fn1);
+ propertySensor8=new FloatConstant(fn2);
+ propertySensor9=new DoubleConstant(dn1);
+ propertySensor10=new DoubleConstant(dn2);
+
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+
+ /*v.add(new ShortConstant(sn1));
+ v.add(new ShortConstant(sn2));
+ v.add(new IntegerConstant(in1));
+ v.add(new IntegerConstant(in2));
+ v.add(new LongConstant(ln1));
+ v.add(new LongConstant(ln2));
+ v.add(new FloatConstant(fn1));
+ v.add(new FloatConstant(fn2));
+ v.add(new DoubleConstant(dn1));
+ v.add(new DoubleConstant(dn2));
+ Expression e = new Min(v,true);*/
+
+ v.clear();
+ v.add(new ShortConstant(sn2));
+ v.add(new IntegerConstant(in1));
+ Expression emix1 = new Min(v,true);
+ v.clear();
+ v.add(new IntegerConstant(in2));
+ v.add(new LongConstant(ln1));
+ Expression emix2 = new Min(v,true);
+ v.clear();
+ v.add(new LongConstant(ln2));
+ v.add(new FloatConstant(fn1));
+ Expression emix3 = new Min(v,true);
+ v.clear();
+ v.add(new FloatConstant(fn2));
+ v.add(new DoubleConstant(dn1));
+ Expression emix4 = new Min(v,true);
+ v.clear();
+ v.add(new DoubleConstant(dn2));
+ v.add(new ShortConstant(sn1));
+ Expression emix5 = new Min(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ v.add(propertySensor2);
+ Expression eps1 = new Min(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ v.add(propertySensor4);
+ Expression eps2 = new Min(v,true);
+
+ v.clear();
+ v.add(propertySensor5);
+ v.add(propertySensor6);
+ Expression eps3 = new Min(v,true);
+
+ v.clear();
+ v.add(propertySensor7);
+ v.add(propertySensor8);
+ Expression eps4 = new Min(v,true);
+
+ v.clear();
+ v.add(propertySensor9);
+ v.add(propertySensor10);
+ Expression eps5 = new Min(v,true);
+
+ assertTrue(Math.min(sn2, in1)- ((Number) emix1.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(in2, ln1)- ((Number) emix2.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(ln2, fn1)- ((Number) emix3.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(fn2, dn1)- ((Number) emix4.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(dn2, sn1)- ((Number) emix5.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(sn1, sn2)- ((Number) eps1.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(in1, in2)- ((Number) eps2.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(ln1, ln2)- ((Number) eps3.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(fn1, fn2)- ((Number) eps4.evaluate()).doubleValue()== 0);
+ assertTrue(Math.min(dn1, dn2)- ((Number) eps5.evaluate()).doubleValue()== 0);
+
+/*
+ assertSame((new Short(sn1).getClass()), (eps1.evaluate()).getClass());
+ assertSame((new Integer(in1).getClass()), (eps2.evaluate()).getClass());
+ assertSame((new Long(ln1).getClass()), (eps3.evaluate()).getClass());
+ assertSame((new Float(fn1).getClass()), (eps4.evaluate()).getClass());
+ assertSame((new Double(dn1).getClass()), (eps5.evaluate()).getClass()); */
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Ln Expression
+ */
+ public void testLnExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = 2000;
+ float fn1 = 505.1F;
+ double dn1 = 100.4;
+
+ //HashMap map = new HashMap();
+ propertySensor1=new ShortConstant(sn1);
+ propertySensor2=new IntegerConstant(in1);
+ propertySensor3=new LongConstant(ln1);
+ propertySensor4=new FloatConstant(fn1);
+ propertySensor5=new DoubleConstant(dn1);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Ln(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Ln(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Ln(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Ln(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Ln(v,true);
+
+ v.clear();
+ v.add(propertySensor1);
+ Expression eps1 = new Ln(v,true);
+
+ v.clear();
+ v.add(propertySensor2);
+ Expression eps2 = new Ln(v,true);
+
+ v.clear();
+ v.add(propertySensor3);
+ Expression eps3 = new Ln(v,true);
+
+ v.clear();
+ v.add(propertySensor4);
+ Expression eps4 = new Ln(v,true);
+
+ v.clear();
+ v.add(propertySensor5);
+ Expression eps5 = new Ln(v,true);
+
+ assertTrue(
+ (new Double(Math.log(sn1)).shortValue()
+ - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(in1)).intValue()
+ - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(ln1)).longValue()
+ - ((Number) e3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(fn1)).floatValue()
+ - ((Number) e4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(dn1)).doubleValue()
+ - ((Number) e5.evaluate()).doubleValue())
+ == 0);
+
+ assertTrue(
+ (new Double(Math.log(sn1)).shortValue()
+ - ((Number) eps1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(in1)).intValue()
+ - ((Number) eps2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(ln1)).longValue()
+ - ((Number) eps3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(fn1)).floatValue()
+ - ((Number) eps4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.log(dn1)).doubleValue()
+ - ((Number) eps5.evaluate()).doubleValue())
+ == 0);
+
+ assertSame((new Double(dn1)).getClass(), (eps1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Exp Expression
+ */
+ public void testExpExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = 2000;
+ float fn1 = 50.1F;
+ double dn1 = 100.4;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Exp(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Exp(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Exp(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Exp(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Exp(v,true);
+
+ assertTrue(
+ (new Double(Math.exp(sn1)).shortValue()
+ - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.exp(in1)).intValue()
+ - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.exp(ln1)).longValue()
+ - ((Number) e3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.exp(fn1)).floatValue()
+ - ((Number) e4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.exp(dn1)).doubleValue()
+ - ((Number) e5.evaluate()).doubleValue())
+ == 0);
+
+ //assertSame((new Double(dn1)).getClass(), (e1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Power Expression
+ */
+ public void testPowerExpression() {
+ short sn1 = 30, sn2 = 5;
+ int in1 = 1000, in2 = 9;
+ long ln1 = 2000, ln2 = 30;
+ float fn1 = 50.1F, fn2 = 9.3F;
+ double dn1 = 100.4, dn2 = 0.123;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ v.add(new ShortConstant(sn2));
+ Expression e1 = new Power(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ v.add(new IntegerConstant(in2));
+ Expression e2 = new Power(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ v.add(new LongConstant(ln2));
+ Expression e3 = new Power(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ v.add(new FloatConstant(fn2));
+ Expression e4 = new Power(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ v.add(new DoubleConstant(dn2));
+ Expression e5 = new Power(v,true);
+
+ assertTrue(
+ (new Double(Math.pow(sn1, sn2)).shortValue()
+ - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.pow(in1, in2)).intValue()
+ - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.pow(ln1, ln2)).longValue()
+ - ((Number) e3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.pow(fn1, fn2)).floatValue()
+ - ((Number) e4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.pow(dn1, dn2)).doubleValue()
+ - ((Number) e5.evaluate()).doubleValue())
+ == 0);
+
+ //assertSame((new Double(dn1)).getClass(), (e1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test SquareRoot Expression
+ */
+ public void testSquareRootExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = 2000;
+ float fn1 = 50.1F;
+ double dn1 = 100.4;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new SquareRoot(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new SquareRoot(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new SquareRoot(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new SquareRoot(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new SquareRoot(v,true);
+
+ assertTrue(
+ (new Double(Math.sqrt(sn1)).shortValue()
+ - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.sqrt(in1)).intValue()
+ - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.sqrt(ln1)).longValue()
+ - ((Number) e3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.sqrt(fn1)).floatValue()
+ - ((Number) e4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ (new Double(Math.sqrt(dn1)).doubleValue()
+ - ((Number) e5.evaluate()).doubleValue())
+ == 0);
+
+ //assertSame((new Double(dn1)).getClass(), (e1.evaluate()).getClass());
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Abs Expression
+ */
+ public void testAbsExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = -2000;
+ float fn1 = -50.1F;
+ double dn1 = -100.4;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Abs(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Abs(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Abs(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Abs(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Abs(v,true);
+
+ assertTrue(
+ (Math.abs(sn1) - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (Math.abs(in1) - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.abs(ln1) - ((Number) e3.evaluate()).longValue())
+ == 0);
+ assertTrue(
+ (Math.abs(fn1) - ((Number) e4.evaluate()).floatValue())
+ == 0);
+ assertTrue(
+ (Math.abs(dn1) - ((Number) e5.evaluate()).doubleValue())
+ == 0);
+/*
+ assertSame((new Short(sn1)).getClass(), (e1.evaluate()).getClass());
+ assertSame((new Integer(in1)).getClass(), (e2.evaluate()).getClass());
+ assertSame((new Long(ln1)).getClass(), (e3.evaluate()).getClass());
+ assertSame((new Float(fn1)).getClass(), (e4.evaluate()).getClass());
+ assertSame((new Double(dn1)).getClass(), (e5.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Round Expression
+ */
+ public void testRoundExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = -2000;
+ float fn1 = -50.1F;
+ double dn1 = -100.5;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Round(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Round(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Round(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Round(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Round(v,true);
+
+ assertTrue(
+ (Math.round(sn1) - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (Math.round(in1) - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.round(ln1) - ((Number) e3.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.round(fn1) - ((Number) e4.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.round(dn1) - ((Number) e5.evaluate()).longValue())
+ == 0);
+/*
+// assertSame((new Short(sn1)).getClass(), (e1.evaluate()).getClass());
+// assertSame((new Integer(in1)).getClass(), (e2.evaluate()).getClass());
+// assertSame((new Long(ln1)).getClass(), (e3.evaluate()).getClass());
+ assertSame((new Integer(in1)).getClass(), (e4.evaluate()).getClass());
+ assertSame((new Long(ln1)).getClass(), (e5.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Rint Expression
+ */
+ public void testRintExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = -2000;
+ float fn1 = -50.1F;
+ double dn1 = -100.5;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Rint(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Rint(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Rint(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Rint(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Rint(v,true);
+
+ assertTrue(
+ (Math.rint(sn1) - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (Math.rint(in1) - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.rint(ln1) - ((Number) e3.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.rint(fn1) - ((Number) e4.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.rint(dn1) - ((Number) e5.evaluate()).longValue())
+ == 0);
+/*
+ assertSame((new Double(sn1)).getClass(), (e1.evaluate()).getClass());
+ assertSame((new Double(in1)).getClass(), (e2.evaluate()).getClass());
+ assertSame((new Double(ln1)).getClass(), (e3.evaluate()).getClass());
+ assertSame((new Double(in1)).getClass(), (e4.evaluate()).getClass());
+ assertSame((new Double(ln1)).getClass(), (e5.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Floor Expression
+ */
+ public void testFloorExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = -2000;
+ float fn1 = -50.1F;
+ double dn1 = -100.5;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Floor(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Floor(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Floor(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Floor(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Floor(v,true);
+
+ assertTrue(
+ (Math.floor(sn1) - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (Math.floor(in1) - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.floor(ln1) - ((Number) e3.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.floor(fn1) - ((Number) e4.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.floor(dn1) - ((Number) e5.evaluate()).longValue())
+ == 0);
+/*
+ assertSame((new Double(sn1)).getClass(), (e1.evaluate()).getClass());
+ assertSame((new Double(in1)).getClass(), (e2.evaluate()).getClass());
+ assertSame((new Double(ln1)).getClass(), (e3.evaluate()).getClass());
+ assertSame((new Double(in1)).getClass(), (e4.evaluate()).getClass());
+ assertSame((new Double(ln1)).getClass(), (e5.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ /*
+ * This will test Ceiling Expression
+ */
+ public void testCeilingExpression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = -2000;
+ float fn1 = -50.1F;
+ double dn1 = -100.5;
+
+ ////HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Ceiling(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Ceiling(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Ceiling(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Ceiling(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Ceiling(v,true);
+
+ assertTrue(
+ (Math.ceil(sn1) - ((Number) e1.evaluate()).shortValue())
+ == 0);
+ assertTrue(
+ (Math.ceil(in1) - ((Number) e2.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.ceil(ln1) - ((Number) e3.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.ceil(fn1) - ((Number) e4.evaluate()).intValue())
+ == 0);
+ assertTrue(
+ (Math.ceil(dn1) - ((Number) e5.evaluate()).longValue())
+ == 0);
+/*
+ assertSame((new Double(sn1)).getClass(), (e1.evaluate()).getClass());
+ assertSame((new Double(in1)).getClass(), (e2.evaluate()).getClass());
+ assertSame((new Double(ln1)).getClass(), (e3.evaluate()).getClass());
+ assertSame((new Double(in1)).getClass(), (e4.evaluate()).getClass());
+ assertSame((new Double(ln1)).getClass(), (e5.evaluate()).getClass());*/
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+
+ public void testLog10Expression() {
+ short sn1 = 30;
+ int in1 = 1000;
+ long ln1 = 2000;
+ float fn1 = 50.1F;
+ double dn1 = 100.4;
+
+ //HashMap map = new HashMap();
+ // propertySensor1=new StringConstant(s1.toString());
+ // propertySensor2=new StringConstant(s2.toString());
+ // propertySensor3=dn1);
+ // propertySensor4=dn2);
+ //SensorLookup lookup = new SensorLookupImpl(map);
+
+ try {
+ Vector v = new Vector();
+ v.add(new ShortConstant(sn1));
+ Expression e1 = new Log10(v,true);
+
+ v.clear();
+ v.add(new IntegerConstant(in1));
+ Expression e2 = new Log10(v,true);
+
+ v.clear();
+ v.add(new LongConstant(ln1));
+ Expression e3 = new Log10(v,true);
+
+ v.clear();
+ v.add(new FloatConstant(fn1));
+ Expression e4 = new Log10(v,true);
+
+ v.clear();
+ v.add(new DoubleConstant(dn1));
+ Expression e5 = new Log10(v,true);
+
+ assertTrue(((Number) e1.evaluate()).doubleValue()==1.4771212547196624);
+ assertTrue(((Number) e2.evaluate()).doubleValue()==2.9999999999999996);
+ assertTrue(((Number) e3.evaluate()).doubleValue()==3.301029995663981);
+ assertTrue(((Number) e4.evaluate()).doubleValue()==1.6998377126400839);
+ assertTrue(((Number) e5.evaluate()).doubleValue()==2.0017337128090005);
+
+
+ } catch (SPLException e) {
+ fail("Received evaluation exception " + e.getMessage());
+ } catch (Exception e) {
+ fail("Received expression exception " + e.getMessage());
+ }
+ }
+}
\ No newline at end of file