diff options
| -rw-r--r-- | dependency-versions/pom.xml | 4 | ||||
| -rw-r--r-- | messagebus/src/tests/routing/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | messagebus/src/tests/routing/routing.cpp | 579 | ||||
| -rw-r--r-- | messagebus/src/tests/routingcontext/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | messagebus/src/tests/routingcontext/routingcontext.cpp | 74 | ||||
| -rw-r--r-- | messagebus/src/tests/routingspec/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | messagebus/src/tests/routingspec/routingspec.cpp | 206 | ||||
| -rw-r--r-- | messagebus/src/tests/sourcesession/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | messagebus/src/tests/sourcesession/sourcesession.cpp | 56 | ||||
| -rw-r--r-- | messagebus/src/tests/throttling/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | messagebus/src/tests/throttling/throttling.cpp | 114 | ||||
| -rw-r--r-- | messagebus/src/tests/timeout/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | messagebus/src/tests/timeout/timeout.cpp | 38 | ||||
| -rw-r--r-- | parent/pom.xml | 2 | ||||
| -rw-r--r-- | searchcore/src/tests/proton/attribute/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | searchcore/src/tests/proton/attribute/attributeflush_test.cpp | 228 |
16 files changed, 535 insertions, 773 deletions
diff --git a/dependency-versions/pom.xml b/dependency-versions/pom.xml index fcb58c3e71b..ea055e97476 100644 --- a/dependency-versions/pom.xml +++ b/dependency-versions/pom.xml @@ -33,7 +33,7 @@ <!-- DO NOT UPGRADE THESE TO A NEW MAJOR VERSION WITHOUT CHECKING FOR BINARY COMPATIBILITY --> <aopalliance.vespa.version>1.0</aopalliance.vespa.version> - <error-prone-annotations.vespa.version>2.25.0</error-prone-annotations.vespa.version> + <error-prone-annotations.vespa.version>2.26.0</error-prone-annotations.vespa.version> <guava.vespa.version>33.0.0-jre</guava.vespa.version> <guice.vespa.version>6.0.0</guice.vespa.version> <jackson2.vespa.version>2.16.2</jackson2.vespa.version> @@ -166,7 +166,7 @@ <maven-deploy-plugin.vespa.version>3.1.1</maven-deploy-plugin.vespa.version> <maven-enforcer-plugin.vespa.version>3.4.1</maven-enforcer-plugin.vespa.version> <maven-failsafe-plugin.vespa.version>3.2.5</maven-failsafe-plugin.vespa.version> - <maven-gpg-plugin.vespa.version>3.1.0</maven-gpg-plugin.vespa.version> + <maven-gpg-plugin.vespa.version>3.2.0</maven-gpg-plugin.vespa.version> <maven-install-plugin.vespa.version>3.1.1</maven-install-plugin.vespa.version> <maven-jar-plugin.vespa.version>3.3.0</maven-jar-plugin.vespa.version> <maven-javadoc-plugin.vespa.version>3.6.3</maven-javadoc-plugin.vespa.version> diff --git a/messagebus/src/tests/routing/CMakeLists.txt b/messagebus/src/tests/routing/CMakeLists.txt index 68e466ceff6..6b013f7b9cc 100644 --- a/messagebus/src/tests/routing/CMakeLists.txt +++ b/messagebus/src/tests/routing/CMakeLists.txt @@ -5,5 +5,6 @@ vespa_add_executable(messagebus_routing_test_app TEST DEPENDS messagebus_messagebus-test messagebus + GTest::gtest ) vespa_add_test(NAME messagebus_routing_test_app COMMAND messagebus_routing_test_app) diff --git a/messagebus/src/tests/routing/routing.cpp b/messagebus/src/tests/routing/routing.cpp index b459f093e4c..f37032e18e7 100644 --- a/messagebus/src/tests/routing/routing.cpp +++ b/messagebus/src/tests/routing/routing.cpp @@ -11,7 +11,7 @@ #include <vespa/messagebus/testlib/slobrok.h> #include <vespa/messagebus/testlib/testserver.h> #include <vespa/vespalib/component/vtag.h> -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/log/log.h> @@ -330,59 +330,59 @@ public: mergeFromChild, mergeError, mergeException); } - static MyPolicyFactory::SP - newSelectAndMerge(const string &select) + static MyPolicyFactory::SP + newSelectAndMerge(const string &select) { return newInstance(select, ErrorCode::NONE, false, true, ErrorCode::NONE, false); } - static MyPolicyFactory::SP - newEmptySelection() + static MyPolicyFactory::SP + newEmptySelection() { return newInstance("", ErrorCode::NONE, false, false, ErrorCode::NONE, false); } - static MyPolicyFactory::SP + static MyPolicyFactory::SP newSelectError(uint32_t errCode) { return newInstance("", errCode, false, false, ErrorCode::NONE, false); } - static MyPolicyFactory::SP - newSelectException() + static MyPolicyFactory::SP + newSelectException() { return newInstance("", ErrorCode::NONE, true, false, ErrorCode::NONE, false); } - static MyPolicyFactory::SP - newSelectAndThrow(const string &select) + static MyPolicyFactory::SP + newSelectAndThrow(const string &select) { return newInstance(select, ErrorCode::NONE, true, false, ErrorCode::NONE, false); } - static MyPolicyFactory::SP - newEmptyMerge(const string &select) + static MyPolicyFactory::SP + newEmptyMerge(const string &select) { return newInstance(select, ErrorCode::NONE, false, false, ErrorCode::NONE, false); } - static MyPolicyFactory::SP - newMergeError(const string &select, int errCode) + static MyPolicyFactory::SP + newMergeError(const string &select, int errCode) { return newInstance(select, ErrorCode::NONE, false, false, errCode, false); } - static MyPolicyFactory::SP - newMergeException(const string &select) + static MyPolicyFactory::SP + newMergeException(const string &select) { return newInstance(select, ErrorCode::NONE, false, false, ErrorCode::NONE, true); } - static MyPolicyFactory::SP + static MyPolicyFactory::SP newMergeAndThrow(const string &select) { return newInstance(select, ErrorCode::NONE, false, true, ErrorCode::NONE, true); - } + } }; MyPolicyFactory::MyPolicyFactory(const string &selectRoute, uint32_t &selectError, bool selectException, @@ -400,7 +400,7 @@ MyPolicyFactory::~MyPolicyFactory() = default; class MyPolicy : public IRoutingPolicy { private: const MyPolicyFactory &_parent; - + public: explicit MyPolicy(const MyPolicyFactory &parent) : _parent(parent) @@ -465,76 +465,6 @@ public: bool start(); }; -class Test : public vespalib::TestApp { -private: - Message::UP createMessage(const string &msg, uint32_t level = 9); - void setupRouting(TestData &data, RoutingTableSpec && spec); - void setupPolicy(TestData &data, const string &policyName, - SimpleProtocol::IPolicyFactory::SP policy); - static bool testAcknowledge(TestData &data); - bool testSend(TestData &data, const string &route, uint32_t level = 9); - bool testTrace(TestData &data, const std::vector<string> &expected); - bool testTrace(const std::vector<string> &expected, const Trace &trace); - - static const duration RECEPTOR_TIMEOUT; - -public: - int Main() override; - void testNoRoutingTable(TestData &data); - void testUnknownRoute(TestData &data); - void testNoRoute(TestData &data); - void testRecognizeHopName(TestData &data); - void testRecognizeRouteDirective(TestData &data); - void testRecognizeRouteName(TestData &data); - void testHopResolutionOverflow(TestData &data); - void testRouteResolutionOverflow(TestData &data); - void testInsertRoute(TestData &data); - void testErrorDirective(TestData &data); - void testSelectError(TestData &data); - void testSelectNone(TestData &data); - void testSelectOne(TestData &data); - void testResend1(TestData &data); - void testResend2(TestData &data); - void testNoResend(TestData &data); - void testSelectOnResend(TestData &data); - void testNoSelectOnResend(TestData &data); - void testCanConsumeError(TestData &data); - void testCantConsumeError(TestData &data); - void testNestedPolicies(TestData &data); - void testRemoveReply(TestData &data); - void testSetReply(TestData &data); - void testResendSetAndReuseReply(TestData &data); - void testResendSetAndRemoveReply(TestData &data); - void testHopIgnoresReply(TestData &data); - void testHopBlueprintIgnoresReply(TestData &data); - void testAcceptEmptyRoute(TestData &data); - void testAbortOnlyActiveNodes(TestData &data); - void testTimeout(TestData &data); - void testUnknownPolicy(TestData &data); - void testSelectException(TestData &data); - void testMergeException(TestData &data); - - void requireThatIgnoreFlagPersistsThroughHopLookup(TestData &data); - void requireThatIgnoreFlagPersistsThroughRouteLookup(TestData &data); - void requireThatIgnoreFlagPersistsThroughPolicySelect(TestData &data); - void requireThatIgnoreFlagIsSerializedWithMessage(TestData &data); - void requireThatIgnoreFlagDoesNotInterfere(TestData &data); - void requireThatEmptySelectionCanBeIgnored(TestData &data); - void requireThatSelectErrorCanBeIgnored(TestData &data); - void requireThatSelectExceptionCanBeIgnored(TestData &data); - void requireThatSelectAndThrowCanBeIgnored(TestData &data); - void requireThatEmptyMergeCanBeIgnored(TestData &data); - void requireThatMergeErrorCanBeIgnored(TestData &data); - void requireThatMergeExceptionCanBeIgnored(TestData &data); - void requireThatMergeAndThrowCanBeIgnored(TestData &data); - void requireThatAllocServiceCanBeIgnored(TestData &data); - void requireThatDepthLimitCanBeIgnored(TestData &data); -}; - -const duration Test::RECEPTOR_TIMEOUT = 120s; - -TEST_APPHOOK(Test); - TestData::TestData() : _slobrok(), _retryPolicy(std::make_shared<RetryTransientErrorsPolicy>()), @@ -577,22 +507,81 @@ TestData::start() return true; } +class RoutingTest : public testing::Test { +protected: + static const duration RECEPTOR_TIMEOUT; + static std::shared_ptr<TestData> _data; + static bool _force_teardown; + RoutingTest(); + ~RoutingTest() override; + static void SetUpTestSuite(); + static void TearDownTestSuite(); + void SetUp() override; + void TearDown() override; + static Message::UP createMessage(const string &msg, uint32_t level = 9); + static void setupRouting(TestData &data, RoutingTableSpec && spec); + static void setupPolicy(TestData &data, const string &policyName, + SimpleProtocol::IPolicyFactory::SP policy); + static bool testAcknowledge(TestData &data); + static bool testSend(TestData &data, const string &route, uint32_t level = 9); + static bool testTrace(TestData &data, const std::vector<string> &expected); + static bool testTrace(const std::vector<string> &expected, const Trace &trace); +}; + +const duration RoutingTest::RECEPTOR_TIMEOUT = 120s; +std::shared_ptr<TestData> RoutingTest::_data; +bool RoutingTest::_force_teardown = false; + +RoutingTest::RoutingTest() = default; +RoutingTest::~RoutingTest() = default; + +void +RoutingTest::SetUpTestSuite() +{ + _data = std::make_shared<TestData>(); + ASSERT_TRUE(_data->start()); +} + +void +RoutingTest::TearDownTestSuite() +{ + _data.reset(); +} + +void +RoutingTest::SetUp() +{ + if (!_data) { + _data = std::make_shared<TestData>(); + ASSERT_TRUE(_data->start()); + } +} + +void +RoutingTest::TearDown() +{ + if (_force_teardown) { + _force_teardown = false; + _data.reset(); + } +} + Message::UP -Test::createMessage(const string &msg, uint32_t level) +RoutingTest::createMessage(const string &msg, uint32_t level) { auto ret = std::make_unique<SimpleMessage>(msg); ret->getTrace().setLevel(level); return ret; } -void -Test::setupRouting(TestData &data, RoutingTableSpec && spec) +void +RoutingTest::setupRouting(TestData &data, RoutingTableSpec && spec) { data._srcServer.mb.setupRouting(RoutingSpec().addTable(std::move(spec))); } -void -Test::setupPolicy(TestData &data, const string &policyName, +void +RoutingTest::setupPolicy(TestData &data, const string &policyName, SimpleProtocol::IPolicyFactory::SP policy) { auto protocol = std::make_shared<SimpleProtocol>(); @@ -600,40 +589,45 @@ Test::setupPolicy(TestData &data, const string &policyName, data._srcServer.mb.putProtocol(protocol); } -bool -Test::testAcknowledge(TestData &data) +bool +RoutingTest::testAcknowledge(TestData &data) { Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT); - if (!EXPECT_TRUE(msg)) { + bool failed = false; + EXPECT_TRUE(msg) << (failed = true, ""); + if (failed) { return false; } data._dstSession->acknowledge(std::move(msg)); return true; } - -bool -Test::testSend(TestData &data, const string &route, uint32_t level) + +bool +RoutingTest::testSend(TestData &data, const string &route, uint32_t level) { Message::UP msg = createMessage("msg", level); msg->setRoute(Route::parse(route)); return data._srcSession->send(std::move(msg)).isAccepted(); } -bool -Test::testTrace(TestData &data, const std::vector<string> &expected) +bool +RoutingTest::testTrace(TestData &data, const std::vector<string> &expected) { Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); - if (!EXPECT_TRUE(reply)) { + bool failed = false; + EXPECT_TRUE(reply) << (failed = true, ""); + if (failed) { return false; } - if (!EXPECT_FALSE(reply->hasErrors())) { + EXPECT_FALSE(reply->hasErrors()) << (failed = true, ""); + if (failed) { return false; } return testTrace(expected, reply->getTrace()); } bool -Test::testTrace(const std::vector<string> &expected, const Trace &trace) +RoutingTest::testTrace(const std::vector<string> &expected, const Trace &trace) { const string& version = vespalib::Vtag::currentVersion.toString(); string actual = trace.toString(); @@ -646,13 +640,17 @@ Test::testTrace(const std::vector<string> &expected, const Trace &trace) } if (line[0] == '-') { string str = line.substr(1); - if (!EXPECT_TRUE(actual.find(str, pos) == string::npos)) { + bool failed = false; + EXPECT_TRUE(actual.find(str, pos) == string::npos) << (failed = true, ""); + if (failed) { LOG(error, "Line %d '%s' not expected.", i, str.c_str()); return false; } } else { pos = actual.find(line, pos); - if (!EXPECT_TRUE(pos != string::npos)) { + bool failed = false; + EXPECT_TRUE(pos != string::npos) << (failed = true, ""); + if (failed) { LOG(error, "Line %d '%s' missing.", i, line.c_str()); return false; } @@ -662,110 +660,47 @@ Test::testTrace(const std::vector<string> &expected, const Trace &trace) return true; } -int -Test::Main() -{ - TEST_INIT("routing_test"); - - TestData data; - ASSERT_TRUE(data.start()); - - testNoRoutingTable(data); TEST_FLUSH(); - testUnknownRoute(data); TEST_FLUSH(); - testNoRoute(data); TEST_FLUSH(); - testRecognizeHopName(data); TEST_FLUSH(); - testRecognizeRouteDirective(data); TEST_FLUSH(); - testRecognizeRouteName(data); TEST_FLUSH(); - testHopResolutionOverflow(data); TEST_FLUSH(); - testRouteResolutionOverflow(data); TEST_FLUSH(); - testInsertRoute(data); TEST_FLUSH(); - testErrorDirective(data); TEST_FLUSH(); - testSelectError(data); TEST_FLUSH(); - testSelectNone(data); TEST_FLUSH(); - testSelectOne(data); TEST_FLUSH(); - testResend1(data); TEST_FLUSH(); - testResend2(data); TEST_FLUSH(); - testNoResend(data); TEST_FLUSH(); - testSelectOnResend(data); TEST_FLUSH(); - testNoSelectOnResend(data); TEST_FLUSH(); - testCanConsumeError(data); TEST_FLUSH(); - testCantConsumeError(data); TEST_FLUSH(); - testNestedPolicies(data); TEST_FLUSH(); - testRemoveReply(data); TEST_FLUSH(); - testSetReply(data); TEST_FLUSH(); - testResendSetAndReuseReply(data); TEST_FLUSH(); - testResendSetAndRemoveReply(data); TEST_FLUSH(); - testHopIgnoresReply(data); TEST_FLUSH(); - testHopBlueprintIgnoresReply(data); TEST_FLUSH(); - testAcceptEmptyRoute(data); TEST_FLUSH(); - testAbortOnlyActiveNodes(data); TEST_FLUSH(); - testUnknownPolicy(data); TEST_FLUSH(); - testSelectException(data); TEST_FLUSH(); - testMergeException(data); TEST_FLUSH(); - - requireThatIgnoreFlagPersistsThroughHopLookup(data); TEST_FLUSH(); - requireThatIgnoreFlagPersistsThroughRouteLookup(data); TEST_FLUSH(); - requireThatIgnoreFlagPersistsThroughPolicySelect(data); TEST_FLUSH(); - requireThatIgnoreFlagIsSerializedWithMessage(data); TEST_FLUSH(); - requireThatIgnoreFlagDoesNotInterfere(data); TEST_FLUSH(); - requireThatEmptySelectionCanBeIgnored(data); TEST_FLUSH(); - requireThatSelectErrorCanBeIgnored(data); TEST_FLUSH(); - requireThatSelectExceptionCanBeIgnored(data); TEST_FLUSH(); - requireThatSelectAndThrowCanBeIgnored(data); TEST_FLUSH(); - requireThatEmptyMergeCanBeIgnored(data); TEST_FLUSH(); - requireThatMergeErrorCanBeIgnored(data); TEST_FLUSH(); - requireThatMergeExceptionCanBeIgnored(data); TEST_FLUSH(); - requireThatMergeAndThrowCanBeIgnored(data); TEST_FLUSH(); - requireThatAllocServiceCanBeIgnored(data); TEST_FLUSH(); - requireThatDepthLimitCanBeIgnored(data); TEST_FLUSH(); - - // This needs to be last because it changes timeouts: - testTimeout(data); TEST_FLUSH(); - - TEST_DONE(); -} - //////////////////////////////////////////////////////////////////////////////// // // Tests // //////////////////////////////////////////////////////////////////////////////// -void -Test::testNoRoutingTable(TestData &data) +TEST_F(RoutingTest, test_no_routing_table) { + auto& data = *_data; Result res = data._srcSession->send(createMessage("msg"), "foo"); EXPECT_FALSE(res.isAccepted()); - EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode()); + EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode()); Message::UP msg = res.getMessage(); EXPECT_TRUE(msg); } -void -Test::testUnknownRoute(TestData &data) +TEST_F(RoutingTest, test_unknown_route) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addHop(HopSpec("foo", "bar")))); Result res = data._srcSession->send(createMessage("msg"), "baz"); EXPECT_FALSE(res.isAccepted()); - EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode()); + EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode()); Message::UP msg = res.getMessage(); EXPECT_TRUE(msg); } -void -Test::testNoRoute(TestData &data) +TEST_F(RoutingTest, test_no_route) { + auto& data = *_data; EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route()).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); } -void -Test::testRecognizeHopName(TestData &data) +TEST_F(RoutingTest, test_recognize_hop_name) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addHop(HopSpec("dst", "dst/session")))); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst")).isAccepted()); @@ -777,9 +712,9 @@ Test::testRecognizeHopName(TestData &data) EXPECT_FALSE(reply->hasErrors()); } -void -Test::testRecognizeRouteDirective(TestData &data) +TEST_F(RoutingTest, test_recognize_route_directive) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addRoute(RouteSpec("dst").addHop("dst/session")) .addHop(HopSpec("dir", "route:dst")))); @@ -792,9 +727,9 @@ Test::testRecognizeRouteDirective(TestData &data) EXPECT_FALSE(reply->hasErrors()); } -void -Test::testRecognizeRouteName(TestData &data) +TEST_F(RoutingTest, test_recognize_route_name) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addRoute(RouteSpec("dst").addHop("dst/session")))); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst")).isAccepted()); @@ -806,64 +741,64 @@ Test::testRecognizeRouteName(TestData &data) EXPECT_FALSE(reply->hasErrors()); } -void -Test::testHopResolutionOverflow(TestData &data) +TEST_F(RoutingTest, test_hop_resolution_overflow) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addHop(HopSpec("foo", "bar")) .addHop(HopSpec("bar", "foo")))); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("foo")).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); } -void -Test::testRouteResolutionOverflow(TestData &data) +TEST_F(RoutingTest, test_route_resolution_overflow) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addRoute(RouteSpec("foo").addHop("route:foo")))); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), "foo").isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); } -void -Test::testInsertRoute(TestData &data) +TEST_F(RoutingTest, test_insert_route) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addRoute(RouteSpec("foo").addHop("dst/session").addHop("bar")))); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("route:foo baz")).isAccepted()); Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT); ASSERT_TRUE(msg); - EXPECT_EQUAL(2u, msg->getRoute().getNumHops()); - EXPECT_EQUAL("bar", msg->getRoute().getHop(0).toString()); - EXPECT_EQUAL("baz", msg->getRoute().getHop(1).toString()); + EXPECT_EQ(2u, msg->getRoute().getNumHops()); + EXPECT_EQ("bar", msg->getRoute().getHop(0).toString()); + EXPECT_EQ("baz", msg->getRoute().getHop(1).toString()); data._dstSession->acknowledge(std::move(msg)); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); EXPECT_FALSE(reply->hasErrors()); } -void -Test::testErrorDirective(TestData &data) +TEST_F(RoutingTest, test_error_directive) { + auto& data = *_data; Route route = Route::parse("foo/bar/baz"); route.getHop(0).setDirective(1, std::make_shared<ErrorDirective>("err")); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), route).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); - EXPECT_EQUAL("err", reply->getError(0).getMessage()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); + EXPECT_EQ("err", reply->getError(0).getMessage()); } -void -Test::testSelectError(TestData &data) +TEST_F(RoutingTest, test_select_error) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); @@ -872,26 +807,26 @@ Test::testSelectError(TestData &data) ASSERT_TRUE(reply); LOG(info, "testSelectError trace=%s", reply->getTrace().toString().c_str()); LOG(info, "testSelectError error=%s", reply->getError(0).toString().c_str()); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode()); } -void -Test::testSelectNone(TestData &data) +TEST_F(RoutingTest, test_select_none) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[Custom]")).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::NO_SERVICES_FOR_ROUTE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::NO_SERVICES_FOR_ROUTE, reply->getError(0).getCode()); } -void -Test::testSelectOne(TestData &data) +TEST_F(RoutingTest, test_select_one) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); @@ -904,9 +839,9 @@ Test::testSelectOne(TestData &data) EXPECT_FALSE(reply->hasErrors()); } -void -Test::testResend1(TestData &data) +TEST_F(RoutingTest, test_resend_1) { + auto& data = *_data; data._retryPolicy->setEnabled(true); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/session")).isAccepted()); Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT); @@ -935,9 +870,9 @@ Test::testResend1(TestData &data) reply->getTrace())); } -void -Test::testResend2(TestData &data) +TEST_F(RoutingTest, test_resend_2) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); @@ -1003,9 +938,9 @@ Test::testResend2(TestData &data) reply->getTrace())); } -void -Test::testNoResend(TestData &data) +TEST_F(RoutingTest, test_no_resend) { + auto& data = *_data; data._retryPolicy->setEnabled(false); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/session")).isAccepted()); Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT); @@ -1016,13 +951,13 @@ Test::testNoResend(TestData &data) data._dstSession->reply(std::move(reply)); reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::APP_TRANSIENT_ERROR, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::APP_TRANSIENT_ERROR, reply->getError(0).getCode()); } -void -Test::testSelectOnResend(TestData &data) +TEST_F(RoutingTest, test_select_on_resend) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); @@ -1051,9 +986,9 @@ Test::testSelectOnResend(TestData &data) reply->getTrace())); } -void -Test::testNoSelectOnResend(TestData &data) +TEST_F(RoutingTest, test_no_select_on_resend) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(false)); data._srcServer.mb.putProtocol(protocol); @@ -1082,9 +1017,9 @@ Test::testNoSelectOnResend(TestData &data) reply->getTrace())); } -void -Test::testCanConsumeError(TestData &data) +TEST_F(RoutingTest, test_can_consume_error) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(true, ErrorCode::NO_ADDRESS_FOR_SERVICE)); data._srcServer.mb.putProtocol(protocol); @@ -1095,8 +1030,8 @@ Test::testCanConsumeError(TestData &data) data._dstSession->acknowledge(std::move(msg)); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); EXPECT_TRUE(testTrace(StringList() .add("Selecting { 'dst/session', 'dst/unknown' }.") .add("[NO_ADDRESS_FOR_SERVICE @ localhost]") @@ -1105,9 +1040,9 @@ Test::testCanConsumeError(TestData &data) reply->getTrace())); } -void -Test::testCantConsumeError(TestData &data) +TEST_F(RoutingTest, test_cant_consume_error) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); @@ -1116,8 +1051,8 @@ Test::testCantConsumeError(TestData &data) Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); printf("%s", reply->getTrace().toString().c_str()); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); EXPECT_TRUE(testTrace(StringList() .add("Selecting { 'dst/unknown' }.") .add("[NO_ADDRESS_FOR_SERVICE @ localhost]") @@ -1125,9 +1060,9 @@ Test::testCantConsumeError(TestData &data) reply->getTrace())); } -void -Test::testNestedPolicies(TestData &data) +TEST_F(RoutingTest, test_nested_policies) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(true, ErrorCode::NO_ADDRESS_FOR_SERVICE)); data._srcServer.mb.putProtocol(protocol); @@ -1138,13 +1073,13 @@ Test::testNestedPolicies(TestData &data) data._dstSession->acknowledge(std::move(msg)); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); } -void -Test::testRemoveReply(TestData &data) +TEST_F(RoutingTest, test_remove_reply) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<RemoveReplyPolicyFactory>(true, UIntList().add(ErrorCode::NO_ADDRESS_FOR_SERVICE), 0)); data._srcServer.mb.putProtocol(protocol); @@ -1164,9 +1099,9 @@ Test::testRemoveReply(TestData &data) reply->getTrace())); } -void -Test::testSetReply(TestData &data) +TEST_F(RoutingTest, test_set_reply) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Select", std::make_shared<CustomPolicyFactory>(true, ErrorCode::APP_FATAL_ERROR)); protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(true, UIntList().add(ErrorCode::APP_FATAL_ERROR))); @@ -1178,14 +1113,14 @@ Test::testSetReply(TestData &data) data._dstSession->acknowledge(std::move(msg)); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode()); - EXPECT_EQUAL("foo", reply->getError(0).getMessage()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode()); + EXPECT_EQ("foo", reply->getError(0).getMessage()); } -void -Test::testResendSetAndReuseReply(TestData &data) +TEST_F(RoutingTest, test_resend_set_and_reuse_reply) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("ReuseReply", std::make_shared<ReuseReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_FATAL_ERROR))); protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_FATAL_ERROR))); @@ -1206,9 +1141,9 @@ Test::testResendSetAndReuseReply(TestData &data) EXPECT_FALSE(reply->hasErrors()); } -void -Test::testResendSetAndRemoveReply(TestData &data) +TEST_F(RoutingTest, test_resend_set_and_remove_reply) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("RemoveReply", std::make_shared<RemoveReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_TRANSIENT_ERROR), 0)); protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_TRANSIENT_ERROR).add(ErrorCode::APP_FATAL_ERROR))); @@ -1220,9 +1155,9 @@ Test::testResendSetAndRemoveReply(TestData &data) data._dstSession->acknowledge(std::move(msg)); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode()); - EXPECT_EQUAL("foo", reply->getError(0).getMessage()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode()); + EXPECT_EQ("foo", reply->getError(0).getMessage()); EXPECT_TRUE(testTrace(StringList() .add("Resolving '[SetReply:foo]'.") .add("Resolving 'dst/session'.") @@ -1232,9 +1167,9 @@ Test::testResendSetAndRemoveReply(TestData &data) reply->getTrace())); } -void -Test::testHopIgnoresReply(TestData &data) +TEST_F(RoutingTest, test_hop_ignores_reply) { + auto& data = *_data; EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("?dst/session")).isAccepted()); Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT); ASSERT_TRUE(msg); @@ -1250,9 +1185,9 @@ Test::testHopIgnoresReply(TestData &data) reply->getTrace())); } -void -Test::testHopBlueprintIgnoresReply(TestData &data) +TEST_F(RoutingTest, test_hop_blueprint_ignores_reply) { + auto& data = *_data; data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME) .addHop(std::move(HopSpec("foo", "dst/session").setIgnoreResult(true))))); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("foo")).isAccepted()); @@ -1270,22 +1205,22 @@ Test::testHopBlueprintIgnoresReply(TestData &data) reply->getTrace())); } -void -Test::testAcceptEmptyRoute(TestData &data) +TEST_F(RoutingTest, test_accept_empty_route) { + auto& data = *_data; EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/session")).isAccepted()); Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT); ASSERT_TRUE(msg); const Route &route = msg->getRoute(); - EXPECT_EQUAL(0u, route.getNumHops()); + EXPECT_EQ(0u, route.getNumHops()); data._dstSession->acknowledge(std::move(msg)); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); } -void -Test::testAbortOnlyActiveNodes(TestData &data) +TEST_F(RoutingTest, test_abort_only_active_nodes) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(false)); protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(false, @@ -1297,39 +1232,39 @@ Test::testAbortOnlyActiveNodes(TestData &data) EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[Custom:[SetReply:foo],?bar,dst/session]")).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(2u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode()); - EXPECT_EQUAL((uint32_t)ErrorCode::SEND_ABORTED, reply->getError(1).getCode()); + EXPECT_EQ(2u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode()); + EXPECT_EQ((uint32_t)ErrorCode::SEND_ABORTED, reply->getError(1).getCode()); } -void -Test::testUnknownPolicy(TestData &data) +TEST_F(RoutingTest, test_unknown_policy) { + auto& data = *_data; EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[Unknown]")).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::UNKNOWN_POLICY, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::UNKNOWN_POLICY, reply->getError(0).getCode()); } -void -Test::testSelectException(TestData &data) +TEST_F(RoutingTest, test_select_exception) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("SelectException", std::make_shared<SelectExceptionPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[SelectException]")).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::POLICY_ERROR, reply->getError(0).getCode()); - EXPECT_EQUAL("Policy 'SelectException' threw an exception; {test exception}", - reply->getError(0).getMessage()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::POLICY_ERROR, reply->getError(0).getCode()); + EXPECT_EQ("Policy 'SelectException' threw an exception; {test exception}", + reply->getError(0).getMessage()); } -void -Test::testMergeException(TestData &data) +TEST_F(RoutingTest, test_merge_exception) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); protocol->addPolicyFactory("MergeException", std::make_shared<MergeExceptionPolicyFactory>()); data._srcServer.mb.putProtocol(protocol); @@ -1340,157 +1275,161 @@ Test::testMergeException(TestData &data) data._dstSession->acknowledge(std::move(msg)); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::POLICY_ERROR, + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::POLICY_ERROR, reply->getError(0).getCode()); - EXPECT_EQUAL("Policy 'MergeException' threw an exception; {test exception}", - reply->getError(0).getMessage()); + EXPECT_EQ("Policy 'MergeException' threw an exception; {test exception}", + reply->getError(0).getMessage()); } -void -Test::requireThatIgnoreFlagPersistsThroughHopLookup(TestData &data) +TEST_F(RoutingTest, require_that_ignore_flag_persists_through_hop_lookup) { + auto& data = *_data; setupRouting(data, RoutingTableSpec(SimpleProtocol::NAME).addHop(HopSpec("foo", "dst/unknown"))); ASSERT_TRUE(testSend(data, "?foo")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatIgnoreFlagPersistsThroughRouteLookup(TestData &data) +TEST_F(RoutingTest, require_that_ignore_flag_persists_through_route_lookup) { + auto& data = *_data; setupRouting(data, RoutingTableSpec(SimpleProtocol::NAME).addRoute(RouteSpec("foo").addHop("dst/unknown"))); ASSERT_TRUE(testSend(data, "?foo")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatIgnoreFlagPersistsThroughPolicySelect(TestData &data) +TEST_F(RoutingTest, require_that_ignore_flag_persists_through_policy_select) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndMerge("dst/unknown")); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatIgnoreFlagIsSerializedWithMessage(TestData &data) +TEST_F(RoutingTest, require_that_ignore_flag_is_serialized_with_message) { + auto& data = *_data; ASSERT_TRUE(testSend(data, "dst/session foo ?bar")); Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT); ASSERT_TRUE(msg); Route route = msg->getRoute(); - EXPECT_EQUAL(2u, route.getNumHops()); + EXPECT_EQ(2u, route.getNumHops()); Hop hop = route.getHop(0); - EXPECT_EQUAL("foo", hop.toString()); + EXPECT_EQ("foo", hop.toString()); EXPECT_FALSE(hop.getIgnoreResult()); hop = route.getHop(1); - EXPECT_EQUAL("?bar", hop.toString()); + EXPECT_EQ("?bar", hop.toString()); EXPECT_TRUE(hop.getIgnoreResult()); data._dstSession->acknowledge(std::move(msg)); ASSERT_TRUE(testTrace(data, StringList().add("-Ignoring errors in reply."))); } -void -Test::requireThatIgnoreFlagDoesNotInterfere(TestData &data) +TEST_F(RoutingTest, require_that_ignore_flag_does_not_interfere) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndMerge("dst/session")); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testTrace(data, StringList().add("-Ignoring errors in reply."))); ASSERT_TRUE(testAcknowledge(data)); } - -void -Test::requireThatEmptySelectionCanBeIgnored(TestData &data) + +TEST_F(RoutingTest, require_that_empty_selection_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newEmptySelection()); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatSelectErrorCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_select_error_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newSelectError(ErrorCode::APP_FATAL_ERROR)); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatSelectExceptionCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_select_exception_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newSelectException()); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatSelectAndThrowCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_select_and_throw_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndThrow("dst/session")); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatEmptyMergeCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_empty_merge_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newEmptyMerge("dst/session")); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testAcknowledge(data)); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatMergeErrorCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_merge_error_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newMergeError("dst/session", ErrorCode::APP_FATAL_ERROR)); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testAcknowledge(data)); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatMergeExceptionCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_merge_exception_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newMergeException("dst/session")); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testAcknowledge(data)); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } - -void -Test::requireThatMergeAndThrowCanBeIgnored(TestData &data) + +TEST_F(RoutingTest, require_that_merge_and_throw_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newMergeAndThrow("dst/session")); ASSERT_TRUE(testSend(data, "?[Custom]")); ASSERT_TRUE(testAcknowledge(data)); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatAllocServiceCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_alloc_service_can_be_ignored) { + auto& data = *_data; ASSERT_TRUE(testSend(data, "?dst/unknown")); ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply."))); } -void -Test::requireThatDepthLimitCanBeIgnored(TestData &data) +TEST_F(RoutingTest, require_that_depth_limit_can_be_ignored) { + auto& data = *_data; setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndMerge("[Custom]")); ASSERT_TRUE(testSend(data, "?[Custom]", 0)); ASSERT_TRUE(testTrace(data, StringList())); } -void -Test::testTimeout(TestData &data) +TEST_F(RoutingTest, test_timeout) { + auto& data = *_data; + // Force teardown after this test case since timeouts have been changed. + _force_teardown = true; data._retryPolicy->setEnabled(true); data._retryPolicy->setBaseDelay(0.01); data._srcSession->setTimeout(500ms); EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/unknown")).isAccepted()); Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT); ASSERT_TRUE(reply); - EXPECT_EQUAL(2u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); - EXPECT_EQUAL((uint32_t)ErrorCode::TIMEOUT, reply->getError(1).getCode()); + EXPECT_EQ(2u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode()); + EXPECT_EQ((uint32_t)ErrorCode::TIMEOUT, reply->getError(1).getCode()); } + +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/messagebus/src/tests/routingcontext/CMakeLists.txt b/messagebus/src/tests/routingcontext/CMakeLists.txt index 96bf6dbe35e..932d0020a3e 100644 --- a/messagebus/src/tests/routingcontext/CMakeLists.txt +++ b/messagebus/src/tests/routingcontext/CMakeLists.txt @@ -5,5 +5,6 @@ vespa_add_executable(messagebus_routingcontext_test_app TEST DEPENDS messagebus_messagebus-test messagebus + GTest::gtest ) vespa_add_test(NAME messagebus_routingcontext_test_app COMMAND messagebus_routingcontext_test_app) diff --git a/messagebus/src/tests/routingcontext/routingcontext.cpp b/messagebus/src/tests/routingcontext/routingcontext.cpp index d81bada2bc6..c8bbc53a0df 100644 --- a/messagebus/src/tests/routingcontext/routingcontext.cpp +++ b/messagebus/src/tests/routingcontext/routingcontext.cpp @@ -9,7 +9,7 @@ #include <vespa/messagebus/testlib/simpleprotocol.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/vespalib/util/stringfmt.h> @@ -17,6 +17,8 @@ using namespace mbus; using vespalib::make_string; +namespace { + static const duration TIMEOUT = 120s; class StringList : public std::vector<string> { @@ -192,20 +194,6 @@ public: bool start(); }; -class Test : public vespalib::TestApp { -private: - static Message::UP createMessage(const string &msg); - -public: - int Main() override; - void testSingleDirective(TestData &data); - void testMoreDirectives(TestData &data); - void testRecipientsRemain(TestData &data); - void testConstRoute(TestData &data); -}; - -TEST_APPHOOK(Test); - TestData::TestData() : _slobrok(), _retryPolicy(std::make_shared<RetryTransientErrorsPolicy>()), @@ -240,28 +228,33 @@ TestData::start() return true; } -Message::UP -Test::createMessage(const string &msg) -{ - auto ret = std::make_unique<SimpleMessage>(msg); - ret->getTrace().setLevel(9); - return ret; } -int -Test::Main() -{ - TEST_INIT("routingcontext_test"); +class RoutingContextTest : public testing::Test { +protected: + static std::shared_ptr<TestData> _data; + RoutingContextTest(); + ~RoutingContextTest() override; + static void SetUpTestSuite(); + static void TearDownTestSuite(); +}; - TestData data; - ASSERT_TRUE(data.start()); +std::shared_ptr<TestData> RoutingContextTest::_data; - testSingleDirective(data); TEST_FLUSH(); - testMoreDirectives(data); TEST_FLUSH(); - testRecipientsRemain(data); TEST_FLUSH(); - testConstRoute(data); TEST_FLUSH(); +RoutingContextTest::RoutingContextTest() = default; +RoutingContextTest::~RoutingContextTest() = default; - TEST_DONE(); +void +RoutingContextTest::SetUpTestSuite() +{ + _data = std::make_shared<TestData>(); + ASSERT_TRUE(_data->start()); +} + +void +RoutingContextTest::TearDownTestSuite() +{ + _data.reset(); } //////////////////////////////////////////////////////////////////////////////// @@ -270,9 +263,9 @@ Test::Main() // //////////////////////////////////////////////////////////////////////////////// -void -Test::testSingleDirective(TestData &data) +TEST_F(RoutingContextTest, test_single_directive) { + auto& data = *_data; IProtocol::SP protocol(new SimpleProtocol()); auto &simple = dynamic_cast<SimpleProtocol&>(*protocol); simple.addPolicyFactory("Custom", SimpleProtocol::IPolicyFactory::SP(new CustomPolicyFactory( @@ -295,9 +288,9 @@ Test::testSingleDirective(TestData &data) } } -void -Test::testMoreDirectives(TestData &data) +TEST_F(RoutingContextTest, test_more_directives) { + auto& data = *_data; IProtocol::SP protocol(new SimpleProtocol()); auto &simple = dynamic_cast<SimpleProtocol&>(*protocol); simple.addPolicyFactory("Custom", SimpleProtocol::IPolicyFactory::SP(new CustomPolicyFactory( @@ -322,9 +315,9 @@ Test::testMoreDirectives(TestData &data) } } -void -Test::testRecipientsRemain(TestData &data) +TEST_F(RoutingContextTest, test_recipients_remain) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); auto &simple = dynamic_cast<SimpleProtocol&>(*protocol); simple.addPolicyFactory("First", std::make_shared<CustomPolicyFactory>(true, @@ -347,9 +340,9 @@ Test::testRecipientsRemain(TestData &data) } } -void -Test::testConstRoute(TestData &data) +TEST_F(RoutingContextTest, test_const_route) { + auto& data = *_data; auto protocol = std::make_shared<SimpleProtocol>(); auto &simple = dynamic_cast<SimpleProtocol&>(*protocol); simple.addPolicyFactory("DocumentRouteSelector", @@ -371,3 +364,4 @@ Test::testConstRoute(TestData &data) } } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/messagebus/src/tests/routingspec/CMakeLists.txt b/messagebus/src/tests/routingspec/CMakeLists.txt index 7a2ba9d8fe4..c7115c16fd9 100644 --- a/messagebus/src/tests/routingspec/CMakeLists.txt +++ b/messagebus/src/tests/routingspec/CMakeLists.txt @@ -5,5 +5,6 @@ vespa_add_executable(messagebus_routingspec_test_app TEST DEPENDS messagebus_messagebus-test messagebus + GTest::gtest ) vespa_add_test(NAME messagebus_routingspec_test_app COMMAND messagebus_routingspec_test_app) diff --git a/messagebus/src/tests/routingspec/routingspec.cpp b/messagebus/src/tests/routingspec/routingspec.cpp index 40f3f293de3..eec19982b8e 100644 --- a/messagebus/src/tests/routingspec/routingspec.cpp +++ b/messagebus/src/tests/routingspec/routingspec.cpp @@ -3,9 +3,9 @@ #include <vespa/messagebus/configagent.h> #include <vespa/messagebus/iconfighandler.h> #include <vespa/messagebus/routing/routingspec.h> -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/messagebus/config-messagebus.h> #include <vespa/config/helper/configgetter.hpp> +#include <vespa/vespalib/gtest/gtest.h> using namespace mbus; @@ -31,32 +31,19 @@ public: } }; -class Test : public vespalib::TestApp { -private: - bool testRouting(const RoutingSpec &spec); - bool testConfig(const RoutingSpec &spec); - -public: - void testConstructors(); - void testConfigGeneration(); - int Main() override; +class RoutingSpecTest : public testing::Test { +protected: + RoutingSpecTest(); + ~RoutingSpecTest() override; + static void test_routing_helper(const RoutingSpec &spec, bool& success); + static bool testRouting(const RoutingSpec &spec); + static bool testConfig(const RoutingSpec &spec); }; -TEST_APPHOOK(Test); - -int -Test::Main() -{ - TEST_INIT("routingspec_test"); - - testConstructors(); TEST_FLUSH(); - testConfigGeneration(); TEST_FLUSH(); - - TEST_DONE(); -} +RoutingSpecTest::RoutingSpecTest() = default; +RoutingSpecTest::~RoutingSpecTest() = default; -void -Test::testConstructors() +TEST_F(RoutingSpecTest, test_constructors) { { RoutingSpec spec; @@ -126,57 +113,64 @@ Test::testConstructors() } } +void +RoutingSpecTest::test_routing_helper(const RoutingSpec &spec, bool& success) +{ + ASSERT_TRUE(spec.getNumTables() == 2); + ASSERT_TRUE(spec.getTable(0).getProtocol() == "foo"); + ASSERT_TRUE(spec.getTable(0).getNumHops() == 2); + ASSERT_TRUE(spec.getTable(0).getHop(0).getName() == "foo-h1"); + ASSERT_TRUE(spec.getTable(0).getHop(0).getSelector() == "foo-h1-sel"); + ASSERT_TRUE(spec.getTable(0).getHop(0).getNumRecipients() == 2); + ASSERT_TRUE(spec.getTable(0).getHop(0).getRecipient(0) == "foo-h1-r1"); + ASSERT_TRUE(spec.getTable(0).getHop(0).getRecipient(1) == "foo-h1-r2"); + ASSERT_TRUE(spec.getTable(0).getHop(1).getName() == "foo-h2"); + ASSERT_TRUE(spec.getTable(0).getHop(1).getSelector() == "foo-h2-sel"); + ASSERT_TRUE(spec.getTable(0).getHop(1).getNumRecipients() == 2); + ASSERT_TRUE(spec.getTable(0).getHop(1).getRecipient(0) == "foo-h2-r1"); + ASSERT_TRUE(spec.getTable(0).getHop(1).getRecipient(1) == "foo-h2-r2"); + ASSERT_TRUE(spec.getTable(0).getNumRoutes() == 2); + ASSERT_TRUE(spec.getTable(0).getRoute(0).getName() == "foo-r1"); + ASSERT_TRUE(spec.getTable(0).getRoute(0).getNumHops() == 2); + ASSERT_TRUE(spec.getTable(0).getRoute(0).getHop(0) == "foo-h1"); + ASSERT_TRUE(spec.getTable(0).getRoute(0).getHop(1) == "foo-h2"); + ASSERT_TRUE(spec.getTable(0).getRoute(1).getName() == "foo-r2"); + ASSERT_TRUE(spec.getTable(0).getRoute(1).getNumHops() == 2); + ASSERT_TRUE(spec.getTable(0).getRoute(1).getHop(0) == "foo-h2"); + ASSERT_TRUE(spec.getTable(0).getRoute(1).getHop(1) == "foo-h1"); + ASSERT_TRUE(spec.getTable(1).getProtocol() == "bar"); + ASSERT_TRUE(spec.getTable(1).getNumHops() == 2); + ASSERT_TRUE(spec.getTable(1).getHop(0).getName() == "bar-h1"); + ASSERT_TRUE(spec.getTable(1).getHop(0).getSelector() == "bar-h1-sel"); + ASSERT_TRUE(spec.getTable(1).getHop(0).getNumRecipients() == 2); + ASSERT_TRUE(spec.getTable(1).getHop(0).getRecipient(0) == "bar-h1-r1"); + ASSERT_TRUE(spec.getTable(1).getHop(0).getRecipient(1) == "bar-h1-r2"); + ASSERT_TRUE(spec.getTable(1).getHop(1).getName() == "bar-h2"); + ASSERT_TRUE(spec.getTable(1).getHop(1).getSelector() == "bar-h2-sel"); + ASSERT_TRUE(spec.getTable(1).getHop(1).getNumRecipients() == 2); + ASSERT_TRUE(spec.getTable(1).getHop(1).getRecipient(0) == "bar-h2-r1"); + ASSERT_TRUE(spec.getTable(1).getHop(1).getRecipient(1) == "bar-h2-r2"); + ASSERT_TRUE(spec.getTable(1).getNumRoutes() == 2); + ASSERT_TRUE(spec.getTable(1).getRoute(0).getName() == "bar-r1"); + ASSERT_TRUE(spec.getTable(1).getRoute(0).getNumHops() == 2); + ASSERT_TRUE(spec.getTable(1).getRoute(0).getHop(0) == "bar-h1"); + ASSERT_TRUE(spec.getTable(1).getRoute(0).getHop(1) == "bar-h2"); + ASSERT_TRUE(spec.getTable(1).getRoute(1).getName() == "bar-r2"); + ASSERT_TRUE(spec.getTable(1).getRoute(1).getNumHops() == 2); + ASSERT_TRUE(spec.getTable(1).getRoute(1).getHop(0) == "bar-h2"); + ASSERT_TRUE(spec.getTable(1).getRoute(1).getHop(1) == "bar-h1"); + success = true; +} + bool -Test::testRouting(const RoutingSpec &spec) +RoutingSpecTest::testRouting(const RoutingSpec &spec) { - if (!ASSERT_TRUE(spec.getNumTables() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getProtocol() == "foo")) { return false; } - if (!ASSERT_TRUE(spec.getTable(0).getNumHops() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getName() == "foo-h1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getSelector() == "foo-h1-sel")) { return false; } - if (!ASSERT_TRUE(spec.getTable(0).getHop(0).getNumRecipients() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getRecipient(0) == "foo-h1-r1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getRecipient(1) == "foo-h1-r2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getName() == "foo-h2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getSelector() == "foo-h2-sel")) { return false; } - if (!ASSERT_TRUE(spec.getTable(0).getHop(1).getNumRecipients() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getRecipient(0) == "foo-h2-r1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getRecipient(1) == "foo-h2-r2")) { return false; } - if (!ASSERT_TRUE(spec.getTable(0).getNumRoutes() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getRoute(0).getName() == "foo-r1")) { return false; } - if (!ASSERT_TRUE(spec.getTable(0).getRoute(0).getNumHops() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getRoute(0).getHop(0) == "foo-h1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getRoute(0).getHop(1) == "foo-h2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getRoute(1).getName() == "foo-r2")) { return false; } - if (!ASSERT_TRUE(spec.getTable(0).getRoute(1).getNumHops() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getRoute(1).getHop(0) == "foo-h2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(0).getRoute(1).getHop(1) == "foo-h1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getProtocol() == "bar")) { return false; } - if (!ASSERT_TRUE(spec.getTable(1).getNumHops() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getName() == "bar-h1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getSelector() == "bar-h1-sel")) { return false; } - if (!ASSERT_TRUE(spec.getTable(1).getHop(0).getNumRecipients() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getRecipient(0) == "bar-h1-r1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getRecipient(1) == "bar-h1-r2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getName() == "bar-h2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getSelector() == "bar-h2-sel")) { return false; } - if (!ASSERT_TRUE(spec.getTable(1).getHop(1).getNumRecipients() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getRecipient(0) == "bar-h2-r1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getRecipient(1) == "bar-h2-r2")) { return false; } - if (!ASSERT_TRUE(spec.getTable(1).getNumRoutes() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getRoute(0).getName() == "bar-r1")) { return false; } - if (!ASSERT_TRUE(spec.getTable(1).getRoute(0).getNumHops() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getRoute(0).getHop(0) == "bar-h1")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getRoute(0).getHop(1) == "bar-h2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getRoute(1).getName() == "bar-r2")) { return false; } - if (!ASSERT_TRUE(spec.getTable(1).getRoute(1).getNumHops() == 2)) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getRoute(1).getHop(0) == "bar-h2")) { return false; } - if (!EXPECT_TRUE(spec.getTable(1).getRoute(1).getHop(1) == "bar-h1")) { return false; } - return true; + bool success = false; + test_routing_helper(spec, success); + return success; } -void -Test::testConfigGeneration() +TEST_F(RoutingSpecTest, test_config_generation) { EXPECT_TRUE(testConfig(RoutingSpec())); EXPECT_TRUE(testConfig(RoutingSpec().addTable(RoutingTableSpec("mytable1")))); @@ -200,50 +194,52 @@ Test::testConfigGeneration() .addRoute(RouteSpec("myroute12").addHop("myhop1").addHop("myhop2"))) .addTable(RoutingTableSpec("mytable2")))); - EXPECT_EQUAL("routingtable[2]\n" - "routingtable[0].protocol \"mytable1\"\n" - "routingtable[1].protocol \"mytable2\"\n" - "routingtable[1].hop[3]\n" - "routingtable[1].hop[0].name \"myhop1\"\n" - "routingtable[1].hop[0].selector \"myselector1\"\n" - "routingtable[1].hop[1].name \"myhop2\"\n" - "routingtable[1].hop[1].selector \"myselector2\"\n" - "routingtable[1].hop[1].ignoreresult true\n" - "routingtable[1].hop[2].name \"myhop1\"\n" - "routingtable[1].hop[2].selector \"myselector3\"\n" - "routingtable[1].hop[2].recipient[2]\n" - "routingtable[1].hop[2].recipient[0] \"myrecipient1\"\n" - "routingtable[1].hop[2].recipient[1] \"myrecipient2\"\n" - "routingtable[1].route[1]\n" - "routingtable[1].route[0].name \"myroute1\"\n" - "routingtable[1].route[0].hop[1]\n" - "routingtable[1].route[0].hop[0] \"myhop1\"\n", - RoutingSpec() - .addTable(RoutingTableSpec("mytable1")) - .addTable(RoutingTableSpec("mytable2") - .addHop(HopSpec("myhop1", "myselector1")) - .addHop(std::move(HopSpec("myhop2", "myselector2").setIgnoreResult(true))) - .addHop(HopSpec("myhop1", "myselector3") - .addRecipient("myrecipient1") - .addRecipient("myrecipient2")) - .addRoute(RouteSpec("myroute1").addHop("myhop1"))).toString()); + EXPECT_EQ("routingtable[2]\n" + "routingtable[0].protocol \"mytable1\"\n" + "routingtable[1].protocol \"mytable2\"\n" + "routingtable[1].hop[3]\n" + "routingtable[1].hop[0].name \"myhop1\"\n" + "routingtable[1].hop[0].selector \"myselector1\"\n" + "routingtable[1].hop[1].name \"myhop2\"\n" + "routingtable[1].hop[1].selector \"myselector2\"\n" + "routingtable[1].hop[1].ignoreresult true\n" + "routingtable[1].hop[2].name \"myhop1\"\n" + "routingtable[1].hop[2].selector \"myselector3\"\n" + "routingtable[1].hop[2].recipient[2]\n" + "routingtable[1].hop[2].recipient[0] \"myrecipient1\"\n" + "routingtable[1].hop[2].recipient[1] \"myrecipient2\"\n" + "routingtable[1].route[1]\n" + "routingtable[1].route[0].name \"myroute1\"\n" + "routingtable[1].route[0].hop[1]\n" + "routingtable[1].route[0].hop[0] \"myhop1\"\n", + RoutingSpec() + .addTable(RoutingTableSpec("mytable1")) + .addTable(RoutingTableSpec("mytable2") + .addHop(HopSpec("myhop1", "myselector1")) + .addHop(std::move(HopSpec("myhop2", "myselector2").setIgnoreResult(true))) + .addHop(HopSpec("myhop1", "myselector3") + .addRecipient("myrecipient1") + .addRecipient("myrecipient2")) + .addRoute(RouteSpec("myroute1").addHop("myhop1"))).toString()); } bool -Test::testConfig(const RoutingSpec &spec) +RoutingSpecTest::testConfig(const RoutingSpec &spec) { - if (!EXPECT_TRUE(spec == spec)) { + bool failure = false; + EXPECT_TRUE(spec == spec) << (failure = true, ""); + if (failure) { return false; } - if (!EXPECT_TRUE(spec == RoutingSpec(spec))) { + EXPECT_TRUE(spec == RoutingSpec(spec)) << (failure = true, ""); + if (failure) { return false; } ConfigStore store; ConfigAgent agent(store); agent.configure(ConfigGetter<MessagebusConfig>().getConfig("", RawSpec(spec.toString()))); - if (!EXPECT_TRUE(store.getRoutingSpec() == spec)) { - return false; - } - return true; + EXPECT_TRUE(store.getRoutingSpec() == spec) << (failure = true, ""); + return !failure; } +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/messagebus/src/tests/sourcesession/CMakeLists.txt b/messagebus/src/tests/sourcesession/CMakeLists.txt index 067b281939a..6f8b14667ee 100644 --- a/messagebus/src/tests/sourcesession/CMakeLists.txt +++ b/messagebus/src/tests/sourcesession/CMakeLists.txt @@ -5,5 +5,6 @@ vespa_add_executable(messagebus_sourcesession_test_app TEST DEPENDS messagebus_messagebus-test messagebus + GTest::gtest ) vespa_add_test(NAME messagebus_sourcesession_test_app COMMAND messagebus_sourcesession_test_app) diff --git a/messagebus/src/tests/sourcesession/sourcesession.cpp b/messagebus/src/tests/sourcesession/sourcesession.cpp index 5d1a8e8ad24..d642209d816 100644 --- a/messagebus/src/tests/sourcesession/sourcesession.cpp +++ b/messagebus/src/tests/sourcesession/sourcesession.cpp @@ -15,7 +15,7 @@ #include <vespa/messagebus/testlib/simpleprotocol.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 <thread> using namespace mbus; @@ -64,21 +64,7 @@ bool waitQueueSize(RoutableQueue &queue, uint32_t size) { return false; } -class Test : public vespalib::TestApp -{ -public: - void testSequencing(); - void testResendError(); - void testResendConnDown(); - void testIllegalRoute(); - void testNoServices(); - void testBlockingClose(); - void testNonBlockingClose(); - int Main() override; -}; - -void -Test::testSequencing() +TEST(SourceSessionTest, test_sequencing) { Slobrok slobrok; TestServer src(Identity(""), getRouting(), slobrok); @@ -111,8 +97,7 @@ Test::testSequencing() ASSERT_TRUE(waitQueueSize(dstQ, 0)); } -void -Test::testResendError() +TEST(SourceSessionTest, test_resend_error) { Slobrok slobrok; auto retryPolicy = std::make_shared<RetryTransientErrorsPolicy>(); @@ -172,8 +157,7 @@ Test::testResendError() } } -void -Test::testResendConnDown() +TEST(SourceSessionTest, test_resend_conn_down) { Slobrok slobrok; auto retryPolicy = std::make_shared<RetryTransientErrorsPolicy>(); @@ -218,8 +202,7 @@ Test::testResendConnDown() fprintf(stderr, "\nTRACE DUMP:\n%s\n\n", trace.c_str()); } -void -Test::testIllegalRoute() +TEST(SourceSessionTest, test_illegal_route) { Slobrok slobrok; TestServer src(MessageBusParams() @@ -243,16 +226,15 @@ Test::testIllegalRoute() Routable::UP routable = srcQ.dequeue(); ASSERT_TRUE(routable->isReply()); Reply::UP r(dynamic_cast<Reply*>(routable.release())); - EXPECT_EQUAL(1u, r->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, r->getError(0).getCode()); + EXPECT_EQ(1u, r->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, r->getError(0).getCode()); string trace = r->getTrace().toString(); fprintf(stderr, "\nTRACE DUMP:\n%s\n\n", trace.c_str()); } } } -void -Test::testNoServices() +TEST(SourceSessionTest, test_no_services) { Slobrok slobrok; TestServer src(MessageBusParams() @@ -283,8 +265,7 @@ Test::testNoServices() } } -void -Test::testBlockingClose() +TEST(SourceSessionTest, test_blocking_close) { Slobrok slobrok; TestServer src(Identity(""), getRouting(), slobrok); @@ -304,8 +285,7 @@ Test::testBlockingClose() EXPECT_TRUE(routable->isReply()); } -void -Test::testNonBlockingClose() +TEST(SourceSessionTest, test_non_blocking_close) { Slobrok slobrok; TestServer src(Identity(""), getRouting(), slobrok); @@ -317,18 +297,4 @@ Test::testNonBlockingClose() ss->close(); // this should not hang } -int -Test::Main() -{ - TEST_INIT("sourcesession_test"); - testSequencing(); TEST_FLUSH(); - testResendError(); TEST_FLUSH(); - testResendConnDown(); TEST_FLUSH(); - testIllegalRoute(); TEST_FLUSH(); - testNoServices(); TEST_FLUSH(); - testBlockingClose(); TEST_FLUSH(); - testNonBlockingClose(); TEST_FLUSH(); - TEST_DONE(); -} - -TEST_APPHOOK(Test); +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/messagebus/src/tests/throttling/CMakeLists.txt b/messagebus/src/tests/throttling/CMakeLists.txt index 95df4c6d873..3ad0662d13b 100644 --- a/messagebus/src/tests/throttling/CMakeLists.txt +++ b/messagebus/src/tests/throttling/CMakeLists.txt @@ -5,5 +5,6 @@ vespa_add_executable(messagebus_throttling_test_app TEST DEPENDS messagebus_messagebus-test messagebus + GTest::gtest ) vespa_add_test(NAME messagebus_throttling_test_app COMMAND messagebus_throttling_test_app) diff --git a/messagebus/src/tests/throttling/throttling.cpp b/messagebus/src/tests/throttling/throttling.cpp index 73f4366e5d7..5b372334dcf 100644 --- a/messagebus/src/tests/throttling/throttling.cpp +++ b/messagebus/src/tests/throttling/throttling.cpp @@ -1,6 +1,5 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/messagebus/destinationsession.h> #include <vespa/messagebus/dynamicthrottlepolicy.h> #include <vespa/messagebus/routablequeue.h> @@ -12,6 +11,7 @@ #include <vespa/messagebus/testlib/simplemessage.h> #include <vespa/messagebus/testlib/simplereply.h> #include <vespa/messagebus/testlib/testserver.h> +#include <vespa/vespalib/gtest/gtest.h> #include <thread> using namespace mbus; @@ -65,46 +65,31 @@ bool waitPending(SourceSession& session, uint32_t size) return false; } -//////////////////////////////////////////////////////////////////////////////// -// -// Setup -// -//////////////////////////////////////////////////////////////////////////////// - -class Test : public vespalib::TestApp { -private: - uint32_t getWindowSize(DynamicThrottlePolicy &policy, DynamicTimer &timer, uint32_t maxPending); - -protected: - void testMaxPendingCount(); - void testMaxPendingSize(); - void testMinOne(); - void testDynamicWindowSize(); - void testIdleTimePeriod(); - void testMinWindowSize(); - void testMaxWindowSize(); - -public: - int Main() override; -}; - -int -Test::Main() +uint32_t +getWindowSize(DynamicThrottlePolicy &policy, DynamicTimer &timer, uint32_t maxPending) { - TEST_INIT("throttling_test"); + SimpleMessage msg("foo"); + SimpleReply reply("bar"); + reply.setContext(mbus::Context(uint64_t(1))); // To offset pending size bump in static policy - testMaxPendingCount(); TEST_FLUSH(); - testMaxPendingSize(); TEST_FLUSH(); - testMinOne(); TEST_FLUSH(); - testDynamicWindowSize(); TEST_FLUSH(); - testIdleTimePeriod(); TEST_FLUSH(); - testMinWindowSize(); TEST_FLUSH(); - testMaxWindowSize(); TEST_FLUSH(); + for (uint32_t i = 0; i < 999; ++i) { + uint32_t numPending = 0; + while (policy.canSend(msg, numPending)) { + policy.processMessage(msg); + ++numPending; + } - TEST_DONE(); -} + uint64_t tripTime = (numPending < maxPending) ? 1000 : 1000 + (numPending - maxPending) * 1000; + timer._millis += tripTime; -TEST_APPHOOK(Test); + for( ; numPending > 0 ; --numPending) { + policy.processReply(reply); + } + } + uint32_t ret = policy.getMaxPendingCount(); + fprintf(stderr, "getWindowSize() = %u\n", ret); + return ret; +} //////////////////////////////////////////////////////////////////////////////// // @@ -112,8 +97,7 @@ TEST_APPHOOK(Test); // //////////////////////////////////////////////////////////////////////////////// -void -Test::testMaxPendingCount() +TEST(ThrottlingTest, test_max_pending_count) { Slobrok slobrok; TestServer src(Identity(""), getRouting(), slobrok); @@ -165,8 +149,7 @@ Test::testMaxPendingCount() ASSERT_TRUE(waitQueueSize(dstQ, 0)); } -void -Test::testMaxPendingSize() +TEST(ThrottlingTest, test_max_pending_size) { ASSERT_TRUE(SimpleMessage("1234567890").getApproxSize() == 10); ASSERT_TRUE(SimpleMessage("123456").getApproxSize() == 6); @@ -191,8 +174,8 @@ Test::testMaxPendingSize() DestinationSession::UP ds = dst.mb.createDestinationSession("session", true, dstQ); ASSERT_TRUE(src.waitSlobrok("dst/session")); - EXPECT_EQUAL(1u, SimpleMessage("1").getApproxSize()); - EXPECT_EQUAL(2u, SimpleMessage("12").getApproxSize()); + EXPECT_EQ(1u, SimpleMessage("1").getApproxSize()); + EXPECT_EQ(2u, SimpleMessage("12").getApproxSize()); EXPECT_TRUE(ss->send(Message::UP(new SimpleMessage("1")), "dst").isAccepted()); EXPECT_TRUE(waitQueueSize(dstQ, 1)); @@ -214,8 +197,7 @@ Test::testMaxPendingSize() ASSERT_TRUE(waitQueueSize(srcQ, 3)); } -void -Test::testMinOne() +TEST(ThrottlingTest, test_min_one) { ASSERT_TRUE(SimpleMessage("1234567890").getApproxSize() == 10); ASSERT_TRUE(SimpleMessage("").getApproxSize() == 0); @@ -248,8 +230,7 @@ Test::testMinOne() } -void -Test::testDynamicWindowSize() +TEST(ThrottlingTest, test_dynamic_window_size) { auto ptr = std::make_unique<DynamicTimer>(); auto* timer = ptr.get(); @@ -274,8 +255,7 @@ Test::testDynamicWindowSize() ASSERT_TRUE(windowSize >= 90 && windowSize <= 115); } -void -Test::testIdleTimePeriod() +TEST(ThrottlingTest, test_idle_time_period) { auto ptr = std::make_unique<DynamicTimer>(); auto* timer = ptr.get(); @@ -295,15 +275,14 @@ Test::testIdleTimePeriod() timer->_millis += 60001; ASSERT_TRUE(policy.canSend(msg, 50)); - EXPECT_EQUAL(55u, policy.getMaxPendingCount()); + EXPECT_EQ(55u, policy.getMaxPendingCount()); timer->_millis += 60001; ASSERT_TRUE(policy.canSend(msg, 0)); - EXPECT_EQUAL(5u, policy.getMaxPendingCount()); + EXPECT_EQ(5u, policy.getMaxPendingCount()); } -void -Test::testMinWindowSize() +TEST(ThrottlingTest, test_min_window_size) { auto ptr = std::make_unique<DynamicTimer>(); auto* timer = ptr.get(); @@ -317,8 +296,7 @@ Test::testMinWindowSize() ASSERT_TRUE(windowSize >= 150 && windowSize <= 210); } -void -Test::testMaxWindowSize() +TEST(ThrottlingTest, test_max_window_size) { auto ptr = std::make_unique<DynamicTimer>(); auto* timer = ptr.get(); @@ -337,28 +315,4 @@ Test::testMaxWindowSize() } -uint32_t -Test::getWindowSize(DynamicThrottlePolicy &policy, DynamicTimer &timer, uint32_t maxPending) -{ - SimpleMessage msg("foo"); - SimpleReply reply("bar"); - reply.setContext(mbus::Context(uint64_t(1))); // To offset pending size bump in static policy - - for (uint32_t i = 0; i < 999; ++i) { - uint32_t numPending = 0; - while (policy.canSend(msg, numPending)) { - policy.processMessage(msg); - ++numPending; - } - - uint64_t tripTime = (numPending < maxPending) ? 1000 : 1000 + (numPending - maxPending) * 1000; - timer._millis += tripTime; - - for( ; numPending > 0 ; --numPending) { - policy.processReply(reply); - } - } - uint32_t ret = policy.getMaxPendingCount(); - fprintf(stderr, "getWindowSize() = %u\n", ret); - return ret; -} +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/messagebus/src/tests/timeout/CMakeLists.txt b/messagebus/src/tests/timeout/CMakeLists.txt index 2292b6d649f..4aa3458cb14 100644 --- a/messagebus/src/tests/timeout/CMakeLists.txt +++ b/messagebus/src/tests/timeout/CMakeLists.txt @@ -5,5 +5,6 @@ vespa_add_executable(messagebus_timeout_test_app TEST DEPENDS messagebus_messagebus-test messagebus + GTest::gtest ) vespa_add_test(NAME messagebus_timeout_test_app COMMAND messagebus_timeout_test_app) diff --git a/messagebus/src/tests/timeout/timeout.cpp b/messagebus/src/tests/timeout/timeout.cpp index 2ffdab11c40..497af9c5c0e 100644 --- a/messagebus/src/tests/timeout/timeout.cpp +++ b/messagebus/src/tests/timeout/timeout.cpp @@ -1,6 +1,5 @@ // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/vespalib/testkit/testapp.h> #include <vespa/messagebus/errorcode.h> #include <vespa/messagebus/emptyreply.h> #include <vespa/messagebus/sourcesession.h> @@ -11,33 +10,13 @@ #include <vespa/messagebus/testlib/simplemessage.h> #include <vespa/messagebus/testlib/slobrok.h> #include <vespa/messagebus/testlib/testserver.h> +#include <vespa/vespalib/gtest/gtest.h> using namespace mbus; using namespace std::chrono_literals; -class Test : public vespalib::TestApp { -public: - int Main() override; - void testZeroTimeout(); - void testMessageExpires(); -}; - -TEST_APPHOOK(Test); - -int -Test::Main() -{ - TEST_INIT("timeout_test"); - - testZeroTimeout(); TEST_FLUSH(); - testMessageExpires(); TEST_FLUSH(); - - TEST_DONE(); -} - -void -Test::testZeroTimeout() +TEST(TimeoutTest, test_zero_timeout) { Slobrok slobrok; TestServer srcServer(Identity("src"), RoutingSpec(), slobrok); @@ -53,12 +32,11 @@ Test::testZeroTimeout() Reply::UP reply = srcHandler.getReply(); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::TIMEOUT, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::TIMEOUT, reply->getError(0).getCode()); } -void -Test::testMessageExpires() +TEST(TimeoutTest, test_message_expires) { Slobrok slobrok; TestServer srcServer(Identity("src"), RoutingSpec(), slobrok); @@ -73,11 +51,13 @@ Test::testMessageExpires() Reply::UP reply = srcHandler.getReply(); ASSERT_TRUE(reply); - EXPECT_EQUAL(1u, reply->getNumErrors()); - EXPECT_EQUAL((uint32_t)ErrorCode::TIMEOUT, reply->getError(0).getCode()); + EXPECT_EQ(1u, reply->getNumErrors()); + EXPECT_EQ((uint32_t)ErrorCode::TIMEOUT, reply->getError(0).getCode()); Message::UP msg = dstHandler.getMessage(1s); if (msg) { msg->discard(); } } + +GTEST_MAIN_RUN_ALL_TESTS() diff --git a/parent/pom.xml b/parent/pom.xml index 780d05241be..cb6e4c1d433 100644 --- a/parent/pom.xml +++ b/parent/pom.xml @@ -317,7 +317,7 @@ --> <groupId>org.openrewrite.maven</groupId> <artifactId>rewrite-maven-plugin</artifactId> - <version>5.23.3</version> + <version>5.24.0</version> <configuration> <activeRecipes> <recipe>org.openrewrite.java.testing.junit5.JUnit5BestPractices</recipe> diff --git a/searchcore/src/tests/proton/attribute/CMakeLists.txt b/searchcore/src/tests/proton/attribute/CMakeLists.txt index 911268bd92a..88b30df608f 100644 --- a/searchcore/src/tests/proton/attribute/CMakeLists.txt +++ b/searchcore/src/tests/proton/attribute/CMakeLists.txt @@ -21,6 +21,7 @@ vespa_add_executable(searchcore_attributeflush_test_app TEST searchcore_attribute searchcore_flushengine searchcore_pcommon + GTest::gtest ) vespa_add_test(NAME searchcore_attributeflush_test_app COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/attributeflush_test.sh DEPENDS searchcore_attributeflush_test_app) diff --git a/searchcore/src/tests/proton/attribute/attributeflush_test.cpp b/searchcore/src/tests/proton/attribute/attributeflush_test.cpp index a621451bf3b..6969032535c 100644 --- a/searchcore/src/tests/proton/attribute/attributeflush_test.cpp +++ b/searchcore/src/tests/proton/attribute/attributeflush_test.cpp @@ -14,7 +14,7 @@ #include <vespa/searchlib/index/dummyfileheadercontext.h> #include <vespa/searchlib/test/directory_handler.h> #include <vespa/searchcommon/attribute/config.h> -#include <vespa/vespalib/testkit/testapp.h> +#include <vespa/vespalib/gtest/gtest.h> #include <vespa/vespalib/util/foreground_thread_executor.h> #include <vespa/vespalib/util/foregroundtaskexecutor.h> #include <vespa/vespalib/util/idestructorcallback.h> @@ -209,46 +209,6 @@ AVConfig getInt32ArrayConfig() return AVConfig(AVBasicType::INT32, AVCollectionType::ARRAY); } -class Test : public vespalib::TestApp -{ -private: - void - requireThatUpdaterAndFlusherCanRunConcurrently(); - - void - requireThatFlushableAttributeReportsMemoryUsage(); - - void - requireThatFlushableAttributeManagesSyncTokenInfo(); - - void - requireThatFlushTargetsCanBeRetrieved(); - - void - requireThatCleanUpIsPerformedAfterFlush(); - - void - requireThatFlushStatsAreUpdated(); - - void - requireThatOnlyOneFlusherCanRunAtTheSameTime(); - - void - requireThatLastFlushTimeIsReported(); - - void - requireThatShrinkWorks(); - - void requireThatFlushedAttributeCanBeLoaded(const HwInfo &hwInfo); - void requireThatFlushedAttributeCanBeLoaded(); - - void requireThatFlushFailurePreventsSyncTokenUpdate(); -public: - int - Main() override; -}; - - const string test_dir = "flush"; struct BaseFixture @@ -325,9 +285,7 @@ struct Fixture : public BaseFixture, public AttributeManagerFixture Fixture::~Fixture() = default; - -void -Test::requireThatUpdaterAndFlusherCanRunConcurrently() +TEST(AttributeFlushTest, require_that_updater_and_flusher_can_run_concurrently) { Fixture f; AttributeManager &am = f._m; @@ -352,14 +310,12 @@ Test::requireThatUpdaterAndFlusherCanRunConcurrently() AttributeFactory::createAttribute(baseFileName, getInt32Config()); EXPECT_TRUE(attr->load()); - EXPECT_EQUAL((uint32_t)snap.syncToken + 1, attr->getNumDocs()); + EXPECT_EQ((uint32_t)snap.syncToken + 1, attr->getNumDocs()); } } } - -void -Test::requireThatFlushableAttributeReportsMemoryUsage() +TEST(AttributeFlushTest, require_that_flushable_attribute_reports_memory_usage) { Fixture f; AttributeManager &am = f._m; @@ -368,16 +324,14 @@ Test::requireThatFlushableAttributeReportsMemoryUsage() av->commit(); IFlushTarget::SP fa = am.getFlushable("a2"); EXPECT_TRUE(av->getStatus().getAllocated() >= 100u * sizeof(int32_t)); - EXPECT_EQUAL(av->getStatus().getUsed(), - fa->getApproxMemoryGain().getBefore()+0lu); + EXPECT_EQ(av->getStatus().getUsed(), + fa->getApproxMemoryGain().getBefore()+0lu); // attributes stay in memory - EXPECT_EQUAL(fa->getApproxMemoryGain().getBefore(), - fa->getApproxMemoryGain().getAfter()); + EXPECT_EQ(fa->getApproxMemoryGain().getBefore(), + fa->getApproxMemoryGain().getAfter()); } - -void -Test::requireThatFlushableAttributeManagesSyncTokenInfo() +TEST(AttributeFlushTest, require_that_flushable_attribute_manages_sync_token_info) { Fixture f; AttributeManager &am = f._m; @@ -386,49 +340,45 @@ Test::requireThatFlushableAttributeManagesSyncTokenInfo() IFlushTarget::SP fa = am.getFlushable("a3"); IndexMetaInfo info("flush/a3"); - EXPECT_EQUAL(0u, fa->getFlushedSerialNum()); + EXPECT_EQ(0u, fa->getFlushedSerialNum()); EXPECT_TRUE(fa->initFlush(0, std::make_shared<search::FlushToken>()).get() == NULL); EXPECT_TRUE(!info.load()); av->commit(CommitParam(10)); // last sync token = 10 - EXPECT_EQUAL(0u, fa->getFlushedSerialNum()); + EXPECT_EQ(0u, fa->getFlushedSerialNum()); EXPECT_TRUE(fa->initFlush(10, std::make_shared<search::FlushToken>()).get() != NULL); fa->initFlush(10, std::make_shared<search::FlushToken>())->run(); - EXPECT_EQUAL(10u, fa->getFlushedSerialNum()); + EXPECT_EQ(10u, fa->getFlushedSerialNum()); EXPECT_TRUE(info.load()); - EXPECT_EQUAL(1u, info.snapshots().size()); + EXPECT_EQ(1u, info.snapshots().size()); EXPECT_TRUE(info.snapshots()[0].valid); - EXPECT_EQUAL(10u, info.snapshots()[0].syncToken); + EXPECT_EQ(10u, info.snapshots()[0].syncToken); av->commit(CommitParam(20)); // last sync token = 20 - EXPECT_EQUAL(10u, fa->getFlushedSerialNum()); + EXPECT_EQ(10u, fa->getFlushedSerialNum()); fa->initFlush(20, std::make_shared<search::FlushToken>())->run(); - EXPECT_EQUAL(20u, fa->getFlushedSerialNum()); + EXPECT_EQ(20u, fa->getFlushedSerialNum()); EXPECT_TRUE(info.load()); - EXPECT_EQUAL(1u, info.snapshots().size()); // snapshot 10 removed + EXPECT_EQ(1u, info.snapshots().size()); // snapshot 10 removed EXPECT_TRUE(info.snapshots()[0].valid); - EXPECT_EQUAL(20u, info.snapshots()[0].syncToken); + EXPECT_EQ(20u, info.snapshots()[0].syncToken); } - -void -Test::requireThatFlushTargetsCanBeRetrieved() +TEST(AttributeFlushTest, require_that_flush_targets_can_be_retrieved) { Fixture f; AttributeManager &am = f._m; f.addAttribute("a4"); f.addAttribute("a5"); std::vector<IFlushTarget::SP> ftl = am.getFlushTargets(); - EXPECT_EQUAL(4u, ftl.size()); - EXPECT_EQUAL(am.getFlushable("a4").get(), ftl[0].get()); - EXPECT_EQUAL(am.getShrinker("a4").get(), ftl[1].get()); - EXPECT_EQUAL(am.getFlushable("a5").get(), ftl[2].get()); - EXPECT_EQUAL(am.getShrinker("a5").get(), ftl[3].get()); + EXPECT_EQ(4u, ftl.size()); + EXPECT_EQ(am.getFlushable("a4").get(), ftl[0].get()); + EXPECT_EQ(am.getShrinker("a4").get(), ftl[1].get()); + EXPECT_EQ(am.getFlushable("a5").get(), ftl[2].get()); + EXPECT_EQ(am.getShrinker("a5").get(), ftl[3].get()); } - -void -Test::requireThatCleanUpIsPerformedAfterFlush() +TEST(AttributeFlushTest, require_that_cleanup_is_performed_after_flush) { Fixture f; AttributeVector::SP av = f.addAttribute("a6"); @@ -454,16 +404,14 @@ Test::requireThatCleanUpIsPerformedAfterFlush() fa.initFlush(30, std::make_shared<search::FlushToken>())->run(); EXPECT_TRUE(info.load()); - EXPECT_EQUAL(1u, info.snapshots().size()); // snapshots 10 & 20 removed + EXPECT_EQ(1u, info.snapshots().size()); // snapshots 10 & 20 removed EXPECT_TRUE(info.snapshots()[0].valid); - EXPECT_EQUAL(30u, info.snapshots()[0].syncToken); + EXPECT_EQ(30u, info.snapshots()[0].syncToken); EXPECT_FALSE(fs::exists(fs::path(snap10))); EXPECT_FALSE(fs::exists(fs::path(snap20))); } - -void -Test::requireThatFlushStatsAreUpdated() +TEST(AttributeFlushTest, require_that_flush_stats_are_updated) { Fixture f; AttributeManager &am = f._m; @@ -473,13 +421,11 @@ Test::requireThatFlushStatsAreUpdated() IFlushTarget::SP ft = am.getFlushable("a7"); ft->initFlush(101, std::make_shared<search::FlushToken>())->run(); FlushStats stats = ft->getLastFlushStats(); - EXPECT_EQUAL("flush/a7/snapshot-101", stats.getPath()); - EXPECT_EQUAL(8u, stats.getPathElementsToLog()); + EXPECT_EQ("flush/a7/snapshot-101", stats.getPath()); + EXPECT_EQ(8u, stats.getPathElementsToLog()); } - -void -Test::requireThatOnlyOneFlusherCanRunAtTheSameTime() +TEST(AttributeFlushTest, require_that_only_one_flusher_can_run_at_the_same_time) { Fixture f; AttributeManager &am = f._m; @@ -504,15 +450,13 @@ Test::requireThatOnlyOneFlusherCanRunAtTheSameTime() ASSERT_TRUE(info.load()); LOG(info, "Found %zu snapshots", info.snapshots().size()); for (size_t i = 0; i < info.snapshots().size(); ++i) { - EXPECT_EQUAL(true, info.snapshots()[i].valid); + EXPECT_EQ(true, info.snapshots()[i].valid); } IndexMetaInfo::Snapshot best = info.getBestSnapshot(); - EXPECT_EQUAL(true, best.valid); + EXPECT_EQ(true, best.valid); } - -void -Test::requireThatLastFlushTimeIsReported() +TEST(AttributeFlushTest, require_that_last_flush_time_is_reported) { using seconds = std::chrono::seconds; BaseFixture f; @@ -521,38 +465,36 @@ Test::requireThatLastFlushTimeIsReported() AttributeManagerFixture amf(f); AttributeManager &am = amf._m; AttributeVector::SP av = amf.addAttribute("a9"); - EXPECT_EQUAL(vespalib::system_time(), am.getFlushable("a9")->getLastFlushTime()); + EXPECT_EQ(vespalib::system_time(), am.getFlushable("a9")->getLastFlushTime()); } { // no snapshot flushed yet AttributeManagerFixture amf(f); AttributeManager &am = amf._m; AttributeVector::SP av = amf.addAttribute("a9"); IFlushTarget::SP ft = am.getFlushable("a9"); - EXPECT_EQUAL(vespalib::system_time(), ft->getLastFlushTime()); + EXPECT_EQ(vespalib::system_time(), ft->getLastFlushTime()); ft->initFlush(200, std::make_shared<search::FlushToken>())->run(); EXPECT_TRUE(FastOS_File::Stat("flush/a9/snapshot-200", &stat)); - EXPECT_EQUAL(stat._modifiedTime, ft->getLastFlushTime()); + EXPECT_EQ(stat._modifiedTime, ft->getLastFlushTime()); } { // snapshot flushed AttributeManagerFixture amf(f); AttributeManager &am = amf._m; amf.addAttribute("a9"); IFlushTarget::SP ft = am.getFlushable("a9"); - EXPECT_EQUAL(stat._modifiedTime, ft->getLastFlushTime()); + EXPECT_EQ(stat._modifiedTime, ft->getLastFlushTime()); { // updated flush time after nothing to flush std::this_thread::sleep_for(1100ms); std::chrono::seconds now = duration_cast<seconds>(vespalib::system_clock::now().time_since_epoch()); Executor::Task::UP task = ft->initFlush(200, std::make_shared<search::FlushToken>()); EXPECT_FALSE(task); - EXPECT_LESS(stat._modifiedTime, ft->getLastFlushTime()); - EXPECT_APPROX(now.count(), duration_cast<seconds>(ft->getLastFlushTime().time_since_epoch()).count(), 3); + EXPECT_LT(stat._modifiedTime, ft->getLastFlushTime()); + EXPECT_NEAR(now.count(), duration_cast<seconds>(ft->getLastFlushTime().time_since_epoch()).count(), 3); } } } - -void -Test::requireThatShrinkWorks() +TEST(AttributeFlushTest, require_that_shrink_works) { Fixture f; AttributeManager &am = f._m; @@ -562,32 +504,32 @@ Test::requireThatShrinkWorks() av->addDocs(1000 - av->getNumDocs()); av->commit(CommitParam(50)); IFlushTarget::SP ft = am.getShrinker("a10"); - EXPECT_EQUAL(ft->getApproxMemoryGain().getBefore(), - ft->getApproxMemoryGain().getAfter()); + EXPECT_EQ(ft->getApproxMemoryGain().getBefore(), + ft->getApproxMemoryGain().getAfter()); AttributeGuard::UP g = am.getAttribute("a10"); EXPECT_FALSE(av->wantShrinkLidSpace()); EXPECT_FALSE(av->canShrinkLidSpace()); - EXPECT_EQUAL(1000u, av->getNumDocs()); - EXPECT_EQUAL(1000u, av->getCommittedDocIdLimit()); + EXPECT_EQ(1000u, av->getNumDocs()); + EXPECT_EQ(1000u, av->getCommittedDocIdLimit()); av->compactLidSpace(100); EXPECT_TRUE(av->wantShrinkLidSpace()); EXPECT_FALSE(av->canShrinkLidSpace()); - EXPECT_EQUAL(1000u, av->getNumDocs()); - EXPECT_EQUAL(100u, av->getCommittedDocIdLimit()); + EXPECT_EQ(1000u, av->getNumDocs()); + EXPECT_EQ(100u, av->getCommittedDocIdLimit()); aw.heartBeat(51, IDestructorCallback::SP()); EXPECT_TRUE(av->wantShrinkLidSpace()); EXPECT_FALSE(av->canShrinkLidSpace()); - EXPECT_EQUAL(ft->getApproxMemoryGain().getBefore(), - ft->getApproxMemoryGain().getAfter()); + EXPECT_EQ(ft->getApproxMemoryGain().getBefore(), + ft->getApproxMemoryGain().getAfter()); g.reset(); aw.heartBeat(52, IDestructorCallback::SP()); EXPECT_TRUE(av->wantShrinkLidSpace()); EXPECT_TRUE(av->canShrinkLidSpace()); EXPECT_TRUE(ft->getApproxMemoryGain().getBefore() > ft->getApproxMemoryGain().getAfter()); - EXPECT_EQUAL(1000u, av->getNumDocs()); - EXPECT_EQUAL(100u, av->getCommittedDocIdLimit()); - EXPECT_EQUAL(createSerialNum - 1, ft->getFlushedSerialNum()); + EXPECT_EQ(1000u, av->getNumDocs()); + EXPECT_EQ(100u, av->getCommittedDocIdLimit()); + EXPECT_EQ(createSerialNum - 1, ft->getFlushedSerialNum()); vespalib::ThreadStackExecutor exec(1); vespalib::Executor::Task::UP task = ft->initFlush(53, std::make_shared<search::FlushToken>()); exec.execute(std::move(task)); @@ -595,15 +537,16 @@ Test::requireThatShrinkWorks() exec.shutdown(); EXPECT_FALSE(av->wantShrinkLidSpace()); EXPECT_FALSE(av->canShrinkLidSpace()); - EXPECT_EQUAL(ft->getApproxMemoryGain().getBefore(), - ft->getApproxMemoryGain().getAfter()); - EXPECT_EQUAL(100u, av->getNumDocs()); - EXPECT_EQUAL(100u, av->getCommittedDocIdLimit()); + EXPECT_EQ(ft->getApproxMemoryGain().getBefore(), + ft->getApproxMemoryGain().getAfter()); + EXPECT_EQ(100u, av->getNumDocs()); + EXPECT_EQ(100u, av->getCommittedDocIdLimit()); } void -Test::requireThatFlushedAttributeCanBeLoaded(const HwInfo &hwInfo) +require_that_flushed_attribute_can_be_loaded(const HwInfo &hwInfo, const vespalib::string& label) { + SCOPED_TRACE(label); constexpr uint32_t numDocs = 100; BaseFixture f(hwInfo); vespalib::string attrName(hwInfo.disk().slow() ? "a11slow" : "a11fast"); @@ -612,9 +555,9 @@ Test::requireThatFlushedAttributeCanBeLoaded(const HwInfo &hwInfo) AttributeManager &am = amf._m; AttributeVector::SP av = amf.addPostingAttribute(attrName); IntegerAttribute & ia = static_cast<IntegerAttribute &>(*av); - EXPECT_EQUAL(1u, av->getNumDocs()); + EXPECT_EQ(1u, av->getNumDocs()); av->addDocs(numDocs); - EXPECT_EQUAL(numDocs + 1, av->getNumDocs()); + EXPECT_EQ(numDocs + 1, av->getNumDocs()); for (uint32_t i = 0; i < numDocs; ++i) { ia.update(i + 1, i + 43); } @@ -625,61 +568,44 @@ Test::requireThatFlushedAttributeCanBeLoaded(const HwInfo &hwInfo) { AttributeManagerFixture amf(f); AttributeVector::SP av = amf.addPostingAttribute(attrName); - EXPECT_EQUAL(numDocs + 1, av->getNumDocs()); + EXPECT_EQ(numDocs + 1, av->getNumDocs()); for (uint32_t i = 0; i < numDocs; ++i) { - EXPECT_EQUAL(i + 43, av->getInt(i + 1)); + EXPECT_EQ(i + 43, av->getInt(i + 1)); } } } -void -Test::requireThatFlushedAttributeCanBeLoaded() +TEST(AttributeFlushTest, require_that_flushed_attribute_can_be_loaded) { - TEST_DO(requireThatFlushedAttributeCanBeLoaded(HwInfo(HwInfo::Disk(0, false, false), HwInfo::Memory(0), HwInfo::Cpu(0)))); - TEST_DO(requireThatFlushedAttributeCanBeLoaded(HwInfo(HwInfo::Disk(0, true, false), HwInfo::Memory(0), HwInfo::Cpu(0)))); + require_that_flushed_attribute_can_be_loaded(HwInfo(HwInfo::Disk(0, false, false), HwInfo::Memory(0), HwInfo::Cpu(0)), "fast-disk"); + require_that_flushed_attribute_can_be_loaded(HwInfo(HwInfo::Disk(0, true, false), HwInfo::Memory(0), HwInfo::Cpu(0)), "slow-disk"); } -void -Test::requireThatFlushFailurePreventsSyncTokenUpdate() +TEST(AttributeFlushTest, require_that_flush_failure_prevents_sync_token_update) { BaseFixture f; AttributeManagerFixture amf(f); auto &am = amf._m; auto av = amf.addIntArrayPostingAttribute("a12"); - EXPECT_EQUAL(1u, av->getNumDocs()); + EXPECT_EQ(1u, av->getNumDocs()); auto flush_target = am.getFlushable("a12"); - EXPECT_EQUAL(0u, flush_target->getFlushedSerialNum()); + EXPECT_EQ(0u, flush_target->getFlushedSerialNum()); auto flush_task = flush_target->initFlush(200, std::make_shared<search::FlushToken>()); // Trigger flush failure av->getEnumStoreBase()->inc_compaction_count(); flush_task->run(); - EXPECT_EQUAL(0u, flush_target->getFlushedSerialNum()); + EXPECT_EQ(0u, flush_target->getFlushedSerialNum()); +} + } int -Test::Main() +main(int argc, char* argv[]) { - TEST_INIT("attributeflush_test"); - - if (_argc > 0) { - DummyFileHeaderContext::setCreator(_argv[0]); + ::testing::InitGoogleTest(&argc, argv); + if (argc > 0) { + DummyFileHeaderContext::setCreator(argv[0]); } - fs::remove_all(fs::path(test_dir)); - TEST_DO(requireThatUpdaterAndFlusherCanRunConcurrently()); - TEST_DO(requireThatFlushableAttributeReportsMemoryUsage()); - TEST_DO(requireThatFlushableAttributeManagesSyncTokenInfo()); - TEST_DO(requireThatFlushTargetsCanBeRetrieved()); - TEST_DO(requireThatCleanUpIsPerformedAfterFlush()); - TEST_DO(requireThatFlushStatsAreUpdated()); - TEST_DO(requireThatOnlyOneFlusherCanRunAtTheSameTime()); - TEST_DO(requireThatLastFlushTimeIsReported()); - TEST_DO(requireThatShrinkWorks()); - TEST_DO(requireThatFlushedAttributeCanBeLoaded()); - TEST_DO(requireThatFlushFailurePreventsSyncTokenUpdate()); - - TEST_DONE(); + fs::remove_all(fs::path(proton::test_dir)); + return RUN_ALL_TESTS(); } - -} - -TEST_APPHOOK(proton::Test); |