Use ArithmeticNode.resolve instead of creating a new one explicit.

1 files changed, 36 insertions, 9 deletions

diff --git a/config-model/src/test/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformerTestCase.java b/config-model/src/test/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformerTestCase.java
index 71d0657c701..01e4d4ce232 100644
--- a/config-model/src/test/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformerTestCase.java
+++ b/config-model/src/test/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformerTestCase.java
@@ -4,12 +4,16 @@ package com.yahoo.schema.expressiontransforms;
 import com.yahoo.searchlib.rankingexpression.RankingExpression;
 import com.yahoo.searchlib.rankingexpression.evaluation.MapContext;
 import com.yahoo.searchlib.rankingexpression.evaluation.MapTypeContext;
+import com.yahoo.searchlib.rankingexpression.rule.ArithmeticNode;
 import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.Map;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
 /**
  * @author bratseth
  */
@@ -33,6 +37,37 @@ public class BooleanExpressionTransformerTestCase {
         assertTransformed("if(1 - 1, true, 1 - 1)", "1 - 1 || 1 - 1");
     }
 
+    @Test
+    public void testNotSkewingNonBoolean() throws Exception {
+        assertTransformed("a + b + c * d + e + f", "a + b + c * d + e + f");
+        var expr = new BooleanExpressionTransformer()
+                .transform(new RankingExpression("a + b + c * d + e + f"),
+                        new TransformContext(Map.of(), new MapTypeContext()));
+        assertTrue(expr.getRoot() instanceof ArithmeticNode);
+        ArithmeticNode root = (ArithmeticNode) expr.getRoot();
+        assertEquals(5, root.operators().size());
+        assertEquals(6, root.children().size());
+    }
+
+    @Test
+    public void testTransformPreservesPrecedence() throws Exception {
+        assertUnTransformed("a");
+        assertUnTransformed("a + b");
+        assertUnTransformed("a + b + c");
+        assertUnTransformed("a * b");
+        assertUnTransformed("a + b * c + d");
+        assertUnTransformed("a + b + c * d + e + f");
+        assertUnTransformed("a * b + c + d + e * f");
+        assertUnTransformed("(a * b) + c + d + e * f");
+        assertUnTransformed("(a * b + c) + d + e * f");
+        assertUnTransformed("a * (b + c) + d + e * f");
+        assertUnTransformed("(a * b) + (c + (d + e)) * f");
+    }
+
+    private void assertUnTransformed(String input) throws Exception {
+        assertTransformed(input, input);
+    }
+
     private void assertTransformed(String expected, String input) throws Exception {
         var transformedExpression = new BooleanExpressionTransformer()
                                             .transform(new RankingExpression(input),
@@ -40,18 +75,10 @@ public class BooleanExpressionTransformerTestCase {
 
         assertEquals(new RankingExpression(expected), transformedExpression, "Transformed as expected");
 
-        MapContext context = contextWithSingleLetterVariables();
         var inputExpression = new RankingExpression(input);
         assertEquals(inputExpression.evaluate(new MapContext()).asBoolean(),
                      transformedExpression.evaluate(new MapContext()).asBoolean(),
                      "Transform and original input are equivalent");
     }
 
-    private MapContext contextWithSingleLetterVariables() {
-        var context = new MapContext();
-        for (int i = 0; i < 26; i++)
-            context.put(Character.toString(i + 97), Math.floorMod(i, 2));
-        return context;
-    }
-
 }