Add conformance testing for 'sum' aggregator too.

3 files changed, 71 insertions, 18 deletions

diff --git a/searchlib/src/tests/aggregator/perdocexpr.cpp b/searchlib/src/tests/aggregator/perdocexpr.cpp
index c3667c36f8e..1b85fb8f427 100644
--- a/searchlib/src/tests/aggregator/perdocexpr.cpp
+++ b/searchlib/src/tests/aggregator/perdocexpr.cpp
@@ -1357,6 +1357,43 @@ TEST("test Average over non-numeric string") {
     EXPECT_EQUAL(0, avg.getAverage().getInteger());
 }
 
+TEST("test Sum over integer") {
+    AggregationResult::Configure conf;
+    SumAggregationResult sum;
+    sum.setExpression(createScalarInt(I4)).select(conf, conf);
+    sum.aggregate(0, 0);
+    sum.aggregate(0, 0);
+    EXPECT_EQUAL(I4*2, sum.getSum().getInteger());
+}
+
+TEST("test Sum over float") {
+    AggregationResult::Configure conf;
+    SumAggregationResult sum;
+    sum.setExpression(createScalarFloat(I4)).select(conf, conf);
+    sum.aggregate(0, 0);
+    sum.aggregate(0, 0);
+    EXPECT_EQUAL(I4*2, sum.getSum().getInteger());
+}
+
+TEST("test Sum over numeric string") {
+    AggregationResult::Configure conf;
+    SumAggregationResult sum;
+    sum.setExpression(createScalarString("7.8")).select(conf, conf);
+    sum.aggregate(0, 0);
+    sum.aggregate(0, 0);
+    EXPECT_EQUAL(7.8*2, sum.getSum().getFloat());
+}
+
+TEST("test Sum over non-numeric string") {
+    AggregationResult::Configure conf;
+    SumAggregationResult sum;
+    sum.setExpression(createScalarString("ABC")).select(conf, conf);
+    sum.aggregate(0, 0);
+    sum.aggregate(0, 0);
+    EXPECT_EQUAL(0, sum.getSum().getInteger());
+}
+
+
 TEST("testGrouping") {
     AttributeGuard attr1 = createInt64Attribute();
     ExpressionNode::UP result1(new CountAggregationResult());
diff --git a/searchlib/src/tests/grouping/grouping_test.cpp b/searchlib/src/tests/grouping/grouping_test.cpp
index fea18619ef9..4fdf4d34778 100644
--- a/searchlib/src/tests/grouping/grouping_test.cpp
+++ b/searchlib/src/tests/grouping/grouping_test.cpp
@@ -630,6 +630,14 @@ createAggr(SingleResultNode::UP r, ExpressionNode::UP e) {
     return aggr;
 }
 
+template<typename T>
+ExpressionNode::UP
+createNumAggr(NumericResultNode::UP r, ExpressionNode::UP e) {
+    std::unique_ptr<T> aggr = MU<T>(std::move(r));
+    aggr->setExpression(std::move(e));
+    return aggr;
+}
+
 void
 Test::testAggregationGroupCapping()
 {
@@ -680,13 +688,13 @@ Test::testAggregationGroupCapping()
 
         Group expect;
         expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
-                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
                                 .addOrderBy(MU<AggregationRefNode>(0), false))
               .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
-                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
                                 .addOrderBy(MU<AggregationRefNode>(0), false))
               .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
-                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
                                 .addOrderBy(MU<AggregationRefNode>(0), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
@@ -701,13 +709,13 @@ Test::testAggregationGroupCapping()
 
         Group expect = Group()
                        .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1))
-                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(1), MU<AttributeNode>("attr")))
+                                         .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(1), MU<AttributeNode>("attr")))
                                          .addOrderBy(MU<AggregationRefNode>(0), true))
                        .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2))
-                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(2), MU<AttributeNode>("attr")))
+                                         .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(2), MU<AttributeNode>("attr")))
                                          .addOrderBy(MU<AggregationRefNode>(0), true))
                        .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3))
-                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(3), MU<AttributeNode>("attr")))
+                                         .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(3), MU<AttributeNode>("attr")))
                                          .addOrderBy(MU<AggregationRefNode>(0), true));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
@@ -726,13 +734,13 @@ Test::testAggregationGroupCapping()
 
         Group expect;
         expect.addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
-                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
                                 .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(10)), false))
               .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
-                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
                                 .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(11)), false))
               .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
-                                .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
                                 .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(12)), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
diff --git a/searchlib/src/tests/groupingengine/groupingengine_test.cpp b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
index 3920667c1d6..da9b8d62305 100644
--- a/searchlib/src/tests/groupingengine/groupingengine_test.cpp
+++ b/searchlib/src/tests/groupingengine/groupingengine_test.cpp
@@ -615,6 +615,14 @@ createAggr(SingleResultNode::UP r, ExpressionNode::UP e) {
     return aggr;
 }
 
+template<typename T>
+ExpressionNode::UP
+createNumAggr(NumericResultNode::UP r, ExpressionNode::UP e) {
+    std::unique_ptr<T> aggr = MU<T>(std::move(r));
+    aggr->setExpression(std::move(e));
+    return aggr;
+}
+
 void
 Test::testAggregationGroupCapping()
 {
@@ -670,13 +678,13 @@ Test::testAggregationGroupCapping()
         Group expect;
         expect.setId(NullResultNode())
                 .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
-                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), false))
                 .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
-                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), false))
                 .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
-                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
@@ -693,13 +701,13 @@ Test::testAggregationGroupCapping()
         Group expect;
         expect.setId(NullResultNode())
                 .addChild(Group().setId(Int64ResultNode(1)).setRank(RawRank(1))
-                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(1), MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(1), MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), true))
                 .addChild(Group().setId(Int64ResultNode(2)).setRank(RawRank(2))
-                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(2), MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(2), MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), true))
                 .addChild(Group().setId(Int64ResultNode(3)).setRank(RawRank(3))
-                                  .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(3), MU<AttributeNode>("attr")))
+                                  .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(3), MU<AttributeNode>("attr")))
                                   .addOrderBy(MU<AggregationRefNode>(0), true));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));
@@ -718,13 +726,13 @@ Test::testAggregationGroupCapping()
 
         Group expect = Group()
                        .addChild(Group().setId(Int64ResultNode(7)).setRank(RawRank(7))
-                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
+                                         .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(7), MU<AttributeNode>("attr")))
                                          .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(10)), false))
                        .addChild(Group().setId(Int64ResultNode(8)).setRank(RawRank(8))
-                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
+                                         .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(8), MU<AttributeNode>("attr")))
                                          .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(11)), false))
                        .addChild(Group().setId(Int64ResultNode(9)).setRank(RawRank(9))
-                                         .addAggregationResult(createAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
+                                         .addAggregationResult(createNumAggr<SumAggregationResult>(MU<Int64ResultNode>(9), MU<AttributeNode>("attr")))
                                          .addOrderBy(AddFunctionNode().appendArg(MU<AggregationRefNode>(0)).appendArg(MU<ConstantNode>(MU<Int64ResultNode>(3))).setResult(Int64ResultNode(12)), false));
 
         EXPECT_TRUE(testAggregation(ctx, request, expect));