Merge commit '79159ffd87bf86e92ab5af6fffd5cc93c205a630' as 'src/nudb'

2025-12-06 17:27:55 +00:00 · 2016-09-29 19:24:13 -04:00
parent 231a5ae6fb 79159ffd87
commit bd93ecbd6b
113 changed files with 15806 additions and 0 deletions
--- a/src/nudb/test/rekey.cpp
+++ b/src/nudb/test/rekey.cpp
@@ -0,0 +1,136 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Test that header file is self-contained
+#include <nudb/rekey.hpp>
+
+#include <nudb/test/fail_file.hpp>
+#include <nudb/test/test_store.hpp>
+#include <nudb/progress.hpp>
+#include <nudb/verify.hpp>
+#include <beast/unit_test/suite.hpp>
+
+namespace nudb {
+namespace test {
+
+// Simple test to check that rekey works, and
+// also to exercise all its failure paths.
+//
+class rekey_test : public beast::unit_test::suite
+{
+public:
+    void
+    do_recover(
+        std::size_t N, nsize_t blockSize, float loadFactor)
+    {
+        using key_type = std::uint32_t;
+
+        auto const keys = static_cast<std::size_t>(
+            loadFactor * detail::bucket_capacity(blockSize));
+        std::size_t const bufferSize =
+            (blockSize * (1 + ((N + keys - 1) / keys)))
+                / 2;
+        error_code ec;
+        test_store ts{sizeof(key_type), blockSize, loadFactor};
+        ts.create(ec);
+        if(! BEAST_EXPECTS(! ec, ec.message()))
+            return;
+        ts.open(ec);
+        if(! BEAST_EXPECTS(! ec, ec.message()))
+            return;
+        // Insert
+        for(std::size_t i = 0; i < N; ++i)
+        {
+            auto const item = ts[i];
+            ts.db.insert(item.key, item.data, item.size, ec);
+            if(! BEAST_EXPECTS(! ec, ec.message()))
+                return;
+        }
+        ts.close(ec);
+        if(! BEAST_EXPECTS(! ec, ec.message()))
+            return;
+        // Verify
+        verify_info info;
+        verify<xxhasher>(
+            info, ts.dp, ts.kp, bufferSize, no_progress{}, ec);
+        if(! BEAST_EXPECTS(! ec, ec.message()))
+            return;
+        if(! BEAST_EXPECT(info.value_count == N))
+            return;
+        if(! BEAST_EXPECT(info.spill_count > 0))
+            return;
+        // Rekey
+        auto const kp2 = ts.kp + "2";
+        for(std::size_t n = 1;; ++n)
+        {
+            fail_counter fc{n};
+            rekey<xxhasher, fail_file<native_file>>(
+                ts.dp, kp2, ts.lp, blockSize, loadFactor,
+                    N, bufferSize, ec, no_progress{}, fc);
+            if(! ec)
+                break;
+            if(! BEAST_EXPECTS(ec ==
+                    test::test_error::failure, ec.message()))
+                return;
+            ec = {};
+            recover<xxhasher, native_file>(
+                ts.dp, kp2, ts.lp, ec);
+            if(ec == error::no_key_file ||
+                ec == errc::no_such_file_or_directory)
+            {
+                ec = {};
+                continue;
+            }
+            if(! BEAST_EXPECTS(! ec, ec.message()))
+                return;
+            native_file::erase(kp2, ec);
+            if(ec == errc::no_such_file_or_directory)
+                ec = {};
+            if(! BEAST_EXPECTS(! ec, ec.message()))
+                return;
+            // Verify
+            verify<xxhasher>(info, ts.dp, ts.kp,
+                bufferSize, no_progress{}, ec);
+            if(! BEAST_EXPECTS(! ec, ec.message()))
+                return;
+            if(! BEAST_EXPECT(info.value_count == N))
+                return;
+        }
+        // Verify
+        verify<xxhasher>(info, ts.dp, ts.kp,
+            bufferSize, no_progress{}, ec);
+        if(! BEAST_EXPECTS(! ec, ec.message()))
+            return;
+        if(! BEAST_EXPECT(info.value_count == N))
+            return;
+        verify<xxhasher>(info, ts.dp, kp2,
+            bufferSize, no_progress{}, ec);
+        if(! BEAST_EXPECTS(! ec, ec.message()))
+            return;
+        if(! BEAST_EXPECT(info.value_count == N))
+            return;
+    }
+
+    void
+    run() override
+    {
+        enum
+        {
+            N =         50000,
+            blockSize = 256
+        };
+
+        float const loadFactor = 0.95f;
+
+        do_recover(N, blockSize, loadFactor);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(rekey, test, nudb);
+
+} // test
+} // nudb