diff options
Diffstat (limited to 'searchlib/src/tests/fef')
21 files changed, 384 insertions, 379 deletions
diff --git a/searchlib/src/tests/fef/CMakeLists.txt b/searchlib/src/tests/fef/CMakeLists.txt index a01cb15a492..de32f1718da 100644 --- a/searchlib/src/tests/fef/CMakeLists.txt +++ b/searchlib/src/tests/fef/CMakeLists.txt @@ -3,6 +3,6 @@ vespa_add_executable(searchlib_fef_test_app TEST SOURCES fef_test.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_fef_test_app COMMAND searchlib_fef_test_app) diff --git a/searchlib/src/tests/fef/attributecontent/CMakeLists.txt b/searchlib/src/tests/fef/attributecontent/CMakeLists.txt index d9c88fb9eaf..966f84700a5 100644 --- a/searchlib/src/tests/fef/attributecontent/CMakeLists.txt +++ b/searchlib/src/tests/fef/attributecontent/CMakeLists.txt @@ -3,7 +3,7 @@ vespa_add_executable(searchlib_attributecontent_test_app TEST SOURCES attributecontent_test.cpp DEPENDS - searchlib + vespa_searchlib GTest::gtest ) vespa_add_test(NAME searchlib_attributecontent_test_app COMMAND searchlib_attributecontent_test_app) diff --git a/searchlib/src/tests/fef/featurenamebuilder/CMakeLists.txt b/searchlib/src/tests/fef/featurenamebuilder/CMakeLists.txt index 5f8dc64c564..8675e36e7b9 100644 --- a/searchlib/src/tests/fef/featurenamebuilder/CMakeLists.txt +++ b/searchlib/src/tests/fef/featurenamebuilder/CMakeLists.txt @@ -3,6 +3,6 @@ vespa_add_executable(searchlib_featurenamebuilder_test_app TEST SOURCES featurenamebuilder_test.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_featurenamebuilder_test_app COMMAND searchlib_featurenamebuilder_test_app) diff --git a/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp b/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp index a6910ad5df8..d4e5be770d4 100644 --- a/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp +++ b/searchlib/src/tests/fef/featurenamebuilder/featurenamebuilder_test.cpp @@ -1,19 +1,14 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/log/log.h> LOG_SETUP("featurenamebuilder_test"); -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/testkit/test_kit.h> #include <vespa/searchlib/fef/featurenamebuilder.h> using namespace search::fef; using B = FeatureNameBuilder; -TEST_SETUP(Test); - -int -Test::Main() -{ - TEST_INIT("featurenamebuilder_test"); +TEST("featurenamebuilder_test") { // normal cases EXPECT_EQUAL(B().baseName("foo").buildName(), "foo"); @@ -72,6 +67,6 @@ Test::Main() EXPECT_EQUAL(B().baseName("foo").parameter(" bar ( a , b ) . out ", false).buildName(), "foo(bar(a,b).out)"); EXPECT_EQUAL(B().baseName("foo").parameter(" bar ( a , b ) . out.2 ", false).buildName(), "foo(bar(a,b).out.2)"); EXPECT_EQUAL(B().baseName("foo").parameter(" bar ( a , b ) . out . 2 ", false).buildName(), "foo(\" bar ( a , b ) . out . 2 \")"); - - TEST_DONE(); } + +TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt b/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt index cb040472a6f..ff224d9ab5f 100644 --- a/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt +++ b/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt @@ -3,7 +3,7 @@ vespa_add_executable(searchlib_featurenameparser_test_app TEST SOURCES featurenameparser_test.cpp DEPENDS - searchlib + vespa_searchlib GTest::gtest ) vespa_add_test(NAME searchlib_featurenameparser_test_app COMMAND searchlib_featurenameparser_test_app) diff --git a/searchlib/src/tests/fef/featureoverride/CMakeLists.txt b/searchlib/src/tests/fef/featureoverride/CMakeLists.txt index 789903633a3..7f3c5bf3e32 100644 --- a/searchlib/src/tests/fef/featureoverride/CMakeLists.txt +++ b/searchlib/src/tests/fef/featureoverride/CMakeLists.txt @@ -3,6 +3,6 @@ vespa_add_executable(searchlib_featureoverride_test_app TEST SOURCES featureoverride_test.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_featureoverride_test_app COMMAND searchlib_featureoverride_test_app) diff --git a/searchlib/src/tests/fef/featureoverride/featureoverride_test.cpp b/searchlib/src/tests/fef/featureoverride/featureoverride_test.cpp index 5b3e3c356ac..f7c6b9fd7ed 100644 --- a/searchlib/src/tests/fef/featureoverride/featureoverride_test.cpp +++ b/searchlib/src/tests/fef/featureoverride/featureoverride_test.cpp @@ -1,5 +1,5 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/testkit/test_kit.h> #include <vespa/searchlib/fef/fef.h> #include <vespa/searchlib/fef/test/indexenvironment.h> diff --git a/searchlib/src/tests/fef/fef_test.cpp b/searchlib/src/tests/fef/fef_test.cpp index 0f2de1665e8..37089cfa5ea 100644 --- a/searchlib/src/tests/fef/fef_test.cpp +++ b/searchlib/src/tests/fef/fef_test.cpp @@ -1,5 +1,5 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/testkit/test_kit.h> #include <vespa/searchlib/fef/fef.h> #include <vespa/searchlib/fef/objectstore.h> diff --git a/searchlib/src/tests/fef/object_passing/CMakeLists.txt b/searchlib/src/tests/fef/object_passing/CMakeLists.txt index 2c8e0400b92..db9b95b22a6 100644 --- a/searchlib/src/tests/fef/object_passing/CMakeLists.txt +++ b/searchlib/src/tests/fef/object_passing/CMakeLists.txt @@ -3,6 +3,6 @@ vespa_add_executable(searchlib_object_passing_test_app TEST SOURCES object_passing_test.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_object_passing_test_app COMMAND searchlib_object_passing_test_app) diff --git a/searchlib/src/tests/fef/parameter/CMakeLists.txt b/searchlib/src/tests/fef/parameter/CMakeLists.txt index b238e09c98b..58ae4c412a4 100644 --- a/searchlib/src/tests/fef/parameter/CMakeLists.txt +++ b/searchlib/src/tests/fef/parameter/CMakeLists.txt @@ -3,7 +3,7 @@ vespa_add_executable(searchlib_parameter_test_app TEST SOURCES parameter_test.cpp DEPENDS - searchlib + vespa_searchlib GTest::gtest ) vespa_add_test(NAME searchlib_parameter_test_app NO_VALGRIND COMMAND searchlib_parameter_test_app) diff --git a/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt b/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt index 8f3946d110c..6c4c7ae124a 100644 --- a/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt +++ b/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt @@ -3,7 +3,7 @@ vespa_add_executable(searchlib_phrasesplitter_test_app TEST SOURCES phrasesplitter_test.cpp DEPENDS - searchlib + vespa_searchlib GTest::gtest ) vespa_add_test(NAME searchlib_phrasesplitter_test_app COMMAND searchlib_phrasesplitter_test_app) @@ -11,6 +11,6 @@ vespa_add_executable(searchlib_benchmark_app SOURCES benchmark.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_benchmark_app COMMAND searchlib_benchmark_app BENCHMARK) diff --git a/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp b/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp index 93a5a01262d..6be252380da 100644 --- a/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp +++ b/searchlib/src/tests/fef/phrasesplitter/benchmark.cpp @@ -1,18 +1,16 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> + #include <vespa/searchlib/fef/matchdatalayout.h> #include <vespa/searchlib/fef/phrasesplitter.h> #include <vespa/searchlib/fef/phrase_splitter_query_env.h> #include <vespa/searchlib/fef/test/queryenvironment.h> +#include <vespa/vespalib/util/time.h> #include <iomanip> #include <iostream> -#include <vespa/log/log.h> -LOG_SETUP("phrasesplitter_test"); - namespace search::fef { -class Benchmark : public vespalib::TestApp +class Benchmark { private: vespalib::Timer _timer; @@ -20,12 +18,16 @@ private: void start() { _timer = vespalib::Timer(); } void sample() { _sample = _timer.elapsed(); } - void run(size_t numRuns, size_t numPositions); public: - Benchmark() : _timer(), _sample(0) {} - ~Benchmark() override; - int Main() override; + Benchmark() + : _timer(), + _sample(0) + { + } + ~Benchmark(); + void run(size_t numRuns, size_t numPositions); + vespalib::duration get_sample() const noexcept { return _sample; } }; Benchmark::~Benchmark() = default; @@ -61,28 +63,24 @@ Benchmark::run(size_t numRuns, size_t numPositions) sample(); } +} + int -Benchmark::Main() +main(int argc, char* argv[]) { - - TEST_INIT("benchmark"); - - if (_argc != 3) { + if (argc != 3) { std::cout << "Must specify <numRuns> and <numPositions>" << std::endl; return 0; } - size_t numRuns = strtoull(_argv[1], nullptr, 10); - size_t numPositions = strtoull(_argv[2], nullptr, 10); + size_t numRuns = strtoull(argv[1], nullptr, 10); + size_t numPositions = strtoull(argv[2], nullptr, 10); - run(numRuns, numPositions); + auto app = std::make_unique<search::fef::Benchmark>(); + app->run(numRuns, numPositions); + auto sample = app->get_sample(); - std::cout << "TET: " << vespalib::count_ms(_sample) << " (ms)" << std::endl; - std::cout << "ETPD: " << std::fixed << std::setprecision(10) << (vespalib::count_ns(_sample) / (numRuns * 1000000.0)) << " (ms)" << std::endl; + std::cout << "TET: " << vespalib::count_ms(sample) << " (ms)" << std::endl; + std::cout << "ETPD: " << std::fixed << std::setprecision(10) << (vespalib::count_ns(sample) / (numRuns * 1000000.0)) << " (ms)" << std::endl; - TEST_DONE(); } - -} - -TEST_APPHOOK(search::fef::Benchmark); diff --git a/searchlib/src/tests/fef/properties/CMakeLists.txt b/searchlib/src/tests/fef/properties/CMakeLists.txt index dd1eb83b0c2..4eae94344c4 100644 --- a/searchlib/src/tests/fef/properties/CMakeLists.txt +++ b/searchlib/src/tests/fef/properties/CMakeLists.txt @@ -3,6 +3,7 @@ vespa_add_executable(searchlib_properties_test_app TEST SOURCES properties_test.cpp DEPENDS - searchlib + vespa_searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_properties_test_app COMMAND searchlib_properties_test_app) diff --git a/searchlib/src/tests/fef/properties/properties_test.cpp b/searchlib/src/tests/fef/properties/properties_test.cpp index c8073739b3e..80a7b64a2e0 100644 --- a/searchlib/src/tests/fef/properties/properties_test.cpp +++ b/searchlib/src/tests/fef/properties/properties_test.cpp @@ -1,7 +1,7 @@ // 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/fef/indexproperties.h> #include <vespa/searchlib/fef/properties.h> +#include <vespa/vespalib/gtest/gtest.h> #include <limits> using namespace search::fef; @@ -30,7 +30,8 @@ Properties make_props(std::initializer_list<std::pair<const char *, std::initial return props; } -TEST("require that namespace visitation works") { +TEST(PropertiesTest, require_that_namespace_visitation_works) +{ Properties props = make_props({ {"foo", {"outside"}}, {"foo.a", {"a_value"}}, {"foo.b", {"b_value"}}, @@ -39,20 +40,21 @@ TEST("require that namespace visitation works") { Properties result; CopyVisitor copy_visitor(result); props.visitNamespace("foo", copy_visitor); - EXPECT_EQUAL(2u, result.numKeys()); - EXPECT_EQUAL(result.lookup("a").get(), Property::Value("a_value")); - EXPECT_EQUAL(result.lookup("b").get(), Property::Value("b_value")); + EXPECT_EQ(2u, result.numKeys()); + EXPECT_EQ(result.lookup("a").get(), Property::Value("a_value")); + EXPECT_EQ(result.lookup("b").get(), Property::Value("b_value")); } -TEST("test stuff") { +TEST(PropertiesTest, test_stuff) +{ { // empty lookup result Property p; - EXPECT_EQUAL(p.found(), false); - EXPECT_EQUAL(p.get(), Property::Value("")); - EXPECT_EQUAL(p.get("fb"), Property::Value("fb")); - EXPECT_EQUAL(p.size(), 0u); - EXPECT_EQUAL(p.getAt(0), Property::Value("")); + EXPECT_EQ(p.found(), false); + EXPECT_EQ(p.get(), Property::Value("")); + EXPECT_EQ(p.get("fb"), Property::Value("fb")); + EXPECT_EQ(p.size(), 0u); + EXPECT_EQ(p.getAt(0), Property::Value("")); } { // add / count / remove Properties p = make_props({ {"a", {"a1", "a2", "a3"}}, @@ -61,48 +63,48 @@ TEST("test stuff") { }); const Properties &pc = p; - EXPECT_EQUAL(pc.numKeys(), 3u); - EXPECT_EQUAL(pc.numValues(), 6u); - EXPECT_EQUAL(pc.count("a"), 3u); - EXPECT_EQUAL(pc.count("b"), 2u); - EXPECT_EQUAL(pc.count("c"), 1u); - EXPECT_EQUAL(pc.count("d"), 0u); + EXPECT_EQ(pc.numKeys(), 3u); + EXPECT_EQ(pc.numValues(), 6u); + EXPECT_EQ(pc.count("a"), 3u); + EXPECT_EQ(pc.count("b"), 2u); + EXPECT_EQ(pc.count("c"), 1u); + EXPECT_EQ(pc.count("d"), 0u); p.remove("d"); - EXPECT_EQUAL(pc.numKeys(), 3u); - EXPECT_EQUAL(pc.numValues(), 6u); - EXPECT_EQUAL(pc.count("a"), 3u); - EXPECT_EQUAL(pc.count("b"), 2u); - EXPECT_EQUAL(pc.count("c"), 1u); - EXPECT_EQUAL(pc.count("d"), 0u); + EXPECT_EQ(pc.numKeys(), 3u); + EXPECT_EQ(pc.numValues(), 6u); + EXPECT_EQ(pc.count("a"), 3u); + EXPECT_EQ(pc.count("b"), 2u); + EXPECT_EQ(pc.count("c"), 1u); + EXPECT_EQ(pc.count("d"), 0u); p.remove("c"); - EXPECT_EQUAL(pc.numKeys(), 2u); - EXPECT_EQUAL(pc.numValues(), 5u); - EXPECT_EQUAL(pc.count("a"), 3u); - EXPECT_EQUAL(pc.count("b"), 2u); - EXPECT_EQUAL(pc.count("c"), 0u); - EXPECT_EQUAL(pc.count("d"), 0u); + EXPECT_EQ(pc.numKeys(), 2u); + EXPECT_EQ(pc.numValues(), 5u); + EXPECT_EQ(pc.count("a"), 3u); + EXPECT_EQ(pc.count("b"), 2u); + EXPECT_EQ(pc.count("c"), 0u); + EXPECT_EQ(pc.count("d"), 0u); p.remove("b"); - EXPECT_EQUAL(pc.numKeys(), 1u); - EXPECT_EQUAL(pc.numValues(), 3u); - EXPECT_EQUAL(pc.count("a"), 3u); - EXPECT_EQUAL(pc.count("b"), 0u); - EXPECT_EQUAL(pc.count("c"), 0u); - EXPECT_EQUAL(pc.count("d"), 0u); + EXPECT_EQ(pc.numKeys(), 1u); + EXPECT_EQ(pc.numValues(), 3u); + EXPECT_EQ(pc.count("a"), 3u); + EXPECT_EQ(pc.count("b"), 0u); + EXPECT_EQ(pc.count("c"), 0u); + EXPECT_EQ(pc.count("d"), 0u); p.remove("a"); - EXPECT_EQUAL(pc.numKeys(), 0u); - EXPECT_EQUAL(pc.numValues(), 0u); - EXPECT_EQUAL(pc.count("a"), 0u); - EXPECT_EQUAL(pc.count("b"), 0u); - EXPECT_EQUAL(pc.count("c"), 0u); - EXPECT_EQUAL(pc.count("d"), 0u); + EXPECT_EQ(pc.numKeys(), 0u); + EXPECT_EQ(pc.numValues(), 0u); + EXPECT_EQ(pc.count("a"), 0u); + EXPECT_EQ(pc.count("b"), 0u); + EXPECT_EQ(pc.count("c"), 0u); + EXPECT_EQ(pc.count("d"), 0u); } { // lookup / import / visit / compare / hash Properties p; @@ -114,38 +116,38 @@ TEST("test stuff") { p.add("list", "e1").add("list", "e2").add("list", "e3"); - EXPECT_EQUAL(p.numKeys(), 5u); - EXPECT_EQUAL(p.numValues(), 7u); - - EXPECT_EQUAL(p.lookup("x").found(), true); - EXPECT_EQUAL(p.lookup("a.x").found(), true); - EXPECT_EQUAL(p.lookup("a.b.x").found(), true); - EXPECT_EQUAL(p.lookup("a.b.c.x").found(), true); - EXPECT_EQUAL(p.lookup("list").found(), true); - EXPECT_EQUAL(p.lookup("y").found(), false); - - EXPECT_EQUAL(p.lookup("x").get(), Property::Value("x1")); - EXPECT_EQUAL(p.lookup("a.x").get(), Property::Value("x2")); - EXPECT_EQUAL(p.lookup("a.b.x").get(), Property::Value("x3")); - EXPECT_EQUAL(p.lookup("a.b.c.x").get(), Property::Value("x4")); - EXPECT_EQUAL(p.lookup("list").get(), Property::Value("e1")); - EXPECT_EQUAL(p.lookup("y").get(), Property::Value("")); - - EXPECT_EQUAL(p.lookup("x").get(), Property::Value("x1")); - EXPECT_EQUAL(p.lookup("a", "x").get(), Property::Value("x2")); - EXPECT_EQUAL(p.lookup("a", "b", "x").get(), Property::Value("x3")); - EXPECT_EQUAL(p.lookup("a", "b", "c", "x").get(), Property::Value("x4")); - - EXPECT_EQUAL(p.lookup("x").get("fallback"), Property::Value("x1")); - EXPECT_EQUAL(p.lookup("y").get("fallback"), Property::Value("fallback")); - - EXPECT_EQUAL(p.lookup("y").size(), 0u); - EXPECT_EQUAL(p.lookup("x").size(), 1u); - EXPECT_EQUAL(p.lookup("list").size(), 3u); - EXPECT_EQUAL(p.lookup("list").getAt(0), Property::Value("e1")); - EXPECT_EQUAL(p.lookup("list").getAt(1), Property::Value("e2")); - EXPECT_EQUAL(p.lookup("list").getAt(2), Property::Value("e3")); - EXPECT_EQUAL(p.lookup("list").getAt(3), Property::Value("")); + EXPECT_EQ(p.numKeys(), 5u); + EXPECT_EQ(p.numValues(), 7u); + + EXPECT_EQ(p.lookup("x").found(), true); + EXPECT_EQ(p.lookup("a.x").found(), true); + EXPECT_EQ(p.lookup("a.b.x").found(), true); + EXPECT_EQ(p.lookup("a.b.c.x").found(), true); + EXPECT_EQ(p.lookup("list").found(), true); + EXPECT_EQ(p.lookup("y").found(), false); + + EXPECT_EQ(p.lookup("x").get(), Property::Value("x1")); + EXPECT_EQ(p.lookup("a.x").get(), Property::Value("x2")); + EXPECT_EQ(p.lookup("a.b.x").get(), Property::Value("x3")); + EXPECT_EQ(p.lookup("a.b.c.x").get(), Property::Value("x4")); + EXPECT_EQ(p.lookup("list").get(), Property::Value("e1")); + EXPECT_EQ(p.lookup("y").get(), Property::Value("")); + + EXPECT_EQ(p.lookup("x").get(), Property::Value("x1")); + EXPECT_EQ(p.lookup("a", "x").get(), Property::Value("x2")); + EXPECT_EQ(p.lookup("a", "b", "x").get(), Property::Value("x3")); + EXPECT_EQ(p.lookup("a", "b", "c", "x").get(), Property::Value("x4")); + + EXPECT_EQ(p.lookup("x").get("fallback"), Property::Value("x1")); + EXPECT_EQ(p.lookup("y").get("fallback"), Property::Value("fallback")); + + EXPECT_EQ(p.lookup("y").size(), 0u); + EXPECT_EQ(p.lookup("x").size(), 1u); + EXPECT_EQ(p.lookup("list").size(), 3u); + EXPECT_EQ(p.lookup("list").getAt(0), Property::Value("e1")); + EXPECT_EQ(p.lookup("list").getAt(1), Property::Value("e2")); + EXPECT_EQ(p.lookup("list").getAt(2), Property::Value("e3")); + EXPECT_EQ(p.lookup("list").getAt(3), Property::Value("")); Properties p2; @@ -153,29 +155,29 @@ TEST("test stuff") { p2.add("y", "y1"); p2.add("list", "foo").add("list", "bar"); - EXPECT_EQUAL(p2.numKeys(), 3u); - EXPECT_EQUAL(p2.numValues(), 4u); + EXPECT_EQ(p2.numKeys(), 3u); + EXPECT_EQ(p2.numValues(), 4u); p.import(p2); - EXPECT_EQUAL(p.numKeys(), 6u); - EXPECT_EQUAL(p.numValues(), 7u); + EXPECT_EQ(p.numKeys(), 6u); + EXPECT_EQ(p.numValues(), 7u); - EXPECT_EQUAL(p.lookup("y").size(), 1u); - EXPECT_EQUAL(p.lookup("y").get(), Property::Value("y1")); + EXPECT_EQ(p.lookup("y").size(), 1u); + EXPECT_EQ(p.lookup("y").get(), Property::Value("y1")); - EXPECT_EQUAL(p.lookup("x").size(), 1u); - EXPECT_EQUAL(p.lookup("x").get(), Property::Value("new_x")); + EXPECT_EQ(p.lookup("x").size(), 1u); + EXPECT_EQ(p.lookup("x").get(), Property::Value("new_x")); - EXPECT_EQUAL(p.lookup("z").size(), 0u); + EXPECT_EQ(p.lookup("z").size(), 0u); - EXPECT_EQUAL(p.lookup("a", "x").size(), 1u); - EXPECT_EQUAL(p.lookup("a", "x").get(), Property::Value("x2")); + EXPECT_EQ(p.lookup("a", "x").size(), 1u); + EXPECT_EQ(p.lookup("a", "x").get(), Property::Value("x2")); - EXPECT_EQUAL(p.lookup("list").size(), 2u); - EXPECT_EQUAL(p.lookup("list").getAt(0), Property::Value("foo")); - EXPECT_EQUAL(p.lookup("list").getAt(1), Property::Value("bar")); - EXPECT_EQUAL(p.lookup("list").getAt(2), Property::Value("")); + EXPECT_EQ(p.lookup("list").size(), 2u); + EXPECT_EQ(p.lookup("list").getAt(0), Property::Value("foo")); + EXPECT_EQ(p.lookup("list").getAt(1), Property::Value("bar")); + EXPECT_EQ(p.lookup("list").getAt(2), Property::Value("")); Properties p3; @@ -189,32 +191,32 @@ TEST("test stuff") { CopyVisitor cv(p3); p.visitProperties(cv); - EXPECT_EQUAL(p3.numKeys(), 6u); - EXPECT_EQUAL(p3.numValues(), 7u); + EXPECT_EQ(p3.numKeys(), 6u); + EXPECT_EQ(p3.numValues(), 7u); EXPECT_TRUE(p == p3); EXPECT_TRUE(p3 == p); - EXPECT_EQUAL(p.hashCode(), p3.hashCode()); + EXPECT_EQ(p.hashCode(), p3.hashCode()); p.clear(); - EXPECT_EQUAL(p.numKeys(), 0u); - EXPECT_EQUAL(p.numValues(), 0u); + EXPECT_EQ(p.numKeys(), 0u); + EXPECT_EQ(p.numValues(), 0u); EXPECT_TRUE(!(p == p3)); EXPECT_TRUE(!(p3 == p)); Properties p4; CopyVisitor cv2(p4); p.visitProperties(cv); - EXPECT_EQUAL(p4.numKeys(), 0u); - EXPECT_EQUAL(p4.numValues(), 0u); + EXPECT_EQ(p4.numKeys(), 0u); + EXPECT_EQ(p4.numValues(), 0u); EXPECT_TRUE(p == p4); EXPECT_TRUE(p4 == p); - EXPECT_EQUAL(p.hashCode(), p4.hashCode()); + EXPECT_EQ(p.hashCode(), p4.hashCode()); } { // test index properties known by the framework { // vespa.eval.lazy_expressions - EXPECT_EQUAL(eval::LazyExpressions::NAME, vespalib::string("vespa.eval.lazy_expressions")); + EXPECT_EQ(eval::LazyExpressions::NAME, vespalib::string("vespa.eval.lazy_expressions")); { Properties p; EXPECT_TRUE(eval::LazyExpressions::check(p, true)); @@ -234,201 +236,203 @@ TEST("test stuff") { } } { // vespa.eval.use_fast_forest - EXPECT_EQUAL(eval::UseFastForest::NAME, vespalib::string("vespa.eval.use_fast_forest")); - EXPECT_EQUAL(eval::UseFastForest::DEFAULT_VALUE, false); + EXPECT_EQ(eval::UseFastForest::NAME, vespalib::string("vespa.eval.use_fast_forest")); + EXPECT_EQ(eval::UseFastForest::DEFAULT_VALUE, false); Properties p; - EXPECT_EQUAL(eval::UseFastForest::check(p), false); + EXPECT_EQ(eval::UseFastForest::check(p), false); p.add("vespa.eval.use_fast_forest", "true"); - EXPECT_EQUAL(eval::UseFastForest::check(p), true); + EXPECT_EQ(eval::UseFastForest::check(p), true); } { // vespa.rank.firstphase - EXPECT_EQUAL(rank::FirstPhase::NAME, vespalib::string("vespa.rank.firstphase")); - EXPECT_EQUAL(rank::FirstPhase::DEFAULT_VALUE, vespalib::string("nativeRank")); + EXPECT_EQ(rank::FirstPhase::NAME, vespalib::string("vespa.rank.firstphase")); + EXPECT_EQ(rank::FirstPhase::DEFAULT_VALUE, vespalib::string("nativeRank")); Properties p; - EXPECT_EQUAL(rank::FirstPhase::lookup(p), vespalib::string("nativeRank")); + EXPECT_EQ(rank::FirstPhase::lookup(p), vespalib::string("nativeRank")); p.add("vespa.rank.firstphase", "specialrank"); - EXPECT_EQUAL(rank::FirstPhase::lookup(p), vespalib::string("specialrank")); + EXPECT_EQ(rank::FirstPhase::lookup(p), vespalib::string("specialrank")); } { // vespa.rank.secondphase - EXPECT_EQUAL(rank::SecondPhase::NAME, vespalib::string("vespa.rank.secondphase")); - EXPECT_EQUAL(rank::SecondPhase::DEFAULT_VALUE, vespalib::string("")); + EXPECT_EQ(rank::SecondPhase::NAME, vespalib::string("vespa.rank.secondphase")); + EXPECT_EQ(rank::SecondPhase::DEFAULT_VALUE, vespalib::string("")); Properties p; - EXPECT_EQUAL(rank::SecondPhase::lookup(p), vespalib::string("")); + EXPECT_EQ(rank::SecondPhase::lookup(p), vespalib::string("")); p.add("vespa.rank.secondphase", "specialrank"); - EXPECT_EQUAL(rank::SecondPhase::lookup(p), vespalib::string("specialrank")); + EXPECT_EQ(rank::SecondPhase::lookup(p), vespalib::string("specialrank")); } { // vespa.dump.feature - EXPECT_EQUAL(dump::Feature::NAME, vespalib::string("vespa.dump.feature")); - EXPECT_EQUAL(dump::Feature::DEFAULT_VALUE.size(), 0u); + EXPECT_EQ(dump::Feature::NAME, vespalib::string("vespa.dump.feature")); + EXPECT_EQ(dump::Feature::DEFAULT_VALUE.size(), 0u); Properties p; - EXPECT_EQUAL(dump::Feature::lookup(p).size(), 0u); + EXPECT_EQ(dump::Feature::lookup(p).size(), 0u); p.add("vespa.dump.feature", "foo"); p.add("vespa.dump.feature", "bar"); std::vector<vespalib::string> a = dump::Feature::lookup(p); ASSERT_TRUE(a.size() == 2); - EXPECT_EQUAL(a[0], vespalib::string("foo")); - EXPECT_EQUAL(a[1], vespalib::string("bar")); + EXPECT_EQ(a[0], vespalib::string("foo")); + EXPECT_EQ(a[1], vespalib::string("bar")); } { // vespa.dump.ignoredefaultfeatures - EXPECT_EQUAL(dump::IgnoreDefaultFeatures::NAME, vespalib::string("vespa.dump.ignoredefaultfeatures")); - EXPECT_EQUAL(dump::IgnoreDefaultFeatures::DEFAULT_VALUE, "false"); + EXPECT_EQ(dump::IgnoreDefaultFeatures::NAME, vespalib::string("vespa.dump.ignoredefaultfeatures")); + EXPECT_EQ(dump::IgnoreDefaultFeatures::DEFAULT_VALUE, "false"); Properties p; EXPECT_TRUE(!dump::IgnoreDefaultFeatures::check(p)); p.add("vespa.dump.ignoredefaultfeatures", "true"); EXPECT_TRUE(dump::IgnoreDefaultFeatures::check(p)); } { // vespa.matching.termwise_limit - EXPECT_EQUAL(matching::TermwiseLimit::NAME, vespalib::string("vespa.matching.termwise_limit")); - EXPECT_EQUAL(matching::TermwiseLimit::DEFAULT_VALUE, 1.0); + EXPECT_EQ(matching::TermwiseLimit::NAME, vespalib::string("vespa.matching.termwise_limit")); + EXPECT_EQ(matching::TermwiseLimit::DEFAULT_VALUE, 1.0); Properties p; - EXPECT_EQUAL(matching::TermwiseLimit::lookup(p), 1.0); + EXPECT_EQ(matching::TermwiseLimit::lookup(p), 1.0); p.add("vespa.matching.termwise_limit", "0.05"); - EXPECT_EQUAL(matching::TermwiseLimit::lookup(p), 0.05); + EXPECT_EQ(matching::TermwiseLimit::lookup(p), 0.05); } { // vespa.matching.numthreads - EXPECT_EQUAL(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch")); - EXPECT_EQUAL(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max()); + EXPECT_EQ(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch")); + EXPECT_EQ(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max()); Properties p; - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), std::numeric_limits<uint32_t>::max()); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), std::numeric_limits<uint32_t>::max()); p.add("vespa.matching.numthreadspersearch", "50"); - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u); } { // vespa.matching.minhitsperthread - EXPECT_EQUAL(matching::MinHitsPerThread::NAME, vespalib::string("vespa.matching.minhitsperthread")); - EXPECT_EQUAL(matching::MinHitsPerThread::DEFAULT_VALUE, 0u); + EXPECT_EQ(matching::MinHitsPerThread::NAME, vespalib::string("vespa.matching.minhitsperthread")); + EXPECT_EQ(matching::MinHitsPerThread::DEFAULT_VALUE, 0u); Properties p; - EXPECT_EQUAL(matching::MinHitsPerThread::lookup(p), 0u); + EXPECT_EQ(matching::MinHitsPerThread::lookup(p), 0u); p.add("vespa.matching.minhitsperthread", "50"); - EXPECT_EQUAL(matching::MinHitsPerThread::lookup(p), 50u); + EXPECT_EQ(matching::MinHitsPerThread::lookup(p), 50u); } { - EXPECT_EQUAL(matching::NumSearchPartitions::NAME, vespalib::string("vespa.matching.numsearchpartitions")); - EXPECT_EQUAL(matching::NumSearchPartitions::DEFAULT_VALUE, 1u); + EXPECT_EQ(matching::NumSearchPartitions::NAME, vespalib::string("vespa.matching.numsearchpartitions")); + EXPECT_EQ(matching::NumSearchPartitions::DEFAULT_VALUE, 1u); Properties p; - EXPECT_EQUAL(matching::NumSearchPartitions::lookup(p), 1u); + EXPECT_EQ(matching::NumSearchPartitions::lookup(p), 1u); p.add("vespa.matching.numsearchpartitions", "50"); - EXPECT_EQUAL(matching::NumSearchPartitions::lookup(p), 50u); + EXPECT_EQ(matching::NumSearchPartitions::lookup(p), 50u); } { // vespa.matchphase.degradation.attribute - EXPECT_EQUAL(matchphase::DegradationAttribute::NAME, vespalib::string("vespa.matchphase.degradation.attribute")); - EXPECT_EQUAL(matchphase::DegradationAttribute::DEFAULT_VALUE, ""); + EXPECT_EQ(matchphase::DegradationAttribute::NAME, vespalib::string("vespa.matchphase.degradation.attribute")); + EXPECT_EQ(matchphase::DegradationAttribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(matchphase::DegradationAttribute::lookup(p), ""); + EXPECT_EQ(matchphase::DegradationAttribute::lookup(p), ""); p.add("vespa.matchphase.degradation.attribute", "foobar"); - EXPECT_EQUAL(matchphase::DegradationAttribute::lookup(p), "foobar"); + EXPECT_EQ(matchphase::DegradationAttribute::lookup(p), "foobar"); } { // vespa.matchphase.degradation.ascending - EXPECT_EQUAL(matchphase::DegradationAscendingOrder::NAME, vespalib::string("vespa.matchphase.degradation.ascendingorder")); - EXPECT_EQUAL(matchphase::DegradationAscendingOrder::DEFAULT_VALUE, false); + EXPECT_EQ(matchphase::DegradationAscendingOrder::NAME, vespalib::string("vespa.matchphase.degradation.ascendingorder")); + EXPECT_EQ(matchphase::DegradationAscendingOrder::DEFAULT_VALUE, false); Properties p; - EXPECT_EQUAL(matchphase::DegradationAscendingOrder::lookup(p), false); + EXPECT_EQ(matchphase::DegradationAscendingOrder::lookup(p), false); p.add("vespa.matchphase.degradation.ascendingorder", "true"); - EXPECT_EQUAL(matchphase::DegradationAscendingOrder::lookup(p), true); + EXPECT_EQ(matchphase::DegradationAscendingOrder::lookup(p), true); } { // vespa.matchphase.degradation.maxhits - EXPECT_EQUAL(matchphase::DegradationMaxHits::NAME, vespalib::string("vespa.matchphase.degradation.maxhits")); - EXPECT_EQUAL(matchphase::DegradationMaxHits::DEFAULT_VALUE, 0u); + EXPECT_EQ(matchphase::DegradationMaxHits::NAME, vespalib::string("vespa.matchphase.degradation.maxhits")); + EXPECT_EQ(matchphase::DegradationMaxHits::DEFAULT_VALUE, 0u); Properties p; - EXPECT_EQUAL(matchphase::DegradationMaxHits::lookup(p), 0u); + EXPECT_EQ(matchphase::DegradationMaxHits::lookup(p), 0u); p.add("vespa.matchphase.degradation.maxhits", "123789"); - EXPECT_EQUAL(matchphase::DegradationMaxHits::lookup(p), 123789u); + EXPECT_EQ(matchphase::DegradationMaxHits::lookup(p), 123789u); } { // vespa.matchphase.degradation.samplepercentage - EXPECT_EQUAL(matchphase::DegradationSamplePercentage::NAME, vespalib::string("vespa.matchphase.degradation.samplepercentage")); - EXPECT_EQUAL(matchphase::DegradationSamplePercentage::DEFAULT_VALUE, 0.2); + EXPECT_EQ(matchphase::DegradationSamplePercentage::NAME, vespalib::string("vespa.matchphase.degradation.samplepercentage")); + EXPECT_EQ(matchphase::DegradationSamplePercentage::DEFAULT_VALUE, 0.2); Properties p; - EXPECT_EQUAL(matchphase::DegradationSamplePercentage::lookup(p), 0.2); + EXPECT_EQ(matchphase::DegradationSamplePercentage::lookup(p), 0.2); p.add("vespa.matchphase.degradation.samplepercentage", "0.9"); - EXPECT_EQUAL(matchphase::DegradationSamplePercentage::lookup(p), 0.9); + EXPECT_EQ(matchphase::DegradationSamplePercentage::lookup(p), 0.9); } { // vespa.matchphase.degradation.maxfiltercoverage - EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::NAME, vespalib::string("vespa.matchphase.degradation.maxfiltercoverage")); - EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::DEFAULT_VALUE, 0.2); + EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::NAME, vespalib::string("vespa.matchphase.degradation.maxfiltercoverage")); + EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::DEFAULT_VALUE, 0.2); Properties p; - EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.2); + EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.2); p.add("vespa.matchphase.degradation.maxfiltercoverage", "0.076"); - EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.076); + EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.076); } { // vespa.matchphase.degradation.postfiltermultiplier - EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::NAME, vespalib::string("vespa.matchphase.degradation.postfiltermultiplier")); - EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::DEFAULT_VALUE, 1.0); + EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::NAME, vespalib::string("vespa.matchphase.degradation.postfiltermultiplier")); + EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::DEFAULT_VALUE, 1.0); Properties p; - EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::lookup(p), 1.0); + EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::lookup(p), 1.0); p.add("vespa.matchphase.degradation.postfiltermultiplier", "0.9"); - EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::lookup(p), 0.9); + EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::lookup(p), 0.9); } { // vespa.matchphase.diversity.attribute - EXPECT_EQUAL(matchphase::DiversityAttribute::NAME, vespalib::string("vespa.matchphase.diversity.attribute")); - EXPECT_EQUAL(matchphase::DiversityAttribute::DEFAULT_VALUE, ""); + EXPECT_EQ(matchphase::DiversityAttribute::NAME, vespalib::string("vespa.matchphase.diversity.attribute")); + EXPECT_EQ(matchphase::DiversityAttribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(matchphase::DiversityAttribute::lookup(p), ""); + EXPECT_EQ(matchphase::DiversityAttribute::lookup(p), ""); p.add("vespa.matchphase.diversity.attribute", "foobar"); - EXPECT_EQUAL(matchphase::DiversityAttribute::lookup(p), "foobar"); + EXPECT_EQ(matchphase::DiversityAttribute::lookup(p), "foobar"); } { // vespa.matchphase.diversity.mingroups - EXPECT_EQUAL(matchphase::DiversityMinGroups::NAME, vespalib::string("vespa.matchphase.diversity.mingroups")); - EXPECT_EQUAL(matchphase::DiversityMinGroups::DEFAULT_VALUE, 1u); + EXPECT_EQ(matchphase::DiversityMinGroups::NAME, vespalib::string("vespa.matchphase.diversity.mingroups")); + EXPECT_EQ(matchphase::DiversityMinGroups::DEFAULT_VALUE, 1u); Properties p; - EXPECT_EQUAL(matchphase::DiversityMinGroups::lookup(p), 1u); + EXPECT_EQ(matchphase::DiversityMinGroups::lookup(p), 1u); p.add("vespa.matchphase.diversity.mingroups", "5"); - EXPECT_EQUAL(matchphase::DiversityMinGroups::lookup(p), 5u); + EXPECT_EQ(matchphase::DiversityMinGroups::lookup(p), 5u); } { // vespa.hitcollector.heapsize - EXPECT_EQUAL(hitcollector::HeapSize::NAME, vespalib::string("vespa.hitcollector.heapsize")); - EXPECT_EQUAL(hitcollector::HeapSize::DEFAULT_VALUE, 100u); + EXPECT_EQ(hitcollector::HeapSize::NAME, vespalib::string("vespa.hitcollector.heapsize")); + EXPECT_EQ(hitcollector::HeapSize::DEFAULT_VALUE, 100u); Properties p; - EXPECT_EQUAL(hitcollector::HeapSize::lookup(p), 100u); + EXPECT_EQ(hitcollector::HeapSize::lookup(p), 100u); p.add("vespa.hitcollector.heapsize", "50"); - EXPECT_EQUAL(hitcollector::HeapSize::lookup(p), 50u); + EXPECT_EQ(hitcollector::HeapSize::lookup(p), 50u); } { // vespa.hitcollector.arraysize - EXPECT_EQUAL(hitcollector::ArraySize::NAME, vespalib::string("vespa.hitcollector.arraysize")); - EXPECT_EQUAL(hitcollector::ArraySize::DEFAULT_VALUE, 10000u); + EXPECT_EQ(hitcollector::ArraySize::NAME, vespalib::string("vespa.hitcollector.arraysize")); + EXPECT_EQ(hitcollector::ArraySize::DEFAULT_VALUE, 10000u); Properties p; - EXPECT_EQUAL(hitcollector::ArraySize::lookup(p), 10000u); + EXPECT_EQ(hitcollector::ArraySize::lookup(p), 10000u); p.add("vespa.hitcollector.arraysize", "50"); - EXPECT_EQUAL(hitcollector::ArraySize::lookup(p), 50u); + EXPECT_EQ(hitcollector::ArraySize::lookup(p), 50u); } { // vespa.hitcollector.estimatepoint - EXPECT_EQUAL(hitcollector::EstimatePoint::NAME, vespalib::string("vespa.hitcollector.estimatepoint")); - EXPECT_EQUAL(hitcollector::EstimatePoint::DEFAULT_VALUE, 0xffffffffu); + EXPECT_EQ(hitcollector::EstimatePoint::NAME, vespalib::string("vespa.hitcollector.estimatepoint")); + EXPECT_EQ(hitcollector::EstimatePoint::DEFAULT_VALUE, 0xffffffffu); Properties p; - EXPECT_EQUAL(hitcollector::EstimatePoint::lookup(p), 0xffffffffu); + EXPECT_EQ(hitcollector::EstimatePoint::lookup(p), 0xffffffffu); p.add("vespa.hitcollector.estimatepoint", "50"); - EXPECT_EQUAL(hitcollector::EstimatePoint::lookup(p), 50u); + EXPECT_EQ(hitcollector::EstimatePoint::lookup(p), 50u); } { // vespa.hitcollector.estimatelimit - EXPECT_EQUAL(hitcollector::EstimateLimit::NAME, vespalib::string("vespa.hitcollector.estimatelimit")); - EXPECT_EQUAL(hitcollector::EstimateLimit::DEFAULT_VALUE, 0xffffffffu); + EXPECT_EQ(hitcollector::EstimateLimit::NAME, vespalib::string("vespa.hitcollector.estimatelimit")); + EXPECT_EQ(hitcollector::EstimateLimit::DEFAULT_VALUE, 0xffffffffu); Properties p; - EXPECT_EQUAL(hitcollector::EstimateLimit::lookup(p), 0xffffffffu); + EXPECT_EQ(hitcollector::EstimateLimit::lookup(p), 0xffffffffu); p.add("vespa.hitcollector.estimatelimit", "50"); - EXPECT_EQUAL(hitcollector::EstimateLimit::lookup(p), 50u); + EXPECT_EQ(hitcollector::EstimateLimit::lookup(p), 50u); } { // vespa.hitcollector.rankscoredroplimit - EXPECT_EQUAL(hitcollector::RankScoreDropLimit::NAME, vespalib::string("vespa.hitcollector.rankscoredroplimit")); - search::feature_t got1 = hitcollector::RankScoreDropLimit::DEFAULT_VALUE; - EXPECT_TRUE(got1 != got1); - Properties p; - search::feature_t got2= hitcollector::RankScoreDropLimit::lookup(p); - EXPECT_TRUE(got2 != got2); + EXPECT_EQ(vespalib::string("vespa.hitcollector.rankscoredroplimit"), hitcollector::FirstPhaseRankScoreDropLimit::NAME); + Properties p; + auto got2 = hitcollector::FirstPhaseRankScoreDropLimit::lookup(p); + EXPECT_EQ(std::optional<search::feature_t>(), got2); + got2 = hitcollector::FirstPhaseRankScoreDropLimit::lookup(p, std::nullopt); + EXPECT_EQ(std::optional<search::feature_t>(), got2); + got2 = hitcollector::FirstPhaseRankScoreDropLimit::lookup(p, 4.5); + EXPECT_EQ(std::optional<search::feature_t>(4.5), got2); p.add("vespa.hitcollector.rankscoredroplimit", "-123456789.12345"); - EXPECT_EQUAL(hitcollector::RankScoreDropLimit::lookup(p), -123456789.12345); + EXPECT_EQ(std::optional<search::feature_t>(-123456789.12345), hitcollector::FirstPhaseRankScoreDropLimit::lookup(p)); p.clear().add("vespa.hitcollector.rankscoredroplimit", "123456789.12345"); - EXPECT_EQUAL(hitcollector::RankScoreDropLimit::lookup(p), 123456789.12345); + EXPECT_EQ(std::optional<search::feature_t>(123456789.12345), hitcollector::FirstPhaseRankScoreDropLimit::lookup(p)); } { // vespa.fieldweight. - EXPECT_EQUAL(FieldWeight::BASE_NAME, vespalib::string("vespa.fieldweight.")); - EXPECT_EQUAL(FieldWeight::DEFAULT_VALUE, 100u); + EXPECT_EQ(FieldWeight::BASE_NAME, vespalib::string("vespa.fieldweight.")); + EXPECT_EQ(FieldWeight::DEFAULT_VALUE, 100u); Properties p; - EXPECT_EQUAL(FieldWeight::lookup(p, "foo"), 100u); + EXPECT_EQ(FieldWeight::lookup(p, "foo"), 100u); p.add("vespa.fieldweight.foo", "200"); - EXPECT_EQUAL(FieldWeight::lookup(p, "foo"), 200u); + EXPECT_EQ(FieldWeight::lookup(p, "foo"), 200u); } { // vespa.isfilterfield. - EXPECT_EQUAL(IsFilterField::BASE_NAME, "vespa.isfilterfield."); - EXPECT_EQUAL(IsFilterField::DEFAULT_VALUE, "false"); + EXPECT_EQ(IsFilterField::BASE_NAME, "vespa.isfilterfield."); + EXPECT_EQ(IsFilterField::DEFAULT_VALUE, "false"); Properties p; EXPECT_TRUE(!IsFilterField::check(p, "foo")); p.add("vespa.isfilterfield.foo", "true"); @@ -438,192 +442,206 @@ TEST("test stuff") { EXPECT_TRUE(IsFilterField::check(p, "bar")); } { - EXPECT_EQUAL(mutate::on_match::Attribute::NAME, vespalib::string("vespa.mutate.on_match.attribute")); - EXPECT_EQUAL(mutate::on_match::Attribute::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_match::Attribute::NAME, vespalib::string("vespa.mutate.on_match.attribute")); + EXPECT_EQ(mutate::on_match::Attribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_match::Attribute::lookup(p), ""); + EXPECT_EQ(mutate::on_match::Attribute::lookup(p), ""); p.add("vespa.mutate.on_match.attribute", "foobar"); - EXPECT_EQUAL(mutate::on_match::Attribute::lookup(p), "foobar"); + EXPECT_EQ(mutate::on_match::Attribute::lookup(p), "foobar"); } { - EXPECT_EQUAL(mutate::on_match::Operation::NAME, vespalib::string("vespa.mutate.on_match.operation")); - EXPECT_EQUAL(mutate::on_match::Operation::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_match::Operation::NAME, vespalib::string("vespa.mutate.on_match.operation")); + EXPECT_EQ(mutate::on_match::Operation::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_match::Operation::lookup(p), ""); + EXPECT_EQ(mutate::on_match::Operation::lookup(p), ""); p.add("vespa.mutate.on_match.operation", "+=1"); - EXPECT_EQUAL(mutate::on_match::Operation::lookup(p), "+=1"); + EXPECT_EQ(mutate::on_match::Operation::lookup(p), "+=1"); } { - EXPECT_EQUAL(mutate::on_first_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_first_phase.attribute")); - EXPECT_EQUAL(mutate::on_first_phase::Attribute::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_first_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_first_phase.attribute")); + EXPECT_EQ(mutate::on_first_phase::Attribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_first_phase::Attribute::lookup(p), ""); + EXPECT_EQ(mutate::on_first_phase::Attribute::lookup(p), ""); p.add("vespa.mutate.on_first_phase.attribute", "foobar"); - EXPECT_EQUAL(mutate::on_first_phase::Attribute::lookup(p), "foobar"); + EXPECT_EQ(mutate::on_first_phase::Attribute::lookup(p), "foobar"); } { - EXPECT_EQUAL(mutate::on_first_phase::Operation::NAME, vespalib::string("vespa.mutate.on_first_phase.operation")); - EXPECT_EQUAL(mutate::on_first_phase::Operation::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_first_phase::Operation::NAME, vespalib::string("vespa.mutate.on_first_phase.operation")); + EXPECT_EQ(mutate::on_first_phase::Operation::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_first_phase::Operation::lookup(p), ""); + EXPECT_EQ(mutate::on_first_phase::Operation::lookup(p), ""); p.add("vespa.mutate.on_first_phase.operation", "+=1"); - EXPECT_EQUAL(mutate::on_first_phase::Operation::lookup(p), "+=1"); + EXPECT_EQ(mutate::on_first_phase::Operation::lookup(p), "+=1"); } { - EXPECT_EQUAL(mutate::on_second_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_second_phase.attribute")); - EXPECT_EQUAL(mutate::on_second_phase::Attribute::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_second_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_second_phase.attribute")); + EXPECT_EQ(mutate::on_second_phase::Attribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_second_phase::Attribute::lookup(p), ""); + EXPECT_EQ(mutate::on_second_phase::Attribute::lookup(p), ""); p.add("vespa.mutate.on_second_phase.attribute", "foobar"); - EXPECT_EQUAL(mutate::on_second_phase::Attribute::lookup(p), "foobar"); + EXPECT_EQ(mutate::on_second_phase::Attribute::lookup(p), "foobar"); } { - EXPECT_EQUAL(mutate::on_second_phase::Operation::NAME, vespalib::string("vespa.mutate.on_second_phase.operation")); - EXPECT_EQUAL(mutate::on_second_phase::Operation::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_second_phase::Operation::NAME, vespalib::string("vespa.mutate.on_second_phase.operation")); + EXPECT_EQ(mutate::on_second_phase::Operation::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_second_phase::Operation::lookup(p), ""); + EXPECT_EQ(mutate::on_second_phase::Operation::lookup(p), ""); p.add("vespa.mutate.on_second_phase.operation", "+=1"); - EXPECT_EQUAL(mutate::on_second_phase::Operation::lookup(p), "+=1"); + EXPECT_EQ(mutate::on_second_phase::Operation::lookup(p), "+=1"); } { - EXPECT_EQUAL(mutate::on_summary::Attribute::NAME, vespalib::string("vespa.mutate.on_summary.attribute")); - EXPECT_EQUAL(mutate::on_summary::Attribute::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_summary::Attribute::NAME, vespalib::string("vespa.mutate.on_summary.attribute")); + EXPECT_EQ(mutate::on_summary::Attribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_summary::Attribute::lookup(p), ""); + EXPECT_EQ(mutate::on_summary::Attribute::lookup(p), ""); p.add("vespa.mutate.on_summary.attribute", "foobar"); - EXPECT_EQUAL(mutate::on_summary::Attribute::lookup(p), "foobar"); + EXPECT_EQ(mutate::on_summary::Attribute::lookup(p), "foobar"); } { - EXPECT_EQUAL(mutate::on_summary::Operation::NAME, vespalib::string("vespa.mutate.on_summary.operation")); - EXPECT_EQUAL(mutate::on_summary::Operation::DEFAULT_VALUE, ""); + EXPECT_EQ(mutate::on_summary::Operation::NAME, vespalib::string("vespa.mutate.on_summary.operation")); + EXPECT_EQ(mutate::on_summary::Operation::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(mutate::on_summary::Operation::lookup(p), ""); + EXPECT_EQ(mutate::on_summary::Operation::lookup(p), ""); p.add("vespa.mutate.on_summary.operation", "+=1"); - EXPECT_EQUAL(mutate::on_summary::Operation::lookup(p), "+=1"); + EXPECT_EQ(mutate::on_summary::Operation::lookup(p), "+=1"); } { - EXPECT_EQUAL(execute::onmatch::Attribute::NAME, vespalib::string("vespa.execute.onmatch.attribute")); - EXPECT_EQUAL(execute::onmatch::Attribute::DEFAULT_VALUE, ""); + EXPECT_EQ(execute::onmatch::Attribute::NAME, vespalib::string("vespa.execute.onmatch.attribute")); + EXPECT_EQ(execute::onmatch::Attribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(execute::onmatch::Attribute::lookup(p), ""); + EXPECT_EQ(execute::onmatch::Attribute::lookup(p), ""); p.add("vespa.execute.onmatch.attribute", "foobar"); - EXPECT_EQUAL(execute::onmatch::Attribute::lookup(p), "foobar"); + EXPECT_EQ(execute::onmatch::Attribute::lookup(p), "foobar"); } { - EXPECT_EQUAL(execute::onmatch::Operation::NAME, vespalib::string("vespa.execute.onmatch.operation")); - EXPECT_EQUAL(execute::onmatch::Operation::DEFAULT_VALUE, ""); + EXPECT_EQ(execute::onmatch::Operation::NAME, vespalib::string("vespa.execute.onmatch.operation")); + EXPECT_EQ(execute::onmatch::Operation::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(execute::onmatch::Operation::lookup(p), ""); + EXPECT_EQ(execute::onmatch::Operation::lookup(p), ""); p.add("vespa.execute.onmatch.operation", "++"); - EXPECT_EQUAL(execute::onmatch::Operation::lookup(p), "++"); + EXPECT_EQ(execute::onmatch::Operation::lookup(p), "++"); } { - EXPECT_EQUAL(execute::onrerank::Attribute::NAME, vespalib::string("vespa.execute.onrerank.attribute")); - EXPECT_EQUAL(execute::onrerank::Attribute::DEFAULT_VALUE, ""); + EXPECT_EQ(execute::onrerank::Attribute::NAME, vespalib::string("vespa.execute.onrerank.attribute")); + EXPECT_EQ(execute::onrerank::Attribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(execute::onrerank::Attribute::lookup(p), ""); + EXPECT_EQ(execute::onrerank::Attribute::lookup(p), ""); p.add("vespa.execute.onrerank.attribute", "foobar"); - EXPECT_EQUAL(execute::onrerank::Attribute::lookup(p), "foobar"); + EXPECT_EQ(execute::onrerank::Attribute::lookup(p), "foobar"); } { - EXPECT_EQUAL(execute::onrerank::Operation::NAME, vespalib::string("vespa.execute.onrerank.operation")); - EXPECT_EQUAL(execute::onrerank::Operation::DEFAULT_VALUE, ""); + EXPECT_EQ(execute::onrerank::Operation::NAME, vespalib::string("vespa.execute.onrerank.operation")); + EXPECT_EQ(execute::onrerank::Operation::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(execute::onrerank::Operation::lookup(p), ""); + EXPECT_EQ(execute::onrerank::Operation::lookup(p), ""); p.add("vespa.execute.onrerank.operation", "++"); - EXPECT_EQUAL(execute::onrerank::Operation::lookup(p), "++"); + EXPECT_EQ(execute::onrerank::Operation::lookup(p), "++"); } { - EXPECT_EQUAL(execute::onsummary::Attribute::NAME, vespalib::string("vespa.execute.onsummary.attribute")); - EXPECT_EQUAL(execute::onsummary::Attribute::DEFAULT_VALUE, ""); + EXPECT_EQ(execute::onsummary::Attribute::NAME, vespalib::string("vespa.execute.onsummary.attribute")); + EXPECT_EQ(execute::onsummary::Attribute::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(execute::onsummary::Attribute::lookup(p), ""); + EXPECT_EQ(execute::onsummary::Attribute::lookup(p), ""); p.add("vespa.execute.onsummary.attribute", "foobar"); - EXPECT_EQUAL(execute::onsummary::Attribute::lookup(p), "foobar"); + EXPECT_EQ(execute::onsummary::Attribute::lookup(p), "foobar"); } { - EXPECT_EQUAL(execute::onsummary::Operation::NAME, vespalib::string("vespa.execute.onsummary.operation")); - EXPECT_EQUAL(execute::onsummary::Operation::DEFAULT_VALUE, ""); + EXPECT_EQ(execute::onsummary::Operation::NAME, vespalib::string("vespa.execute.onsummary.operation")); + EXPECT_EQ(execute::onsummary::Operation::DEFAULT_VALUE, ""); Properties p; - EXPECT_EQUAL(execute::onsummary::Operation::lookup(p), ""); + EXPECT_EQ(execute::onsummary::Operation::lookup(p), ""); p.add("vespa.execute.onsummary.operation", "++"); - EXPECT_EQUAL(execute::onsummary::Operation::lookup(p), "++"); + EXPECT_EQ(execute::onsummary::Operation::lookup(p), "++"); } { - EXPECT_EQUAL(softtimeout::Enabled::NAME, vespalib::string("vespa.softtimeout.enable")); + EXPECT_EQ(softtimeout::Enabled::NAME, vespalib::string("vespa.softtimeout.enable")); EXPECT_TRUE(softtimeout::Enabled::DEFAULT_VALUE); Properties p; p.add(softtimeout::Enabled::NAME, "false"); EXPECT_FALSE(softtimeout::Enabled::lookup(p)); } { - EXPECT_EQUAL(softtimeout::Factor::NAME, vespalib::string("vespa.softtimeout.factor")); - EXPECT_EQUAL(0.5, softtimeout::Factor::DEFAULT_VALUE); + EXPECT_EQ(softtimeout::Factor::NAME, vespalib::string("vespa.softtimeout.factor")); + EXPECT_EQ(0.5, softtimeout::Factor::DEFAULT_VALUE); Properties p; p.add(softtimeout::Factor::NAME, "0.33"); - EXPECT_EQUAL(0.33, softtimeout::Factor::lookup(p)); + EXPECT_EQ(0.33, softtimeout::Factor::lookup(p)); } { - EXPECT_EQUAL(softtimeout::TailCost::NAME, vespalib::string("vespa.softtimeout.tailcost")); - EXPECT_EQUAL(0.1, softtimeout::TailCost::DEFAULT_VALUE); + EXPECT_EQ(softtimeout::TailCost::NAME, vespalib::string("vespa.softtimeout.tailcost")); + EXPECT_EQ(0.1, softtimeout::TailCost::DEFAULT_VALUE); Properties p; p.add(softtimeout::TailCost::NAME, "0.17"); - EXPECT_EQUAL(0.17, softtimeout::TailCost::lookup(p)); + EXPECT_EQ(0.17, softtimeout::TailCost::lookup(p)); } } } -TEST("test attribute type properties") +TEST(PropertiesTest, test_attribute_type_properties) { Properties p; p.add("vespa.type.attribute.foo", "tensor(x[10])"); - EXPECT_EQUAL("tensor(x[10])", type::Attribute::lookup(p, "foo")); - EXPECT_EQUAL("", type::Attribute::lookup(p, "bar")); + EXPECT_EQ("tensor(x[10])", type::Attribute::lookup(p, "foo")); + EXPECT_EQ("", type::Attribute::lookup(p, "bar")); } -TEST("test query feature type properties") +TEST(PropertiesTest, test_query_feature_type_properties) { Properties p; p.add("vespa.type.query.foo", "tensor(x[10])"); - EXPECT_EQUAL("tensor(x[10])", type::QueryFeature::lookup(p, "foo")); - EXPECT_EQUAL("", type::QueryFeature::lookup(p, "bar")); + EXPECT_EQ("tensor(x[10])", type::QueryFeature::lookup(p, "foo")); + EXPECT_EQ("", type::QueryFeature::lookup(p, "bar")); } -TEST("test integer lookup") +TEST(PropertiesTest, test_integer_lookup) { - EXPECT_EQUAL(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch")); - EXPECT_EQUAL(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max()); + EXPECT_EQ(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch")); + EXPECT_EQ(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max()); { Properties p; p.add("vespa.matching.numthreadspersearch", "50"); - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u); } { Properties p; p.add("vespa.matching.numthreadspersearch", "50 "); - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u); } { Properties p; p.add("vespa.matching.numthreadspersearch", " 50"); - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u); } { Properties p; p.add("vespa.matching.numthreadspersearch", " "); - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE); } { Properties p; p.add("vespa.matching.numthreadspersearch", "50x"); - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u); } { Properties p; p.add("vespa.matching.numthreadspersearch", "x"); - EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE); + EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE); } } +TEST(PropertiesTest, second_phase_rank_score_drop_limit) +{ + vespalib::stringref name = hitcollector::SecondPhaseRankScoreDropLimit::NAME; + EXPECT_EQ(vespalib::string("vespa.hitcollector.secondphase.rankscoredroplimit"), name); + Properties p; + EXPECT_EQ(std::optional<search::feature_t>(), hitcollector::SecondPhaseRankScoreDropLimit::lookup(p)); + EXPECT_EQ(std::optional<search::feature_t>(4.0), hitcollector::SecondPhaseRankScoreDropLimit::lookup(p, 4.0)); + p.add(name, "-123456789.12345"); + EXPECT_EQ(std::optional<search::feature_t>(-123456789.12345), hitcollector::SecondPhaseRankScoreDropLimit::lookup(p)); + EXPECT_EQ(std::optional<search::feature_t>(-123456789.12345), hitcollector::SecondPhaseRankScoreDropLimit::lookup(p, 4.0)); + p.clear().add(name, "123456789.12345"); + EXPECT_EQ(std::optional<search::feature_t>(123456789.12345), hitcollector::SecondPhaseRankScoreDropLimit::lookup(p)); + EXPECT_EQ(std::optional<search::feature_t>(123456789.12345), hitcollector::SecondPhaseRankScoreDropLimit::lookup(p, 4.0)); +} -TEST_MAIN() { TEST_RUN_ALL(); } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/fef/rank_program/CMakeLists.txt b/searchlib/src/tests/fef/rank_program/CMakeLists.txt index 2956e9ccfd8..23e5ff007fc 100644 --- a/searchlib/src/tests/fef/rank_program/CMakeLists.txt +++ b/searchlib/src/tests/fef/rank_program/CMakeLists.txt @@ -3,6 +3,6 @@ vespa_add_executable(searchlib_rank_program_test_app TEST SOURCES rank_program_test.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_rank_program_test_app COMMAND searchlib_rank_program_test_app) diff --git a/searchlib/src/tests/fef/resolver/CMakeLists.txt b/searchlib/src/tests/fef/resolver/CMakeLists.txt index 107b2daf46a..8c7f806a1a6 100644 --- a/searchlib/src/tests/fef/resolver/CMakeLists.txt +++ b/searchlib/src/tests/fef/resolver/CMakeLists.txt @@ -3,6 +3,6 @@ vespa_add_executable(searchlib_resolver_test_app TEST SOURCES resolver_test.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_resolver_test_app COMMAND searchlib_resolver_test_app) diff --git a/searchlib/src/tests/fef/table/CMakeLists.txt b/searchlib/src/tests/fef/table/CMakeLists.txt index 6cc6856e0ce..c7408da325d 100644 --- a/searchlib/src/tests/fef/table/CMakeLists.txt +++ b/searchlib/src/tests/fef/table/CMakeLists.txt @@ -3,6 +3,7 @@ vespa_add_executable(searchlib_table_test_app TEST SOURCES table_test.cpp DEPENDS - searchlib + vespa_searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_table_test_app COMMAND searchlib_table_test_app) diff --git a/searchlib/src/tests/fef/table/table_test.cpp b/searchlib/src/tests/fef/table/table_test.cpp index b0a47a8bdbc..9c15274c093 100644 --- a/searchlib/src/tests/fef/table/table_test.cpp +++ b/searchlib/src/tests/fef/table/table_test.cpp @@ -1,18 +1,21 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/searchlib/fef/filetablefactory.h> #include <vespa/searchlib/fef/functiontablefactory.h> #include <vespa/searchlib/fef/tablemanager.h> +#include <vespa/vespalib/gtest/gtest.h> +#include <vespa/vespalib/testkit/test_path.h> #include <fstream> #include <iostream> -namespace search { -namespace fef { +namespace search::fef { -class TableTest : public vespalib::TestApp +class TableTest : public ::testing::Test { -private: +protected: + const std::string _tables1Dir; + const std::string _tables2Dir; + bool assertTable(const Table & act, const Table & exp); bool assertCreateTable(const ITableFactory & tf, const vespalib::string & name, const Table & exp); void testTable(); @@ -20,29 +23,32 @@ private: void testFunctionTableFactory(); void testTableManager(); - const std::string _tables1Dir; - const std::string _tables2Dir; -public: TableTest(); - ~TableTest(); - int Main() override; + ~TableTest() override; }; -TableTest::TableTest() : - vespalib::TestApp(), - _tables1Dir(TEST_PATH("tables1")), - _tables2Dir(TEST_PATH("tables2")) +TableTest::TableTest() + : ::testing::Test(), + _tables1Dir(TEST_PATH("tables1")), + _tables2Dir(TEST_PATH("tables2")) { } -TableTest::~TableTest() {} +TableTest::~TableTest() = default; bool TableTest::assertTable(const Table & act, const Table & exp) { - if (!EXPECT_EQUAL(act.size(), exp.size())) return false; + bool failed = false; + EXPECT_EQ(act.size(), exp.size()) << (failed = true, ""); + if (failed) { + return false; + } for (size_t i = 0; i < act.size(); ++i) { - if (!EXPECT_APPROX(act[i], exp[i], 0.01)) return false; + EXPECT_NEAR(act[i], exp[i], 0.01) << (failed = true, ""); + if (failed) { + return false; + } } return true; } @@ -51,33 +57,35 @@ bool TableTest::assertCreateTable(const ITableFactory & tf, const vespalib::string & name, const Table & exp) { Table::SP t = tf.createTable(name); - if (!EXPECT_TRUE(t.get() != NULL)) return false; + bool failed = false; + EXPECT_TRUE(t.get() != nullptr) << (failed = true, ""); + if (failed) { + return false; + } return assertTable(*t, exp); } -void -TableTest::testTable() +TEST_F(TableTest, table) { Table t; - EXPECT_EQUAL(t.size(), 0u); - EXPECT_EQUAL(t.max(), -std::numeric_limits<double>::max()); + EXPECT_EQ(t.size(), 0u); + EXPECT_EQ(t.max(), -std::numeric_limits<double>::max()); t.add(1).add(2); - EXPECT_EQUAL(t.size(), 2u); - EXPECT_EQUAL(t.max(), 2); - EXPECT_EQUAL(t[0], 1); - EXPECT_EQUAL(t[1], 2); + EXPECT_EQ(t.size(), 2u); + EXPECT_EQ(t.max(), 2); + EXPECT_EQ(t[0], 1); + EXPECT_EQ(t[1], 2); t.add(10); - EXPECT_EQUAL(t.size(), 3u); - EXPECT_EQUAL(t.max(), 10); - EXPECT_EQUAL(t[2], 10); + EXPECT_EQ(t.size(), 3u); + EXPECT_EQ(t.max(), 10); + EXPECT_EQ(t[2], 10); t.add(5); - EXPECT_EQUAL(t.size(), 4u); - EXPECT_EQUAL(t.max(), 10); - EXPECT_EQUAL(t[3], 5); + EXPECT_EQ(t.size(), 4u); + EXPECT_EQ(t.max(), 10); + EXPECT_EQ(t[3], 5); } -void -TableTest::testFileTableFactory() +TEST_F(TableTest, file_table_factory) { { FileTableFactory ftf(_tables1Dir); @@ -90,8 +98,7 @@ TableTest::testFileTableFactory() } } -void -TableTest::testFunctionTableFactory() +TEST_F(TableTest, function_table_factory) { FunctionTableFactory ftf(2); EXPECT_TRUE(assertCreateTable(ftf, "expdecay(400,12)", @@ -117,8 +124,7 @@ TableTest::testFunctionTableFactory() EXPECT_TRUE(ftf.createTable("none)(").get() == NULL); } -void -TableTest::testTableManager() +TEST_F(TableTest, table_manager) { { TableManager tm; @@ -148,20 +154,6 @@ TableTest::testTableManager() } } -int -TableTest::Main() -{ - TEST_INIT("table_test"); - - testTable(); - testFileTableFactory(); - testFunctionTableFactory(); - testTableManager(); - - TEST_DONE(); -} - -} } -TEST_APPHOOK(search::fef::TableTest); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/fef/termfieldmodel/CMakeLists.txt b/searchlib/src/tests/fef/termfieldmodel/CMakeLists.txt index 70c3b952e49..3dc46b06b19 100644 --- a/searchlib/src/tests/fef/termfieldmodel/CMakeLists.txt +++ b/searchlib/src/tests/fef/termfieldmodel/CMakeLists.txt @@ -3,6 +3,6 @@ vespa_add_executable(searchlib_termfieldmodel_test_app TEST SOURCES termfieldmodel_test.cpp DEPENDS - searchlib + vespa_searchlib ) vespa_add_test(NAME searchlib_termfieldmodel_test_app COMMAND searchlib_termfieldmodel_test_app) diff --git a/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp b/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp index e8eec096cd4..b6a01f23949 100644 --- a/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp +++ b/searchlib/src/tests/fef/termfieldmodel/termfieldmodel_test.cpp @@ -261,14 +261,14 @@ TEST("Access subqueries") { testSetup(state); state.f3->reset(10); state.f3->setSubqueries(10, 42); - EXPECT_EQUAL(42ULL, state.f3->getSubqueries()); + EXPECT_EQUAL(42UL, state.f3->getSubqueries()); state.f3->enableRawScore(); - EXPECT_EQUAL(0ULL, state.f3->getSubqueries()); + EXPECT_EQUAL(0UL, state.f3->getSubqueries()); state.f3->reset(11); state.f3->appendPosition(TermFieldMatchDataPosition()); state.f3->setSubqueries(11, 42); - EXPECT_EQUAL(0ULL, state.f3->getSubqueries()); + EXPECT_EQUAL(0UL, state.f3->getSubqueries()); } TEST("require that TermFieldMatchData can be tagged as needed or not") { diff --git a/searchlib/src/tests/fef/termmatchdatamerger/CMakeLists.txt b/searchlib/src/tests/fef/termmatchdatamerger/CMakeLists.txt index fc4de86cc24..d757999def0 100644 --- a/searchlib/src/tests/fef/termmatchdatamerger/CMakeLists.txt +++ b/searchlib/src/tests/fef/termmatchdatamerger/CMakeLists.txt @@ -3,7 +3,7 @@ vespa_add_executable(searchlib_termmatchdatamerger_test_app TEST SOURCES termmatchdatamerger_test.cpp DEPENDS - searchlib + vespa_searchlib GTest::GTest ) vespa_add_test(NAME searchlib_termmatchdatamerger_test_app COMMAND searchlib_termmatchdatamerger_test_app) |