Merge pull request #15559 from vespa-engine/arnej/test-more-lambdas-with-factory

ensure all cases can test with factory

1 files changed, 43 insertions, 65 deletions

diff --git a/eval/src/tests/eval/tensor_lambda/tensor_lambda_test.cpp b/eval/src/tests/eval/tensor_lambda/tensor_lambda_test.cpp
index 2bffc376dbf..f1c8e6d3a5e 100644
--- a/eval/src/tests/eval/tensor_lambda/tensor_lambda_test.cpp
+++ b/eval/src/tests/eval/tensor_lambda/tensor_lambda_test.cpp
@@ -4,7 +4,6 @@
 #include <vespa/eval/eval/tensor_function.h>
 #include <vespa/eval/eval/simple_value.h>
 #include <vespa/eval/eval/fast_value.h>
-#include <vespa/eval/tensor/default_tensor_engine.h>
 #include <vespa/eval/tensor/dense/dense_replace_type_function.h>
 #include <vespa/eval/instruction/dense_cell_range_function.h>
 #include <vespa/eval/instruction/dense_lambda_peek_function.h>
@@ -21,26 +20,10 @@
 using namespace vespalib;
 using namespace vespalib::eval;
 using namespace vespalib::eval::test;
-using namespace vespalib::tensor;
 using namespace vespalib::eval::tensor_function;
 
-using EvalMode = DenseLambdaFunction::EvalMode;
-
-namespace vespalib::tensor {
-
-std::ostream &operator<<(std::ostream &os, EvalMode eval_mode)
-{
-    switch(eval_mode) {
-    case EvalMode::COMPILED:    return os << "COMPILED";
-    case EvalMode::INTERPRETED: return os << "INTERPRETED";
-    }
-    abort();
-}
-
-}
-
-const TensorEngine &prod_engine = DefaultTensorEngine::ref();
 const ValueBuilderFactory &simple_factory = SimpleValueBuilderFactory::get();
+const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
 
 EvalFixture::ParamRepo make_params() {
     return EvalFixture::ParamRepo()
@@ -58,13 +41,14 @@ EvalFixture::ParamRepo param_repo = make_params();
 
 template <typename T, typename F>
 void verify_impl(const vespalib::string &expr, const vespalib::string &expect, F &&inspect) {
-    EvalFixture fixture(prod_engine, expr, param_repo, true);
-    EvalFixture slow_fixture(prod_engine, expr, param_repo, false);
+    EvalFixture fixture(prod_factory, expr, param_repo, true);
+    EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
     EvalFixture simple_factory_fixture(simple_factory, expr, param_repo, false);
-    EXPECT_EQUAL(fixture.result(), slow_fixture.result());
-    EXPECT_EQUAL(fixture.result(), simple_factory_fixture.result());
-    EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expr, param_repo));
-    EXPECT_EQUAL(fixture.result(), EvalFixture::ref(expect, param_repo));
+    auto expect_spec = EvalFixture::ref(expect, param_repo);
+    EXPECT_EQUAL(fixture.result(), expect_spec);
+    EXPECT_EQUAL(slow_fixture.result(), expect_spec);
+    EXPECT_EQUAL(simple_factory_fixture.result(), expect_spec);
+    EXPECT_EQUAL(EvalFixture::ref(expr, param_repo), expect_spec);
     auto info = fixture.find_all<T>();
     if (EXPECT_EQUAL(info.size(), 1u)) {
         inspect(info[0]);
@@ -75,18 +59,12 @@ void verify_impl(const vespalib::string &expr, const vespalib::string &expect) {
     verify_impl<T>(expr, expect, [](const T*){});
 }
 
-void verify_generic(const vespalib::string &expr, const vespalib::string &expect,
-                    EvalMode expect_eval_mode)
-{
-    verify_impl<DenseLambdaFunction>(expr, expect,
-                                     [&](const DenseLambdaFunction *info)
-                                     {
-                                         EXPECT_EQUAL(info->eval_mode(), expect_eval_mode);
-                                     });
+void verify_generic(const vespalib::string &expr, const vespalib::string &expect) {
+    verify_impl<tensor_function::Lambda>(expr, expect);
 }
 
 void verify_reshape(const vespalib::string &expr, const vespalib::string &expect) {
-    verify_impl<DenseReplaceTypeFunction>(expr, expect);
+    verify_impl<tensor::DenseReplaceTypeFunction>(expr, expect);
 }
 
 void verify_range(const vespalib::string &expr, const vespalib::string &expect) {
@@ -113,43 +91,15 @@ TEST("require that simple constant tensor lambda works") {
     TEST_DO(verify_const("tensor(x[3])(x+1)", "tensor(x[3]):[1,2,3]"));
 }
 
-TEST("require that simple dynamic tensor lambda works") {
-    TEST_DO(verify_generic("tensor(x[3])(x+a)", "tensor(x[3]):[1,2,3]", EvalMode::COMPILED));
-}
-
-TEST("require that compiled multi-dimensional multi-param dynamic tensor lambda works") {
-    TEST_DO(verify_generic("tensor(x[3],y[2])((b-a)+x+y)", "tensor(x[3],y[2]):[[1,2],[2,3],[3,4]]", EvalMode::COMPILED));
-    TEST_DO(verify_generic("tensor<float>(x[3],y[2])((b-a)+x+y)", "tensor<float>(x[3],y[2]):[[1,2],[2,3],[3,4]]", EvalMode::COMPILED));
-}
-
-TEST("require that interpreted multi-dimensional multi-param dynamic tensor lambda works") {
-    TEST_DO(verify_generic("tensor(x[3],y[2])((x3{x:(a)}-a)+x+y)", "tensor(x[3],y[2]):[[1,2],[2,3],[3,4]]", EvalMode::INTERPRETED));
-    TEST_DO(verify_generic("tensor<float>(x[3],y[2])((x3{x:(a)}-a)+x+y)", "tensor<float>(x[3],y[2]):[[1,2],[2,3],[3,4]]", EvalMode::INTERPRETED));
-}
-
-TEST("require that tensor lambda can be used for tensor slicing") {
-    TEST_DO(verify_generic("tensor(x[2])(x3{x:(x+a)})", "tensor(x[2]):[2,3]", EvalMode::INTERPRETED));
-    TEST_DO(verify_generic("tensor(x[2])(a+x3{x:(x)})", "tensor(x[2]):[2,3]", EvalMode::INTERPRETED));
-}
-
 TEST("require that tensor lambda can be used for cell type casting") {
     TEST_DO(verify_idx_fun("tensor(x[3])(x3f{x:(x)})", "tensor(x[3]):[1,2,3]", "f(x)(x)"));
     TEST_DO(verify_idx_fun("tensor<float>(x[3])(x3{x:(x)})", "tensor<float>(x[3]):[1,2,3]", "f(x)(x)"));
 }
 
-TEST("require that tensor lambda can be used to convert from sparse to dense tensors") {
-    TEST_DO(verify_generic("tensor(x[3])(x3m{x:(x)})", "tensor(x[3]):[1,2,3]", EvalMode::INTERPRETED));
-    TEST_DO(verify_generic("tensor(x[2])(x3m{x:(x)})", "tensor(x[2]):[1,2]", EvalMode::INTERPRETED));
-}
-
 TEST("require that constant nested tensor lambda using tensor peek works") {
     TEST_DO(verify_const("tensor(x[2])(tensor(y[2])((x+y)+1){y:(x)})", "tensor(x[2]):[1,3]"));
 }
 
-TEST("require that dynamic nested tensor lambda using tensor peek works") {
-    TEST_DO(verify_generic("tensor(x[2])(tensor(y[2])((x+y)+a){y:(x)})", "tensor(x[2]):[1,3]", EvalMode::INTERPRETED));
-}
-
 TEST("require that tensor reshape is optimized") {
     TEST_DO(verify_reshape("tensor(x[15])(x3y5{x:(x/5),y:(x%5)})", "x15"));
     TEST_DO(verify_reshape("tensor(x[3],y[5])(x15{x:(x*5+y)})", "x3y5"));
@@ -182,11 +132,39 @@ TEST("require that non-continuous cell extraction is optimized") {
     TEST_DO(verify_idx_fun("tensor<float>(x[3])(x3y5f{x:(x),y:2})", "x3y5f{y:2}", "f(x)((floor(x)*5)+2)"));
 }
 
+TEST("require that simple dynamic tensor lambda works") {
+    TEST_DO(verify_generic("tensor(x[3])(x+a)", "tensor(x[3]):[1,2,3]"));
+}
+
+TEST("require that compiled multi-dimensional multi-param dynamic tensor lambda works") {
+    TEST_DO(verify_generic("tensor(x[3],y[2])((b-a)+x+y)", "tensor(x[3],y[2]):[[1,2],[2,3],[3,4]]"));
+    TEST_DO(verify_generic("tensor<float>(x[3],y[2])((b-a)+x+y)", "tensor<float>(x[3],y[2]):[[1,2],[2,3],[3,4]]"));
+}
+
+TEST("require that interpreted multi-dimensional multi-param dynamic tensor lambda works") {
+    TEST_DO(verify_generic("tensor(x[3],y[2])((x3{x:(a)}-a)+x+y)", "tensor(x[3],y[2]):[[1,2],[2,3],[3,4]]"));
+    TEST_DO(verify_generic("tensor<float>(x[3],y[2])((x3{x:(a)}-a)+x+y)", "tensor<float>(x[3],y[2]):[[1,2],[2,3],[3,4]]"));
+}
+
+TEST("require that tensor lambda can be used for tensor slicing") {
+    TEST_DO(verify_generic("tensor(x[2])(x3{x:(x+a)})", "tensor(x[2]):[2,3]"));
+    TEST_DO(verify_generic("tensor(x[2])(a+x3{x:(x)})", "tensor(x[2]):[2,3]"));
+}
+
+TEST("require that tensor lambda can be used to convert from sparse to dense tensors") {
+    TEST_DO(verify_generic("tensor(x[3])(x3m{x:(x)})", "tensor(x[3]):[1,2,3]"));
+    TEST_DO(verify_generic("tensor(x[2])(x3m{x:(x)})", "tensor(x[2]):[1,2]"));
+}
+
+TEST("require that dynamic nested tensor lambda using tensor peek works") {
+    TEST_DO(verify_generic("tensor(x[2])(tensor(y[2])((x+y)+a){y:(x)})", "tensor(x[2]):[1,3]"));
+}
+
 TEST("require that out-of-bounds cell extraction is not optimized") {
-    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:1,y:(x+3)})", "tensor(x[3]):[9,10,0]", EvalMode::INTERPRETED));
-    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:1,y:(x-1)})", "tensor(x[3]):[0,6,7]", EvalMode::INTERPRETED));
-    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:(x+1),y:(x)})", "tensor(x[3]):[6,12,0]", EvalMode::INTERPRETED));
-    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:(x-1),y:(x)})", "tensor(x[3]):[0,2,8]", EvalMode::INTERPRETED));
+    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:1,y:(x+3)})", "tensor(x[3]):[9,10,0]"));
+    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:1,y:(x-1)})", "tensor(x[3]):[0,6,7]"));
+    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:(x+1),y:(x)})", "tensor(x[3]):[6,12,0]"));
+    TEST_DO(verify_generic("tensor(x[3])(x3y5{x:(x-1),y:(x)})", "tensor(x[3]):[0,2,8]"));
 }
 
 TEST("require that non-double result from inner tensor lambda function fails type resolving") {