Convert BucketInfoTest from CppUnit to GTest

2 files changed, 46 insertions, 106 deletions

diff --git a/storage/src/tests/bucketdb/CMakeLists.txt b/storage/src/tests/bucketdb/CMakeLists.txt
index 714faf34de5..a349d4b4463 100644
--- a/storage/src/tests/bucketdb/CMakeLists.txt
+++ b/storage/src/tests/bucketdb/CMakeLists.txt
@@ -3,7 +3,6 @@
 # TODO: Remove test library when all tests have been migrated to gtest.
 vespa_add_library(storage_testbucketdb TEST
     SOURCES
-    bucketinfotest.cpp
     bucketmanagertest.cpp
     initializertest.cpp
     judyarraytest.cpp
@@ -16,6 +15,7 @@ vespa_add_library(storage_testbucketdb TEST
 
 vespa_add_executable(storage_bucketdb_gtest_runner_app TEST
     SOURCES
+    bucketinfotest.cpp
     gtest_runner.cpp
     DEPENDS
     storage
diff --git a/storage/src/tests/bucketdb/bucketinfotest.cpp b/storage/src/tests/bucketdb/bucketinfotest.cpp
index 0298c50866c..fe922b5d6bd 100644
--- a/storage/src/tests/bucketdb/bucketinfotest.cpp
+++ b/storage/src/tests/bucketdb/bucketinfotest.cpp
@@ -1,47 +1,13 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/vdstestlib/cppunit/macros.h>
-#include <boost/assign.hpp>
-#include <boost/random.hpp>
-#include <cppunit/extensions/HelperMacros.h>
-#include <map>
-#include <vector>
 #include <vespa/vespalib/text/stringtokenizer.h>
 #include <vespa/storage/bucketdb/bucketinfo.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <vector>
+
+using namespace ::testing;
 
-namespace storage {
-
-namespace distributor {
-
-struct BucketInfoTest : public CppUnit::TestFixture {
-    void testBucketInfoEntriesWithNewestTimestampsAreKept();
-    void testOrder();
-    void testHasInvalidCopy();
-    void testAddNodeSetsTrustedWhenConsistent();
-    void testTrustedResetWhenCopiesBecomeInconsistent();
-    void testTrustedResetWhenTrustedCopiesGoOutOfSync();
-    void testTrustedNotResetWhenNonTrustedCopiesStillOutOfSync();
-    void add_nodes_can_immediately_update_trusted_flag();
-    void add_nodes_can_defer_update_of_trusted_flag();
-    void remove_node_can_immediately_update_trusted_flag();
-    void remove_node_can_defer_update_of_trusted_flag();
-
-    CPPUNIT_TEST_SUITE(BucketInfoTest);
-    CPPUNIT_TEST(testBucketInfoEntriesWithNewestTimestampsAreKept);
-    CPPUNIT_TEST(testOrder);
-    CPPUNIT_TEST(testHasInvalidCopy);
-    CPPUNIT_TEST(testAddNodeSetsTrustedWhenConsistent);
-    CPPUNIT_TEST_IGNORED(testTrustedResetWhenCopiesBecomeInconsistent);
-    CPPUNIT_TEST(testTrustedResetWhenTrustedCopiesGoOutOfSync);
-    CPPUNIT_TEST(testTrustedNotResetWhenNonTrustedCopiesStillOutOfSync);
-    CPPUNIT_TEST(add_nodes_can_immediately_update_trusted_flag);
-    CPPUNIT_TEST(add_nodes_can_defer_update_of_trusted_flag);
-    CPPUNIT_TEST(remove_node_can_immediately_update_trusted_flag);
-    CPPUNIT_TEST(remove_node_can_defer_update_of_trusted_flag);
-    CPPUNIT_TEST_SUITE_END();
-};
-
-CPPUNIT_TEST_SUITE_REGISTRATION(BucketInfoTest);
+namespace storage::distributor {
 
 BucketInfo
 getBucketInfo(std::string nodeList, std::string order) {
@@ -83,68 +49,55 @@ nodeList(const BucketInfo& info) {
 // in the meantime from having their updates lost when we perform a batch
 // insert. This also applies for when we postpone db updates in persistence
 // message tracker until we've received a reply from all copies.
-void
-BucketInfoTest::testBucketInfoEntriesWithNewestTimestampsAreKept()
-{
+TEST(BucketInfoTest, bucket_info_entries_with_newest_timestamps_are_kept) {
     BucketInfo bi;
     std::vector<uint16_t> idealState;
     idealState.push_back(0);
 
     bi.addNode(BucketCopy(5, 0, api::BucketInfo(1,1,1)), idealState);
-    CPPUNIT_ASSERT_EQUAL(api::BucketInfo(1,1,1),
-                         bi.getNode(0)->getBucketInfo());
+    EXPECT_EQ(api::BucketInfo(1,1,1), bi.getNode(0)->getBucketInfo());
 
     bi.addNode(BucketCopy(5, 0, api::BucketInfo(2,2,2)), idealState);
-    CPPUNIT_ASSERT_EQUAL(api::BucketInfo(1,1,1),
-                         bi.getNode(0)->getBucketInfo());
+    EXPECT_EQ(api::BucketInfo(1,1,1), bi.getNode(0)->getBucketInfo());
 
     bi.addNode(BucketCopy(4, 0, api::BucketInfo(3,3,3)), idealState);
-    CPPUNIT_ASSERT_EQUAL(api::BucketInfo(1,1,1),
-                         bi.getNode(0)->getBucketInfo());
+    EXPECT_EQ(api::BucketInfo(1,1,1), bi.getNode(0)->getBucketInfo());
 
     bi.addNode(BucketCopy(7, 0, api::BucketInfo(4,4,4)), idealState);
-    CPPUNIT_ASSERT_EQUAL(api::BucketInfo(4,4,4),
-                         bi.getNode(0)->getBucketInfo());
+    EXPECT_EQ(api::BucketInfo(4,4,4), bi.getNode(0)->getBucketInfo());
 
     bi.addNode(BucketCopy(2, 1, api::BucketInfo(4,4,4)), idealState);
-    CPPUNIT_ASSERT_EQUAL(api::BucketInfo(4,4,4),
-                         bi.getNode(1)->getBucketInfo());
+    EXPECT_EQ(api::BucketInfo(4,4,4), bi.getNode(1)->getBucketInfo());
 }
 
-void
-BucketInfoTest::testOrder() {
-
-    CPPUNIT_ASSERT_EQUAL(std::string("2,0,1"), nodeList(getBucketInfo("0,1,2", "2,0,1")));
-    CPPUNIT_ASSERT_EQUAL(std::string("2,0,1"), nodeList(getBucketInfo("1,0,2", "2,0,1")));
-    CPPUNIT_ASSERT_EQUAL(std::string("1,0,2"), nodeList(getBucketInfo("1,2,0", "1")));
-    CPPUNIT_ASSERT_EQUAL(std::string("2,1,0,3,4"), nodeList(getBucketInfo("0,1,2,3,4", "2,1")));
+TEST(BucketInfoTest, node_ordering_is_preserved) {
+    EXPECT_EQ("2,0,1", nodeList(getBucketInfo("0,1,2", "2,0,1")));
+    EXPECT_EQ("2,0,1", nodeList(getBucketInfo("1,0,2", "2,0,1")));
+    EXPECT_EQ("1,0,2", nodeList(getBucketInfo("1,2,0", "1")));
+    EXPECT_EQ("2,1,0,3,4", nodeList(getBucketInfo("0,1,2,3,4", "2,1")));
 }
 
-void
-BucketInfoTest::testHasInvalidCopy()
-{
+TEST(BucketInfoTest, can_query_for_replica_with_invalid_info) {
     std::vector<uint16_t> order;
 
     BucketInfo info;
     info.addNode(BucketCopy(0, 0, api::BucketInfo(10, 100, 1000)), order);
     info.addNode(BucketCopy(0, 1, api::BucketInfo(10, 100, 1000)), order);
-    CPPUNIT_ASSERT(!info.hasInvalidCopy());
+    EXPECT_FALSE(info.hasInvalidCopy());
 
     info.addNode(BucketCopy(0, 2, api::BucketInfo()), order);
-    CPPUNIT_ASSERT(info.hasInvalidCopy());
+    EXPECT_TRUE(info.hasInvalidCopy());
 
 }
 
-void
-BucketInfoTest::testAddNodeSetsTrustedWhenConsistent()
-{
+TEST(BucketInfoTest, add_node_sets_trusted_when_consistent) {
     std::vector<uint16_t> order;
 
     {
         BucketInfo info;
         info.addNode(BucketCopy(0, 0, api::BucketInfo(0x1, 2, 144)).setTrusted(), order);
         info.addNode(BucketCopy(0, 1, api::BucketInfo(0x1, 2, 144)), order);
-        CPPUNIT_ASSERT(info.getNode(1)->trusted());
+        EXPECT_TRUE(info.getNode(1)->trusted());
     }
 
     {
@@ -155,91 +108,78 @@ BucketInfoTest::testAddNodeSetsTrustedWhenConsistent()
 
         BucketCopy copy(1, 1, api::BucketInfo(0x1, 1, 2));
         info.updateNode(copy);
-        CPPUNIT_ASSERT(info.getNode(1)->trusted());
-        CPPUNIT_ASSERT(!info.getNode(2)->trusted());
+        EXPECT_TRUE(info.getNode(1)->trusted());
+        EXPECT_FALSE(info.getNode(2)->trusted());
     }
 }
 
-void
-BucketInfoTest::testTrustedResetWhenCopiesBecomeInconsistent()
-{
-    CPPUNIT_FAIL("TODO: test this!");
-}
-
-void
-BucketInfoTest::testTrustedResetWhenTrustedCopiesGoOutOfSync()
-{
+TEST(BucketInfoTest, testTrustedResetWhenTrustedCopiesGoOutOfSync) {
     std::vector<uint16_t> order;
 
     BucketInfo info;
     info.addNode(BucketCopy(0, 0, api::BucketInfo(10, 100, 1000)).setTrusted(), order);
     info.addNode(BucketCopy(0, 1, api::BucketInfo(10, 100, 1000)), order);
-    CPPUNIT_ASSERT(info.getNode(0)->trusted());
-    CPPUNIT_ASSERT(info.getNode(1)->trusted());
+    EXPECT_TRUE(info.getNode(0)->trusted());
+    EXPECT_TRUE(info.getNode(1)->trusted());
     
     info.updateNode(BucketCopy(0, 1, api::BucketInfo(20, 200, 2000)).setTrusted());
-    CPPUNIT_ASSERT(!info.getNode(0)->trusted());
-    CPPUNIT_ASSERT(!info.getNode(1)->trusted());
+    EXPECT_FALSE(info.getNode(0)->trusted());
+    EXPECT_FALSE(info.getNode(1)->trusted());
 }
 
-void
-BucketInfoTest::testTrustedNotResetWhenNonTrustedCopiesStillOutOfSync()
-{
+TEST(BucketInfoTest, trusted_not_reset_when_non_trusted_copies_still_out_of_sync) {
     std::vector<uint16_t> order;
 
     BucketInfo info;
     info.addNode(BucketCopy(0, 0, api::BucketInfo(10, 100, 1000)).setTrusted(), order);
     info.addNode(BucketCopy(0, 1, api::BucketInfo(20, 200, 2000)), order);
     info.addNode(BucketCopy(0, 2, api::BucketInfo(30, 300, 3000)), order);
-    CPPUNIT_ASSERT(info.getNode(0)->trusted());
-    CPPUNIT_ASSERT(!info.getNode(1)->trusted());
-    CPPUNIT_ASSERT(!info.getNode(2)->trusted());
+    EXPECT_TRUE(info.getNode(0)->trusted());
+    EXPECT_FALSE(info.getNode(1)->trusted());
+    EXPECT_FALSE(info.getNode(2)->trusted());
     
     info.updateNode(BucketCopy(0, 1, api::BucketInfo(21, 201, 2001)));
 
-    CPPUNIT_ASSERT(info.getNode(0)->trusted());
-    CPPUNIT_ASSERT(!info.getNode(1)->trusted());
-    CPPUNIT_ASSERT(!info.getNode(2)->trusted());
+    EXPECT_TRUE(info.getNode(0)->trusted());
+    EXPECT_FALSE(info.getNode(1)->trusted());
+    EXPECT_FALSE(info.getNode(2)->trusted());
 }
 
-void BucketInfoTest::add_nodes_can_immediately_update_trusted_flag() {
+TEST(BucketInfoTest, add_nodes_can_immediately_update_trusted_flag) {
     BucketInfo info;
     std::vector<uint16_t> order;
     info.addNodes({BucketCopy(0, 0, api::BucketInfo(10, 100, 1000))}, order, TrustedUpdate::UPDATE);
     // Only one replica, so implicitly trusted iff trusted flag update is invoked.
-    CPPUNIT_ASSERT(info.getNode(0)->trusted());
+    EXPECT_TRUE(info.getNode(0)->trusted());
 }
 
-void BucketInfoTest::add_nodes_can_defer_update_of_trusted_flag() {
+TEST(BucketInfoTest, add_nodes_can_defer_update_of_trusted_flag) {
     BucketInfo info;
     std::vector<uint16_t> order;
     info.addNodes({BucketCopy(0, 0, api::BucketInfo(10, 100, 1000))}, order, TrustedUpdate::DEFER);
-    CPPUNIT_ASSERT(!info.getNode(0)->trusted());
+    EXPECT_FALSE(info.getNode(0)->trusted());
 }
 
-void BucketInfoTest::remove_node_can_immediately_update_trusted_flag() {
+TEST(BucketInfoTest, remove_node_can_immediately_update_trusted_flag) {
     BucketInfo info;
     std::vector<uint16_t> order;
     info.addNodes({BucketCopy(0, 0, api::BucketInfo(10, 100, 1000)),
                    BucketCopy(0, 1, api::BucketInfo(20, 200, 2000))},
                   order, TrustedUpdate::UPDATE);
-    CPPUNIT_ASSERT(!info.getNode(0)->trusted());
+    EXPECT_FALSE(info.getNode(0)->trusted());
     info.removeNode(1, TrustedUpdate::UPDATE);
     // Only one replica remaining after remove, so implicitly trusted iff trusted flag update is invoked.
-    CPPUNIT_ASSERT(info.getNode(0)->trusted());
+    EXPECT_TRUE(info.getNode(0)->trusted());
 }
 
-void BucketInfoTest::remove_node_can_defer_update_of_trusted_flag() {
+TEST(BucketInfoTest, remove_node_can_defer_update_of_trusted_flag) {
     BucketInfo info;
     std::vector<uint16_t> order;
     info.addNodes({BucketCopy(0, 0, api::BucketInfo(10, 100, 1000)),
                    BucketCopy(0, 1, api::BucketInfo(20, 200, 2000))},
                   order, TrustedUpdate::UPDATE);
     info.removeNode(1, TrustedUpdate::DEFER);
-    CPPUNIT_ASSERT(!info.getNode(0)->trusted());
-}
-
+    EXPECT_FALSE(info.getNode(0)->trusted());
 }
 
-} // storage
-
+} // storage::distributor