From f4b459259c899de8cb191c8906b7ec7e99a2e087 Mon Sep 17 00:00:00 2001 From: Tor Egge Date: Sun, 18 Feb 2024 01:10:24 +0100 Subject: Rewrite attribute search context unit test to gtest. --- .../attribute/searchcontext/searchcontext_test.cpp | 290 ++++++++------------- 1 file changed, 111 insertions(+), 179 deletions(-) (limited to 'searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp') diff --git a/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp b/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp index 85b13c20f88..77acbe046ca 100644 --- a/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp +++ b/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp @@ -18,9 +18,10 @@ #include #include #include +#define ENABLE_GTEST_MIGRATION #include +#include #include -#include #include #include #include @@ -142,7 +143,7 @@ public: DocRange(uint32_t start_, uint32_t end_) : start(start_), end(end_) {} }; -class SearchContextTest : public vespalib::TestApp +class SearchContextTest : public ::testing::Test { public: // helper functions @@ -150,7 +151,7 @@ public: static void addDocs(AttributeVector & ptr, uint32_t numDocs); template static SearchContextPtr getSearch(const V & vec, const T & term, TermType termType=TermType::WORD); -private: +protected: using ConfigMap = std::map; // Map of all config objects ConfigMap _integerCfg; @@ -185,7 +186,6 @@ private: template void testSearchIterator(const std::vector & keys, const vespalib::string &keyAsString, const ConfigMap &cfgs); - void testSearchIteratorConformance(); // test search functionality template void testFind(const PostingList & first, bool verify_hit_estimate); @@ -198,7 +198,6 @@ private: void testMultiValueSearchHelper(V & vec, const std::vector & values); template void testMultiValueSearch(V& attr, uint32_t num_docs, const std::vector & values); - void testSearch(); class IteratorTester { public: @@ -237,7 +236,6 @@ private: void testNonStrictSearchIterator(SearchContext & threeHits, SearchContext & noHits, const IteratorTester & typeTester); AttributePtr fillForSearchIteratorTest(const vespalib::string& name, const Config& cfg); AttributePtr fillForSemiNibbleSearchIteratorTest(const vespalib::string& name, const Config& cfg); - void testSearchIterator(); // test search iterator unpacking @@ -250,7 +248,6 @@ private: } void testSearchIteratorUnpacking(const AttributePtr & ptr, SearchContext & sc, bool extra, bool strict, bool withElementId); - void testSearchIteratorUnpacking(); // test range search @@ -258,58 +255,41 @@ private: void performRangeSearch(const VectorType & vec, const vespalib::string & term, const DocSet & expected); template void testRangeSearch(const AttributePtr & ptr, uint32_t numDocs, std::vector values); - void testRangeSearch(); - void testRangeSearchLimited(); - void testRangeSearchLimitedHugeDictionary(); // test case insensitive search void performCaseInsensitiveSearch(const StringAttribute & vec, const vespalib::string & term, const DocSet & expected); void testCaseInsensitiveSearch(const AttributePtr & ptr); - void testCaseInsensitiveSearch(); void testRegexSearch(const vespalib::string& name, const Config& cfg); - void testRegexSearch(); // test prefix search void testPrefixSearch(const vespalib::string& name, const Config& cfg); - void testPrefixSearch(); // test fuzzy search void testFuzzySearch(const vespalib::string& name, const Config& cfg); - void testFuzzySearch(); // test that search is working after clear doc template void requireThatSearchIsWorkingAfterClearDoc(const vespalib::string & name, const Config & cfg, ValueType startValue, const vespalib::string & term); - void requireThatSearchIsWorkingAfterClearDoc(); // test that search is working after load and clear doc template void requireThatSearchIsWorkingAfterLoadAndClearDoc(const vespalib::string & name, const Config & cfg, ValueType startValue, ValueType defaultValue, const vespalib::string & term); - void requireThatSearchIsWorkingAfterLoadAndClearDoc(); template void requireThatSearchIsWorkingAfterUpdates(const vespalib::string & name, const Config & cfg, ValueType value1, ValueType value2); - void requireThatSearchIsWorkingAfterUpdates(); - void requireThatFlagAttributeIsWorkingWhenNewDocsAreAdded(); template void requireThatInvalidSearchTermGivesZeroHits(const vespalib::string & name, const Config & cfg, ValueType value); - void requireThatInvalidSearchTermGivesZeroHits(); - void requireThatFlagAttributeHandlesTheByteRange(); void requireThatOutOfBoundsSearchTermGivesZeroHits(const vespalib::string &name, const Config &cfg, int32_t maxValue); - void requireThatOutOfBoundsSearchTermGivesZeroHits(); - - void single_bool_attribute_search_context_handles_true_and_false_queries(); - void single_bool_attribute_search_iterator_handles_true_and_false_queries(); // init maps with config objects void initIntegerConfig(); @@ -319,7 +299,6 @@ private: public: SearchContextTest(); ~SearchContextTest() override; - int Main() override; }; @@ -337,7 +316,7 @@ SearchContextTest::addDocs(AttributeVector & ptr, uint32_t numDocs) addReservedDoc(ptr); for (uint32_t i = 1; i <= numDocs; ++i) { ptr.addDoc(docId); - EXPECT_EQUAL(docId, i); + EXPECT_EQ(docId, i); } ASSERT_TRUE(ptr.getNumDocs() == numDocs + 1); } @@ -531,7 +510,7 @@ SearchContextTest::performSearch(const V & vec, const vespalib::string & term, void SearchContextTest::checkResultSet(const ResultSet & rs, const DocSet & expected, bool bitVector) { - EXPECT_EQUAL(rs.getNumHits(), expected.size()); + EXPECT_EQ(rs.getNumHits(), expected.size()); if (bitVector) { const BitVector * vec = rs.getBitOverflow(); if ( ! expected.empty()) { @@ -546,7 +525,7 @@ SearchContextTest::checkResultSet(const ResultSet & rs, const DocSet & expected, ASSERT_TRUE(array != nullptr); uint32_t i = 0; for (auto iter = expected.begin(); iter != expected.end(); ++iter, ++i) { - EXPECT_EQUAL(array[i].getDocId(), *iter); + EXPECT_EQ(array[i].getDocId(), *iter); } } } @@ -565,8 +544,8 @@ SearchContextTest::testFind(const PostingList & pl, bool verify_hit_estima if (verify_hit_estimate) { auto act_est = sc->calc_hit_estimate(); auto exp_est = pl.expected_hit_estimate(); - EXPECT_EQUAL(exp_est.est_hits(), act_est.est_hits()); - EXPECT_EQUAL(exp_est.is_unknown(), act_est.is_unknown()); + EXPECT_EQ(exp_est.est_hits(), act_est.est_hits()); + EXPECT_EQ(exp_est.is_unknown(), act_est.is_unknown()); } sc->fetchPostings(queryeval::ExecuteInfo::TRUE); TermFieldMatchData dummy; @@ -721,7 +700,7 @@ Verifier::Verifier(const std::vector & keys, const vespalib::string & k } _attribute->commit(true); _sc = SearchContextTest::getSearch(*_attribute, keyAsString); - ASSERT_TRUE(_sc->valid()); + EXPECT_TRUE(_sc->valid()); } template @@ -743,15 +722,15 @@ void SearchContextTest::testSearchIterator(const std::vector & keys, const ve } } -void SearchContextTest::testSearchIteratorConformance() { +TEST_F(SearchContextTest, test_search_iterator_conformance) +{ testSearchIterator({42,45,46}, "[0;100]", _integerCfg); testSearchIterator({42}, "42", _integerCfg); testSearchIterator({42.42}, "42.42", _floatCfg); testSearchIterator({"any-key"}, "any-key", _stringCfg); } -void -SearchContextTest::testSearch() +TEST_F(SearchContextTest, test_search) { const uint32_t numDocs = 100; const uint32_t numUniques = 20; @@ -812,15 +791,15 @@ SearchContextTest::testStrictSearchIterator(SearchContext & threeHits, EXPECT_TRUE(sb->getDocId() == sb->beginId() || sb->getDocId() == 1u); EXPECT_TRUE(sb->seek(1)); - EXPECT_EQUAL(sb->getDocId(), 1u); + EXPECT_EQ(sb->getDocId(), 1u); EXPECT_TRUE(!sb->seek(2)); - EXPECT_EQUAL(sb->getDocId(), 3u); + EXPECT_EQ(sb->getDocId(), 3u); EXPECT_TRUE(sb->seek(3)); - EXPECT_EQUAL(sb->getDocId(), 3u); + EXPECT_EQ(sb->getDocId(), 3u); EXPECT_TRUE(!sb->seek(4)); - EXPECT_EQUAL(sb->getDocId(), 5u); + EXPECT_EQ(sb->getDocId(), 5u); EXPECT_TRUE(sb->seek(5)); - EXPECT_EQUAL(sb->getDocId(), 5u); + EXPECT_EQ(sb->getDocId(), 5u); EXPECT_TRUE(!sb->seek(6)); EXPECT_TRUE(sb->isAtEnd()); } @@ -849,15 +828,15 @@ SearchContextTest::testNonStrictSearchIterator(SearchContext & threeHits, sb->initRange(1, threeHits.attribute().getCommittedDocIdLimit()); EXPECT_TRUE(typeTester.matches(*sb)); EXPECT_TRUE(sb->seek(1)); - EXPECT_EQUAL(sb->getDocId(), 1u); + EXPECT_EQ(sb->getDocId(), 1u); EXPECT_TRUE(!sb->seek(2)); - EXPECT_EQUAL(sb->getDocId(), 1u); + EXPECT_EQ(sb->getDocId(), 1u); EXPECT_TRUE(sb->seek(3)); - EXPECT_EQUAL(sb->getDocId(), 3u); + EXPECT_EQ(sb->getDocId(), 3u); EXPECT_TRUE(!sb->seek(4)); - EXPECT_EQUAL(sb->getDocId(), 3u); + EXPECT_EQ(sb->getDocId(), 3u); EXPECT_TRUE(sb->seek(5)); - EXPECT_EQUAL(sb->getDocId(), 5u); + EXPECT_EQ(sb->getDocId(), 5u); EXPECT_TRUE(!sb->seek(6)); EXPECT_TRUE(sb->getDocId() == 5u || sb->isAtEnd()); } @@ -870,9 +849,9 @@ SearchContextTest::testNonStrictSearchIterator(SearchContext & threeHits, EXPECT_TRUE(sb->getDocId() == sb->beginId() || sb->isAtEnd()); EXPECT_TRUE(!sb->seek(1)); - EXPECT_NOT_EQUAL(sb->getDocId(), 1u); + EXPECT_NE(sb->getDocId(), 1u); EXPECT_TRUE(!sb->seek(6)); - EXPECT_NOT_EQUAL(sb->getDocId(), 6u); + EXPECT_NE(sb->getDocId(), 6u); } } @@ -888,8 +867,7 @@ SearchContextTest::fillForSemiNibbleSearchIteratorTest(const vespalib::string& n return AttributeBuilder(name, cfg).fill({1, 2, 1, 2, 1}).get(); } -void -SearchContextTest::testSearchIterator() +TEST_F(SearchContextTest, test_search_iterator) { { Config cfg(BasicType::INT32, CollectionType::SINGLE); @@ -1031,46 +1009,45 @@ SearchContextTest::testSearchIteratorUnpacking(const AttributePtr & attr, Search // unpack and check weights search.unpack(1); - EXPECT_EQUAL(search.getDocId(), 1u); - EXPECT_EQUAL(md.getDocId(), 1u); - EXPECT_EQUAL(md.getWeight(), weights[0]); + EXPECT_EQ(search.getDocId(), 1u); + EXPECT_EQ(md.getDocId(), 1u); + EXPECT_EQ(md.getWeight(), weights[0]); search.unpack(2); - EXPECT_EQUAL(search.getDocId(), 2u); - EXPECT_EQUAL(md.getDocId(), 2u); + EXPECT_EQ(search.getDocId(), 2u); + EXPECT_EQ(md.getDocId(), 2u); if (withElementId && attr->hasMultiValue() && !attr->hasWeightedSetType()) { std::vector elems; elemIt->getElementIds(2, elems); - ASSERT_EQUAL(2u, elems.size()); - EXPECT_EQUAL(0u,elems[0]); - EXPECT_EQUAL(1u,elems[1]); + ASSERT_EQ(2u, elems.size()); + EXPECT_EQ(0u,elems[0]); + EXPECT_EQ(1u,elems[1]); } else { - EXPECT_EQUAL(md.getWeight(), weights[1]); + EXPECT_EQ(md.getWeight(), weights[1]); } search.unpack(3); - EXPECT_EQUAL(search.getDocId(), 3u); - EXPECT_EQUAL(md.getDocId(), 3u); + EXPECT_EQ(search.getDocId(), 3u); + EXPECT_EQ(md.getDocId(), 3u); if (withElementId && attr->hasMultiValue() && !attr->hasWeightedSetType()) { std::vector elems; elemIt->getElementIds(3, elems); - ASSERT_EQUAL(3u, elems.size()); - EXPECT_EQUAL(0u,elems[0]); - EXPECT_EQUAL(1u,elems[1]); - EXPECT_EQUAL(2u,elems[2]); + ASSERT_EQ(3u, elems.size()); + EXPECT_EQ(0u,elems[0]); + EXPECT_EQ(1u,elems[1]); + EXPECT_EQ(2u,elems[2]); } else { - EXPECT_EQUAL(md.getWeight(), weights[2]); + EXPECT_EQ(md.getWeight(), weights[2]); } if (extra) { search.unpack(4); - EXPECT_EQUAL(search.getDocId(), 4u); - EXPECT_EQUAL(md.getDocId(), 4u); - EXPECT_EQUAL(md.getWeight(), 1); + EXPECT_EQ(search.getDocId(), 4u); + EXPECT_EQ(md.getDocId(), 4u); + EXPECT_EQ(md.getWeight(), 1); } } -void -SearchContextTest::testSearchIteratorUnpacking() +TEST_F(SearchContextTest, test_search_iterator_unpacking) { std::vector > config; @@ -1242,8 +1219,8 @@ createDocs(uint32_t from, int32_t count) { return docs; } -void -SearchContextTest::testRangeSearchLimitedHugeDictionary() { +TEST_F(SearchContextTest, test_range_search_limited_huge_dictionary) +{ Config cfg(BasicType::INT32, CollectionType::SINGLE); cfg.setFastSearch(true); std::vector v; @@ -1263,8 +1240,7 @@ SearchContextTest::testRangeSearchLimitedHugeDictionary() { performRangeSearch(vec, "[1;3009;-1200]", createDocs(2000, -1200)); } -void -SearchContextTest::testRangeSearchLimited() +TEST_F(SearchContextTest, test_range_search_limited) { Config cfg(BasicType::INT32, CollectionType::SINGLE); cfg.setFastSearch(true); @@ -1317,8 +1293,7 @@ SearchContextTest::testRangeSearchLimited() performRangeSearch(vec, "[;;-1]", expected); } -void -SearchContextTest::testRangeSearch() +TEST_F(SearchContextTest, test_range_search) { const uint32_t numDocs = 100; const uint32_t numValues = 20; @@ -1412,8 +1387,8 @@ SearchContextTest::testCaseInsensitiveSearch(const AttributePtr & ptr) doc = 1; for (uint32_t j = 0; j < 5; ++j) { for (uint32_t i = 0; i < 5; ++i) { - EXPECT_EQUAL(ptr->get(doc++, buffer, 1), uint32_t(1)); - EXPECT_EQUAL(vespalib::string(buffer[0]), vespalib::string(terms[i][j])); + EXPECT_EQ(ptr->get(doc++, buffer, 1), uint32_t(1)); + EXPECT_EQ(vespalib::string(buffer[0]), vespalib::string(terms[i][j])); } } @@ -1462,16 +1437,14 @@ SearchContextTest::testRegexSearch(const vespalib::string& name, const Config& c } -void -SearchContextTest::testCaseInsensitiveSearch() +TEST_F(SearchContextTest, test_case_insensitive_search) { for (const auto & cfg : _stringCfg) { testCaseInsensitiveSearch(AttributeFactory::createAttribute(cfg.first, cfg.second)); } } -void -SearchContextTest::testRegexSearch() +TEST_F(SearchContextTest, test_regex_search) { for (const auto & cfg : _stringCfg) { testRegexSearch(cfg.first, cfg.second); @@ -1534,8 +1507,7 @@ SearchContextTest::testPrefixSearch(const vespalib::string& name, const Config& } -void -SearchContextTest::testPrefixSearch() +TEST_F(SearchContextTest, test_prefix_search) { for (const auto & cfg : _stringCfg) { testPrefixSearch(cfg.first, cfg.second); @@ -1570,8 +1542,7 @@ SearchContextTest::testFuzzySearch(const vespalib::string& name, const Config& c } } -void -SearchContextTest::testFuzzySearch() +TEST_F(SearchContextTest, test_fuzzy_search) { for (const auto & cfg : _stringCfg) { testFuzzySearch(cfg.first, cfg.second); @@ -1595,28 +1566,27 @@ SearchContextTest::requireThatSearchIsWorkingAfterClearDoc(const vespalib::strin resetAttribute(v, startValue); { ResultSetPtr rs = performSearch(v, term); - EXPECT_EQUAL(4u, rs->getNumHits()); + EXPECT_EQ(4u, rs->getNumHits()); ASSERT_TRUE(4u == rs->getNumHits()); const RankedHit * array = rs->getArray(); - EXPECT_EQUAL(1u, array[0].getDocId()); - EXPECT_EQUAL(2u, array[1].getDocId()); - EXPECT_EQUAL(3u, array[2].getDocId()); - EXPECT_EQUAL(4u, array[3].getDocId()); + EXPECT_EQ(1u, array[0].getDocId()); + EXPECT_EQ(2u, array[1].getDocId()); + EXPECT_EQ(3u, array[2].getDocId()); + EXPECT_EQ(4u, array[3].getDocId()); } a->clearDoc(1); a->clearDoc(3); a->commit(true); { ResultSetPtr rs = performSearch(v, term); - EXPECT_EQUAL(2u, rs->getNumHits()); + EXPECT_EQ(2u, rs->getNumHits()); const RankedHit * array = rs->getArray(); - EXPECT_EQUAL(2u, array[0].getDocId()); - EXPECT_EQUAL(4u, array[1].getDocId()); + EXPECT_EQ(2u, array[0].getDocId()); + EXPECT_EQ(4u, array[1].getDocId()); } } -void -SearchContextTest::requireThatSearchIsWorkingAfterClearDoc() +TEST_F(SearchContextTest, require_that_search_is_working_after_clear_doc) { for (const auto & cfg : _integerCfg) { requireThatSearchIsWorkingAfterClearDoc(cfg.first, cfg.second, 10, "10"); @@ -1655,26 +1625,25 @@ SearchContextTest::requireThatSearchIsWorkingAfterLoadAndClearDoc(const vespalib b->commit(true); { ResultSetPtr rs = performSearch(dynamic_cast(*b), term); - EXPECT_EQUAL(14u, rs->getNumHits()); + EXPECT_EQ(14u, rs->getNumHits()); const RankedHit * array = rs->getArray(); for (uint32_t i = 0; i < 14; ++i) { if (i < 5) { - EXPECT_EQUAL(i + 1, array[i].getDocId()); + EXPECT_EQ(i + 1, array[i].getDocId()); } else - EXPECT_EQUAL(i + 2, array[i].getDocId()); + EXPECT_EQ(i + 2, array[i].getDocId()); } } ValueType buf; if (cfg.collectionType().isMultiValue()) { - EXPECT_EQUAL(0u, b->get(6, &buf, 1)); + EXPECT_EQ(0u, b->get(6, &buf, 1)); } else { - EXPECT_EQUAL(1u, b->get(6, &buf, 1)); - EXPECT_EQUAL(defaultValue, buf); + EXPECT_EQ(1u, b->get(6, &buf, 1)); + EXPECT_EQ(defaultValue, buf); } } -void -SearchContextTest::requireThatSearchIsWorkingAfterLoadAndClearDoc() +TEST_F(SearchContextTest, require_that_search_is_working_after_load_and_clear_doc) { { int64_t value = 10; @@ -1713,16 +1682,15 @@ SearchContextTest::requireThatSearchIsWorkingAfterUpdates(const vespalib::string va.commit(true); { ResultSetPtr rs = performSearch(va, value1); - EXPECT_EQUAL(1u, rs->getNumHits()); // doc 1 should not have this value + EXPECT_EQ(1u, rs->getNumHits()); // doc 1 should not have this value } { ResultSetPtr rs = performSearch(va, value2); - EXPECT_EQUAL(1u, rs->getNumHits()); + EXPECT_EQ(1u, rs->getNumHits()); } } -void -SearchContextTest::requireThatSearchIsWorkingAfterUpdates() +TEST_F(SearchContextTest, require_that_search_is_working_after_updates) { for (const auto & cfg : _integerCfg) { requireThatSearchIsWorkingAfterUpdates(cfg.first, cfg.second, 10, 20); @@ -1733,8 +1701,7 @@ SearchContextTest::requireThatSearchIsWorkingAfterUpdates() } } -void -SearchContextTest::requireThatFlagAttributeIsWorkingWhenNewDocsAreAdded() +TEST_F(SearchContextTest, require_that_flag_attribute_is_working_when_new_docs_are_added) { LOG(info, "requireThatFlagAttributeIsWorkingWhenNewDocsAreAdded()"); Config cfg(BasicType::INT8, CollectionType::ARRAY); @@ -1746,16 +1713,16 @@ SearchContextTest::requireThatFlagAttributeIsWorkingWhenNewDocsAreAdded() fill_array({IL{10, 24}, {20, 24}, {30, 26}, {40, 24}}).get(); { ResultSetPtr rs = performSearch(*a, "<24"); - EXPECT_EQUAL(2u, rs->getNumHits()); - EXPECT_EQUAL(1u, rs->getArray()[0].getDocId()); - EXPECT_EQUAL(2u, rs->getArray()[1].getDocId()); + EXPECT_EQ(2u, rs->getNumHits()); + EXPECT_EQ(1u, rs->getArray()[0].getDocId()); + EXPECT_EQ(2u, rs->getArray()[1].getDocId()); } { ResultSetPtr rs = performSearch(*a, "24"); - EXPECT_EQUAL(3u, rs->getNumHits()); - EXPECT_EQUAL(1u, rs->getArray()[0].getDocId()); - EXPECT_EQUAL(2u, rs->getArray()[1].getDocId()); - EXPECT_EQUAL(4u, rs->getArray()[2].getDocId()); + EXPECT_EQ(3u, rs->getNumHits()); + EXPECT_EQ(1u, rs->getArray()[0].getDocId()); + EXPECT_EQ(2u, rs->getArray()[1].getDocId()); + EXPECT_EQ(4u, rs->getArray()[2].getDocId()); } } { @@ -1779,18 +1746,18 @@ SearchContextTest::requireThatFlagAttributeIsWorkingWhenNewDocsAreAdded() { ResultSetPtr rs1 = performSearch(fa, "50"); ResultSetPtr rs2 = performSearch(fa, "<51"); - EXPECT_EQUAL(exp50.size(), rs1->getNumHits()); - EXPECT_EQUAL(exp50.size(), rs2->getNumHits()); + EXPECT_EQ(exp50.size(), rs1->getNumHits()); + EXPECT_EQ(exp50.size(), rs2->getNumHits()); for (size_t j = 0; j < exp50.size(); ++j) { - EXPECT_EQUAL(exp50[j], rs1->getArray()[j].getDocId()); - EXPECT_EQUAL(exp50[j], rs2->getArray()[j].getDocId()); + EXPECT_EQ(exp50[j], rs1->getArray()[j].getDocId()); + EXPECT_EQ(exp50[j], rs2->getArray()[j].getDocId()); } } { ResultSetPtr rs = performSearch(fa, "60"); - EXPECT_EQUAL(exp60.size(), rs->getNumHits()); + EXPECT_EQ(exp60.size(), rs->getNumHits()); for (size_t j = 0; j < exp60.size(); ++j) { - EXPECT_EQUAL(exp60[j], rs->getArray()[j].getDocId()); + EXPECT_EQ(exp60[j], rs->getArray()[j].getDocId()); } } } @@ -1806,11 +1773,10 @@ SearchContextTest::requireThatInvalidSearchTermGivesZeroHits(const vespalib::str auto a = AttributeBuilder(name, cfg).fill({value}).get(); LOG(info, "requireThatInvalidSearchTermGivesZeroHits: vector '%s'", a->getName().c_str()); ResultSetPtr rs = performSearch(*a, "foo"); - EXPECT_EQUAL(0u, rs->getNumHits()); + EXPECT_EQ(0u, rs->getNumHits()); } -void -SearchContextTest::requireThatInvalidSearchTermGivesZeroHits() +TEST_F(SearchContextTest, require_that_invalid_search_term_gives_zero_hits) { for (const auto & cfg : _integerCfg) { requireThatInvalidSearchTermGivesZeroHits(cfg.first, cfg.second, 10); @@ -1820,8 +1786,7 @@ SearchContextTest::requireThatInvalidSearchTermGivesZeroHits() } } -void -SearchContextTest::requireThatFlagAttributeHandlesTheByteRange() +TEST_F(SearchContextTest, require_that_flag_attribute_handles_the_byte_range) { LOG(info, "requireThatFlagAttributeHandlesTheByteRange()"); Config cfg(BasicType::INT8, CollectionType::ARRAY); @@ -1850,11 +1815,10 @@ SearchContextTest::requireThatOutOfBoundsSearchTermGivesZeroHits(const vespalib: vespalib::string term = vespalib::make_string("%" PRIu64 "", (int64_t) maxValue + 1); LOG(info, "requireThatOutOfBoundsSearchTermGivesZeroHits: vector '%s', term '%s'", a->getName().c_str(), term.c_str()); ResultSetPtr rs = performSearch(*a, term); - EXPECT_EQUAL(0u, rs->getNumHits()); + EXPECT_EQ(0u, rs->getNumHits()); } -void -SearchContextTest::requireThatOutOfBoundsSearchTermGivesZeroHits() +TEST_F(SearchContextTest, require_that_out_of_bounds_search_term_gives_zero_hits) { for (const auto & cfg : _integerCfg) { int32_t maxValue = std::numeric_limits::max(); @@ -1894,8 +1858,8 @@ public: for (uint32_t docid = 1; docid < _attr.getNumDocs(); ++docid) { bool match_1 = search_ctx->matches(docid); bool match_2 = search_ctx->matches(docid, weight); - EXPECT_EQUAL(match_1, match_2); - EXPECT_EQUAL(match_2 ? 1 : 0, weight); + EXPECT_EQ(match_1, match_2); + EXPECT_EQ(match_2 ? 1 : 0, weight); if (match_1) { result.addHit(docid); } @@ -1917,36 +1881,34 @@ public: } }; -void -SearchContextTest::single_bool_attribute_search_context_handles_true_and_false_queries() +TEST_F(SearchContextTest, single_bool_attribute_search_context_handles_true_and_false_queries) { BoolAttributeFixture f(SimpleResult().addHit(3).addHit(5).addHit(7), 9); auto true_exp = SimpleResult().addHit(3).addHit(5).addHit(7); - EXPECT_EQUAL(true_exp, f.search_context("true")); - EXPECT_EQUAL(true_exp, f.search_context("1")); + EXPECT_EQ(true_exp, f.search_context("true")); + EXPECT_EQ(true_exp, f.search_context("1")); auto false_exp = SimpleResult().addHit(1).addHit(2).addHit(4).addHit(6).addHit(8); - EXPECT_EQUAL(false_exp, f.search_context("false")); - EXPECT_EQUAL(false_exp, f.search_context("0")); + EXPECT_EQ(false_exp, f.search_context("false")); + EXPECT_EQ(false_exp, f.search_context("0")); } -void -SearchContextTest::single_bool_attribute_search_iterator_handles_true_and_false_queries() +TEST_F(SearchContextTest, single_bool_attribute_search_iterator_handles_true_and_false_queries) { BoolAttributeFixture f(SimpleResult().addHit(3).addHit(5).addHit(7), 9); auto true_exp = SimpleResult().addHit(3).addHit(5).addHit(7); - EXPECT_EQUAL(true_exp, f.search_iterator("true", false)); - EXPECT_EQUAL(true_exp, f.search_iterator("1", false)); - EXPECT_EQUAL(true_exp, f.search_iterator("true", true)); - EXPECT_EQUAL(true_exp, f.search_iterator("1", true)); + EXPECT_EQ(true_exp, f.search_iterator("true", false)); + EXPECT_EQ(true_exp, f.search_iterator("1", false)); + EXPECT_EQ(true_exp, f.search_iterator("true", true)); + EXPECT_EQ(true_exp, f.search_iterator("1", true)); auto false_exp = SimpleResult().addHit(1).addHit(2).addHit(4).addHit(6).addHit(8); - EXPECT_EQUAL(false_exp, f.search_iterator("false", false)); - EXPECT_EQUAL(false_exp, f.search_iterator("0", false)); - EXPECT_EQUAL(false_exp, f.search_iterator("false", true)); - EXPECT_EQUAL(false_exp, f.search_iterator("0", true)); + EXPECT_EQ(false_exp, f.search_iterator("false", false)); + EXPECT_EQ(false_exp, f.search_iterator("0", false)); + EXPECT_EQ(false_exp, f.search_iterator("false", true)); + EXPECT_EQ(false_exp, f.search_iterator("0", true)); } void @@ -2057,36 +2019,6 @@ SearchContextTest::SearchContextTest() : SearchContextTest::~SearchContextTest() = default; -int -SearchContextTest::Main() -{ - TEST_INIT("searchcontext_test"); - EXPECT_TRUE(true); - - testSearch(); - testSearchIterator(); - testRangeSearch(); - testRangeSearchLimited(); - testRangeSearchLimitedHugeDictionary(); - testCaseInsensitiveSearch(); - testRegexSearch(); - testPrefixSearch(); - testSearchIteratorConformance(); - testSearchIteratorUnpacking(); - testFuzzySearch(); - TEST_DO(requireThatSearchIsWorkingAfterClearDoc()); - TEST_DO(requireThatSearchIsWorkingAfterLoadAndClearDoc()); - TEST_DO(requireThatSearchIsWorkingAfterUpdates()); - TEST_DO(requireThatFlagAttributeIsWorkingWhenNewDocsAreAdded()); - TEST_DO(requireThatInvalidSearchTermGivesZeroHits()); - TEST_DO(requireThatFlagAttributeHandlesTheByteRange()); - TEST_DO(requireThatOutOfBoundsSearchTermGivesZeroHits()); - TEST_DO(single_bool_attribute_search_context_handles_true_and_false_queries()); - TEST_DO(single_bool_attribute_search_iterator_handles_true_and_false_queries()); - - TEST_DONE(); -} - } -TEST_APPHOOK(search::SearchContextTest); +GTEST_MAIN_RUN_ALL_TESTS() -- cgit v1.2.3