Merge pull request #30569 from vespa-engine/toregge/rewrite-messagebus-route-parser-unit-test-to-gtestv8.317.19

Rewrite messagebus route parser unit test to gtest.

2 files changed, 79 insertions, 93 deletions

diff --git a/messagebus/src/tests/routeparser/CMakeLists.txt b/messagebus/src/tests/routeparser/CMakeLists.txt
index 917c6983d9f..6c715d49f73 100644
--- a/messagebus/src/tests/routeparser/CMakeLists.txt
+++ b/messagebus/src/tests/routeparser/CMakeLists.txt
@@ -5,5 +5,6 @@ vespa_add_executable(messagebus_routeparser_test_app TEST
     DEPENDS
     messagebus_messagebus-test
     messagebus
+    GTest::gtest
 )
 vespa_add_test(NAME messagebus_routeparser_test_app COMMAND messagebus_routeparser_test_app)
diff --git a/messagebus/src/tests/routeparser/routeparser.cpp b/messagebus/src/tests/routeparser/routeparser.cpp
index 0983b6734c6..f01ad44fdba 100644
--- a/messagebus/src/tests/routeparser/routeparser.cpp
+++ b/messagebus/src/tests/routeparser/routeparser.cpp
@@ -11,63 +11,34 @@
 #include <vespa/messagebus/testlib/simplemessage.h>
 #include <vespa/messagebus/testlib/slobrok.h>
 #include <vespa/messagebus/testlib/testserver.h>
-#include <vespa/vespalib/testkit/testapp.h>
+#include <vespa/vespalib/gtest/gtest.h>
 
 #include <vespa/log/log.h>
 LOG_SETUP("routeparser_test");
 
 using namespace mbus;
 
-class Test : public vespalib::TestApp {
-public:
-    int Main() override;
-    void testHopParser();
-    void testHopParserErrors();
-    void testRouteParser();
-    void testRouteParserErrors();
-
-private:
-    bool testError(const Route &route, const string &msg);
-    bool testError(const Hop &hop, const string &msg);
-    bool testErrorDirective(const IHopDirective & dir, const string &msg);
-    bool testPolicyDirective(const IHopDirective & dir, const string &name, const string &param);
-    bool testRouteDirective(const IHopDirective & dir, const string &name);
-    bool testTcpDirective(const IHopDirective & dir, const string &host, uint32_t port, const string &session);
-    bool testVerbatimDirective(const IHopDirective & dir, const string &image);
-};
-
-TEST_APPHOOK(Test);
-
-int
-Test::Main()
-{
-    TEST_INIT("routeparser_test");
-
-    testHopParser();         TEST_FLUSH();
-    testHopParserErrors();   TEST_FLUSH();
-    testRouteParser();       TEST_FLUSH();
-    testRouteParserErrors(); TEST_FLUSH();
-
-    TEST_DONE();
-}
+namespace {
 
 bool
-Test::testError(const Route &route, const string &msg)
+testErrorDirective(const IHopDirective & dir, const string &msg)
 {
-    if (!EXPECT_EQUAL(1u, route.getNumHops())) {
+    bool failed = false;
+    EXPECT_EQ(IHopDirective::TYPE_ERROR, dir.getType()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    if (!testError(route.getHop(0), msg)) {
-        return false;
-    }
-    return true;
+    EXPECT_EQ(msg, static_cast<const ErrorDirective&>(dir).getMessage()) << (failed = true, "");
+    return !failed;
 }
 
 bool
-Test::testError(const Hop &hop, const string &msg)
+testError(const Hop &hop, const string &msg)
 {
     LOG(info, "%s", hop.toDebugString().c_str());
-    if (!EXPECT_EQUAL(1u, hop.getNumDirectives())) {
+    bool failed = false;
+    EXPECT_EQ(1u, hop.getNumDirectives()) << (failed = true, "");
+    if (failed) {
         return false;
     }
     if (!testErrorDirective(hop.getDirective(0), msg)) {
@@ -77,106 +48,121 @@ Test::testError(const Hop &hop, const string &msg)
 }
 
 bool
-Test::testErrorDirective(const IHopDirective & dir, const string &msg)
+testError(const Route &route, const string &msg)
 {
-    if (!EXPECT_EQUAL(IHopDirective::TYPE_ERROR, dir.getType())) {
+    bool failed = false;
+    EXPECT_EQ(1u, route.getNumHops()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    if (!EXPECT_EQUAL(msg, static_cast<const ErrorDirective&>(dir).getMessage())) {
+    if (!testError(route.getHop(0), msg)) {
         return false;
     }
     return true;
 }
 
 bool
-Test::testPolicyDirective(const IHopDirective & dir, const string &name, const string &param)
+testPolicyDirective(const IHopDirective & dir, const string &name, const string &param)
 {
-    if (!EXPECT_EQUAL(IHopDirective::TYPE_POLICY, dir.getType())) {
-        return false;
-    }
-    if (!EXPECT_EQUAL(name, static_cast<const PolicyDirective&>(dir).getName())) {
+    bool failed = false;
+    EXPECT_EQ(IHopDirective::TYPE_POLICY, dir.getType()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    if (!EXPECT_EQUAL(param, static_cast<const PolicyDirective&>(dir).getParam())) {
+    EXPECT_EQ(name, static_cast<const PolicyDirective&>(dir).getName()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    return true;
+    EXPECT_EQ(param, static_cast<const PolicyDirective&>(dir).getParam()) << (failed = true, "");
+    return !failed;
 }
 
 bool
-Test::testRouteDirective(const IHopDirective & dir, const string &name)
+testRouteDirective(const IHopDirective & dir, const string &name)
 {
-    if (!EXPECT_EQUAL(IHopDirective::TYPE_ROUTE, dir.getType())) {
+    bool failed = false;
+    EXPECT_EQ(IHopDirective::TYPE_ROUTE, dir.getType()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    if (!EXPECT_EQUAL(name, static_cast<const RouteDirective&>(dir).getName())) {
-        return false;
-    }
-    return true;
+    EXPECT_EQ(name, static_cast<const RouteDirective&>(dir).getName()) << (failed = true, "");
+    return !failed;
 }
 
 bool
-Test::testTcpDirective(const IHopDirective & dir, const string &host, uint32_t port, const string &session)
+testTcpDirective(const IHopDirective & dir, const string &host, uint32_t port, const string &session)
 {
-    if (!EXPECT_EQUAL(IHopDirective::TYPE_TCP, dir.getType())) {
-        return false;
-    }
-    if (!EXPECT_EQUAL(host, static_cast<const TcpDirective&>(dir).getHost())) {
+    bool failed = false;
+    EXPECT_EQ(IHopDirective::TYPE_TCP, dir.getType()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    if (!EXPECT_EQUAL(port, static_cast<const TcpDirective&>(dir).getPort())) {
+    EXPECT_EQ(host, static_cast<const TcpDirective&>(dir).getHost()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    if (!EXPECT_EQUAL(session, static_cast<const TcpDirective&>(dir).getSession())) {
+    EXPECT_EQ(port, static_cast<const TcpDirective&>(dir).getPort()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    return true;
+    EXPECT_EQ(session, static_cast<const TcpDirective&>(dir).getSession()) << (failed = true, "");
+    return !failed;
 }
 
 bool
-Test::testVerbatimDirective(const IHopDirective & dir, const string &image)
+testVerbatimDirective(const IHopDirective & dir, const string &image)
 {
-    if (!EXPECT_EQUAL(IHopDirective::TYPE_VERBATIM, dir.getType())) {
-        return false;
-    }
-    if (!EXPECT_EQUAL(image, static_cast<const VerbatimDirective&>(dir).getImage())) {
+    bool failed = false;
+    EXPECT_EQ(IHopDirective::TYPE_VERBATIM, dir.getType()) << (failed = true, "");
+    if (failed) {
         return false;
     }
-    return true;
+    EXPECT_EQ(image, static_cast<const VerbatimDirective&>(dir).getImage()) << (failed = true, "");
+    return !failed;
+}
+
 }
 
-void
-Test::testHopParser()
+class RouteParserTest : public testing::Test {
+protected:
+    RouteParserTest();
+    ~RouteParserTest() override;
+};
+
+RouteParserTest::RouteParserTest() = default;
+RouteParserTest::~RouteParserTest() = default;
+
+TEST_F(RouteParserTest, test_hop_parser)
 {
     {
         Hop hop = Hop::parse("foo");
-        EXPECT_EQUAL(1u, hop.getNumDirectives());
+        EXPECT_EQ(1u, hop.getNumDirectives());
         EXPECT_TRUE(testVerbatimDirective(hop.getDirective(0), "foo"));
     }
     {
         Hop hop = Hop::parse("foo/bar");
-        EXPECT_EQUAL(2u, hop.getNumDirectives());
+        EXPECT_EQ(2u, hop.getNumDirectives());
         EXPECT_TRUE(testVerbatimDirective(hop.getDirective(0), "foo"));
         EXPECT_TRUE(testVerbatimDirective(hop.getDirective(1), "bar"));
     }
     {
         Hop hop = Hop::parse("tcp/foo:666/bar");
-        EXPECT_EQUAL(1u, hop.getNumDirectives());
+        EXPECT_EQ(1u, hop.getNumDirectives());
         EXPECT_TRUE(testTcpDirective(hop.getDirective(0), "foo", 666, "bar"));
     }
     {
         Hop hop = Hop::parse("route:foo");
-        EXPECT_EQUAL(1u, hop.getNumDirectives());
+        EXPECT_EQ(1u, hop.getNumDirectives());
         EXPECT_TRUE(testRouteDirective(hop.getDirective(0), "foo"));
     }
     {
         Hop hop = Hop::parse("[Extern:tcp/localhost:3619;foo/bar]");
-        EXPECT_EQUAL(1u, hop.getNumDirectives());
+        EXPECT_EQ(1u, hop.getNumDirectives());
         EXPECT_TRUE(testPolicyDirective(hop.getDirective(0), "Extern", "tcp/localhost:3619;foo/bar"));
     }
     {
         Hop hop = Hop::parse("[AND:foo bar]");
-        EXPECT_EQUAL(1u, hop.getNumDirectives());
+        EXPECT_EQ(1u, hop.getNumDirectives());
         EXPECT_TRUE(testPolicyDirective(hop.getDirective(0), "AND", "foo bar"));
     }
     {
@@ -188,7 +174,7 @@ Test::testHopParser()
                              "route[1].selector \"other\"\n"
                              "route[1].feed \"myfeed\"\n"
                              "]");
-        EXPECT_EQUAL(1u, hop.getNumDirectives());
+        EXPECT_EQ(1u, hop.getNumDirectives());
         EXPECT_TRUE(testPolicyDirective(hop.getDirective(0), "DocumentRouteSelector",
                                        "raw:route[2]\n"
                                        "route[0].name \"foo\"\n"
@@ -204,7 +190,7 @@ Test::testHopParser()
                              "route[0].selector \"testdoc\"\n"
                              "route[0].feed \"myfeed\"\n"
                              "]");
-        EXPECT_EQUAL(1u, hop.getNumDirectives());
+        EXPECT_EQ(1u, hop.getNumDirectives());
         EXPECT_TRUE(testPolicyDirective(hop.getDirective(0), "DocumentRouteSelector",
                                        "raw:route[1]\n"
                                        "route[0].name \"docproc/cluster.foo\"\n"
@@ -213,8 +199,7 @@ Test::testHopParser()
     }
 }
 
-void
-Test::testHopParserErrors()
+TEST_F(RouteParserTest, test_hop_parser_errors)
 {
     EXPECT_TRUE(testError(Hop::parse(""), "Failed to parse empty string."));
     EXPECT_TRUE(testError(Hop::parse("[foo"), "Unexpected token '': syntax error"));
@@ -222,44 +207,44 @@ Test::testHopParserErrors()
     EXPECT_TRUE(testError(Hop::parse("foo bar"), "Failed to completely parse 'foo bar'."));
 }
 
-void
-Test::testRouteParser()
+TEST_F(RouteParserTest, test_route_parser)
 {
     {
         Route route = Route::parse("foo bar/baz");
-        EXPECT_EQUAL(2u, route.getNumHops());
+        EXPECT_EQ(2u, route.getNumHops());
         {
             const Hop &hop = route.getHop(0);
-            EXPECT_EQUAL(1u, hop.getNumDirectives());
+            EXPECT_EQ(1u, hop.getNumDirectives());
             EXPECT_TRUE(testVerbatimDirective(hop.getDirective(0), "foo"));
         }
         {
             const Hop &hop = route.getHop(1);
-            EXPECT_EQUAL(2u, hop.getNumDirectives());
+            EXPECT_EQ(2u, hop.getNumDirectives());
             EXPECT_TRUE(testVerbatimDirective(hop.getDirective(0), "bar"));
             EXPECT_TRUE(testVerbatimDirective(hop.getDirective(1), "baz"));
         }
     }
     {
         Route route = Route::parse("[Extern:tcp/localhost:3633;itr/session] default");
-        EXPECT_EQUAL(2u, route.getNumHops());
+        EXPECT_EQ(2u, route.getNumHops());
         {
             const Hop &hop = route.getHop(0);
-            EXPECT_EQUAL(1u, hop.getNumDirectives());
+            EXPECT_EQ(1u, hop.getNumDirectives());
             EXPECT_TRUE(testPolicyDirective(hop.getDirective(0), "Extern", "tcp/localhost:3633;itr/session"));
         }
         {
             const Hop &hop = route.getHop(1);
-            EXPECT_EQUAL(1u, hop.getNumDirectives());
+            EXPECT_EQ(1u, hop.getNumDirectives());
             EXPECT_TRUE(testVerbatimDirective(hop.getDirective(0), "default"));
         }
     }
 }
 
-void
-Test::testRouteParserErrors()
+TEST_F(RouteParserTest, test_route_parser_errors)
 {
     EXPECT_TRUE(testError(Route::parse(""), "Failed to parse empty string."));
     EXPECT_TRUE(testError(Route::parse("foo [bar"), "Unexpected token '': syntax error"));
     EXPECT_TRUE(testError(Route::parse("foo bar/[baz]]"), "Unexpected token ']': syntax error"));
 }
+
+GTEST_MAIN_RUN_ALL_TESTS()