mdbxmou 0.1.26

package/deps/libmdbx/test/extra/early_close_dbi.c++

@@ -0,0 +1,137 @@
+#include "mdbx.h++"
+#include <cstring>
+#include <iostream>
+
+static const char *const testkey = "testkey";
+static uint64_t testval = 11;
+
+int doit() {
+  mdbx::path db_filename = "test-early_close_dbi";
+  mdbx::env_managed::remove(db_filename);
+
+  MDBX_env *environment;
+  MDBX_MAYBE_UNUSED int err = mdbx_env_create(&environment);
+  assert(err == MDBX_SUCCESS);
+
+  err = mdbx_env_set_option(environment, MDBX_opt_max_db, 2);
+  assert(err == MDBX_SUCCESS);
+  err = mdbx_env_set_option(environment, MDBX_opt_max_readers, 2);
+  assert(err == MDBX_SUCCESS);
+  // status = mdbx_env_set_option(environment, MDBX_opt_prefault_write_enable,
+  // 1); assert(err == MDBX_SUCCESS);
+
+  intptr_t lowerbound(0), size(0), upperbound(mdbx::env::geometry::GiB / 2);
+  intptr_t step(128 * mdbx::env::geometry::MiB), shrink(256 * mdbx::env::geometry::MiB), pagesize(-1);
+  err = mdbx_env_set_geometry(environment, lowerbound, size, upperbound, step, shrink, pagesize);
+  assert(err == MDBX_SUCCESS);
+
+  MDBX_env_flags_t flags(MDBX_NOSUBDIR | MDBX_WRITEMAP | MDBX_LIFORECLAIM | MDBX_NORDAHEAD);
+  err = mdbx_env_openT(environment, db_filename.c_str(), flags, 0644);
+  assert(err == MDBX_SUCCESS);
+
+  // ---
+
+  MDBX_txn *transaction;
+  err = mdbx_txn_begin(environment, nullptr, MDBX_TXN_READWRITE, &transaction);
+  assert(err == MDBX_SUCCESS);
+
+  MDBX_dbi textindex;
+  err = mdbx_dbi_open(transaction, "testdb", MDBX_DB_DEFAULTS, &textindex);
+  assert(err == MDBX_NOTFOUND);
+  err = mdbx_dbi_open(transaction, "testdb", MDBX_CREATE, &textindex);
+  assert(err == MDBX_SUCCESS);
+
+  MDBX_val mdbxkey{(void *)testkey, std::strlen(testkey)}, mdbxval{};
+  err = mdbx_get(transaction, textindex, &mdbxkey, &mdbxval);
+  assert(err == MDBX_NOTFOUND);
+
+  unsigned dbi_flags, dbi_state;
+  err = mdbx_dbi_flags_ex(transaction, textindex, &dbi_flags, &dbi_state);
+  assert(err == MDBX_SUCCESS);
+  assert((dbi_state & (MDBX_DBI_CREAT | MDBX_DBI_DIRTY)) != 0);
+  err = mdbx_dbi_close(environment, textindex);
+  assert(err == MDBX_DANGLING_DBI);
+
+  err = mdbx_txn_commit(transaction);
+  assert(err == MDBX_SUCCESS);
+
+  // ---
+
+  err = mdbx_txn_begin(environment, nullptr, MDBX_TXN_READWRITE, &transaction);
+  assert(err == MDBX_SUCCESS);
+
+  MDBX_val mdbxput{&testval, sizeof(uint64_t)};
+  err = mdbx_put(transaction, textindex, &mdbxkey, &mdbxput, MDBX_NOOVERWRITE);
+  assert(err == MDBX_SUCCESS);
+  err = mdbx_get(transaction, textindex, &mdbxkey, &mdbxval);
+  assert(err == MDBX_SUCCESS);
+  assert(testval == mdbx::slice(mdbxval).as_uint64());
+
+  err = mdbx_put(transaction, textindex, &mdbxkey, &mdbxput, MDBX_NOOVERWRITE);
+  assert(err == MDBX_KEYEXIST);
+  err = mdbx_get(transaction, textindex, &mdbxkey, &mdbxval);
+  assert(err == MDBX_SUCCESS);
+  assert(testval == mdbx::slice(mdbxval).as_uint64());
+
+  err = mdbx_dbi_flags_ex(transaction, textindex, &dbi_flags, &dbi_state);
+  assert(err == MDBX_SUCCESS);
+  assert((dbi_state & MDBX_DBI_DIRTY) != 0);
+  err = mdbx_dbi_close(environment, textindex);
+  assert(err == MDBX_DANGLING_DBI);
+  err = mdbx_txn_commit(transaction);
+  assert(err == MDBX_SUCCESS);
+
+  // ---
+
+  err = mdbx_txn_begin(environment, nullptr, MDBX_TXN_RDONLY, &transaction);
+  assert(err == MDBX_SUCCESS);
+  err = mdbx_get(transaction, textindex, &mdbxkey, &mdbxval);
+  assert(err == MDBX_SUCCESS);
+  assert(testval == mdbx::slice(mdbxval).as_uint64());
+
+  err = mdbx_dbi_close(environment, textindex);
+  assert(err == MDBX_SUCCESS);
+  err = mdbx_txn_commit(transaction);
+  assert(err == MDBX_SUCCESS);
+  err = mdbx_env_close_ex(environment, true);
+  assert(err == MDBX_SUCCESS);
+
+  // -------------------------------------------------------------------------
+
+  auto env = mdbx::env_managed(db_filename, mdbx::env_managed::operate_parameters(2));
+  auto txn = env.start_write();
+  auto dbi = txn.create_map("keller-case");
+  txn.commit();
+
+  txn = env.start_write();
+  txn.rename_map(dbi, "keller-case.renamed");
+  txn.commit();
+
+  txn = env.start_write();
+  auto dbi2 = txn.create_map("keller-case");
+  txn.drop_map(dbi);
+  txn.drop_map(dbi2);
+  txn.commit();
+
+  err = mdbx_dbi_close(env, dbi);
+  assert(err == MDBX_BAD_DBI);
+  if (err != MDBX_BAD_DBI)
+    return 1;
+  err = mdbx_dbi_close(env, dbi2);
+  assert(err == MDBX_BAD_DBI);
+  if (err != MDBX_BAD_DBI)
+    return 2;
+
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+  try {
+    return doit();
+  } catch (const std::exception &ex) {
+    std::cerr << "Exception: " << ex.what() << "\n";
+    return EXIT_FAILURE;
+  }
+}

package/deps/libmdbx/test/extra/hex_base64_base58.c++

@@ -0,0 +1,118 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "mdbx.h++"
+#include <array>
+#include <iostream>
+
+#include <functional>
+#include <random>
+
+using buffer = mdbx::default_buffer;
+
+std::default_random_engine prng(42);
+
+static buffer random(size_t length) {
+  buffer result(length);
+#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+  for (auto &i : result.bytes())
+    i = mdbx::byte(prng());
+#else
+  for (auto p = result.byte_ptr(); p < result.end_byte_ptr(); ++p)
+    *p = mdbx::byte(prng());
+#endif
+  return result;
+}
+
+static bool basic() {
+  bool ok = true;
+  const char *const hex_dump = "1D58fa\n2e46E3\nBd9c7A\nC0bF";
+  const uint8_t native[] = {0x1D, 0x58, 0xfa, 0x2e, 0x46, 0xE3, 0xBd, 0x9c, 0x7A, 0xC0, 0xbF};
+
+  if (mdbx::slice(hex_dump).hex_decode(true) != mdbx::slice::wrap(native))
+    std::cerr << "hex_decode() failed\n";
+  else if (mdbx::slice::wrap(native).encode_hex(true, 4).hex_decode(true) != mdbx::slice::wrap(native))
+    std::cerr << "hex_encode(UPPERCASE) failed\n";
+  else if (mdbx::slice::wrap(native).encode_hex(false).hex_decode(true) != mdbx::slice::wrap(native))
+    std::cerr << "hex_encode(lowercase) failed\n";
+
+  if (mdbx::slice("").as_base64_string() != "" || mdbx::slice(" ").encode_base64().as_string() != "IA==" ||
+      mdbx::slice("~0").encode_base64().as_string() != "fjA=" ||
+      mdbx::slice("A_z").encode_base64().as_string() != "QV96" ||
+      mdbx::slice("Ka9q").encode_base64().as_string() != "S2E5cQ==" ||
+      mdbx::slice("123456789").encode_base64().as_string() != "MTIzNDU2Nzg5") {
+    std::cerr << "encode_base64() failed\n";
+    ok = false;
+  }
+
+  const uint8_t base58_rfc[] = {0x00, 0x00, 0x28, 0x7f, 0xb4, 0xcd};
+  if (mdbx::slice("").as_base58_string() != "" || mdbx::slice(" ").encode_base58().as_string() != "Z" ||
+      mdbx::slice("Hello World!").as_base58_string() != "2NEpo7TZRRrLZSi2U" ||
+      mdbx::slice("The quick brown fox jumps over the lazy dog.").encode_base58().as_string() !=
+          "USm3fpXnKG5EUBx2ndxBDMPVciP5hGey2Jh4NDv6gmeo1LkMeiKrLJUUBk6Z" ||
+      mdbx::slice::wrap(base58_rfc).as_base58_string() != "11233QC4" ||
+      mdbx::slice("~0").encode_base58().as_string() != "Aby" ||
+      mdbx::slice("A_z").encode_base58().as_string() != "NxZw" ||
+      mdbx::slice("Ka9q").encode_base58().as_string() != "2vkjDi" ||
+      mdbx::slice("123456789").encode_base58().as_string() != "dKYWwnRHc7Ck") {
+    std::cerr << "encode_base58() failed\n";
+    ok = false;
+  }
+
+  if (mdbx::slice("").base58_decode() != mdbx::slice() || mdbx::slice("Z").base58_decode() != mdbx::slice(" ") ||
+      mdbx::slice("2NEpo7TZRRrLZSi2U").base58_decode() != "Hello World!" ||
+      mdbx::slice("USm3fpXnKG5EUBx2ndxBDMPVciP5hGey2Jh4NDv6gmeo1LkMeiKrLJUUBk6Z").base58_decode() !=
+          mdbx::slice("The quick brown fox jumps over the lazy dog.") ||
+      mdbx::slice("11233QC4").base58_decode() != mdbx::slice::wrap(base58_rfc) ||
+      mdbx::slice("Aby").base58_decode() != mdbx::slice("~0") ||
+      mdbx::slice("NxZw").base58_decode() != mdbx::slice("A_z") ||
+      mdbx::slice("2vkjDi").base58_decode() != mdbx::slice("Ka9q") ||
+      mdbx::slice("dKYWwnRHc7Ck").base58_decode() != mdbx::slice("123456789")) {
+    std::cerr << "decode_base58() failed\n";
+    ok = false;
+  }
+
+  return ok;
+}
+
+int doit() {
+  auto ok = basic();
+  for (size_t n = 0; n < 1000; ++n) {
+    for (size_t length = 0; ok && length < 111; ++length) {
+      const auto pattern = random(length);
+      if (pattern !=
+          pattern.encode_hex(bool(prng() & 1), prng() % 111).hex_decode(true).encode_hex().hex_decode(false)) {
+        std::cerr << "hex encode/decode failed: n " << n << ", length " << length << std::endl;
+        ok = false;
+      }
+      if (pattern !=
+          pattern.encode_base64(unsigned(prng() % 111)).base64_decode(true).encode_base64().base64_decode(false)) {
+        std::cerr << "base64 encode/decode failed: n " << n << ", length " << length << std::endl;
+        ok = false;
+      }
+      if (pattern !=
+          pattern.encode_base58(unsigned(prng() % 111)).base58_decode(true).encode_base58().base58_decode(false)) {
+        std::cerr << "base58 encode/decode failed: n " << n << ", length " << length << std::endl;
+        ok = false;
+      }
+    }
+  }
+
+  if (!ok) {
+    std::cerr << "Fail\n";
+    return EXIT_FAILURE;
+  }
+  std::cout << "OK\n";
+  return EXIT_SUCCESS;
+}
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+  try {
+    return doit();
+  } catch (const std::exception &ex) {
+    std::cerr << "Exception: " << ex.what() << "\n";
+    return EXIT_FAILURE;
+  }
+}

package/deps/libmdbx/test/extra/maindb_ordinal.c++

@@ -0,0 +1,61 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "mdbx.h++"
+#include <iostream>
+
+static int doit() {
+  mdbx::path db_filename = "test-maindb-ordinal";
+  mdbx::env_managed::remove(db_filename);
+  mdbx::env_managed env(db_filename, mdbx::env_managed::create_parameters(), mdbx::env::operate_parameters());
+
+  using buffer = mdbx::buffer<mdbx::default_allocator, mdbx::default_capacity_policy>;
+  auto txn = env.start_write();
+  auto map = txn.create_map(nullptr, mdbx::key_mode::ordinal, mdbx::value_mode::single);
+#if 0 /* workaround */
+  txn.commit();
+  env.close();
+  env = mdbx::env_managed(db_filename, mdbx::env_managed::create_parameters(),
+                        mdbx::env::operate_parameters());
+  txn = env.start_write();
+#endif
+
+  txn.insert(map, buffer::key_from_u64(UINT64_C(8) << 8 * 0), buffer("a"));
+  txn.insert(map, buffer::key_from_u64(UINT64_C(7) << 8 * 1), buffer("b"));
+  txn.insert(map, buffer::key_from_u64(UINT64_C(6) << 8 * 2), buffer("c"));
+  txn.insert(map, buffer::key_from_u64(UINT64_C(5) << 8 * 3), buffer("d"));
+  txn.insert(map, buffer::key_from_u64(UINT64_C(4) << 8 * 4), buffer("e"));
+  txn.insert(map, buffer::key_from_u64(UINT64_C(3) << 8 * 5), buffer("f"));
+  txn.insert(map, buffer::key_from_u64(UINT64_C(2) << 8 * 6), buffer("g"));
+  txn.insert(map, buffer::key_from_u64(UINT64_C(1) << 8 * 7), buffer("h"));
+  txn.commit();
+
+  txn = env.start_read();
+  auto cursor = txn.open_cursor(map);
+#if defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L
+  if (cursor.to_first().value.string_view() == "a" && cursor.to_next().value.string_view() == "b" &&
+      cursor.to_next().value.string_view() == "c" && cursor.to_next().value.string_view() == "d" &&
+      cursor.to_next().value.string_view() == "e" && cursor.to_next().value.string_view() == "f" &&
+      cursor.to_next().value.string_view() == "g" && cursor.to_next().value.string_view() == "h" &&
+      !cursor.to_next(false).done && cursor.eof()) {
+    std::cout << "OK\n";
+    return EXIT_SUCCESS;
+  }
+  std::cerr << "Fail\n";
+  return EXIT_FAILURE;
+#else
+  std::cerr << "Skipped since no std::string_view\n";
+  return EXIT_SUCCESS;
+#endif /* __cpp_lib_string_view >= 201606L */
+}
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+  try {
+    return doit();
+  } catch (const std::exception &ex) {
+    std::cerr << "Exception: " << ex.what() << "\n";
+    return EXIT_FAILURE;
+  }
+}

package/deps/libmdbx/test/extra/open.c++

@@ -0,0 +1,96 @@
+#include "mdbx.h++"
+
+#include <iostream>
+
+#if !defined(__cpp_lib_latch) && __cpp_lib_latch < 201907L
+
+int main(int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+  std::cout << "FAKE-OK (since no C++20 std::thread and/or std::latch)\n";
+  return EXIT_SUCCESS;
+}
+
+#else
+
+#include <latch>
+#include <thread>
+
+static char log_buffer[1024];
+
+static void logger_nofmt(MDBX_log_level_t loglevel, const char *function, int line, const char *msg,
+                         unsigned length) noexcept {
+  (void)length;
+  (void)loglevel;
+  fprintf(stdout, "%s:%u %s", function, line, msg);
+}
+
+int doit() {
+  mdbx::path path = "test-open";
+  mdbx::env::remove(path);
+
+  {
+    mdbx::env::operate_parameters operateParameters2(100, 10);
+    mdbx::env_managed::create_parameters createParameters2;
+    createParameters2.geometry.make_fixed(42 * mdbx::env::geometry::MiB);
+    mdbx::env_managed env2(path, createParameters2, operateParameters2);
+    mdbx::txn_managed txn2 = env2.start_write(false);
+    /* mdbx::map_handle testHandle2 = */ txn2.create_map("fap1", mdbx::key_mode::reverse, mdbx::value_mode::single);
+    txn2.commit();
+  }
+
+  {
+    mdbx::env::operate_parameters operateParameters(100, 10);
+    mdbx::env_managed::create_parameters createParameters;
+    createParameters.geometry.make_dynamic(21 * mdbx::env::geometry::MiB, mdbx::env::geometry::GiB / 2);
+    mdbx::env_managed env(path, createParameters, operateParameters);
+  }
+
+  mdbx::env::operate_parameters operateParameters(100, 10);
+  mdbx::env_managed::create_parameters createParameters;
+  createParameters.geometry.make_dynamic(21 * mdbx::env::geometry::MiB, 84 * mdbx::env::geometry::MiB);
+  mdbx::env_managed env(path, createParameters, operateParameters);
+  mdbx::txn_managed txn = env.start_write(false);
+  /* mdbx::map_handle testHandle = */ txn.create_map("fap1", mdbx::key_mode::usual, mdbx::value_mode::single);
+  txn.commit();
+
+  std::latch starter(1);
+
+  std::thread t1([&]() {
+    starter.wait();
+    // mdbx::env_managed env(path, createParameters, operateParameters);
+    mdbx::txn_managed txn = env.start_write(false);
+    /* mdbx::map_handle testHandle = */ txn.create_map("fap1", mdbx::key_mode::usual, mdbx::value_mode::single);
+    txn.commit();
+  });
+
+  std::thread t2([&]() {
+    starter.wait();
+    // mdbx::env_managed env(path, createParameters, operateParameters);
+    mdbx::txn_managed txn = env.start_write(false);
+    /* mdbx::map_handle testHandle = */ txn.create_map("fap1", mdbx::key_mode::usual, mdbx::value_mode::single);
+    txn.commit();
+  });
+
+  starter.count_down();
+
+  t1.join();
+  t2.join();
+
+  std::cout << "OK\n";
+  return EXIT_SUCCESS;
+}
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+  mdbx_setup_debug_nofmt(MDBX_LOG_VERBOSE, MDBX_DBG_ASSERT, logger_nofmt, log_buffer, sizeof(log_buffer));
+  try {
+    return doit();
+  } catch (const std::exception &ex) {
+    std::cerr << "Exception: " << ex.what() << "\n";
+    return EXIT_FAILURE;
+  }
+}
+
+#endif /* __cpp_lib_latch */

package/deps/libmdbx/test/extra/pcrf/README.md

@@ -0,0 +1,2 @@
+PCRF Session DB emulation test
+