Convert storageserver and visiting tests from CppUnit to GTest

1 files changed, 122 insertions, 156 deletions

diff --git a/storage/src/tests/storageserver/statemanagertest.cpp b/storage/src/tests/storageserver/statemanagertest.cpp
index cdf990fa28f..c2074c53dd7 100644
--- a/storage/src/tests/storageserver/statemanagertest.cpp
+++ b/storage/src/tests/storageserver/statemanagertest.cpp
@@ -1,6 +1,5 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <cppunit/extensions/HelperMacros.h>
 #include <vespa/metrics/metricmanager.h>
 #include <vespa/storageapi/message/bucket.h>
 #include <vespa/storageapi/message/state.h>
@@ -11,15 +10,17 @@
 #include <tests/common/testhelper.h>
 #include <tests/common/dummystoragelink.h>
 #include <vespa/vespalib/data/slime/slime.h>
+#include <vespa/vespalib/gtest/gtest.h>
 
 using storage::lib::NodeState;
 using storage::lib::NodeType;
 using storage::lib::State;
 using storage::lib::ClusterState;
+using namespace ::testing;
 
 namespace storage {
 
-struct StateManagerTest : public CppUnit::TestFixture {
+struct StateManagerTest : Test {
     std::unique_ptr<TestServiceLayerApp> _node;
     std::unique_ptr<DummyStorageLink> _upper;
     std::unique_ptr<metrics::MetricManager> _metricManager;
@@ -28,26 +29,8 @@ struct StateManagerTest : public CppUnit::TestFixture {
 
     StateManagerTest();
 
-    void setUp() override;
-    void tearDown() override;
-
-    void testSystemState();
-    void testReportedNodeState();
-    void current_cluster_state_version_is_included_in_host_info_json();
-    void can_explicitly_send_get_node_state_reply();
-    void explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request();
-    void immediate_node_state_replying_is_tracked_per_controller();
-    void activation_command_is_bounced_with_current_cluster_state_version();
-
-    CPPUNIT_TEST_SUITE(StateManagerTest);
-    CPPUNIT_TEST(testSystemState);
-    CPPUNIT_TEST(testReportedNodeState);
-    CPPUNIT_TEST(current_cluster_state_version_is_included_in_host_info_json);
-    CPPUNIT_TEST(can_explicitly_send_get_node_state_reply);
-    CPPUNIT_TEST(explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request);
-    CPPUNIT_TEST(immediate_node_state_replying_is_tracked_per_controller);
-    CPPUNIT_TEST(activation_command_is_bounced_with_current_cluster_state_version);
-    CPPUNIT_TEST_SUITE_END();
+    void SetUp() override;
+    void TearDown() override;
 
     void force_current_cluster_state_version(uint32_t version);
     void mark_reported_node_state_up();
@@ -55,52 +38,49 @@ struct StateManagerTest : public CppUnit::TestFixture {
     void assert_ok_get_node_state_reply_sent_and_clear();
     void clear_sent_replies();
     void mark_reply_observed_from_n_controllers(uint16_t n);
-};
 
-CPPUNIT_TEST_SUITE_REGISTRATION(StateManagerTest);
+    std::string get_node_info() const {
+        return _manager->getNodeInfo();
+    }
+};
 
 StateManagerTest::StateManagerTest()
     : _node(),
       _upper(),
-      _manager(0),
-      _lower(0)
+      _manager(nullptr),
+      _lower(nullptr)
 {
 }
 
 void
-StateManagerTest::setUp() {
-    try{
-        vdstestlib::DirConfig config(getStandardConfig(true));
-        _node.reset(new TestServiceLayerApp(DiskCount(1), NodeIndex(2)));
-        // Clock will increase 1 sec per call.
-        _node->getClock().setAbsoluteTimeInSeconds(1);
-        _metricManager.reset(new metrics::MetricManager);
-        _upper.reset(new DummyStorageLink());
-        _manager = new StateManager(_node->getComponentRegister(),
-                                    *_metricManager,
-                                    std::unique_ptr<HostInfo>(new HostInfo));
-        _lower = new DummyStorageLink();
-        _upper->push_back(StorageLink::UP(_manager));
-        _upper->push_back(StorageLink::UP(_lower));
-        _upper->open();
-    } catch (std::exception& e) {
-        std::cerr << "Failed to static initialize objects: " << e.what()
-                  << "\n";
-    }
+StateManagerTest::SetUp() {
+    vdstestlib::DirConfig config(getStandardConfig(true));
+    _node = std::make_unique<TestServiceLayerApp>(DiskCount(1), NodeIndex(2));
+    // Clock will increase 1 sec per call.
+    _node->getClock().setAbsoluteTimeInSeconds(1);
+    _metricManager = std::make_unique<metrics::MetricManager>();
+    _upper = std::make_unique<DummyStorageLink>();
+    _manager = new StateManager(_node->getComponentRegister(),
+                                *_metricManager,
+                                std::make_unique<HostInfo>());
+    _lower = new DummyStorageLink();
+    _upper->push_back(StorageLink::UP(_manager));
+    _upper->push_back(StorageLink::UP(_lower));
+    _upper->open();
 }
 
 void
-StateManagerTest::tearDown() {
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _lower->getNumReplies());
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _lower->getNumCommands());
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies());
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumCommands());
-    _manager = 0;
-    _lower = 0;
+StateManagerTest::TearDown() {
+    assert(_lower->getNumReplies() == 0);
+    assert(_lower->getNumCommands() == 0);
+    assert(_upper->getNumReplies() == 0);
+    assert(_upper->getNumCommands() == 0);
+    _manager = nullptr;
+    _lower = nullptr;
     _upper->close();
     _upper->flush();
-    _upper.reset(0);
-    _node.reset(0);
+    _upper.reset();
+    _node.reset();
     _metricManager.reset();
 }
 
@@ -112,107 +92,96 @@ void StateManagerTest::force_current_cluster_state_version(uint32_t version) {
 
 #define GET_ONLY_OK_REPLY(varname) \
 { \
-    CPPUNIT_ASSERT_EQUAL(size_t(1), _upper->getNumReplies()); \
-    CPPUNIT_ASSERT(_upper->getReply(0)->getType().isReply()); \
+    ASSERT_EQ(size_t(1), _upper->getNumReplies()); \
+    ASSERT_TRUE(_upper->getReply(0)->getType().isReply()); \
     varname = std::dynamic_pointer_cast<api::StorageReply>( \
                     _upper->getReply(0)); \
-    CPPUNIT_ASSERT(varname != 0); \
+    ASSERT_TRUE(varname.get() != nullptr); \
     _upper->reset(); \
-    CPPUNIT_ASSERT_EQUAL(api::ReturnCode(api::ReturnCode::OK), \
-                         varname->getResult()); \
+    ASSERT_EQ(api::ReturnCode(api::ReturnCode::OK), \
+              varname->getResult()); \
 }
 
-void
-StateManagerTest::testSystemState()
-{
+TEST_F(StateManagerTest, cluster_state) {
     std::shared_ptr<api::StorageReply> reply;
-        // Verify initial state on startup
-    ClusterState::CSP currentState = _manager->getClusterStateBundle()->getBaselineClusterState();
-    CPPUNIT_ASSERT_EQUAL(std::string("cluster:d"),
-                         currentState->toString(false));
+    // Verify initial state on startup
+    auto currentState = _manager->getClusterStateBundle()->getBaselineClusterState();
+    EXPECT_EQ("cluster:d", currentState->toString(false));
 
-    NodeState::CSP currentNodeState = _manager->getCurrentNodeState();
-    CPPUNIT_ASSERT_EQUAL(std::string("s:d"), currentNodeState->toString(false));
+    auto currentNodeState = _manager->getCurrentNodeState();
+    EXPECT_EQ("s:d", currentNodeState->toString(false));
 
     ClusterState sendState("storage:4 .2.s:m");
-    std::shared_ptr<api::SetSystemStateCommand> cmd(
-            new api::SetSystemStateCommand(sendState));
+    auto cmd = std::make_shared<api::SetSystemStateCommand>(sendState);
     _upper->sendDown(cmd);
     GET_ONLY_OK_REPLY(reply);
 
     currentState = _manager->getClusterStateBundle()->getBaselineClusterState();
-    CPPUNIT_ASSERT_EQUAL(sendState, *currentState);
+    EXPECT_EQ(sendState, *currentState);
 
     currentNodeState = _manager->getCurrentNodeState();
-    CPPUNIT_ASSERT_EQUAL(std::string("s:m"), currentNodeState->toString(false));
+    EXPECT_EQ("s:m", currentNodeState->toString(false));
 }
 
 namespace {
-    struct MyStateListener : public StateListener {
-        const NodeStateUpdater& updater;
-        lib::NodeState current;
-        std::ostringstream ost;
-
-        MyStateListener(const NodeStateUpdater& upd)
-            : updater(upd), current(*updater.getReportedNodeState()) {}
-        ~MyStateListener() { }
-
-        void handleNewState() override {
-            ost << current << " -> ";
-            current = *updater.getReportedNodeState();
-            ost << current << "\n";
-        }
-    };
+struct MyStateListener : public StateListener {
+    const NodeStateUpdater& updater;
+    lib::NodeState current;
+    std::ostringstream ost;
+
+    MyStateListener(const NodeStateUpdater& upd)
+        : updater(upd), current(*updater.getReportedNodeState()) {}
+    ~MyStateListener() override = default;
+
+    void handleNewState() override {
+        ost << current << " -> ";
+        current = *updater.getReportedNodeState();
+        ost << current << "\n";
+    }
+};
 }
 
-void
-StateManagerTest::testReportedNodeState()
-{
+TEST_F(StateManagerTest, reported_node_state) {
     std::shared_ptr<api::StorageReply> reply;
-        // Add a state listener to check that we get events.
+    // Add a state listener to check that we get events.
     MyStateListener stateListener(*_manager);
     _manager->addStateListener(stateListener);
-        // Test that initial state is initializing
-    NodeState::CSP nodeState = _manager->getReportedNodeState();
-    CPPUNIT_ASSERT_EQUAL(std::string("s:i b:58 i:0 t:1"), nodeState->toString(false));
-        // Test that it works to update the state
+    // Test that initial state is initializing
+    auto nodeState = _manager->getReportedNodeState();
+    EXPECT_EQ("s:i b:58 i:0 t:1", nodeState->toString(false));
+    // Test that it works to update the state
     {
-        NodeStateUpdater::Lock::SP lock(_manager->grabStateChangeLock());
+        auto lock = _manager->grabStateChangeLock();
         NodeState ns(*_manager->getReportedNodeState());
         ns.setState(State::UP);
         _manager->setReportedNodeState(ns);
     }
-        // And that we get the change both through state interface
+    // And that we get the change both through state interface
     nodeState = _manager->getReportedNodeState();
-    CPPUNIT_ASSERT_EQUAL(std::string("s:u b:58 t:1"),
-                         nodeState->toString(false));
-        // And get node state command (no expected state)
-    std::shared_ptr<api::GetNodeStateCommand> cmd(
-            new api::GetNodeStateCommand(lib::NodeState::UP()));
+    EXPECT_EQ("s:u b:58 t:1", nodeState->toString(false));
+    // And get node state command (no expected state)
+    auto cmd = std::make_shared<api::GetNodeStateCommand>(lib::NodeState::UP());
     _upper->sendDown(cmd);
     GET_ONLY_OK_REPLY(reply);
-    CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY,
-                         reply->getType());
-    nodeState.reset(new NodeState(
-                dynamic_cast<api::GetNodeStateReply&>(*reply).getNodeState()));
-    CPPUNIT_ASSERT_EQUAL(std::string("s:u b:58 t:1"),
-                         nodeState->toString(false));
-        // We should also get it with wrong expected state
-    cmd.reset(new api::GetNodeStateCommand(lib::NodeState::UP(new NodeState(NodeType::STORAGE, State::INITIALIZING))));
+    ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType());
+    nodeState = std::make_shared<NodeState>(
+                dynamic_cast<api::GetNodeStateReply&>(*reply).getNodeState());
+    EXPECT_EQ("s:u b:58 t:1", nodeState->toString(false));
+    // We should also get it with wrong expected state
+    cmd = std::make_shared<api::GetNodeStateCommand>(
+            std::make_unique<NodeState>(NodeType::STORAGE, State::INITIALIZING));
     _upper->sendDown(cmd);
     GET_ONLY_OK_REPLY(reply);
-    CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY,
-                         reply->getType());
-    nodeState.reset(new NodeState(
-                dynamic_cast<api::GetNodeStateReply&>(*reply).getNodeState()));
-    CPPUNIT_ASSERT_EQUAL(std::string("s:u b:58 t:1"),
-                         nodeState->toString(false));
-        // With correct wanted state we should not get response right away
-    cmd.reset(new api::GetNodeStateCommand(
-                      lib::NodeState::UP(new NodeState("s:u b:58 t:1", &NodeType::STORAGE))));
+    ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType());
+    nodeState = std::make_unique<NodeState>(
+                dynamic_cast<api::GetNodeStateReply&>(*reply).getNodeState());
+    EXPECT_EQ("s:u b:58 t:1", nodeState->toString(false));
+    // With correct wanted state we should not get response right away
+    cmd = std::make_shared<api::GetNodeStateCommand>(
+            std::make_unique<lib::NodeState>("s:u b:58 t:1", &NodeType::STORAGE));
     _upper->sendDown(cmd);
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies());
-        // But when we update state, we get the reply
+    ASSERT_EQ(size_t(0), _upper->getNumReplies());
+    // But when we update state, we get the reply
     {
         NodeStateUpdater::Lock::SP lock(_manager->grabStateChangeLock());
         NodeState ns(*_manager->getReportedNodeState());
@@ -222,16 +191,14 @@ StateManagerTest::testReportedNodeState()
     }
 
     GET_ONLY_OK_REPLY(reply);
-    CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY,
-                         reply->getType());
-    nodeState.reset(new NodeState(
-                dynamic_cast<api::GetNodeStateReply&>(*reply).getNodeState()));
-    CPPUNIT_ASSERT_EQUAL(std::string("s:s b:58 t:1 m:Stopping\\x20node"),
-                         nodeState->toString(false));
-
-        // Removing state listener, it stops getting updates
+    ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType());
+    nodeState = std::make_unique<NodeState>(
+                dynamic_cast<api::GetNodeStateReply&>(*reply).getNodeState());
+    EXPECT_EQ("s:s b:58 t:1 m:Stopping\\x20node", nodeState->toString(false));
+
+    // Removing state listener, it stops getting updates
     _manager->removeStateListener(stateListener);
-        // Do another update which listener should not get..
+    // Do another update which listener should not get..
     {
         NodeStateUpdater::Lock::SP lock(_manager->grabStateChangeLock());
         NodeState ns(*_manager->getReportedNodeState());
@@ -241,35 +208,34 @@ StateManagerTest::testReportedNodeState()
     std::string expectedEvents =
             "s:i b:58 i:0 t:1 -> s:u b:58 t:1\n"
             "s:u b:58 t:1 -> s:s b:58 t:1 m:Stopping\\x20node\n";
-    CPPUNIT_ASSERT_EQUAL(expectedEvents, stateListener.ost.str());
+    EXPECT_EQ(expectedEvents, stateListener.ost.str());
 }
 
-void StateManagerTest::current_cluster_state_version_is_included_in_host_info_json() {
+TEST_F(StateManagerTest, current_cluster_state_version_is_included_in_host_info_json) {
     force_current_cluster_state_version(123);
 
-    std::string nodeInfoString(_manager->getNodeInfo());
+    std::string nodeInfoString = get_node_info();
     vespalib::Memory goldenMemory(nodeInfoString);
     vespalib::Slime nodeInfo;
     vespalib::slime::JsonFormat::decode(nodeInfoString, nodeInfo);
     
-    vespalib::slime::Symbol lookupSymbol =
-        nodeInfo.lookup("cluster-state-version");
+    vespalib::slime::Symbol lookupSymbol = nodeInfo.lookup("cluster-state-version");
     if (lookupSymbol.undefined()) {
-        CPPUNIT_FAIL("No cluster-state-version was found in the node info");
+        FAIL() << "No cluster-state-version was found in the node info";
     }
 
     auto& cursor = nodeInfo.get();
     auto& clusterStateVersionCursor = cursor["cluster-state-version"];
     if (!clusterStateVersionCursor.valid()) {
-        CPPUNIT_FAIL("No cluster-state-version was found in the node info");
+        FAIL() << "No cluster-state-version was found in the node info";
     }
 
     if (clusterStateVersionCursor.type().getId() != vespalib::slime::LONG::ID) {
-        CPPUNIT_FAIL("No cluster-state-version was found in the node info");
+        FAIL() << "No cluster-state-version was found in the node info";
     }
 
     int version = clusterStateVersionCursor.asLong();
-    CPPUNIT_ASSERT_EQUAL(123, version);
+    EXPECT_EQ(123, version);
 }
 
 void StateManagerTest::mark_reported_node_state_up() {
@@ -286,10 +252,10 @@ void StateManagerTest::send_down_get_node_state_request(uint16_t controller_inde
 }
 
 void StateManagerTest::assert_ok_get_node_state_reply_sent_and_clear() {
-    CPPUNIT_ASSERT_EQUAL(size_t(1), _upper->getNumReplies());
+    ASSERT_EQ(1, _upper->getNumReplies());
     std::shared_ptr<api::StorageReply> reply;
     GET_ONLY_OK_REPLY(reply); // Implicitly clears messages from _upper
-    CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY, reply->getType());
+    ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType());
 }
 
 void StateManagerTest::clear_sent_replies() {
@@ -299,11 +265,11 @@ void StateManagerTest::clear_sent_replies() {
 void StateManagerTest::mark_reply_observed_from_n_controllers(uint16_t n) {
     for (uint16_t i = 0; i < n; ++i) {
         send_down_get_node_state_request(i);
-        assert_ok_get_node_state_reply_sent_and_clear();
+        ASSERT_NO_FATAL_FAILURE(assert_ok_get_node_state_reply_sent_and_clear());
     }
 }
 
-void StateManagerTest::can_explicitly_send_get_node_state_reply() {
+TEST_F(StateManagerTest, can_explicitly_send_get_node_state_reply) {
     mark_reported_node_state_up();
     // Must "pre-trigger" that a controller has already received a GetNodeState
     // reply, or an immediate reply will be sent by default when the first request
@@ -311,13 +277,13 @@ void StateManagerTest::can_explicitly_send_get_node_state_reply() {
     mark_reply_observed_from_n_controllers(1);
 
     send_down_get_node_state_request(0);
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies());
+    ASSERT_EQ(0, _upper->getNumReplies());
 
     _manager->immediately_send_get_node_state_replies();
-    assert_ok_get_node_state_reply_sent_and_clear();
+    ASSERT_NO_FATAL_FAILURE(assert_ok_get_node_state_reply_sent_and_clear());
 }
 
-void StateManagerTest::explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request() {
+TEST_F(StateManagerTest, explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request) {
     mark_reported_node_state_up();
     mark_reply_observed_from_n_controllers(1);
 
@@ -325,13 +291,13 @@ void StateManagerTest::explicit_node_state_replying_without_pending_request_imme
     _manager->immediately_send_get_node_state_replies();
 
     send_down_get_node_state_request(0);
-    assert_ok_get_node_state_reply_sent_and_clear();
+    ASSERT_NO_FATAL_FAILURE(assert_ok_get_node_state_reply_sent_and_clear());
     // Sending a new request should now _not_ immediately receive a reply
     send_down_get_node_state_request(0);
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies());
+    ASSERT_EQ(0, _upper->getNumReplies());
 }
 
-void StateManagerTest::immediate_node_state_replying_is_tracked_per_controller() {
+TEST_F(StateManagerTest, immediate_node_state_replying_is_tracked_per_controller) {
     mark_reported_node_state_up();
     mark_reply_observed_from_n_controllers(3);
 
@@ -340,17 +306,17 @@ void StateManagerTest::immediate_node_state_replying_is_tracked_per_controller()
     send_down_get_node_state_request(0);
     send_down_get_node_state_request(1);
     send_down_get_node_state_request(2);
-    CPPUNIT_ASSERT_EQUAL(size_t(3), _upper->getNumReplies());
+    ASSERT_EQ(3, _upper->getNumReplies());
     clear_sent_replies();
 
     // Sending a new request should now _not_ immediately receive a reply
     send_down_get_node_state_request(0);
     send_down_get_node_state_request(1);
     send_down_get_node_state_request(2);
-    CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies());
+    ASSERT_EQ(0, _upper->getNumReplies());
 }
 
-void StateManagerTest::activation_command_is_bounced_with_current_cluster_state_version() {
+TEST_F(StateManagerTest, activation_command_is_bounced_with_current_cluster_state_version) {
     force_current_cluster_state_version(12345);
 
     auto cmd = std::make_shared<api::ActivateClusterStateVersionCommand>(12340);
@@ -358,13 +324,13 @@ void StateManagerTest::activation_command_is_bounced_with_current_cluster_state_
     cmd->setSourceIndex(0);
     _upper->sendDown(cmd);
 
-    CPPUNIT_ASSERT_EQUAL(size_t(1), _upper->getNumReplies());
+    ASSERT_EQ(1, _upper->getNumReplies());
     std::shared_ptr<api::StorageReply> reply;
     GET_ONLY_OK_REPLY(reply); // Implicitly clears messages from _upper
-    CPPUNIT_ASSERT_EQUAL(api::MessageType::ACTIVATE_CLUSTER_STATE_VERSION_REPLY, reply->getType());
+    ASSERT_EQ(api::MessageType::ACTIVATE_CLUSTER_STATE_VERSION_REPLY, reply->getType());
     auto& activate_reply = dynamic_cast<api::ActivateClusterStateVersionReply&>(*reply);
-    CPPUNIT_ASSERT_EQUAL(uint32_t(12340), activate_reply.activateVersion());
-    CPPUNIT_ASSERT_EQUAL(uint32_t(12345), activate_reply.actualVersion());
+    EXPECT_EQ(12340, activate_reply.activateVersion());
+    EXPECT_EQ(12345, activate_reply.actualVersion());
 }
 
 } // storage