From imperius-commits-return-65-apmail-incubator-imperius-commits-archive=incubator.apache.org@incubator.apache.org Fri Jan 04 02:48:14 2008 Return-Path: Delivered-To: apmail-incubator-imperius-commits-archive@locus.apache.org Received: (qmail 45351 invoked from network); 4 Jan 2008 02:48:14 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.2) by minotaur.apache.org with SMTP; 4 Jan 2008 02:48:14 -0000 Received: (qmail 35998 invoked by uid 500); 4 Jan 2008 02:48:03 -0000 Delivered-To: apmail-incubator-imperius-commits-archive@incubator.apache.org Received: (qmail 35981 invoked by uid 500); 4 Jan 2008 02:48:03 -0000 Mailing-List: contact imperius-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: imperius-dev@incubator.apache.org Delivered-To: mailing list imperius-commits@incubator.apache.org Received: (qmail 35972 invoked by uid 99); 4 Jan 2008 02:48:03 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 03 Jan 2008 18:48:03 -0800 X-ASF-Spam-Status: No, hits=-100.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.3] (HELO eris.apache.org) (140.211.11.3) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 04 Jan 2008 02:47:47 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id F389F1A9846; Thu, 3 Jan 2008 18:47:51 -0800 (PST) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r608716 [4/5] - in /incubator/imperius/trunk/modules/imperius-splcore/src/test: ./ java/ java/org/ java/org/apache/ java/org/apache/imperius/ java/org/apache/imperius/spl/ java/org/apache/imperius/spl/tests/ Date: Fri, 04 Jan 2008 02:47:50 -0000 To: imperius-commits@incubator.apache.org From: jneeraj@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20080104024751.F389F1A9846@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Added: incubator/imperius/trunk/modules/imperius-splcore/src/test/java/org/apache/imperius/spl/tests/NumericExpressionTest.java URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/modules/imperius-splcore/src/test/java/org/apache/imperius/spl/tests/NumericExpressionTest.java?rev=608716&view=auto ============================================================================== --- incubator/imperius/trunk/modules/imperius-splcore/src/test/java/org/apache/imperius/spl/tests/NumericExpressionTest.java (added) +++ incubator/imperius/trunk/modules/imperius-splcore/src/test/java/org/apache/imperius/spl/tests/NumericExpressionTest.java Thu Jan 3 18:47:48 2008 @@ -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 + * + */ + + +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