Rewrite unique store tests to gtest.

2 files changed, 100 insertions, 99 deletions

diff --git a/vespalib/src/tests/datastore/unique_store/CMakeLists.txt b/vespalib/src/tests/datastore/unique_store/CMakeLists.txt
index dd200018448..d72e8c10ad5 100644
--- a/vespalib/src/tests/datastore/unique_store/CMakeLists.txt
+++ b/vespalib/src/tests/datastore/unique_store/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(vespalib_unique_store_test_app TEST
     unique_store_test.cpp
     DEPENDS
     vespalib
+    gtest
 )
 vespa_add_test(NAME vespalib_unique_store_test_app COMMAND vespalib_unique_store_test_app)
diff --git a/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp b/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
index 2ed7bfd52ed..a585186aa3e 100644
--- a/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
+++ b/vespalib/src/tests/datastore/unique_store/unique_store_test.cpp
@@ -1,13 +1,14 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/log/log.h>
-LOG_SETUP("unique_store_test");
 #include <vespa/vespalib/datastore/unique_store.hpp>
-#include <vespa/vespalib/testkit/testapp.h>
+#include <vespa/vespalib/gtest/gtest.h>
 #include <vespa/vespalib/test/datastore/memstats.h>
 #include <vespa/vespalib/test/insertion_operators.h>
 #include <vespa/vespalib/util/traits.h>
 #include <vector>
 
+#include <vespa/log/log.h>
+LOG_SETUP("unique_store_test");
+
 using namespace search::datastore;
 using vespalib::MemoryUsage;
 using vespalib::ArrayRef;
@@ -15,8 +16,7 @@ using generation_t = vespalib::GenerationHandler::generation_t;
 using MemStats = search::datastore::test::MemStats;
 
 template <typename EntryT, typename RefT = EntryRefT<22> >
-struct Fixture
-{
+struct TestBase : public ::testing::Test {
     using EntryRefType = RefT;
     using UniqueStoreType = UniqueStore<EntryT, RefT>;
     using value_type = EntryT;
@@ -25,7 +25,7 @@ struct Fixture
     UniqueStoreType store;
     ReferenceStore refStore;
     generation_t generation;
-    Fixture()
+    TestBase()
         : store(),
           refStore(),
           generation(1)
@@ -38,7 +38,7 @@ struct Fixture
         UniqueStoreAddResult addResult = store.add(input);
         EntryRef result = addResult.ref();
         auto insres = refStore.insert(std::make_pair(result, std::make_pair(input, 1u)));
-        EXPECT_EQUAL(insres.second, addResult.inserted());
+        EXPECT_EQ(insres.second, addResult.inserted());
         if (!insres.second) {
             ++insres.first->second.second;
         }
@@ -56,10 +56,10 @@ struct Fixture
     }
     void assertGet(EntryRef ref, const EntryT &exp) const {
         EntryT act = store.get(ref);
-        EXPECT_EQUAL(exp, act);
+        EXPECT_EQ(exp, act);
     }
     void remove(EntryRef ref) {
-        ASSERT_EQUAL(1u, refStore.count(ref));
+        ASSERT_EQ(1u, refStore.count(ref));
         store.remove(ref);
         if (refStore[ref].second > 1) {
             --refStore[ref].second;
@@ -74,19 +74,19 @@ struct Fixture
         return EntryRefType(ref).bufferId();
     }
     void assertBufferState(EntryRef ref, const MemStats expStats) const {
-        EXPECT_EQUAL(expStats._used, store.bufferState(ref).size());
-        EXPECT_EQUAL(expStats._hold, store.bufferState(ref).getHoldElems());
-        EXPECT_EQUAL(expStats._dead, store.bufferState(ref).getDeadElems());
+        EXPECT_EQ(expStats._used, store.bufferState(ref).size());
+        EXPECT_EQ(expStats._hold, store.bufferState(ref).getHoldElems());
+        EXPECT_EQ(expStats._dead, store.bufferState(ref).getDeadElems());
     }
     void assertMemoryUsage(const MemStats expStats) const {
         MemoryUsage act = store.getMemoryUsage();
-        EXPECT_EQUAL(expStats._used, act.usedBytes());
-        EXPECT_EQUAL(expStats._hold, act.allocatedBytesOnHold());
-        EXPECT_EQUAL(expStats._dead, act.deadBytes());
+        EXPECT_EQ(expStats._used, act.usedBytes());
+        EXPECT_EQ(expStats._hold, act.allocatedBytesOnHold());
+        EXPECT_EQ(expStats._dead, act.deadBytes());
     }
     void assertStoreContent() const {
         for (const auto &elem : refStore) {
-            TEST_DO(assertGet(elem.first, elem.second.first));
+            assertGet(elem.first, elem.second.first);
         }
     }
     EntryRef getEntryRef(const EntryT &input) {
@@ -115,8 +115,8 @@ struct Fixture
         refs.pop_back();
         ReferenceStore compactedRefStore;
         for (size_t i = 0; i < refs.size(); ++i) {
-            ASSERT_EQUAL(0u, compactedRefStore.count(compactedRefs[i]));
-            ASSERT_EQUAL(1u, refStore.count(refs[i]));
+            ASSERT_EQ(0u, compactedRefStore.count(compactedRefs[i]));
+            ASSERT_EQ(1u, refStore.count(refs[i]));
             compactedRefStore.insert(std::make_pair(compactedRefs[i], refStore[refs[i]]));
         }
         refStore = compactedRefStore;
@@ -126,141 +126,141 @@ struct Fixture
     auto getSaver() { return store.getSaver(); }
 };
 
-using NumberFixture = Fixture<uint32_t>;
-using StringFixture = Fixture<std::string>;
-using SmallOffsetNumberFixture = Fixture<uint32_t, EntryRefT<10>>;
+using NumberTest = TestBase<uint32_t>;
+using StringTest = TestBase<std::string>;
+using SmallOffsetNumberTest = TestBase<uint32_t, EntryRefT<10>>;
 
-TEST("require that we test with trivial and non-trivial types")
+TEST(UniqueStoreTest, trivial_and_non_trivial_types_are_tested)
 {
-    EXPECT_TRUE(vespalib::can_skip_destruction<NumberFixture::value_type>::value);
-    EXPECT_FALSE(vespalib::can_skip_destruction<StringFixture::value_type>::value);
+    EXPECT_TRUE(vespalib::can_skip_destruction<NumberTest::value_type>::value);
+    EXPECT_FALSE(vespalib::can_skip_destruction<StringTest::value_type>::value);
 }
 
-TEST_F("require that we can add and get values of trivial type", NumberFixture)
+TEST_F(NumberTest, can_add_and_get_values_of_trivial_type)
 {
-    TEST_DO(f.assertAdd(1));
-    TEST_DO(f.assertAdd(2));
-    TEST_DO(f.assertAdd(3));
-    TEST_DO(f.assertAdd(1));
+    assertAdd(1);
+    assertAdd(2);
+    assertAdd(3);
+    assertAdd(1);
 }
 
-TEST_F("require that we can add and get values of non-trivial type", StringFixture)
+TEST_F(StringTest, can_add_and_get_values_of_non_trivial_type)
 {
-    TEST_DO(f.assertAdd("aa"));
-    TEST_DO(f.assertAdd("bbb"));
-    TEST_DO(f.assertAdd("ccc"));
-    TEST_DO(f.assertAdd("aa"));
+    assertAdd("aa");
+    assertAdd("bbb");
+    assertAdd("ccc");
+    assertAdd("aa");
 }
 
-TEST_F("require that elements are put on hold when value is removed", NumberFixture)
+TEST_F(NumberTest, elements_are_put_on_hold_when_value_is_removed)
 {
-    EntryRef ref = f.add(1);
+    EntryRef ref = add(1);
     // Note: The first buffer have the first element reserved -> we expect 2 elements used here.
-    TEST_DO(f.assertBufferState(ref, MemStats().used(2).hold(0).dead(1)));
-    f.store.remove(ref);
-    TEST_DO(f.assertBufferState(ref, MemStats().used(2).hold(1).dead(1)));
+    assertBufferState(ref, MemStats().used(2).hold(0).dead(1));
+    store.remove(ref);
+    assertBufferState(ref, MemStats().used(2).hold(1).dead(1));
 }
 
-TEST_F("require that elements are reference counted", NumberFixture)
+TEST_F(NumberTest, elements_are_reference_counted)
 {
-    EntryRef ref = f.add(1);
-    EntryRef ref2 = f.add(1);
-    EXPECT_EQUAL(ref.ref(), ref2.ref());
+    EntryRef ref = add(1);
+    EntryRef ref2 = add(1);
+    EXPECT_EQ(ref.ref(), ref2.ref());
     // Note: The first buffer have the first element reserved -> we expect 2 elements used here.
-    TEST_DO(f.assertBufferState(ref, MemStats().used(2).hold(0).dead(1)));
-    f.store.remove(ref);
-    TEST_DO(f.assertBufferState(ref, MemStats().used(2).hold(0).dead(1)));
-    f.store.remove(ref);
-    TEST_DO(f.assertBufferState(ref, MemStats().used(2).hold(1).dead(1)));
+    assertBufferState(ref, MemStats().used(2).hold(0).dead(1));
+    store.remove(ref);
+    assertBufferState(ref, MemStats().used(2).hold(0).dead(1));
+    store.remove(ref);
+    assertBufferState(ref, MemStats().used(2).hold(1).dead(1));
 }
 
-TEST_F("require that new underlying buffer is allocated when current is full", SmallOffsetNumberFixture)
+TEST_F(SmallOffsetNumberTest, new_underlying_buffer_is_allocated_when_current_is_full)
 {
-    uint32_t firstBufferId = f.getBufferId(f.add(1));
-    for (uint32_t i = 0; i < (F1::EntryRefType::offsetSize() - 2); ++i) {
-        uint32_t bufferId = f.getBufferId(f.add(i + 2));
-        EXPECT_EQUAL(firstBufferId, bufferId);
+    uint32_t firstBufferId = getBufferId(add(1));
+    for (uint32_t i = 0; i < (SmallOffsetNumberTest::EntryRefType::offsetSize() - 2); ++i) {
+        uint32_t bufferId = getBufferId(add(i + 2));
+        EXPECT_EQ(firstBufferId, bufferId);
     }
-    TEST_DO(f.assertStoreContent());
+    assertStoreContent();
 
-    uint32_t bias = F1::EntryRefType::offsetSize();
-    uint32_t secondBufferId = f.getBufferId(f.add(bias + 1));
-    EXPECT_NOT_EQUAL(firstBufferId, secondBufferId);
+    uint32_t bias = SmallOffsetNumberTest::EntryRefType::offsetSize();
+    uint32_t secondBufferId = getBufferId(add(bias + 1));
+    EXPECT_NE(firstBufferId, secondBufferId);
     for (uint32_t i = 0; i < 10u; ++i) {
-        uint32_t bufferId = f.getBufferId(f.add(bias + i + 2));
-        EXPECT_EQUAL(secondBufferId, bufferId);
+        uint32_t bufferId = getBufferId(add(bias + i + 2));
+        EXPECT_EQ(secondBufferId, bufferId);
     }
-    TEST_DO(f.assertStoreContent());
+    assertStoreContent();
 }
 
-TEST_F("require that compaction works", NumberFixture)
+TEST_F(NumberTest, store_can_be_compacted)
 {
-    EntryRef val1Ref = f.add(1);
-    EntryRef val2Ref = f.add(2);
-    f.remove(f.add(4));
-    f.trimHoldLists();
-    TEST_DO(f.assertBufferState(val1Ref, MemStats().used(4).dead(2))); // Note: First element is reserved
-    uint32_t val1BufferId = f.getBufferId(val1Ref);
+    EntryRef val1Ref = add(1);
+    EntryRef val2Ref = add(2);
+    remove(add(4));
+    trimHoldLists();
+    assertBufferState(val1Ref, MemStats().used(4).dead(2)); // Note: First element is reserved
+    uint32_t val1BufferId = getBufferId(val1Ref);
 
-    EXPECT_EQUAL(2u, f.refStore.size());
-    f.compactWorst();
-    EXPECT_EQUAL(2u, f.refStore.size());
-    TEST_DO(f.assertStoreContent());
+    EXPECT_EQ(2u, refStore.size());
+    compactWorst();
+    EXPECT_EQ(2u, refStore.size());
+    assertStoreContent();
 
     // Buffer has been compacted
-    EXPECT_NOT_EQUAL(val1BufferId, f.getBufferId(f.getEntryRef(1)));
+    EXPECT_NE(val1BufferId, getBufferId(getEntryRef(1)));
     // Old ref should still point to data.
-    f.assertGet(val1Ref, 1);
-    f.assertGet(val2Ref, 2);
-    EXPECT_TRUE(f.store.bufferState(val1Ref).isOnHold());
-    f.trimHoldLists();
-    EXPECT_TRUE(f.store.bufferState(val1Ref).isFree());
-    TEST_DO(f.assertStoreContent());
+    assertGet(val1Ref, 1);
+    assertGet(val2Ref, 2);
+    EXPECT_TRUE(store.bufferState(val1Ref).isOnHold());
+    trimHoldLists();
+    EXPECT_TRUE(store.bufferState(val1Ref).isFree());
+    assertStoreContent();
 }
 
-TEST_F("require that builder works", NumberFixture)
+TEST_F(NumberTest, store_can_be_instantiated_with_builder)
 {
-    auto builder = f.getBuilder(2);
+    auto builder = getBuilder(2);
     builder.add(10);
     builder.add(20);
     builder.setupRefCounts();
     EntryRef val10Ref = builder.mapEnumValueToEntryRef(1);
     EntryRef val20Ref = builder.mapEnumValueToEntryRef(2);
-    TEST_DO(f.assertBufferState(val10Ref, MemStats().used(3).dead(1))); // Note: First element is reserved
+    assertBufferState(val10Ref, MemStats().used(3).dead(1)); // Note: First element is reserved
     EXPECT_TRUE(val10Ref.valid());
     EXPECT_TRUE(val20Ref.valid());
-    EXPECT_NOT_EQUAL(val10Ref.ref(), val20Ref.ref());
-    f.assertGet(val10Ref, 10);
-    f.assertGet(val20Ref, 20);
+    EXPECT_NE(val10Ref.ref(), val20Ref.ref());
+    assertGet(val10Ref, 10);
+    assertGet(val20Ref, 20);
     builder.makeDictionary();
     // Align refstore with the two entries added by builder.
-    f.alignRefStore(val10Ref, 10, 1);
-    f.alignRefStore(val20Ref, 20, 1);
-    EXPECT_EQUAL(val10Ref.ref(), f.add(10).ref());
-    EXPECT_EQUAL(val20Ref.ref(), f.add(20).ref());
+    alignRefStore(val10Ref, 10, 1);
+    alignRefStore(val20Ref, 20, 1);
+    EXPECT_EQ(val10Ref.ref(), add(10).ref());
+    EXPECT_EQ(val20Ref.ref(), add(20).ref());
 }
 
-TEST_F("require that saver works", NumberFixture)
+TEST_F(NumberTest, store_can_be_saved)
 {
-    EntryRef val10Ref = f.add(10);
-    EntryRef val20Ref = f.add(20);
-    f.remove(f.add(40));
-    f.trimHoldLists();
+    EntryRef val10Ref = add(10);
+    EntryRef val20Ref = add(20);
+    remove(add(40));
+    trimHoldLists();
 
-    auto saver = f.getSaver();
+    auto saver = getSaver();
     std::vector<uint32_t> refs;
     saver.foreach_key([&](EntryRef ref) { refs.push_back(ref.ref()); });
     std::vector<uint32_t> expRefs;
     expRefs.push_back(val10Ref.ref());
     expRefs.push_back(val20Ref.ref());
-    EXPECT_EQUAL(expRefs, refs);
+    EXPECT_EQ(expRefs, refs);
     saver.enumerateValues();
     uint32_t invalidEnum = saver.mapEntryRefToEnumValue(EntryRef());
     uint32_t enumValue10 = saver.mapEntryRefToEnumValue(val10Ref);
     uint32_t enumValue20 = saver.mapEntryRefToEnumValue(val20Ref);
-    EXPECT_EQUAL(0u, invalidEnum);
-    EXPECT_EQUAL(1u, enumValue10);
-    EXPECT_EQUAL(2u, enumValue20);
+    EXPECT_EQ(0u, invalidEnum);
+    EXPECT_EQ(1u, enumValue10);
+    EXPECT_EQ(2u, enumValue20);
 }
 
-TEST_MAIN() { TEST_RUN_ALL(); }
+GTEST_MAIN_RUN_ALL_TESTS()