diff options
Diffstat (limited to 'searchlib')
20 files changed, 439 insertions, 454 deletions
diff --git a/searchlib/CMakeLists.txt b/searchlib/CMakeLists.txt index ffc6cf75ab0..a5453ac5273 100644 --- a/searchlib/CMakeLists.txt +++ b/searchlib/CMakeLists.txt @@ -131,6 +131,7 @@ vespa_define_module( src/tests/engine/proto_rpc_adapter src/tests/expression/attributenode src/tests/expression/current_index_setup + src/tests/expression/interpolated_document_field_lookup_node src/tests/features src/tests/features/beta src/tests/features/bm25 diff --git a/searchlib/src/tests/attribute/guard/CMakeLists.txt b/searchlib/src/tests/attribute/guard/CMakeLists.txt index a956182e1e1..f5570377814 100644 --- a/searchlib/src/tests/attribute/guard/CMakeLists.txt +++ b/searchlib/src/tests/attribute/guard/CMakeLists.txt @@ -4,6 +4,7 @@ vespa_add_executable(searchlib_attributeguard_test_app TEST attributeguard_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_attributeguard_test_app COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/attributeguard_test.sh DEPENDS searchlib_attributeguard_test_app) diff --git a/searchlib/src/tests/attribute/guard/attributeguard_test.cpp b/searchlib/src/tests/attribute/guard/attributeguard_test.cpp index 47df9d7c320..513fa7406b6 100644 --- a/searchlib/src/tests/attribute/guard/attributeguard_test.cpp +++ b/searchlib/src/tests/attribute/guard/attributeguard_test.cpp @@ -1,31 +1,17 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/log/log.h> -LOG_SETUP("attributeguard_test"); -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/searchlib/attribute/attributeguard.h> #include <vespa/searchlib/attribute/extendableattributes.h> +#include <vespa/vespalib/gtest/gtest.h> namespace search { -class AttributeGuardTest : public vespalib::TestApp +TEST(AttributeGuardTest, test_attribute_guard) { -public: - int Main() override; -}; - -int -AttributeGuardTest::Main() -{ - TEST_INIT("attributeguard_test"); - - AttributeVector::SP ssattr(new SingleStringExtAttribute("ss1")); AttributeGuard guard(ssattr); EXPECT_TRUE(guard.valid()); - - TEST_DONE(); } } -TEST_APPHOOK(search::AttributeGuardTest); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/attribute/postinglist/CMakeLists.txt b/searchlib/src/tests/attribute/postinglist/CMakeLists.txt index 20e2dff1b13..e88b37696fc 100644 --- a/searchlib/src/tests/attribute/postinglist/CMakeLists.txt +++ b/searchlib/src/tests/attribute/postinglist/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_postinglist_test_app TEST postinglist_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_postinglist_test_app COMMAND searchlib_postinglist_test_app) diff --git a/searchlib/src/tests/attribute/postinglist/postinglist_test.cpp b/searchlib/src/tests/attribute/postinglist/postinglist_test.cpp index c6b627f97e2..16b28d038c5 100644 --- a/searchlib/src/tests/attribute/postinglist/postinglist_test.cpp +++ b/searchlib/src/tests/attribute/postinglist/postinglist_test.cpp @@ -8,7 +8,7 @@ #include <vespa/vespalib/btree/btreestore.hpp> #include <vespa/vespalib/datastore/datastore.h> #include <vespa/vespalib/util/rand48.h> -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/gtest/gtest.h> #include <set> #include <map> #include <cinttypes> @@ -24,9 +24,9 @@ using vespalib::GenerationHandler; * TODO: Make it pass MALLOC_OPTIONS=AJ on freebsd and valgrind on Linux. */ -class AttributePostingListTest : public vespalib::TestApp +class AttributePostingListTest : public ::testing::Test { -private: +protected: /* Limited STL version for validation of full version */ using STLPostingList = std::set<uint32_t>; using STLValueTree = std::map<int, STLPostingList>; @@ -96,7 +96,6 @@ private: }; std::vector<RandomValue> _randomValues; -public: using IntKeyStore = vespalib::datastore::DataStore<int>; using AttributePosting = vespalib::btree::BTreeKeyData<uint32_t, vespalib::btree::BTreeNoLeafData>; using PostingList = vespalib::btree::BTreeStore<uint32_t, @@ -134,7 +133,7 @@ public: using TreeManager = IntEnumNodeAllocator; using ValueHandle = IntKeyStore; using RandomValuesVector = std::vector<RandomValue>; -private: + GenerationHandler _handler; IntKeyStore *_intKeyStore; IntEnumNodeAllocator *_intNodeAlloc; @@ -210,15 +209,12 @@ private: { return frozen ? "frozen" : "thawed"; } -public: AttributePostingListTest(); - ~AttributePostingListTest(); - - int Main() override; + ~AttributePostingListTest() override; }; AttributePostingListTest::AttributePostingListTest() - : vespalib::TestApp(), + : ::testing::Test(), _randomValues(), _handler(), _intKeyStore(NULL), @@ -228,7 +224,8 @@ AttributePostingListTest::AttributePostingListTest() _stlTree(NULL), _randomGenerator() {} -AttributePostingListTest::~AttributePostingListTest() {} + +AttributePostingListTest::~AttributePostingListTest() = default; void AttributePostingListTest::allocTree() @@ -368,7 +365,7 @@ insertRandomValues(Tree &tree, } else { } ASSERT_TRUE(itr.valid()); - EXPECT_EQUAL(i->_value, valueHandle.getEntry(itr.getKey())); + EXPECT_EQ(i->_value, valueHandle.getEntry(itr.getKey())); /* TODO: Insert docid to postinglist */ PostingIdx oldIdx = itr.getData(); @@ -669,30 +666,21 @@ reclaim_memory(Tree &tree, postings.reclaim_memory(_handler.get_oldest_used_generation()); } -int -AttributePostingListTest::Main() +TEST_F(AttributePostingListTest, test_posting_list) { - TEST_INIT("postinglist_test"); - fillRandomValues(1000, 10); allocTree(); - insertRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, - _stlTree, _randomValues); - lookupRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, - _stlTree, _randomValues); + ASSERT_NO_FATAL_FAILURE(insertRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, _stlTree, _randomValues)); + ASSERT_NO_FATAL_FAILURE(lookupRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, _stlTree, _randomValues)); _intNodeAlloc->freeze(); _intNodeAlloc->assign_generation(_handler.getCurrentGeneration()); doCompactEnumStore(*_intTree, *_intNodeAlloc, *_intKeyStore); - removeRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, - _stlTree, _randomValues); - insertRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, - _stlTree, _randomValues); + ASSERT_NO_FATAL_FAILURE(removeRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, _stlTree, _randomValues)); + ASSERT_NO_FATAL_FAILURE(insertRandomValues(*_intTree, *_intNodeAlloc, *_intKeyStore, *_intPostings, _stlTree, _randomValues)); freeTree(true); - - TEST_DONE(); } } -TEST_APPHOOK(search::AttributePostingListTest); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/attribute/sourceselector/CMakeLists.txt b/searchlib/src/tests/attribute/sourceselector/CMakeLists.txt index 3c525a96b07..c70470852ba 100644 --- a/searchlib/src/tests/attribute/sourceselector/CMakeLists.txt +++ b/searchlib/src/tests/attribute/sourceselector/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_sourceselector_test_app TEST sourceselector_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_sourceselector_test_app COMMAND searchlib_sourceselector_test_app) diff --git a/searchlib/src/tests/attribute/sourceselector/sourceselector_test.cpp b/searchlib/src/tests/attribute/sourceselector/sourceselector_test.cpp index f9567f83edf..2d6806257e6 100644 --- a/searchlib/src/tests/attribute/sourceselector/sourceselector_test.cpp +++ b/searchlib/src/tests/attribute/sourceselector/sourceselector_test.cpp @@ -4,13 +4,10 @@ #include <vespa/searchlib/attribute/fixedsourceselector.h> #include <vespa/searchlib/index/dummyfileheadercontext.h> #include <vespa/searchcommon/common/undefinedvalues.h> -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/vespalib/util/size_literals.h> #include <filesystem> -#include <vespa/log/log.h> -LOG_SETUP("sourceselector_test"); - using std::unique_ptr; using std::string; using namespace search; @@ -37,47 +34,17 @@ uint8_t capSource(uint8_t source, uint8_t defaultSource, bool cap) { return (cap ? std::min(source, defaultSource) : source); } -class Test : public vespalib::TestApp +class SourceSelectorTest : public ::testing::Test { -public: - int Main() override; -private: +protected: + SourceSelectorTest(); + ~SourceSelectorTest() override; void testSourceSelector(const DocSource *docSource, size_t sz, uint8_t defaultSource, ISourceSelector & selector, bool cap); - void testFixed(const DocSource *docSource, size_t sz); - template <typename SelectorType> - void requireThatSelectorCanCloneAndSubtract(); - void requireThatSelectorCanCloneAndSubtract(); - template <typename SelectorType> void requireThatSelectorCanSaveAndLoad(bool compactLidSpace); - void requireThatSelectorCanSaveAndLoad(); - template <typename SelectorType> - void requireThatCompleteSourceRangeIsHandled(); - void requireThatCompleteSourceRangeIsHandled(); - template <typename SelectorType> - void requireThatSourcesAreCountedCorrectly(); - void requireThatSourcesAreCountedCorrectly(); - void requireThatDocIdLimitIsCorrect(); - void requireThatCorrectDefaultValueIsUsedAfterCompaction(); }; -int -Test::Main() -{ - TEST_INIT("sourceselector_test"); - - if (_argc > 0) { - DummyFileHeaderContext::setCreator(_argv[0]); - } - testFixed(docs, arraysize(docs)); - TEST_DO(requireThatSelectorCanCloneAndSubtract()); - TEST_DO(requireThatSelectorCanSaveAndLoad()); - TEST_DO(requireThatCompleteSourceRangeIsHandled()); - TEST_DO(requireThatSourcesAreCountedCorrectly()); - TEST_DO(requireThatDocIdLimitIsCorrect()); - TEST_DO(requireThatCorrectDefaultValueIsUsedAfterCompaction()); - - TEST_DONE(); -} +SourceSelectorTest::SourceSelectorTest() = default; +SourceSelectorTest::~SourceSelectorTest() = default; void setSources(ISourceSelector &selector) { for (size_t i = 0; i < arraysize(docs); ++i) { @@ -85,75 +52,75 @@ void setSources(ISourceSelector &selector) { } } -void Test::testFixed(const DocSource *docSource, size_t sz) +TEST_F(SourceSelectorTest, test_fixed) { + const DocSource *docSource = docs; + size_t sz = arraysize(docs); FixedSourceSelector selector(default_source, base_file_name, 10); - EXPECT_EQUAL(default_source, selector.getDefaultSource()); - EXPECT_EQUAL(10u, selector.getDocIdLimit()); -// EXPECT_EQUAL(default_source, selector.createIterator()->getSource(maxDocId + 1)); + EXPECT_EQ(default_source, selector.getDefaultSource()); + EXPECT_EQ(10u, selector.getDocIdLimit()); setSources(selector); + /* + * One extra element beyond highest explicitly set element is + * initialized to accommodate a match loop optimization. See + * setSource() and reserve() member functions in + * FixedSourceSelector for details. + */ + EXPECT_EQ(default_source, selector.createIterator()->getSource(maxDocId + 1)); testSourceSelector(docSource, sz, selector.getDefaultSource(), selector, false); - EXPECT_EQUAL(maxDocId+1, selector.getDocIdLimit()); + EXPECT_EQ(maxDocId+1, selector.getDocIdLimit()); } -void Test::testSourceSelector(const DocSource *docSource, size_t sz, - uint8_t defaultSource, ISourceSelector &selector, bool cap) +void +SourceSelectorTest::testSourceSelector(const DocSource *docSource, size_t sz, + uint8_t defaultSource, ISourceSelector &selector, bool cap) { { auto it(selector.createIterator()); for (size_t i = 0; i < sz; ++i) { - EXPECT_EQUAL((uint32_t)capSource(docSource[i].source, defaultSource, cap), (uint32_t)it->getSource(docSource[i].docId)); + EXPECT_EQ((uint32_t)capSource(docSource[i].source, defaultSource, cap), (uint32_t)it->getSource(docSource[i].docId)); } } { auto it(selector.createIterator()); for (size_t i = 0, j = 0; i <= docSource[sz - 1].docId; ++i) { if (i != docSource[j].docId) { - EXPECT_EQUAL((uint32_t)defaultSource, (uint32_t)it->getSource(i)); + EXPECT_EQ((uint32_t)defaultSource, (uint32_t)it->getSource(i)); } else { - EXPECT_EQUAL((uint32_t)capSource(docSource[j].source, defaultSource, cap), (uint32_t)it->getSource(i)); + EXPECT_EQ((uint32_t)capSource(docSource[j].source, defaultSource, cap), (uint32_t)it->getSource(i)); ++j; } } } } -template <typename SelectorType> -void -Test::requireThatSelectorCanCloneAndSubtract() +TEST_F(SourceSelectorTest, require_that_selector_can_clone_and_subtract) { - SelectorType selector(default_source, base_file_name); + FixedSourceSelector selector(default_source, base_file_name); setSources(selector); selector.setBaseId(base_id); const uint32_t diff = 3; - typename SelectorType::UP - new_selector(selector.cloneAndSubtract(base_file_name2, diff)); - EXPECT_EQUAL(default_source - diff, new_selector->getDefaultSource()); - EXPECT_EQUAL(base_id + diff, new_selector->getBaseId()); - EXPECT_EQUAL(maxDocId+1, new_selector->getDocIdLimit()); + auto new_selector(selector.cloneAndSubtract(base_file_name2, diff)); + EXPECT_EQ(default_source - diff, new_selector->getDefaultSource()); + EXPECT_EQ(base_id + diff, new_selector->getBaseId()); + EXPECT_EQ(maxDocId+1, new_selector->getDocIdLimit()); auto it(new_selector->createIterator()); for(size_t i = 0; i < arraysize(docs); ++i) { if (docs[i].source > diff) { - EXPECT_EQUAL(docs[i].source - diff, it->getSource(docs[i].docId)); + EXPECT_EQ(docs[i].source - diff, it->getSource(docs[i].docId)); } else { - EXPECT_EQUAL(0, it->getSource(docs[i].docId)); + EXPECT_EQ(0, it->getSource(docs[i].docId)); } } } void -Test::requireThatSelectorCanCloneAndSubtract() -{ - requireThatSelectorCanCloneAndSubtract<FixedSourceSelector>(); -} - -template <typename SelectorType> -void -Test::requireThatSelectorCanSaveAndLoad(bool compactLidSpace) +SourceSelectorTest::requireThatSelectorCanSaveAndLoad(bool compactLidSpace) { - SelectorType selector(default_source, base_file_name2); + SCOPED_TRACE(compactLidSpace ? "compactLidSpace=true" : "compactLidSpace=false"); + FixedSourceSelector selector(default_source, base_file_name2); setSources(selector); selector.setBaseId(base_id); selector.setSource(maxDocId + 1, default_source); @@ -167,105 +134,93 @@ Test::requireThatSelectorCanSaveAndLoad(bool compactLidSpace) SourceSelector::SaveInfo::UP save_info = selector.extractSaveInfo(base_file_name); save_info->save(TuneFileAttributes(), DummyFileHeaderContext()); - typename SelectorType::UP - selector2(SelectorType::load(base_file_name, default_source + base_id)); + auto selector2(FixedSourceSelector::load(base_file_name, default_source + base_id)); testSourceSelector(docs, arraysize(docs) - compactLidSpace, default_source, *selector2, true); - EXPECT_EQUAL(base_id, selector2->getBaseId()); + EXPECT_EQ(base_id, selector2->getBaseId()); if (compactLidSpace) { - EXPECT_EQUAL(maxDocId - 4, selector2->getDocIdLimit()); + EXPECT_EQ(maxDocId - 4, selector2->getDocIdLimit()); } else { - EXPECT_EQUAL(maxDocId + 2, selector2->getDocIdLimit()); + EXPECT_EQ(maxDocId + 2, selector2->getDocIdLimit()); } std::filesystem::remove_all(std::filesystem::path(index_dir)); } -void -Test::requireThatSelectorCanSaveAndLoad() +TEST_F(SourceSelectorTest, require_that_selector_can_save_and_Load) { - requireThatSelectorCanSaveAndLoad<FixedSourceSelector>(false); - requireThatSelectorCanSaveAndLoad<FixedSourceSelector>(true); + requireThatSelectorCanSaveAndLoad(false); + requireThatSelectorCanSaveAndLoad(true); } -template <typename SelectorType> -void -Test::requireThatCompleteSourceRangeIsHandled() +TEST_F(SourceSelectorTest, require_that_complete_source_range_is_handled) { - SelectorType selector(default_source, base_file_name); + FixedSourceSelector selector(default_source, base_file_name); for (uint32_t i = 0; i < ISourceSelector::SOURCE_LIMIT; ++i) { selector.setSource(i, i); } auto itr = selector.createIterator(); for (uint32_t i = 0; i < ISourceSelector::SOURCE_LIMIT; ++i) { - EXPECT_EQUAL((queryeval::Source)i, itr->getSource(i)); + EXPECT_EQ((queryeval::Source)i, itr->getSource(i)); } } -void -Test::requireThatCompleteSourceRangeIsHandled() -{ - requireThatCompleteSourceRangeIsHandled<FixedSourceSelector>(); -} - -template <typename SelectorType> -void -Test::requireThatSourcesAreCountedCorrectly() +TEST_F(SourceSelectorTest, require_that_sources_are_counted_correctly) { - SelectorType selector(default_source, base_file_name); + FixedSourceSelector selector(default_source, base_file_name); for (uint32_t i = 0; i < 256; ++i) { selector.setSource(i, i%16); } SourceSelector::Histogram hist = selector.getDistribution(); for (uint32_t i = 0; i < 16; ++i) { - EXPECT_EQUAL(16u, hist[i]); + EXPECT_EQ(16u, hist[i]); } for (uint32_t i = 16; i < 256; ++i) { - EXPECT_EQUAL(0u, hist[i]); + EXPECT_EQ(0u, hist[i]); } } -void -Test::requireThatSourcesAreCountedCorrectly() -{ - requireThatSourcesAreCountedCorrectly<FixedSourceSelector>(); -} - -void -Test::requireThatDocIdLimitIsCorrect() +TEST_F(SourceSelectorTest, require_that_doc_id_limit_is_correct) { FixedSourceSelector selector(default_source, base_file_name); - EXPECT_EQUAL(0u, selector.getDocIdLimit()); + EXPECT_EQ(0u, selector.getDocIdLimit()); selector.setSource(8, 10); - EXPECT_EQUAL(9u, selector.getDocIdLimit()); + EXPECT_EQ(9u, selector.getDocIdLimit()); selector.compactLidSpace(4); - EXPECT_EQUAL(4u, selector.getDocIdLimit()); + EXPECT_EQ(4u, selector.getDocIdLimit()); selector.setSource(6, 10); - EXPECT_EQUAL(7u, selector.getDocIdLimit()); + EXPECT_EQ(7u, selector.getDocIdLimit()); auto selector2 = selector.cloneAndSubtract(base_file_name2, 3); - EXPECT_EQUAL(7u, selector2->getDocIdLimit()); + EXPECT_EQ(7u, selector2->getDocIdLimit()); } -void -Test::requireThatCorrectDefaultValueIsUsedAfterCompaction() +TEST_F(SourceSelectorTest, require_that_correct_default_value_is_used_after_compaction) { FixedSourceSelector selector(default_source, base_file_name); - EXPECT_EQUAL(0u, selector.getDocIdLimit()); + EXPECT_EQ(0u, selector.getDocIdLimit()); auto it(selector.createIterator()); selector.setSource(8, 4); - EXPECT_EQUAL(default_source, (uint32_t) it->getSource(9)); - EXPECT_EQUAL(default_source, (uint32_t) it->getSource(6)); + EXPECT_EQ(default_source, (uint32_t) it->getSource(9)); + EXPECT_EQ(default_source, (uint32_t) it->getSource(6)); selector.compactLidSpace(4); - EXPECT_EQUAL(4u, selector.getDocIdLimit()); - EXPECT_EQUAL(default_source, (uint32_t) it->getSource(4)); - EXPECT_EQUAL(invalid_source, (uint32_t) it->getSource(5)); // beyond guard + EXPECT_EQ(4u, selector.getDocIdLimit()); + EXPECT_EQ(default_source, (uint32_t) it->getSource(4)); + EXPECT_EQ(invalid_source, (uint32_t) it->getSource(5)); // beyond guard selector.setSource(6, 4); - EXPECT_EQUAL(7u, selector.getDocIdLimit()); - EXPECT_EQUAL(default_source, (uint32_t) it->getSource(5)); - EXPECT_EQUAL(4u, (uint8_t) it->getSource(6)); - EXPECT_EQUAL(default_source, (uint32_t) it->getSource(7)); + EXPECT_EQ(7u, selector.getDocIdLimit()); + EXPECT_EQ(default_source, (uint32_t) it->getSource(5)); + EXPECT_EQ(4u, (uint8_t) it->getSource(6)); + EXPECT_EQ(default_source, (uint32_t) it->getSource(7)); } } // namespace -TEST_APPHOOK(Test); +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/diskindex/bitvector/CMakeLists.txt b/searchlib/src/tests/diskindex/bitvector/CMakeLists.txt index b227d3d5fa8..f70a1efd23c 100644 --- a/searchlib/src/tests/diskindex/bitvector/CMakeLists.txt +++ b/searchlib/src/tests/diskindex/bitvector/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_bitvector_test-diskindex_app TEST bitvector_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_bitvector_test-diskindex_app COMMAND searchlib_bitvector_test-diskindex_app) diff --git a/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp b/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp index 6032b7156ff..5e4b8763534 100644 --- a/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp +++ b/searchlib/src/tests/diskindex/bitvector/bitvector_test.cpp @@ -1,16 +1,13 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/searchlib/index/field_length_info.h> #include <vespa/searchlib/diskindex/bitvectordictionary.h> #include <vespa/searchlib/diskindex/fieldwriter.h> #include <vespa/searchlib/index/dummyfileheadercontext.h> #include <vespa/searchcommon/common/schema.h> +#include <vespa/vespalib/gtest/gtest.h> #include <filesystem> -#include <vespa/log/log.h> -LOG_SETUP("bitvector_test"); - using namespace search::index; using search::index::schema::DataType; @@ -58,38 +55,57 @@ FieldWriterWrapper::add(uint32_t docId) daf.elements().emplace_back(0); daf.elements().back().setNumOccs(1); daf.word_positions().emplace_back(0); - //LOG(info, "add(%" PRIu64 ", %u)", wordNum, docId); _writer.add(daf); return *this; } -class Test : public vespalib::TestApp +struct TestParam { + bool directio; + bool readmmap; +}; + +std::ostream& operator<<(std::ostream& os, const TestParam& param) +{ + os << (param.directio ? "directio" : "normal") << (param.readmmap ? "mmap" : "read"); + return os; +} + +class BitVectorTest : public ::testing::TestWithParam<TestParam> { -private: +protected: Schema _schema; uint32_t _indexId; -public: - void requireThatDictionaryHandlesNoEntries(bool directio, bool readmmap); - void requireThatDictionaryHandlesMultipleEntries(bool directio, bool readmmap); - - Test(); - ~Test() override; - int Main() override; + BitVectorTest(); + ~BitVectorTest() override; }; -void -Test::requireThatDictionaryHandlesNoEntries(bool directio, bool readmmap) +BitVectorTest::BitVectorTest() + : ::testing::TestWithParam<TestParam>(), + _schema(), + _indexId(0) +{ + _schema.addIndexField(Schema::IndexField("f1", DataType::STRING)); +} + +BitVectorTest::~BitVectorTest() = default; + +INSTANTIATE_TEST_SUITE_P(BitVectorMultiTest, BitVectorTest, + ::testing::Values(TestParam{false, false}, TestParam{true, false}, TestParam{false, true}), + ::testing::PrintToStringParamName()); + +TEST_P(BitVectorTest, require_that_dictionary_handles_no_entries) { TuneFileSeqWrite tuneFileWrite; TuneFileRandRead tuneFileRead; DummyFileHeaderContext fileHeaderContext; - if (directio) { + if (GetParam().directio) { tuneFileWrite.setWantDirectIO(); tuneFileRead.setWantDirectIO(); } - if (readmmap) + if (GetParam().readmmap) { tuneFileRead.setWantMemoryMap(); + } std::filesystem::create_directory(std::filesystem::path("dump")); FieldWriterWrapper fww(5, 2, "dump/1/"); EXPECT_TRUE(fww.open(_schema, _indexId, tuneFileWrite, fileHeaderContext)); @@ -100,25 +116,25 @@ Test::requireThatDictionaryHandlesNoEntries(bool directio, bool readmmap) BitVectorDictionary dict; BitVectorKeyScope bvScope(BitVectorKeyScope::PERFIELD_WORDS); EXPECT_TRUE(dict.open("dump/1/", tuneFileRead, bvScope)); - EXPECT_EQUAL(5u, dict.getDocIdLimit()); - EXPECT_EQUAL(0u, dict.getEntries().size()); + EXPECT_EQ(5u, dict.getDocIdLimit()); + EXPECT_EQ(0u, dict.getEntries().size()); EXPECT_FALSE(dict.lookup(1)); EXPECT_FALSE(dict.lookup(2)); } -void -Test::requireThatDictionaryHandlesMultipleEntries(bool directio, bool readmmap) +TEST_P(BitVectorTest, require_that_dictionary_handles_multiple_entries) { TuneFileSeqWrite tuneFileWrite; TuneFileRandRead tuneFileRead; DummyFileHeaderContext fileHeaderContext; - if (directio) { + if (GetParam().directio) { tuneFileWrite.setWantDirectIO(); tuneFileRead.setWantDirectIO(); } - if (readmmap) + if (GetParam().readmmap) { tuneFileRead.setWantMemoryMap(); + } FieldWriterWrapper fww(64, 6, "dump/2/"); EXPECT_TRUE(fww.open(_schema, _indexId, tuneFileWrite, fileHeaderContext)); // must have >16 docs in order to create bitvector for a word @@ -149,16 +165,16 @@ Test::requireThatDictionaryHandlesMultipleEntries(bool directio, bool readmmap) BitVectorDictionary dict; BitVectorKeyScope bvScope(BitVectorKeyScope::PERFIELD_WORDS); EXPECT_TRUE(dict.open("dump/2/", tuneFileRead, bvScope)); - EXPECT_EQUAL(64u, dict.getDocIdLimit()); - EXPECT_EQUAL(2u, dict.getEntries().size()); + EXPECT_EQ(64u, dict.getDocIdLimit()); + EXPECT_EQ(2u, dict.getEntries().size()); BitVectorWordSingleKey e; e = dict.getEntries()[0]; - EXPECT_EQUAL(1u, e._wordNum); - EXPECT_EQUAL(17u, e._numDocs); + EXPECT_EQ(1u, e._wordNum); + EXPECT_EQ(17u, e._numDocs); e = dict.getEntries()[1]; - EXPECT_EQUAL(5u, e._wordNum); - EXPECT_EQUAL(23u, e._numDocs); + EXPECT_EQ(5u, e._wordNum); + EXPECT_EQ(23u, e._numDocs); EXPECT_FALSE(dict.lookup(2)); EXPECT_FALSE(dict.lookup(3)); @@ -174,33 +190,14 @@ Test::requireThatDictionaryHandlesMultipleEntries(bool directio, bool readmmap) EXPECT_TRUE(*bv5exp == *bv5act); } -Test::Test() - : _schema(), - _indexId(0) -{ - _schema.addIndexField(Schema::IndexField("f1", DataType::STRING)); } -Test::~Test() = default; - int -Test::Main() +main(int argc, char* argv[]) { - TEST_INIT("bitvector_test"); - - if (_argc > 0) { - DummyFileHeaderContext::setCreator(_argv[0]); + ::testing::InitGoogleTest(&argc, argv); + if (argc > 0) { + search::index::DummyFileHeaderContext::setCreator(argv[0]); } - TEST_DO(requireThatDictionaryHandlesNoEntries(false, false)); - TEST_DO(requireThatDictionaryHandlesMultipleEntries(false, false)); - TEST_DO(requireThatDictionaryHandlesNoEntries(true, false)); - TEST_DO(requireThatDictionaryHandlesMultipleEntries(true, false)); - TEST_DO(requireThatDictionaryHandlesNoEntries(false, true)); - TEST_DO(requireThatDictionaryHandlesMultipleEntries(false, true)); - - TEST_DONE(); + return RUN_ALL_TESTS(); } - -} - -TEST_APPHOOK(search::diskindex::Test); diff --git a/searchlib/src/tests/expression/interpolated_document_field_lookup_node/CMakeLists.txt b/searchlib/src/tests/expression/interpolated_document_field_lookup_node/CMakeLists.txt new file mode 100644 index 00000000000..267848d9468 --- /dev/null +++ b/searchlib/src/tests/expression/interpolated_document_field_lookup_node/CMakeLists.txt @@ -0,0 +1,8 @@ +# Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +vespa_add_executable(searchlib_interpolated_document_field_lookup_node_test_app + SOURCES + interpolated_document_field_lookup_node_test.cpp + DEPENDS + searchlib_test +) +vespa_add_test(NAME searchlib_interpolated_document_field_lookup_node_test_app COMMAND searchlib_interpolated_document_field_lookup_node_test_app) diff --git a/searchlib/src/tests/expression/interpolated_document_field_lookup_node/interpolated_document_field_lookup_node_test.cpp b/searchlib/src/tests/expression/interpolated_document_field_lookup_node/interpolated_document_field_lookup_node_test.cpp new file mode 100644 index 00000000000..c131efcacb2 --- /dev/null +++ b/searchlib/src/tests/expression/interpolated_document_field_lookup_node/interpolated_document_field_lookup_node_test.cpp @@ -0,0 +1,98 @@ +// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. + +#include <vespa/document/fieldvalue/arrayfieldvalue.h> +#include <vespa/document/fieldvalue/document.h> +#include <vespa/document/fieldvalue/doublefieldvalue.h> +#include <vespa/document/repo/configbuilder.h> +#include <vespa/searchlib/expression/constantnode.h> +#include <vespa/searchlib/expression/floatresultnode.h> +#include <vespa/searchlib/expression/interpolated_document_field_lookup_node.h> +#include <vespa/searchlib/test/doc_builder.h> +#include <vespa/vespalib/gtest/gtest.h> + +using document::DataType; +using document::Document; +using document::DoubleFieldValue; +using search::expression::ConstantNode; +using search::expression::DocumentAccessorNode; +using search::expression::FloatResultNode; +using search::expression::InterpolatedDocumentFieldLookupNode; +using search::test::DocBuilder; + +const vespalib::string field_name("f"); + +struct Fixture { + DocBuilder _builder; + std::unique_ptr<Document> _doc; + std::unique_ptr<DocumentAccessorNode> _node; + + Fixture(); + ~Fixture(); + + Fixture& setup_doc(std::vector<double> field_value); + Fixture& setup_node(double lookup_value); + double evaluate(); +}; + +Fixture::Fixture() + : _builder([](auto& header) + { header.addField(field_name, document::config_builder::Array(DataType::T_DOUBLE)); }), + _doc(_builder.make_document("id:ns:searchdocument::0")), + _node() +{ +} + +Fixture::~Fixture() = default; + + +Fixture& +Fixture::setup_doc(std::vector<double> field_value) +{ + auto array = _builder.make_array(field_name); + for (auto& v : field_value) { + array.add(DoubleFieldValue(v)); + } + _doc->setValue(field_name, array); + return *this; +} + +Fixture& +Fixture::setup_node(double lookup_value) +{ + _node = std::make_unique<InterpolatedDocumentFieldLookupNode>(field_name, std::make_unique<ConstantNode>(std::make_unique<FloatResultNode>(lookup_value))); + _node->prepare(true); + _node->setDocType(_doc->getType()); + _node->setDoc(*_doc); + return *this; +} + +double +Fixture::evaluate() +{ + EXPECT_TRUE(_node->execute()); + return _node->getResult()->getFloat(); +} + + +class InterpolatedDocumentFieldLookupNodeTest : public Fixture, + public ::testing::Test +{ +protected: + InterpolatedDocumentFieldLookupNodeTest(); + ~InterpolatedDocumentFieldLookupNodeTest() override; +}; + +InterpolatedDocumentFieldLookupNodeTest::InterpolatedDocumentFieldLookupNodeTest() = default; +InterpolatedDocumentFieldLookupNodeTest::~InterpolatedDocumentFieldLookupNodeTest() = default; + +TEST_F(InterpolatedDocumentFieldLookupNodeTest, test_interpolated_lookup_in_document_field) +{ + EXPECT_EQ(0.0, setup_doc({ 2, 10 }).setup_node(1.0).evaluate()); + EXPECT_EQ(0.0, setup_node(2.0).evaluate()); + EXPECT_EQ(0.3125, setup_node(4.5).evaluate()); + EXPECT_EQ(1.0, setup_node(10).evaluate()); + EXPECT_EQ(1.0, setup_node(11).evaluate()); + EXPECT_EQ(2.5, setup_doc({1.5, 5.25, 8.0, 14.0 }).evaluate()); +} + +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/fef/attributecontent/CMakeLists.txt b/searchlib/src/tests/fef/attributecontent/CMakeLists.txt index 48d8375dbb9..d9c88fb9eaf 100644 --- a/searchlib/src/tests/fef/attributecontent/CMakeLists.txt +++ b/searchlib/src/tests/fef/attributecontent/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_attributecontent_test_app TEST attributecontent_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_attributecontent_test_app COMMAND searchlib_attributecontent_test_app) diff --git a/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp b/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp index 1c75d47a134..d501d259ea5 100644 --- a/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp +++ b/searchlib/src/tests/fef/attributecontent/attributecontent_test.cpp @@ -1,34 +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/searchcommon/attribute/attributecontent.h> #include <vespa/searchcommon/attribute/config.h> #include <vespa/searchlib/attribute/attributefactory.h> #include <vespa/searchlib/attribute/integerbase.h> -#include <vespa/log/log.h> -LOG_SETUP("attributecontent_test"); +#include <vespa/vespalib/gtest/gtest.h> using namespace search::attribute; -namespace search { -namespace fef { +namespace search::fef { -class Test : public vespalib::TestApp { -private: - void testWriteAndRead(); - void testFill(); - -public: - int Main() override; -}; - -void -Test::testWriteAndRead() +TEST(AttributeContentTest, test_write_and_read) { using UintContent = search::attribute::AttributeContent<uint32_t>; UintContent buf; - EXPECT_EQUAL(buf.capacity(), 16u); - EXPECT_EQUAL(buf.size(), 0u); + EXPECT_EQ(buf.capacity(), 16u); + EXPECT_EQ(buf.size(), 0u); uint32_t i; uint32_t * data; @@ -37,34 +24,33 @@ Test::testWriteAndRead() *data = i; } buf.setSize(16); - EXPECT_EQUAL(buf.size(), 16u); + EXPECT_EQ(buf.size(), 16u); for (i = 0, itr = buf.begin(); itr != buf.end(); ++i, ++itr) { - EXPECT_EQUAL(*itr, i); - EXPECT_EQUAL(buf[i], i); + EXPECT_EQ(*itr, i); + EXPECT_EQ(buf[i], i); } - EXPECT_EQUAL(i, 16u); + EXPECT_EQ(i, 16u); buf.allocate(10); - EXPECT_EQUAL(buf.capacity(), 16u); - EXPECT_EQUAL(buf.size(), 16u); + EXPECT_EQ(buf.capacity(), 16u); + EXPECT_EQ(buf.size(), 16u); buf.allocate(32); - EXPECT_EQUAL(buf.capacity(), 32u); - EXPECT_EQUAL(buf.size(), 0u); + EXPECT_EQ(buf.capacity(), 32u); + EXPECT_EQ(buf.size(), 0u); for (i = 0, data = buf.data(); i < 32; ++i, ++data) { *data = i; } buf.setSize(32); - EXPECT_EQUAL(buf.size(), 32u); + EXPECT_EQ(buf.size(), 32u); for (i = 0, itr = buf.begin(); itr != buf.end(); ++i, ++itr) { - EXPECT_EQUAL(*itr, i); - EXPECT_EQUAL(buf[i], i); + EXPECT_EQ(*itr, i); + EXPECT_EQ(buf[i], i); } - EXPECT_EQUAL(i, 32u); + EXPECT_EQ(i, 32u); } -void -Test::testFill() +TEST(AttributeContentTest, test_fill) { Config cfg(BasicType::INT32, CollectionType::ARRAY); AttributeVector::SP av = AttributeFactory::createAttribute("aint32", cfg); @@ -77,29 +63,17 @@ Test::testFill() const IAttributeVector & iav = *av.get(); IntegerContent buf; buf.fill(iav, 0); - EXPECT_EQUAL(1u, buf.size()); - EXPECT_EQUAL(10, buf[0]); + EXPECT_EQ(1u, buf.size()); + EXPECT_EQ(10, buf[0]); buf.fill(iav, 1); - EXPECT_EQUAL(2u, buf.size()); - EXPECT_EQUAL(20, buf[0]); - EXPECT_EQUAL(30, buf[1]); + EXPECT_EQ(2u, buf.size()); + EXPECT_EQ(20, buf[0]); + EXPECT_EQ(30, buf[1]); buf.fill(iav, 0); - EXPECT_EQUAL(1u, buf.size()); - EXPECT_EQUAL(10, buf[0]); + EXPECT_EQ(1u, buf.size()); + EXPECT_EQ(10, buf[0]); } -int -Test::Main() -{ - TEST_INIT("attributecontent_test"); - - testWriteAndRead(); - testFill(); - - TEST_DONE(); } -} // namespace fef -} // namespace search - -TEST_APPHOOK(search::fef::Test); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt b/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt index e7874558122..cb040472a6f 100644 --- a/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt +++ b/searchlib/src/tests/fef/featurenameparser/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_featurenameparser_test_app TEST featurenameparser_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_featurenameparser_test_app COMMAND searchlib_featurenameparser_test_app) diff --git a/searchlib/src/tests/fef/featurenameparser/featurenameparser_test.cpp b/searchlib/src/tests/fef/featurenameparser/featurenameparser_test.cpp index 90a9135389a..ee22a49f8db 100644 --- a/searchlib/src/tests/fef/featurenameparser/featurenameparser_test.cpp +++ b/searchlib/src/tests/fef/featurenameparser/featurenameparser_test.cpp @@ -1,13 +1,15 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/log/log.h> -LOG_SETUP("featurenameparser_test"); -#include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/vespalib/testkit/testapp.h> -#include <vespa/vespalib/util/size_literals.h> + #include <vespa/searchlib/fef/featurenameparser.h> +#include <vespa/vespalib/gtest/gtest.h> +#include <vespa/vespalib/testkit/test_path.h> +#include <vespa/vespalib/util/size_literals.h> #include <vector> #include <string> +#include <vespa/log/log.h> +LOG_SETUP("featurenameparser_test"); + using namespace search::fef; struct ParamList { @@ -31,20 +33,10 @@ std::ostream &operator<<(std::ostream &os, const ParamList &pl) { return os; } -class Test : public vespalib::TestApp -{ -public: - bool testParse(const vespalib::string &input, bool valid, - const vespalib::string &base, ParamList pl, - const vespalib::string &output); - void testFile(const vespalib::string &name); - int Main() override; -}; - bool -Test::testParse(const vespalib::string &input, bool valid, - const vespalib::string &base, ParamList pl, - const vespalib::string &output) +testParse(const vespalib::string &input, bool valid, + const vespalib::string &base, ParamList pl, + const vespalib::string &output) { bool ok = true; FeatureNameParser parser(input); @@ -52,15 +44,15 @@ Test::testParse(const vespalib::string &input, bool valid, LOG(warning, "parse error: input:'%s', rest:'%s'", input.c_str(), input.substr(parser.parsedBytes()).c_str()); } - ok &= EXPECT_EQUAL(parser.valid(), valid); - ok &= EXPECT_EQUAL(parser.baseName(), base); - ok &= EXPECT_EQUAL(ParamList(parser.parameters()), pl); - ok &= EXPECT_EQUAL(parser.output(), output); + EXPECT_EQ(parser.valid(), valid) << (ok = false, ""); + EXPECT_EQ(parser.baseName(), base) << (ok = false, ""); + EXPECT_EQ(ParamList(parser.parameters()), pl) << (ok = false, ""); + EXPECT_EQ(parser.output(), output) << (ok = false, ""); return ok; } void -Test::testFile(const vespalib::string &name) +testFile(const vespalib::string &name) { char buf[4_Ki]; uint32_t lineN = 0; @@ -76,13 +68,16 @@ Test::testFile(const vespalib::string &name) continue; } uint32_t idx = line.find("<=>"); - if (!EXPECT_TRUE(idx < line.size())) { + bool failed = false; + EXPECT_TRUE(idx < line.size()) << (failed = true, ""); + if (failed) { LOG(error, "(%s:%u): malformed line: '%s'", name.c_str(), lineN, line.c_str()); } else { vespalib::string input = line.substr(0, idx); vespalib::string expect = line.substr(idx + strlen("<=>")); - if (!EXPECT_EQUAL(FeatureNameParser(input).featureName(), expect)) { + EXPECT_EQ(FeatureNameParser(input).featureName(), expect) << (failed = true, ""); + if (failed) { LOG(error, "(%s:%u): test failed: '%s'", name.c_str(), lineN, line.c_str()); } @@ -92,42 +87,54 @@ Test::testFile(const vespalib::string &name) fclose(f); } -int -Test::Main() +TEST(FeatureNameParserTest, test_normal_cases) { - TEST_INIT("featurenameparser_test"); - // normal cases EXPECT_TRUE(testParse("foo", true, "foo", ParamList(), "")); EXPECT_TRUE(testParse("foo.out", true, "foo", ParamList(), "out")); EXPECT_TRUE(testParse("foo(a)", true, "foo", ParamList().add("a"), "")); EXPECT_TRUE(testParse("foo(a,b)", true, "foo", ParamList().add("a").add("b"), "")); EXPECT_TRUE(testParse("foo(a,b).out", true, "foo", ParamList().add("a").add("b"), "out")); +} +TEST(FeatureNameParserTest, test_0_in_feature_name) +{ // @ in feature name (for macros) EXPECT_TRUE(testParse("foo@", true, "foo@", ParamList(), "")); EXPECT_TRUE(testParse("foo@.out", true, "foo@", ParamList(), "out")); EXPECT_TRUE(testParse("foo@(a)", true, "foo@", ParamList().add("a"), "")); EXPECT_TRUE(testParse("foo@(a,b)", true, "foo@", ParamList().add("a").add("b"), "")); EXPECT_TRUE(testParse("foo@(a,b).out", true, "foo@", ParamList().add("a").add("b"), "out")); +} +TEST(FeatureNameParserTest, test_dollar_in_feature_name) +{ // $ in feature name (for macros) EXPECT_TRUE(testParse("foo$", true, "foo$", ParamList(), "")); EXPECT_TRUE(testParse("foo$.out", true, "foo$", ParamList(), "out")); EXPECT_TRUE(testParse("foo$(a)", true, "foo$", ParamList().add("a"), "")); EXPECT_TRUE(testParse("foo$(a,b)", true, "foo$", ParamList().add("a").add("b"), "")); EXPECT_TRUE(testParse("foo$(a,b).out", true, "foo$", ParamList().add("a").add("b"), "out")); +} +TEST(FeatureNameParserTest, test_de_quoting_of_parameters) +{ // de-quoting of parameters EXPECT_TRUE(testParse("foo(a,\"b\")", true, "foo", ParamList().add("a").add("b"), "")); EXPECT_TRUE(testParse("foo(a,\" b \")", true, "foo", ParamList().add("a").add(" b "), "")); EXPECT_TRUE(testParse("foo( \"a\" , \" b \" )", true, "foo", ParamList().add("a").add(" b "), "")); EXPECT_TRUE(testParse("foo(\"\\\"\\\\\\t\\n\\r\\f\\x20\")", true, "foo", ParamList().add("\"\\\t\n\r\f "), "")); +} +TEST(FeatureNameParserTest, test_no_default_output_when_ending_with_dot) +{ // only default output if '.' not specified EXPECT_TRUE(testParse("foo.", false, "", ParamList(), "")); EXPECT_TRUE(testParse("foo(a,b).", false, "", ParamList(), "")); +} +TEST(FeatureNameParserTest, test_string_cannot_end_in_parmeter_list) +{ // string cannot end in parameter list EXPECT_TRUE(testParse("foo(", false, "", ParamList(), "")); EXPECT_TRUE(testParse("foo(a", false, "", ParamList(), "")); @@ -135,7 +142,10 @@ Test::Main() EXPECT_TRUE(testParse("foo(a\\)", false, "", ParamList(), "")); EXPECT_TRUE(testParse("foo(a,", false, "", ParamList(), "")); EXPECT_TRUE(testParse("foo(a,b", false, "", ParamList(), "")); +} +TEST(FeatureNameParserTest, test_empty_parameters) +{ // empty parameters EXPECT_TRUE(testParse("foo()", true, "foo", ParamList().add(""), "")); EXPECT_TRUE(testParse("foo(,)", true, "foo", ParamList().add("").add(""), "")); @@ -144,9 +154,11 @@ Test::Main() EXPECT_TRUE(testParse("foo( )", true, "foo", ParamList().add(""), "")); EXPECT_TRUE(testParse("foo( , , )", true, "foo", ParamList().add("").add("").add(""), "")); EXPECT_TRUE(testParse("foo( \t , \n , \r , \f )", true, "foo", ParamList().add("").add("").add("").add(""), "")); +} +TEST(FeatureNameParserTest, test_cases_from_file) +{ testFile(TEST_PATH("parsetest.txt")); - TEST_DONE(); } -TEST_APPHOOK(Test); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/fef/parameter/CMakeLists.txt b/searchlib/src/tests/fef/parameter/CMakeLists.txt index da847e061f9..b238e09c98b 100644 --- a/searchlib/src/tests/fef/parameter/CMakeLists.txt +++ b/searchlib/src/tests/fef/parameter/CMakeLists.txt @@ -4,5 +4,6 @@ vespa_add_executable(searchlib_parameter_test_app TEST parameter_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_parameter_test_app NO_VALGRIND COMMAND searchlib_parameter_test_app) diff --git a/searchlib/src/tests/fef/parameter/parameter_test.cpp b/searchlib/src/tests/fef/parameter/parameter_test.cpp index fa29f16f1d5..a8acd2ea34d 100644 --- a/searchlib/src/tests/fef/parameter/parameter_test.cpp +++ b/searchlib/src/tests/fef/parameter/parameter_test.cpp @@ -1,32 +1,34 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/log/log.h> -LOG_SETUP("parameter_test"); -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/searchlib/fef/parametervalidator.h> #include <vespa/searchlib/fef/test/indexenvironment.h> #include <vespa/searchlib/fef/test/indexenvironmentbuilder.h> +#include <vespa/vespalib/gtest/gtest.h> + +#include <vespa/log/log.h> +LOG_SETUP("parameter_test"); using namespace search::fef::test; using CollectionType = search::fef::FieldInfo::CollectionType; using DataType = search::fef::FieldInfo::DataType; -namespace search { -namespace fef { +namespace search::fef { class StringList : public std::vector<vespalib::string> { public: StringList & add(const vespalib::string & str) { push_back(str); return *this; } }; -class ParameterTest : public vespalib::TestApp { -private: +class ParameterTest : public ::testing::Test { +protected: using PDS = ParameterDescriptions; using PT = ParameterType; using P = Parameter; using SL = StringList; using PVR = ParameterValidator::Result; + ParameterTest(); + ~ParameterTest() override; bool assertParameter(const Parameter & exp, const Parameter & act); bool validate(const IIndexEnvironment & env, const std::vector<vespalib::string> & params, @@ -35,24 +37,20 @@ private: const std::vector<vespalib::string> & params, const ParameterDescriptions & descs, const ParameterValidator::Result & result); - - void testDescriptions(); - void testValidator(); - void testParameters(); - -public: - int Main() override; }; +ParameterTest::ParameterTest() = default; +ParameterTest::~ParameterTest() = default; + bool ParameterTest::assertParameter(const Parameter & exp, const Parameter & act) { bool retval = true; - if (!EXPECT_EQUAL(exp.getType(), act.getType())) retval = false; - if (!EXPECT_EQUAL(exp.getValue(), act.getValue())) retval = false; - if (!EXPECT_EQUAL(exp.asDouble(), act.asDouble())) retval = false; - if (!EXPECT_EQUAL(exp.asInteger(), act.asInteger())) retval = false; - if (!EXPECT_EQUAL(exp.asField(), act.asField())) retval = false; + EXPECT_EQ(exp.getType(), act.getType()) << (retval = false, ""); + EXPECT_EQ(exp.getValue(), act.getValue()) << (retval = false, ""); + EXPECT_EQ(exp.asDouble(), act.asDouble()) << (retval = false, ""); + EXPECT_EQ(exp.asInteger(), act.asInteger()) << (retval = false, ""); + EXPECT_EQ(exp.asField(), act.asField()) << (retval = false, ""); return retval; } @@ -76,8 +74,15 @@ ParameterTest::validate(const IIndexEnvironment & env, if (!validate(env, params, descs)) return false; ParameterValidator pv(env, params, descs); ParameterValidator::Result actual = pv.validate(); - if (!EXPECT_EQUAL(result.getTag(), actual.getTag())) return false; - if (!EXPECT_EQUAL(result.getParameters().size(), actual.getParameters().size())) return false; + bool failed = false; + EXPECT_EQ(result.getTag(), actual.getTag()) << (failed = true, ""); + if (failed) { + return false; + } + EXPECT_EQ(result.getParameters().size(), actual.getParameters().size()) << (failed = true, ""); + if (failed) { + return false; + } bool retval = true; for (size_t i = 0; i < result.getParameters().size(); ++i) { if (!assertParameter(result.getParameters()[i], actual.getParameters()[i])) retval = false; @@ -85,52 +90,50 @@ ParameterTest::validate(const IIndexEnvironment & env, return retval; } -void -ParameterTest::testDescriptions() +TEST_F(ParameterTest, test_descriptions) { PDS descs = PDS(). desc().indexField(ParameterCollection::SINGLE).indexField(ParameterCollection::ARRAY).indexField(ParameterCollection::WEIGHTEDSET).attribute(ParameterCollection::ANY).attributeField(ParameterCollection::ANY).field(). desc(5).feature().number().string().attribute(ParameterCollection::ANY). desc().string().number().repeat(2); const PDS::DescriptionVector & v = descs.getDescriptions(); - EXPECT_EQUAL(v.size(), 3u); - EXPECT_EQUAL(v[0].getTag(), 0u); + EXPECT_EQ(v.size(), 3u); + EXPECT_EQ(v[0].getTag(), 0u); EXPECT_TRUE(!v[0].hasRepeat()); - EXPECT_EQUAL(v[0].getParams().size(), 6u); - EXPECT_EQUAL(v[0].getParam(0).type, ParameterType::INDEX_FIELD); - EXPECT_EQUAL(v[0].getParam(1).type, ParameterType::INDEX_FIELD); - EXPECT_EQUAL(v[0].getParam(2).type, ParameterType::INDEX_FIELD); - EXPECT_EQUAL(v[0].getParam(3).type, ParameterType::ATTRIBUTE); - EXPECT_EQUAL(v[0].getParam(4).type, ParameterType::ATTRIBUTE_FIELD); - EXPECT_EQUAL(v[0].getParam(5).type, ParameterType::FIELD); - EXPECT_EQUAL(v[0].getParam(0).collection, ParameterCollection::SINGLE); - EXPECT_EQUAL(v[0].getParam(1).collection, ParameterCollection::ARRAY); - EXPECT_EQUAL(v[0].getParam(2).collection, ParameterCollection::WEIGHTEDSET); - EXPECT_EQUAL(v[0].getParam(3).collection, ParameterCollection::ANY); - EXPECT_EQUAL(v[0].getParam(4).collection, ParameterCollection::ANY); - EXPECT_EQUAL(v[0].getParam(5).collection, ParameterCollection::ANY); + EXPECT_EQ(v[0].getParams().size(), 6u); + EXPECT_EQ(v[0].getParam(0).type, ParameterType::INDEX_FIELD); + EXPECT_EQ(v[0].getParam(1).type, ParameterType::INDEX_FIELD); + EXPECT_EQ(v[0].getParam(2).type, ParameterType::INDEX_FIELD); + EXPECT_EQ(v[0].getParam(3).type, ParameterType::ATTRIBUTE); + EXPECT_EQ(v[0].getParam(4).type, ParameterType::ATTRIBUTE_FIELD); + EXPECT_EQ(v[0].getParam(5).type, ParameterType::FIELD); + EXPECT_EQ(v[0].getParam(0).collection, ParameterCollection::SINGLE); + EXPECT_EQ(v[0].getParam(1).collection, ParameterCollection::ARRAY); + EXPECT_EQ(v[0].getParam(2).collection, ParameterCollection::WEIGHTEDSET); + EXPECT_EQ(v[0].getParam(3).collection, ParameterCollection::ANY); + EXPECT_EQ(v[0].getParam(4).collection, ParameterCollection::ANY); + EXPECT_EQ(v[0].getParam(5).collection, ParameterCollection::ANY); - EXPECT_EQUAL(v[1].getTag(), 5u); + EXPECT_EQ(v[1].getTag(), 5u); EXPECT_TRUE(!v[1].hasRepeat()); - EXPECT_EQUAL(v[1].getParams().size(), 4u); - EXPECT_EQUAL(v[1].getParam(0).type, ParameterType::FEATURE); - EXPECT_EQUAL(v[1].getParam(1).type, ParameterType::NUMBER); - EXPECT_EQUAL(v[1].getParam(2).type, ParameterType::STRING); - EXPECT_EQUAL(v[1].getParam(3).type, ParameterType::ATTRIBUTE); + EXPECT_EQ(v[1].getParams().size(), 4u); + EXPECT_EQ(v[1].getParam(0).type, ParameterType::FEATURE); + EXPECT_EQ(v[1].getParam(1).type, ParameterType::NUMBER); + EXPECT_EQ(v[1].getParam(2).type, ParameterType::STRING); + EXPECT_EQ(v[1].getParam(3).type, ParameterType::ATTRIBUTE); - EXPECT_EQUAL(v[2].getTag(), 6u); + EXPECT_EQ(v[2].getTag(), 6u); EXPECT_TRUE(v[2].hasRepeat()); - EXPECT_EQUAL(v[2].getParams().size(), 2u); - EXPECT_EQUAL(v[2].getParam(0).type, ParameterType::STRING); - EXPECT_EQUAL(v[2].getParam(1).type, ParameterType::NUMBER); - EXPECT_EQUAL(v[2].getParam(2).type, ParameterType::STRING); - EXPECT_EQUAL(v[2].getParam(3).type, ParameterType::NUMBER); - EXPECT_EQUAL(v[2].getParam(4).type, ParameterType::STRING); - EXPECT_EQUAL(v[2].getParam(5).type, ParameterType::NUMBER); + EXPECT_EQ(v[2].getParams().size(), 2u); + EXPECT_EQ(v[2].getParam(0).type, ParameterType::STRING); + EXPECT_EQ(v[2].getParam(1).type, ParameterType::NUMBER); + EXPECT_EQ(v[2].getParam(2).type, ParameterType::STRING); + EXPECT_EQ(v[2].getParam(3).type, ParameterType::NUMBER); + EXPECT_EQ(v[2].getParam(4).type, ParameterType::STRING); + EXPECT_EQ(v[2].getParam(5).type, ParameterType::NUMBER); } -void -ParameterTest::testValidator() +TEST_F(ParameterTest, test_validator) { IndexEnvironment env; IndexEnvironmentBuilder builder(env); @@ -201,8 +204,7 @@ ParameterTest::testValidator() EXPECT_TRUE(!validate(env, SL().add("str").add("bar").add("foo").add("bar"), d2)); } -void -ParameterTest::testParameters() +TEST_F(ParameterTest, test_parameters) { IndexEnvironment env; IndexEnvironmentBuilder builder(env); @@ -254,20 +256,6 @@ ParameterTest::testParameters() PVR(20).addParameter(P(PT::STRING, "baz")))); // second desc matching } -int -ParameterTest::Main() -{ - TEST_INIT("parameter_test"); - - testDescriptions(); - testValidator(); - testParameters(); - - TEST_DONE(); } -} -} - -TEST_APPHOOK(search::fef::ParameterTest); - +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt b/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt index 95f6eaad705..8f3946d110c 100644 --- a/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt +++ b/searchlib/src/tests/fef/phrasesplitter/CMakeLists.txt @@ -4,6 +4,7 @@ vespa_add_executable(searchlib_phrasesplitter_test_app TEST phrasesplitter_test.cpp DEPENDS searchlib + GTest::gtest ) vespa_add_test(NAME searchlib_phrasesplitter_test_app COMMAND searchlib_phrasesplitter_test_app) vespa_add_executable(searchlib_benchmark_app diff --git a/searchlib/src/tests/fef/phrasesplitter/phrasesplitter_test.cpp b/searchlib/src/tests/fef/phrasesplitter/phrasesplitter_test.cpp index c4767c571b9..f4b3c878a06 100644 --- a/searchlib/src/tests/fef/phrasesplitter/phrasesplitter_test.cpp +++ b/searchlib/src/tests/fef/phrasesplitter/phrasesplitter_test.cpp @@ -1,41 +1,25 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/log/log.h> -LOG_SETUP("phrasesplitter_test"); -#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/gtest/gtest.h> -namespace search { -namespace fef { - -class PhraseSplitterTest : public vespalib::TestApp -{ -private: - void assertTermData(const ITermData * td, uint32_t uniqueId, uint32_t numTerms, - uint32_t fieldId, uint32_t termHandle); - void testCopyTermFieldMatchData(); - void testSplitter(); - void testSplitterUpdate(); - -public: - int Main() override; -}; +namespace search::fef { void -PhraseSplitterTest::assertTermData(const ITermData *td, uint32_t uniqueId, uint32_t numTerms, - uint32_t fieldId, uint32_t tfHandle) +assertTermData(const ITermData *td, uint32_t uniqueId, uint32_t numTerms, + uint32_t fieldId, uint32_t tfHandle, const vespalib::string& label) { + SCOPED_TRACE(label); // fprintf(stderr, "checking uid=%d numterms=%d field=%d handle=%d\n", uniqueId, numTerms, fieldId, tfHandle); - EXPECT_EQUAL(uniqueId, td->getUniqueId()); - EXPECT_EQUAL(numTerms, td->getPhraseLength()); - EXPECT_EQUAL(tfHandle, td->lookupField(fieldId)->getHandle()); + EXPECT_EQ(uniqueId, td->getUniqueId()); + EXPECT_EQ(numTerms, td->getPhraseLength()); + EXPECT_EQ(tfHandle, td->lookupField(fieldId)->getHandle()); } -void -PhraseSplitterTest::testCopyTermFieldMatchData() +TEST(PhraseSplitterTest, test_copy_term_field_match_data) { TermFieldMatchData src; src.reset(1); @@ -49,34 +33,33 @@ PhraseSplitterTest::testCopyTermFieldMatchData() dst.appendPosition(TermFieldMatchDataPosition(0, 10, 0, 1000)); { FieldPositionsIterator itr = dst.getIterator(); - EXPECT_EQUAL(itr.getPosition(), 10u); + EXPECT_EQ(itr.getPosition(), 10u); itr.next(); ASSERT_TRUE(!itr.valid()); } PhraseSplitter::copyTermFieldMatchData(dst, src, 2); - EXPECT_EQUAL(dst.getDocId(), 1u); + EXPECT_EQ(dst.getDocId(), 1u); { TermFieldMatchData::PositionsIterator itr = dst.begin(); - EXPECT_EQUAL(itr->getPosition(), 7u); + EXPECT_EQ(itr->getPosition(), 7u); ++itr; - EXPECT_EQUAL(itr->getPosition(), 17u); + EXPECT_EQ(itr->getPosition(), 17u); ++itr; ASSERT_TRUE(itr == dst.end()); } { FieldPositionsIterator itr = dst.getIterator(); - EXPECT_EQUAL(itr.getPosition(), 7u); + EXPECT_EQ(itr.getPosition(), 7u); itr.next(); - EXPECT_EQUAL(itr.getPosition(), 17u); + EXPECT_EQ(itr.getPosition(), 17u); itr.next(); ASSERT_TRUE(!itr.valid()); } } -void -PhraseSplitterTest::testSplitter() +TEST(PhraseSplitterTest, test_splitter) { { // single term test::QueryEnvironment qe; @@ -91,9 +74,9 @@ PhraseSplitterTest::testSplitter() ps.bind_match_data(*md); ps.update(); // check that nothing is served from the splitter - EXPECT_EQUAL(ps.get_query_env().getTerm(0), &terms[0]); + EXPECT_EQ(ps.get_query_env().getTerm(0), &terms[0]); TermFieldHandle handle = terms[0].lookupField(0)->getHandle(); - EXPECT_EQUAL(ps.resolveTermField(handle), md->resolveTermField(handle)); + EXPECT_EQ(ps.resolveTermField(handle), md->resolveTermField(handle)); } { // single phrase test::QueryEnvironment qe; @@ -114,14 +97,14 @@ PhraseSplitterTest::testSplitter() for (size_t i = 0; i < 3; ++i) { // fprintf(stderr, "checking term %d\n", (int)i); const ITermData *td = ps.get_query_env().getTerm(i); - EXPECT_NOT_EQUAL(td, &terms[0]); - EXPECT_NOT_EQUAL(td->lookupField(7), (ITermFieldData *)0); - EXPECT_EQUAL(td->lookupField(0), (ITermFieldData *)0); - TEST_DO(assertTermData(td, 1, 1, 7, i + 4)); // skipHandles = 4 - EXPECT_NOT_EQUAL(td->lookupField(7)->getHandle(), - terms[0].lookupField(7)->getHandle()); - EXPECT_NOT_EQUAL(ps.resolveTermField(td->lookupField(7)->getHandle()), - md->resolveTermField(terms[0].lookupField(7)->getHandle())); + EXPECT_NE(td, &terms[0]); + EXPECT_NE(td->lookupField(7), (ITermFieldData *)0); + EXPECT_EQ(td->lookupField(0), (ITermFieldData *)0); + assertTermData(td, 1, 1, 7, i + 4, "single phrase"); // skipHandles = 4 + EXPECT_NE(td->lookupField(7)->getHandle(), + terms[0].lookupField(7)->getHandle()); + EXPECT_NE(ps.resolveTermField(td->lookupField(7)->getHandle()), + md->resolveTermField(terms[0].lookupField(7)->getHandle())); } } { // combination @@ -145,40 +128,39 @@ PhraseSplitterTest::testSplitter() ps.update(); { // first term // fprintf(stderr, "first term\n"); - EXPECT_EQUAL(ps.get_query_env().getTerm(0), &terms[0]); - TEST_DO(assertTermData(ps.get_query_env().getTerm(0), 0, 1, 4, 0)); - TEST_DO(assertTermData(ps.get_query_env().getTerm(0), 0, 1, 7, 1)); + EXPECT_EQ(ps.get_query_env().getTerm(0), &terms[0]); + assertTermData(ps.get_query_env().getTerm(0), 0, 1, 4, 0, "first term 1"); + assertTermData(ps.get_query_env().getTerm(0), 0, 1, 7, 1, "first term 2"); TermFieldHandle handle = terms[0].lookupField(4)->getHandle(); - EXPECT_EQUAL(ps.resolveTermField(handle), md->resolveTermField(handle)); + EXPECT_EQ(ps.resolveTermField(handle), md->resolveTermField(handle)); handle = terms[0].lookupField(7)->getHandle(); - EXPECT_EQUAL(ps.resolveTermField(handle), md->resolveTermField(handle)); + EXPECT_EQ(ps.resolveTermField(handle), md->resolveTermField(handle)); } for (size_t i = 0; i < 3; ++i) { // phrase // fprintf(stderr, "phrase term %zd\n", i); const ITermData *td = ps.get_query_env().getTerm(i + 1); - EXPECT_NOT_EQUAL(td, &terms[1]); - TEST_DO(assertTermData(td, 1, 1, 4, i + 11)); // skipHandles == 11 - EXPECT_EQUAL(td->lookupField(7), (ITermFieldData *)0); - EXPECT_NOT_EQUAL(ps.resolveTermField(td->lookupField(4)->getHandle()), - md->resolveTermField(terms[1].lookupField(4)->getHandle())); + EXPECT_NE(td, &terms[1]); + assertTermData(td, 1, 1, 4, i + 11, "phrase term"); // skipHandles == 11 + EXPECT_EQ(td->lookupField(7), (ITermFieldData *)0); + EXPECT_NE(ps.resolveTermField(td->lookupField(4)->getHandle()), + md->resolveTermField(terms[1].lookupField(4)->getHandle())); } { // last term // fprintf(stderr, "last term\n"); - EXPECT_EQUAL(ps.get_query_env().getTerm(4), &terms[2]); - TEST_DO(assertTermData(ps.get_query_env().getTerm(4), 2, 1, 4, 4)); - TEST_DO(assertTermData(ps.get_query_env().getTerm(4), 2, 1, 7, 5)); + EXPECT_EQ(ps.get_query_env().getTerm(4), &terms[2]); + assertTermData(ps.get_query_env().getTerm(4), 2, 1, 4, 4, "last term 1"); + assertTermData(ps.get_query_env().getTerm(4), 2, 1, 7, 5, "last term 2"); // fprintf(stderr, "inspect term %p #f %zd\n", &terms[2], terms[2].numFields()); fflush(stderr); TermFieldHandle handle = terms[2].lookupField(4)->getHandle(); - EXPECT_EQUAL(ps.resolveTermField(handle), md->resolveTermField(handle)); + EXPECT_EQ(ps.resolveTermField(handle), md->resolveTermField(handle)); } } } -void -PhraseSplitterTest::testSplitterUpdate() +TEST(PhraseSplitterTest, test_splitter_update) { { test::QueryEnvironment qe; @@ -213,38 +195,24 @@ PhraseSplitterTest::testSplitterUpdate() for (size_t i = 0; i < 2; ++i) { // first phrase const TermFieldMatchData * tmd = ps.resolveTermField(ps.get_query_env().getTerm(i)->lookupField(0)->getHandle()); TermFieldMatchData::PositionsIterator itr = tmd->begin(); - EXPECT_EQUAL((itr++)->getPosition(), 10 + i); + EXPECT_EQ((itr++)->getPosition(), 10 + i); ASSERT_TRUE(itr == tmd->end()); } { // first term TermFieldMatchData * tmd = md->resolveTermField(ps.get_query_env().getTerm(2)->lookupField(0)->getHandle()); TermFieldMatchData::PositionsIterator itr = tmd->begin(); - EXPECT_EQUAL((itr++)->getPosition(), 20u); + EXPECT_EQ((itr++)->getPosition(), 20u); ASSERT_TRUE(itr == tmd->end()); } for (size_t i = 0; i < 2; ++i) { // second phrase const TermFieldMatchData * tmd = ps.resolveTermField(ps.get_query_env().getTerm(i + 3)->lookupField(0)->getHandle()); TermFieldMatchData::PositionsIterator itr = tmd->begin(); - EXPECT_EQUAL((itr++)->getPosition(), 30 + i); + EXPECT_EQ((itr++)->getPosition(), 30 + i); ASSERT_TRUE(itr == tmd->end()); } } } -int -PhraseSplitterTest::Main() -{ - - TEST_INIT("phrasesplitter_test"); - - testCopyTermFieldMatchData(); - testSplitter(); - testSplitterUpdate(); - - TEST_DONE(); -} - -} } -TEST_APPHOOK(search::fef::PhraseSplitterTest); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/searchlib/src/vespa/searchlib/queryeval/flow_tuning.h b/searchlib/src/vespa/searchlib/queryeval/flow_tuning.h index ce5a24d9c2f..53f2be88c1f 100644 --- a/searchlib/src/vespa/searchlib/queryeval/flow_tuning.h +++ b/searchlib/src/vespa/searchlib/queryeval/flow_tuning.h @@ -22,6 +22,8 @@ inline double array_cost(double my_est, size_t num_children) { * The following tests were executed on a machine with an Intel Xeon 2.5 GHz CPU with 48 cores and 256 Gb of memory: * ./searchlib_iterator_benchmark_test_app --gtest_filter='*analyze_term_search*' * + * TODO: Add details on OR benchmarking. + * * The benchmark summary shows the 'average ms per cost' of the different benchmark cases. * The following constants and formulas were derived to balance 'average ms per cost' to be similar * across the different benchmark cases. @@ -29,7 +31,7 @@ inline double array_cost(double my_est, size_t num_children) { // Non-strict cost of lookup based matching in an attribute (not fast-search). inline double lookup_cost(size_t num_indirections) { - return 1.0 + (num_indirections * 4.0); + return 1.0 + (num_indirections * 1.0); } // Strict cost of lookup based matching in an attribute (not fast-search). @@ -39,7 +41,7 @@ inline double lookup_strict_cost(size_t num_indirections) { // Non-strict cost of matching in a btree posting list (e.g. fast-search attribute or memory index field). inline double btree_cost() { - return 7.0; + return 1.0; } // Strict cost of matching in a btree posting list (e.g. fast-search attribute or memory index field). @@ -49,7 +51,7 @@ inline double btree_strict_cost(double my_est) { // Non-strict cost of matching in a disk index posting list. inline double disk_index_cost() { - return 12.0; + return 1.5; } // Strict cost of matching in a disk index posting list. |