diff options
Diffstat (limited to 'searchlib')
23 files changed, 723 insertions, 630 deletions
diff --git a/searchlib/src/apps/tests/CMakeLists.txt b/searchlib/src/apps/tests/CMakeLists.txt index af48f379f37..883f343cc30 100644 --- a/searchlib/src/apps/tests/CMakeLists.txt +++ b/searchlib/src/apps/tests/CMakeLists.txt @@ -4,6 +4,7 @@ vespa_add_executable(searchlib_biglog_test_app biglogtest.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_biglog_test_app COMMAND searchlib_biglog_test_app BENCHMARK) vespa_add_executable(searchlib_memoryindexstress_test_app diff --git a/searchlib/src/apps/tests/biglogtest.cpp b/searchlib/src/apps/tests/biglogtest.cpp index 6106a0b7585..9f5fa581549 100644 --- a/searchlib/src/apps/tests/biglogtest.cpp +++ b/searchlib/src/apps/tests/biglogtest.cpp @@ -1,62 +1,70 @@ // 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/util/random.h> #include <vespa/searchlib/docstore/logdatastore.h> #include <vespa/searchlib/index/dummyfileheadercontext.h> #include <vespa/searchlib/transactionlog/nosyncproxy.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/vespalib/util/size_literals.h> #include <vespa/vespalib/util/threadstackexecutor.h> #include <vespa/vespalib/data/databuffer.h> #include <filesystem> +#include <memory> using namespace search; using search::index::DummyFileHeaderContext; -class Test : public vespalib::TestApp { +class BigLogTest : public ::testing::Test { private: struct Blob { ssize_t sz; - char *buf; - Blob(size_t s) : sz(s), buf(s == 0 ? 0 : new char[s]) {} + std::unique_ptr<char[]> buf; + Blob(size_t s) : sz(s), buf(s == 0 ? nullptr : new char[s]) {} }; using Map = std::map<uint32_t, uint32_t>; - void makeBlobs(); - void cleanBlobs(); + static void makeBlobs(); + static void cleanBlobs(); void checkBlobs(const IDataStore &datastore, const Map &lidToBlobMap); + std::string _dir; + static std::vector<Blob> _blobs; + static vespalib::RandomGen _randomgenerator; + +protected: template <typename DS> void testDIO(); - std::string _dir; - std::vector<Blob> _blobs; - vespalib::RandomGen _randomgenerator; - public: - int Main() override { - TEST_INIT("big_logdatastore_test"); - - if (_argc > 0) { - DummyFileHeaderContext::setCreator(_argv[0]); - } - makeBlobs(); + BigLogTest(); + ~BigLogTest() override; + static void SetUpTestSuite(); + static void TearDownTestSuite(); +}; - _dir = "logged"; - TEST_DO(testDIO<LogDataStore>()); +std::vector<BigLogTest::Blob> BigLogTest::_blobs; +vespalib::RandomGen BigLogTest::_randomgenerator(42); - cleanBlobs(); +BigLogTest::BigLogTest() + : _dir("logged") +{ +} - TEST_DONE(); - } +BigLogTest::~BigLogTest() = default; - Test() : _dir(""), _blobs(), _randomgenerator(42) {} - ~Test() {} -}; +void +BigLogTest::SetUpTestSuite() +{ + makeBlobs(); +} -TEST_APPHOOK(Test); +void +BigLogTest::TearDownTestSuite() +{ + cleanBlobs(); +} void -Test::makeBlobs() +BigLogTest::makeBlobs() { _randomgenerator.setSeed(42); _blobs.push_back(Blob(0)); @@ -66,7 +74,7 @@ Test::makeBlobs() size_t blobsize = _randomgenerator.nextUint32() % (1<<sizeclass); if (blobsize > usemem) blobsize = usemem; _blobs.push_back(Blob(blobsize)); - char *p = _blobs.back().buf; + char *p = _blobs.back().buf.get(); for (size_t j=0; j < blobsize; ++j) { *p++ = _randomgenerator.nextUint32(); } @@ -75,22 +83,19 @@ Test::makeBlobs() } void -Test::cleanBlobs() +BigLogTest::cleanBlobs() { printf("count %lu blobs sizes:", _blobs.size()); while (_blobs.size() > 0) { - char *p = _blobs.back().buf; printf(" %lu", _blobs.back().sz); - delete[] p; _blobs.pop_back(); } printf("\n"); } - void -Test::checkBlobs(const IDataStore &datastore, - const Map &lidToBlobMap) +BigLogTest::checkBlobs(const IDataStore &datastore, + const Map &lidToBlobMap) { for (Map::const_iterator it = lidToBlobMap.begin(); it != lidToBlobMap.end(); @@ -99,8 +104,8 @@ Test::checkBlobs(const IDataStore &datastore, uint32_t lid = it->first; uint32_t bno = it->second; vespalib::DataBuffer got; - EXPECT_EQUAL(datastore.read(lid, got), _blobs[bno].sz); - EXPECT_TRUE(memcmp(got.getData(), _blobs[bno].buf, _blobs[bno].sz) == 0); + EXPECT_EQ(_blobs[bno].sz, datastore.read(lid, got)); + EXPECT_EQ(0, memcmp(got.getData(), _blobs[bno].buf.get(), _blobs[bno].sz)); } } @@ -144,7 +149,7 @@ factory<LogDataStore>::~factory() {} template <typename DS> void -Test::testDIO() +BigLogTest::testDIO() { uint64_t serial = 0; @@ -158,14 +163,14 @@ Test::testDIO() for (uint32_t lid=0; lid<15; ++lid) { uint32_t blobno = _randomgenerator.nextUint32() % _blobs.size(); lidToBlobMap[lid] = blobno; - ds().write(++serial, lid, _blobs[blobno].buf, _blobs[blobno].sz); + ds().write(++serial, lid, _blobs[blobno].buf.get(), _blobs[blobno].sz); } uint64_t flushToken = ds().initFlush(serial); ds().flush(flushToken); for (uint32_t lid=10; lid<30; ++lid) { uint32_t blobno = _randomgenerator.nextUint32() % _blobs.size(); lidToBlobMap[lid] = blobno; - ds().write(++serial, lid, _blobs[blobno].buf, _blobs[blobno].sz); + ds().write(++serial, lid, _blobs[blobno].buf.get(), _blobs[blobno].sz); } checkBlobs(ds(), lidToBlobMap); flushToken = ds().initFlush(serial); @@ -179,17 +184,17 @@ Test::testDIO() for (uint32_t lid=3; lid<8; ++lid) { uint32_t blobno = _randomgenerator.nextUint32() % _blobs.size(); lidToBlobMap[lid] = blobno; - ds().write(++serial, lid, _blobs[blobno].buf, _blobs[blobno].sz); + ds().write(++serial, lid, _blobs[blobno].buf.get(), _blobs[blobno].sz); } for (uint32_t lid=23; lid<28; ++lid) { uint32_t blobno = _randomgenerator.nextUint32() % _blobs.size(); lidToBlobMap[lid] = blobno; - ds().write(++serial, lid, _blobs[blobno].buf, _blobs[blobno].sz); + ds().write(++serial, lid, _blobs[blobno].buf.get(), _blobs[blobno].sz); } for (uint32_t lid=100033; lid<100088; ++lid) { uint32_t blobno = _randomgenerator.nextUint32() % _blobs.size(); lidToBlobMap[lid] = blobno; - ds().write(++serial, lid, _blobs[blobno].buf, _blobs[blobno].sz); + ds().write(++serial, lid, _blobs[blobno].buf.get(), _blobs[blobno].sz); } checkBlobs(ds(), lidToBlobMap); @@ -226,7 +231,7 @@ Test::testDIO() for (uint32_t lid=1234567; lid < 1234999; ++lid) { uint32_t blobno = _randomgenerator.nextUint32() % _blobs.size(); lidToBlobMap[lid] = blobno; - ds().write(++serial, lid, _blobs[blobno].buf, _blobs[blobno].sz); + ds().write(++serial, lid, _blobs[blobno].buf.get(), _blobs[blobno].sz); } checkBlobs(ds(), lidToBlobMap); uint64_t flushToken = ds().initFlush(22); @@ -238,5 +243,19 @@ Test::testDIO() checkBlobs(ds(), lidToBlobMap); } std::filesystem::remove_all(std::filesystem::path(_dir)); - TEST_FLUSH(); +} + +TEST_F(BigLogTest, logdatastore_dio) +{ + testDIO<LogDataStore>(); +} + +int +main(int argc, char* argv[]) +{ + ::testing::InitGoogleTest(&argc, argv); + if (argc > 0) { + DummyFileHeaderContext::setCreator(argv[0]); + } + return RUN_ALL_TESTS(); } diff --git a/searchlib/src/tests/features/element_similarity_feature/CMakeLists.txt b/searchlib/src/tests/features/element_similarity_feature/CMakeLists.txt index 748556b0fcd..7703d9be0c6 100644 --- a/searchlib/src/tests/features/element_similarity_feature/CMakeLists.txt +++ b/searchlib/src/tests/features/element_similarity_feature/CMakeLists.txt @@ -6,4 +6,4 @@ vespa_add_executable(searchlib_element_similarity_feature_test_app TEST searchlib searchlib_test ) -vespa_add_test(NAME searchlib_element_similarity_feature_test_app COMMAND searchlib_element_similarity_feature_test_app) +vespa_add_test(NAME searchlib_element_similarity_feature_test_app COMMAND searchlib_element_similarity_feature_test_app COST 50) 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 e7523288e8f..82e227e0d35 100644 --- a/searchlib/src/tests/features/euclidean_distance/euclidean_distance_test.cpp +++ b/searchlib/src/tests/features/euclidean_distance/euclidean_distance_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/searchcommon/attribute/config.h> #include <vespa/searchlib/attribute/attributefactory.h> 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..d0abf5bd377 100644 --- a/searchlib/src/tests/fef/properties/CMakeLists.txt +++ b/searchlib/src/tests/fef/properties/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_properties_test_app TEST properties_test.cpp DEPENDS 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/table/CMakeLists.txt b/searchlib/src/tests/fef/table/CMakeLists.txt index 6cc6856e0ce..2353fd50c95 100644 --- a/searchlib/src/tests/fef/table/CMakeLists.txt +++ b/searchlib/src/tests/fef/table/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_table_test_app TEST table_test.cpp DEPENDS 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/hitcollector/hitcollector_test.cpp b/searchlib/src/tests/hitcollector/hitcollector_test.cpp index 60daa571f1d..784afea7801 100644 --- a/searchlib/src/tests/hitcollector/hitcollector_test.cpp +++ b/searchlib/src/tests/hitcollector/hitcollector_test.cpp @@ -585,6 +585,7 @@ struct RankDropFixture { _hc(docid_limit, max_hits_size) { } + ~RankDropFixture(); void add(std::vector<RankedHit> hits) { for (const auto& hit : hits) { _hc.addHit(hit.getDocId(), hit.getRank()); @@ -619,6 +620,8 @@ struct RankDropFixture { } }; +RankDropFixture::~RankDropFixture() = default; + TEST(HitCollectorTest, require_that_second_phase_rank_drop_limit_is_enforced) { // Track rank score for all 7 hits from first phase diff --git a/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp b/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp index b0234010f77..f7745da174c 100644 --- a/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp +++ b/searchlib/src/tests/queryeval/blueprint/blueprint_test.cpp @@ -648,6 +648,7 @@ getExpectedBlueprint() " strict_cost: 0\n" " sourceId: 4294967295\n" " docid_limit: 0\n" + " id: 0\n" " strict: false\n" " children: std::vector {\n" " [0]: (anonymous namespace)::MyTerm {\n" @@ -671,6 +672,7 @@ getExpectedBlueprint() " strict_cost: 0\n" " sourceId: 4294967295\n" " docid_limit: 0\n" + " id: 0\n" " strict: false\n" " }\n" " }\n" @@ -704,6 +706,7 @@ getExpectedSlimeBlueprint() { " strict_cost: 0.0," " sourceId: 4294967295," " docid_limit: 0," + " id: 0," " strict: false," " children: {" " '[type]': 'std::vector'," @@ -732,6 +735,7 @@ getExpectedSlimeBlueprint() { " strict_cost: 0.0," " sourceId: 4294967295," " docid_limit: 0," + " id: 0," " strict: false" " }" " }" @@ -842,6 +846,30 @@ TEST("self strict resolving during sort") { } } +void check_ids(Blueprint &bp, const std::vector<uint32_t> &expect) { + std::vector<uint32_t> actual; + bp.each_node_post_order([&](auto &node){ actual.push_back(node.id()); }); + ASSERT_EQUAL(actual.size(), expect.size()); + for (size_t i = 0; i < actual.size(); ++i) { + EXPECT_EQUAL(actual[i], expect[i]); + } +} + +TEST("blueprint node enumeration") { + auto a = std::make_unique<AndBlueprint>(); + a->addChild(std::make_unique<MyLeaf>()); + a->addChild(std::make_unique<MyLeaf>()); + auto b = std::make_unique<AndBlueprint>(); + b->addChild(std::make_unique<MyLeaf>()); + b->addChild(std::make_unique<MyLeaf>()); + auto root = std::make_unique<OrBlueprint>(); + root->addChild(std::move(a)); + root->addChild(std::move(b)); + TEST_DO(check_ids(*root, {0,0,0,0,0,0,0})); + root->enumerate(1); + TEST_DO(check_ids(*root, {3,4,2,6,7,5,1})); +} + TEST_MAIN() { TEST_DEBUG("lhs.out", "rhs.out"); TEST_RUN_ALL(); diff --git a/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp b/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp index 996cd448f44..1cec376b01c 100644 --- a/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp +++ b/searchlib/src/tests/queryeval/parallel_weak_and/parallel_weak_and_test.cpp @@ -635,6 +635,7 @@ TEST(ParallelWeakAndTest, require_that_asString_on_blueprint_works) " strict_cost: 0\n" " sourceId: 4294967295\n" " docid_limit: 0\n" + " id: 0\n" " strict: false\n" " _weights: std::vector {\n" " [0]: 5\n" @@ -661,6 +662,7 @@ TEST(ParallelWeakAndTest, require_that_asString_on_blueprint_works) " strict_cost: 0\n" " sourceId: 4294967295\n" " docid_limit: 0\n" + " id: 0\n" " strict: false\n" " }\n" " }\n" diff --git a/searchlib/src/tests/queryeval/termwise_eval/termwise_eval_test.cpp b/searchlib/src/tests/queryeval/termwise_eval/termwise_eval_test.cpp index 310c6d628e3..4d84dabf834 100644 --- a/searchlib/src/tests/queryeval/termwise_eval/termwise_eval_test.cpp +++ b/searchlib/src/tests/queryeval/termwise_eval/termwise_eval_test.cpp @@ -465,7 +465,7 @@ TEST(TermwiseEvalTest, require_that_termwise_evaluation_can_be_multi_level_but_n child->addChild(UP(new MyBlueprint({3}, true, 3))); my_or.addChild(std::move(child)); for (bool strict: {true, false}) { - my_or.basic_plan(strict, 100); + my_or.null_plan(strict, 100); EXPECT_EQ(my_or.createSearch(*md)->asString(), make_termwise(OR({ TERM({1}, strict), ORz({ TERM({2}, strict), TERM({3}, strict) }, strict) }, diff --git a/searchlib/src/tests/ranksetup/CMakeLists.txt b/searchlib/src/tests/ranksetup/CMakeLists.txt index d5eb349a6c7..8dc0ea98835 100644 --- a/searchlib/src/tests/ranksetup/CMakeLists.txt +++ b/searchlib/src/tests/ranksetup/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_ranksetup_test_app TEST ranksetup_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_ranksetup_test_app COMMAND searchlib_ranksetup_test_app) diff --git a/searchlib/src/tests/ranksetup/ranksetup_test.cpp b/searchlib/src/tests/ranksetup/ranksetup_test.cpp index 348326c3936..a5e7fed5685 100644 --- a/searchlib/src/tests/ranksetup/ranksetup_test.cpp +++ b/searchlib/src/tests/ranksetup/ranksetup_test.cpp @@ -1,7 +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/util/stringfmt.h> #include <vespa/searchlib/common/feature.h> #include <vespa/searchlib/attribute/attributeguard.h> @@ -36,6 +34,8 @@ #include <vespa/searchlib/fef/test/plugin/sum.h> #include <vespa/searchlib/fef/test/plugin/cfgvalue.h> #include <vespa/searchlib/fef/test/dummy_dependency_handler.h> +#include <vespa/vespalib/gtest/gtest.h> +#include <vespa/vespalib/util/stringfmt.h> #include <iostream> using namespace search::fef; @@ -220,9 +220,9 @@ FeatureDumper::dump() //----------------------------------------------------------------------------- // RankSetupTest //----------------------------------------------------------------------------- -class RankSetupTest : public vespalib::TestApp +class RankSetupTest : public ::testing::Test { -private: +protected: BlueprintFactory _factory; search::AttributeManager _manager; IndexEnvironment _indexEnv; @@ -230,14 +230,6 @@ private: RankEnvironment _rankEnv; DumpFeatureVisitor _visitor; - void testValueBlueprint(); - void testDoubleBlueprint(); - void testSumBlueprint(); - void testStaticRankBlueprint(); - void testChainBlueprint(); - void testCfgValueBlueprint(); - void testCompilation(); - void testRankSetup(); bool testExecution(const vespalib::string & initRank, feature_t initScore, const vespalib::string & finalRank = "", feature_t finalScore = 0.0f, uint32_t docId = 1); bool testExecution(const RankEnvironment &rankEnv, @@ -249,15 +241,52 @@ private: void checkFeatures(std::map<vespalib::string, feature_t> &exp, std::map<vespalib::string, feature_t> &actual); void testFeatureNormalization(); -public: RankSetupTest(); - ~RankSetupTest(); - int Main() override; + ~RankSetupTest() override; }; +RankSetupTest::RankSetupTest() + : _factory(), + _manager(), + _indexEnv(), + _queryEnv(), + _rankEnv(_factory, _indexEnv, _queryEnv), + _visitor() +{ + // register blueprints + setup_fef_test_plugin(_factory); + _factory.addPrototype(Blueprint::SP(new ValueBlueprint())); + _factory.addPrototype(Blueprint::SP(new RankingExpressionBlueprint())); + _factory.addPrototype(std::make_shared<SecondPhaseBlueprint>()); -void -RankSetupTest::testValueBlueprint() + // setup an original attribute manager with two attributes + search::attribute::Config cfg(search::attribute::BasicType::INT32, + search::attribute::CollectionType::SINGLE); + search::AttributeVector::SP av1 = + search::AttributeFactory::createAttribute("staticrank1", cfg); + search::AttributeVector::SP av2 = + search::AttributeFactory::createAttribute("staticrank2", cfg); + av1->addDocs(5); + av2->addDocs(5); + for (uint32_t i = 0; i < 5; ++i) { + (static_cast<search::IntegerAttribute *>(av1.get()))->update(i, i + 100); + (static_cast<search::IntegerAttribute *>(av2.get()))->update(i, i + 200); + } + av1->commit(); + av2->commit(); + _manager.add(av1); + _manager.add(av2); + + // set the index environment + _queryEnv.setIndexEnv(&_indexEnv); + + // set the manager + _queryEnv.overrideAttributeManager(&_manager); +} + +RankSetupTest::~RankSetupTest() = default; + +TEST_F(RankSetupTest, value_blueprint) { ValueBlueprint prototype; prototype.visitDumpFeatures(_indexEnv, _visitor); @@ -265,22 +294,22 @@ RankSetupTest::testValueBlueprint() Blueprint::UP bp = prototype.createInstance(); DummyDependencyHandler deps(*bp); bp->setName("value"); - EXPECT_EQUAL(bp->getName(), "value"); + EXPECT_EQ(bp->getName(), "value"); std::vector<vespalib::string> params; params.push_back("5.5"); params.push_back("10.5"); EXPECT_TRUE(bp->setup(_indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 0u); - EXPECT_EQUAL(deps.output.size(), 2u); - EXPECT_EQUAL(deps.output[0], "0"); - EXPECT_EQUAL(deps.output[1], "1"); + EXPECT_EQ(deps.input.size(), 0u); + EXPECT_EQ(deps.output.size(), 2u); + EXPECT_EQ(deps.output[0], "0"); + EXPECT_EQ(deps.output[1], "1"); vespalib::Stash stash; FeatureExecutor &fe = bp->createExecutor(_queryEnv, stash); ValueExecutor * vfe = static_cast<ValueExecutor *>(&fe); - EXPECT_EQUAL(vfe->getValues().size(), 2u); - EXPECT_EQUAL(vfe->getValues()[0], 5.5f); - EXPECT_EQUAL(vfe->getValues()[1], 10.5f); + EXPECT_EQ(vfe->getValues().size(), 2u); + EXPECT_EQ(vfe->getValues()[0], 5.5f); + EXPECT_EQ(vfe->getValues()[1], 10.5f); } { // invalid params Blueprint::UP bp = prototype.createInstance(); @@ -290,8 +319,7 @@ RankSetupTest::testValueBlueprint() } } -void -RankSetupTest::testDoubleBlueprint() +TEST_F(RankSetupTest, double_blueprint) { DoubleBlueprint prototype; prototype.visitDumpFeatures(_indexEnv, _visitor); @@ -302,17 +330,16 @@ RankSetupTest::testDoubleBlueprint() params.push_back("value(5.5).0"); params.push_back("value(10.5).0"); EXPECT_TRUE(bp->setup(_indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 2u); - EXPECT_EQUAL(deps.input[0], "value(5.5).0"); - EXPECT_EQUAL(deps.input[1], "value(10.5).0"); - EXPECT_EQUAL(deps.output.size(), 2u); - EXPECT_EQUAL(deps.output[0], "0"); - EXPECT_EQUAL(deps.output[1], "1"); + EXPECT_EQ(deps.input.size(), 2u); + EXPECT_EQ(deps.input[0], "value(5.5).0"); + EXPECT_EQ(deps.input[1], "value(10.5).0"); + EXPECT_EQ(deps.output.size(), 2u); + EXPECT_EQ(deps.output[0], "0"); + EXPECT_EQ(deps.output[1], "1"); } } -void -RankSetupTest::testSumBlueprint() +TEST_F(RankSetupTest, sum_blueprint) { SumBlueprint prototype; prototype.visitDumpFeatures(_indexEnv, _visitor); @@ -323,16 +350,15 @@ RankSetupTest::testSumBlueprint() params.push_back("value(5.5, 10.5).0"); params.push_back("value(5.5, 10.5).1"); EXPECT_TRUE(bp->setup(_indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 2u); - EXPECT_EQUAL(deps.input[0], "value(5.5, 10.5).0"); - EXPECT_EQUAL(deps.input[1], "value(5.5, 10.5).1"); - EXPECT_EQUAL(deps.output.size(), 1u); - EXPECT_EQUAL(deps.output[0], "out"); + EXPECT_EQ(deps.input.size(), 2u); + EXPECT_EQ(deps.input[0], "value(5.5, 10.5).0"); + EXPECT_EQ(deps.input[1], "value(5.5, 10.5).1"); + EXPECT_EQ(deps.output.size(), 1u); + EXPECT_EQ(deps.output[0], "out"); } } -void -RankSetupTest::testStaticRankBlueprint() +TEST_F(RankSetupTest, static_rank_blueprint) { StaticRankBlueprint prototype; { // basic test @@ -341,9 +367,9 @@ RankSetupTest::testStaticRankBlueprint() std::vector<vespalib::string> params; params.push_back("sr1"); EXPECT_TRUE(bp->setup(_indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 0u); - EXPECT_EQUAL(deps.output.size(), 1u); - EXPECT_EQUAL(deps.output[0], "out"); + EXPECT_EQ(deps.input.size(), 0u); + EXPECT_EQ(deps.output.size(), 1u); + EXPECT_EQ(deps.output[0], "out"); } { // invalid params Blueprint::UP bp = prototype.createInstance(); @@ -356,8 +382,7 @@ RankSetupTest::testStaticRankBlueprint() } } -void -RankSetupTest::testChainBlueprint() +TEST_F(RankSetupTest, chain_blueprint) { ChainBlueprint prototype; { // chaining @@ -368,8 +393,8 @@ RankSetupTest::testChainBlueprint() params.push_back("2"); params.push_back("4"); EXPECT_TRUE(bp->setup(_indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 1u); - EXPECT_EQUAL(deps.input[0], "chain(basic,1,4)"); + EXPECT_EQ(deps.input.size(), 1u); + EXPECT_EQ(deps.input[0], "chain(basic,1,4)"); } { // leaf node Blueprint::UP bp = prototype.createInstance(); @@ -379,8 +404,8 @@ RankSetupTest::testChainBlueprint() params.push_back("1"); params.push_back("4"); EXPECT_TRUE(bp->setup(_indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 1u); - EXPECT_EQUAL(deps.input[0], "value(4)"); + EXPECT_EQ(deps.input.size(), 1u); + EXPECT_EQ(deps.input[0], "value(4)"); } { // cycle Blueprint::UP bp = prototype.createInstance(); @@ -390,8 +415,8 @@ RankSetupTest::testChainBlueprint() params.push_back("1"); params.push_back("4"); EXPECT_TRUE(bp->setup(_indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 1u); - EXPECT_EQUAL(deps.input[0], "chain(cycle,4,4)"); + EXPECT_EQ(deps.input.size(), 1u); + EXPECT_EQ(deps.input[0], "chain(cycle,4,4)"); } { // invalid params Blueprint::UP bp = prototype.createInstance(); @@ -405,8 +430,7 @@ RankSetupTest::testChainBlueprint() } } -void -RankSetupTest::testCfgValueBlueprint() +TEST_F(RankSetupTest, cfg_value_blueprint) { CfgValueBlueprint prototype; IndexEnvironment indexEnv; @@ -422,25 +446,23 @@ RankSetupTest::testCfgValueBlueprint() params.push_back("foo"); EXPECT_TRUE(bp->setup(indexEnv, params)); - EXPECT_EQUAL(deps.input.size(), 0u); - EXPECT_EQUAL(deps.output.size(), 3u); - EXPECT_EQUAL(deps.output[0], "0"); - EXPECT_EQUAL(deps.output[1], "1"); - EXPECT_EQUAL(deps.output[2], "2"); + EXPECT_EQ(deps.input.size(), 0u); + EXPECT_EQ(deps.output.size(), 3u); + EXPECT_EQ(deps.output[0], "0"); + EXPECT_EQ(deps.output[1], "1"); + EXPECT_EQ(deps.output[2], "2"); vespalib::Stash stash; FeatureExecutor &fe = bp->createExecutor(_queryEnv, stash); ValueExecutor *vfe = static_cast<ValueExecutor *>(&fe); - EXPECT_EQUAL(vfe->getValues().size(), 3u); - EXPECT_EQUAL(vfe->getValues()[0], 1.0f); - EXPECT_EQUAL(vfe->getValues()[1], 2.0f); - EXPECT_EQUAL(vfe->getValues()[2], 3.0f); + EXPECT_EQ(vfe->getValues().size(), 3u); + EXPECT_EQ(vfe->getValues()[0], 1.0f); + EXPECT_EQ(vfe->getValues()[1], 2.0f); + EXPECT_EQ(vfe->getValues()[2], 3.0f); } } - -void -RankSetupTest::testCompilation() +TEST_F(RankSetupTest, compilation) { { // unknown blueprint RankSetup rs(_factory, _indexEnv); @@ -499,7 +521,7 @@ RankSetupTest::testCompilation() } } -void RankSetupTest::testRankSetup() +TEST_F(RankSetupTest, rank_setup) { using namespace search::fef::indexproperties; IndexEnvironment env; @@ -525,7 +547,8 @@ void RankSetupTest::testRankSetup() env.getProperties().add(hitcollector::ArraySize::NAME, "60"); env.getProperties().add(hitcollector::EstimatePoint::NAME, "70"); env.getProperties().add(hitcollector::EstimateLimit::NAME, "80"); - env.getProperties().add(hitcollector::RankScoreDropLimit::NAME, "90.5"); + env.getProperties().add(hitcollector::FirstPhaseRankScoreDropLimit::NAME, "90.5"); + env.getProperties().add(hitcollector::SecondPhaseRankScoreDropLimit::NAME, "91.5"); env.getProperties().add(mutate::on_match::Attribute::NAME, "a"); env.getProperties().add(mutate::on_match::Operation::NAME, "+=3"); env.getProperties().add(mutate::on_first_phase::Attribute::NAME, "b"); @@ -542,44 +565,45 @@ void RankSetupTest::testRankSetup() RankSetup rs(_factory, env); EXPECT_FALSE(rs.has_match_features()); rs.configure(); - EXPECT_EQUAL(rs.getFirstPhaseRank(), vespalib::string("firstphase")); - EXPECT_EQUAL(rs.getSecondPhaseRank(), vespalib::string("secondphase")); + EXPECT_EQ(rs.getFirstPhaseRank(), vespalib::string("firstphase")); + EXPECT_EQ(rs.getSecondPhaseRank(), vespalib::string("secondphase")); EXPECT_TRUE(rs.has_match_features()); ASSERT_TRUE(rs.get_match_features().size() == 2); - EXPECT_EQUAL(rs.get_match_features()[0], vespalib::string("match_foo")); - EXPECT_EQUAL(rs.get_match_features()[1], vespalib::string("match_bar")); + EXPECT_EQ(rs.get_match_features()[0], vespalib::string("match_foo")); + EXPECT_EQ(rs.get_match_features()[1], vespalib::string("match_bar")); ASSERT_TRUE(rs.getDumpFeatures().size() == 2); - EXPECT_EQUAL(rs.getDumpFeatures()[0], vespalib::string("foo")); - EXPECT_EQUAL(rs.getDumpFeatures()[1], vespalib::string("bar")); - EXPECT_EQUAL(rs.getNumThreadsPerSearch(), 3u); - EXPECT_EQUAL(rs.getMinHitsPerThread(), 8u); - EXPECT_EQUAL(rs.getDegradationAttribute(), "mystaticrankattr"); - EXPECT_EQUAL(rs.isDegradationOrderAscending(), true); - EXPECT_EQUAL(rs.getDegradationMaxHits(), 12345u); - EXPECT_EQUAL(rs.getDegradationSamplePercentage(), 0.9); - EXPECT_EQUAL(rs.getDegradationMaxFilterCoverage(), 0.19); - EXPECT_EQUAL(rs.getDegradationPostFilterMultiplier(), 0.7); - EXPECT_EQUAL(rs.getDiversityAttribute(), "mycategoryattr"); - EXPECT_EQUAL(rs.getDiversityMinGroups(), 37u); - EXPECT_EQUAL(rs.getDiversityCutoffFactor(), 7.1); - EXPECT_EQUAL(rs.getDiversityCutoffStrategy(), "strict"); - EXPECT_EQUAL(rs.getHeapSize(), 50u); - EXPECT_EQUAL(rs.getArraySize(), 60u); - EXPECT_EQUAL(rs.getEstimatePoint(), 70u); - EXPECT_EQUAL(rs.getEstimateLimit(), 80u); - EXPECT_EQUAL(rs.getRankScoreDropLimit(), 90.5); - EXPECT_EQUAL(rs.getMutateOnMatch()._attribute, "a"); - EXPECT_EQUAL(rs.getMutateOnMatch()._operation, "+=3"); - EXPECT_EQUAL(rs.getMutateOnFirstPhase()._attribute, "b"); - EXPECT_EQUAL(rs.getMutateOnFirstPhase()._operation, "=3"); - EXPECT_EQUAL(rs.getMutateOnSecondPhase()._attribute, "b"); - EXPECT_EQUAL(rs.getMutateOnSecondPhase()._operation, "=7"); - EXPECT_EQUAL(rs.getMutateOnSummary()._attribute, "c"); - EXPECT_EQUAL(rs.getMutateOnSummary()._operation, "-=2"); - EXPECT_EQUAL(rs.get_global_filter_lower_limit(), 0.3); - EXPECT_EQUAL(rs.get_global_filter_upper_limit(), 0.7); - EXPECT_EQUAL(rs.get_target_hits_max_adjustment_factor(), 5.0); - EXPECT_EQUAL(rs.get_fuzzy_matching_algorithm(), vespalib::FuzzyMatchingAlgorithm::DfaImplicit); + EXPECT_EQ(rs.getDumpFeatures()[0], vespalib::string("foo")); + EXPECT_EQ(rs.getDumpFeatures()[1], vespalib::string("bar")); + EXPECT_EQ(rs.getNumThreadsPerSearch(), 3u); + EXPECT_EQ(rs.getMinHitsPerThread(), 8u); + EXPECT_EQ(rs.getDegradationAttribute(), "mystaticrankattr"); + EXPECT_EQ(rs.isDegradationOrderAscending(), true); + EXPECT_EQ(rs.getDegradationMaxHits(), 12345u); + EXPECT_EQ(rs.getDegradationSamplePercentage(), 0.9); + EXPECT_EQ(rs.getDegradationMaxFilterCoverage(), 0.19); + EXPECT_EQ(rs.getDegradationPostFilterMultiplier(), 0.7); + EXPECT_EQ(rs.getDiversityAttribute(), "mycategoryattr"); + EXPECT_EQ(rs.getDiversityMinGroups(), 37u); + EXPECT_EQ(rs.getDiversityCutoffFactor(), 7.1); + EXPECT_EQ(rs.getDiversityCutoffStrategy(), "strict"); + EXPECT_EQ(rs.getHeapSize(), 50u); + EXPECT_EQ(rs.getArraySize(), 60u); + EXPECT_EQ(rs.getEstimatePoint(), 70u); + EXPECT_EQ(rs.getEstimateLimit(), 80u); + EXPECT_EQ(std::optional<feature_t>(90.5), rs.get_first_phase_rank_score_drop_limit()); + EXPECT_EQ(std::optional<feature_t>(91.5), rs.get_second_phase_rank_score_drop_limit()); + EXPECT_EQ(rs.getMutateOnMatch()._attribute, "a"); + EXPECT_EQ(rs.getMutateOnMatch()._operation, "+=3"); + EXPECT_EQ(rs.getMutateOnFirstPhase()._attribute, "b"); + EXPECT_EQ(rs.getMutateOnFirstPhase()._operation, "=3"); + EXPECT_EQ(rs.getMutateOnSecondPhase()._attribute, "b"); + EXPECT_EQ(rs.getMutateOnSecondPhase()._operation, "=7"); + EXPECT_EQ(rs.getMutateOnSummary()._attribute, "c"); + EXPECT_EQ(rs.getMutateOnSummary()._operation, "-=2"); + EXPECT_EQ(rs.get_global_filter_lower_limit(), 0.3); + EXPECT_EQ(rs.get_global_filter_upper_limit(), 0.7); + EXPECT_EQ(rs.get_target_hits_max_adjustment_factor(), 5.0); + EXPECT_EQ(rs.get_fuzzy_matching_algorithm(), vespalib::FuzzyMatchingAlgorithm::DfaImplicit); } bool @@ -604,12 +628,11 @@ RankSetupTest::testExecution(const RankEnvironment &rankEnv, const vespalib::str } RankResult rs = re.execute(docId); ok = ok && (exp == rs); - EXPECT_EQUAL(exp, rs); + EXPECT_EQ(exp, rs); return ok; } -void -RankSetupTest::testExecution() +TEST_F(RankSetupTest, execution) { { // value executor vespalib::string v = FNB().baseName("value").parameter("5.5").parameter("10.5").buildName(); @@ -699,8 +722,7 @@ RankSetupTest::testExecution() } } -void -RankSetupTest::testFeatureDump() +TEST_F(RankSetupTest, feature_dump) { { FeatureDumper dumper(_rankEnv); @@ -722,7 +744,7 @@ RankSetupTest::testFeatureDump() parameter(FNB().baseName("double").parameter("value(8)").buildName()). parameter(FNB().baseName("double").parameter("value(32)").buildName()). buildName(), 80.0f); - EXPECT_EQUAL(exp, dumper.dump()); + EXPECT_EQ(exp, dumper.dump()); } { FeatureDumper dumper(_rankEnv); @@ -732,7 +754,7 @@ RankSetupTest::testFeatureDump() RankResult exp; exp.addScore("value(50)", 50.0f); exp.addScore("value(100)", 100.0f); - EXPECT_EQUAL(exp, dumper.dump()); + EXPECT_EQ(exp, dumper.dump()); } { FeatureDumper dumper(_rankEnv); @@ -740,7 +762,7 @@ RankSetupTest::testFeatureDump() EXPECT_TRUE(dumper.setup()); RankResult exp; exp.addScore(FNB().baseName("rankingExpression").parameter("if(4<2,3,4)").buildName(), 4.0f); - EXPECT_EQUAL(exp, dumper.dump()); + EXPECT_EQ(exp, dumper.dump()); } { @@ -749,7 +771,7 @@ RankSetupTest::testFeatureDump() EXPECT_TRUE(dumper.setup()); RankResult exp; exp.addScore(FNB().baseName("rankingExpression").parameter("if(mysum(value(12),value(10))>2,3,4)").buildName(), 3.0f); - EXPECT_EQUAL(exp, dumper.dump()); + EXPECT_EQ(exp, dumper.dump()); } { // dump features indicated by visitation IndexEnvironment indexEnv; @@ -767,7 +789,7 @@ RankSetupTest::testFeatureDump() RankResult exp; exp.addScore("test_cfgvalue(foo)", 1.0); exp.addScore("test_cfgvalue(bar)", 5.0); - EXPECT_EQUAL(exp, dumper.dump()); + EXPECT_EQ(exp, dumper.dump()); } { // ignore features indicated by visitation IndexEnvironment indexEnv; @@ -786,7 +808,7 @@ RankSetupTest::testFeatureDump() EXPECT_TRUE(dumper.setup()); RankResult exp; exp.addScore("test_cfgvalue(foo)", 1.0); - EXPECT_EQUAL(exp, dumper.dump()); + EXPECT_EQ(exp, dumper.dump()); } { // Dump secondPhase feature IndexEnvironment indexEnv; @@ -799,7 +821,7 @@ RankSetupTest::testFeatureDump() EXPECT_TRUE(dumper.setup()); RankResult exp; exp.addScore("secondPhase", 4.0); - EXPECT_EQUAL(exp, dumper.dump()); + EXPECT_EQ(exp, dumper.dump()); } } @@ -807,22 +829,19 @@ void RankSetupTest::checkFeatures(std::map<vespalib::string, feature_t> &exp, std::map<vespalib::string, feature_t> &actual) { using ITR = std::map<vespalib::string, feature_t>::const_iterator; - if (!EXPECT_EQUAL(exp.size(), actual.size())) { - return; - } + ASSERT_EQ(exp.size(), actual.size()); ITR exp_itr = exp.begin(); ITR exp_end = exp.end(); ITR actual_itr = actual.begin(); ITR actual_end = actual.end(); for (; exp_itr != exp_end && actual_itr != actual_end; ++exp_itr, ++actual_itr) { - EXPECT_EQUAL(exp_itr->first, actual_itr->first); - EXPECT_APPROX(exp_itr->second, actual_itr->second, 0.001); + EXPECT_EQ(exp_itr->first, actual_itr->first); + EXPECT_NEAR(exp_itr->second, actual_itr->second, 0.001); } - EXPECT_EQUAL(exp_itr == exp_end, actual_itr == actual_end); + EXPECT_EQ(exp_itr == exp_end, actual_itr == actual_end); } -void -RankSetupTest::testFeatureNormalization() +TEST_F(RankSetupTest, feature_normalization) { BlueprintFactory factory; factory.addPrototype(Blueprint::SP(new ValueBlueprint())); @@ -855,35 +874,39 @@ RankSetupTest::testFeatureNormalization() match_program->setup(*match_data, queryEnv); summaryProgram->setup(*match_data, queryEnv); - EXPECT_APPROX(2.0, Utils::getScoreFeature(*firstPhaseProgram, 1), 0.001); - EXPECT_APPROX(4.0, Utils::getScoreFeature(*secondPhaseProgram, 1), 0.001); + EXPECT_NEAR(2.0, Utils::getScoreFeature(*firstPhaseProgram, 1), 0.001); + EXPECT_NEAR(4.0, Utils::getScoreFeature(*secondPhaseProgram, 1), 0.001); - { // rank seed features + { + SCOPED_TRACE("rank seed features"); std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*summaryProgram, 1); std::map<vespalib::string, feature_t> exp; exp["mysum(value(5),value(5))"] = 10.0; exp["mysum(\"value( 5 )\",\"value( 5 )\")"] = 10.0; - TEST_DO(checkFeatures(exp, actual)); + checkFeatures(exp, actual); } - { // all rank features (1. phase) + { + SCOPED_TRACE("all rank features (1. phase)"); std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*firstPhaseProgram, 1); std::map<vespalib::string, feature_t> exp; exp["value(1)"] = 1.0; exp["value(1).0"] = 1.0; exp["mysum(value(1),value(1))"] = 2.0; exp["mysum(value(1),value(1)).out"] = 2.0; - TEST_DO(checkFeatures(exp, actual)); + checkFeatures(exp, actual); } - { // all rank features (2. phase) + { + SCOPED_TRACE("all rank features (2. phase)"); std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*secondPhaseProgram, 1); std::map<vespalib::string, feature_t> exp; exp["value(2)"] = 2.0; exp["value(2).0"] = 2.0; exp["mysum(value(2),value(2))"] = 4.0; exp["mysum(value(2),value(2)).out"] = 4.0; - TEST_DO(checkFeatures(exp, actual)); + checkFeatures(exp, actual); } - { // all match features + { + SCOPED_TRACE("all match features"); std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*match_program, 1); std::map<vespalib::string, feature_t> exp; exp["value(3)"] = 3.0; @@ -892,9 +915,10 @@ RankSetupTest::testFeatureNormalization() exp["mysum(value(3),value(3)).out"] = 6.0; exp["mysum(\"value( 3 )\",\"value( 3 )\")"] = 6.0; exp["mysum(\"value( 3 )\",\"value( 3 )\").out"] = 6.0; - TEST_DO(checkFeatures(exp, actual)); + checkFeatures(exp, actual); } - { // all rank features (summary) + { + SCOPED_TRACE("all rank features (summary)"); std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*summaryProgram, 1); std::map<vespalib::string, feature_t> exp; exp["value(5)"] = 5.0; @@ -903,7 +927,7 @@ RankSetupTest::testFeatureNormalization() exp["mysum(value(5),value(5)).out"] = 10.0; exp["mysum(\"value( 5 )\",\"value( 5 )\")"] = 10.0; exp["mysum(\"value( 5 )\",\"value( 5 )\").out"] = 10.0; - TEST_DO(checkFeatures(exp, actual)); + checkFeatures(exp, actual); } } @@ -914,15 +938,17 @@ RankSetupTest::testFeatureNormalization() RankProgram::UP rankProgram = rankSetup.create_dump_program(); rankProgram->setup(*match_data, queryEnv); - { // dump seed features + { + SCOPED_TRACE("dump seed features"); std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*rankProgram, 1); std::map<vespalib::string, feature_t> exp; exp["mysum(value(10),value(10))"] = 20.0; exp["mysum(\"value( 10 )\",\"value( 10 )\")"] = 20.0; - TEST_DO(checkFeatures(exp, actual)); + checkFeatures(exp, actual); } - { // all dump features + { + SCOPED_TRACE("all dump features"); std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*rankProgram, 1); std::map<vespalib::string, feature_t> exp; @@ -935,72 +961,9 @@ RankSetupTest::testFeatureNormalization() exp["mysum(\"value( 10 )\",\"value( 10 )\")"] = 20.0; exp["mysum(\"value( 10 )\",\"value( 10 )\").out"] = 20.0; - TEST_DO(checkFeatures(exp, actual)); + checkFeatures(exp, actual); } } } - -RankSetupTest::RankSetupTest() : - _factory(), - _manager(), - _indexEnv(), - _queryEnv(), - _rankEnv(_factory, _indexEnv, _queryEnv), - _visitor() -{ - // register blueprints - setup_fef_test_plugin(_factory); - _factory.addPrototype(Blueprint::SP(new ValueBlueprint())); - _factory.addPrototype(Blueprint::SP(new RankingExpressionBlueprint())); - _factory.addPrototype(std::make_shared<SecondPhaseBlueprint>()); - - // setup an original attribute manager with two attributes - search::attribute::Config cfg(search::attribute::BasicType::INT32, - search::attribute::CollectionType::SINGLE); - search::AttributeVector::SP av1 = - search::AttributeFactory::createAttribute("staticrank1", cfg); - search::AttributeVector::SP av2 = - search::AttributeFactory::createAttribute("staticrank2", cfg); - av1->addDocs(5); - av2->addDocs(5); - for (uint32_t i = 0; i < 5; ++i) { - (static_cast<search::IntegerAttribute *>(av1.get()))->update(i, i + 100); - (static_cast<search::IntegerAttribute *>(av2.get()))->update(i, i + 200); - } - av1->commit(); - av2->commit(); - _manager.add(av1); - _manager.add(av2); - - // set the index environment - _queryEnv.setIndexEnv(&_indexEnv); - - // set the manager - _queryEnv.overrideAttributeManager(&_manager); -} - -RankSetupTest::~RankSetupTest() {} - -int -RankSetupTest::Main() -{ - TEST_INIT("ranksetup_test"); - - testValueBlueprint(); - testDoubleBlueprint(); - testSumBlueprint(); - testStaticRankBlueprint(); - testChainBlueprint(); - testCfgValueBlueprint(); - - testCompilation(); - testRankSetup(); - testExecution(); - testFeatureDump(); - testFeatureNormalization(); - - TEST_DONE(); -} - -TEST_APPHOOK(RankSetupTest); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/vespa/searchlib/fef/indexproperties.cpp b/searchlib/src/vespa/searchlib/fef/indexproperties.cpp index 1f88c34bef3..3ca53d3f777 100644 --- a/searchlib/src/vespa/searchlib/fef/indexproperties.cpp +++ b/searchlib/src/vespa/searchlib/fef/indexproperties.cpp @@ -36,14 +36,20 @@ lookupStringVector(const Properties &props, const vespalib::string &name, return defaultValue; } -double -lookupDouble(const Properties &props, const vespalib::string &name, double defaultValue) +std::optional<double> +lookup_opt_double(const Properties &props, vespalib::stringref name, std::optional<double> default_value) { Property p = props.lookup(name); if (p.found()) { return vespalib::locale::c::strtod(p.get().c_str(), nullptr); } - return defaultValue; + return default_value; +} + +double +lookupDouble(const Properties &props, const vespalib::string &name, double defaultValue) +{ + return lookup_opt_double(props, name, defaultValue).value(); } uint32_t @@ -180,7 +186,7 @@ namespace onsummary { namespace temporary { const vespalib::string WeakAndRange::NAME("vespa.weakand.range"); -const double WeakAndRange::DEFAULT_VALUE(0.0); +const double WeakAndRange::DEFAULT_VALUE(1.0); double WeakAndRange::lookup(const Properties &props) @@ -683,19 +689,34 @@ EstimateLimit::lookup(const Properties &props) return lookupUint32(props, NAME, DEFAULT_VALUE); } -const vespalib::string RankScoreDropLimit::NAME("vespa.hitcollector.rankscoredroplimit"); -const feature_t RankScoreDropLimit::DEFAULT_VALUE(-std::numeric_limits<feature_t>::quiet_NaN()); +const vespalib::string FirstPhaseRankScoreDropLimit::NAME("vespa.hitcollector.rankscoredroplimit"); +const std::optional<feature_t> FirstPhaseRankScoreDropLimit::DEFAULT_VALUE(std::nullopt); -feature_t -RankScoreDropLimit::lookup(const Properties &props) +std::optional<feature_t> +FirstPhaseRankScoreDropLimit::lookup(const Properties &props) { return lookup(props, DEFAULT_VALUE); } -feature_t -RankScoreDropLimit::lookup(const Properties &props, feature_t defaultValue) +std::optional<feature_t> +FirstPhaseRankScoreDropLimit::lookup(const Properties &props, std::optional<feature_t> default_value) { - return lookupDouble(props, NAME, defaultValue); + return lookup_opt_double(props, NAME, default_value); +} + +const vespalib::string SecondPhaseRankScoreDropLimit::NAME("vespa.hitcollector.secondphase.rankscoredroplimit"); +const std::optional<feature_t> SecondPhaseRankScoreDropLimit::DEFAULT_VALUE(std::nullopt); + +std::optional<feature_t> +SecondPhaseRankScoreDropLimit::lookup(const Properties &props) +{ + return lookup_opt_double(props, NAME, DEFAULT_VALUE); +} + +std::optional<feature_t> +SecondPhaseRankScoreDropLimit::lookup(const Properties &props, std::optional<feature_t> default_value) +{ + return lookup_opt_double(props, NAME, default_value); } } // namspace hitcollector diff --git a/searchlib/src/vespa/searchlib/fef/indexproperties.h b/searchlib/src/vespa/searchlib/fef/indexproperties.h index d047eb13347..afaf7ac1a61 100644 --- a/searchlib/src/vespa/searchlib/fef/indexproperties.h +++ b/searchlib/src/vespa/searchlib/fef/indexproperties.h @@ -5,6 +5,7 @@ #include <vespa/searchlib/common/feature.h> #include <vespa/vespalib/fuzzy/fuzzy_matching_algorithm.h> #include <vespa/vespalib/stllike/string.h> +#include <optional> #include <vector> namespace search::fef { class Properties; } @@ -562,16 +563,28 @@ namespace hitcollector { }; /** - * Property for the rank score drop limit used in parallel query evaluation. - * Drop a hit if the rank score <= drop limit. + * Property for the first phase rank score drop limit used in parallel + * query evaluation. + * Drop a hit if the first phase rank score <= drop limit. **/ - struct RankScoreDropLimit { + struct FirstPhaseRankScoreDropLimit { static const vespalib::string NAME; - static const feature_t DEFAULT_VALUE; - static feature_t lookup(const Properties &props); - static feature_t lookup(const Properties &props, feature_t defaultValue); + static const std::optional<feature_t> DEFAULT_VALUE; + static std::optional<feature_t> lookup(const Properties &props); + static std::optional<feature_t> lookup(const Properties &props, std::optional<feature_t> default_value); }; + /** + * Property for the second phase rank score drop limit used in + * parallel query evaluation. Drop a hit if the score (reranked or + * rescored) <= drop limit. + **/ + struct SecondPhaseRankScoreDropLimit { + static const vespalib::string NAME; + static const std::optional<feature_t> DEFAULT_VALUE; + static std::optional<feature_t> lookup(const Properties &props); + static std::optional<feature_t> lookup(const Properties &props, std::optional<double> default_value); + }; } // namespace hitcollector diff --git a/searchlib/src/vespa/searchlib/fef/ranksetup.cpp b/searchlib/src/vespa/searchlib/fef/ranksetup.cpp index ba5abb35141..f62dda66b76 100644 --- a/searchlib/src/vespa/searchlib/fef/ranksetup.cpp +++ b/searchlib/src/vespa/searchlib/fef/ranksetup.cpp @@ -50,7 +50,8 @@ RankSetup::RankSetup(const BlueprintFactory &factory, const IIndexEnvironment &i _degradationMaxFilterCoverage(1.0), _degradationSamplePercentage(0.2), _degradationPostFilterMultiplier(1.0), - _rankScoreDropLimit(0), + _first_phase_rank_score_drop_limit(), + _second_phase_rank_score_drop_limit(), _match_features(), _summaryFeatures(), _dumpFeatures(), @@ -120,7 +121,8 @@ RankSetup::configure() setDiversityCutoffStrategy(matchphase::DiversityCutoffStrategy::lookup(_indexEnv.getProperties())); setEstimatePoint(hitcollector::EstimatePoint::lookup(_indexEnv.getProperties())); setEstimateLimit(hitcollector::EstimateLimit::lookup(_indexEnv.getProperties())); - setRankScoreDropLimit(hitcollector::RankScoreDropLimit::lookup(_indexEnv.getProperties())); + set_first_phase_rank_score_drop_limit(hitcollector::FirstPhaseRankScoreDropLimit::lookup(_indexEnv.getProperties())); + set_second_phase_rank_score_drop_limit(hitcollector::SecondPhaseRankScoreDropLimit::lookup(_indexEnv.getProperties())); setSoftTimeoutEnabled(softtimeout::Enabled::lookup(_indexEnv.getProperties())); setSoftTimeoutTailCost(softtimeout::TailCost::lookup(_indexEnv.getProperties())); set_global_filter_lower_limit(matching::GlobalFilterLowerLimit::lookup(_indexEnv.getProperties())); diff --git a/searchlib/src/vespa/searchlib/fef/ranksetup.h b/searchlib/src/vespa/searchlib/fef/ranksetup.h index f20ecd4b42b..b5309b128e2 100644 --- a/searchlib/src/vespa/searchlib/fef/ranksetup.h +++ b/searchlib/src/vespa/searchlib/fef/ranksetup.h @@ -9,6 +9,7 @@ #include "rank_program.h" #include <vespa/searchlib/common/stringmap.h> #include <vespa/vespalib/fuzzy/fuzzy_matching_algorithm.h> +#include <optional> namespace search::fef { @@ -59,7 +60,8 @@ private: double _degradationMaxFilterCoverage; double _degradationSamplePercentage; double _degradationPostFilterMultiplier; - feature_t _rankScoreDropLimit; + std::optional<feature_t> _first_phase_rank_score_drop_limit; + std::optional<feature_t> _second_phase_rank_score_drop_limit; std::vector<vespalib::string> _match_features; std::vector<vespalib::string> _summaryFeatures; std::vector<vespalib::string> _dumpFeatures; @@ -332,18 +334,22 @@ public: uint32_t getEstimateLimit() const { return _estimateLimit; } /** - * Sets the rank score drop limit to be used in parallel query evaluation. + * Sets the first phase rank score drop limit to be used in parallel query evaluation. * - * @param rankScoreDropLimit the rank score drop limit + * @param value the first phase rank score drop limit **/ - void setRankScoreDropLimit(feature_t rankScoreDropLimit) { _rankScoreDropLimit = rankScoreDropLimit; } + void set_first_phase_rank_score_drop_limit(std::optional<feature_t> value) { _first_phase_rank_score_drop_limit = value; } /** * Returns the rank score drop limit to be used in parallel query evaluation. * * @return the rank score drop limit **/ - feature_t getRankScoreDropLimit() const { return _rankScoreDropLimit; } + std::optional<feature_t> get_first_phase_rank_score_drop_limit() const noexcept { return _first_phase_rank_score_drop_limit; } + + void set_second_phase_rank_score_drop_limit(std::optional<feature_t> value) { _second_phase_rank_score_drop_limit = value; } + + std::optional<feature_t> get_second_phase_rank_score_drop_limit() const noexcept { return _second_phase_rank_score_drop_limit; } /** * This method may be used to indicate that certain features diff --git a/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp b/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp index c02990c5921..f1c9e041a64 100644 --- a/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp +++ b/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp @@ -122,6 +122,7 @@ Blueprint::Blueprint() noexcept _flow_stats(0.0, 0.0, 0.0), _sourceId(0xffffffff), _docid_limit(0), + _id(0), _strict(false), _frozen(false) { @@ -141,6 +142,13 @@ Blueprint::resolve_strict(InFlow &in_flow) noexcept _strict = in_flow.strict(); } +uint32_t +Blueprint::enumerate(uint32_t next_id) noexcept +{ + set_id(next_id++); + return next_id; +} + void Blueprint::each_node_post_order(const std::function<void(Blueprint&)> &f) { @@ -411,6 +419,7 @@ Blueprint::visitMembers(vespalib::ObjectVisitor &visitor) const visitor.visitFloat("strict_cost", strict_cost()); visitor.visitInt("sourceId", _sourceId); visitor.visitInt("docid_limit", _docid_limit); + visitor.visitInt("id", _id); visitor.visitBool("strict", _strict); } @@ -450,11 +459,21 @@ IntermediateBlueprint::setDocIdLimit(uint32_t limit) noexcept } } +uint32_t +IntermediateBlueprint::enumerate(uint32_t next_id) noexcept +{ + set_id(next_id++); + for (Blueprint::UP &child: _children) { + next_id = child->enumerate(next_id); + } + return next_id; +} + void IntermediateBlueprint::each_node_post_order(const std::function<void(Blueprint&)> &f) { - for (Blueprint::UP &child : _children) { - f(*child); + for (Blueprint::UP &child: _children) { + child->each_node_post_order(f); } f(*this); } diff --git a/searchlib/src/vespa/searchlib/queryeval/blueprint.h b/searchlib/src/vespa/searchlib/queryeval/blueprint.h index a443f34f856..12f18c74970 100644 --- a/searchlib/src/vespa/searchlib/queryeval/blueprint.h +++ b/searchlib/src/vespa/searchlib/queryeval/blueprint.h @@ -240,6 +240,7 @@ private: FlowStats _flow_stats; uint32_t _sourceId; uint32_t _docid_limit; + uint32_t _id; bool _strict; bool _frozen; @@ -288,6 +289,10 @@ public: virtual void setDocIdLimit(uint32_t limit) noexcept { _docid_limit = limit; } uint32_t get_docid_limit() const noexcept { return _docid_limit; } + void set_id(uint32_t value) noexcept { _id = value; } + uint32_t id() const noexcept { return _id; } + virtual uint32_t enumerate(uint32_t next_id) noexcept; + bool strict() const noexcept { return _strict; } virtual void each_node_post_order(const std::function<void(Blueprint&)> &f); @@ -480,6 +485,7 @@ public: ~IntermediateBlueprint() override; void setDocIdLimit(uint32_t limit) noexcept final; + uint32_t enumerate(uint32_t next_id) noexcept override; void each_node_post_order(const std::function<void(Blueprint&)> &f) override; void optimize(Blueprint* &self, OptimizePass pass) final; diff --git a/searchlib/src/vespa/searchlib/test/mock_attribute_context.cpp b/searchlib/src/vespa/searchlib/test/mock_attribute_context.cpp index 75e85d9d828..1003160249d 100644 --- a/searchlib/src/vespa/searchlib/test/mock_attribute_context.cpp +++ b/searchlib/src/vespa/searchlib/test/mock_attribute_context.cpp @@ -28,7 +28,7 @@ MockAttributeContext::getAttributeList(std::vector<const IAttributeVector *> & l MockAttributeContext::~MockAttributeContext() = default; void -MockAttributeContext::add(std::shared_ptr<IAttributeVector> attr) { +MockAttributeContext::add(std::shared_ptr<const IAttributeVector> attr) { _vectors[attr->getName()] = attr; } diff --git a/searchlib/src/vespa/searchlib/test/mock_attribute_context.h b/searchlib/src/vespa/searchlib/test/mock_attribute_context.h index 5b522e907b1..165a37994b9 100644 --- a/searchlib/src/vespa/searchlib/test/mock_attribute_context.h +++ b/searchlib/src/vespa/searchlib/test/mock_attribute_context.h @@ -11,12 +11,12 @@ namespace search::attribute::test { class MockAttributeContext : public IAttributeContext { private: - using Map = std::map<string, std::shared_ptr<IAttributeVector>>; + using Map = std::map<string, std::shared_ptr<const IAttributeVector>>; Map _vectors; public: ~MockAttributeContext() override; - void add(std::shared_ptr<IAttributeVector> attr); + void add(std::shared_ptr<const IAttributeVector> attr); const IAttributeVector *get(const string &name) const; const IAttributeVector * getAttribute(const string &name) const override; |