Rewrite streaming search query unit test to use gtest.

2 files changed, 263 insertions, 235 deletions

diff --git a/searchlib/src/tests/query/CMakeLists.txt b/searchlib/src/tests/query/CMakeLists.txt
index 2b56129277c..0cb6c9413b0 100644
--- a/searchlib/src/tests/query/CMakeLists.txt
+++ b/searchlib/src/tests/query/CMakeLists.txt
@@ -39,6 +39,7 @@ vespa_add_executable(searchlib_streaming_query_test_app TEST
     streaming_query_test.cpp
     DEPENDS
     searchlib
+    GTest::gtest
 )
 vespa_add_test(NAME searchlib_streaming_query_test_app COMMAND searchlib_streaming_query_test_app)
 vespa_add_executable(searchlib_streaming_query_large_test_app TEST
diff --git a/searchlib/src/tests/query/streaming_query_test.cpp b/searchlib/src/tests/query/streaming_query_test.cpp
index ffd8c21d561..020afc484e0 100644
--- a/searchlib/src/tests/query/streaming_query_test.cpp
+++ b/searchlib/src/tests/query/streaming_query_test.cpp
@@ -5,7 +5,7 @@
 #include <vespa/searchlib/query/tree/querybuilder.h>
 #include <vespa/searchlib/query/tree/simplequery.h>
 #include <vespa/searchlib/query/tree/stackdumpcreator.h>
-#include <vespa/vespalib/testkit/test_kit.h>
+#include <vespa/vespalib/gtest/gtest.h>
 #include <limits>
 #include <cmath>
 
@@ -15,12 +15,13 @@ using namespace search::streaming;
 using TermType = QueryTerm::Type;
 
 void assertHit(const Hit & h, size_t expWordpos, size_t expContext, int32_t weight) {
-    EXPECT_EQUAL(h.wordpos(), expWordpos);
-    EXPECT_EQUAL(h.context(), expContext);
-    EXPECT_EQUAL(h.weight(), weight);
+    EXPECT_EQ(h.wordpos(), expWordpos);
+    EXPECT_EQ(h.context(), expContext);
+    EXPECT_EQ(h.weight(), weight);
 }
 
-TEST("testQueryLanguage") {
+TEST(StreamingQueryTest, test_query_language)
+{
     QueryNodeResultFactory factory;
     int64_t ia(0), ib(0);
     double da(0), db(0);
@@ -28,209 +29,209 @@ TEST("testQueryLanguage") {
     {
         QueryTerm q(factory.create(), "7", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, 7);
-        EXPECT_EQUAL(ib, 7);
+        EXPECT_EQ(ia, 7);
+        EXPECT_EQ(ib, 7);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, 7);
-        EXPECT_EQUAL(db, 7);
+        EXPECT_EQ(da, 7);
+        EXPECT_EQ(db, 7);
     }
 
     {
         QueryTerm q(factory.create(), "-7", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -7);
-        EXPECT_EQUAL(ib, -7);
+        EXPECT_EQ(ia, -7);
+        EXPECT_EQ(ib, -7);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -7);
-        EXPECT_EQUAL(db, -7);
+        EXPECT_EQ(da, -7);
+        EXPECT_EQ(db, -7);
     }
 
     {
         QueryTerm q(factory.create(), "7.5", "index", TermType::WORD);
         EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, 7.5);
-        EXPECT_EQUAL(db, 7.5);
+        EXPECT_EQ(da, 7.5);
+        EXPECT_EQ(db, 7.5);
     }
 
     {
         QueryTerm q(factory.create(), "-7.5", "index", TermType::WORD);
         EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -7.5);
-        EXPECT_EQUAL(db, -7.5);
+        EXPECT_EQ(da, -7.5);
+        EXPECT_EQ(db, -7.5);
     }
 
     {
         QueryTerm q(factory.create(), "<7", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-        EXPECT_EQUAL(ib, 6);
+        EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQ(ib, 6);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-        EXPECT_LESS(db, 7);
-        EXPECT_GREATER(db, 6.99);
+        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_LT(db, 7);
+        EXPECT_GT(db, 6.99);
     }
 
     {
         QueryTerm q(factory.create(), "[;7]", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-        EXPECT_EQUAL(ib, 7);
+        EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQ(ib, 7);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-        EXPECT_EQUAL(db, 7);
+        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_EQ(db, 7);
     }
 
     {
         QueryTerm q(factory.create(), ">7", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, 8);
-        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_EQ(ia, 8);
+        EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_GREATER(da, 7);
-        EXPECT_LESS(da, 7.01);
-        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+        EXPECT_GT(da, 7);
+        EXPECT_LT(da, 7.01);
+        EXPECT_EQ(db, std::numeric_limits<double>::max());
     }
 
     {
         QueryTerm q(factory.create(), "[7;]", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, 7);
-        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_EQ(ia, 7);
+        EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, 7);
-        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(da, 7);
+        EXPECT_EQ(db, std::numeric_limits<double>::max());
     }
 
     {
         QueryTerm q(factory.create(), "[-7;7]", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -7);
-        EXPECT_EQUAL(ib, 7);
+        EXPECT_EQ(ia, -7);
+        EXPECT_EQ(ib, 7);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -7);
-        EXPECT_EQUAL(db, 7);
+        EXPECT_EQ(da, -7);
+        EXPECT_EQ(db, 7);
     }
 
     {
         QueryTerm q(factory.create(), "[-7.1;7.1]", "index", TermType::WORD);
         EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
-        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -7.1);
-        EXPECT_EQUAL(db, 7.1);
+        EXPECT_EQ(da, -7.1);
+        EXPECT_EQ(db, 7.1);
     }
 
     {
         QueryTerm q(factory.create(), "[500.0;1.7976931348623157E308]", "index", TermType::WORD);
         EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
-        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, 500.0);
-        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(da, 500.0);
+        EXPECT_EQ(db, std::numeric_limits<double>::max());
     }
 
     const double minusSeven(-7), seven(7);
     {
         QueryTerm q(factory.create(), "<-7;7]", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -6);
-        EXPECT_EQUAL(ib, 7);
+        EXPECT_EQ(ia, -6);
+        EXPECT_EQ(ib, 7);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven));
-        EXPECT_EQUAL(db, seven);
+        EXPECT_EQ(da, std::nextafterf(minusSeven, seven));
+        EXPECT_EQ(db, seven);
     }
 
     {
         QueryTerm q(factory.create(), "<-7;7>", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -6);
-        EXPECT_EQUAL(ib, 6);
+        EXPECT_EQ(ia, -6);
+        EXPECT_EQ(ib, 6);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven));
-        EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven));
+        EXPECT_EQ(da, std::nextafterf(minusSeven, seven));
+        EXPECT_EQ(db, std::nextafterf(seven, minusSeven));
     }
 
     {
         QueryTerm q(factory.create(), "<1;2>", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, 2);
-        EXPECT_EQUAL(ib, 1);
+        EXPECT_EQ(ia, 2);
+        EXPECT_EQ(ib, 1);
     }
 
     {
         QueryTerm q(factory.create(), "[-7;7>", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -7);
-        EXPECT_EQUAL(ib, 6);
+        EXPECT_EQ(ia, -7);
+        EXPECT_EQ(ib, 6);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, minusSeven);
-        EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven));
+        EXPECT_EQ(da, minusSeven);
+        EXPECT_EQ(db, std::nextafterf(seven, minusSeven));
     }
 
     {
         QueryTerm q(factory.create(), "<-7", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-        EXPECT_EQUAL(ib, -8);
+        EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQ(ib, -8);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-        EXPECT_LESS(db, -7);
-        EXPECT_GREATER(db, -7.01);
+        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_LT(db, -7);
+        EXPECT_GT(db, -7.01);
     }
 
     {
         QueryTerm q(factory.create(), "[;-7]", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-        EXPECT_EQUAL(ib, -7);
+        EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQ(ib, -7);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-        EXPECT_EQUAL(db, -7);
+        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_EQ(db, -7);
     }
 
     {
         QueryTerm q(factory.create(), "<;-7]", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-        EXPECT_EQUAL(ib, -7);
+        EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQ(ib, -7);
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-        EXPECT_EQUAL(db, -7);
+        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_EQ(db, -7);
     }
 
     {
         QueryTerm q(factory.create(), ">-7", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -6);
-        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_EQ(ia, -6);
+        EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_GREATER(da, -7);
-        EXPECT_LESS(da, -6.99);
-        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+        EXPECT_GT(da, -7);
+        EXPECT_LT(da, -6.99);
+        EXPECT_EQ(db, std::numeric_limits<double>::max());
     }
 
     {
         QueryTerm q(factory.create(), "[-7;]", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -7);
-        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_EQ(ia, -7);
+        EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -7);
-        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(da, -7);
+        EXPECT_EQ(db, std::numeric_limits<double>::max());
     }
 
     {
         QueryTerm q(factory.create(), "[-7;>", "index", TermType::WORD);
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-        EXPECT_EQUAL(ia, -7);
-        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_EQ(ia, -7);
+        EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
         EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQUAL(da, -7);
-        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(da, -7);
+        EXPECT_EQ(db, std::numeric_limits<double>::max());
     }
 
     {
@@ -284,76 +285,80 @@ public:
 
 const char TERM_UNIQ = static_cast<char>(ParseItem::ITEM_TERM) | static_cast<char>(ParseItem::IF_UNIQUEID);
 
-TEST("e is not rewritten even if allowed") {
+TEST(StreamingQueryTest, e_is_not_rewritten_even_if_allowed)
+{
     const char term[6] = {TERM_UNIQ, 3, 1, 'c', 1, 'e'};
     vespalib::stringref stackDump(term, sizeof(term));
-    EXPECT_EQUAL(6u, stackDump.size());
+    EXPECT_EQ(6u, stackDump.size());
     AllowRewrite allowRewrite;
     const Query q(allowRewrite, stackDump);
     EXPECT_TRUE(q.valid());
     const QueryNode & root = q.getRoot();
     EXPECT_TRUE(dynamic_cast<const QueryTerm *>(&root) != nullptr);
     const QueryTerm & qt = static_cast<const QueryTerm &>(root);
-    EXPECT_EQUAL("c", qt.index());
-    EXPECT_EQUAL(vespalib::stringref("e"), qt.getTerm());
-    EXPECT_EQUAL(3u, qt.uniqueId());
+    EXPECT_EQ("c", qt.index());
+    EXPECT_EQ(vespalib::stringref("e"), qt.getTerm());
+    EXPECT_EQ(3u, qt.uniqueId());
 }
 
-TEST("1.0e is not rewritten by default") {
+TEST(StreamingQueryTest, onedot0e_is_not_rewritten_by_default)
+{
     const char term[9] = {TERM_UNIQ, 3, 1, 'c', 4, '1', '.', '0', 'e'};
     vespalib::stringref stackDump(term, sizeof(term));
-    EXPECT_EQUAL(9u, stackDump.size());
+    EXPECT_EQ(9u, stackDump.size());
     QueryNodeResultFactory empty;
     const Query q(empty, stackDump);
     EXPECT_TRUE(q.valid());
     const QueryNode & root = q.getRoot();
     EXPECT_TRUE(dynamic_cast<const QueryTerm *>(&root) != nullptr);
     const QueryTerm & qt = static_cast<const QueryTerm &>(root);
-    EXPECT_EQUAL("c", qt.index());
-    EXPECT_EQUAL(vespalib::stringref("1.0e"), qt.getTerm());
-    EXPECT_EQUAL(3u, qt.uniqueId());
+    EXPECT_EQ("c", qt.index());
+    EXPECT_EQ(vespalib::stringref("1.0e"), qt.getTerm());
+    EXPECT_EQ(3u, qt.uniqueId());
 }
 
-TEST("1.0e is rewritten if allowed too.") {
+TEST(StreamingQueryTest, onedot0e_is_rewritten_if_allowed_too)
+{
     const char term[9] = {TERM_UNIQ, 3, 1, 'c', 4, '1', '.', '0', 'e'};
     vespalib::stringref stackDump(term, sizeof(term));
-    EXPECT_EQUAL(9u, stackDump.size());
+    EXPECT_EQ(9u, stackDump.size());
     AllowRewrite empty;
     const Query q(empty, stackDump);
     EXPECT_TRUE(q.valid());
     const QueryNode & root = q.getRoot();
     EXPECT_TRUE(dynamic_cast<const EquivQueryNode *>(&root) != nullptr);
     const EquivQueryNode & equiv = static_cast<const EquivQueryNode &>(root);
-    EXPECT_EQUAL(2u, equiv.size());
+    EXPECT_EQ(2u, equiv.size());
     EXPECT_TRUE(dynamic_cast<const QueryTerm *>(equiv[0].get()) != nullptr);
     {
         const QueryTerm & qt = static_cast<const QueryTerm &>(*equiv[0]);
-        EXPECT_EQUAL("c", qt.index());
-        EXPECT_EQUAL(vespalib::stringref("1.0e"), qt.getTerm());
-        EXPECT_EQUAL(3u, qt.uniqueId());
+        EXPECT_EQ("c", qt.index());
+        EXPECT_EQ(vespalib::stringref("1.0e"), qt.getTerm());
+        EXPECT_EQ(3u, qt.uniqueId());
     }
     EXPECT_TRUE(dynamic_cast<const PhraseQueryNode *>(equiv[1].get()) != nullptr);
     {
         const PhraseQueryNode & phrase = static_cast<const PhraseQueryNode &>(*equiv[1]);
-        EXPECT_EQUAL(2u, phrase.size());
+        EXPECT_EQ(2u, phrase.size());
         EXPECT_TRUE(dynamic_cast<const QueryTerm *>(phrase[0].get()) != nullptr);
         {
             const QueryTerm & qt = static_cast<const QueryTerm &>(*phrase[0]);
-            EXPECT_EQUAL("c", qt.index());
-            EXPECT_EQUAL(vespalib::stringref("1"), qt.getTerm());
-            EXPECT_EQUAL(0u, qt.uniqueId());
+            EXPECT_EQ("c", qt.index());
+            EXPECT_EQ(vespalib::stringref("1"), qt.getTerm());
+            EXPECT_EQ(0u, qt.uniqueId());
         }
         EXPECT_TRUE(dynamic_cast<const QueryTerm *>(phrase[1].get()) != nullptr);
         {
             const QueryTerm & qt = static_cast<const QueryTerm &>(*phrase[1]);
-            EXPECT_EQUAL("c", qt.index());
-            EXPECT_EQUAL(vespalib::stringref("0e"), qt.getTerm());
-            EXPECT_EQUAL(0u, qt.uniqueId());
+            EXPECT_EQ("c", qt.index());
+            EXPECT_EQ(vespalib::stringref("0e"), qt.getTerm());
+            EXPECT_EQ(0u, qt.uniqueId());
         }
     }
 }
 
-TEST("testGetQueryParts") {
+TEST(StreamingQueryTest, test_get_query_parts)
+{
     QueryBuilder<SimpleQueryNodeTypes> builder;
     builder.addAnd(4);
     {
@@ -387,7 +392,7 @@ TEST("testGetQueryParts") {
         phrases[0]->getLeaves(pts);
         ASSERT_TRUE(pts.size() == 3);
         for (size_t i = 0; i < 3; ++i) {
-            EXPECT_EQUAL(pts[i], terms[i + 1]);
+            EXPECT_EQ(pts[i], terms[i + 1]);
         }
     }
     {
@@ -395,12 +400,13 @@ TEST("testGetQueryParts") {
         phrases[1]->getLeaves(pts);
         ASSERT_TRUE(pts.size() == 2);
         for (size_t i = 0; i < 2; ++i) {
-            EXPECT_EQUAL(pts[i], terms[i + 5]);
+            EXPECT_EQ(pts[i], terms[i + 5]);
         }
     }
 }
 
-TEST("testPhraseEvaluate") {
+TEST(StreamingQueryTest, test_phrase_evaluate)
+{
     QueryBuilder<SimpleQueryNodeTypes> builder;
     builder.addPhrase(3, "", 0, Weight(0));
     {
@@ -449,26 +455,27 @@ TEST("testPhraseEvaluate") {
     HitList hits;
     PhraseQueryNode * p = static_cast<PhraseQueryNode *>(phrases[0]);
     p->evaluateHits(hits);
-    ASSERT_EQUAL(3u, hits.size());
-    EXPECT_EQUAL(hits[0].wordpos(), 2u);
-    EXPECT_EQUAL(hits[0].context(), 0u);
-    EXPECT_EQUAL(hits[1].wordpos(), 6u);
-    EXPECT_EQUAL(hits[1].context(), 1u);
-    EXPECT_EQUAL(hits[2].wordpos(), 2u);
-    EXPECT_EQUAL(hits[2].context(), 3u);
-    ASSERT_EQUAL(4u, p->getFieldInfoSize());
-    EXPECT_EQUAL(p->getFieldInfo(0).getHitOffset(), 0u);
-    EXPECT_EQUAL(p->getFieldInfo(0).getHitCount(),  1u);
-    EXPECT_EQUAL(p->getFieldInfo(1).getHitOffset(), 1u);
-    EXPECT_EQUAL(p->getFieldInfo(1).getHitCount(),  1u);
-    EXPECT_EQUAL(p->getFieldInfo(2).getHitOffset(), 0u); // invalid, but will never be used
-    EXPECT_EQUAL(p->getFieldInfo(2).getHitCount(),  0u);
-    EXPECT_EQUAL(p->getFieldInfo(3).getHitOffset(), 2u);
-    EXPECT_EQUAL(p->getFieldInfo(3).getHitCount(),  1u);
+    ASSERT_EQ(3u, hits.size());
+    EXPECT_EQ(hits[0].wordpos(), 2u);
+    EXPECT_EQ(hits[0].context(), 0u);
+    EXPECT_EQ(hits[1].wordpos(), 6u);
+    EXPECT_EQ(hits[1].context(), 1u);
+    EXPECT_EQ(hits[2].wordpos(), 2u);
+    EXPECT_EQ(hits[2].context(), 3u);
+    ASSERT_EQ(4u, p->getFieldInfoSize());
+    EXPECT_EQ(p->getFieldInfo(0).getHitOffset(), 0u);
+    EXPECT_EQ(p->getFieldInfo(0).getHitCount(),  1u);
+    EXPECT_EQ(p->getFieldInfo(1).getHitOffset(), 1u);
+    EXPECT_EQ(p->getFieldInfo(1).getHitCount(),  1u);
+    EXPECT_EQ(p->getFieldInfo(2).getHitOffset(), 0u); // invalid, but will never be used
+    EXPECT_EQ(p->getFieldInfo(2).getHitCount(),  0u);
+    EXPECT_EQ(p->getFieldInfo(3).getHitOffset(), 2u);
+    EXPECT_EQ(p->getFieldInfo(3).getHitCount(),  1u);
     EXPECT_TRUE(p->evaluate());
 }
 
-TEST("testHit") {
+TEST(StreamingQueryTest, test_hit)
+{
     // positions (0 - (2^24-1))
     assertHit(Hit(0,        0, 0, 0),        0, 0, 0);
     assertHit(Hit(256,      0, 0, 1),      256, 0, 1);
@@ -484,31 +491,32 @@ TEST("testHit") {
 void assertInt8Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) {
     QueryTermSimple q(term, TermType::WORD);
     QueryTermSimple::RangeResult<int8_t> res = q.getRange<int8_t>();
-    EXPECT_EQUAL(true, res.valid);
-    EXPECT_EQUAL(expAdjusted, res.adjusted);
-    EXPECT_EQUAL(expLow, (int64_t)res.low);
-    EXPECT_EQUAL(expHigh, (int64_t)res.high);
+    EXPECT_EQ(true, res.valid);
+    EXPECT_EQ(expAdjusted, res.adjusted);
+    EXPECT_EQ(expLow, (int64_t)res.low);
+    EXPECT_EQ(expHigh, (int64_t)res.high);
 }
 
 void assertInt32Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) {
     QueryTermSimple q(term, TermType::WORD);
     QueryTermSimple::RangeResult<int32_t> res = q.getRange<int32_t>();
-    EXPECT_EQUAL(true, res.valid);
-    EXPECT_EQUAL(expAdjusted, res.adjusted);
-    EXPECT_EQUAL(expLow, (int64_t)res.low);
-    EXPECT_EQUAL(expHigh, (int64_t)res.high);
+    EXPECT_EQ(true, res.valid);
+    EXPECT_EQ(expAdjusted, res.adjusted);
+    EXPECT_EQ(expLow, (int64_t)res.low);
+    EXPECT_EQ(expHigh, (int64_t)res.high);
 }
 
 void assertInt64Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) {
     QueryTermSimple q(term, TermType::WORD);
     QueryTermSimple::RangeResult<int64_t> res = q.getRange<int64_t>();
-    EXPECT_EQUAL(true, res.valid);
-    EXPECT_EQUAL(expAdjusted, res.adjusted);
-    EXPECT_EQUAL(expLow, (int64_t)res.low);
-    EXPECT_EQUAL(expHigh, (int64_t)res.high);
+    EXPECT_EQ(true, res.valid);
+    EXPECT_EQ(expAdjusted, res.adjusted);
+    EXPECT_EQ(expLow, (int64_t)res.low);
+    EXPECT_EQ(expHigh, (int64_t)res.high);
 }
 
-TEST("requireThatInt8LimitsAreEnforced") {
+TEST(StreamingQueryTest, require_that_int8_limits_are_enforced)
+{
     //std::numeric_limits<int8_t>::min() -> -128
     //std::numeric_limits<int8_t>::max() -> 127
 
@@ -525,7 +533,8 @@ TEST("requireThatInt8LimitsAreEnforced") {
     assertInt8Range("[-129;128]", true, -128, 127);
 }
 
-TEST("requireThatInt32LimitsAreEnforced") {
+TEST(StreamingQueryTest, require_that_int32_limits_are_enforced)
+{
     //std::numeric_limits<int32_t>::min() -> -2147483648
     //std::numeric_limits<int32_t>::max() -> 2147483647
 
@@ -545,7 +554,8 @@ TEST("requireThatInt32LimitsAreEnforced") {
     assertInt32Range("[-2147483649;2147483648]", true, min, max);
 }
 
-TEST("requireThatInt64LimitsAreEnforced") {
+TEST(StreamingQueryTest, require_that_int64_limits_are_enforced)
+{
     //std::numeric_limits<int64_t>::min() -> -9223372036854775808
     //std::numeric_limits<int64_t>::max() -> 9223372036854775807
 
@@ -565,13 +575,15 @@ TEST("requireThatInt64LimitsAreEnforced") {
     assertInt64Range("[-9223372036854775809;9223372036854775808]", false, min, max);
 }
 
-TEST("require sensible rounding when using integer attributes.") {
+TEST(StreamingQueryTest, require_sensible_rounding_when_using_integer_attributes)
+{
     assertInt64Range("1.2", false, 1, 1);
     assertInt64Range("1.51", false, 2, 2);
     assertInt64Range("2.49", false, 2, 2);
 }
 
-TEST("require that we can take floating point values in range search too.") {
+TEST(StreamingQueryTest, require_that_we_can_take_floating_point_values_in_range_search_too)
+{
     assertInt64Range("[1;2]", false, 1, 2);
     assertInt64Range("[1.1;2.1]", false, 2, 2);
     assertInt64Range("[1.9;3.9]", false, 2, 3);
@@ -588,7 +600,8 @@ TEST("require that we can take floating point values in range search too.") {
     assertInt64Range("[1.7976931348623157E308;-1.7976931348623157E308]", false, std::numeric_limits<int64_t>::max(), std::numeric_limits<int64_t>::min());
 }
 
-TEST("require that we handle empty range as expected") {
+TEST(StreamingQueryTest, require_that_we_handle_empty_range_as_expected)
+{
     assertInt64Range("[1;1]", false, 1, 1);
     assertInt64Range("<1;1]", false, 2, 1);
     assertInt64Range("[0;1>", false, 0, 0);
@@ -596,7 +609,8 @@ TEST("require that we handle empty range as expected") {
     assertInt64Range("<1;1>", false, 2, 0);
 }
 
-TEST("require that ascending range can be specified with limit only") {
+TEST(StreamingQueryTest, require_that_ascending_range_can_be_specified_with_limit_only)
+{
     int64_t low_integer = 0;
     int64_t high_integer = 0;
     double low_double = 0.0;
@@ -607,14 +621,15 @@ TEST("require that ascending range can be specified with limit only") {
 
     EXPECT_TRUE(ascending_query.getAsIntegerTerm(low_integer, high_integer));
     EXPECT_TRUE(ascending_query.getAsDoubleTerm(low_double, high_double));
-    EXPECT_EQUAL(std::numeric_limits<int64_t>::min(), low_integer);
-    EXPECT_EQUAL(std::numeric_limits<int64_t>::max(), high_integer);
-    EXPECT_EQUAL(-std::numeric_limits<double>::max(), low_double);
-    EXPECT_EQUAL(std::numeric_limits<double>::max(), high_double);
-    EXPECT_EQUAL(500, ascending_query.getRangeLimit());
+    EXPECT_EQ(std::numeric_limits<int64_t>::min(), low_integer);
+    EXPECT_EQ(std::numeric_limits<int64_t>::max(), high_integer);
+    EXPECT_EQ(-std::numeric_limits<double>::max(), low_double);
+    EXPECT_EQ(std::numeric_limits<double>::max(), high_double);
+    EXPECT_EQ(500, ascending_query.getRangeLimit());
 }
 
-TEST("require that descending range can be specified with limit only") {
+TEST(StreamingQueryTest, require_that_descending_range_can_be_specified_with_limit_only)
+{
     int64_t low_integer = 0;
     int64_t high_integer = 0;
     double low_double = 0.0;
@@ -625,102 +640,111 @@ TEST("require that descending range can be specified with limit only") {
 
     EXPECT_TRUE(descending_query.getAsIntegerTerm(low_integer, high_integer));
     EXPECT_TRUE(descending_query.getAsDoubleTerm(low_double, high_double));
-    EXPECT_EQUAL(std::numeric_limits<int64_t>::min(), low_integer);
-    EXPECT_EQUAL(std::numeric_limits<int64_t>::max(), high_integer);
-    EXPECT_EQUAL(-std::numeric_limits<double>::max(), low_double);
-    EXPECT_EQUAL(std::numeric_limits<double>::max(), high_double);
-    EXPECT_EQUAL(-500, descending_query.getRangeLimit());
+    EXPECT_EQ(std::numeric_limits<int64_t>::min(), low_integer);
+    EXPECT_EQ(std::numeric_limits<int64_t>::max(), high_integer);
+    EXPECT_EQ(-std::numeric_limits<double>::max(), low_double);
+    EXPECT_EQ(std::numeric_limits<double>::max(), high_double);
+    EXPECT_EQ(-500, descending_query.getRangeLimit());
 }
 
-TEST("require that correctly specified diversity can be parsed") {
+TEST(StreamingQueryTest, require_that_correctly_specified_diversity_can_be_parsed)
+{
     QueryNodeResultFactory eqnr;
     QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78]", "index", TermType::WORD);
     EXPECT_TRUE(descending_query.isValid());
-    EXPECT_EQUAL(-500, descending_query.getRangeLimit());
-    EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute());
-    EXPECT_EQUAL(78u, descending_query.getMaxPerGroup());
-    EXPECT_EQUAL(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups());
+    EXPECT_EQ(-500, descending_query.getRangeLimit());
+    EXPECT_EQ("ab56", descending_query.getDiversityAttribute());
+    EXPECT_EQ(78u, descending_query.getMaxPerGroup());
+    EXPECT_EQ(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups());
     EXPECT_FALSE(descending_query.getDiversityCutoffStrict());
 }
 
-TEST("require that correctly specified diversity with cutoff groups can be parsed") {
+TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_cutoff_groups_can_be_parsed)
+{
     QueryNodeResultFactory eqnr;
     QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93]", "index", TermType::WORD);
     EXPECT_TRUE(descending_query.isValid());
-    EXPECT_EQUAL(-500, descending_query.getRangeLimit());
-    EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute());
-    EXPECT_EQUAL(78u, descending_query.getMaxPerGroup());
-    EXPECT_EQUAL(93u, descending_query.getDiversityCutoffGroups());
+    EXPECT_EQ(-500, descending_query.getRangeLimit());
+    EXPECT_EQ("ab56", descending_query.getDiversityAttribute());
+    EXPECT_EQ(78u, descending_query.getMaxPerGroup());
+    EXPECT_EQ(93u, descending_query.getDiversityCutoffGroups());
     EXPECT_FALSE(descending_query.getDiversityCutoffStrict());
 }
 
-TEST("require that correctly specified diversity with cutoff groups can be parsed") {
+TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_cutoff_groups_can_be_parsed_2)
+{
     QueryNodeResultFactory eqnr;
     QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;13]", "index", TermType::WORD);
     EXPECT_TRUE(descending_query.isValid());
-    EXPECT_EQUAL(-500, descending_query.getRangeLimit());
-    EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute());
-    EXPECT_EQUAL(78u, descending_query.getMaxPerGroup());
-    EXPECT_EQUAL(13u, descending_query.getDiversityCutoffGroups());
+    EXPECT_EQ(-500, descending_query.getRangeLimit());
+    EXPECT_EQ("ab56", descending_query.getDiversityAttribute());
+    EXPECT_EQ(78u, descending_query.getMaxPerGroup());
+    EXPECT_EQ(13u, descending_query.getDiversityCutoffGroups());
     EXPECT_FALSE(descending_query.getDiversityCutoffStrict());
 }
 
-TEST("require that correctly specified diversity with incorrect cutoff groups can be parsed") {
+TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_incorrect_cutoff_groups_can_be_parsed)
+{
     QueryNodeResultFactory eqnr;
     QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;a13.9]", "index", TermType::WORD);
     EXPECT_TRUE(descending_query.isValid());
-    EXPECT_EQUAL(-500, descending_query.getRangeLimit());
-    EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute());
-    EXPECT_EQUAL(78u, descending_query.getMaxPerGroup());
-    EXPECT_EQUAL(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups());
+    EXPECT_EQ(-500, descending_query.getRangeLimit());
+    EXPECT_EQ("ab56", descending_query.getDiversityAttribute());
+    EXPECT_EQ(78u, descending_query.getMaxPerGroup());
+    EXPECT_EQ(std::numeric_limits<uint32_t>::max(), descending_query.getDiversityCutoffGroups());
     EXPECT_FALSE(descending_query.getDiversityCutoffStrict());
 }
 
-TEST("require that correctly specified diversity with cutoff strategy can be parsed") {
+TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_cutoff_strategy_can_be_parsed)
+{
     QueryNodeResultFactory eqnr;
     QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;anything but strict]", "index", TermType::WORD);
     EXPECT_TRUE(descending_query.isValid());
-    EXPECT_EQUAL(-500, descending_query.getRangeLimit());
-    EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute());
-    EXPECT_EQUAL(78u, descending_query.getMaxPerGroup());
-    EXPECT_EQUAL(93u, descending_query.getDiversityCutoffGroups());
+    EXPECT_EQ(-500, descending_query.getRangeLimit());
+    EXPECT_EQ("ab56", descending_query.getDiversityAttribute());
+    EXPECT_EQ(78u, descending_query.getMaxPerGroup());
+    EXPECT_EQ(93u, descending_query.getDiversityCutoffGroups());
     EXPECT_FALSE(descending_query.getDiversityCutoffStrict());
 }
 
-TEST("require that correctly specified diversity with strict cutoff strategy can be parsed") {
+TEST(StreamingQueryTest, require_that_correctly_specified_diversity_with_strict_cutoff_strategy_can_be_parsed)
+{
     QueryNodeResultFactory eqnr;
     QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;strict]", "index", TermType::WORD);
     EXPECT_TRUE(descending_query.isValid());
-    EXPECT_EQUAL(-500, descending_query.getRangeLimit());
-    EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute());
-    EXPECT_EQUAL(78u, descending_query.getMaxPerGroup());
-    EXPECT_EQUAL(93u, descending_query.getDiversityCutoffGroups());
+    EXPECT_EQ(-500, descending_query.getRangeLimit());
+    EXPECT_EQ("ab56", descending_query.getDiversityAttribute());
+    EXPECT_EQ(78u, descending_query.getMaxPerGroup());
+    EXPECT_EQ(93u, descending_query.getDiversityCutoffGroups());
     EXPECT_TRUE(descending_query.getDiversityCutoffStrict());
 }
 
-TEST("require that incorrectly specified diversity can be parsed") {
+TEST(StreamingQueryTest, require_that_incorrectly_specified_diversity_can_be_parsed)
+{
     QueryNodeResultFactory eqnr;
     QueryTerm descending_query(eqnr.create(), "[;;-500;ab56]", "index", TermType::WORD);
     EXPECT_FALSE(descending_query.isValid());
 }
 
-TEST("require that we do not break the stack on bad query") {
+TEST(StreamingQueryTest, require_that_we_do_not_break_the_stack_on_bad_query)
+{
     QueryTermSimple term("<form><iframe+&#09;&#10;&#11;+src=\\\"javascript&#58;alert(1)\\\"&#11;&#10;&#09;;>", TermType::WORD);
     EXPECT_FALSE(term.isValid());
 }
 
-TEST("a unhandled sameElement stack") {
+TEST(StreamingQueryTest, a_unhandled_sameElement_stack)
+{
     const char * stack = "\022\002\026xyz_abcdefghij_xyzxyzxQ\001\vxxxxxx_name\034xxxxxx_xxxx_xxxxxxx_xxxxxxxxE\002\005delta\b<0.00393";
     vespalib::stringref stackDump(stack);
-    EXPECT_EQUAL(85u, stackDump.size());
+    EXPECT_EQ(85u, stackDump.size());
     AllowRewrite empty;
     const Query q(empty, stackDump);
     EXPECT_TRUE(q.valid());
     const QueryNode & root = q.getRoot();
     auto sameElement = dynamic_cast<const SameElementQueryNode *>(&root);
     EXPECT_TRUE(sameElement != nullptr);
-    EXPECT_EQUAL(2u, sameElement->size());
-    EXPECT_EQUAL("xyz_abcdefghij_xyzxyzx", sameElement->getIndex());
+    EXPECT_EQ(2u, sameElement->size());
+    EXPECT_EQ("xyz_abcdefghij_xyzxyzx", sameElement->getIndex());
     auto term0 = dynamic_cast<const QueryTerm *>((*sameElement)[0].get());
     EXPECT_TRUE(term0 != nullptr);
     auto term1 = dynamic_cast<const QueryTerm *>((*sameElement)[1].get());
@@ -730,10 +754,12 @@ TEST("a unhandled sameElement stack") {
 namespace {
     void verifyQueryTermNode(const vespalib::string & index, const QueryNode *node) {
         EXPECT_TRUE(dynamic_cast<const QueryTerm *>(node) != nullptr);
-        EXPECT_EQUAL(index, node->getIndex());
+        EXPECT_EQ(index, node->getIndex());
     }
 }
-TEST("testSameElementEvaluate") {
+
+TEST(StreamingQueryTest, test_same_element_evaluate)
+{
     QueryBuilder<SimpleQueryNodeTypes> builder;
     builder.addSameElement(3, "field", 0, Weight(0));
     {
@@ -747,15 +773,15 @@ TEST("testSameElementEvaluate") {
     Query q(empty, stackDump);
     SameElementQueryNode * sameElem = dynamic_cast<SameElementQueryNode *>(&q.getRoot());
     EXPECT_TRUE(sameElem != nullptr);
-    EXPECT_EQUAL("field", sameElem->getIndex());
-    EXPECT_EQUAL(3u, sameElem->size());
+    EXPECT_EQ("field", sameElem->getIndex());
+    EXPECT_EQ(3u, sameElem->size());
     verifyQueryTermNode("field.f1", (*sameElem)[0].get());
     verifyQueryTermNode("field.f2", (*sameElem)[1].get());
     verifyQueryTermNode("field.f3", (*sameElem)[2].get());
 
     QueryTermList terms;
     q.getLeaves(terms);
-    EXPECT_EQUAL(3u, terms.size());
+    EXPECT_EQ(3u, terms.size());
     for (QueryTerm * qt : terms) {
         qt->resizeFieldId(3);
     }
@@ -782,30 +808,30 @@ TEST("testSameElementEvaluate") {
     terms[2]->add(17, 2, 6, 170);
     HitList hits;
     sameElem->evaluateHits(hits);
-    EXPECT_EQUAL(4u, hits.size());
-    EXPECT_EQUAL(0u, hits[0].wordpos());
-    EXPECT_EQUAL(2u, hits[0].context());
-    EXPECT_EQUAL(0u, hits[0].elemId());
-    EXPECT_EQUAL(130,  hits[0].weight());
-
-    EXPECT_EQUAL(0u, hits[1].wordpos());
-    EXPECT_EQUAL(2u, hits[1].context());
-    EXPECT_EQUAL(2u, hits[1].elemId());
-    EXPECT_EQUAL(140,  hits[1].weight());
-
-    EXPECT_EQUAL(0u, hits[2].wordpos());
-    EXPECT_EQUAL(2u, hits[2].context());
-    EXPECT_EQUAL(4u, hits[2].elemId());
-    EXPECT_EQUAL(150,  hits[2].weight());
-
-    EXPECT_EQUAL(0u, hits[3].wordpos());
-    EXPECT_EQUAL(2u, hits[3].context());
-    EXPECT_EQUAL(5u, hits[3].elemId());
-    EXPECT_EQUAL(160,  hits[3].weight());
+    EXPECT_EQ(4u, hits.size());
+    EXPECT_EQ(0u, hits[0].wordpos());
+    EXPECT_EQ(2u, hits[0].context());
+    EXPECT_EQ(0u, hits[0].elemId());
+    EXPECT_EQ(130,  hits[0].weight());
+
+    EXPECT_EQ(0u, hits[1].wordpos());
+    EXPECT_EQ(2u, hits[1].context());
+    EXPECT_EQ(2u, hits[1].elemId());
+    EXPECT_EQ(140,  hits[1].weight());
+
+    EXPECT_EQ(0u, hits[2].wordpos());
+    EXPECT_EQ(2u, hits[2].context());
+    EXPECT_EQ(4u, hits[2].elemId());
+    EXPECT_EQ(150,  hits[2].weight());
+
+    EXPECT_EQ(0u, hits[3].wordpos());
+    EXPECT_EQ(2u, hits[3].context());
+    EXPECT_EQ(5u, hits[3].elemId());
+    EXPECT_EQ(160,  hits[3].weight());
     EXPECT_TRUE(sameElem->evaluate());
 }
 
-TEST("test_nearest_neighbor_query_node")
+TEST(StreamingQueryTest, test_nearest_neighbor_query_node)
 {
     QueryBuilder<SimpleQueryNodeTypes> builder;
     constexpr double distance_threshold = 35.5;
@@ -824,27 +850,28 @@ TEST("test_nearest_neighbor_query_node")
     EXPECT_TRUE(qterm != nullptr);
     auto* node = dynamic_cast<NearestNeighborQueryNode *>(&q.getRoot());
     EXPECT_TRUE(node != nullptr);
-    EXPECT_EQUAL(node, qterm->as_nearest_neighbor_query_node());
-    EXPECT_EQUAL("qtensor", node->get_query_tensor_name());
-    EXPECT_EQUAL("field", node->getIndex());
-    EXPECT_EQUAL(id, static_cast<int32_t>(node->uniqueId()));
-    EXPECT_EQUAL(weight, node->weight().percent());
-    EXPECT_EQUAL(distance_threshold, node->get_distance_threshold());
+    EXPECT_EQ(node, qterm->as_nearest_neighbor_query_node());
+    EXPECT_EQ("qtensor", node->get_query_tensor_name());
+    EXPECT_EQ("field", node->getIndex());
+    EXPECT_EQ(id, static_cast<int32_t>(node->uniqueId()));
+    EXPECT_EQ(weight, node->weight().percent());
+    EXPECT_EQ(distance_threshold, node->get_distance_threshold());
     EXPECT_FALSE(node->get_distance().has_value());
     EXPECT_FALSE(node->evaluate());
     node->set_distance(distance);
     EXPECT_TRUE(node->get_distance().has_value());
-    EXPECT_EQUAL(distance, node->get_distance().value());
+    EXPECT_EQ(distance, node->get_distance().value());
     EXPECT_TRUE(node->evaluate());
     node->reset();
     EXPECT_FALSE(node->get_distance().has_value());
     EXPECT_FALSE(node->evaluate());
 }
 
-TEST("Control the size of query terms") {
-    EXPECT_EQUAL(112u, sizeof(QueryTermSimple));
-    EXPECT_EQUAL(128u, sizeof(QueryTermUCS4));
-    EXPECT_EQUAL(272u, sizeof(QueryTerm));
+TEST(StreamingQueryTest, control_the_size_of_query_terms)
+{
+    EXPECT_EQ(112u, sizeof(QueryTermSimple));
+    EXPECT_EQ(128u, sizeof(QueryTermUCS4));
+    EXPECT_EQ(272u, sizeof(QueryTerm));
 }
 
-TEST_MAIN() { TEST_RUN_ALL(); }
+GTEST_MAIN_RUN_ALL_TESTS()