Examples of tcg.common.util.ExpressionParser

tcg.common.util.ExpressionParser

    }
  }
  
  public void testAdditionInt()
  {
    ExpressionParser parser = null;
    Integer result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("1 + 5", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("1+5", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 + var2", Integer.class);
    parser.createVariable("var1", Integer.class, new Integer(0));
    parser.createVariable("var2", Integer.class, new Integer(0));
    try
    {
      //set the variable (using variable name)
      parser.set("var1", new Integer(1));
      parser.set("var2", new Integer(5));
      //evaluate
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6, result.intValue());
      //change one of the variable (using index)
      parser.set(1, new Integer(-7));
      //evaluate
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-6, result.intValue());
    }
    catch(Exception ex)
    {

View Full Code Here

    }
  }
  
  public void testAdditionDbl()
  {
    ExpressionParser parser = null;
    Double result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("1.2 + 5.6", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6.8, round(result.doubleValue(), 1));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("1.2+5.6", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6.8, round(result.doubleValue(), 1));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 + var2", Double.class);
    parser.createVariable("var1", Double.class, new Double(0));
    parser.createVariable("var2", Double.class, new Double(0));
    try
    {
      //set the variable (using variable name)
      parser.set("var1", new Double(1.2));
      parser.set("var2", new Double(5.6));
      //evaluate
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6.8, round(result.doubleValue(), 1));
      //change one of the variable (using index)
      parser.set(1, new Double(-7.8));
      //evaluate
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-6.6, round(result.doubleValue(), 1));
    }
    catch(Exception ex)
    {

View Full Code Here

    }
  }
  
  public void testSubstractionInt()
  {
    ExpressionParser parser = null;
    Integer result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("5 - 1", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(4, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("5-1", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(4, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 - var2", Integer.class);
    parser.createVariable("var1", Integer.class, new Integer(0));
    parser.createVariable("var2", Integer.class, new Integer(0));
    try
    {
      //set the variable (using variable name)
      parser.set("var1", new Integer(5));
      parser.set("var2", new Integer(1));
      //evaluate (5 - 1)
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(4, result.intValue());
      //subtract with negative value (using index)
      parser.set(1, new Integer(-2));
      //evaluate (5 - (-2))
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(7, result.intValue());
      //subtract from negative value (using index)
      parser.set(0, new Integer(-5));
      //evaluate (-5 - (-2)
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-3, result.intValue());
    }
    catch(Exception ex)
    {

View Full Code Here

    }
  }
  
  public void testSubtractionDbl()
  {
    ExpressionParser parser = null;
    Double result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("5.6 - 1.2", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(4.4, round(result.doubleValue(), 1));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("5.6-1.2", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(4.4, round(result.doubleValue(), 1));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 - var2", Double.class);
    parser.createVariable("var1", Double.class, new Double(0));
    parser.createVariable("var2", Double.class, new Double(0));
    try
    {
      //set the variable (using variable name)
      parser.set("var1", new Double(5.6));
      parser.set("var2", new Double(1.2));
      //evaluate (5.6 - 1.2)
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(4.4, round(result.doubleValue(), 1));
      //subtract with negative value (using index)
      parser.set(1, new Double(-2.3));
      //evaluate (5.6 - (-2.3))
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(7.9, round(result.doubleValue(), 1));
      //subtract from negative value (using index)
      parser.set(0, new Double(-6.7));
      //evaluate (-6.7 - (-2.3))
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-4.4, round(result.doubleValue(), 1));
    }
    catch(Exception ex)
    {

View Full Code Here

    }
  }
  
  public void testMultiplicationInt()
  {
    ExpressionParser parser = null;
    Integer result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("5 * 2", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(10, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("5*2", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(10, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 * var2", Integer.class);
    parser.createVariable("var1", Integer.class, new Integer(0));
    parser.createVariable("var2", Integer.class, new Integer(0));
    try
    {
      //evaluate (5 * 2)
      parser.set("var1", new Integer(5));
      parser.set("var2", new Integer(2));
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(10, result.intValue());
      //evaluate (3 * -4)
      parser.set(0, new Integer(3));
      parser.set(1, new Integer(-4));
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-12, result.intValue());
      //evaluate (-6 - (-3))
      parser.set(0, new Integer(-6));
      parser.set(1, new Integer(-3));
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(18, result.intValue());
    }
    catch(Exception ex)
    {

View Full Code Here

    }
  }
  
  public void testMultiplicationDbl()
  {
    ExpressionParser parser = null;
    Double result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("5.6 * 1.2", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6.72, round(result.doubleValue(), 2));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("5.6*1.2", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6.72, round(result.doubleValue(), 2));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 * var2", Double.class);
    parser.createVariable("var1", Double.class, new Double(0));
    parser.createVariable("var2", Double.class, new Double(0));
    try
    {
      //evaluate (5.6 * 1.2)
      parser.set("var1", new Double(5.6));
      parser.set("var2", new Double(1.2));
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6.72, round(result.doubleValue(), 2));
      //evaluate (5.6 * -1.2)
      parser.set("var1", new Double(5.6));
      parser.set("var2", new Double(-1.2));
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-6.72, round(result.doubleValue(), 2));
      //evaluate (-5.6 * -1.2)
      parser.set("var1", new Double(-5.6));
      parser.set("var2", new Double(-1.2));
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(6.72, round(result.doubleValue(), 2));
    }
    catch(Exception ex)
    {

View Full Code Here

    }
  }
  
  public void testDivisionInt()
  {
    ExpressionParser parser = null;
    Integer result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("6 / 2", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(3, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("6/2", Integer.class);
    try
    {
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(3, result.intValue());
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 / var2", Integer.class);
    parser.createVariable("var1", Integer.class, new Integer(0));
    parser.createVariable("var2", Integer.class, new Integer(0));
    try
    {
      //evaluate (6 * 2)
      parser.set("var1", new Integer(6));
      parser.set("var2", new Integer(2));
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(3, result.intValue());
      //evaluate (6 * -2)
      parser.set(0, new Integer(6));
      parser.set(1, new Integer(-2));
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-3, result.intValue());
      //evaluate (-6 - (-3))
      parser.set(0, new Integer(-6));
      parser.set(1, new Integer(-3));
      result = (Integer)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(2, result.intValue());
    }
    catch(Exception ex)
    {

View Full Code Here

    }
  }
  
  public void testDivisionDouble()
  {
    ExpressionParser parser = null;
    Double result = null;


    //using constant-value (with space)
    parser = new ExpressionParser("6.72 / 1.2", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(5.6, round(result.doubleValue(), 2));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using constant-value (without space)
    parser = new ExpressionParser("6.72/1.2", Double.class);
    try
    {
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(5.6, round(result.doubleValue(), 2));
    }
    catch(Exception ex)
    {
      Assert.fail(ex.toString());
    }


    //using variable with space
    parser = new ExpressionParser("var1 / var2", Double.class);
    parser.createVariable("var1", Double.class, new Double(0));
    parser.createVariable("var2", Double.class, new Double(0));
    try
    {
      //evaluate (6.72 / 1.2)
      parser.set("var1", new Double(6.72));
      parser.set("var2", new Double(1.2));
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(5.6, round(result.doubleValue(), 2));
      //evaluate (6.72 / -1.2)
      parser.set(0, new Double(6.72));
      parser.set(1, new Double(-1.2));
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(-5.6, round(result.doubleValue(), 2));
      //evaluate (-6.72 / -1.2)
      parser.set(0, new Double(-6.72));
      parser.set(1, new Double(-1.2));
      result = (Double)parser.evaluate();
      Assert.assertNotNull(result);
      Assert.assertEquals(5.6, round(result.doubleValue(), 2));
    }
    catch(Exception ex)
    {

View Full Code Here

  {
    fail("Not yet implemented"); // TODO
  }


  public void testBiggerThan() {
    ExpressionParser parser = null;
    Boolean boolResult = null;
    
    parser = new ExpressionParser("var1 > var2", Boolean.class);
    parser.createVariable("var1", Integer.class, new Integer(0));
    parser.createVariable("var2", Integer.class, new Integer(0));
    try
    {
      //initial state
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(false, boolResult.booleanValue());
      //evaluate (4 > 6)
      parser.set("var1", new Integer(4));
      parser.set("var2", new Integer(6));
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(false, boolResult.booleanValue());
      //evaluate (6 > 6)
      parser.set("var1", new Integer(6));
      parser.set("var2", new Integer(6));
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(false, boolResult.booleanValue());
      //evaluate (8 > 6)
      parser.set("var1", new Integer(8));
      parser.set("var2", new Integer(6));
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(true, boolResult.booleanValue());
    }
    catch(Exception ex)
    {

View Full Code Here

      Assert.fail(ex.toString());
    }    
  }
  
  public void testBiggerThanEqual() {
    ExpressionParser parser = null;
    Boolean boolResult = null;
    
    parser = new ExpressionParser("var1 >= var2", Boolean.class);
    parser.createVariable("var1", Integer.class, new Integer(0));
    parser.createVariable("var2", Integer.class, new Integer(0));
    try
    {
      //initial state (true -> 0 >= 0)
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(true, boolResult.booleanValue());
      //evaluate (4 >= 6)
      parser.set("var1", new Integer(4));
      parser.set("var2", new Integer(6));
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(false, boolResult.booleanValue());
      //evaluate (6 >= 6)
      parser.set("var1", new Integer(6));
      parser.set("var2", new Integer(6));
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(true, boolResult.booleanValue());
      //evaluate (8 >= 6)
      parser.set("var1", new Integer(8));
      parser.set("var2", new Integer(6));
      boolResult = (Boolean)parser.evaluate();
      Assert.assertNotNull(boolResult);
      Assert.assertEquals(true, boolResult.booleanValue());
    }
    catch(Exception ex)
    {

View Full Code Here

0 1 2

TOP

Related Classes of tcg.common.util.ExpressionParser

org.codehaus.janino.ExpressionEvaluator

tcg.scada.da.CalculatedDataPoint

tcg.scada.da.OutputDataPoint

tcg.scada.da.RealDataPoint

tcg.scada.da.xxxDataPoint

tst.common.util.ExpressionParserTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.