Unit test proton::documentmetastore::LidAllocator::unregister_lids().

1 files changed, 146 insertions, 0 deletions

diff --git a/searchcore/src/tests/proton/documentmetastore/lid_state_vector/lid_state_vector_test.cpp b/searchcore/src/tests/proton/documentmetastore/lid_state_vector/lid_state_vector_test.cpp
new file mode 100644
index 00000000000..af4c2efd74b
--- /dev/null
+++ b/searchcore/src/tests/proton/documentmetastore/lid_state_vector/lid_state_vector_test.cpp
@@ -0,0 +1,146 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include <vespa/searchcore/proton/documentmetastore/lidstatevector.h>
+#include <vespa/searchcore/proton/documentmetastore/lid_hold_list.h>
+#include <vespa/vespalib/util/generationholder.h>
+#include <vespa/vespalib/gtest/gtest.h>
+
+using vespalib::GenerationHolder;
+
+namespace proton {
+
+class LidStateVectorTest : public ::testing::Test
+{
+protected:
+    GenerationHolder _gen_hold;
+
+    LidStateVectorTest()
+        : ::testing::Test(),
+          _gen_hold()
+    {
+    }
+
+    ~LidStateVectorTest()
+    {
+        _gen_hold.clearHoldLists();
+    }
+
+};
+
+
+TEST_F(LidStateVectorTest, basic_free_list_is_working)
+{
+    LidStateVector freeLids(100, 100, _gen_hold, true, false);
+    LidHoldList list;
+    EXPECT_TRUE(freeLids.empty());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(0u, list.size());
+
+    list.add(10, 10);
+    EXPECT_TRUE(freeLids.empty());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(1u, list.size());
+
+    list.add(20, 20);
+    list.add(30, 30);
+    EXPECT_TRUE(freeLids.empty());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(3u, list.size());
+
+    list.trimHoldLists(20, freeLids);
+    EXPECT_FALSE(freeLids.empty());
+    EXPECT_EQ(1u, freeLids.count());
+
+    EXPECT_EQ(10u, freeLids.getLowest());
+    freeLids.clearBit(10);
+    EXPECT_TRUE(freeLids.empty());
+    EXPECT_EQ(0u, freeLids.count());
+    EXPECT_EQ(2u, list.size());
+
+    list.trimHoldLists(31, freeLids);
+    EXPECT_FALSE(freeLids.empty());
+    EXPECT_EQ(2u, freeLids.count());
+
+    EXPECT_EQ(20u, freeLids.getLowest());
+    freeLids.clearBit(20);
+    EXPECT_FALSE(freeLids.empty());
+    EXPECT_EQ(1u, freeLids.count());
+    EXPECT_EQ(0u, list.size());
+
+    EXPECT_EQ(30u, freeLids.getLowest());
+    freeLids.clearBit(30);
+    EXPECT_TRUE(freeLids.empty());
+    EXPECT_EQ(0u, list.size());
+    EXPECT_EQ(0u, freeLids.count());
+}
+
+void
+assertLidStateVector(const std::vector<uint32_t> &expLids, uint32_t lowest, uint32_t highest,
+                     const LidStateVector &actLids)
+{
+    if (!expLids.empty()) {
+        EXPECT_EQ(expLids.size(), actLids.count());
+        uint32_t trueBit = 0;
+        for (auto i : expLids) {
+            EXPECT_TRUE(actLids.testBit(i));
+            trueBit = actLids.getNextTrueBit(trueBit);
+            EXPECT_EQ(i, trueBit);
+            ++trueBit;
+        }
+        trueBit = actLids.getNextTrueBit(trueBit);
+        EXPECT_EQ(actLids.size(), trueBit);
+    } else {
+        EXPECT_TRUE(actLids.empty());
+    }
+    EXPECT_EQ(lowest, actLids.getLowest());
+    EXPECT_EQ(highest, actLids.getHighest());
+}
+
+TEST_F(LidStateVectorTest, lid_state_vector_resizing_is_working)
+{
+    LidStateVector lids(1000, 1000, _gen_hold, true, true);
+    lids.setBit(3);
+    lids.setBit(150);
+    lids.setBit(270);
+    lids.setBit(310);
+    lids.setBit(440);
+    lids.setBit(780);
+    lids.setBit(930);
+    assertLidStateVector({3,150,270,310,440,780,930}, 3, 930, lids);
+
+    lids.resizeVector(1500, 1500);
+    assertLidStateVector({3,150,270,310,440,780,930}, 3, 930, lids);
+    lids.clearBit(3);
+    assertLidStateVector({150,270,310,440,780,930}, 150, 930, lids);
+    lids.clearBit(150);
+    assertLidStateVector({270,310,440,780,930}, 270, 930, lids);
+    lids.setBit(170);
+    assertLidStateVector({170,270,310,440,780,930}, 170, 930, lids);
+    lids.setBit(1490);
+    assertLidStateVector({170,270,310,440,780,930,1490}, 170, 1490, lids);
+
+    lids.resizeVector(2000, 2000);
+    assertLidStateVector({170,270,310,440,780,930,1490}, 170, 1490, lids);
+    lids.clearBit(170);
+    assertLidStateVector({270,310,440,780,930,1490}, 270, 1490, lids);
+    lids.clearBit(270);
+    assertLidStateVector({310,440,780,930,1490}, 310, 1490, lids);
+    lids.setBit(1990);
+    assertLidStateVector({310,440,780,930,1490,1990}, 310, 1990, lids);
+    lids.clearBit(310);
+    assertLidStateVector({440,780,930,1490,1990}, 440, 1990, lids);
+    lids.clearBit(440);
+    assertLidStateVector({780,930,1490,1990}, 780, 1990, lids);
+    lids.clearBit(780);
+    assertLidStateVector({930,1490,1990}, 930, 1990, lids);
+    lids.clearBit(930);
+    assertLidStateVector({1490,1990}, 1490, 1990, lids);
+    lids.clearBit(1490);
+    assertLidStateVector({1990}, 1990, 1990, lids);
+    lids.clearBit(1990);
+    assertLidStateVector({}, 2000, 0, lids);
+}
+
+}
+
+GTEST_MAIN_RUN_ALL_TESTS()