Rewrite multivalue mapping tests to gtest.

2 files changed, 150 insertions, 144 deletions

diff --git a/searchlib/src/tests/attribute/multi_value_mapping/CMakeLists.txt b/searchlib/src/tests/attribute/multi_value_mapping/CMakeLists.txt
index 4ea27ff8edc..6b1f5f3d656 100644
--- a/searchlib/src/tests/attribute/multi_value_mapping/CMakeLists.txt
+++ b/searchlib/src/tests/attribute/multi_value_mapping/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(searchlib_multi_value_mapping_test_app TEST
     multi_value_mapping_test.cpp
     DEPENDS
     searchlib
+    gtest
 )
 vespa_add_test(NAME searchlib_multi_value_mapping_test_app COMMAND searchlib_multi_value_mapping_test_app)
diff --git a/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp b/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp
index 8c0cd95eecb..9bbcd71f59d 100644
--- a/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp
+++ b/searchlib/src/tests/attribute/multi_value_mapping/multi_value_mapping_test.cpp
@@ -1,13 +1,13 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/vespalib/testkit/test_kit.h>
 #include <vespa/searchlib/attribute/multi_value_mapping.h>
 #include <vespa/searchlib/attribute/multi_value_mapping.hpp>
 #include <vespa/searchlib/attribute/not_implemented_attribute.h>
 #include <vespa/searchlib/util/rand48.h>
-#include <vespa/vespalib/util/generationhandler.h>
-#include <vespa/vespalib/test/insertion_operators.h>
+#include <vespa/vespalib/gtest/gtest.h>
 #include <vespa/vespalib/stllike/hash_set.h>
+#include <vespa/vespalib/test/insertion_operators.h>
+#include <vespa/vespalib/util/generationhandler.h>
 
 #include <vespa/log/log.h>
 LOG_SETUP("multivaluemapping_test");
@@ -18,7 +18,7 @@ template <typename EntryT>
 void
 assertArray(const std::vector<EntryT> &exp, vespalib::ConstArrayRef<EntryT> values)
 {
-    EXPECT_EQUAL(exp, std::vector<EntryT>(values.cbegin(), values.cend()));
+    EXPECT_EQ(exp, std::vector<EntryT>(values.cbegin(), values.cend()));
 }
 
 template <class MvMapping>
@@ -62,66 +62,72 @@ public:
 constexpr float ALLOC_GROW_FACTOR = 0.2;
 
 template <typename EntryT>
-class Fixture
-{
+class MappingTestBase : public ::testing::Test {
 protected:
     using MvMapping = search::attribute::MultiValueMapping<EntryT>;
-    MvMapping _mvMapping;
-    MyAttribute<MvMapping> _attr;
+    using AttributeType = MyAttribute<MvMapping>;
+    std::unique_ptr<MvMapping> _mvMapping;
+    std::unique_ptr<AttributeType> _attr;
+    uint32_t _maxSmallArraySize;
     using RefType = typename MvMapping::RefType;
     using generation_t = vespalib::GenerationHandler::generation_t;
 
 public:
     using ConstArrayRef = vespalib::ConstArrayRef<EntryT>;
-    Fixture(uint32_t maxSmallArraySize)
-        : _mvMapping(ArrayStoreConfig(maxSmallArraySize,
-                                      ArrayStoreConfig::AllocSpec(0, RefType::offsetSize(), 8 * 1024,
-                                      ALLOC_GROW_FACTOR))),
-          _attr(_mvMapping)
+    MappingTestBase()
+        : _mvMapping(),
+          _attr(),
+          _maxSmallArraySize()
     {
     }
-    Fixture(uint32_t maxSmallArraySize, size_t minArrays, size_t maxArrays, size_t numArraysForNewBuffer)
-        : _mvMapping(ArrayStoreConfig(maxSmallArraySize,
-                                      ArrayStoreConfig::AllocSpec(minArrays, maxArrays, numArraysForNewBuffer,
-                                      ALLOC_GROW_FACTOR))),
-          _attr(_mvMapping)
-    {
+    void setup(uint32_t maxSmallArraySize) {
+        _mvMapping = std::make_unique<MvMapping>(ArrayStoreConfig(maxSmallArraySize,
+                                                                  ArrayStoreConfig::AllocSpec(0, RefType::offsetSize(), 8 * 1024,
+                                                                                              ALLOC_GROW_FACTOR)));
+        _attr = std::make_unique<AttributeType>(*_mvMapping);
+        _maxSmallArraySize = maxSmallArraySize;
+    }
+    void setup(uint32_t maxSmallArraySize, size_t minArrays, size_t maxArrays, size_t numArraysForNewBuffer) {
+        _mvMapping = std::make_unique<MvMapping>(ArrayStoreConfig(maxSmallArraySize,
+                                                                  ArrayStoreConfig::AllocSpec(minArrays, maxArrays, numArraysForNewBuffer,
+                                                                                              ALLOC_GROW_FACTOR)));
+        _attr = std::make_unique<AttributeType>(*_mvMapping);
+        _maxSmallArraySize = maxSmallArraySize;
     }
-    ~Fixture() { }
+    ~MappingTestBase() { }
 
-    void set(uint32_t docId, const std::vector<EntryT> &values) { _mvMapping.set(docId, values); }
-    void replace(uint32_t docId, const std::vector<EntryT> &values) { _mvMapping.replace(docId, values); }
-    ConstArrayRef get(uint32_t docId) { return _mvMapping.get(docId); }
-    void assertGet(uint32_t docId, const std::vector<EntryT> &exp)
-    {
+    void set(uint32_t docId, const std::vector<EntryT> &values) { _mvMapping->set(docId, values); }
+    void replace(uint32_t docId, const std::vector<EntryT> &values) { _mvMapping->replace(docId, values); }
+    ConstArrayRef get(uint32_t docId) { return _mvMapping->get(docId); }
+    void assertGet(uint32_t docId, const std::vector<EntryT> &exp) {
         ConstArrayRef act = get(docId);
-        EXPECT_EQUAL(exp, std::vector<EntryT>(act.cbegin(), act.cend()));
+        EXPECT_EQ(exp, std::vector<EntryT>(act.cbegin(), act.cend()));
     }
-    void transferHoldLists(generation_t generation) { _mvMapping.transferHoldLists(generation); }
-    void trimHoldLists(generation_t firstUsed) { _mvMapping.trimHoldLists(firstUsed); }
+    void transferHoldLists(generation_t generation) { _mvMapping->transferHoldLists(generation); }
+    void trimHoldLists(generation_t firstUsed) { _mvMapping->trimHoldLists(firstUsed); }
     void addDocs(uint32_t numDocs) {
         for (uint32_t i = 0; i < numDocs; ++i) {
             uint32_t doc = 0;
-            _attr.addDoc(doc);
+            _attr->addDoc(doc);
         }
-        _attr.commit();
-        _attr.incGeneration();
+        _attr->commit();
+        _attr->incGeneration();
     }
-    uint32_t size() const { return _mvMapping.size(); }
+    uint32_t size() const { return _mvMapping->size(); }
     void shrink(uint32_t docIdLimit) {
-        _attr.setCommittedDocIdLimit(docIdLimit);
-        _attr.commit();
-        _attr.incGeneration();
-        _attr.shrinkLidSpace();
+        _attr->setCommittedDocIdLimit(docIdLimit);
+        _attr->commit();
+        _attr->incGeneration();
+        _attr->shrinkLidSpace();
     }
     void clearDocs(uint32_t lidLow, uint32_t lidLimit) {
-        _mvMapping.clearDocs(lidLow, lidLimit, [=](uint32_t docId) { _attr.clearDoc(docId); });
+        _mvMapping->clearDocs(lidLow, lidLimit, [=](uint32_t docId) { _attr->clearDoc(docId); });
     }
-    size_t getTotalValueCnt() const { return _mvMapping.getTotalValueCnt(); }
+    size_t getTotalValueCnt() const { return _mvMapping->getTotalValueCnt(); }
 
     uint32_t countBuffers() {
         using RefVector = typename MvMapping::RefCopyVector;
-        RefVector refs = _mvMapping.getRefCopy(_mvMapping.size());
+        RefVector refs = _mvMapping->getRefCopy(_mvMapping->size());
         vespalib::hash_set<uint32_t> buffers;
         for (const auto &ref : refs) {
             if (ref.valid()) {
@@ -133,32 +139,23 @@ public:
     }
 
     void compactWorst() {
-        _mvMapping.compactWorst(true, false);
-        _attr.commit();
-        _attr.incGeneration();
+        _mvMapping->compactWorst(true, false);
+        _attr->commit();
+        _attr->incGeneration();
     }
 };
 
-class IntFixture : public Fixture<int>
+using IntMappingTest = MappingTestBase<int>;
+
+class CompactionIntMappingTest : public MappingTestBase<int>
 {
     search::Rand48 _rnd;
     std::map<uint32_t, std::vector<int>> _refMapping;
-    uint32_t _maxSmallArraySize;
 public:
-    IntFixture(uint32_t maxSmallArraySize)
-        : Fixture<int>(maxSmallArraySize),
-          _rnd(),
-          _refMapping(),
-          _maxSmallArraySize(maxSmallArraySize)
-    {
-        _rnd.srand48(32);
-    }
-
-    IntFixture(uint32_t maxSmallArraySize, size_t minArrays, size_t maxArrays, size_t numArraysForNewBuffer)
-        : Fixture<int>(maxSmallArraySize, minArrays, maxArrays, numArraysForNewBuffer),
+    CompactionIntMappingTest()
+        : MappingTestBase<int>(),
           _rnd(),
-          _refMapping(),
-          _maxSmallArraySize(maxSmallArraySize)
+          _refMapping()
     {
         _rnd.srand48(32);
     }
@@ -175,12 +172,12 @@ public:
 
     void addRandomDoc() {
         uint32_t docId = 0;
-        _attr.addDoc(docId);
+        _attr->addDoc(docId);
         std::vector<int> values = makeValues();
         _refMapping[docId] = values;
         set(docId, values);
-        _attr.commit();
-        _attr.incGeneration();
+        _attr->commit();
+        _attr->incGeneration();
     }
 
     void addRandomDocs(uint32_t count) {
@@ -193,14 +190,14 @@ public:
         uint32_t docId = 0;
         for (const auto &kv : _refMapping) {
             while (docId < kv.first) {
-                TEST_DO(assertGet(docId, {}));
+                assertGet(docId, {});
                 ++docId;
             }
-            TEST_DO(assertGet(docId, kv.second));
+            assertGet(docId, kv.second);
             ++docId;
         }
         while (docId < size()) {
-            TEST_DO(assertGet(docId, {}));
+            assertGet(docId, {});
             ++docId;
         }
     }
@@ -211,122 +208,130 @@ public:
     }
 };
 
-TEST_F("Test that set and get works", Fixture<int>(3))
+TEST_F(IntMappingTest, test_that_set_and_get_works)
 {
-    f.set(1, {});
-    f.set(2, {4, 7});
-    f.set(3, {5});
-    f.set(4, {10, 14, 17, 16});
-    f.set(5, {3});
-    TEST_DO(f.assertGet(1, {}));
-    TEST_DO(f.assertGet(2, {4, 7}));
-    TEST_DO(f.assertGet(3, {5}));
-    TEST_DO(f.assertGet(4, {10, 14, 17, 16}));
-    TEST_DO(f.assertGet(5, {3}));
+    setup(3);
+    set(1, {});
+    set(2, {4, 7});
+    set(3, {5});
+    set(4, {10, 14, 17, 16});
+    set(5, {3});
+    assertGet(1, {});
+    assertGet(2, {4, 7});
+    assertGet(3, {5});
+    assertGet(4, {10, 14, 17, 16});
+    assertGet(5, {3});
 }
 
-TEST_F("Test that old value is not overwritten while held", Fixture<int>(3, 32, 64, 0))
+TEST_F(IntMappingTest, test_that_old_value_is_not_overwritten_while_held)
 {
-    f.set(3, {5});
-    typename F1::ConstArrayRef old3 = f.get(3);
-    TEST_DO(assertArray({5}, old3));
-    f.set(3, {7});
-    f.transferHoldLists(10);
-    TEST_DO(assertArray({5}, old3));
-    TEST_DO(f.assertGet(3, {7}));
-    f.trimHoldLists(10);
-    TEST_DO(assertArray({5}, old3));
-    f.trimHoldLists(11);
-    TEST_DO(assertArray({0}, old3));
+    setup(3, 32, 64, 0);
+    set(3, {5});
+    auto old3 = get(3);
+    assertArray({5}, old3);
+    set(3, {7});
+    transferHoldLists(10);
+    assertArray({5}, old3);
+    assertGet(3, {7});
+    trimHoldLists(10);
+    assertArray({5}, old3);
+    trimHoldLists(11);
+    assertArray({0}, old3);
 }
 
-TEST_F("Test that addDoc works", Fixture<int>(3))
+TEST_F(IntMappingTest, test_that_addDoc_works)
 {
-    EXPECT_EQUAL(0u, f.size());
-    f.addDocs(10);
-    EXPECT_EQUAL(10u, f.size());
+    setup(3);
+    EXPECT_EQ(0u, size());
+    addDocs(10);
+    EXPECT_EQ(10u, size());
 }
 
-TEST_F("Test that shrink works", Fixture<int>(3))
+TEST_F(IntMappingTest, test_that_shrink_works)
 {
-    f.addDocs(10);
-    EXPECT_EQUAL(10u, f.size());
-    f.shrink(5);
-    EXPECT_EQUAL(5u, f.size());
+    setup(3);
+    addDocs(10);
+    EXPECT_EQ(10u, size());
+    shrink(5);
+    EXPECT_EQ(5u, size());
 }
 
-TEST_F("Test that clearDocs works", Fixture<int>(3))
+TEST_F(IntMappingTest, test_that_clearDocs_works)
 {
-    f.addDocs(10);
-    f.set(1, {});
-    f.set(2, {4, 7});
-    f.set(3, {5});
-    f.set(4, {10, 14, 17, 16});
-    f.set(5, {3});
-    f.clearDocs(3, 5);
-    TEST_DO(f.assertGet(1, {}));
-    TEST_DO(f.assertGet(2, {4, 7}));
-    TEST_DO(f.assertGet(3, {}));
-    TEST_DO(f.assertGet(4, {}));
-    TEST_DO(f.assertGet(5, {3}));
+    setup(3);
+    addDocs(10);
+    set(1, {});
+    set(2, {4, 7});
+    set(3, {5});
+    set(4, {10, 14, 17, 16});
+    set(5, {3});
+    clearDocs(3, 5);
+    assertGet(1, {});
+    assertGet(2, {4, 7});
+    assertGet(3, {});
+    assertGet(4, {});
+    assertGet(5, {3});
 }
 
-TEST_F("Test that totalValueCnt works", Fixture<int>(3))
+TEST_F(IntMappingTest, test_that_totalValueCnt_works)
 {
-    f.addDocs(10);
-    EXPECT_EQUAL(0u, f.getTotalValueCnt());
-    f.set(1, {});
-    EXPECT_EQUAL(0u, f.getTotalValueCnt());
-    f.set(2, {4, 7});
-    EXPECT_EQUAL(2u, f.getTotalValueCnt());
-    f.set(3, {5});
-    EXPECT_EQUAL(3u, f.getTotalValueCnt());
-    f.set(4, {10, 14, 17, 16});
-    EXPECT_EQUAL(7u, f.getTotalValueCnt());
-    f.set(5, {3});
-    EXPECT_EQUAL(8u, f.getTotalValueCnt());
-    f.set(4, {10, 16});
-    EXPECT_EQUAL(6u, f.getTotalValueCnt());
-    f.set(2, {4});
-    EXPECT_EQUAL(5u, f.getTotalValueCnt());
+    setup(3);
+    addDocs(10);
+    EXPECT_EQ(0u, getTotalValueCnt());
+    set(1, {});
+    EXPECT_EQ(0u, getTotalValueCnt());
+    set(2, {4, 7});
+    EXPECT_EQ(2u, getTotalValueCnt());
+    set(3, {5});
+    EXPECT_EQ(3u, getTotalValueCnt());
+    set(4, {10, 14, 17, 16});
+    EXPECT_EQ(7u, getTotalValueCnt());
+    set(5, {3});
+    EXPECT_EQ(8u, getTotalValueCnt());
+    set(4, {10, 16});
+    EXPECT_EQ(6u, getTotalValueCnt());
+    set(2, {4});
+    EXPECT_EQ(5u, getTotalValueCnt());
 }
 
-TEST_F("Test that replace works", Fixture<int>(3))
+TEST_F(IntMappingTest, test_that_replace_works)
 {
-    f.addDocs(10);
-    f.set(4, {10, 14, 17, 16});
-    typename F1::ConstArrayRef old4 = f.get(4);
-    TEST_DO(assertArray({10, 14, 17, 16}, old4));
-    EXPECT_EQUAL(4u, f.getTotalValueCnt());
-    f.replace(4, {20, 24, 27, 26});
-    TEST_DO(assertArray({20, 24, 27, 26}, old4));
-    EXPECT_EQUAL(4u, f.getTotalValueCnt());
+    setup(3);
+    addDocs(10);
+    set(4, {10, 14, 17, 16});
+    auto old4 = get(4);
+    assertArray({10, 14, 17, 16}, old4);
+    EXPECT_EQ(4u, getTotalValueCnt());
+    replace(4, {20, 24, 27, 26});
+    assertArray({20, 24, 27, 26}, old4);
+    EXPECT_EQ(4u, getTotalValueCnt());
 }
 
-TEST_F("Test that compaction works", IntFixture(3, 64, 512, 129))
+TEST_F(CompactionIntMappingTest, test_that_compaction_works)
 {
+    setup(3, 64, 512, 129);
     uint32_t addDocs = 10;
     uint32_t bufferCountBefore = 0;
     do {
-        f.addRandomDocs(addDocs);
+        addRandomDocs(addDocs);
         addDocs *= 2;
-        bufferCountBefore = f.countBuffers();
+        bufferCountBefore = countBuffers();
     } while (bufferCountBefore < 10);
-    uint32_t docIdLimit = f.size();
+    uint32_t docIdLimit = size();
     uint32_t clearLimit = docIdLimit / 2;
     LOG(info, "Have %u buffers, %u docs, clearing to %u",
         bufferCountBefore, docIdLimit, clearLimit);
     for (uint32_t docId = 0; docId < clearLimit; ++docId) {
-        f.clearDoc(docId);
+        clearDoc(docId);
     }
     uint32_t bufferCountAfter = bufferCountBefore;
     for (uint32_t compactIter = 0; compactIter < 10; ++compactIter) {
-        f.compactWorst();
-        bufferCountAfter = f.countBuffers();
-        f.checkRefMapping();
+        compactWorst();
+        bufferCountAfter = countBuffers();
+        checkRefMapping();
         LOG(info, "Have %u buffers after compacting", bufferCountAfter);
     }
-    EXPECT_LESS(bufferCountAfter, bufferCountBefore);
+    EXPECT_LT(bufferCountAfter, bufferCountBefore);
 }
 
-TEST_MAIN() { TEST_RUN_ALL(); }
+GTEST_MAIN_RUN_ALL_TESTS()