Merge pull request #30341 from vespa-engine/toregge/rewrite-tensor-from-weighted-set-feature-unit-test-to-gtest

Rewrite tensorFromWeightedSet feature unit test to gtest.

1 files changed, 59 insertions, 54 deletions

diff --git a/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp b/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
index 9c8f231051e..6ba4ed2c6ba 100644
--- a/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
+++ b/searchlib/src/tests/features/tensor_from_weighted_set/tensor_from_weighted_set_test.cpp
@@ -1,5 +1,4 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/test_kit.h>
 
 #include <vespa/eval/eval/function.h>
 #include <vespa/eval/eval/simple_value.h>
@@ -15,7 +14,9 @@
 #include <vespa/searchlib/features/tensor_from_weighted_set_feature.h>
 #include <vespa/searchlib/fef/fef.h>
 #include <vespa/searchlib/fef/test/indexenvironment.h>
-#include <vespa/searchlib/test/ft_test_app.h>
+#define ENABLE_GTEST_MIGRATION
+#include <vespa/searchlib/test/ft_test_app_base.h>
+#include <vespa/vespalib/gtest/gtest.h>
 
 using search::feature_t;
 using namespace search::fef;
@@ -33,7 +34,7 @@ using AVC = search::attribute::Config;
 using AVBT = search::attribute::BasicType;
 using AVCT = search::attribute::CollectionType;
 using AttributePtr = search::AttributeVector::SP;
-using FTA = FtTestApp;
+using FTA = FtTestAppBase;
 
 Value::UP make_tensor(const TensorSpec &spec) {
     return SimpleValue::from_spec(spec);
@@ -54,24 +55,28 @@ struct SetupFixture
     }
 };
 
-TEST_F("require that blueprint can be created from factory", SetupFixture)
+TEST(TensorFromWeightedSetTest, require_that_blueprint_can_be_created_from_factory)
 {
+    SetupFixture f;
     EXPECT_TRUE(FTA::assertCreateInstance(f.blueprint, "tensorFromWeightedSet"));
 }
 
-TEST_F("require that setup fails if source spec is invalid", SetupFixture)
+TEST(TensorFromWeightedSetTest, require_that_setup_fails_if_source_spec_is_invalid)
 {
+    SetupFixture f;
     FTA::FT_SETUP_FAIL(f.blueprint, f.indexEnv, StringList().add("source(foo)"));
 }
 
-TEST_F("require that setup succeeds with attribute source", SetupFixture)
+TEST(TensorFromWeightedSetTest, require_that_setup_succeeds_with_attribute_source)
 {
+    SetupFixture f;
     FTA::FT_SETUP_OK(f.blueprint, f.indexEnv, StringList().add("attribute(foo)"),
             StringList(), StringList().add("tensor"));
 }
 
-TEST_F("require that setup succeeds with query source", SetupFixture)
+TEST(TensorFromWeightedSetTest, require_that_setup_succeeds_with_query_source)
 {
+    SetupFixture f;
     FTA::FT_SETUP_OK(f.blueprint, f.indexEnv, StringList().add("query(foo)"),
             StringList(), StringList().add("tensor"));
 }
@@ -87,7 +92,7 @@ struct ExecFixture
         setup_search_features(factory);
         setupAttributeVectors();
         setupQueryEnvironment();
-        ASSERT_TRUE(test.setup());
+        EXPECT_TRUE(test.setup());
     }
     void setupAttributeVectors() {
         std::vector<AttributePtr> attrs;
@@ -126,76 +131,76 @@ struct ExecFixture
     }
 };
 
-TEST_F("require that weighted set string attribute can be converted to tensor (default dimension)",
-        ExecFixture("tensorFromWeightedSet(attribute(wsstr))"))
+TEST(TensorFromWeightedSetTest, require_that_weighted_set_string_attribute_can_be_converted_to_tensor_using_default_dimension)
 {
-    EXPECT_EQUAL(*make_tensor(TensorSpec("tensor(wsstr{})")
-                              .add({{"wsstr","b"}}, 5)
-                              .add({{"wsstr","c"}}, 7)
-                              .add({{"wsstr","a"}}, 3)), f.execute());
+    ExecFixture f("tensorFromWeightedSet(attribute(wsstr))");
+    EXPECT_EQ(*make_tensor(TensorSpec("tensor(wsstr{})")
+                           .add({{"wsstr","b"}}, 5)
+                           .add({{"wsstr","c"}}, 7)
+                           .add({{"wsstr","a"}}, 3)), f.execute());
 }
 
-TEST_F("require that weighted set string attribute can be converted to tensor (explicit dimension)",
-        ExecFixture("tensorFromWeightedSet(attribute(wsstr),dim)"))
+TEST(TensorFromWeightedSetTest, require_that_weighted_set_string_attribute_can_be_converted_to_tensor_using_explicit_dimension)
 {
-    EXPECT_EQUAL(*make_tensor(TensorSpec("tensor(dim{})")
-                              .add({{"dim","a"}}, 3)
-                              .add({{"dim","b"}}, 5)
-                              .add({{"dim","c"}}, 7)), f.execute());
+    ExecFixture f("tensorFromWeightedSet(attribute(wsstr),dim)");
+    EXPECT_EQ(*make_tensor(TensorSpec("tensor(dim{})")
+                           .add({{"dim","a"}}, 3)
+                           .add({{"dim","b"}}, 5)
+                           .add({{"dim","c"}}, 7)), f.execute());
 }
 
-TEST_F("require that weighted set integer attribute can be converted to tensor (default dimension)",
-        ExecFixture("tensorFromWeightedSet(attribute(wsint))"))
+TEST(TensorFromWeightedSetTest, require_that_weighted_set_integer_attribute_can_be_converted_to_tensor_using_default_dimension)
 {
-    EXPECT_EQUAL(*make_tensor(TensorSpec("tensor(wsint{})")
-                              .add({{"wsint","13"}}, 5)
-                              .add({{"wsint","17"}}, 7)
-                              .add({{"wsint","11"}}, 3)), f.execute());
+    ExecFixture f("tensorFromWeightedSet(attribute(wsint))");
+    EXPECT_EQ(*make_tensor(TensorSpec("tensor(wsint{})")
+                           .add({{"wsint","13"}}, 5)
+                           .add({{"wsint","17"}}, 7)
+                           .add({{"wsint","11"}}, 3)), f.execute());
 }
 
-TEST_F("require that weighted set integer attribute can be converted to tensor (explicit dimension)",
-        ExecFixture("tensorFromWeightedSet(attribute(wsint),dim)"))
+TEST(TensorFromWeightedSetTest, require_that_weighted_set_integer_attribute_can_be_converted_to_tensor_using_explicit_dimension)
 {
-    EXPECT_EQUAL(*make_tensor(TensorSpec("tensor(dim{})")
-                              .add({{"dim","17"}}, 7)
-                              .add({{"dim","11"}}, 3)
-                              .add({{"dim","13"}}, 5)), f.execute());
+    ExecFixture f("tensorFromWeightedSet(attribute(wsint),dim)");
+    EXPECT_EQ(*make_tensor(TensorSpec("tensor(dim{})")
+                           .add({{"dim","17"}}, 7)
+                           .add({{"dim","11"}}, 3)
+                           .add({{"dim","13"}}, 5)), f.execute());
 }
 
-TEST_F("require that weighted set from query can be converted to tensor (default dimension)",
-        ExecFixture("tensorFromWeightedSet(query(wsquery))"))
+TEST(TensorFromWeightedSetTest, require_that_weighted_set_from_query_can_be_converted_to_tensor_using_default_dimension)
 {
-    EXPECT_EQUAL(*make_tensor(TensorSpec("tensor(wsquery{})")
-                              .add({{"wsquery","f"}}, 17)
-                              .add({{"wsquery","d"}}, 11)
-                              .add({{"wsquery","e"}}, 13)), f.execute());
+    ExecFixture f("tensorFromWeightedSet(query(wsquery))");
+    EXPECT_EQ(*make_tensor(TensorSpec("tensor(wsquery{})")
+                           .add({{"wsquery","f"}}, 17)
+                           .add({{"wsquery","d"}}, 11)
+                           .add({{"wsquery","e"}}, 13)), f.execute());
 }
 
-TEST_F("require that weighted set from query can be converted to tensor (explicit dimension)",
-        ExecFixture("tensorFromWeightedSet(query(wsquery),dim)"))
+TEST(TensorFromWeightedSetTest, require_that_weighted_set_from_query_can_be_converted_to_tensor_using_explicit_dimension)
 {
-    EXPECT_EQUAL(*make_tensor(TensorSpec("tensor(dim{})")
-                              .add({{"dim","d"}}, 11)
-                              .add({{"dim","e"}}, 13)
-                              .add({{"dim","f"}}, 17)), f.execute());
+    ExecFixture f("tensorFromWeightedSet(query(wsquery),dim)");
+    EXPECT_EQ(*make_tensor(TensorSpec("tensor(dim{})")
+                           .add({{"dim","d"}}, 11)
+                           .add({{"dim","e"}}, 13)
+                           .add({{"dim","f"}}, 17)), f.execute());
 }
 
-TEST_F("require that empty tensor is created if attribute does not exists",
-        ExecFixture("tensorFromWeightedSet(attribute(null))"))
+TEST(TensorFromWeightedSetTest, require_that_empty_tensor_is_created_if_attribute_does_not_exists)
 {
-    EXPECT_EQUAL(*make_empty("tensor(null{})"), f.execute());
+    ExecFixture f("tensorFromWeightedSet(attribute(null))");
+    EXPECT_EQ(*make_empty("tensor(null{})"), f.execute());
 }
 
-TEST_F("require that empty tensor is created if attribute type is not supported",
-        ExecFixture("tensorFromWeightedSet(attribute(astr))"))
+TEST(TensorFromWeightedSetTest, require_that_empty_tensor_is_created_if_attribute_type_is_not_supported)
 {
-    EXPECT_EQUAL(*make_empty("tensor(astr{})"), f.execute());
+    ExecFixture f("tensorFromWeightedSet(attribute(astr))");
+    EXPECT_EQ(*make_empty("tensor(astr{})"), f.execute());
 }
 
-TEST_F("require that empty tensor is created if query parameter is not found",
-        ExecFixture("tensorFromWeightedSet(query(null))"))
+TEST(TensorFromWeightedSetTest, require_that_empty_tensor_is_created_if_query_parameter_is_not_found)
 {
-    EXPECT_EQUAL(*make_empty("tensor(null{})"), f.execute());
+    ExecFixture f("tensorFromWeightedSet(query(null))");
+    EXPECT_EQ(*make_empty("tensor(null{})"), f.execute());
 }
 
-TEST_MAIN() { TEST_RUN_ALL(); }
+GTEST_MAIN_RUN_ALL_TESTS()