Convert JudyArrayTest from CppUnit to Gtest

3 files changed, 96 insertions, 166 deletions

diff --git a/storage/src/tests/bucketdb/CMakeLists.txt b/storage/src/tests/bucketdb/CMakeLists.txt
index cac79c77362..9f8fbf7cf49 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
-    judyarraytest.cpp
     judymultimaptest.cpp
     lockablemaptest.cpp
     DEPENDS
@@ -17,6 +16,7 @@ vespa_add_executable(storage_bucketdb_gtest_runner_app TEST
     bucketmanagertest.cpp
     gtest_runner.cpp
     initializertest.cpp
+    judyarraytest.cpp
     DEPENDS
     storage
     storage_testcommon
diff --git a/storage/src/tests/bucketdb/initializertest.cpp b/storage/src/tests/bucketdb/initializertest.cpp
index 509824d2168..57bb3a865d5 100644
--- a/storage/src/tests/bucketdb/initializertest.cpp
+++ b/storage/src/tests/bucketdb/initializertest.cpp
@@ -78,37 +78,36 @@ struct InitializerTest : public Test {
     void do_test_initialization(InitParams& params);
 };
 
-/** Test initializing with an empty node. */
-TEST_F(InitializerTest, testInitEmptyNode) {
+TEST_F(InitializerTest, init_with_empty_node) {
     InitParams params;
     params.docsPerDisk = 0;
     do_test_initialization(params);
 }
-/** Test initializing with some data on single disk. */
-TEST_F(InitializerTest, testInitSingleDisk) {
+
+TEST_F(InitializerTest, init_with_data_on_single_disk) {
     InitParams params;
     params.diskCount = DiskCount(1);
     do_test_initialization(params);
 }
-/** Test initializing with multiple disks. */
-TEST_F(InitializerTest, testInitMultiDisk) {
+
+TEST_F(InitializerTest, init_with_multiple_disks) {
     InitParams params;
     do_test_initialization(params);
 }
-/** Test initializing with one of the disks being bad. */
-TEST_F(InitializerTest, testInitFailingMiddleDisk) {
+
+TEST_F(InitializerTest, init_with_bad_non_last_disk) {
     InitParams params;
     params.disksDown.insert(1);
     do_test_initialization(params);
 }
-/** Test initializing with last disk being bad. */
-TEST_F(InitializerTest, testInitFailingLastDisk) {
+
+TEST_F(InitializerTest, init_with_bad_last_disk) {
     InitParams params;
     params.disksDown.insert(params.diskCount - 1);
     do_test_initialization(params);
 }
-/** Test initializing with bucket on wrong disk. */
-TEST_F(InitializerTest, testInitBucketOnWrongDisk) {
+
+TEST_F(InitializerTest, init_with_bucket_on_wrong_disk) {
     InitParams params;
     params.bucketWrongDisk = true;
     params.bucketBitsUsed = 58;
diff --git a/storage/src/tests/bucketdb/judyarraytest.cpp b/storage/src/tests/bucketdb/judyarraytest.cpp
index 07992450fbf..defa4b34b79 100644
--- a/storage/src/tests/bucketdb/judyarraytest.cpp
+++ b/storage/src/tests/bucketdb/judyarraytest.cpp
@@ -1,36 +1,20 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/storage/bucketdb/judyarray.h>
-#include <vespa/vdstestlib/cppunit/macros.h>
-#include <boost/assign.hpp>
 #include <boost/random.hpp>
-#include <cppunit/extensions/HelperMacros.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <gmock/gmock.h>
 #include <map>
 #include <vector>
 
-namespace storage {
-
-struct JudyArrayTest : public CppUnit::TestFixture {
-    void testIterating();
-    void testDualArrayFunctions();
-    void testComparing();
-    void testSize();
-    void testStress();
+using namespace ::testing;
 
-    CPPUNIT_TEST_SUITE(JudyArrayTest);
-    CPPUNIT_TEST(testIterating);
-    CPPUNIT_TEST(testDualArrayFunctions);
-    CPPUNIT_TEST(testSize);
-    CPPUNIT_TEST(testStress);
-    CPPUNIT_TEST_SUITE_END();
-};
-
-CPPUNIT_TEST_SUITE_REGISTRATION(JudyArrayTest);
+namespace storage {
 
 namespace {
-    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type> >
+    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type>>
     getJudyArrayContents(const JudyArray& array) {
-        std::vector<std::pair<JudyArray::key_type, JudyArray::data_type> > vals;
+        std::vector<std::pair<JudyArray::key_type, JudyArray::data_type>> vals;
         for (JudyArray::const_iterator it = array.begin();
              it != array.end(); ++it)
         {
@@ -40,168 +24,130 @@ namespace {
     }
 }
 
-void
-JudyArrayTest::testIterating()
-{
+TEST(JudyArrayTest, iterating) {
     JudyArray array;
-        // Test that things are sane for empty document
-    CPPUNIT_ASSERT_EQUAL(array.begin(), array.end());
-        // Add some values
-    using namespace boost::assign;
-    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type> > values
-        = map_list_of(3,2)(5,12)(15,8)(13,10)(7,6)(9,4);
+    // Test that things are sane for empty document
+    ASSERT_EQ(array.begin(), array.end());
+    // Add some values
+    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type>> values({
+        {3, 2}, {5, 12}, {15, 8}, {13, 10}, {7, 6}, {9, 4}
+    });
     for (uint32_t i=0; i<values.size(); ++i) {
         array.insert(values[i].first, values[i].second);
     }
-        // Create expected result
+    // Create expected result
     std::sort(values.begin(), values.end());
-        // Test that we can iterate through const iterator
-    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type> >
-        foundVals = getJudyArrayContents(array);
-    CPPUNIT_ASSERT_EQUAL(values, foundVals);
+    // Test that we can iterate through const iterator
+    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type>>
+    foundVals = getJudyArrayContents(array);
+    ASSERT_EQ(values, foundVals);
 
     {   // Test that we can alter through non-const iterator
         JudyArray::iterator it = array.begin();
         ++it;
         ++it;
         it.setValue(20);
-        CPPUNIT_ASSERT_EQUAL((JudyArray::key_type) 7, it.key());
-        CPPUNIT_ASSERT_EQUAL((JudyArray::data_type) 20, array[7]);
+        ASSERT_EQ((JudyArray::key_type) 7, it.key());
+        ASSERT_EQ((JudyArray::data_type) 20, array[7]);
         it.remove();
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 5,
-                             getJudyArrayContents(array).size());
-        CPPUNIT_ASSERT_EQUAL(array.end(), array.find(7));
+        ASSERT_EQ((JudyArray::size_type) 5, getJudyArrayContents(array).size());
+        ASSERT_EQ(array.end(), array.find(7));
         values.erase(values.begin() + 2);
-        CPPUNIT_ASSERT_EQUAL(values, getJudyArrayContents(array));
-            // And that we can continue iterating after removing.
+        ASSERT_EQ(values, getJudyArrayContents(array));
+        // And that we can continue iterating after removing.
         ++it;
-        CPPUNIT_ASSERT_EQUAL((JudyArray::key_type) 9, it.key());
-        CPPUNIT_ASSERT_EQUAL((JudyArray::data_type) 4, array[9]);
+        ASSERT_EQ((JudyArray::key_type) 9, it.key());
+        ASSERT_EQ((JudyArray::data_type) 4, array[9]);
     }
     {   // Test printing of iterators
         JudyArray::ConstIterator cit = array.begin();
-        CPPUNIT_ASSERT_MATCH_REGEX(
-                "^ConstIterator\\(Key: 3, Valp: 0x[0-9a-f]{1,16}, Val: 2\\)$",
-                cit.toString());
+        EXPECT_THAT(cit.toString(), MatchesRegex("^ConstIterator\\(Key: 3, Valp: 0x[0-9a-f]{1,16}, Val: 2\\)$"));
         JudyArray::Iterator it = array.end();
-        CPPUNIT_ASSERT_MATCH_REGEX(
-                "^Iterator\\(Key: 0, Valp: 0\\)$",
-                it.toString());
+        EXPECT_THAT(it.toString(), MatchesRegex("^Iterator\\(Key: 0, Valp: 0\\)$"));
     }
 }
 
-void
-JudyArrayTest::testDualArrayFunctions()
-{
+TEST(JudyArrayTest, dual_array_functions) {
     JudyArray array1;
     JudyArray array2;
-        // Add values to array1
-    using namespace boost::assign;
-    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type> > values1
-        = map_list_of(3,2)(5,12)(15,8)(13,10)(7,6)(9,4);
+    // Add values to array1
+    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type>> values1({
+        {3, 2}, {5, 12}, {15, 8}, {13, 10}, {7, 6}, {9, 4}
+    });
     for (uint32_t i=0; i<values1.size(); ++i) {
         array1.insert(values1[i].first, values1[i].second);
     }
-        // Add values to array2
-    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type> > values2
-        = map_list_of(4,5)(9,40);
+    // Add values to array2
+    std::vector<std::pair<JudyArray::key_type, JudyArray::data_type>> values2({
+        {4, 5}, {9, 40}
+    });
     for (uint32_t i=0; i<values2.size(); ++i) {
         array2.insert(values2[i].first, values2[i].second);
     }
-        // Create expected result
+    // Create expected result
     std::sort(values1.begin(), values1.end());
     std::sort(values2.begin(), values2.end());
 
-    CPPUNIT_ASSERT_EQUAL(values1, getJudyArrayContents(array1));
-    CPPUNIT_ASSERT_EQUAL(values2, getJudyArrayContents(array2));
-    CPPUNIT_ASSERT(array2 < array1);
-    CPPUNIT_ASSERT(array1 != array2);
+    EXPECT_EQ(values1, getJudyArrayContents(array1));
+    EXPECT_EQ(values2, getJudyArrayContents(array2));
+    EXPECT_LT(array2, array1);
+    EXPECT_NE(array1, array2);
     array1.swap(array2);
-    CPPUNIT_ASSERT_EQUAL(values1, getJudyArrayContents(array2));
-    CPPUNIT_ASSERT_EQUAL(values2, getJudyArrayContents(array1));
-    CPPUNIT_ASSERT(array1 < array2);
-    CPPUNIT_ASSERT(array1 != array2);
+    EXPECT_EQ(values1, getJudyArrayContents(array2));
+    EXPECT_EQ(values2, getJudyArrayContents(array1));
+    EXPECT_LT(array1, array2);
+    EXPECT_NE(array1, array2);
 
-        // Test some operators
+    // Test some operators
     JudyArray array3;
     for (uint32_t i=0; i<values1.size(); ++i) {
         array3.insert(values1[i].first, values1[i].second);
     }
-    CPPUNIT_ASSERT(array1 != array3);
-    CPPUNIT_ASSERT_EQUAL(array2, array3);
-    CPPUNIT_ASSERT(!(array2 < array3));
+    EXPECT_NE(array1, array3);
+    EXPECT_EQ(array2, array3);
+    EXPECT_FALSE(array2 < array3);
 }
 
-void
-JudyArrayTest::testSize()
-{
+TEST(JudyArrayTest, size) {
     JudyArray array;
-    CPPUNIT_ASSERT_EQUAL(array.begin(), array.end());
-    CPPUNIT_ASSERT(array.empty());
-    CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 0, array.size());
-    CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 0, array.getMemoryUsage());
+    EXPECT_EQ(array.begin(), array.end());
+    EXPECT_TRUE(array.empty());
+    EXPECT_EQ((JudyArray::size_type) 0, array.size());
+    EXPECT_EQ((JudyArray::size_type) 0, array.getMemoryUsage());
 
-        // Test each method one can insert stuff into array
+    // Test each method one can insert stuff into array
     array.insert(4, 3);
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
     array.insert(4, 7);
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
-    if (sizeof(JudyArray::size_type) == 4) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 12, array.getMemoryUsage());
-    } else if (sizeof(JudyArray::size_type) == 8) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 24, array.getMemoryUsage());
-    } else CPPUNIT_FAIL("Unknown size of type");
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ((JudyArray::size_type) 24, array.getMemoryUsage());
 
     array[6] = 8;
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
     array[6] = 10;
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
-    if (sizeof(JudyArray::size_type) == 4) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 20, array.getMemoryUsage());
-    } else if (sizeof(JudyArray::size_type) == 8) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 40, array.getMemoryUsage());
-    } else CPPUNIT_FAIL("Unknown size of type");
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ((JudyArray::size_type) 40, array.getMemoryUsage());
 
     bool preExisted;
     array.find(8, true, preExisted);
-    CPPUNIT_ASSERT_EQUAL(false, preExisted);
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ(false, preExisted);
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
     array.find(8, true, preExisted);
-    CPPUNIT_ASSERT_EQUAL(true, preExisted);
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
-    CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 3, array.size());
-    if (sizeof(JudyArray::size_type) == 4) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 28, array.getMemoryUsage());
-    } else if (sizeof(JudyArray::size_type) == 8) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 56, array.getMemoryUsage());
-    } else CPPUNIT_FAIL("Unknown size of type");
+    EXPECT_EQ(true, preExisted);
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ((JudyArray::size_type) 3, array.size());
+    EXPECT_EQ((JudyArray::size_type) 56, array.getMemoryUsage());
 
-        // Test each method one can remove stuff in array with
+    // Test each method one can remove stuff in array with
     array.erase(8);
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
     array.erase(8);
-    CPPUNIT_ASSERT_EQUAL(getJudyArrayContents(array).size(), array.size());
-    CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 2, array.size());
-    if (sizeof(JudyArray::size_type) == 4) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 20, array.getMemoryUsage());
-    } else if (sizeof(JudyArray::size_type) == 8) {
-        CPPUNIT_ASSERT_EQUAL((JudyArray::size_type) 40, array.getMemoryUsage());
-    } else CPPUNIT_FAIL("Unknown size of type");
-}
-
-namespace {
-    template<typename T>
-    std::string toString(const T& m) {
-        std::cerr << "#";
-        std::ostringstream ost;
-        ost << m;
-        return ost.str();
-    }
+    EXPECT_EQ(getJudyArrayContents(array).size(), array.size());
+    EXPECT_EQ((JudyArray::size_type) 2, array.size());
+    EXPECT_EQ((JudyArray::size_type) 40, array.getMemoryUsage());
 }
 
-void
-JudyArrayTest::testStress()
-{
+TEST(JudyArrayTest, stress) {
     // Do a lot of random stuff to both judy array and std::map. Ensure equal
     // behaviour
 
@@ -219,9 +165,6 @@ JudyArrayTest::testStress()
                 JudyArray::key_type value(rnd());
                 judyArray.insert(key, value);
                 stdMap[key] = value;
-                //std::pair<StdMap::iterator, bool> result
-                //        = stdMap.insert(std::make_pair(key, value));
-                //if (!result.second) result.first->second = value;
             } else if (optype < 50) { // operator[]
                 JudyArray::key_type key(rnd() % 500);
                 JudyArray::key_type value(rnd());
@@ -229,42 +172,30 @@ JudyArrayTest::testStress()
                 stdMap[key] = value;
             } else if (optype < 70) { // erase()
                 JudyArray::key_type key(rnd() % 500);
-                CPPUNIT_ASSERT_EQUAL_MSG(
-                        toString(judyArray) + toString(stdMap),
-                        stdMap.erase(key), judyArray.erase(key));
+                EXPECT_EQ(stdMap.erase(key), judyArray.erase(key));
             } else if (optype < 75) { // size()
-                CPPUNIT_ASSERT_EQUAL_MSG(
-                        toString(judyArray) + toString(stdMap),
-                        stdMap.size(), judyArray.size());
+                EXPECT_EQ(stdMap.size(), judyArray.size());
             } else if (optype < 78) { // empty()
-                CPPUNIT_ASSERT_EQUAL_MSG(
-                        toString(judyArray) + toString(stdMap),
-                        stdMap.empty(), judyArray.empty());
+                EXPECT_EQ(stdMap.empty(), judyArray.empty());
             } else { // find()
                 JudyArray::key_type key(rnd() % 500);
-                JudyArray::iterator it = judyArray.find(key);
-                StdMap::iterator it2 = stdMap.find(key);
-                CPPUNIT_ASSERT_EQUAL_MSG(
-                        toString(judyArray) + toString(stdMap),
-                        it2 == stdMap.end(), it == judyArray.end());
+                auto it = judyArray.find(key);
+                auto it2 = stdMap.find(key);
+                EXPECT_EQ(it2 == stdMap.end(), it == judyArray.end());
                 if (it != judyArray.end()) {
-                    CPPUNIT_ASSERT_EQUAL_MSG(
-                            toString(judyArray) + toString(stdMap),
-                            it.key(), it2->first);
-                    CPPUNIT_ASSERT_EQUAL_MSG(
-                            toString(judyArray) + toString(stdMap),
-                            it.value(), it2->second);
+                    EXPECT_EQ(it.key(), it2->first);
+                    EXPECT_EQ(it.value(), it2->second);
                 }
             }
         }
-            // Ensure judy array contents is equal to std::map's at this point
+        // Ensure judy array contents is equal to std::map's at this point
         StdMap tmpMap;
         for (JudyArray::const_iterator it = judyArray.begin();
              it != judyArray.end(); ++it)
         {
             tmpMap[it.key()] = it.value();
         }
-        CPPUNIT_ASSERT_EQUAL(stdMap, tmpMap);
+        EXPECT_EQ(stdMap, tmpMap);
     }
 }