Rewrite search::fef::Properties unit test to gtest.

2 files changed, 271 insertions, 269 deletions

diff --git a/searchlib/src/tests/fef/properties/CMakeLists.txt b/searchlib/src/tests/fef/properties/CMakeLists.txt
index dd1eb83b0c2..d0abf5bd377 100644
--- a/searchlib/src/tests/fef/properties/CMakeLists.txt
+++ b/searchlib/src/tests/fef/properties/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(searchlib_properties_test_app TEST
     properties_test.cpp
     DEPENDS
     searchlib
+    GTest::gtest
 )
 vespa_add_test(NAME searchlib_properties_test_app COMMAND searchlib_properties_test_app)
diff --git a/searchlib/src/tests/fef/properties/properties_test.cpp b/searchlib/src/tests/fef/properties/properties_test.cpp
index c8073739b3e..d3890c8f9fc 100644
--- a/searchlib/src/tests/fef/properties/properties_test.cpp
+++ b/searchlib/src/tests/fef/properties/properties_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/fef/indexproperties.h>
 #include <vespa/searchlib/fef/properties.h>
+#include <vespa/vespalib/gtest/gtest.h>
 #include <limits>
 
 using namespace search::fef;
@@ -30,7 +30,8 @@ Properties make_props(std::initializer_list<std::pair<const char *, std::initial
     return props;
 }
 
-TEST("require that namespace visitation works") {
+TEST(PropertiesTest, require_that_namespace_visitation_works)
+{
     Properties props = make_props({    {"foo",   {"outside"}},
                                        {"foo.a", {"a_value"}},
                                        {"foo.b", {"b_value"}},
@@ -39,20 +40,21 @@ TEST("require that namespace visitation works") {
     Properties result;
     CopyVisitor copy_visitor(result);
     props.visitNamespace("foo", copy_visitor);
-    EXPECT_EQUAL(2u, result.numKeys());
-    EXPECT_EQUAL(result.lookup("a").get(), Property::Value("a_value"));
-    EXPECT_EQUAL(result.lookup("b").get(), Property::Value("b_value"));
+    EXPECT_EQ(2u, result.numKeys());
+    EXPECT_EQ(result.lookup("a").get(), Property::Value("a_value"));
+    EXPECT_EQ(result.lookup("b").get(), Property::Value("b_value"));
 }
 
-TEST("test stuff") {
+TEST(PropertiesTest, test_stuff)
+{
     { // empty lookup result
         Property p;
 
-        EXPECT_EQUAL(p.found(), false);
-        EXPECT_EQUAL(p.get(), Property::Value(""));
-        EXPECT_EQUAL(p.get("fb"), Property::Value("fb"));
-        EXPECT_EQUAL(p.size(), 0u);
-        EXPECT_EQUAL(p.getAt(0), Property::Value(""));
+        EXPECT_EQ(p.found(), false);
+        EXPECT_EQ(p.get(), Property::Value(""));
+        EXPECT_EQ(p.get("fb"), Property::Value("fb"));
+        EXPECT_EQ(p.size(), 0u);
+        EXPECT_EQ(p.getAt(0), Property::Value(""));
     }
     { // add / count / remove
         Properties p = make_props({    {"a", {"a1", "a2", "a3"}},
@@ -61,48 +63,48 @@ TEST("test stuff") {
                                    });
         const Properties &pc = p;
 
-        EXPECT_EQUAL(pc.numKeys(), 3u);
-        EXPECT_EQUAL(pc.numValues(), 6u);
-        EXPECT_EQUAL(pc.count("a"), 3u);
-        EXPECT_EQUAL(pc.count("b"), 2u);
-        EXPECT_EQUAL(pc.count("c"), 1u);
-        EXPECT_EQUAL(pc.count("d"), 0u);
+        EXPECT_EQ(pc.numKeys(), 3u);
+        EXPECT_EQ(pc.numValues(), 6u);
+        EXPECT_EQ(pc.count("a"), 3u);
+        EXPECT_EQ(pc.count("b"), 2u);
+        EXPECT_EQ(pc.count("c"), 1u);
+        EXPECT_EQ(pc.count("d"), 0u);
 
         p.remove("d");
 
-        EXPECT_EQUAL(pc.numKeys(), 3u);
-        EXPECT_EQUAL(pc.numValues(), 6u);
-        EXPECT_EQUAL(pc.count("a"), 3u);
-        EXPECT_EQUAL(pc.count("b"), 2u);
-        EXPECT_EQUAL(pc.count("c"), 1u);
-        EXPECT_EQUAL(pc.count("d"), 0u);
+        EXPECT_EQ(pc.numKeys(), 3u);
+        EXPECT_EQ(pc.numValues(), 6u);
+        EXPECT_EQ(pc.count("a"), 3u);
+        EXPECT_EQ(pc.count("b"), 2u);
+        EXPECT_EQ(pc.count("c"), 1u);
+        EXPECT_EQ(pc.count("d"), 0u);
 
         p.remove("c");
 
-        EXPECT_EQUAL(pc.numKeys(), 2u);
-        EXPECT_EQUAL(pc.numValues(), 5u);
-        EXPECT_EQUAL(pc.count("a"), 3u);
-        EXPECT_EQUAL(pc.count("b"), 2u);
-        EXPECT_EQUAL(pc.count("c"), 0u);
-        EXPECT_EQUAL(pc.count("d"), 0u);
+        EXPECT_EQ(pc.numKeys(), 2u);
+        EXPECT_EQ(pc.numValues(), 5u);
+        EXPECT_EQ(pc.count("a"), 3u);
+        EXPECT_EQ(pc.count("b"), 2u);
+        EXPECT_EQ(pc.count("c"), 0u);
+        EXPECT_EQ(pc.count("d"), 0u);
 
         p.remove("b");
 
-        EXPECT_EQUAL(pc.numKeys(), 1u);
-        EXPECT_EQUAL(pc.numValues(), 3u);
-        EXPECT_EQUAL(pc.count("a"), 3u);
-        EXPECT_EQUAL(pc.count("b"), 0u);
-        EXPECT_EQUAL(pc.count("c"), 0u);
-        EXPECT_EQUAL(pc.count("d"), 0u);
+        EXPECT_EQ(pc.numKeys(), 1u);
+        EXPECT_EQ(pc.numValues(), 3u);
+        EXPECT_EQ(pc.count("a"), 3u);
+        EXPECT_EQ(pc.count("b"), 0u);
+        EXPECT_EQ(pc.count("c"), 0u);
+        EXPECT_EQ(pc.count("d"), 0u);
 
         p.remove("a");
 
-        EXPECT_EQUAL(pc.numKeys(), 0u);
-        EXPECT_EQUAL(pc.numValues(), 0u);
-        EXPECT_EQUAL(pc.count("a"), 0u);
-        EXPECT_EQUAL(pc.count("b"), 0u);
-        EXPECT_EQUAL(pc.count("c"), 0u);
-        EXPECT_EQUAL(pc.count("d"), 0u);
+        EXPECT_EQ(pc.numKeys(), 0u);
+        EXPECT_EQ(pc.numValues(), 0u);
+        EXPECT_EQ(pc.count("a"), 0u);
+        EXPECT_EQ(pc.count("b"), 0u);
+        EXPECT_EQ(pc.count("c"), 0u);
+        EXPECT_EQ(pc.count("d"), 0u);
     }
     { // lookup / import / visit / compare / hash
         Properties p;
@@ -114,38 +116,38 @@ TEST("test stuff") {
 
         p.add("list", "e1").add("list", "e2").add("list", "e3");
 
-        EXPECT_EQUAL(p.numKeys(), 5u);
-        EXPECT_EQUAL(p.numValues(), 7u);
-
-        EXPECT_EQUAL(p.lookup("x").found(),       true);
-        EXPECT_EQUAL(p.lookup("a.x").found(),     true);
-        EXPECT_EQUAL(p.lookup("a.b.x").found(),   true);
-        EXPECT_EQUAL(p.lookup("a.b.c.x").found(), true);
-        EXPECT_EQUAL(p.lookup("list").found(),    true);
-        EXPECT_EQUAL(p.lookup("y").found(),       false);
-
-        EXPECT_EQUAL(p.lookup("x").get(),       Property::Value("x1"));
-        EXPECT_EQUAL(p.lookup("a.x").get(),     Property::Value("x2"));
-        EXPECT_EQUAL(p.lookup("a.b.x").get(),   Property::Value("x3"));
-        EXPECT_EQUAL(p.lookup("a.b.c.x").get(), Property::Value("x4"));
-        EXPECT_EQUAL(p.lookup("list").get(),    Property::Value("e1"));
-        EXPECT_EQUAL(p.lookup("y").get(),       Property::Value(""));
-
-        EXPECT_EQUAL(p.lookup("x").get(),                Property::Value("x1"));
-        EXPECT_EQUAL(p.lookup("a", "x").get(),           Property::Value("x2"));
-        EXPECT_EQUAL(p.lookup("a", "b", "x").get(),      Property::Value("x3"));
-        EXPECT_EQUAL(p.lookup("a", "b", "c", "x").get(), Property::Value("x4"));
-
-        EXPECT_EQUAL(p.lookup("x").get("fallback"), Property::Value("x1"));
-        EXPECT_EQUAL(p.lookup("y").get("fallback"), Property::Value("fallback"));
-
-        EXPECT_EQUAL(p.lookup("y").size(), 0u);
-        EXPECT_EQUAL(p.lookup("x").size(), 1u);
-        EXPECT_EQUAL(p.lookup("list").size(), 3u);
-        EXPECT_EQUAL(p.lookup("list").getAt(0), Property::Value("e1"));
-        EXPECT_EQUAL(p.lookup("list").getAt(1), Property::Value("e2"));
-        EXPECT_EQUAL(p.lookup("list").getAt(2), Property::Value("e3"));
-        EXPECT_EQUAL(p.lookup("list").getAt(3), Property::Value(""));
+        EXPECT_EQ(p.numKeys(), 5u);
+        EXPECT_EQ(p.numValues(), 7u);
+
+        EXPECT_EQ(p.lookup("x").found(),       true);
+        EXPECT_EQ(p.lookup("a.x").found(),     true);
+        EXPECT_EQ(p.lookup("a.b.x").found(),   true);
+        EXPECT_EQ(p.lookup("a.b.c.x").found(), true);
+        EXPECT_EQ(p.lookup("list").found(),    true);
+        EXPECT_EQ(p.lookup("y").found(),       false);
+
+        EXPECT_EQ(p.lookup("x").get(),       Property::Value("x1"));
+        EXPECT_EQ(p.lookup("a.x").get(),     Property::Value("x2"));
+        EXPECT_EQ(p.lookup("a.b.x").get(),   Property::Value("x3"));
+        EXPECT_EQ(p.lookup("a.b.c.x").get(), Property::Value("x4"));
+        EXPECT_EQ(p.lookup("list").get(),    Property::Value("e1"));
+        EXPECT_EQ(p.lookup("y").get(),       Property::Value(""));
+
+        EXPECT_EQ(p.lookup("x").get(),                Property::Value("x1"));
+        EXPECT_EQ(p.lookup("a", "x").get(),           Property::Value("x2"));
+        EXPECT_EQ(p.lookup("a", "b", "x").get(),      Property::Value("x3"));
+        EXPECT_EQ(p.lookup("a", "b", "c", "x").get(), Property::Value("x4"));
+
+        EXPECT_EQ(p.lookup("x").get("fallback"), Property::Value("x1"));
+        EXPECT_EQ(p.lookup("y").get("fallback"), Property::Value("fallback"));
+
+        EXPECT_EQ(p.lookup("y").size(), 0u);
+        EXPECT_EQ(p.lookup("x").size(), 1u);
+        EXPECT_EQ(p.lookup("list").size(), 3u);
+        EXPECT_EQ(p.lookup("list").getAt(0), Property::Value("e1"));
+        EXPECT_EQ(p.lookup("list").getAt(1), Property::Value("e2"));
+        EXPECT_EQ(p.lookup("list").getAt(2), Property::Value("e3"));
+        EXPECT_EQ(p.lookup("list").getAt(3), Property::Value(""));
 
         Properties p2;
 
@@ -153,29 +155,29 @@ TEST("test stuff") {
         p2.add("y", "y1");
         p2.add("list", "foo").add("list", "bar");
 
-        EXPECT_EQUAL(p2.numKeys(), 3u);
-        EXPECT_EQUAL(p2.numValues(), 4u);
+        EXPECT_EQ(p2.numKeys(), 3u);
+        EXPECT_EQ(p2.numValues(), 4u);
 
         p.import(p2);
 
-        EXPECT_EQUAL(p.numKeys(), 6u);
-        EXPECT_EQUAL(p.numValues(), 7u);
+        EXPECT_EQ(p.numKeys(), 6u);
+        EXPECT_EQ(p.numValues(), 7u);
 
-        EXPECT_EQUAL(p.lookup("y").size(), 1u);
-        EXPECT_EQUAL(p.lookup("y").get(), Property::Value("y1"));
+        EXPECT_EQ(p.lookup("y").size(), 1u);
+        EXPECT_EQ(p.lookup("y").get(), Property::Value("y1"));
 
-        EXPECT_EQUAL(p.lookup("x").size(), 1u);
-        EXPECT_EQUAL(p.lookup("x").get(), Property::Value("new_x"));
+        EXPECT_EQ(p.lookup("x").size(), 1u);
+        EXPECT_EQ(p.lookup("x").get(), Property::Value("new_x"));
 
-        EXPECT_EQUAL(p.lookup("z").size(), 0u);
+        EXPECT_EQ(p.lookup("z").size(), 0u);
 
-        EXPECT_EQUAL(p.lookup("a", "x").size(), 1u);
-        EXPECT_EQUAL(p.lookup("a", "x").get(), Property::Value("x2"));
+        EXPECT_EQ(p.lookup("a", "x").size(), 1u);
+        EXPECT_EQ(p.lookup("a", "x").get(), Property::Value("x2"));
 
-        EXPECT_EQUAL(p.lookup("list").size(), 2u);
-        EXPECT_EQUAL(p.lookup("list").getAt(0), Property::Value("foo"));
-        EXPECT_EQUAL(p.lookup("list").getAt(1), Property::Value("bar"));
-        EXPECT_EQUAL(p.lookup("list").getAt(2), Property::Value(""));
+        EXPECT_EQ(p.lookup("list").size(), 2u);
+        EXPECT_EQ(p.lookup("list").getAt(0), Property::Value("foo"));
+        EXPECT_EQ(p.lookup("list").getAt(1), Property::Value("bar"));
+        EXPECT_EQ(p.lookup("list").getAt(2), Property::Value(""));
 
         Properties p3;
 
@@ -189,32 +191,32 @@ TEST("test stuff") {
         CopyVisitor cv(p3);
         p.visitProperties(cv);
 
-        EXPECT_EQUAL(p3.numKeys(), 6u);
-        EXPECT_EQUAL(p3.numValues(), 7u);
+        EXPECT_EQ(p3.numKeys(), 6u);
+        EXPECT_EQ(p3.numValues(), 7u);
 
         EXPECT_TRUE(p == p3);
         EXPECT_TRUE(p3 == p);
-        EXPECT_EQUAL(p.hashCode(), p3.hashCode());
+        EXPECT_EQ(p.hashCode(), p3.hashCode());
 
         p.clear();
-        EXPECT_EQUAL(p.numKeys(), 0u);
-        EXPECT_EQUAL(p.numValues(), 0u);
+        EXPECT_EQ(p.numKeys(), 0u);
+        EXPECT_EQ(p.numValues(), 0u);
         EXPECT_TRUE(!(p == p3));
         EXPECT_TRUE(!(p3 == p));
 
         Properties p4;
         CopyVisitor cv2(p4);
         p.visitProperties(cv);
-        EXPECT_EQUAL(p4.numKeys(), 0u);
-        EXPECT_EQUAL(p4.numValues(), 0u);
+        EXPECT_EQ(p4.numKeys(), 0u);
+        EXPECT_EQ(p4.numValues(), 0u);
         EXPECT_TRUE(p == p4);
         EXPECT_TRUE(p4 == p);
-        EXPECT_EQUAL(p.hashCode(), p4.hashCode());
+        EXPECT_EQ(p.hashCode(), p4.hashCode());
     }
 
     { // test index properties known by the framework
         { // vespa.eval.lazy_expressions
-            EXPECT_EQUAL(eval::LazyExpressions::NAME, vespalib::string("vespa.eval.lazy_expressions"));
+            EXPECT_EQ(eval::LazyExpressions::NAME, vespalib::string("vespa.eval.lazy_expressions"));
             {
                 Properties p;
                 EXPECT_TRUE(eval::LazyExpressions::check(p, true));
@@ -234,201 +236,201 @@ TEST("test stuff") {
             }
         }
         { // vespa.eval.use_fast_forest
-            EXPECT_EQUAL(eval::UseFastForest::NAME, vespalib::string("vespa.eval.use_fast_forest"));
-            EXPECT_EQUAL(eval::UseFastForest::DEFAULT_VALUE, false);
+            EXPECT_EQ(eval::UseFastForest::NAME, vespalib::string("vespa.eval.use_fast_forest"));
+            EXPECT_EQ(eval::UseFastForest::DEFAULT_VALUE, false);
             Properties p;
-            EXPECT_EQUAL(eval::UseFastForest::check(p), false);
+            EXPECT_EQ(eval::UseFastForest::check(p), false);
             p.add("vespa.eval.use_fast_forest", "true");
-            EXPECT_EQUAL(eval::UseFastForest::check(p), true);
+            EXPECT_EQ(eval::UseFastForest::check(p), true);
         }
         { // vespa.rank.firstphase
-            EXPECT_EQUAL(rank::FirstPhase::NAME, vespalib::string("vespa.rank.firstphase"));
-            EXPECT_EQUAL(rank::FirstPhase::DEFAULT_VALUE, vespalib::string("nativeRank"));
+            EXPECT_EQ(rank::FirstPhase::NAME, vespalib::string("vespa.rank.firstphase"));
+            EXPECT_EQ(rank::FirstPhase::DEFAULT_VALUE, vespalib::string("nativeRank"));
             Properties p;
-            EXPECT_EQUAL(rank::FirstPhase::lookup(p), vespalib::string("nativeRank"));
+            EXPECT_EQ(rank::FirstPhase::lookup(p), vespalib::string("nativeRank"));
             p.add("vespa.rank.firstphase", "specialrank");
-            EXPECT_EQUAL(rank::FirstPhase::lookup(p), vespalib::string("specialrank"));
+            EXPECT_EQ(rank::FirstPhase::lookup(p), vespalib::string("specialrank"));
         }
         { // vespa.rank.secondphase
-            EXPECT_EQUAL(rank::SecondPhase::NAME, vespalib::string("vespa.rank.secondphase"));
-            EXPECT_EQUAL(rank::SecondPhase::DEFAULT_VALUE, vespalib::string(""));
+            EXPECT_EQ(rank::SecondPhase::NAME, vespalib::string("vespa.rank.secondphase"));
+            EXPECT_EQ(rank::SecondPhase::DEFAULT_VALUE, vespalib::string(""));
             Properties p;
-            EXPECT_EQUAL(rank::SecondPhase::lookup(p), vespalib::string(""));
+            EXPECT_EQ(rank::SecondPhase::lookup(p), vespalib::string(""));
             p.add("vespa.rank.secondphase", "specialrank");
-            EXPECT_EQUAL(rank::SecondPhase::lookup(p), vespalib::string("specialrank"));
+            EXPECT_EQ(rank::SecondPhase::lookup(p), vespalib::string("specialrank"));
         }
         { // vespa.dump.feature
-            EXPECT_EQUAL(dump::Feature::NAME, vespalib::string("vespa.dump.feature"));
-            EXPECT_EQUAL(dump::Feature::DEFAULT_VALUE.size(), 0u);
+            EXPECT_EQ(dump::Feature::NAME, vespalib::string("vespa.dump.feature"));
+            EXPECT_EQ(dump::Feature::DEFAULT_VALUE.size(), 0u);
             Properties p;
-            EXPECT_EQUAL(dump::Feature::lookup(p).size(), 0u);
+            EXPECT_EQ(dump::Feature::lookup(p).size(), 0u);
             p.add("vespa.dump.feature", "foo");
             p.add("vespa.dump.feature", "bar");
             std::vector<vespalib::string> a = dump::Feature::lookup(p);
             ASSERT_TRUE(a.size() == 2);
-            EXPECT_EQUAL(a[0], vespalib::string("foo"));
-            EXPECT_EQUAL(a[1], vespalib::string("bar"));
+            EXPECT_EQ(a[0], vespalib::string("foo"));
+            EXPECT_EQ(a[1], vespalib::string("bar"));
         }
         { // vespa.dump.ignoredefaultfeatures
-            EXPECT_EQUAL(dump::IgnoreDefaultFeatures::NAME, vespalib::string("vespa.dump.ignoredefaultfeatures"));
-            EXPECT_EQUAL(dump::IgnoreDefaultFeatures::DEFAULT_VALUE, "false");
+            EXPECT_EQ(dump::IgnoreDefaultFeatures::NAME, vespalib::string("vespa.dump.ignoredefaultfeatures"));
+            EXPECT_EQ(dump::IgnoreDefaultFeatures::DEFAULT_VALUE, "false");
             Properties p;
             EXPECT_TRUE(!dump::IgnoreDefaultFeatures::check(p));
             p.add("vespa.dump.ignoredefaultfeatures", "true");
             EXPECT_TRUE(dump::IgnoreDefaultFeatures::check(p));
         }
         { // vespa.matching.termwise_limit
-            EXPECT_EQUAL(matching::TermwiseLimit::NAME, vespalib::string("vespa.matching.termwise_limit"));
-            EXPECT_EQUAL(matching::TermwiseLimit::DEFAULT_VALUE, 1.0);
+            EXPECT_EQ(matching::TermwiseLimit::NAME, vespalib::string("vespa.matching.termwise_limit"));
+            EXPECT_EQ(matching::TermwiseLimit::DEFAULT_VALUE, 1.0);
             Properties p;
-            EXPECT_EQUAL(matching::TermwiseLimit::lookup(p), 1.0);
+            EXPECT_EQ(matching::TermwiseLimit::lookup(p), 1.0);
             p.add("vespa.matching.termwise_limit", "0.05");
-            EXPECT_EQUAL(matching::TermwiseLimit::lookup(p), 0.05);
+            EXPECT_EQ(matching::TermwiseLimit::lookup(p), 0.05);
         }
         { // vespa.matching.numthreads
-            EXPECT_EQUAL(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch"));
-            EXPECT_EQUAL(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max());
+            EXPECT_EQ(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch"));
+            EXPECT_EQ(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max());
             Properties p;
-            EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), std::numeric_limits<uint32_t>::max());
+            EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), std::numeric_limits<uint32_t>::max());
             p.add("vespa.matching.numthreadspersearch", "50");
-            EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u);
+            EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u);
         }
 
         { // vespa.matching.minhitsperthread
-            EXPECT_EQUAL(matching::MinHitsPerThread::NAME, vespalib::string("vespa.matching.minhitsperthread"));
-            EXPECT_EQUAL(matching::MinHitsPerThread::DEFAULT_VALUE, 0u);
+            EXPECT_EQ(matching::MinHitsPerThread::NAME, vespalib::string("vespa.matching.minhitsperthread"));
+            EXPECT_EQ(matching::MinHitsPerThread::DEFAULT_VALUE, 0u);
             Properties p;
-            EXPECT_EQUAL(matching::MinHitsPerThread::lookup(p), 0u);
+            EXPECT_EQ(matching::MinHitsPerThread::lookup(p), 0u);
             p.add("vespa.matching.minhitsperthread", "50");
-            EXPECT_EQUAL(matching::MinHitsPerThread::lookup(p), 50u);
+            EXPECT_EQ(matching::MinHitsPerThread::lookup(p), 50u);
         }
         {
-            EXPECT_EQUAL(matching::NumSearchPartitions::NAME, vespalib::string("vespa.matching.numsearchpartitions"));
-            EXPECT_EQUAL(matching::NumSearchPartitions::DEFAULT_VALUE, 1u);
+            EXPECT_EQ(matching::NumSearchPartitions::NAME, vespalib::string("vespa.matching.numsearchpartitions"));
+            EXPECT_EQ(matching::NumSearchPartitions::DEFAULT_VALUE, 1u);
             Properties p;
-            EXPECT_EQUAL(matching::NumSearchPartitions::lookup(p), 1u);
+            EXPECT_EQ(matching::NumSearchPartitions::lookup(p), 1u);
             p.add("vespa.matching.numsearchpartitions", "50");
-            EXPECT_EQUAL(matching::NumSearchPartitions::lookup(p), 50u);
+            EXPECT_EQ(matching::NumSearchPartitions::lookup(p), 50u);
         }
         { // vespa.matchphase.degradation.attribute
-            EXPECT_EQUAL(matchphase::DegradationAttribute::NAME, vespalib::string("vespa.matchphase.degradation.attribute"));
-            EXPECT_EQUAL(matchphase::DegradationAttribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(matchphase::DegradationAttribute::NAME, vespalib::string("vespa.matchphase.degradation.attribute"));
+            EXPECT_EQ(matchphase::DegradationAttribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(matchphase::DegradationAttribute::lookup(p), "");
+            EXPECT_EQ(matchphase::DegradationAttribute::lookup(p), "");
             p.add("vespa.matchphase.degradation.attribute", "foobar");
-            EXPECT_EQUAL(matchphase::DegradationAttribute::lookup(p), "foobar");
+            EXPECT_EQ(matchphase::DegradationAttribute::lookup(p), "foobar");
         }
         { // vespa.matchphase.degradation.ascending
-            EXPECT_EQUAL(matchphase::DegradationAscendingOrder::NAME, vespalib::string("vespa.matchphase.degradation.ascendingorder"));
-            EXPECT_EQUAL(matchphase::DegradationAscendingOrder::DEFAULT_VALUE, false);
+            EXPECT_EQ(matchphase::DegradationAscendingOrder::NAME, vespalib::string("vespa.matchphase.degradation.ascendingorder"));
+            EXPECT_EQ(matchphase::DegradationAscendingOrder::DEFAULT_VALUE, false);
             Properties p;
-            EXPECT_EQUAL(matchphase::DegradationAscendingOrder::lookup(p), false);
+            EXPECT_EQ(matchphase::DegradationAscendingOrder::lookup(p), false);
             p.add("vespa.matchphase.degradation.ascendingorder", "true");
-            EXPECT_EQUAL(matchphase::DegradationAscendingOrder::lookup(p), true);
+            EXPECT_EQ(matchphase::DegradationAscendingOrder::lookup(p), true);
         }
         { // vespa.matchphase.degradation.maxhits
-            EXPECT_EQUAL(matchphase::DegradationMaxHits::NAME, vespalib::string("vespa.matchphase.degradation.maxhits"));
-            EXPECT_EQUAL(matchphase::DegradationMaxHits::DEFAULT_VALUE, 0u);
+            EXPECT_EQ(matchphase::DegradationMaxHits::NAME, vespalib::string("vespa.matchphase.degradation.maxhits"));
+            EXPECT_EQ(matchphase::DegradationMaxHits::DEFAULT_VALUE, 0u);
             Properties p;
-            EXPECT_EQUAL(matchphase::DegradationMaxHits::lookup(p), 0u);
+            EXPECT_EQ(matchphase::DegradationMaxHits::lookup(p), 0u);
             p.add("vespa.matchphase.degradation.maxhits", "123789");
-            EXPECT_EQUAL(matchphase::DegradationMaxHits::lookup(p), 123789u);
+            EXPECT_EQ(matchphase::DegradationMaxHits::lookup(p), 123789u);
         }
         { // vespa.matchphase.degradation.samplepercentage
-            EXPECT_EQUAL(matchphase::DegradationSamplePercentage::NAME, vespalib::string("vespa.matchphase.degradation.samplepercentage"));
-            EXPECT_EQUAL(matchphase::DegradationSamplePercentage::DEFAULT_VALUE, 0.2);
+            EXPECT_EQ(matchphase::DegradationSamplePercentage::NAME, vespalib::string("vespa.matchphase.degradation.samplepercentage"));
+            EXPECT_EQ(matchphase::DegradationSamplePercentage::DEFAULT_VALUE, 0.2);
             Properties p;
-            EXPECT_EQUAL(matchphase::DegradationSamplePercentage::lookup(p), 0.2);
+            EXPECT_EQ(matchphase::DegradationSamplePercentage::lookup(p), 0.2);
             p.add("vespa.matchphase.degradation.samplepercentage", "0.9");
-            EXPECT_EQUAL(matchphase::DegradationSamplePercentage::lookup(p), 0.9);
+            EXPECT_EQ(matchphase::DegradationSamplePercentage::lookup(p), 0.9);
         }
         { // vespa.matchphase.degradation.maxfiltercoverage
-            EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::NAME, vespalib::string("vespa.matchphase.degradation.maxfiltercoverage"));
-            EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::DEFAULT_VALUE, 0.2);
+            EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::NAME, vespalib::string("vespa.matchphase.degradation.maxfiltercoverage"));
+            EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::DEFAULT_VALUE, 0.2);
             Properties p;
-            EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.2);
+            EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.2);
             p.add("vespa.matchphase.degradation.maxfiltercoverage", "0.076");
-            EXPECT_EQUAL(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.076);
+            EXPECT_EQ(matchphase::DegradationMaxFilterCoverage::lookup(p), 0.076);
         }
         { // vespa.matchphase.degradation.postfiltermultiplier
-            EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::NAME, vespalib::string("vespa.matchphase.degradation.postfiltermultiplier"));
-            EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::DEFAULT_VALUE, 1.0);
+            EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::NAME, vespalib::string("vespa.matchphase.degradation.postfiltermultiplier"));
+            EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::DEFAULT_VALUE, 1.0);
             Properties p;
-            EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::lookup(p), 1.0);
+            EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::lookup(p), 1.0);
             p.add("vespa.matchphase.degradation.postfiltermultiplier", "0.9");
-            EXPECT_EQUAL(matchphase::DegradationPostFilterMultiplier::lookup(p), 0.9);
+            EXPECT_EQ(matchphase::DegradationPostFilterMultiplier::lookup(p), 0.9);
         }
         { // vespa.matchphase.diversity.attribute
-            EXPECT_EQUAL(matchphase::DiversityAttribute::NAME, vespalib::string("vespa.matchphase.diversity.attribute"));
-            EXPECT_EQUAL(matchphase::DiversityAttribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(matchphase::DiversityAttribute::NAME, vespalib::string("vespa.matchphase.diversity.attribute"));
+            EXPECT_EQ(matchphase::DiversityAttribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(matchphase::DiversityAttribute::lookup(p), "");
+            EXPECT_EQ(matchphase::DiversityAttribute::lookup(p), "");
             p.add("vespa.matchphase.diversity.attribute", "foobar");
-            EXPECT_EQUAL(matchphase::DiversityAttribute::lookup(p), "foobar");
+            EXPECT_EQ(matchphase::DiversityAttribute::lookup(p), "foobar");
         }
         { // vespa.matchphase.diversity.mingroups
-            EXPECT_EQUAL(matchphase::DiversityMinGroups::NAME, vespalib::string("vespa.matchphase.diversity.mingroups"));
-            EXPECT_EQUAL(matchphase::DiversityMinGroups::DEFAULT_VALUE, 1u);
+            EXPECT_EQ(matchphase::DiversityMinGroups::NAME, vespalib::string("vespa.matchphase.diversity.mingroups"));
+            EXPECT_EQ(matchphase::DiversityMinGroups::DEFAULT_VALUE, 1u);
             Properties p;
-            EXPECT_EQUAL(matchphase::DiversityMinGroups::lookup(p), 1u);
+            EXPECT_EQ(matchphase::DiversityMinGroups::lookup(p), 1u);
             p.add("vespa.matchphase.diversity.mingroups", "5");
-            EXPECT_EQUAL(matchphase::DiversityMinGroups::lookup(p), 5u);
+            EXPECT_EQ(matchphase::DiversityMinGroups::lookup(p), 5u);
         }
         { // vespa.hitcollector.heapsize
-            EXPECT_EQUAL(hitcollector::HeapSize::NAME, vespalib::string("vespa.hitcollector.heapsize"));
-            EXPECT_EQUAL(hitcollector::HeapSize::DEFAULT_VALUE, 100u);
+            EXPECT_EQ(hitcollector::HeapSize::NAME, vespalib::string("vespa.hitcollector.heapsize"));
+            EXPECT_EQ(hitcollector::HeapSize::DEFAULT_VALUE, 100u);
             Properties p;
-            EXPECT_EQUAL(hitcollector::HeapSize::lookup(p), 100u);
+            EXPECT_EQ(hitcollector::HeapSize::lookup(p), 100u);
             p.add("vespa.hitcollector.heapsize", "50");
-            EXPECT_EQUAL(hitcollector::HeapSize::lookup(p), 50u);
+            EXPECT_EQ(hitcollector::HeapSize::lookup(p), 50u);
         }
         { // vespa.hitcollector.arraysize
-            EXPECT_EQUAL(hitcollector::ArraySize::NAME, vespalib::string("vespa.hitcollector.arraysize"));
-            EXPECT_EQUAL(hitcollector::ArraySize::DEFAULT_VALUE, 10000u);
+            EXPECT_EQ(hitcollector::ArraySize::NAME, vespalib::string("vespa.hitcollector.arraysize"));
+            EXPECT_EQ(hitcollector::ArraySize::DEFAULT_VALUE, 10000u);
             Properties p;
-            EXPECT_EQUAL(hitcollector::ArraySize::lookup(p), 10000u);
+            EXPECT_EQ(hitcollector::ArraySize::lookup(p), 10000u);
             p.add("vespa.hitcollector.arraysize", "50");
-            EXPECT_EQUAL(hitcollector::ArraySize::lookup(p), 50u);
+            EXPECT_EQ(hitcollector::ArraySize::lookup(p), 50u);
         }
         { // vespa.hitcollector.estimatepoint
-            EXPECT_EQUAL(hitcollector::EstimatePoint::NAME, vespalib::string("vespa.hitcollector.estimatepoint"));
-            EXPECT_EQUAL(hitcollector::EstimatePoint::DEFAULT_VALUE, 0xffffffffu);
+            EXPECT_EQ(hitcollector::EstimatePoint::NAME, vespalib::string("vespa.hitcollector.estimatepoint"));
+            EXPECT_EQ(hitcollector::EstimatePoint::DEFAULT_VALUE, 0xffffffffu);
             Properties p;
-            EXPECT_EQUAL(hitcollector::EstimatePoint::lookup(p), 0xffffffffu);
+            EXPECT_EQ(hitcollector::EstimatePoint::lookup(p), 0xffffffffu);
             p.add("vespa.hitcollector.estimatepoint", "50");
-            EXPECT_EQUAL(hitcollector::EstimatePoint::lookup(p), 50u);
+            EXPECT_EQ(hitcollector::EstimatePoint::lookup(p), 50u);
         }
         { // vespa.hitcollector.estimatelimit
-            EXPECT_EQUAL(hitcollector::EstimateLimit::NAME, vespalib::string("vespa.hitcollector.estimatelimit"));
-            EXPECT_EQUAL(hitcollector::EstimateLimit::DEFAULT_VALUE, 0xffffffffu);
+            EXPECT_EQ(hitcollector::EstimateLimit::NAME, vespalib::string("vespa.hitcollector.estimatelimit"));
+            EXPECT_EQ(hitcollector::EstimateLimit::DEFAULT_VALUE, 0xffffffffu);
             Properties p;
-            EXPECT_EQUAL(hitcollector::EstimateLimit::lookup(p), 0xffffffffu);
+            EXPECT_EQ(hitcollector::EstimateLimit::lookup(p), 0xffffffffu);
             p.add("vespa.hitcollector.estimatelimit", "50");
-            EXPECT_EQUAL(hitcollector::EstimateLimit::lookup(p), 50u);
+            EXPECT_EQ(hitcollector::EstimateLimit::lookup(p), 50u);
         }
         { // vespa.hitcollector.rankscoredroplimit
-            EXPECT_EQUAL(hitcollector::RankScoreDropLimit::NAME, vespalib::string("vespa.hitcollector.rankscoredroplimit"));
+            EXPECT_EQ(hitcollector::RankScoreDropLimit::NAME, vespalib::string("vespa.hitcollector.rankscoredroplimit"));
             search::feature_t got1 = hitcollector::RankScoreDropLimit::DEFAULT_VALUE;
             EXPECT_TRUE(got1 != got1);
             Properties p;
             search::feature_t got2= hitcollector::RankScoreDropLimit::lookup(p);
             EXPECT_TRUE(got2 != got2);
             p.add("vespa.hitcollector.rankscoredroplimit", "-123456789.12345");
-            EXPECT_EQUAL(hitcollector::RankScoreDropLimit::lookup(p), -123456789.12345);
+            EXPECT_EQ(hitcollector::RankScoreDropLimit::lookup(p), -123456789.12345);
             p.clear().add("vespa.hitcollector.rankscoredroplimit", "123456789.12345");
-            EXPECT_EQUAL(hitcollector::RankScoreDropLimit::lookup(p), 123456789.12345);
+            EXPECT_EQ(hitcollector::RankScoreDropLimit::lookup(p), 123456789.12345);
         }
         { // vespa.fieldweight.
-            EXPECT_EQUAL(FieldWeight::BASE_NAME, vespalib::string("vespa.fieldweight."));
-            EXPECT_EQUAL(FieldWeight::DEFAULT_VALUE, 100u);
+            EXPECT_EQ(FieldWeight::BASE_NAME, vespalib::string("vespa.fieldweight."));
+            EXPECT_EQ(FieldWeight::DEFAULT_VALUE, 100u);
             Properties p;
-            EXPECT_EQUAL(FieldWeight::lookup(p, "foo"), 100u);
+            EXPECT_EQ(FieldWeight::lookup(p, "foo"), 100u);
             p.add("vespa.fieldweight.foo", "200");
-            EXPECT_EQUAL(FieldWeight::lookup(p, "foo"), 200u);
+            EXPECT_EQ(FieldWeight::lookup(p, "foo"), 200u);
         }
         { // vespa.isfilterfield.
-            EXPECT_EQUAL(IsFilterField::BASE_NAME, "vespa.isfilterfield.");
-            EXPECT_EQUAL(IsFilterField::DEFAULT_VALUE, "false");
+            EXPECT_EQ(IsFilterField::BASE_NAME, "vespa.isfilterfield.");
+            EXPECT_EQ(IsFilterField::DEFAULT_VALUE, "false");
             Properties p;
             EXPECT_TRUE(!IsFilterField::check(p, "foo"));
             p.add("vespa.isfilterfield.foo", "true");
@@ -438,192 +440,191 @@ TEST("test stuff") {
             EXPECT_TRUE(IsFilterField::check(p, "bar"));
         }
         {
-            EXPECT_EQUAL(mutate::on_match::Attribute::NAME, vespalib::string("vespa.mutate.on_match.attribute"));
-            EXPECT_EQUAL(mutate::on_match::Attribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_match::Attribute::NAME, vespalib::string("vespa.mutate.on_match.attribute"));
+            EXPECT_EQ(mutate::on_match::Attribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_match::Attribute::lookup(p), "");
+            EXPECT_EQ(mutate::on_match::Attribute::lookup(p), "");
             p.add("vespa.mutate.on_match.attribute", "foobar");
-            EXPECT_EQUAL(mutate::on_match::Attribute::lookup(p), "foobar");
+            EXPECT_EQ(mutate::on_match::Attribute::lookup(p), "foobar");
         }
         {
-            EXPECT_EQUAL(mutate::on_match::Operation::NAME, vespalib::string("vespa.mutate.on_match.operation"));
-            EXPECT_EQUAL(mutate::on_match::Operation::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_match::Operation::NAME, vespalib::string("vespa.mutate.on_match.operation"));
+            EXPECT_EQ(mutate::on_match::Operation::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_match::Operation::lookup(p), "");
+            EXPECT_EQ(mutate::on_match::Operation::lookup(p), "");
             p.add("vespa.mutate.on_match.operation", "+=1");
-            EXPECT_EQUAL(mutate::on_match::Operation::lookup(p), "+=1");
+            EXPECT_EQ(mutate::on_match::Operation::lookup(p), "+=1");
         }
         {
-            EXPECT_EQUAL(mutate::on_first_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_first_phase.attribute"));
-            EXPECT_EQUAL(mutate::on_first_phase::Attribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_first_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_first_phase.attribute"));
+            EXPECT_EQ(mutate::on_first_phase::Attribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_first_phase::Attribute::lookup(p), "");
+            EXPECT_EQ(mutate::on_first_phase::Attribute::lookup(p), "");
             p.add("vespa.mutate.on_first_phase.attribute", "foobar");
-            EXPECT_EQUAL(mutate::on_first_phase::Attribute::lookup(p), "foobar");
+            EXPECT_EQ(mutate::on_first_phase::Attribute::lookup(p), "foobar");
         }
         {
-            EXPECT_EQUAL(mutate::on_first_phase::Operation::NAME, vespalib::string("vespa.mutate.on_first_phase.operation"));
-            EXPECT_EQUAL(mutate::on_first_phase::Operation::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_first_phase::Operation::NAME, vespalib::string("vespa.mutate.on_first_phase.operation"));
+            EXPECT_EQ(mutate::on_first_phase::Operation::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_first_phase::Operation::lookup(p), "");
+            EXPECT_EQ(mutate::on_first_phase::Operation::lookup(p), "");
             p.add("vespa.mutate.on_first_phase.operation", "+=1");
-            EXPECT_EQUAL(mutate::on_first_phase::Operation::lookup(p), "+=1");
+            EXPECT_EQ(mutate::on_first_phase::Operation::lookup(p), "+=1");
         }
         {
-            EXPECT_EQUAL(mutate::on_second_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_second_phase.attribute"));
-            EXPECT_EQUAL(mutate::on_second_phase::Attribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_second_phase::Attribute::NAME, vespalib::string("vespa.mutate.on_second_phase.attribute"));
+            EXPECT_EQ(mutate::on_second_phase::Attribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_second_phase::Attribute::lookup(p), "");
+            EXPECT_EQ(mutate::on_second_phase::Attribute::lookup(p), "");
             p.add("vespa.mutate.on_second_phase.attribute", "foobar");
-            EXPECT_EQUAL(mutate::on_second_phase::Attribute::lookup(p), "foobar");
+            EXPECT_EQ(mutate::on_second_phase::Attribute::lookup(p), "foobar");
         }
         {
-            EXPECT_EQUAL(mutate::on_second_phase::Operation::NAME, vespalib::string("vespa.mutate.on_second_phase.operation"));
-            EXPECT_EQUAL(mutate::on_second_phase::Operation::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_second_phase::Operation::NAME, vespalib::string("vespa.mutate.on_second_phase.operation"));
+            EXPECT_EQ(mutate::on_second_phase::Operation::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_second_phase::Operation::lookup(p), "");
+            EXPECT_EQ(mutate::on_second_phase::Operation::lookup(p), "");
             p.add("vespa.mutate.on_second_phase.operation", "+=1");
-            EXPECT_EQUAL(mutate::on_second_phase::Operation::lookup(p), "+=1");
+            EXPECT_EQ(mutate::on_second_phase::Operation::lookup(p), "+=1");
         }
         {
-            EXPECT_EQUAL(mutate::on_summary::Attribute::NAME, vespalib::string("vespa.mutate.on_summary.attribute"));
-            EXPECT_EQUAL(mutate::on_summary::Attribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_summary::Attribute::NAME, vespalib::string("vespa.mutate.on_summary.attribute"));
+            EXPECT_EQ(mutate::on_summary::Attribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_summary::Attribute::lookup(p), "");
+            EXPECT_EQ(mutate::on_summary::Attribute::lookup(p), "");
             p.add("vespa.mutate.on_summary.attribute", "foobar");
-            EXPECT_EQUAL(mutate::on_summary::Attribute::lookup(p), "foobar");
+            EXPECT_EQ(mutate::on_summary::Attribute::lookup(p), "foobar");
         }
         {
-            EXPECT_EQUAL(mutate::on_summary::Operation::NAME, vespalib::string("vespa.mutate.on_summary.operation"));
-            EXPECT_EQUAL(mutate::on_summary::Operation::DEFAULT_VALUE, "");
+            EXPECT_EQ(mutate::on_summary::Operation::NAME, vespalib::string("vespa.mutate.on_summary.operation"));
+            EXPECT_EQ(mutate::on_summary::Operation::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(mutate::on_summary::Operation::lookup(p), "");
+            EXPECT_EQ(mutate::on_summary::Operation::lookup(p), "");
             p.add("vespa.mutate.on_summary.operation", "+=1");
-            EXPECT_EQUAL(mutate::on_summary::Operation::lookup(p), "+=1");
+            EXPECT_EQ(mutate::on_summary::Operation::lookup(p), "+=1");
         }
         {
-            EXPECT_EQUAL(execute::onmatch::Attribute::NAME, vespalib::string("vespa.execute.onmatch.attribute"));
-            EXPECT_EQUAL(execute::onmatch::Attribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(execute::onmatch::Attribute::NAME, vespalib::string("vespa.execute.onmatch.attribute"));
+            EXPECT_EQ(execute::onmatch::Attribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(execute::onmatch::Attribute::lookup(p), "");
+            EXPECT_EQ(execute::onmatch::Attribute::lookup(p), "");
             p.add("vespa.execute.onmatch.attribute", "foobar");
-            EXPECT_EQUAL(execute::onmatch::Attribute::lookup(p), "foobar");
+            EXPECT_EQ(execute::onmatch::Attribute::lookup(p), "foobar");
         }
         {
-            EXPECT_EQUAL(execute::onmatch::Operation::NAME, vespalib::string("vespa.execute.onmatch.operation"));
-            EXPECT_EQUAL(execute::onmatch::Operation::DEFAULT_VALUE, "");
+            EXPECT_EQ(execute::onmatch::Operation::NAME, vespalib::string("vespa.execute.onmatch.operation"));
+            EXPECT_EQ(execute::onmatch::Operation::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(execute::onmatch::Operation::lookup(p), "");
+            EXPECT_EQ(execute::onmatch::Operation::lookup(p), "");
             p.add("vespa.execute.onmatch.operation", "++");
-            EXPECT_EQUAL(execute::onmatch::Operation::lookup(p), "++");
+            EXPECT_EQ(execute::onmatch::Operation::lookup(p), "++");
         }
         {
-            EXPECT_EQUAL(execute::onrerank::Attribute::NAME, vespalib::string("vespa.execute.onrerank.attribute"));
-            EXPECT_EQUAL(execute::onrerank::Attribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(execute::onrerank::Attribute::NAME, vespalib::string("vespa.execute.onrerank.attribute"));
+            EXPECT_EQ(execute::onrerank::Attribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(execute::onrerank::Attribute::lookup(p), "");
+            EXPECT_EQ(execute::onrerank::Attribute::lookup(p), "");
             p.add("vespa.execute.onrerank.attribute", "foobar");
-            EXPECT_EQUAL(execute::onrerank::Attribute::lookup(p), "foobar");
+            EXPECT_EQ(execute::onrerank::Attribute::lookup(p), "foobar");
         }
         {
-            EXPECT_EQUAL(execute::onrerank::Operation::NAME, vespalib::string("vespa.execute.onrerank.operation"));
-            EXPECT_EQUAL(execute::onrerank::Operation::DEFAULT_VALUE, "");
+            EXPECT_EQ(execute::onrerank::Operation::NAME, vespalib::string("vespa.execute.onrerank.operation"));
+            EXPECT_EQ(execute::onrerank::Operation::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(execute::onrerank::Operation::lookup(p), "");
+            EXPECT_EQ(execute::onrerank::Operation::lookup(p), "");
             p.add("vespa.execute.onrerank.operation", "++");
-            EXPECT_EQUAL(execute::onrerank::Operation::lookup(p), "++");
+            EXPECT_EQ(execute::onrerank::Operation::lookup(p), "++");
         }
         {
-            EXPECT_EQUAL(execute::onsummary::Attribute::NAME, vespalib::string("vespa.execute.onsummary.attribute"));
-            EXPECT_EQUAL(execute::onsummary::Attribute::DEFAULT_VALUE, "");
+            EXPECT_EQ(execute::onsummary::Attribute::NAME, vespalib::string("vespa.execute.onsummary.attribute"));
+            EXPECT_EQ(execute::onsummary::Attribute::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(execute::onsummary::Attribute::lookup(p), "");
+            EXPECT_EQ(execute::onsummary::Attribute::lookup(p), "");
             p.add("vespa.execute.onsummary.attribute", "foobar");
-            EXPECT_EQUAL(execute::onsummary::Attribute::lookup(p), "foobar");
+            EXPECT_EQ(execute::onsummary::Attribute::lookup(p), "foobar");
         }
         {
-            EXPECT_EQUAL(execute::onsummary::Operation::NAME, vespalib::string("vespa.execute.onsummary.operation"));
-            EXPECT_EQUAL(execute::onsummary::Operation::DEFAULT_VALUE, "");
+            EXPECT_EQ(execute::onsummary::Operation::NAME, vespalib::string("vespa.execute.onsummary.operation"));
+            EXPECT_EQ(execute::onsummary::Operation::DEFAULT_VALUE, "");
             Properties p;
-            EXPECT_EQUAL(execute::onsummary::Operation::lookup(p), "");
+            EXPECT_EQ(execute::onsummary::Operation::lookup(p), "");
             p.add("vespa.execute.onsummary.operation", "++");
-            EXPECT_EQUAL(execute::onsummary::Operation::lookup(p), "++");
+            EXPECT_EQ(execute::onsummary::Operation::lookup(p), "++");
         }
         {
-            EXPECT_EQUAL(softtimeout::Enabled::NAME, vespalib::string("vespa.softtimeout.enable"));
+            EXPECT_EQ(softtimeout::Enabled::NAME, vespalib::string("vespa.softtimeout.enable"));
             EXPECT_TRUE(softtimeout::Enabled::DEFAULT_VALUE);
             Properties p;
             p.add(softtimeout::Enabled::NAME, "false");
             EXPECT_FALSE(softtimeout::Enabled::lookup(p));
         }
         {
-            EXPECT_EQUAL(softtimeout::Factor::NAME, vespalib::string("vespa.softtimeout.factor"));
-            EXPECT_EQUAL(0.5, softtimeout::Factor::DEFAULT_VALUE);
+            EXPECT_EQ(softtimeout::Factor::NAME, vespalib::string("vespa.softtimeout.factor"));
+            EXPECT_EQ(0.5, softtimeout::Factor::DEFAULT_VALUE);
             Properties p;
             p.add(softtimeout::Factor::NAME, "0.33");
-            EXPECT_EQUAL(0.33, softtimeout::Factor::lookup(p));
+            EXPECT_EQ(0.33, softtimeout::Factor::lookup(p));
         }
         {
-            EXPECT_EQUAL(softtimeout::TailCost::NAME, vespalib::string("vespa.softtimeout.tailcost"));
-            EXPECT_EQUAL(0.1, softtimeout::TailCost::DEFAULT_VALUE);
+            EXPECT_EQ(softtimeout::TailCost::NAME, vespalib::string("vespa.softtimeout.tailcost"));
+            EXPECT_EQ(0.1, softtimeout::TailCost::DEFAULT_VALUE);
             Properties p;
             p.add(softtimeout::TailCost::NAME, "0.17");
-            EXPECT_EQUAL(0.17, softtimeout::TailCost::lookup(p));
+            EXPECT_EQ(0.17, softtimeout::TailCost::lookup(p));
         }
     }
 }
 
-TEST("test attribute type properties")
+TEST(PropertiesTest, test_attribute_type_properties)
 {
     Properties p;
     p.add("vespa.type.attribute.foo", "tensor(x[10])");
-    EXPECT_EQUAL("tensor(x[10])", type::Attribute::lookup(p, "foo"));
-    EXPECT_EQUAL("", type::Attribute::lookup(p, "bar"));
+    EXPECT_EQ("tensor(x[10])", type::Attribute::lookup(p, "foo"));
+    EXPECT_EQ("", type::Attribute::lookup(p, "bar"));
 }
 
-TEST("test query feature type properties")
+TEST(PropertiesTest, test_query_feature_type_properties)
 {
     Properties p;
     p.add("vespa.type.query.foo", "tensor(x[10])");
-    EXPECT_EQUAL("tensor(x[10])", type::QueryFeature::lookup(p, "foo"));
-    EXPECT_EQUAL("", type::QueryFeature::lookup(p, "bar"));
+    EXPECT_EQ("tensor(x[10])", type::QueryFeature::lookup(p, "foo"));
+    EXPECT_EQ("", type::QueryFeature::lookup(p, "bar"));
 }
 
-TEST("test integer lookup")
+TEST(PropertiesTest, test_integer_lookup)
 {
-    EXPECT_EQUAL(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch"));
-    EXPECT_EQUAL(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max());
+    EXPECT_EQ(matching::NumThreadsPerSearch::NAME, vespalib::string("vespa.matching.numthreadspersearch"));
+    EXPECT_EQ(matching::NumThreadsPerSearch::DEFAULT_VALUE, std::numeric_limits<uint32_t>::max());
     {
         Properties p;
         p.add("vespa.matching.numthreadspersearch", "50");
-        EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u);
+        EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u);
     }
     {
         Properties p;
         p.add("vespa.matching.numthreadspersearch", "50 ");
-        EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u);
+        EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u);
     }
     {
         Properties p;
         p.add("vespa.matching.numthreadspersearch", " 50");
-        EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u);
+        EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u);
     }
     {
         Properties p;
         p.add("vespa.matching.numthreadspersearch", " ");
-        EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE);
+        EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE);
     }
     {
         Properties p;
         p.add("vespa.matching.numthreadspersearch", "50x");
-        EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), 50u);
+        EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), 50u);
     }
     {
         Properties p;
         p.add("vespa.matching.numthreadspersearch", "x");
-        EXPECT_EQUAL(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE);
+        EXPECT_EQ(matching::NumThreadsPerSearch::lookup(p), matching::NumThreadsPerSearch::DEFAULT_VALUE);
     }
 }
 
-
-TEST_MAIN() { TEST_RUN_ALL(); }
+GTEST_MAIN_RUN_ALL_TESTS()