Rewrite hit collector unit test to gtest.

3 files changed, 115 insertions, 89 deletions

diff --git a/searchlib/src/tests/hitcollector/CMakeLists.txt b/searchlib/src/tests/hitcollector/CMakeLists.txt
index 5cedbcbd7e6..cc62dd82af4 100644
--- a/searchlib/src/tests/hitcollector/CMakeLists.txt
+++ b/searchlib/src/tests/hitcollector/CMakeLists.txt
@@ -4,6 +4,7 @@ vespa_add_executable(searchlib_hitcollector_test_app TEST
     hitcollector_test.cpp
     DEPENDS
     searchlib
+    GTest::gtest
 )
 vespa_add_test(NAME searchlib_hitcollector_test_app COMMAND searchlib_hitcollector_test_app)
 vespa_add_executable(searchlib_sorted_hit_sequence_test_app TEST
@@ -11,5 +12,6 @@ vespa_add_executable(searchlib_sorted_hit_sequence_test_app TEST
     sorted_hit_sequence_test.cpp
     DEPENDS
     searchlib
+    GTest::gtest
 )
 vespa_add_test(NAME searchlib_sorted_hit_sequence_test_app COMMAND searchlib_sorted_hit_sequence_test_app)
diff --git a/searchlib/src/tests/hitcollector/hitcollector_test.cpp b/searchlib/src/tests/hitcollector/hitcollector_test.cpp
index e6e38181412..3ac5f419228 100644
--- a/searchlib/src/tests/hitcollector/hitcollector_test.cpp
+++ b/searchlib/src/tests/hitcollector/hitcollector_test.cpp
@@ -1,9 +1,9 @@
 // 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/common/bitvector.h>
 #include <vespa/searchlib/fef/fef.h>
 #include <vespa/searchlib/queryeval/hitcollector.h>
+#include <vespa/vespalib/gtest/gtest.h>
 
 #include <vespa/log/log.h>
 LOG_SETUP("hitcollector_test");
@@ -67,11 +67,11 @@ void checkResult(const ResultSet & rs, const std::vector<RankedHit> & exp)
     if ( ! exp.empty()) {
         const RankedHit * rh = rs.getArray();
         ASSERT_TRUE(rh != nullptr);
-        ASSERT_EQUAL(rs.getArrayUsed(), exp.size());
+        ASSERT_EQ(rs.getArrayUsed(), exp.size());
 
         for (uint32_t i = 0; i < exp.size(); ++i) {
-            EXPECT_EQUAL(rh[i].getDocId(), exp[i].getDocId());
-            EXPECT_EQUAL(rh[i].getRank() + 1.0, exp[i].getRank() + 1.0);
+            EXPECT_EQ(rh[i].getDocId(), exp[i].getDocId());
+            EXPECT_DOUBLE_EQ(rh[i].getRank() + 64.0, exp[i].getRank() + 64.0);
         }
     } else {
         ASSERT_TRUE(rs.getArray() == nullptr);
@@ -93,21 +93,24 @@ void checkResult(ResultSet & rs, BitVector * exp)
     }
 }
 
-void testAddHit(uint32_t numDocs, uint32_t maxHitsSize)
+void testAddHit(uint32_t numDocs, uint32_t maxHitsSize, const vespalib::string& label)
 {
 
+    SCOPED_TRACE(label);
     LOG(info, "testAddHit: no hits");
-    { // no hits
+    {
+        SCOPED_TRACE("no hits");
         HitCollector hc(numDocs, maxHitsSize);
         std::vector<RankedHit> expRh;
 
         std::unique_ptr<ResultSet> rs = hc.getResultSet();
-        TEST_DO(checkResult(*rs, expRh));
-        TEST_DO(checkResult(*rs, nullptr));
+        checkResult(*rs, expRh);
+        checkResult(*rs, nullptr);
     }
 
     LOG(info, "testAddHit: only ranked hits");
-    { // only ranked hits
+    {
+        SCOPED_TRACE("only ranked hits");
         HitCollector hc(numDocs, maxHitsSize);
         std::vector<RankedHit> expRh;
 
@@ -121,12 +124,13 @@ void testAddHit(uint32_t numDocs, uint32_t maxHitsSize)
         }
 
         std::unique_ptr<ResultSet> rs = hc.getResultSet();
-        TEST_DO(checkResult(*rs, expRh));
-        TEST_DO(checkResult(*rs, nullptr));
+        checkResult(*rs, expRh);
+        checkResult(*rs, nullptr);
     }
 
     LOG(info, "testAddHit: both ranked hits and bit vector hits");
-    { // both ranked hits and bit vector hits
+    {
+        SCOPED_TRACE("both ranked hits and bitvector hits");
         HitCollector hc(numDocs, maxHitsSize);
         std::vector<RankedHit> expRh;
         BitVector::UP expBv(BitVector::create(numDocs));
@@ -144,14 +148,15 @@ void testAddHit(uint32_t numDocs, uint32_t maxHitsSize)
         }
 
         std::unique_ptr<ResultSet> rs = hc.getResultSet();
-        TEST_DO(checkResult(*rs, expRh));
-        TEST_DO(checkResult(*rs, expBv.get()));
+        checkResult(*rs, expRh);
+        checkResult(*rs, expBv.get());
     }
 }
 
-TEST("testAddHit") {
-    TEST_DO(testAddHit(30, 10));
-    TEST_DO(testAddHit(400, 10)); // 400/32 = 12 which is bigger than 10.
+TEST(HitCollectorTest, testAddHit)
+{
+    testAddHit(30, 10, "numDocs==30");
+    testAddHit(400, 10, "numDocs==400"); // 400/32 = 12 which is bigger than 10.
 }
 
 struct Fixture {
@@ -197,14 +202,17 @@ struct DescendingScoreFixture : Fixture {
 
 DescendingScoreFixture::~DescendingScoreFixture() = default;
 
-TEST_F("testReRank - empty", Fixture) {
-    EXPECT_EQUAL(0u, f.reRank());
+TEST(HitCollectorTest, rerank_empty)
+{
+    Fixture f;
+    EXPECT_EQ(0u, f.reRank());
 }
 
-TEST_F("testReRank - ascending", AscendingScoreFixture)
+TEST(HitCollectorTest, rerank_ascending)
 {
+    AscendingScoreFixture f;
     f.addHits();
-    EXPECT_EQUAL(5u, f.reRank());
+    EXPECT_EQ(5u, f.reRank());
 
     std::vector<RankedHit> expRh;
     for (uint32_t i = 10; i < 20; ++i) {  // 10 last are the best
@@ -213,17 +221,18 @@ TEST_F("testReRank - ascending", AscendingScoreFixture)
             expRh.back()._rankValue = i + 200; // after reranking
         }
     }
-    EXPECT_EQUAL(expRh.size(), 10u);
+    EXPECT_EQ(expRh.size(), 10u);
 
     std::unique_ptr<ResultSet> rs = f.hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
-    TEST_DO(checkResult(*rs, f.expBv.get()));
+    checkResult(*rs, expRh);
+    checkResult(*rs, f.expBv.get());
 }
 
-TEST_F("testReRank - descending", DescendingScoreFixture)
+TEST(HitCollectorTest, rerank_descending)
 {
+    DescendingScoreFixture f;
     f.addHits();
-    EXPECT_EQUAL(5u, f.reRank());
+    EXPECT_EQ(5u, f.reRank());
 
     std::vector<RankedHit> expRh;
     for (uint32_t i = 0; i < 10; ++i) {  // 10 first are the best
@@ -232,17 +241,18 @@ TEST_F("testReRank - descending", DescendingScoreFixture)
             expRh.back()._rankValue = i + 200; // after reranking
         }
     }
-    EXPECT_EQUAL(expRh.size(), 10u);
+    EXPECT_EQ(expRh.size(), 10u);
 
     std::unique_ptr<ResultSet> rs = f.hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
-    TEST_DO(checkResult(*rs, f.expBv.get()));
+    checkResult(*rs, expRh);
+    checkResult(*rs, f.expBv.get());
 }
 
-TEST_F("testReRank - partial", AscendingScoreFixture)
+TEST(HitCollectorTest, rerank_partial)
 {
+    AscendingScoreFixture f;
     f.addHits();
-    EXPECT_EQUAL(3u, f.reRank(3));
+    EXPECT_EQ(3u, f.reRank(3));
 
     std::vector<RankedHit> expRh;
     for (uint32_t i = 10; i < 20; ++i) {  // 10 last are the best
@@ -251,36 +261,39 @@ TEST_F("testReRank - partial", AscendingScoreFixture)
             expRh.back()._rankValue = i + 200; // after reranking
         }
     }
-    EXPECT_EQUAL(expRh.size(), 10u);
+    EXPECT_EQ(expRh.size(), 10u);
 
     std::unique_ptr<ResultSet> rs = f.hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
-    TEST_DO(checkResult(*rs, f.expBv.get()));
+    checkResult(*rs, expRh);
+    checkResult(*rs, f.expBv.get());
 }
 
-TEST_F("require that hits for 2nd phase candidates can be retrieved", DescendingScoreFixture)
+TEST(HitCollectorTest, require_that_hits_for_2nd_phase_candidates_can_be_retrieved)
 {
+    DescendingScoreFixture f;
     f.addHits();
     std::vector<HitCollector::Hit> scores = extract(f.hc.getSortedHitSequence(5));
-    ASSERT_EQUAL(5u, scores.size());
-    EXPECT_EQUAL(100, scores[0].second);
-    EXPECT_EQUAL(99, scores[1].second);
-    EXPECT_EQUAL(98, scores[2].second);
-    EXPECT_EQUAL(97, scores[3].second);
-    EXPECT_EQUAL(96, scores[4].second);
+    ASSERT_EQ(5u, scores.size());
+    EXPECT_EQ(100, scores[0].second);
+    EXPECT_EQ(99, scores[1].second);
+    EXPECT_EQ(98, scores[2].second);
+    EXPECT_EQ(97, scores[3].second);
+    EXPECT_EQ(96, scores[4].second);
 }
 
-TEST("require that score ranges can be read and set.") {
+TEST(HitCollectorTest, require_that_score_ranges_can_be_read_and_set)
+{
     std::pair<Scores, Scores> ranges = std::make_pair(Scores(1.0, 2.0), Scores(3.0, 4.0));
     HitCollector hc(20, 10);
     hc.setRanges(ranges);
-    EXPECT_EQUAL(ranges.first.low, hc.getRanges().first.low);
-    EXPECT_EQUAL(ranges.first.high, hc.getRanges().first.high);
-    EXPECT_EQUAL(ranges.second.low, hc.getRanges().second.low);
-    EXPECT_EQUAL(ranges.second.high, hc.getRanges().second.high);
+    EXPECT_EQ(ranges.first.low, hc.getRanges().first.low);
+    EXPECT_EQ(ranges.first.high, hc.getRanges().first.high);
+    EXPECT_EQ(ranges.second.low, hc.getRanges().second.low);
+    EXPECT_EQ(ranges.second.high, hc.getRanges().second.high);
 }
 
-TEST("testNoHitsToReRank") {
+TEST(HitCollectorTest, no_hits_to_rerank)
+{
     uint32_t numDocs = 20;
     uint32_t maxHitsSize = 10;
 
@@ -299,8 +312,8 @@ TEST("testNoHitsToReRank") {
         }
 
         std::unique_ptr<ResultSet> rs = hc.getResultSet();
-        TEST_DO(checkResult(*rs, expRh));
-        TEST_DO(checkResult(*rs, nullptr));
+        checkResult(*rs, expRh);
+        checkResult(*rs, nullptr);
     }
 }
 
@@ -317,14 +330,15 @@ void testScaling(const std::vector<feature_t> &initScores,
 
     PredefinedScorer scorer(std::move(finalScores));
     // perform second phase ranking
-    EXPECT_EQUAL(2u, do_reRank(scorer, hc, 2));
+    EXPECT_EQ(2u, do_reRank(scorer, hc, 2));
 
     // check results
     std::unique_ptr<ResultSet> rs = hc.getResultSet();
-    TEST_DO(checkResult(*rs, expected));
+    checkResult(*rs, expected);
 }
 
-TEST("testScaling") {
+TEST(HitCollectorTest, scaling)
+{
     std::vector<feature_t> initScores(5);
     initScores[0] = 1000;
     initScores[1] = 2000;
@@ -338,7 +352,8 @@ TEST("testScaling") {
         exp[i]._docId = i;
     }
 
-    { // scale down and adjust down
+    {
+        SCOPED_TRACE("scale down and adjust down");
         exp[0]._rankValue = 0;   // scaled
         exp[1]._rankValue = 100; // scaled
         exp[2]._rankValue = 200; // scaled
@@ -350,9 +365,10 @@ TEST("testScaling") {
         finalScores[3] = 300;
         finalScores[4] = 400;
 
-        TEST_DO(testScaling(initScores, std::move(finalScores), exp));
+        testScaling(initScores, std::move(finalScores), exp);
     }
-    { // scale down and adjust up
+    {
+        SCOPED_TRACE("scale down and adjust up");
         exp[0]._rankValue = 200; // scaled
         exp[1]._rankValue = 300; // scaled
         exp[2]._rankValue = 400; // scaled
@@ -364,10 +380,10 @@ TEST("testScaling") {
         finalScores[3] = 500;
         finalScores[4] = 600;
 
-        TEST_DO(testScaling(initScores, std::move(finalScores), exp));
+        testScaling(initScores, std::move(finalScores), exp);
     }
-    { // scale up and adjust down
-
+    {
+        SCOPED_TRACE("scale up and adjust down");
         exp[0]._rankValue = -500; // scaled (-500)
         exp[1]._rankValue = 750;  // scaled
         exp[2]._rankValue = 2000; // scaled
@@ -379,9 +395,10 @@ TEST("testScaling") {
         finalScores[3] = 3250;
         finalScores[4] = 4500;
 
-        TEST_DO(testScaling(initScores, std::move(finalScores), exp));
+        testScaling(initScores, std::move(finalScores), exp);
     }
-    { // minimal scale (second phase range = 0 (4 - 4) -> 1)
+    {
+        SCOPED_TRACE("minimal scale (second phase range = 0 (4 - 4) -> 1)");
         exp[0]._rankValue = 1; // scaled
         exp[1]._rankValue = 2; // scaled
         exp[2]._rankValue = 3; // scaled
@@ -393,9 +410,10 @@ TEST("testScaling") {
         finalScores[3] = 4;
         finalScores[4] = 4;
 
-        TEST_DO(testScaling(initScores, std::move(finalScores), exp));
+        testScaling(initScores, std::move(finalScores), exp);
     }
-    { // minimal scale (first phase range = 0 (4000 - 4000) -> 1)
+    {
+        SCOPED_TRACE("minimal scale (first phase range = 0 (4000 - 4000) -> 1)");
         std::vector<feature_t> is(initScores);
         is[4] = 4000;
         exp[0]._rankValue = -299600; // scaled
@@ -409,11 +427,12 @@ TEST("testScaling") {
         finalScores[3] = 400;
         finalScores[4] = 500;
 
-        TEST_DO(testScaling(is, std::move(finalScores), exp));
+        testScaling(is, std::move(finalScores), exp);
     }
 }
 
-TEST("testOnlyBitVector") {
+TEST(HitCollectorTest, only_bitvector)
+{
     uint32_t numDocs = 20;
     LOG(info, "testOnlyBitVector: test it");
     {
@@ -428,8 +447,8 @@ TEST("testOnlyBitVector") {
 
         std::unique_ptr<ResultSet> rs = hc.getResultSet();
         std::vector<RankedHit> expRh;
-        TEST_DO(checkResult(*rs, expRh));  // no ranked hits
-        TEST_DO(checkResult(*rs, expBv.get())); // only bit vector
+        checkResult(*rs, expRh);  // no ranked hits
+        checkResult(*rs, expBv.get()); // only bit vector
     }
 }
 
@@ -443,9 +462,9 @@ struct MergeResultSetFixture {
     {}
 };
 
-TEST_F("require that result set is merged correctly with first phase ranking",
-        MergeResultSetFixture)
+TEST(HitCollectorTest, require_that_result_set_is_merged_correctly_with_first_phase_ranking)
 {
+    MergeResultSetFixture f;
     std::vector<RankedHit> expRh;
     for (uint32_t i = 0; i < f.numDocs; ++i) {
         f.hc.addHit(i, i + 1000);
@@ -457,7 +476,7 @@ TEST_F("require that result set is merged correctly with first phase ranking",
         expRh.back()._rankValue = (i < f.numDocs - f.maxHitsSize) ? default_rank_value : i + 1000;
     }
     std::unique_ptr<ResultSet> rs = f.hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
+    checkResult(*rs, expRh);
 }
 
 void
@@ -474,9 +493,9 @@ addExpectedHitForMergeTest(const MergeResultSetFixture &f, std::vector<RankedHit
     }
 }
 
-TEST_F("require that result set is merged correctly with second phase ranking (document scorer)",
-        MergeResultSetFixture)
+TEST(HitCollectorTest, require_that_result_set_is_merged_correctly_with_second_phase_ranking_using_document_scorer)
 {
+    MergeResultSetFixture f;
     // with second phase ranking that triggers rescoring / scaling
     BasicScorer scorer(500); // second phase ranking setting score to docId + 500
     std::vector<RankedHit> expRh;
@@ -484,12 +503,13 @@ TEST_F("require that result set is merged correctly with second phase ranking (d
         f.hc.addHit(i, i + 1000);
         addExpectedHitForMergeTest(f, expRh, i);
     }
-    EXPECT_EQUAL(f.maxHeapSize, do_reRank(scorer, f.hc, f.maxHeapSize));
+    EXPECT_EQ(f.maxHeapSize, do_reRank(scorer, f.hc, f.maxHeapSize));
     std::unique_ptr<ResultSet> rs = f.hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
+    checkResult(*rs, expRh);
 }
 
-TEST("require that hits can be added out of order") {
+TEST(HitCollectorTest, require_that_hits_can_be_added_out_of_order)
+{
     HitCollector hc(1000, 100);
     std::vector<RankedHit> expRh;
     // produce expected result in normal order
@@ -503,11 +523,12 @@ TEST("require that hits can be added out of order") {
         hc.addHit(i, i + 100);
     }
     std::unique_ptr<ResultSet> rs = hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
-    TEST_DO(checkResult(*rs, nullptr));
+    checkResult(*rs, expRh);
+    checkResult(*rs, nullptr);
 }
 
-TEST("require that hits can be added out of order when passing array limit") {
+TEST(HitCollectorTest, require_that_hits_can_be_added_out_of_order_when_passing_array_limit)
+{
     HitCollector hc(10000, 100);
     std::vector<RankedHit> expRh;
     // produce expected result in normal order
@@ -525,11 +546,12 @@ TEST("require that hits can be added out of order when passing array limit") {
         hc.addHit(i, i + 100);
     }
     std::unique_ptr<ResultSet> rs = hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
-    TEST_DO(checkResult(*rs, nullptr));
+    checkResult(*rs, expRh);
+    checkResult(*rs, nullptr);
 }
 
-TEST("require that hits can be added out of order only after passing array limit") {
+TEST(HitCollectorTest, require_that_hits_can_be_added_out_of_order_only_after_passing_array_limit)
+{
     HitCollector hc(10000, 100);
     std::vector<RankedHit> expRh;
     // produce expected result in normal order
@@ -548,8 +570,8 @@ TEST("require that hits can be added out of order only after passing array limit
         hc.addHit(i, i + 100);
     }
     std::unique_ptr<ResultSet> rs = hc.getResultSet();
-    TEST_DO(checkResult(*rs, expRh));
-    TEST_DO(checkResult(*rs, nullptr));
+    checkResult(*rs, expRh);
+    checkResult(*rs, nullptr);
 }
 
-TEST_MAIN() { TEST_RUN_ALL(); }
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/searchlib/src/tests/hitcollector/sorted_hit_sequence_test.cpp b/searchlib/src/tests/hitcollector/sorted_hit_sequence_test.cpp
index c1c3a550d9b..4eefa5b5dfa 100644
--- a/searchlib/src/tests/hitcollector/sorted_hit_sequence_test.cpp
+++ b/searchlib/src/tests/hitcollector/sorted_hit_sequence_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/queryeval/sorted_hit_sequence.h>
+#include <vespa/vespalib/gtest/gtest.h>
 
 using search::queryeval::SortedHitSequence;
 using Hits = std::vector<SortedHitSequence::Hit>;
@@ -10,20 +10,22 @@ using Refs = std::vector<SortedHitSequence::Ref>;
 Hits hits({{1,10.0},{2,30.0},{3,20.0}});
 Refs refs({1,2,0});
 
-TEST("require that empty hit sequence is empty") {
+TEST(SortedHitsSEquenceTest, require_that_empty_hit_sequence_is_empty)
+{
     EXPECT_TRUE(!SortedHitSequence(nullptr, nullptr, 0).valid());
     EXPECT_TRUE(!SortedHitSequence(&hits[0], &refs[0], 0).valid());
 }
 
-TEST("require that sorted hit sequence can be iterated") {
+TEST(SortedHitsSEquenceTest, require_that_sorted_hit_sequence_can_be_iterated)
+{
     SortedHitSequence seq(&hits[0], &refs[0], refs.size());
     for (const auto &expect: Hits({{2,30.0},{3,20.0},{1,10.0}})) {
         ASSERT_TRUE(seq.valid());
-        EXPECT_EQUAL(expect.first, seq.get().first);
-        EXPECT_EQUAL(expect.second, seq.get().second);
+        EXPECT_EQ(expect.first, seq.get().first);
+        EXPECT_EQ(expect.second, seq.get().second);
         seq.next();
     }
     EXPECT_TRUE(!seq.valid());
 }
 
-TEST_MAIN() { TEST_RUN_ALL(); }
+GTEST_MAIN_RUN_ALL_TESTS()