Rewrite rank setup unit test to gtest.

2 files changed, 165 insertions, 203 deletions

diff --git a/searchlib/src/tests/ranksetup/CMakeLists.txt b/searchlib/src/tests/ranksetup/CMakeLists.txt
index d5eb349a6c7..8dc0ea98835 100644
--- a/searchlib/src/tests/ranksetup/CMakeLists.txt
+++ b/searchlib/src/tests/ranksetup/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(searchlib_ranksetup_test_app TEST
     ranksetup_test.cpp
     DEPENDS
     searchlib
+    GTest::gtest
 )
 vespa_add_test(NAME searchlib_ranksetup_test_app COMMAND searchlib_ranksetup_test_app)
diff --git a/searchlib/src/tests/ranksetup/ranksetup_test.cpp b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
index 595b2065feb..8ac82eeb14e 100644
--- a/searchlib/src/tests/ranksetup/ranksetup_test.cpp
+++ b/searchlib/src/tests/ranksetup/ranksetup_test.cpp
@@ -1,7 +1,5 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/vespalib/testkit/testapp.h>
-#include <vespa/vespalib/util/stringfmt.h>
 #include <vespa/searchlib/common/feature.h>
 
 #include <vespa/searchlib/attribute/attributeguard.h>
@@ -36,6 +34,8 @@
 #include <vespa/searchlib/fef/test/plugin/sum.h>
 #include <vespa/searchlib/fef/test/plugin/cfgvalue.h>
 #include <vespa/searchlib/fef/test/dummy_dependency_handler.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <vespa/vespalib/util/stringfmt.h>
 #include <iostream>
 
 using namespace search::fef;
@@ -220,9 +220,9 @@ FeatureDumper::dump()
 //-----------------------------------------------------------------------------
 // RankSetupTest
 //-----------------------------------------------------------------------------
-class RankSetupTest : public vespalib::TestApp
+class RankSetupTest : public ::testing::Test
 {
-private:
+protected:
     BlueprintFactory _factory;
     search::AttributeManager _manager;
     IndexEnvironment _indexEnv;
@@ -230,14 +230,6 @@ private:
     RankEnvironment  _rankEnv;
     DumpFeatureVisitor _visitor;
 
-    void testValueBlueprint();
-    void testDoubleBlueprint();
-    void testSumBlueprint();
-    void testStaticRankBlueprint();
-    void testChainBlueprint();
-    void testCfgValueBlueprint();
-    void testCompilation();
-    void testRankSetup();
     bool testExecution(const vespalib::string & initRank, feature_t initScore,
                        const vespalib::string & finalRank = "", feature_t finalScore = 0.0f, uint32_t docId = 1);
     bool testExecution(const RankEnvironment &rankEnv,
@@ -249,15 +241,52 @@ private:
     void checkFeatures(std::map<vespalib::string, feature_t> &exp, std::map<vespalib::string, feature_t> &actual);
     void testFeatureNormalization();
 
-public:
     RankSetupTest();
-    ~RankSetupTest();
-    int Main() override;
+    ~RankSetupTest() override;
 };
 
+RankSetupTest::RankSetupTest()
+    : _factory(),
+      _manager(),
+      _indexEnv(),
+      _queryEnv(),
+      _rankEnv(_factory, _indexEnv, _queryEnv),
+      _visitor()
+{
+    // register blueprints
+    setup_fef_test_plugin(_factory);
+    _factory.addPrototype(Blueprint::SP(new ValueBlueprint()));
+    _factory.addPrototype(Blueprint::SP(new RankingExpressionBlueprint()));
+    _factory.addPrototype(std::make_shared<SecondPhaseBlueprint>());
 
-void
-RankSetupTest::testValueBlueprint()
+    // setup an original attribute manager with two attributes
+    search::attribute::Config cfg(search::attribute::BasicType::INT32,
+                                        search::attribute::CollectionType::SINGLE);
+    search::AttributeVector::SP av1 =
+        search::AttributeFactory::createAttribute("staticrank1", cfg);
+    search::AttributeVector::SP av2 =
+        search::AttributeFactory::createAttribute("staticrank2", cfg);
+    av1->addDocs(5);
+    av2->addDocs(5);
+    for (uint32_t i = 0; i < 5; ++i) {
+        (static_cast<search::IntegerAttribute *>(av1.get()))->update(i, i + 100);
+        (static_cast<search::IntegerAttribute *>(av2.get()))->update(i, i + 200);
+    }
+    av1->commit();
+    av2->commit();
+    _manager.add(av1);
+    _manager.add(av2);
+
+    // set the index environment
+    _queryEnv.setIndexEnv(&_indexEnv);
+
+    // set the manager
+    _queryEnv.overrideAttributeManager(&_manager);
+}
+
+RankSetupTest::~RankSetupTest() = default;
+
+TEST_F(RankSetupTest, value_blueprint)
 {
     ValueBlueprint prototype;
     prototype.visitDumpFeatures(_indexEnv, _visitor);
@@ -265,22 +294,22 @@ RankSetupTest::testValueBlueprint()
         Blueprint::UP bp = prototype.createInstance();
         DummyDependencyHandler deps(*bp);
         bp->setName("value");
-        EXPECT_EQUAL(bp->getName(), "value");
+        EXPECT_EQ(bp->getName(), "value");
         std::vector<vespalib::string> params;
         params.push_back("5.5");
         params.push_back("10.5");
         EXPECT_TRUE(bp->setup(_indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 0u);
-        EXPECT_EQUAL(deps.output.size(), 2u);
-        EXPECT_EQUAL(deps.output[0], "0");
-        EXPECT_EQUAL(deps.output[1], "1");
+        EXPECT_EQ(deps.input.size(), 0u);
+        EXPECT_EQ(deps.output.size(), 2u);
+        EXPECT_EQ(deps.output[0], "0");
+        EXPECT_EQ(deps.output[1], "1");
 
         vespalib::Stash stash;
         FeatureExecutor &fe = bp->createExecutor(_queryEnv, stash);
         ValueExecutor * vfe = static_cast<ValueExecutor *>(&fe);
-        EXPECT_EQUAL(vfe->getValues().size(), 2u);
-        EXPECT_EQUAL(vfe->getValues()[0], 5.5f);
-        EXPECT_EQUAL(vfe->getValues()[1], 10.5f);
+        EXPECT_EQ(vfe->getValues().size(), 2u);
+        EXPECT_EQ(vfe->getValues()[0], 5.5f);
+        EXPECT_EQ(vfe->getValues()[1], 10.5f);
     }
     { // invalid params
         Blueprint::UP bp = prototype.createInstance();
@@ -290,8 +319,7 @@ RankSetupTest::testValueBlueprint()
     }
 }
 
-void
-RankSetupTest::testDoubleBlueprint()
+TEST_F(RankSetupTest, double_blueprint)
 {
     DoubleBlueprint prototype;
     prototype.visitDumpFeatures(_indexEnv, _visitor);
@@ -302,17 +330,16 @@ RankSetupTest::testDoubleBlueprint()
         params.push_back("value(5.5).0");
         params.push_back("value(10.5).0");
         EXPECT_TRUE(bp->setup(_indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 2u);
-        EXPECT_EQUAL(deps.input[0], "value(5.5).0");
-        EXPECT_EQUAL(deps.input[1], "value(10.5).0");
-        EXPECT_EQUAL(deps.output.size(), 2u);
-        EXPECT_EQUAL(deps.output[0], "0");
-        EXPECT_EQUAL(deps.output[1], "1");
+        EXPECT_EQ(deps.input.size(), 2u);
+        EXPECT_EQ(deps.input[0], "value(5.5).0");
+        EXPECT_EQ(deps.input[1], "value(10.5).0");
+        EXPECT_EQ(deps.output.size(), 2u);
+        EXPECT_EQ(deps.output[0], "0");
+        EXPECT_EQ(deps.output[1], "1");
    }
 }
 
-void
-RankSetupTest::testSumBlueprint()
+TEST_F(RankSetupTest, sum_blueprint)
 {
     SumBlueprint prototype;
     prototype.visitDumpFeatures(_indexEnv, _visitor);
@@ -323,16 +350,15 @@ RankSetupTest::testSumBlueprint()
         params.push_back("value(5.5, 10.5).0");
         params.push_back("value(5.5, 10.5).1");
         EXPECT_TRUE(bp->setup(_indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 2u);
-        EXPECT_EQUAL(deps.input[0], "value(5.5, 10.5).0");
-        EXPECT_EQUAL(deps.input[1], "value(5.5, 10.5).1");
-        EXPECT_EQUAL(deps.output.size(), 1u);
-        EXPECT_EQUAL(deps.output[0], "out");
+        EXPECT_EQ(deps.input.size(), 2u);
+        EXPECT_EQ(deps.input[0], "value(5.5, 10.5).0");
+        EXPECT_EQ(deps.input[1], "value(5.5, 10.5).1");
+        EXPECT_EQ(deps.output.size(), 1u);
+        EXPECT_EQ(deps.output[0], "out");
     }
 }
 
-void
-RankSetupTest::testStaticRankBlueprint()
+TEST_F(RankSetupTest, static_rank_blueprint)
 {
     StaticRankBlueprint prototype;
     { // basic test
@@ -341,9 +367,9 @@ RankSetupTest::testStaticRankBlueprint()
         std::vector<vespalib::string> params;
         params.push_back("sr1");
         EXPECT_TRUE(bp->setup(_indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 0u);
-        EXPECT_EQUAL(deps.output.size(), 1u);
-        EXPECT_EQUAL(deps.output[0], "out");
+        EXPECT_EQ(deps.input.size(), 0u);
+        EXPECT_EQ(deps.output.size(), 1u);
+        EXPECT_EQ(deps.output[0], "out");
     }
     { // invalid params
         Blueprint::UP bp = prototype.createInstance();
@@ -356,8 +382,7 @@ RankSetupTest::testStaticRankBlueprint()
     }
 }
 
-void
-RankSetupTest::testChainBlueprint()
+TEST_F(RankSetupTest, chain_blueprint)
 {
     ChainBlueprint prototype;
     { // chaining
@@ -368,8 +393,8 @@ RankSetupTest::testChainBlueprint()
         params.push_back("2");
         params.push_back("4");
         EXPECT_TRUE(bp->setup(_indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 1u);
-        EXPECT_EQUAL(deps.input[0], "chain(basic,1,4)");
+        EXPECT_EQ(deps.input.size(), 1u);
+        EXPECT_EQ(deps.input[0], "chain(basic,1,4)");
     }
     { // leaf node
         Blueprint::UP bp = prototype.createInstance();
@@ -379,8 +404,8 @@ RankSetupTest::testChainBlueprint()
         params.push_back("1");
         params.push_back("4");
         EXPECT_TRUE(bp->setup(_indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 1u);
-        EXPECT_EQUAL(deps.input[0], "value(4)");
+        EXPECT_EQ(deps.input.size(), 1u);
+        EXPECT_EQ(deps.input[0], "value(4)");
     }
     { // cycle
         Blueprint::UP bp = prototype.createInstance();
@@ -390,8 +415,8 @@ RankSetupTest::testChainBlueprint()
         params.push_back("1");
         params.push_back("4");
         EXPECT_TRUE(bp->setup(_indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 1u);
-        EXPECT_EQUAL(deps.input[0], "chain(cycle,4,4)");
+        EXPECT_EQ(deps.input.size(), 1u);
+        EXPECT_EQ(deps.input[0], "chain(cycle,4,4)");
     }
     { // invalid params
         Blueprint::UP bp = prototype.createInstance();
@@ -405,8 +430,7 @@ RankSetupTest::testChainBlueprint()
     }
 }
 
-void
-RankSetupTest::testCfgValueBlueprint()
+TEST_F(RankSetupTest, cfg_value_blueprint)
 {
     CfgValueBlueprint     prototype;
     IndexEnvironment      indexEnv;
@@ -422,25 +446,23 @@ RankSetupTest::testCfgValueBlueprint()
         params.push_back("foo");
 
         EXPECT_TRUE(bp->setup(indexEnv, params));
-        EXPECT_EQUAL(deps.input.size(), 0u);
-        EXPECT_EQUAL(deps.output.size(), 3u);
-        EXPECT_EQUAL(deps.output[0], "0");
-        EXPECT_EQUAL(deps.output[1], "1");
-        EXPECT_EQUAL(deps.output[2], "2");
+        EXPECT_EQ(deps.input.size(), 0u);
+        EXPECT_EQ(deps.output.size(), 3u);
+        EXPECT_EQ(deps.output[0], "0");
+        EXPECT_EQ(deps.output[1], "1");
+        EXPECT_EQ(deps.output[2], "2");
 
         vespalib::Stash stash;
         FeatureExecutor &fe = bp->createExecutor(_queryEnv, stash);
         ValueExecutor *vfe = static_cast<ValueExecutor *>(&fe);
-        EXPECT_EQUAL(vfe->getValues().size(), 3u);
-        EXPECT_EQUAL(vfe->getValues()[0], 1.0f);
-        EXPECT_EQUAL(vfe->getValues()[1], 2.0f);
-        EXPECT_EQUAL(vfe->getValues()[2], 3.0f);
+        EXPECT_EQ(vfe->getValues().size(), 3u);
+        EXPECT_EQ(vfe->getValues()[0], 1.0f);
+        EXPECT_EQ(vfe->getValues()[1], 2.0f);
+        EXPECT_EQ(vfe->getValues()[2], 3.0f);
     }
 }
 
-
-void
-RankSetupTest::testCompilation()
+TEST_F(RankSetupTest, compilation)
 {
     { // unknown blueprint
         RankSetup rs(_factory, _indexEnv);
@@ -499,7 +521,7 @@ RankSetupTest::testCompilation()
     }
 }
 
-void RankSetupTest::testRankSetup()
+TEST_F(RankSetupTest, rank_setup)
 {
     using namespace search::fef::indexproperties;
     IndexEnvironment env;
@@ -542,44 +564,44 @@ void RankSetupTest::testRankSetup()
     RankSetup rs(_factory, env);
     EXPECT_FALSE(rs.has_match_features());
     rs.configure();
-    EXPECT_EQUAL(rs.getFirstPhaseRank(), vespalib::string("firstphase"));
-    EXPECT_EQUAL(rs.getSecondPhaseRank(), vespalib::string("secondphase"));
+    EXPECT_EQ(rs.getFirstPhaseRank(), vespalib::string("firstphase"));
+    EXPECT_EQ(rs.getSecondPhaseRank(), vespalib::string("secondphase"));
     EXPECT_TRUE(rs.has_match_features());
     ASSERT_TRUE(rs.get_match_features().size() == 2);
-    EXPECT_EQUAL(rs.get_match_features()[0], vespalib::string("match_foo"));
-    EXPECT_EQUAL(rs.get_match_features()[1], vespalib::string("match_bar"));
+    EXPECT_EQ(rs.get_match_features()[0], vespalib::string("match_foo"));
+    EXPECT_EQ(rs.get_match_features()[1], vespalib::string("match_bar"));
     ASSERT_TRUE(rs.getDumpFeatures().size() == 2);
-    EXPECT_EQUAL(rs.getDumpFeatures()[0], vespalib::string("foo"));
-    EXPECT_EQUAL(rs.getDumpFeatures()[1], vespalib::string("bar"));
-    EXPECT_EQUAL(rs.getNumThreadsPerSearch(), 3u);
-    EXPECT_EQUAL(rs.getMinHitsPerThread(), 8u);
-    EXPECT_EQUAL(rs.getDegradationAttribute(), "mystaticrankattr");
-    EXPECT_EQUAL(rs.isDegradationOrderAscending(), true);
-    EXPECT_EQUAL(rs.getDegradationMaxHits(), 12345u);
-    EXPECT_EQUAL(rs.getDegradationSamplePercentage(), 0.9);
-    EXPECT_EQUAL(rs.getDegradationMaxFilterCoverage(), 0.19);
-    EXPECT_EQUAL(rs.getDegradationPostFilterMultiplier(), 0.7);
-    EXPECT_EQUAL(rs.getDiversityAttribute(), "mycategoryattr");
-    EXPECT_EQUAL(rs.getDiversityMinGroups(), 37u);
-    EXPECT_EQUAL(rs.getDiversityCutoffFactor(), 7.1);
-    EXPECT_EQUAL(rs.getDiversityCutoffStrategy(), "strict");
-    EXPECT_EQUAL(rs.getHeapSize(), 50u);
-    EXPECT_EQUAL(rs.getArraySize(), 60u);
-    EXPECT_EQUAL(rs.getEstimatePoint(), 70u);
-    EXPECT_EQUAL(rs.getEstimateLimit(), 80u);
-    EXPECT_EQUAL(rs.get_first_phase_rank_score_drop_limit().value(), 90.5);
-    EXPECT_EQUAL(rs.getMutateOnMatch()._attribute, "a");
-    EXPECT_EQUAL(rs.getMutateOnMatch()._operation, "+=3");
-    EXPECT_EQUAL(rs.getMutateOnFirstPhase()._attribute, "b");
-    EXPECT_EQUAL(rs.getMutateOnFirstPhase()._operation, "=3");
-    EXPECT_EQUAL(rs.getMutateOnSecondPhase()._attribute, "b");
-    EXPECT_EQUAL(rs.getMutateOnSecondPhase()._operation, "=7");
-    EXPECT_EQUAL(rs.getMutateOnSummary()._attribute, "c");
-    EXPECT_EQUAL(rs.getMutateOnSummary()._operation, "-=2");
-    EXPECT_EQUAL(rs.get_global_filter_lower_limit(), 0.3);
-    EXPECT_EQUAL(rs.get_global_filter_upper_limit(), 0.7);
-    EXPECT_EQUAL(rs.get_target_hits_max_adjustment_factor(), 5.0);
-    EXPECT_EQUAL(rs.get_fuzzy_matching_algorithm(), vespalib::FuzzyMatchingAlgorithm::DfaImplicit);
+    EXPECT_EQ(rs.getDumpFeatures()[0], vespalib::string("foo"));
+    EXPECT_EQ(rs.getDumpFeatures()[1], vespalib::string("bar"));
+    EXPECT_EQ(rs.getNumThreadsPerSearch(), 3u);
+    EXPECT_EQ(rs.getMinHitsPerThread(), 8u);
+    EXPECT_EQ(rs.getDegradationAttribute(), "mystaticrankattr");
+    EXPECT_EQ(rs.isDegradationOrderAscending(), true);
+    EXPECT_EQ(rs.getDegradationMaxHits(), 12345u);
+    EXPECT_EQ(rs.getDegradationSamplePercentage(), 0.9);
+    EXPECT_EQ(rs.getDegradationMaxFilterCoverage(), 0.19);
+    EXPECT_EQ(rs.getDegradationPostFilterMultiplier(), 0.7);
+    EXPECT_EQ(rs.getDiversityAttribute(), "mycategoryattr");
+    EXPECT_EQ(rs.getDiversityMinGroups(), 37u);
+    EXPECT_EQ(rs.getDiversityCutoffFactor(), 7.1);
+    EXPECT_EQ(rs.getDiversityCutoffStrategy(), "strict");
+    EXPECT_EQ(rs.getHeapSize(), 50u);
+    EXPECT_EQ(rs.getArraySize(), 60u);
+    EXPECT_EQ(rs.getEstimatePoint(), 70u);
+    EXPECT_EQ(rs.getEstimateLimit(), 80u);
+    EXPECT_EQ(rs.get_first_phase_rank_score_drop_limit().value(), 90.5);
+    EXPECT_EQ(rs.getMutateOnMatch()._attribute, "a");
+    EXPECT_EQ(rs.getMutateOnMatch()._operation, "+=3");
+    EXPECT_EQ(rs.getMutateOnFirstPhase()._attribute, "b");
+    EXPECT_EQ(rs.getMutateOnFirstPhase()._operation, "=3");
+    EXPECT_EQ(rs.getMutateOnSecondPhase()._attribute, "b");
+    EXPECT_EQ(rs.getMutateOnSecondPhase()._operation, "=7");
+    EXPECT_EQ(rs.getMutateOnSummary()._attribute, "c");
+    EXPECT_EQ(rs.getMutateOnSummary()._operation, "-=2");
+    EXPECT_EQ(rs.get_global_filter_lower_limit(), 0.3);
+    EXPECT_EQ(rs.get_global_filter_upper_limit(), 0.7);
+    EXPECT_EQ(rs.get_target_hits_max_adjustment_factor(), 5.0);
+    EXPECT_EQ(rs.get_fuzzy_matching_algorithm(), vespalib::FuzzyMatchingAlgorithm::DfaImplicit);
 }
 
 bool
@@ -604,12 +626,11 @@ RankSetupTest::testExecution(const RankEnvironment &rankEnv, const vespalib::str
     }
     RankResult rs = re.execute(docId);
     ok = ok && (exp == rs);
-    EXPECT_EQUAL(exp, rs);
+    EXPECT_EQ(exp, rs);
     return ok;
 }
 
-void
-RankSetupTest::testExecution()
+TEST_F(RankSetupTest, execution)
 {
     { // value executor
         vespalib::string v = FNB().baseName("value").parameter("5.5").parameter("10.5").buildName();
@@ -699,8 +720,7 @@ RankSetupTest::testExecution()
     }
 }
 
-void
-RankSetupTest::testFeatureDump()
+TEST_F(RankSetupTest, feature_dump)
 {
     {
         FeatureDumper dumper(_rankEnv);
@@ -722,7 +742,7 @@ RankSetupTest::testFeatureDump()
                      parameter(FNB().baseName("double").parameter("value(8)").buildName()).
                      parameter(FNB().baseName("double").parameter("value(32)").buildName()).
                      buildName(), 80.0f);
-        EXPECT_EQUAL(exp, dumper.dump());
+        EXPECT_EQ(exp, dumper.dump());
     }
     {
         FeatureDumper dumper(_rankEnv);
@@ -732,7 +752,7 @@ RankSetupTest::testFeatureDump()
         RankResult exp;
         exp.addScore("value(50)", 50.0f);
         exp.addScore("value(100)", 100.0f);
-        EXPECT_EQUAL(exp, dumper.dump());
+        EXPECT_EQ(exp, dumper.dump());
     }
     {
         FeatureDumper dumper(_rankEnv);
@@ -740,7 +760,7 @@ RankSetupTest::testFeatureDump()
         EXPECT_TRUE(dumper.setup());
         RankResult exp;
         exp.addScore(FNB().baseName("rankingExpression").parameter("if(4<2,3,4)").buildName(), 4.0f);
-        EXPECT_EQUAL(exp, dumper.dump());
+        EXPECT_EQ(exp, dumper.dump());
     }
 
     {
@@ -749,7 +769,7 @@ RankSetupTest::testFeatureDump()
         EXPECT_TRUE(dumper.setup());
         RankResult exp;
         exp.addScore(FNB().baseName("rankingExpression").parameter("if(mysum(value(12),value(10))>2,3,4)").buildName(), 3.0f);
-        EXPECT_EQUAL(exp, dumper.dump());
+        EXPECT_EQ(exp, dumper.dump());
     }
     { // dump features indicated by visitation
         IndexEnvironment indexEnv;
@@ -767,7 +787,7 @@ RankSetupTest::testFeatureDump()
         RankResult exp;
         exp.addScore("test_cfgvalue(foo)", 1.0);
         exp.addScore("test_cfgvalue(bar)", 5.0);
-        EXPECT_EQUAL(exp, dumper.dump());
+        EXPECT_EQ(exp, dumper.dump());
     }
     { // ignore features indicated by visitation
         IndexEnvironment indexEnv;
@@ -786,7 +806,7 @@ RankSetupTest::testFeatureDump()
         EXPECT_TRUE(dumper.setup());
         RankResult exp;
         exp.addScore("test_cfgvalue(foo)", 1.0);
-        EXPECT_EQUAL(exp, dumper.dump());
+        EXPECT_EQ(exp, dumper.dump());
     }
     { // Dump secondPhase feature
         IndexEnvironment indexEnv;
@@ -799,7 +819,7 @@ RankSetupTest::testFeatureDump()
         EXPECT_TRUE(dumper.setup());
         RankResult exp;
         exp.addScore("secondPhase", 4.0);
-        EXPECT_EQUAL(exp, dumper.dump());
+        EXPECT_EQ(exp, dumper.dump());
     }
 }
 
@@ -807,22 +827,19 @@ void
 RankSetupTest::checkFeatures(std::map<vespalib::string, feature_t> &exp, std::map<vespalib::string, feature_t> &actual)
 {
     using ITR = std::map<vespalib::string, feature_t>::const_iterator;
-    if (!EXPECT_EQUAL(exp.size(), actual.size())) {
-        return;
-    }
+    ASSERT_EQ(exp.size(), actual.size());
     ITR exp_itr    = exp.begin();
     ITR exp_end    = exp.end();
     ITR actual_itr = actual.begin();
     ITR actual_end = actual.end();
     for (; exp_itr != exp_end && actual_itr != actual_end; ++exp_itr, ++actual_itr) {
-        EXPECT_EQUAL(exp_itr->first, actual_itr->first);
-        EXPECT_APPROX(exp_itr->second, actual_itr->second, 0.001);
+        EXPECT_EQ(exp_itr->first, actual_itr->first);
+        EXPECT_NEAR(exp_itr->second, actual_itr->second, 0.001);
     }
-    EXPECT_EQUAL(exp_itr == exp_end, actual_itr == actual_end);
+    EXPECT_EQ(exp_itr == exp_end, actual_itr == actual_end);
 }
 
-void
-RankSetupTest::testFeatureNormalization()
+TEST_F(RankSetupTest, feature_normalization)
 {
     BlueprintFactory factory;
     factory.addPrototype(Blueprint::SP(new ValueBlueprint()));
@@ -855,35 +872,39 @@ RankSetupTest::testFeatureNormalization()
         match_program->setup(*match_data, queryEnv);
         summaryProgram->setup(*match_data, queryEnv);
 
-        EXPECT_APPROX(2.0, Utils::getScoreFeature(*firstPhaseProgram, 1), 0.001);
-        EXPECT_APPROX(4.0, Utils::getScoreFeature(*secondPhaseProgram, 1), 0.001);
+        EXPECT_NEAR(2.0, Utils::getScoreFeature(*firstPhaseProgram, 1), 0.001);
+        EXPECT_NEAR(4.0, Utils::getScoreFeature(*secondPhaseProgram, 1), 0.001);
 
-        { // rank seed features
+        {
+            SCOPED_TRACE("rank seed features");
             std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*summaryProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["mysum(value(5),value(5))"] = 10.0;
             exp["mysum(\"value( 5 )\",\"value( 5 )\")"] = 10.0;
-            TEST_DO(checkFeatures(exp, actual));
+            checkFeatures(exp, actual);
         }
-        { // all rank features (1. phase)
+        {
+            SCOPED_TRACE("all rank features (1. phase)");
             std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*firstPhaseProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["value(1)"] = 1.0;
             exp["value(1).0"] = 1.0;
             exp["mysum(value(1),value(1))"] = 2.0;
             exp["mysum(value(1),value(1)).out"] = 2.0;
-            TEST_DO(checkFeatures(exp, actual));
+            checkFeatures(exp, actual);
         }
-        { // all rank features (2. phase)
+        {
+            SCOPED_TRACE("all rank features (2. phase)");
             std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*secondPhaseProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["value(2)"] = 2.0;
             exp["value(2).0"] = 2.0;
             exp["mysum(value(2),value(2))"] = 4.0;
             exp["mysum(value(2),value(2)).out"] = 4.0;
-            TEST_DO(checkFeatures(exp, actual));
+            checkFeatures(exp, actual);
         }
-        { // all match features
+        {
+            SCOPED_TRACE("all match features");
             std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*match_program, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["value(3)"] = 3.0;
@@ -892,9 +913,10 @@ RankSetupTest::testFeatureNormalization()
             exp["mysum(value(3),value(3)).out"] = 6.0;
             exp["mysum(\"value( 3 )\",\"value( 3 )\")"] = 6.0;
             exp["mysum(\"value( 3 )\",\"value( 3 )\").out"] = 6.0;
-            TEST_DO(checkFeatures(exp, actual));
+            checkFeatures(exp, actual);
         }
-        { // all rank features (summary)
+        {
+            SCOPED_TRACE("all rank features (summary)");
             std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*summaryProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["value(5)"] = 5.0;
@@ -903,7 +925,7 @@ RankSetupTest::testFeatureNormalization()
             exp["mysum(value(5),value(5)).out"] = 10.0;
             exp["mysum(\"value( 5 )\",\"value( 5 )\")"] = 10.0;
             exp["mysum(\"value( 5 )\",\"value( 5 )\").out"] = 10.0;
-            TEST_DO(checkFeatures(exp, actual));
+            checkFeatures(exp, actual);
         }
     }
 
@@ -914,15 +936,17 @@ RankSetupTest::testFeatureNormalization()
         RankProgram::UP rankProgram = rankSetup.create_dump_program();
         rankProgram->setup(*match_data, queryEnv);
 
-        { // dump seed features
+        {
+            SCOPED_TRACE("dump seed features");
             std::map<vespalib::string, feature_t> actual = Utils::getSeedFeatures(*rankProgram, 1);
             std::map<vespalib::string, feature_t> exp;
             exp["mysum(value(10),value(10))"] = 20.0;
             exp["mysum(\"value( 10 )\",\"value( 10 )\")"] = 20.0;
-            TEST_DO(checkFeatures(exp, actual));
+            checkFeatures(exp, actual);
         }
 
-        { // all dump features
+        {
+            SCOPED_TRACE("all dump features");
             std::map<vespalib::string, feature_t> actual = Utils::getAllFeatures(*rankProgram, 1);
             std::map<vespalib::string, feature_t> exp;
 
@@ -935,72 +959,9 @@ RankSetupTest::testFeatureNormalization()
             exp["mysum(\"value( 10 )\",\"value( 10 )\")"] = 20.0;
             exp["mysum(\"value( 10 )\",\"value( 10 )\").out"] = 20.0;
 
-            TEST_DO(checkFeatures(exp, actual));
+            checkFeatures(exp, actual);
         }
     }
 }
 
-
-RankSetupTest::RankSetupTest() :
-    _factory(),
-    _manager(),
-    _indexEnv(),
-    _queryEnv(),
-    _rankEnv(_factory, _indexEnv, _queryEnv),
-    _visitor()
-{
-    // register blueprints
-    setup_fef_test_plugin(_factory);
-    _factory.addPrototype(Blueprint::SP(new ValueBlueprint()));
-    _factory.addPrototype(Blueprint::SP(new RankingExpressionBlueprint()));
-    _factory.addPrototype(std::make_shared<SecondPhaseBlueprint>());
-
-    // setup an original attribute manager with two attributes
-    search::attribute::Config cfg(search::attribute::BasicType::INT32,
-                                        search::attribute::CollectionType::SINGLE);
-    search::AttributeVector::SP av1 =
-        search::AttributeFactory::createAttribute("staticrank1", cfg);
-    search::AttributeVector::SP av2 =
-        search::AttributeFactory::createAttribute("staticrank2", cfg);
-    av1->addDocs(5);
-    av2->addDocs(5);
-    for (uint32_t i = 0; i < 5; ++i) {
-        (static_cast<search::IntegerAttribute *>(av1.get()))->update(i, i + 100);
-        (static_cast<search::IntegerAttribute *>(av2.get()))->update(i, i + 200);
-    }
-    av1->commit();
-    av2->commit();
-    _manager.add(av1);
-    _manager.add(av2);
-
-    // set the index environment
-    _queryEnv.setIndexEnv(&_indexEnv);
-
-    // set the manager
-    _queryEnv.overrideAttributeManager(&_manager);
-}
-
-RankSetupTest::~RankSetupTest() {}
-
-int
-RankSetupTest::Main()
-{
-    TEST_INIT("ranksetup_test");
-
-    testValueBlueprint();
-    testDoubleBlueprint();
-    testSumBlueprint();
-    testStaticRankBlueprint();
-    testChainBlueprint();
-    testCfgValueBlueprint();
-
-    testCompilation();
-    testRankSetup();
-    testExecution();
-    testFeatureDump();
-    testFeatureNormalization();
-
-    TEST_DONE();
-}
-
-TEST_APPHOOK(RankSetupTest);
+GTEST_MAIN_RUN_ALL_TESTS()