diff options
Diffstat (limited to 'searchlib')
7 files changed, 455 insertions, 298 deletions
diff --git a/searchlib/src/tests/features/element_completeness/element_completeness_test.cpp b/searchlib/src/tests/features/element_completeness/element_completeness_test.cpp index ff210035502..4118b395d2b 100644 --- a/searchlib/src/tests/features/element_completeness/element_completeness_test.cpp +++ b/searchlib/src/tests/features/element_completeness/element_completeness_test.cpp @@ -1,12 +1,13 @@ // 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/searchlib/features/setup.h> #include <vespa/searchlib/fef/test/indexenvironment.h> #include <vespa/searchlib/fef/test/indexenvironmentbuilder.h> #include <vespa/searchlib/fef/test/queryenvironment.h> #include <vespa/searchlib/features/element_completeness_feature.h> #include <vespa/searchlib/fef/test/dummy_dependency_handler.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> #include <vespa/vespalib/util/stringfmt.h> using namespace search::fef; @@ -56,8 +57,8 @@ struct FeatureDumpFixture : public IDumpFeatureVisitor { std::vector<vespalib::string> expect; size_t dumped; virtual void visitDumpFeature(const vespalib::string &name) override { - EXPECT_LESS(dumped, expect.size()); - EXPECT_EQUAL(expect[dumped++], name); + EXPECT_LT(dumped, expect.size()); + EXPECT_EQ(expect[dumped++], name); } FeatureDumpFixture() : IDumpFeatureVisitor(), expect(featureNamesFoo()), dumped(0) {} }; @@ -69,6 +70,7 @@ struct RankFixture : BlueprintFactoryFixture { feature_t field, feature_t query, int32_t weight = 1, feature_t factor = 0.5, bool useStaleMatchData = false) { + SCOPED_TRACE(queryStr); std::vector<vespalib::string> names = featureNamesFoo(); ASSERT_TRUE(names.size() == 4u); RankResult expect; @@ -80,123 +82,194 @@ struct RankFixture : BlueprintFactoryFixture { ft.getIndexEnv().getBuilder().addField(FieldType::INDEX, CollectionType::WEIGHTEDSET, "foo"); ft.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::WEIGHTEDSET, "bar"); ft.getIndexEnv().getBuilder().addField(FieldType::INDEX, CollectionType::WEIGHTEDSET, "baz"); - FtTestApp::FT_SETUP(ft, FtUtil::toQuery(queryStr), index, 1); + FtTestAppBase::FT_SETUP(ft, FtUtil::toQuery(queryStr), index, 1); RankResult actual; EXPECT_TRUE(ft.executeOnly(actual, useStaleMatchData ? 2 : 1)); for (size_t i = 0; i < names.size(); ++i) { - TEST_STATE(names[i].c_str()); - EXPECT_EQUAL(expect.getScore(names[i]), actual.getScore(names[i])); + SCOPED_TRACE(names[i].c_str()); + EXPECT_EQ(expect.getScore(names[i]), actual.getScore(names[i])); } } }; -TEST_F("require that blueprint can be created from factory", BlueprintFactoryFixture) { +TEST(ElementCompletenessTest, require_that_blueprint_can_be_created_from_factory) +{ + BlueprintFactoryFixture f; Blueprint::SP bp = f.factory.createBlueprint("elementCompleteness"); EXPECT_TRUE(bp.get() != 0); EXPECT_TRUE(dynamic_cast<ElementCompletenessBlueprint*>(bp.get()) != 0); } -TEST_FFF("require that appropriate features are dumped", ElementCompletenessBlueprint, IndexFixture, FeatureDumpFixture) { +TEST(ElementCompletenessTest, require_that_appropriate_features_are_dumped) +{ + ElementCompletenessBlueprint f1; + IndexFixture f2; + FeatureDumpFixture f3; f1.visitDumpFeatures(f2.indexEnv, f3); - EXPECT_EQUAL(f3.expect.size(), f3.dumped); + EXPECT_EQ(f3.expect.size(), f3.dumped); } -TEST_FF("require that setup can be done on index field", ElementCompletenessBlueprint, IndexFixture) { +TEST(ElementCompletenessTest, require_that_setup_can_be_done_on_index_field) +{ + ElementCompletenessBlueprint f1; + IndexFixture f2; DummyDependencyHandler deps(f1); f1.setName(vespalib::make_string("%s(foo)", f1.getBaseName().c_str())); EXPECT_TRUE(((Blueprint&)f1).setup(f2.indexEnv, std::vector<vespalib::string>(1, "foo"))); } -TEST_FF("require that setup can not be done on attribute field", ElementCompletenessBlueprint, IndexFixture) { +TEST(ElementCompletenessTest, require_that_setup_can_not_be_done_on_attribute_field) +{ + ElementCompletenessBlueprint f1; + IndexFixture f2; DummyDependencyHandler deps(f1); f1.setName(vespalib::make_string("%s(bar)", f1.getBaseName().c_str())); EXPECT_TRUE(!((Blueprint&)f1).setup(f2.indexEnv, std::vector<vespalib::string>(1, "bar"))); } -TEST_FF("require that default config parameters are correct", ElementCompletenessBlueprint, IndexFixture) { +TEST(ElementCompletenessTest, require_that_default_config_parameters_are_correct) +{ + ElementCompletenessBlueprint f1; + IndexFixture f2; DummyDependencyHandler deps(f1); f1.setName(vespalib::make_string("%s(foo)", f1.getBaseName().c_str())); EXPECT_TRUE(((Blueprint&)f1).setup(f2.indexEnv, std::vector<vespalib::string>(1, "foo"))); - EXPECT_EQUAL(0u, f1.getParams().fieldId); - EXPECT_EQUAL(0.5, f1.getParams().fieldCompletenessImportance); + EXPECT_EQ(0u, f1.getParams().fieldId); + EXPECT_EQ(0.5, f1.getParams().fieldCompletenessImportance); } -TEST_FF("require that blueprint can be configured", ElementCompletenessBlueprint, IndexFixture) { +TEST(ElementCompletenessTest, require_that_blueprint_can_be_configured){ + ElementCompletenessBlueprint f1; + IndexFixture f2; DummyDependencyHandler deps(f1); f1.setName(vespalib::make_string("%s(foo)", f1.getBaseName().c_str())); f2.indexEnv.getProperties().add("elementCompleteness(foo).fieldCompletenessImportance", "0.75"); EXPECT_TRUE(((Blueprint&)f1).setup(f2.indexEnv, std::vector<vespalib::string>(1, "foo"))); - EXPECT_EQUAL(0.75, f1.getParams().fieldCompletenessImportance); + EXPECT_EQ(0.75, f1.getParams().fieldCompletenessImportance); } -TEST_F("require that no match gives zero outputs", RankFixture) { - TEST_DO(f.test("x", indexFoo().element("y"), 0.0, 0.0, 0)); +TEST(ElementCompletenessTest, require_that_no_match_gives_zero_outputs) +{ + RankFixture f; + f.test("x", indexFoo().element("y"), 0.0, 0.0, 0); } -TEST_F("require that perfect match gives max outputs", RankFixture) { - TEST_DO(f.test("x", indexFoo().element("x"), 1.0, 1.0)); +TEST(ElementCompletenessTest, require_that_perfect_match_gives_max_outputs) +{ + RankFixture f; + f.test("x", indexFoo().element("x"), 1.0, 1.0); } -TEST_F("require that matching half the field gives appropriate outputs", RankFixture) { - TEST_DO(f.test("x", indexFoo().element("x y"), 0.5, 1.0)); - TEST_DO(f.test("x y", indexFoo().element("x y a b"), 0.5, 1.0)); +TEST(ElementCompletenessTest, require_that_matching_half_the_field_gives_appropriate_outputs) +{ + RankFixture f; + f.test("x", indexFoo().element("x y"), 0.5, 1.0); + f.test("x y", indexFoo().element("x y a b"), 0.5, 1.0); } -TEST_F("require that matching half the query gives appropriate outputs", RankFixture) { - TEST_DO(f.test("x y", indexFoo().element("x"), 1.0, 0.5)); - TEST_DO(f.test("x y a b", indexFoo().element("x y"), 1.0, 0.5)); +TEST(ElementCompletenessTest, require_that_matching_half_the_query_gives_appropriate_outputs) +{ + RankFixture f; + f.test("x y", indexFoo().element("x"), 1.0, 0.5); + f.test("x y a b", indexFoo().element("x y"), 1.0, 0.5); } -TEST_F("require that query completeness is affected by query term weight", RankFixture) { - TEST_DO(f.test("x!300 y!100", indexFoo().element("y"), 1.0, 0.25)); - TEST_DO(f.test("x!300 y!100", indexFoo().element("x"), 1.0, 0.75)); +TEST(ElementCompletenessTest, require_that_query_completeness_is_affected_by_query_term_weight) +{ + RankFixture f; + f.test("x!300 y!100", indexFoo().element("y"), 1.0, 0.25); + f.test("x!300 y!100", indexFoo().element("x"), 1.0, 0.75); } -TEST_F("require that field completeness is not affected by duplicate field tokens", RankFixture) { - TEST_DO(f.test("x", indexFoo().element("x y y y"), 0.25, 1.00)); - TEST_DO(f.test("x", indexFoo().element("x x y y"), 0.25, 1.00)); - TEST_DO(f.test("x", indexFoo().element("x x x y"), 0.25, 1.00)); - TEST_DO(f.test("x", indexFoo().element("x x x x"), 0.25, 1.00)); +TEST(ElementCompletenessTest, require_that_field_completeness_is_not_affected_by_duplicate_field_tokens) +{ + RankFixture f; + { + SCOPED_TRACE("x y y y"); + f.test("x", indexFoo().element("x y y y"), 0.25, 1.00); + } + { + SCOPED_TRACE("x x y y"); + f.test("x", indexFoo().element("x x y y"), 0.25, 1.00); + } + { + SCOPED_TRACE("x x x y"); + f.test("x", indexFoo().element("x x x y"), 0.25, 1.00); + } + { + SCOPED_TRACE("x x x x"); + f.test("x", indexFoo().element("x x x x"), 0.25, 1.00); + } } -TEST_F("require that field completeness is affected by duplicate query terms", RankFixture) { - TEST_DO(f.test("x", indexFoo().element("x x x x"), 0.25, 1.00)); - TEST_DO(f.test("x x", indexFoo().element("x x x x"), 0.50, 1.00)); - TEST_DO(f.test("x x x", indexFoo().element("x x x x"), 0.75, 1.00)); - TEST_DO(f.test("x x x x", indexFoo().element("x x x x"), 1.00, 1.00)); +TEST(ElementCompletenessTest, require_that_field_completeness_is_affected_by_duplicate_query_terms) +{ + RankFixture f; + f.test("x", indexFoo().element("x x x x"), 0.25, 1.00); + f.test("x x", indexFoo().element("x x x x"), 0.50, 1.00); + f.test("x x x", indexFoo().element("x x x x"), 0.75, 1.00); + f.test("x x x x", indexFoo().element("x x x x"), 1.00, 1.00); } -TEST_F("require that a single field token can match multiple query terms", RankFixture) { - TEST_DO(f.test("x", indexFoo().element("x"), 1.00, 1.00)); - TEST_DO(f.test("x x", indexFoo().element("x"), 1.00, 1.00)); - TEST_DO(f.test("x x x", indexFoo().element("x"), 1.00, 1.00)); - TEST_DO(f.test("x x x x", indexFoo().element("x"), 1.00, 1.00)); +TEST(ElementCompletenessTest, require_that_a_single_field_token_can_match_multiple_query_terms) +{ + RankFixture f; + f.test("x", indexFoo().element("x"), 1.00, 1.00); + f.test("x x", indexFoo().element("x"), 1.00, 1.00); + f.test("x x x", indexFoo().element("x"), 1.00, 1.00); + f.test("x x x x", indexFoo().element("x"), 1.00, 1.00); } -TEST_F("require that field completeness importance can be adjusted", RankFixture) { +TEST(ElementCompletenessTest, require_that_field_completeness_importance_can_be_adjusted) +{ + RankFixture f; f.idxProps.clear().add("elementCompleteness(foo).fieldCompletenessImportance", "0.1"); - TEST_DO(f.test("x y", indexFoo().element("x"), 1.0, 0.5, 1, 0.1)); + { + SCOPED_TRACE("0.1"); + f.test("x y", indexFoo().element("x"), 1.0, 0.5, 1, 0.1); + } f.idxProps.clear().add("elementCompleteness(foo).fieldCompletenessImportance", "0.4"); - TEST_DO(f.test("x y", indexFoo().element("x"), 1.0, 0.5, 1, 0.4)); + { + SCOPED_TRACE("0.4"); + f.test("x y", indexFoo().element("x"), 1.0, 0.5, 1, 0.4); + } f.idxProps.clear().add("elementCompleteness(foo).fieldCompletenessImportance", "0.7"); - TEST_DO(f.test("x y", indexFoo().element("x"), 1.0, 0.5, 1, 0.7)); + { + SCOPED_TRACE("0.7"); + f.test("x y", indexFoo().element("x"), 1.0, 0.5, 1, 0.7); + } } -TEST_F("require that order is not relevant", RankFixture) { - TEST_DO(f.test("x y a b", indexFoo().element("n x n y"), 0.5, 0.5)); - TEST_DO(f.test("a b x y", indexFoo().element("y x n n"), 0.5, 0.5)); - TEST_DO(f.test("a y x b", indexFoo().element("x n y n"), 0.5, 0.5)); +TEST(ElementCompletenessTest, require_that_order_is_not_relevant) +{ + RankFixture f; + f.test("x y a b", indexFoo().element("n x n y"), 0.5, 0.5); + f.test("a b x y", indexFoo().element("y x n n"), 0.5, 0.5); + f.test("a y x b", indexFoo().element("x n y n"), 0.5, 0.5); } -TEST_F("require that element is selected based on completeness times element weight", RankFixture) { +TEST(ElementCompletenessTest, require_that_element_is_selected_based_on_completeness_times_element_weight) +{ + RankFixture f; f.idxProps.clear().add("elementCompleteness(foo).fieldCompletenessImportance", "0.0"); - TEST_DO(f.test("x y a b", indexFoo().element("x", 39).element("y", 39).element("a b", 19).element("x y a b", 10), 1.0, 1.0, 10, 0.0)); - TEST_DO(f.test("x y a b", indexFoo().element("x", 39).element("y", 39).element("a b", 21).element("x y a b", 10), 1.0, 0.5, 21, 0.0)); - TEST_DO(f.test("x y a b", indexFoo().element("x", 39).element("y", 45).element("a b", 21).element("x y a b", 10), 1.0, 0.25, 45, 0.0)); + { + SCOPED_TRACE("10"); + f.test("x y a b", indexFoo().element("x", 39).element("y", 39).element("a b", 19).element("x y a b", 10), 1.0, 1.0, 10, 0.0); + } + { + SCOPED_TRACE("21"); + f.test("x y a b", indexFoo().element("x", 39).element("y", 39).element("a b", 21).element("x y a b", 10), 1.0, 0.5, 21, 0.0); + } + { + SCOPED_TRACE("45"); + f.test("x y a b", indexFoo().element("x", 39).element("y", 45).element("a b", 21).element("x y a b", 10), 1.0, 0.25, 45, 0.0); + } } -TEST_F("require that stale match data is ignored", RankFixture) { - TEST_DO(f.test("x y a b", indexFoo().element("x y"), 0.0, 0.0, 0, 0.5, true)); +TEST(ElementCompletenessTest, require_that_stale_match_data_is_ignored) +{ + RankFixture f; + f.test("x y a b", indexFoo().element("x y"), 0.0, 0.0, 0, 0.5, true); } -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/features/element_similarity_feature/element_similarity_feature_test.cpp b/searchlib/src/tests/features/element_similarity_feature/element_similarity_feature_test.cpp index 1eda660d2ec..6d6830ea7df 100644 --- a/searchlib/src/tests/features/element_similarity_feature/element_similarity_feature_test.cpp +++ b/searchlib/src/tests/features/element_similarity_feature/element_similarity_feature_test.cpp @@ -1,13 +1,14 @@ // 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/searchlib/features/setup.h> #include <vespa/searchlib/fef/test/indexenvironment.h> #include <vespa/searchlib/fef/test/indexenvironmentbuilder.h> #include <vespa/searchlib/fef/test/queryenvironment.h> #include <vespa/searchlib/features/element_similarity_feature.h> -#include <vespa/searchlib/test/ft_test_app.h> +#define ENABLE_GTEST_MIGRATION +#include <vespa/searchlib/test/ft_test_app_base.h> #include <initializer_list> #include <vespa/searchlib/fef/test/dummy_dependency_handler.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/vespalib/util/stringfmt.h> using namespace search::fef; @@ -87,11 +88,11 @@ struct RankFixture : BlueprintFactoryFixture { FtFeatureTest ft(factory, names); ft.getIndexEnv().getBuilder().addField(FieldType::INDEX, CollectionType::WEIGHTEDSET, "foo"); ft.getIndexEnv().getBuilder().getIndexEnv().getProperties().import(idx_env.indexEnv.getProperties()); - FtTestApp::FT_SETUP(ft, FtUtil::toQuery(query), index, 1); + FtTestAppBase::FT_SETUP(ft, FtUtil::toQuery(query), index, 1); { RankResult stale; EXPECT_TRUE(ft.executeOnly(stale, 2)); - EXPECT_EQUAL(0.0, stale.getScore(select)); + EXPECT_EQ(0.0, stale.getScore(select)); } RankResult actual; EXPECT_TRUE(ft.executeOnly(actual, 1)); @@ -129,11 +130,14 @@ bool cmp_lists_impl(const A &a, const B &b) { std::vector<typename B::value_type> tmp_b(b.begin(), b.end()); std::sort(tmp_a.begin(), tmp_a.end()); std::sort(tmp_b.begin(), tmp_b.end()); - if (!EXPECT_EQUAL(tmp_a.size(), tmp_b.size())) { + bool failed = false; + EXPECT_EQ(tmp_a.size(), tmp_b.size()) << (failed = true, ""); + if (failed) { return false; } for (size_t i = 0; i < tmp_a.size(); ++i) { - if(!EXPECT_EQUAL(tmp_a[i], tmp_b[i])) { + EXPECT_EQ(tmp_a[i], tmp_b[i]) << (failed = true, ""); + if (failed) { return false; } } @@ -162,13 +166,19 @@ bool cmp_lists(const A &a, const B &b) { //----------------------------------------------------------------------------- -TEST_F("require that blueprint can be created from factory", BlueprintFactoryFixture) { +TEST(ElementSimilarityFeatureTest, require_that_blueprint_can_be_created_from_factory) +{ + BlueprintFactoryFixture f; Blueprint::SP bp = f.factory.createBlueprint("elementSimilarity"); EXPECT_TRUE(bp.get() != 0); EXPECT_TRUE(dynamic_cast<ElementSimilarityBlueprint*>(bp.get()) != 0); } -TEST_FFF("require that appropriate features are dumped", ElementSimilarityBlueprint, IndexFixture, FeatureDumpFixture) { +TEST(ElementSimilarityFeatureTest, require_that_appropriate_features_are_dumped) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; + FeatureDumpFixture f3; f1.visitDumpFeatures(f2.indexEnv, f3); EXPECT_TRUE(cmp_lists(std::vector<vespalib::string>({"elementSimilarity(foo)", "elementSimilarity(foo).proximity", @@ -186,190 +196,252 @@ bool try_setup(ElementSimilarityBlueprint &blueprint, const IndexFixture &index, return ((Blueprint&)blueprint).setup(index.indexEnv, std::vector<vespalib::string>(1, field)); } -TEST_FF("require that setup can be done on weighted set index field", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_can_be_done_on_weighted_set_index_field) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; EXPECT_TRUE(try_setup(f1, f2, "foo")); } -TEST_FF("require that setup can be done on array index field", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_can_be_done_on_array_index_field) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; EXPECT_TRUE(try_setup(f1, f2, "bar")); } -TEST_FF("require that setup can be done on single value index field", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_can_be_done_on_single_value_index_field) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; EXPECT_TRUE(try_setup(f1, f2, "baz")); } -TEST_FF("require that setup can not be done on single value attribute field", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_can_not_be_done_on_single_value_attribute_field) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; EXPECT_FALSE(try_setup(f1, f2, "fox")); } -TEST_FF("require that setup will fail if output expression does not contain an aggregator", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_will_fail_if_output_expression_does_not_contain_an_aggregator) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "p"); EXPECT_FALSE(try_setup(f1, f2, "foo")); } -TEST_FF("require that setup will fail if output expression contains an unknown aggregator", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_will_fail_if_output_expression_contains_an_unknown_aggregator) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "bogus(p)"); EXPECT_FALSE(try_setup(f1, f2, "foo")); } -TEST_FF("require that setup will fail if output expression contains an unknown symbol", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_will_fail_if_output_expression_contains_an_unknown_symbol) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "max(bogus)"); EXPECT_FALSE(try_setup(f1, f2, "foo")); } -TEST_FF("require that setup will fail if output expression is malformed", ElementSimilarityBlueprint, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_setup_will_fail_if_output_expression_is_malformed) +{ + ElementSimilarityBlueprint f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "max(w+)"); EXPECT_FALSE(try_setup(f1, f2, "foo")); } -TEST_F("require that no match gives zero outputs", RankFixture) { - EXPECT_EQUAL(0.0, f1.get_feature("x", indexFoo().element("y"), DEFAULT)); - EXPECT_EQUAL(0.0, f1.get_feature("x", indexFoo().element("y"), PROXIMITY)); - EXPECT_EQUAL(0.0, f1.get_feature("x", indexFoo().element("y"), ORDER)); - EXPECT_EQUAL(0.0, f1.get_feature("x", indexFoo().element("y"), QUERY)); - EXPECT_EQUAL(0.0, f1.get_feature("x", indexFoo().element("y"), FIELD)); -} - -TEST_F("require that minal perfect match gives max outputs", RankFixture) { - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x"), DEFAULT)); - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x"), PROXIMITY)); - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x"), ORDER)); - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x"), QUERY)); - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x"), FIELD)); -} - -TEST_F("require that larger perfect match gives max outputs", RankFixture) { - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), DEFAULT)); - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), PROXIMITY)); - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), ORDER)); - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), QUERY)); - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), FIELD)); -} - -TEST_F("require that extra query terms reduces order but not proximity", RankFixture) { - EXPECT_EQUAL(1.0, f1.get_feature("x y", indexFoo().element("x"), PROXIMITY)); - EXPECT_EQUAL(1.0, f1.get_feature("x y y", indexFoo().element("x"), PROXIMITY)); - EXPECT_EQUAL(1.0, f1.get_feature("x y y y", indexFoo().element("x"), PROXIMITY)); - - EXPECT_EQUAL(0.0, f1.get_feature("x y", indexFoo().element("x"), ORDER)); - EXPECT_EQUAL(0.0, f1.get_feature("x y y", indexFoo().element("x"), ORDER)); - EXPECT_EQUAL(0.0, f1.get_feature("x y y y", indexFoo().element("x"), ORDER)); -} - -TEST_F("require that extra field terms reduces proximity but not order", RankFixture) { - EXPECT_EQUAL(prox(2), f1.get_feature("x", indexFoo().element("x y"), PROXIMITY)); - EXPECT_EQUAL(prox(3), f1.get_feature("x", indexFoo().element("x y y"), PROXIMITY)); - EXPECT_EQUAL(prox(4), f1.get_feature("x", indexFoo().element("x y y y"), PROXIMITY)); - - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x y"), ORDER)); - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x y y"), ORDER)); - EXPECT_EQUAL(1.0, f1.get_feature("x", indexFoo().element("x y y y"), ORDER)); -} - -TEST_F("require that proximity acts as expected", RankFixture) { - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(2), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("a x b c d e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(3), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("a x x b c d e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(4), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("a x x x b c d e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(2), prox(2), prox(2), prox(2)}), f1.get_feature("a b c d e", indexFoo().element("a x b x c x d x e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(2), prox(2), prox(1), prox(3)}), f1.get_feature("a b c d e", indexFoo().element("a x b x c d x x e"), PROXIMITY)); -} - -TEST_F("require that field order does not affect proximity score", RankFixture) { - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e", indexFoo().element("d c a b e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(2), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("d x c a b e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(3), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("d x x c a b e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(4), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("d x x x c a b e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(2), prox(2), prox(2), prox(2)}), f1.get_feature("a b c d e", indexFoo().element("d x c x a x b x e"), PROXIMITY)); - EXPECT_EQUAL(comb({prox(2), prox(2), prox(1), prox(3)}), f1.get_feature("a b c d e", indexFoo().element("d x c x a b x x e"), PROXIMITY)); -} - -TEST_F("require that order score acts as expected", RankFixture) { - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), ORDER)); - EXPECT_EQUAL(comb({1.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("a b c e d"), ORDER)); - EXPECT_EQUAL(comb({0.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b a c e d"), ORDER)); - EXPECT_EQUAL(comb({0.0, 1.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b a e d c"), ORDER)); - EXPECT_EQUAL(comb({0.0, 0.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("e d c b a"), ORDER)); -} - -TEST_F("require that proximity does not affect order score", RankFixture) { - EXPECT_EQUAL(1.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), ORDER)); - EXPECT_EQUAL(comb({1.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("a x b x c x e x d"), ORDER)); - EXPECT_EQUAL(comb({0.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b x a x c x e x d"), ORDER)); - EXPECT_EQUAL(comb({0.0, 1.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b x a x e x d x c"), ORDER)); - EXPECT_EQUAL(comb({0.0, 0.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("e x d x c x b x a"), ORDER)); -} - -TEST_F("require that query coverage acts as expected", RankFixture) { - EXPECT_EQUAL(5.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), QUERY)); - EXPECT_EQUAL(4.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c d"), QUERY)); - EXPECT_EQUAL(3.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c"), QUERY)); - EXPECT_EQUAL(2.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b"), QUERY)); - EXPECT_EQUAL(4.0/7.0, f1.get_feature("a!200 b!200 c d e", indexFoo().element("a b"), QUERY)); - EXPECT_EQUAL(2.0/7.0, f1.get_feature("a b c!500", indexFoo().element("a b"), QUERY)); - EXPECT_EQUAL(5.0/7.0, f1.get_feature("a b c!500", indexFoo().element("c"), QUERY)); -} - -TEST_F("require that field coverage acts as expected", RankFixture) { - EXPECT_EQUAL(5.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), FIELD)); - EXPECT_EQUAL(4.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a x c d e"), FIELD)); - EXPECT_EQUAL(3.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b x x e"), FIELD)); - EXPECT_EQUAL(2.0/5.0, f1.get_feature("a b c d e", indexFoo().element("x x x d e"), FIELD)); -} - -TEST_F("require that first unique match is used per query term", RankFixture) { - EXPECT_EQUAL(prox(3), f1.get_feature("a b", indexFoo().element("a a a b"), PROXIMITY)); - EXPECT_EQUAL(1.0, f1.get_feature("a b", indexFoo().element("a a a b"), ORDER)); - EXPECT_EQUAL(1.0, f1.get_feature("a b", indexFoo().element("a a a b"), QUERY)); - EXPECT_EQUAL(2.0/4.0, f1.get_feature("a b", indexFoo().element("a a a b"), FIELD)); - - EXPECT_EQUAL(comb({prox(1), prox(2)}), f1.get_feature("a b a", indexFoo().element("a a a b"), PROXIMITY)); - EXPECT_EQUAL(0.5, f1.get_feature("a b a", indexFoo().element("a a a b"), ORDER)); - EXPECT_EQUAL(1.0, f1.get_feature("a b a", indexFoo().element("a a a b"), QUERY)); - EXPECT_EQUAL(3.0/4.0, f1.get_feature("a b a", indexFoo().element("a a a b"), FIELD)); -} - -TEST_F("require that default score combines individual signals appropriately", RankFixture) { - EXPECT_EQUAL(comb({prox(1), prox(3), prox(2)}), f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), PROXIMITY)); - EXPECT_EQUAL(comb({1.0, 0.0, 1.0}), f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), ORDER)); - EXPECT_EQUAL(4.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), QUERY)); - EXPECT_EQUAL(4.0/7.0, f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), FIELD)); - EXPECT_EQUAL(mix(comb({prox(1), prox(3), prox(2)}), comb({1.0, 0.0, 1.0}), 4.0/5.0, 4.0/7.0), +TEST(ElementSimilarityFeatureTest, require_that_no_match_gives_zero_outputs) +{ + RankFixture f1; + EXPECT_EQ(0.0, f1.get_feature("x", indexFoo().element("y"), DEFAULT)); + EXPECT_EQ(0.0, f1.get_feature("x", indexFoo().element("y"), PROXIMITY)); + EXPECT_EQ(0.0, f1.get_feature("x", indexFoo().element("y"), ORDER)); + EXPECT_EQ(0.0, f1.get_feature("x", indexFoo().element("y"), QUERY)); + EXPECT_EQ(0.0, f1.get_feature("x", indexFoo().element("y"), FIELD)); +} + +TEST(ElementSimilarityFeatureTest, require_that_minal_perfect_match_gives_max_outputs) +{ + RankFixture f1; + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x"), DEFAULT)); + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x"), PROXIMITY)); + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x"), ORDER)); + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x"), QUERY)); + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x"), FIELD)); +} + +TEST(ElementSimilarityFeatureTest, require_that_larger_perfect_match_gives_max_outputs) +{ + RankFixture f1; + EXPECT_EQ(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), DEFAULT)); + EXPECT_EQ(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), PROXIMITY)); + EXPECT_EQ(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), ORDER)); + EXPECT_EQ(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), QUERY)); + EXPECT_EQ(1.0, f1.get_feature("a b c d e f g", indexFoo().element("a b c d e f g"), FIELD)); +} + +TEST(ElementSimilarityFeatureTest, require_that_extra_query_terms_reduces_order_but_not_proximity) +{ + RankFixture f1; + EXPECT_EQ(1.0, f1.get_feature("x y", indexFoo().element("x"), PROXIMITY)); + EXPECT_EQ(1.0, f1.get_feature("x y y", indexFoo().element("x"), PROXIMITY)); + EXPECT_EQ(1.0, f1.get_feature("x y y y", indexFoo().element("x"), PROXIMITY)); + + EXPECT_EQ(0.0, f1.get_feature("x y", indexFoo().element("x"), ORDER)); + EXPECT_EQ(0.0, f1.get_feature("x y y", indexFoo().element("x"), ORDER)); + EXPECT_EQ(0.0, f1.get_feature("x y y y", indexFoo().element("x"), ORDER)); +} + +TEST(ElementSimilarityFeatureTest, require_that_extra_field_terms_reduces_proximity_but_not_order) +{ + RankFixture f1; + EXPECT_EQ(prox(2), f1.get_feature("x", indexFoo().element("x y"), PROXIMITY)); + EXPECT_EQ(prox(3), f1.get_feature("x", indexFoo().element("x y y"), PROXIMITY)); + EXPECT_EQ(prox(4), f1.get_feature("x", indexFoo().element("x y y y"), PROXIMITY)); + + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x y"), ORDER)); + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x y y"), ORDER)); + EXPECT_EQ(1.0, f1.get_feature("x", indexFoo().element("x y y y"), ORDER)); +} + +TEST(ElementSimilarityFeatureTest, require_that_proximity_acts_as_expected) +{ + RankFixture f1; + EXPECT_EQ(1.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), PROXIMITY)); + EXPECT_EQ(comb({prox(2), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("a x b c d e"), PROXIMITY)); + EXPECT_EQ(comb({prox(3), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("a x x b c d e"), PROXIMITY)); + EXPECT_EQ(comb({prox(4), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("a x x x b c d e"), PROXIMITY)); + EXPECT_EQ(comb({prox(2), prox(2), prox(2), prox(2)}), f1.get_feature("a b c d e", indexFoo().element("a x b x c x d x e"), PROXIMITY)); + EXPECT_EQ(comb({prox(2), prox(2), prox(1), prox(3)}), f1.get_feature("a b c d e", indexFoo().element("a x b x c d x x e"), PROXIMITY)); +} + +TEST(ElementSimilarityFeatureTest, require_that_field_order_does_not_affect_proximity_score) +{ + RankFixture f1; + EXPECT_EQ(1.0, f1.get_feature("a b c d e", indexFoo().element("d c a b e"), PROXIMITY)); + EXPECT_EQ(comb({prox(2), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("d x c a b e"), PROXIMITY)); + EXPECT_EQ(comb({prox(3), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("d x x c a b e"), PROXIMITY)); + EXPECT_EQ(comb({prox(4), prox(1), prox(1), prox(1)}), f1.get_feature("a b c d e", indexFoo().element("d x x x c a b e"), PROXIMITY)); + EXPECT_EQ(comb({prox(2), prox(2), prox(2), prox(2)}), f1.get_feature("a b c d e", indexFoo().element("d x c x a x b x e"), PROXIMITY)); + EXPECT_EQ(comb({prox(2), prox(2), prox(1), prox(3)}), f1.get_feature("a b c d e", indexFoo().element("d x c x a b x x e"), PROXIMITY)); +} + +TEST(ElementSimilarityFeatureTest, require_that_order_score_acts_as_expected) +{ + RankFixture f1; + EXPECT_EQ(1.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), ORDER)); + EXPECT_EQ(comb({1.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("a b c e d"), ORDER)); + EXPECT_EQ(comb({0.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b a c e d"), ORDER)); + EXPECT_EQ(comb({0.0, 1.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b a e d c"), ORDER)); + EXPECT_EQ(comb({0.0, 0.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("e d c b a"), ORDER)); +} + +TEST(ElementSimilarityFeatureTest, require_that_proximity_does_not_affect_order_score) +{ + RankFixture f1; + EXPECT_EQ(1.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), ORDER)); + EXPECT_EQ(comb({1.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("a x b x c x e x d"), ORDER)); + EXPECT_EQ(comb({0.0, 1.0, 1.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b x a x c x e x d"), ORDER)); + EXPECT_EQ(comb({0.0, 1.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("b x a x e x d x c"), ORDER)); + EXPECT_EQ(comb({0.0, 0.0, 0.0, 0.0}), f1.get_feature("a b c d e", indexFoo().element("e x d x c x b x a"), ORDER)); +} + +TEST(ElementSimilarityFeatureTest, require_that_query_coverage_acts_as_expected) +{ + RankFixture f1; + EXPECT_EQ(5.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), QUERY)); + EXPECT_EQ(4.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c d"), QUERY)); + EXPECT_EQ(3.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c"), QUERY)); + EXPECT_EQ(2.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b"), QUERY)); + EXPECT_EQ(4.0/7.0, f1.get_feature("a!200 b!200 c d e", indexFoo().element("a b"), QUERY)); + EXPECT_EQ(2.0/7.0, f1.get_feature("a b c!500", indexFoo().element("a b"), QUERY)); + EXPECT_EQ(5.0/7.0, f1.get_feature("a b c!500", indexFoo().element("c"), QUERY)); +} + +TEST(ElementSimilarityFeatureTest, require_that_field_coverage_acts_as_expected) +{ + RankFixture f1; + EXPECT_EQ(5.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b c d e"), FIELD)); + EXPECT_EQ(4.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a x c d e"), FIELD)); + EXPECT_EQ(3.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a b x x e"), FIELD)); + EXPECT_EQ(2.0/5.0, f1.get_feature("a b c d e", indexFoo().element("x x x d e"), FIELD)); +} + +TEST(ElementSimilarityFeatureTest, require_that_first_unique_match_is_used_per_query_term) +{ + RankFixture f1; + EXPECT_EQ(prox(3), f1.get_feature("a b", indexFoo().element("a a a b"), PROXIMITY)); + EXPECT_EQ(1.0, f1.get_feature("a b", indexFoo().element("a a a b"), ORDER)); + EXPECT_EQ(1.0, f1.get_feature("a b", indexFoo().element("a a a b"), QUERY)); + EXPECT_EQ(2.0/4.0, f1.get_feature("a b", indexFoo().element("a a a b"), FIELD)); + + EXPECT_EQ(comb({prox(1), prox(2)}), f1.get_feature("a b a", indexFoo().element("a a a b"), PROXIMITY)); + EXPECT_EQ(0.5, f1.get_feature("a b a", indexFoo().element("a a a b"), ORDER)); + EXPECT_EQ(1.0, f1.get_feature("a b a", indexFoo().element("a a a b"), QUERY)); + EXPECT_EQ(3.0/4.0, f1.get_feature("a b a", indexFoo().element("a a a b"), FIELD)); +} + +TEST(ElementSimilarityFeatureTest, require_that_default_score_combines_individual_signals_appropriately) +{ + RankFixture f1; + EXPECT_EQ(comb({prox(1), prox(3), prox(2)}), f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), PROXIMITY)); + EXPECT_EQ(comb({1.0, 0.0, 1.0}), f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), ORDER)); + EXPECT_EQ(4.0/5.0, f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), QUERY)); + EXPECT_EQ(4.0/7.0, f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), FIELD)); + EXPECT_EQ(mix(comb({prox(1), prox(3), prox(2)}), comb({1.0, 0.0, 1.0}), 4.0/5.0, 4.0/7.0), f1.get_feature("a b c d e", indexFoo().element("a c x x b x d"), DEFAULT)); - EXPECT_EQUAL(7.0 * mix(comb({prox(1), prox(3), prox(2)}), comb({1.0, 0.0, 1.0}), 4.0/5.0, 4.0/7.0), + EXPECT_EQ(7.0 * mix(comb({prox(1), prox(3), prox(2)}), comb({1.0, 0.0, 1.0}), 4.0/5.0, 4.0/7.0), f1.get_feature("a b c d e", indexFoo().element("a c x x b x d", 7), DEFAULT)); } -TEST_FF("require that max aggregation works", RankFixture, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_max_aggregation_works) +{ + RankFixture f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "max(w)"); - EXPECT_EQUAL(5.0, f1.get_feature("x", indexFoo().element("x y", 5), DEFAULT, f2)); - EXPECT_EQUAL(5.0, f1.get_feature("x", indexFoo().element("x y", 5).element("x y", 3), DEFAULT, f2)); - EXPECT_EQUAL(5.0, f1.get_feature("x", indexFoo().element("x y", 3).element("x y", 5), DEFAULT, f2)); + EXPECT_EQ(5.0, f1.get_feature("x", indexFoo().element("x y", 5), DEFAULT, f2)); + EXPECT_EQ(5.0, f1.get_feature("x", indexFoo().element("x y", 5).element("x y", 3), DEFAULT, f2)); + EXPECT_EQ(5.0, f1.get_feature("x", indexFoo().element("x y", 3).element("x y", 5), DEFAULT, f2)); } -TEST_FF("require that avg aggregation works", RankFixture, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_avg_aggregation_works) +{ + RankFixture f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "avg(w)"); - EXPECT_EQUAL(5.0, f1.get_feature("x", indexFoo().element("x y", 5), DEFAULT, f2)); - EXPECT_EQUAL(4.0, f1.get_feature("x", indexFoo().element("x y", 5).element("x y", 3), DEFAULT, f2)); - EXPECT_EQUAL(4.0, f1.get_feature("x", indexFoo().element("x y", 3).element("x y", 5), DEFAULT, f2)); + EXPECT_EQ(5.0, f1.get_feature("x", indexFoo().element("x y", 5), DEFAULT, f2)); + EXPECT_EQ(4.0, f1.get_feature("x", indexFoo().element("x y", 5).element("x y", 3), DEFAULT, f2)); + EXPECT_EQ(4.0, f1.get_feature("x", indexFoo().element("x y", 3).element("x y", 5), DEFAULT, f2)); } -TEST_FF("require that sum aggregation works", RankFixture, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_sum_aggregation_works) +{ + RankFixture f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "sum(w)"); - EXPECT_EQUAL(5.0, f1.get_feature("x", indexFoo().element("x y", 5), DEFAULT, f2)); - EXPECT_EQUAL(8.0, f1.get_feature("x", indexFoo().element("x y", 5).element("x y", 3), DEFAULT, f2)); - EXPECT_EQUAL(8.0, f1.get_feature("x", indexFoo().element("x y", 3).element("x y", 5), DEFAULT, f2)); + EXPECT_EQ(5.0, f1.get_feature("x", indexFoo().element("x y", 5), DEFAULT, f2)); + EXPECT_EQ(8.0, f1.get_feature("x", indexFoo().element("x y", 5).element("x y", 3), DEFAULT, f2)); + EXPECT_EQ(8.0, f1.get_feature("x", indexFoo().element("x y", 3).element("x y", 5), DEFAULT, f2)); } -TEST_FF("require that element demultiplexing works", RankFixture, IndexFixture) { +TEST(ElementSimilarityFeatureTest, require_that_element_demultiplexing_works) +{ + RankFixture f1; + IndexFixture f2; f2.set("elementSimilarity(foo).output.default", "sum(q)"); - EXPECT_EQUAL(sum({0.25, 0.5, 0.5, 0.25, 0.5}), - f1.get_feature("x y z t", indexFoo() - .element("x") - .element("x y") - .element("x z") - .element("y") - .element("x z"), DEFAULT, f2)); + EXPECT_EQ(sum({0.25, 0.5, 0.5, 0.25, 0.5}), + f1.get_feature("x y z t", indexFoo() + .element("x") + .element("x y") + .element("x z") + .element("y") + .element("x z"), DEFAULT, f2)); } -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp b/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp index 3bc61a77c55..e7523288e8f 100644 --- a/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp +++ b/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp @@ -10,7 +10,9 @@ #include <vespa/searchlib/fef/test/indexenvironment.h> #include <vespa/searchlib/features/euclidean_distance_feature.h> #include <vespa/searchlib/fef/fef.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; @@ -25,7 +27,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; using CollectionType = FieldInfo::CollectionType; struct SetupFixture @@ -41,13 +43,15 @@ struct SetupFixture } }; -TEST_F("require that blueprint can be created from factory", SetupFixture) +TEST(EuclideanDistanceTest, require_that_blueprint_can_be_created_from_factory) { + SetupFixture f; EXPECT_TRUE(FTA::assertCreateInstance(f.blueprint, "euclideanDistance")); } -TEST_F("require that setup succeeds with attribute source", SetupFixture) +TEST(EuclideanDistanceTest, require_that_setup_succeeds_with_attribute_source) { + SetupFixture f; FTA::FT_SETUP_OK(f.blueprint, f.indexEnv, StringList().add("myAttribute").add("myVector"), StringList(), StringList().add("distance")); } @@ -63,7 +67,7 @@ struct ExecFixture setup_search_features(factory); setupAttributeVectors(); setupQueryEnvironment(); - ASSERT_TRUE(test.setup()); + EXPECT_TRUE(test.setup()); } void setupAttributeVectors() { std::vector<AttributePtr> attrs; @@ -100,16 +104,16 @@ struct ExecFixture }; -TEST_F("require that distance is calculated for integer vectors", - ExecFixture("euclideanDistance(aint,intquery)")) +TEST(EuclideanDistanceTest, require_that_distance_is_calculated_for_integer_vectors) { + ExecFixture f("euclideanDistance(aint,intquery)"); EXPECT_TRUE(f.test.execute(11.789826, 0.000001)); } -TEST_F("require that distance is calculated for floating point vectors", - ExecFixture("euclideanDistance(afloat,floatquery)")) +TEST(EuclideanDistanceTest, require_that_distance_is_calculated_for_floating_point_vectors) { + ExecFixture f("euclideanDistance(afloat,floatquery)"); EXPECT_TRUE(f.test.execute(13.891846, 0.000001)); } -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp b/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp index 7611296c641..57e1f22171f 100644 --- a/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp +++ b/searchlib/src/tests/features/internal_max_reduce_prod_join_feature/internal_max_reduce_prod_join_feature_test.cpp @@ -1,12 +1,12 @@ // 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/searchcommon/attribute/config.h> #include <vespa/searchlib/attribute/attribute.h> #include <vespa/searchlib/attribute/attributefactory.h> #include <vespa/searchlib/features/internal_max_reduce_prod_join_feature.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; @@ -22,7 +22,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; struct SetupFixture { @@ -45,36 +45,42 @@ struct SetupFixture } }; -TEST_F("require that blueprint can be created", SetupFixture()) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_blueprint_can_be_created) { + SetupFixture f; EXPECT_TRUE(FTA::assertCreateInstance(f.blueprint, "internalMaxReduceProdJoin")); } -TEST_F("require that setup fails if attribute does not exist", SetupFixture()) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_setup_fails_if_attribute_does_not_exist) { + SetupFixture f; FTA::FT_SETUP_FAIL(f.blueprint, f.indexEnv, StringList().add("foo").add("bar")); } -TEST_F("require that setup fails if attribute is of wrong type", SetupFixture()) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_setup_fails_if_attribute_is_of_wrong_type) { + SetupFixture f; FTA::FT_SETUP_FAIL(f.blueprint, f.indexEnv, StringList().add("long").add("bar")); } -TEST_F("require that setup fails if attribute is of wrong array type", SetupFixture()) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_setup_fails_if_attribute_is_of_wrong_array_type) { + SetupFixture f; FTA::FT_SETUP_FAIL(f.blueprint, f.indexEnv, StringList().add("doublearray").add("bar")); } -TEST_F("require that setup succeeds with long array attribute", SetupFixture()) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_setup_succeeds_with_long_array_attribute) { + SetupFixture f; FTA::FT_SETUP_OK(f.blueprint, f.indexEnv, StringList().add("longarray").add("query"), StringList(), StringList().add("scalar")); } -TEST_F("require that setup succeeds with int array attribute", SetupFixture()) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_setup_succeeds_with_int_array_attribute) { + SetupFixture f; FTA::FT_SETUP_OK(f.blueprint, f.indexEnv, StringList().add("intarray").add("query"), StringList(), @@ -92,7 +98,7 @@ struct ExecFixture factory.addPrototype(std::make_shared<InternalMaxReduceProdJoinBlueprint>()); setupAttributeVectors(); setupQueryEnvironment(); - ASSERT_TRUE(test.setup()); + EXPECT_TRUE(test.setup()); } void setupAttributeVectors() { @@ -138,37 +144,37 @@ struct ExecFixture }; -TEST_F("require that executor returns correct result for long array", - ExecFixture("internalMaxReduceProdJoin(longarray,wset)")) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_executor_returns_correct_result_for_long_array) { + ExecFixture f("internalMaxReduceProdJoin(longarray,wset)"); EXPECT_FALSE(f.evaluatesTo(1234)); EXPECT_TRUE(f.evaluatesTo(2245)); } -TEST_F("require that executor returns correct result for int array", - ExecFixture("internalMaxReduceProdJoin(intarray,wset)")) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_executor_returns_correct_result_for_int_array) { + ExecFixture f("internalMaxReduceProdJoin(intarray,wset)"); EXPECT_TRUE(f.evaluatesTo(1234)); EXPECT_FALSE(f.evaluatesTo(2245)); } -TEST_F("require that executor returns 0 if no items match", - ExecFixture("internalMaxReduceProdJoin(longarray,wsetnomatch)")) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_executor_returns_0_if_no_items_match) { + ExecFixture f("internalMaxReduceProdJoin(longarray,wsetnomatch)"); EXPECT_TRUE(f.evaluatesTo(0.0)); } -TEST_F("require that executor return 0 if query is not a weighted set", - ExecFixture("internalMaxReduceProdJoin(longarray,array)")) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_executor_return_0_if_query_is_not_a_weighted_set) { + ExecFixture f("internalMaxReduceProdJoin(longarray,array)"); EXPECT_TRUE(f.evaluatesTo(0.0)); } -TEST_F("require that executor supports negative numbers", - ExecFixture("internalMaxReduceProdJoin(intarray,negativewset)")) +TEST(InternalMaxReduceProdJoinFeatureTest, require_that_executor_supports_negative_numbers) { + ExecFixture f("internalMaxReduceProdJoin(intarray,negativewset)"); EXPECT_FALSE(f.evaluatesTo(-1000)); EXPECT_TRUE(f.evaluatesTo(-42)); } -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/features/tensor/CMakeLists.txt b/searchlib/src/tests/features/tensor/CMakeLists.txt index 06a70b95acd..7666c613bb3 100644 --- a/searchlib/src/tests/features/tensor/CMakeLists.txt +++ b/searchlib/src/tests/features/tensor/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_tensor_test_app TEST tensor_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_tensor_test_app COMMAND searchlib_tensor_test_app) diff --git a/searchlib/src/tests/features/tensor/tensor_test.cpp b/searchlib/src/tests/features/tensor/tensor_test.cpp index fe4464bad72..0af9224166b 100644 --- a/searchlib/src/tests/features/tensor/tensor_test.cpp +++ b/searchlib/src/tests/features/tensor/tensor_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> @@ -12,10 +11,11 @@ #include <vespa/searchlib/attribute/attributevector.h> #include <vespa/searchlib/features/setup.h> #include <vespa/searchlib/fef/fef.h> +#include <vespa/searchlib/fef/test/ftlib.h> #include <vespa/searchlib/fef/test/indexenvironment.h> #include <vespa/searchlib/tensor/tensor_attribute.h> #include <vespa/searchlib/tensor/direct_tensor_attribute.h> -#include <vespa/searchlib/test/ft_test_app.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/vespalib/objects/nbostream.h> using search::feature_t; @@ -38,7 +38,6 @@ using AVC = search::attribute::Config; using AVBT = search::attribute::BasicType; using AVCT = search::attribute::CollectionType; using AttributePtr = search::AttributeVector::SP; -using FTA = FtTestApp; using CollectionType = FieldInfo::CollectionType; namespace @@ -61,7 +60,7 @@ struct ExecFixture setup_search_features(factory); setupAttributeVectors(); setupQueryEnvironment(); - ASSERT_TRUE(test.setup()); + EXPECT_TRUE(test.setup()); } void addAttributeField(const vespalib::string &attrName) { test.getIndexEnv().getBuilder().addField(FieldType::ATTRIBUTE, CollectionType::SINGLE, attrName); @@ -157,7 +156,7 @@ struct ExecFixture } const Value &extractTensor(uint32_t docid) { Value::CREF value = test.resolveObjectFeature(docid); - ASSERT_TRUE(value.get().type().has_dimensions()); + EXPECT_TRUE(value.get().type().has_dimensions()); return value.get(); } const Value &execute(uint32_t docId = 1) { @@ -165,75 +164,78 @@ struct ExecFixture } }; -TEST_F("require that tensor attribute can be extracted as tensor in attribute feature", - ExecFixture("attribute(tensorattr)")) +TEST(TensorTest, require_that_tensor_attribute_can_be_extracted_as_tensor_in_attribute_feature) { - EXPECT_EQUAL(TensorSpec("tensor(x{})") - .add({{"x", "b"}}, 5) - .add({{"x", "c"}}, 7) - .add({{"x", "a"}}, 3), spec_from_value(f.execute())); + ExecFixture f("attribute(tensorattr)"); + EXPECT_EQ(TensorSpec("tensor(x{})") + .add({{"x", "b"}}, 5) + .add({{"x", "c"}}, 7) + .add({{"x", "a"}}, 3), spec_from_value(f.execute())); } -TEST_F("require that direct tensor attribute can be extracted in attribute feature", - ExecFixture("attribute(directattr)")) +TEST(TensorTest, require_that_direct_tensor_attribute_can_be_extracted_in_attribute_feature) { - EXPECT_EQUAL(TensorSpec("tensor(x{})") - .add({{"x", "b"}}, 5) - .add({{"x", "c"}}, 7) - .add({{"x", "a"}}, 3), spec_from_value(f.execute())); + ExecFixture f("attribute(directattr)"); + EXPECT_EQ(TensorSpec("tensor(x{})") + .add({{"x", "b"}}, 5) + .add({{"x", "c"}}, 7) + .add({{"x", "a"}}, 3), spec_from_value(f.execute())); } -TEST_F("require that tensor from query can be extracted as tensor in query feature", - ExecFixture("query(tensorquery)")) +TEST(TensorTest, require_that_tensor_from_query_can_be_extracted_as_tensor_in_query_feature) { - EXPECT_EQUAL(TensorSpec("tensor(q{})") - .add({{"q", "f"}}, 17) - .add({{"q", "d"}}, 11) - .add({{"q", "e"}}, 13), spec_from_value(f.execute())); + ExecFixture f("query(tensorquery)"); + EXPECT_EQ(TensorSpec("tensor(q{})") + .add({{"q", "f"}}, 17) + .add({{"q", "d"}}, 11) + .add({{"q", "e"}}, 13), spec_from_value(f.execute())); } -TEST_F("require that tensor from query can have default value", - ExecFixture("query(with_default)")) +TEST(TensorTest, require_that_tensor_from_query_can_have_default_value) { - EXPECT_EQUAL(TensorSpec("tensor(x[3])") - .add({{"x", 0}}, 1) - .add({{"x", 1}}, 2) - .add({{"x", 2}}, 3), spec_from_value(f.execute())); + ExecFixture f("query(with_default)"); + EXPECT_EQ(TensorSpec("tensor(x[3])") + .add({{"x", 0}}, 1) + .add({{"x", 1}}, 2) + .add({{"x", 2}}, 3), spec_from_value(f.execute())); } -TEST_F("require that empty tensor is created if attribute does not exists", - ExecFixture("attribute(null)")) +TEST(TensorTest, require_that_empty_tensor_is_created_if_attribute_does_not_exists) { - EXPECT_EQUAL(*make_empty("tensor(x{})"), f.execute()); + ExecFixture f("attribute(null)"); + EXPECT_EQ(*make_empty("tensor(x{})"), f.execute()); } -TEST_F("require that empty tensor is created if tensor type is wrong", - ExecFixture("attribute(wrongtype)")) +TEST(TensorTest, require_that_empty_tensor_is_created_if_tensor_type_is_wrong) { - EXPECT_EQUAL(*make_empty("tensor(x{})"), f.execute()); + ExecFixture f("attribute(wrongtype)"); + EXPECT_EQ(*make_empty("tensor(x{})"), f.execute()); } -TEST_F("require that empty tensor is created if query parameter is not found", - ExecFixture("query(null)")) +TEST(TensorTest, require_that_empty_tensor_is_created_if_query_parameter_is_not_found) { - EXPECT_EQUAL(*make_empty("tensor(q{})"), f.execute()); + ExecFixture f("query(null)"); + EXPECT_EQ(*make_empty("tensor(q{})"), f.execute()); } -TEST_F("require that empty tensor with correct type is created if document has no tensor", - ExecFixture("attribute(tensorattr)")) { - EXPECT_EQUAL(*make_empty("tensor(x{})"), f.execute(2)); +TEST(TensorTest, require_that_empty_tensor_with_correct_type_is_created_if_document_has_no_tensor) +{ + ExecFixture f("attribute(tensorattr)"); + EXPECT_EQ(*make_empty("tensor(x{})"), f.execute(2)); } -TEST_F("require that empty tensor with correct type is returned by direct tensor attribute", - ExecFixture("attribute(directattr)")) { - EXPECT_EQUAL(*make_empty("tensor(x{})"), f.execute(2)); +TEST(TensorTest, require_that_empty_tensor_with_correct_type_is_returned_by_direct_tensor_attribute) +{ + ExecFixture f("attribute(directattr)"); + EXPECT_EQ(*make_empty("tensor(x{})"), f.execute(2)); } -TEST_F("require that wrong tensor type from query tensor gives empty tensor", - ExecFixture("query(mappedtensorquery)")) { - EXPECT_EQUAL(TensorSpec("tensor(x[2])") - .add({{"x", 0}}, 0) - .add({{"x", 1}}, 0), spec_from_value(f.execute())); +TEST(TensorTest, require_that_wrong_tensor_type_from_query_tensor_gives_empty_tensor) +{ + ExecFixture f("query(mappedtensorquery)"); + EXPECT_EQ(TensorSpec("tensor(x[2])") + .add({{"x", 0}}, 0) + .add({{"x", 1}}, 0), spec_from_value(f.execute())); } -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/vespa/searchlib/attribute/attributemanager.cpp b/searchlib/src/vespa/searchlib/attribute/attributemanager.cpp index 9bd44ab4d02..6656ded68ca 100644 --- a/searchlib/src/vespa/searchlib/attribute/attributemanager.cpp +++ b/searchlib/src/vespa/searchlib/attribute/attributemanager.cpp @@ -26,7 +26,7 @@ std::condition_variable baseDirCond; using BaseDirSet = std::set<string>; BaseDirSet baseDirSet; -static void +void waitBaseDir(const string &baseDir) { if (baseDir.empty()) { return; } @@ -49,8 +49,7 @@ waitBaseDir(const string &baseDir) } } - -static void +void dropBaseDir(const string &baseDir) { if (baseDir.empty()) @@ -165,7 +164,7 @@ AttributeManager::getAttributeReadGuard(const string &name, bool stableEnumGuard if (vh != nullptr) { return (*vh)->makeReadGuard(stableEnumGuard); } else { - return std::unique_ptr<attribute::AttributeReadGuard>(); + return {}; } } @@ -187,7 +186,7 @@ AttributeManager::getAttributeList(AttributeList & list) const { list.reserve(_attributes.size()); for (const auto& elem : _attributes) { - list.push_back(AttributeGuard(elem.second)); + list.emplace_back(elem.second); } } |