diff options
Diffstat (limited to 'searchlib/src/tests')
-rw-r--r-- | searchlib/src/tests/ranksetup/CMakeLists.txt | 1 | ||||
-rw-r--r-- | searchlib/src/tests/ranksetup/ranksetup_test.cpp | 367 |
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() |