Implement eval and add test for the expression sub-language.

eraser-base/src/main/jastadd/Expression.jrag

 aspect Expression {
-  syn boolean LogicalExpression.eval() = false;
+
+  //--- eval (logical) ---
+  syn boolean LogicalExpression.eval();
+  eq ParenthesizedLogicalExpression.eval() = getOperand().eval();
   eq NotExpression.eval() = !getOperand().eval();
   eq ComparingExpression.eval() {
-    // TODO
+    double leftValue = getLeftOperand().eval();
+    double rightValue = getRightOperand().eval();
+    switch (getComparator()) {
+      case LessThan:           return leftValue <  rightValue;
+      case LessOrEqualThan:    return leftValue <= rightValue;
+      case Equals:             return leftValue == rightValue;
+      case NotEquals:          return leftValue != rightValue;
+      case GreaterThan:        return leftValue >  rightValue;
+      case GreaterOrEqualThan: return leftValue >= rightValue;
+    }
     return false;
   }
   eq AndExpression.eval() = getLeftOperand().eval() && getRightOperand().eval();
   eq OrExpression.eval() = getLeftOperand().eval() || getRightOperand().eval();
+
+  //--- eval (number) ---
+  syn double NumberExpression.eval();
+  eq AddExpression.eval() = getLeftOperand().eval() + getRightOperand().eval();
+  eq SubExpression.eval() = getLeftOperand().eval() - getRightOperand().eval();
+  eq MultExpression.eval() = getLeftOperand().eval() * getRightOperand().eval();
+  eq DivExpression.eval() = getLeftOperand().eval() / getRightOperand().eval();
+  eq PowerExpression.eval() = Math.pow(getLeftOperand().eval(), getRightOperand().eval());
+  eq Designator.eval() = getItem().getStateAsDouble();
+  eq ParenthesizedNumberExpression.eval() = getOperand().eval();
+  eq NumberLiteralExpression.eval() = getValue();
 }

eraser-base/src/test/java/de/tudresden/inf/st/eraser/ExpressionEvalTest.java

+package de.tudresden.inf.st.eraser;
+
+import beaver.Parser;
+import de.tudresden.inf.st.eraser.jastadd.model.*;
+import de.tudresden.inf.st.eraser.util.ParserUtils;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Test correct evaluation of NumberExpression and LogicalExpression.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class ExpressionEvalTest {
+
+  @Test
+  public void plusExpression() throws IOException, Parser.Exception {
+    NumberExpression sut = ParserUtils.parseNumberExpression("(3 + 4)");
+    assertThat(sut.eval(), equalTo(7.0));
+  }
+
+  @Test
+  public void minusExpression() throws IOException, Parser.Exception {
+    NumberExpression sut = ParserUtils.parseNumberExpression("(4.1 - 12.5)");
+    assertThat(sut.eval(), equalTo(-8.4));
+  }
+
+  @Test
+  public void multExpression() throws IOException, Parser.Exception {
+    NumberExpression sut = ParserUtils.parseNumberExpression("(3 * 4)");
+    assertThat(sut.eval(), equalTo(12.0));
+  }
+
+  @Test
+  public void divExpression() throws IOException, Parser.Exception {
+    NumberExpression sut = ParserUtils.parseNumberExpression("(1.1 / 4.0)");
+    assertThat(sut.eval(), equalTo(0.275));
+  }
+
+  @Test
+  public void powerExpression() throws IOException, Parser.Exception {
+    NumberExpression sut = ParserUtils.parseNumberExpression("(16 ^ 0.5)");
+    assertThat(sut.eval(), equalTo(4.0));
+  }
+
+  @Test
+  public void parenthesizedExpression() throws IOException, Parser.Exception {
+    NumberExpression sut = ParserUtils.parseNumberExpression("(3)");
+    assertThat(sut.eval(), equalTo(3.0));
+  }
+
+  @Test
+  public void complexExpression() throws IOException, Parser.Exception {
+    NumberExpression sut = ParserUtils.parseNumberExpression("((3 + 4) * (1 / (12 - 8)))");
+    assertThat(sut.eval(), equalTo(1.75));
+    MultExpression multExpression = (MultExpression) sut;
+
+    // 3+4
+    assertThat(multExpression.getLeftOperand(), instanceOf(AddExpression.class));
+    assertThat(multExpression.getLeftOperand().eval(), equalTo(7.0));
+
+    // 1/(12-8)
+    assertThat(multExpression.getRightOperand(), instanceOf(DivExpression.class));
+    DivExpression divExpression = (DivExpression) multExpression.getRightOperand();
+    assertThat(divExpression.eval(), equalTo(0.25));
+
+    // 12-8
+    assertThat(divExpression.getRightOperand().eval(), equalTo(4.0));
+  }
+
+  @Test
+  public void comparingExpressions() throws IOException, Parser.Exception {
+    comparingExpression(1, "<",  2, true);
+    comparingExpression(2, "<",  2, false);
+    comparingExpression(3, "<",  2, false);
+
+    comparingExpression(3, "<=", 4, true);
+    comparingExpression(4, "<=", 4, true);
+    comparingExpression(5, "<=", 4, false);
+
+    comparingExpression(5, "==", 6, false);
+    comparingExpression(6, "==", 6, true);
+
+    comparingExpression(7, "!=", 8, true);
+    comparingExpression(8, "!=", 8, false);
+
+    comparingExpression(9, "=>", 10, false);
+    comparingExpression(10, "=>", 10, true);
+    comparingExpression(11, "=>", 10, true);
+
+    comparingExpression(11,">",   12, false);
+    comparingExpression(12,">",   12, false);
+    comparingExpression(13,">",   12, true);
+  }
+
+  private void comparingExpression(double left, String actualComparatorString, double right, boolean expectedResult) throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression(String.format("(%f %s %f)", left, actualComparatorString, right));
+    assertThat(sut.eval(), equalTo(expectedResult));
+  }
+
+  @Test
+  public void notExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("!(0==0)");
+    assertThat(sut.eval(), equalTo(false));
+    LogicalExpression sut2 = ParserUtils.parseLogicalExpression("!!(0==0)");
+    assertThat(sut2.eval(), equalTo(true));
+  }
+
+  @Test
+  public void andExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("((0==0) & (0==0))");
+    assertThat(sut.eval(), equalTo(true));
+
+    LogicalExpression sut2 = ParserUtils.parseLogicalExpression("((0==0) & (0==1))");
+    assertThat(sut2.eval(), equalTo(false));
+
+    LogicalExpression sut3 = ParserUtils.parseLogicalExpression("((0==1) & (0==0))");
+    assertThat(sut3.eval(), equalTo(false));
+
+    LogicalExpression sut4 = ParserUtils.parseLogicalExpression("((0==1) & (0==1))");
+    assertThat(sut4.eval(), equalTo(false));
+  }
+
+  @Test
+  public void orExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("((0==0) | (0==0))");
+    assertThat(sut.eval(), equalTo(true));
+
+    LogicalExpression sut2 = ParserUtils.parseLogicalExpression("((0==0) | (0==1))");
+    assertThat(sut2.eval(), equalTo(true));
+
+    LogicalExpression sut3 = ParserUtils.parseLogicalExpression("((0==1) | (0==0))");
+    assertThat(sut3.eval(), equalTo(true));
+
+    LogicalExpression sut4 = ParserUtils.parseLogicalExpression("((0==1) | (0==1))");
+    assertThat(sut4.eval(), equalTo(false));
+  }
+
+  @Test
+  public void parenthesizedLogicalExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("((0==0))");
+    assertThat(sut.eval(), equalTo(true));
+    ParenthesizedLogicalExpression parenthesizedLogicalExpression = (ParenthesizedLogicalExpression) sut;
+    assertThat(parenthesizedLogicalExpression.getOperand().eval(), equalTo(true));
+  }
+}