mdbxmou 0.1.26

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

@@ -0,0 +1,253 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "mdbx.h++"
+#include <array>
+#include <functional>
+#include <iostream>
+#include <random>
+
+static ::std::ostream &operator<<(::std::ostream &out, const mdbx::cursor::move_operation op) {
+  static const char *const str[] = {"FIRST",
+                                    "FIRST_DUP",
+                                    "GET_BOTH",
+                                    "GET_BOTH_RANGE",
+                                    "GET_CURRENT",
+                                    "GET_MULTIPLE",
+                                    "LAST",
+                                    "LAST_DUP",
+                                    "NEXT",
+                                    "NEXT_DUP",
+                                    "NEXT_MULTIPLE",
+                                    "NEXT_NODUP",
+                                    "PREV",
+                                    "PREV_DUP",
+                                    "PREV_NODUP",
+                                    "SET",
+                                    "SET_KEY",
+                                    "SET_RANGE",
+                                    "PREV_MULTIPLE",
+                                    "SET_LOWERBOUND",
+                                    "SET_UPPERBOUND",
+                                    "TO_KEY_LESSER_THAN",
+                                    "TO_KEY_LESSER_OR_EQUAL",
+                                    "TO_KEY_EQUAL",
+                                    "TO_KEY_GREATER_OR_EQUAL",
+                                    "TO_KEY_GREATER_THAN",
+                                    "TO_EXACT_KEY_VALUE_LESSER_THAN",
+                                    "TO_EXACT_KEY_VALUE_LESSER_OR_EQUAL",
+                                    "TO_EXACT_KEY_VALUE_EQUAL",
+                                    "TO_EXACT_KEY_VALUE_GREATER_OR_EQUAL",
+                                    "TO_EXACT_KEY_VALUE_GREATER_THAN",
+                                    "TO_PAIR_LESSER_THAN",
+                                    "TO_PAIR_LESSER_OR_EQUAL",
+                                    "TO_PAIR_EQUAL",
+                                    "TO_PAIR_GREATER_OR_EQUAL",
+                                    "TO_PAIR_GREATER_THAN"};
+  return out << str[op];
+}
+
+using buffer = mdbx::default_buffer;
+using buffer_pair = mdbx::buffer_pair<buffer>;
+
+std::default_random_engine prng(42);
+
+static buffer random(const unsigned &value) {
+  switch (prng() % 3) {
+  default:
+    return buffer::hex(value);
+  case 1:
+    return buffer::base64(value);
+  case 2:
+    return buffer::base58(value);
+  }
+}
+
+static buffer random_key() { return random(prng() % 10007); }
+
+static buffer random_value() { return random(prng() % 47); }
+
+using predicate = std::function<bool(const mdbx::pair &, const mdbx::pair &)>;
+
+static bool probe(mdbx::txn txn, mdbx::map_handle dbi, mdbx::cursor::move_operation op, predicate cmp,
+                  const buffer_pair &pair) {
+  auto seeker = txn.open_cursor(dbi);
+  auto scanner = seeker.clone();
+
+  const bool scan_backward = op == mdbx::cursor::key_lesser_than || op == mdbx::cursor::key_lesser_or_equal ||
+                             op == mdbx::cursor::multi_exactkey_value_lesser_than ||
+                             op == mdbx::cursor::multi_exactkey_value_lesser_or_equal ||
+                             op == mdbx::cursor::pair_lesser_than || op == mdbx::cursor::pair_lesser_or_equal;
+
+  const bool is_multi = mdbx::is_multi(txn.get_handle_info(dbi).value_mode());
+
+  auto seek_result = seeker.move(op, pair.key, pair.value, false);
+  auto scan_result =
+      scanner.fullscan([cmp, &pair](const mdbx::pair &scan) -> bool { return cmp(scan, pair); }, scan_backward);
+  if (seek_result.done == scan_result &&
+      (!scan_result ||
+       seeker.is_same_position(scanner, op < mdbx::cursor::multi_exactkey_value_lesser_than && is_multi)))
+    return true;
+
+  std::cerr << std::endl;
+  std::cerr << "bug:";
+  std::cerr << std::endl;
+  std::cerr << std::string(is_multi ? "multi" : "single") << "-map, op " << op << ", key " << pair.key << ", value "
+            << pair.value;
+  std::cerr << std::endl;
+  std::cerr << "\tscanner: ";
+  if (scan_result)
+    std::cerr << "     done, key " << scanner.current(false).key << ", value " << scanner.current(false).value;
+  else
+    std::cerr << "not-found";
+  std::cerr << std::endl;
+  std::cerr << "\t seeker: " << (seek_result.done ? "     done" : "not-found") << ", key " << seek_result.key
+            << ", value " << seek_result.value;
+  std::cerr << std::endl;
+  return false;
+}
+
+static bool probe(mdbx::txn txn, mdbx::map_handle dbi, mdbx::cursor::move_operation op, predicate cmp) {
+  const auto pair = buffer_pair(random_key(), random_value());
+  const bool ok = probe(txn, dbi, op, cmp, pair);
+#if MDBX_DEBUG
+  if (!ok)
+    // повтор для отладки и поиска причин
+    probe(txn, dbi, op, cmp, pair);
+#endif /* MDBX_DEBUG */
+  return ok;
+}
+
+static bool test(mdbx::txn txn, mdbx::map_handle dbi) {
+  bool ok = true;
+
+  ok = probe(txn, dbi, mdbx::cursor::key_lesser_than,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) < 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::key_lesser_or_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) <= 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::key_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) == 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::key_greater_or_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) >= 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::key_greater_than,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) > 0;
+             }) &&
+       ok;
+
+  ok = probe(txn, dbi, mdbx::cursor::multi_exactkey_value_lesser_than,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) == 0 && mdbx_dcmp(txn, dbi, l.value, r.value) < 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::multi_exactkey_value_lesser_or_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) == 0 && mdbx_dcmp(txn, dbi, l.value, r.value) <= 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::multi_exactkey_value_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) == 0 && mdbx_dcmp(txn, dbi, l.value, r.value) == 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::multi_exactkey_value_greater_or_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) == 0 && mdbx_dcmp(txn, dbi, l.value, r.value) >= 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::multi_exactkey_value_greater,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               return mdbx_cmp(txn, dbi, l.key, r.key) == 0 && mdbx_dcmp(txn, dbi, l.value, r.value) > 0;
+             }) &&
+       ok;
+
+  ok = probe(txn, dbi, mdbx::cursor::pair_lesser_than,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               auto cmp = mdbx_cmp(txn, dbi, l.key, r.key);
+               if (cmp == 0)
+                 cmp = mdbx_dcmp(txn, dbi, l.value, r.value);
+               return cmp < 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::pair_lesser_or_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               auto cmp = mdbx_cmp(txn, dbi, l.key, r.key);
+               if (cmp == 0)
+                 cmp = mdbx_dcmp(txn, dbi, l.value, r.value);
+               return cmp <= 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::pair_equal,
+             [](const mdbx::pair &l, const mdbx::pair &r) -> bool { return l == r; }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::pair_greater_or_equal,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               auto cmp = mdbx_cmp(txn, dbi, l.key, r.key);
+               if (cmp == 0)
+                 cmp = mdbx_dcmp(txn, dbi, l.value, r.value);
+               return cmp >= 0;
+             }) &&
+       ok;
+  ok = probe(txn, dbi, mdbx::cursor::pair_greater_than,
+             [txn, dbi](const mdbx::pair &l, const mdbx::pair &r) -> bool {
+               auto cmp = mdbx_cmp(txn, dbi, l.key, r.key);
+               if (cmp == 0)
+                 cmp = mdbx_dcmp(txn, dbi, l.value, r.value);
+               return cmp > 0;
+             }) &&
+       ok;
+  return ok;
+}
+
+int doit() {
+  mdbx::path db_filename = "test-posi";
+  mdbx::env_managed::remove(db_filename);
+  mdbx::env_managed env(db_filename, mdbx::env_managed::create_parameters(), mdbx::env::operate_parameters(3));
+
+  auto txn = env.start_write();
+  auto single = txn.create_map("single", mdbx::key_mode::usual, mdbx::value_mode::single);
+  auto multi = txn.create_map("multi", mdbx::key_mode::usual, mdbx::value_mode::multi);
+  for (size_t i = 0; i < 1000; ++i) {
+    auto key = random_key();
+    txn.upsert(single, key, random_value());
+    for (auto n = prng() % 5 + 1; n > 0; --n)
+      txn.upsert(multi, key, random_value());
+  }
+  txn.commit_embark_read();
+
+  bool ok = true;
+  for (size_t i = 0; ok && i < 3333; ++i) {
+    ok = test(txn, single) && ok;
+    ok = test(txn, multi) && ok;
+  }
+
+  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/dupfix_addodd.c

@@ -0,0 +1,94 @@
+/*
+ * @Dvirsw (https://t.me/Dvirsw)
+ * I think there is a bug with DUPFIXED. The following code fails.
+ *
+ * https://t.me/libmdbx/5368
+ */
+
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#include "mdbx.h"
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main() {
+  int rc;
+  MDBX_env *env = NULL;
+  MDBX_dbi dbi = 0;
+  MDBX_val key, data;
+  MDBX_txn *txn = NULL;
+
+  const char *db_filename = "./test-dupfix-addodd";
+  mdbx_env_delete(db_filename, MDBX_ENV_JUST_DELETE);
+
+  rc = mdbx_env_create(&env);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_env_create: (%d) %s\n", rc, mdbx_strerror(rc));
+    exit(EXIT_FAILURE);
+  }
+
+  rc = mdbx_env_set_maxdbs(env, 1);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_env_create: (%d) %s\n", rc, mdbx_strerror(rc));
+    exit(EXIT_FAILURE);
+  }
+
+  rc = mdbx_env_open(env, db_filename, MDBX_NOSUBDIR | MDBX_LIFORECLAIM, 0664);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_env_open: (%d) %s\n", rc, mdbx_strerror(rc));
+    exit(EXIT_FAILURE);
+  }
+
+  rc = mdbx_txn_begin(env, NULL, 0, &txn);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_txn_begin: (%d) %s\n", rc, mdbx_strerror(rc));
+    exit(EXIT_FAILURE);
+  }
+
+  rc = mdbx_dbi_open(txn, "test", MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_CREATE, &dbi);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_dbi_open: (%d) %s\n", rc, mdbx_strerror(rc));
+    exit(EXIT_FAILURE);
+  }
+
+  char key_bytes[32] = {0};
+  key.iov_len = 32;
+  key.iov_base = key_bytes;
+
+  // Another put after this will fail.
+  unsigned char idx;
+  for (idx = 0; idx < 129; idx++) {
+    char data_bytes[15] = {idx};
+    data.iov_len = 15;
+    data.iov_base = data_bytes;
+    rc = mdbx_put(txn, dbi, &key, &data, 0);
+    if (rc != MDBX_SUCCESS) {
+      fprintf(stderr, "mdbx_put: (%d) %s\n", rc, mdbx_strerror(rc));
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  // This will fail and exit.
+  char data_bytes[15] = {idx};
+  data.iov_len = 15;
+  data.iov_base = data_bytes;
+  rc = mdbx_put(txn, dbi, &key, &data, 0);
+  if (rc != MDBX_SUCCESS) {
+    fprintf(stderr, "mdbx_put: (%d) %s\n", rc, mdbx_strerror(rc));
+    fprintf(stderr, "expected failure\n");
+    exit(EXIT_FAILURE);
+  }
+
+  rc = mdbx_txn_commit(txn);
+  if (rc) {
+    fprintf(stderr, "mdbx_txn_commit: (%d) %s\n", rc, mdbx_strerror(rc));
+    exit(EXIT_FAILURE);
+  }
+}

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

@@ -0,0 +1,311 @@
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+/// \copyright SPDX-License-Identifier: Apache-2.0
+
+#include "mdbx.h++"
+#include <chrono>
+#include <iostream>
+
+#if defined(ENABLE_MEMCHECK) || defined(MDBX_CI)
+#if MDBX_DEBUG || !defined(NDEBUG)
+#define RELIEF_FACTOR 16
+#else
+#define RELIEF_FACTOR 8
+#endif
+#elif MDBX_DEBUG || !defined(NDEBUG) || defined(__APPLE__) || defined(_WIN32)
+#define RELIEF_FACTOR 4
+#elif UINTPTR_MAX > 0xffffFFFFul || ULONG_MAX > 0xffffFFFFul
+#define RELIEF_FACTOR 2
+#else
+#define RELIEF_FACTOR 1
+#endif
+
+using buffer = mdbx::default_buffer;
+
+bool case1_ordering(mdbx::env env) {
+  auto txn = env.start_write();
+  auto map = txn.create_map("case1", mdbx::key_mode::ordinal, mdbx::value_mode::multi_ordinal);
+
+  txn.insert(map, buffer::key_from_u64(21), buffer::key_from_u64(18));
+  txn.insert(map, buffer::key_from_u64(7), buffer::key_from_u64(19));
+  txn.insert(map, buffer::key_from_u64(22), buffer::key_from_u64(17));
+  txn.insert(map, buffer::key_from_u64(26), buffer::key_from_u64(13));
+  txn.insert(map, buffer::key_from_u64(24), buffer::key_from_u64(15));
+  txn.insert(map, buffer::key_from_u64(23), buffer::key_from_u64(16));
+  txn.insert(map, buffer::key_from_u64(25), buffer::key_from_u64(14));
+  txn.insert(map, buffer::key_from_u64(27), buffer::key_from_u64(12));
+  txn.commit();
+
+  txn = env.start_read();
+  auto cursor = txn.open_cursor(map);
+  if (cursor.to_first().value.as_uint64() != 19 || cursor.to_next().value.as_uint64() != 18 ||
+      cursor.to_next().value.as_uint64() != 17 || cursor.to_next().value.as_uint64() != 16 ||
+      cursor.to_next().value.as_uint64() != 15 || cursor.to_next().value.as_uint64() != 14 ||
+      cursor.to_next().value.as_uint64() != 13 || cursor.to_next().value.as_uint64() != 12 ||
+      cursor.to_next(false).done || !cursor.eof())
+    return false;
+
+  txn.abort();
+
+  const uint64_t array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 42, 17, 99, 0, 33, 333};
+  txn = env.start_write();
+  txn.put_multiple_samelength(map, buffer::key_from_u64(13), array + 3, 4, mdbx::upsert);
+  txn.put_multiple_samelength(map, buffer::key_from_u64(10), array + 0, 1, mdbx::upsert);
+  txn.put_multiple_samelength(map, buffer::key_from_u64(12), array + 2, 3, mdbx::upsert);
+  txn.put_multiple_samelength(map, buffer::key_from_u64(15), array + 5, 6, mdbx::upsert);
+  txn.put_multiple_samelength(map, buffer::key_from_u64(14), array + 4, 5, mdbx::upsert);
+  txn.put_multiple_samelength(map, buffer::key_from_u64(11), array + 1, 2, mdbx::upsert);
+  txn.put_multiple_samelength(map, buffer::key_from_u64(16), array + 6, 7, mdbx::upsert);
+  txn.commit();
+
+  txn = env.start_read();
+  cursor = txn.open_cursor(map);
+  if (/* key = 7 */ cursor.to_first().value.as_uint64() != 19 ||
+
+      /* key = 10: 1 элемент */
+      cursor.to_next().value.as_uint64() != 1 ||
+
+      /* key = 11: 2 элемента, пропуск 1 */
+      cursor.to_next().value.as_uint64() != 2 || cursor.to_next().value.as_uint64() != 3 ||
+
+      /* key = 12: 3 элемента, пропуск 2 */
+      cursor.to_next().value.as_uint64() != 3 || cursor.to_next().value.as_uint64() != 4 ||
+      cursor.to_next().value.as_uint64() != 5 ||
+
+      /* key = 13: 4 элемента, пропуск 3 */
+      cursor.to_next().value.as_uint64() != 4 || cursor.to_next().value.as_uint64() != 5 ||
+      cursor.to_next().value.as_uint64() != 6 || cursor.to_next().value.as_uint64() != 7 ||
+
+      /* key = 14: 5 элементов, пропуск 4 */
+      cursor.to_next().value.as_uint64() != 5 || cursor.to_next().value.as_uint64() != 6 ||
+      cursor.to_next().value.as_uint64() != 7 || cursor.to_next().value.as_uint64() != 8 ||
+      cursor.to_next().value.as_uint64() != 9 ||
+
+      /* key = 15: 6 элементов, пропуск 5 */
+      cursor.to_next().value.as_uint64() != 6 || cursor.to_next().value.as_uint64() != 7 ||
+      cursor.to_next().value.as_uint64() != 8 || cursor.to_next().value.as_uint64() != 9 ||
+      cursor.to_next().value.as_uint64() != 17 || cursor.to_next().value.as_uint64() != 42 ||
+
+      /* key = 16: 7 элементов, пропуск 6 */
+      cursor.to_next().value.as_uint64() != 0 || cursor.to_next().value.as_uint64() != 7 ||
+      cursor.to_next().value.as_uint64() != 8 || cursor.to_next().value.as_uint64() != 9 ||
+      cursor.to_next().value.as_uint64() != 17 || cursor.to_next().value.as_uint64() != 42 ||
+      cursor.to_next().value.as_uint64() != 99 ||
+
+      /* key = 21 */ cursor.to_next().value.as_uint64() != 18 ||
+      /* key = 22 */ cursor.to_next().value.as_uint64() != 17 ||
+      /* key = 23 */ cursor.to_next().value.as_uint64() != 16 ||
+      /* key = 24 */ cursor.to_next().value.as_uint64() != 15 ||
+      /* key = 25 */ cursor.to_next().value.as_uint64() != 14 ||
+      /* key = 26 */ cursor.to_next().value.as_uint64() != 13 ||
+      /* key = 27 */ cursor.to_next().value.as_uint64() != 12 || cursor.to_next(false).done || !cursor.eof())
+    return false;
+
+  txn.abort();
+
+  txn = env.start_write();
+  txn.put_multiple_samelength(map, buffer::key_from_u64(7), array + 3, 4, mdbx::update);
+  txn.upsert(map, buffer::key_from_u64(10), buffer::key_from_u64(14));
+  txn.put_multiple_samelength(map, buffer::key_from_u64(11), array + 4, 5, mdbx::upsert);
+  txn.put_multiple_samelength(map, buffer::key_from_u64(12), array + 0, 1, mdbx::update);
+  txn.update(map, buffer::key_from_u64(13), buffer::key_from_u64(18));
+  txn.put_multiple_samelength(map, buffer::key_from_u64(14), array + 2, 3, mdbx::update);
+  txn.update(map, buffer::key_from_u64(15), buffer::key_from_u64(13));
+  txn.put_multiple_samelength(map, buffer::key_from_u64(16), array + 6, 9, mdbx::update);
+  txn.update(map, buffer::key_from_u64(21), buffer::key_from_u64(17));
+  txn.update(map, buffer::key_from_u64(22), buffer::key_from_u64(15));
+  txn.put_multiple_samelength(map, buffer::key_from_u64(23), array + 1, 2, mdbx::update);
+  txn.update(map, buffer::key_from_u64(24), buffer::key_from_u64(16));
+  txn.put_multiple_samelength(map, buffer::key_from_u64(25), array + 5, 6, mdbx::update);
+  txn.upsert(map, buffer::key_from_u64(26), buffer::key_from_u64(12));
+  txn.put_multiple_samelength(map, buffer::key_from_u64(27), array + 12, 3, mdbx::update);
+  txn.commit();
+
+  txn = env.start_read();
+  cursor = txn.open_cursor(map);
+  if (/* key = 7 */
+      cursor.to_first().value.as_uint64() != 4 || cursor.to_next().value.as_uint64() != 5 ||
+      cursor.to_next().value.as_uint64() != 6 || cursor.to_next().value.as_uint64() != 7 ||
+
+      /* key = 10: 1 элемент */
+      cursor.to_next().value.as_uint64() != 1 ||
+      /* +1 upsert */
+      cursor.to_next().value.as_uint64() != 14 ||
+
+      /* key = 11: 2 элемента, пропуск 1 */
+      cursor.to_next().value.as_uint64() != 2 || cursor.to_next().value.as_uint64() != 3 ||
+      /* +5 элементов, пропуск 4 */
+      cursor.to_next().value.as_uint64() != 5 || cursor.to_next().value.as_uint64() != 6 ||
+      cursor.to_next().value.as_uint64() != 7 || cursor.to_next().value.as_uint64() != 8 ||
+      cursor.to_next().value.as_uint64() != 9 ||
+
+      /* key = 12: 1 элемент */
+      cursor.to_next().value.as_uint64() != 1 ||
+      /* key = 13 */ cursor.to_next().value.as_uint64() != 18 ||
+
+      /* key = 14: 3 элемента, пропуск 2 */
+      cursor.to_next().value.as_uint64() != 3 || cursor.to_next().value.as_uint64() != 4 ||
+      cursor.to_next().value.as_uint64() != 5 ||
+
+      /* key = 15 */ cursor.to_next().value.as_uint64() != 13 ||
+
+      /* key = 16: 9 элементов, пропуск 6 */
+      cursor.to_next().value.as_uint64() != 0 || cursor.to_next().value.as_uint64() != 7 ||
+      cursor.to_next().value.as_uint64() != 8 || cursor.to_next().value.as_uint64() != 9 ||
+      cursor.to_next().value.as_uint64() != 17 || cursor.to_next().value.as_uint64() != 33 ||
+      cursor.to_next().value.as_uint64() != 42 || cursor.to_next().value.as_uint64() != 99 ||
+      cursor.to_next().value.as_uint64() != 333 ||
+
+      /* key = 21 */ cursor.to_next().value.as_uint64() != 17 ||
+      /* key = 22 */ cursor.to_next().value.as_uint64() != 15 ||
+      /* key = 23: 2 элемента, пропуск 1 */
+      cursor.to_next().value.as_uint64() != 2 || cursor.to_next().value.as_uint64() != 3 ||
+      /* key = 24 */ cursor.to_next().value.as_uint64() != 16 ||
+      /* key = 25: 6 элемента, пропуск 5 */
+      cursor.to_next().value.as_uint64() != 6 || cursor.to_next().value.as_uint64() != 7 ||
+      cursor.to_next().value.as_uint64() != 8 || cursor.to_next().value.as_uint64() != 9 ||
+      cursor.to_next().value.as_uint64() != 17 || cursor.to_next().value.as_uint64() != 42 ||
+
+      /* key = 26, 1+1 upsert */
+      cursor.to_next().value.as_uint64() != 12 || cursor.to_next().value.as_uint64() != 13 ||
+
+      /* key = 27: 3 элемента, пропуск 12 */
+      cursor.to_next().value.as_uint64() != 0 || cursor.to_next().value.as_uint64() != 33 ||
+      cursor.to_next().value.as_uint64() != 333 ||
+
+      cursor.to_next(false).done || !cursor.eof())
+    return false;
+
+  txn.abort();
+
+  txn = env.start_write();
+  txn.clear_map(map);
+  txn.commit();
+
+  return true;
+}
+
+//--------------------------------------------------------------------------------------------
+
+bool case2_batch_read(mdbx::env env) {
+
+  auto txn = env.start_write();
+  auto map = txn.create_map("case2", mdbx::key_mode::usual, mdbx::value_mode::multi_samelength);
+  txn.upsert(map, mdbx::slice("key1"), mdbx::slice("val1"));
+  txn.upsert(map, mdbx::pair("key1", "val2"));
+  txn.upsert(map, mdbx::pair("key1", "val3"));
+  txn.upsert(map, mdbx::slice("key2"), mdbx::slice("val1"));
+  txn.upsert(map, mdbx::pair("key2", "val2"));
+  txn.upsert(map, mdbx::pair("key2", "val3"));
+
+  // cursor.close();
+  auto cursor = txn.open_cursor(map);
+  const auto t1 = cursor.to_first();
+  if (!t1 || t1.key != "key1" || t1.value != "val1") {
+    std::cerr << "Fail-t1\n";
+    return false;
+  }
+  const auto t2 = cursor.get_multiple_samelength();
+  if (!t2 || t2.key != "key1" || t2.value != "val1val2val3") {
+    std::cerr << "Fail-t2\n";
+    return false;
+  }
+  const auto t3 = cursor.next_multiple_samelength();
+  if (t3) {
+    std::cerr << "Fail-t3\n";
+    return false;
+  }
+  const auto t4 = cursor.seek_multiple_samelength("key2");
+  if (!t4 || t4.key != "key2" || t4.value != "val1val2val3") {
+    std::cerr << "Fail-t4\n";
+    return false;
+  }
+
+  txn.clear_map(map);
+  txn.commit();
+
+  return true;
+}
+
+//--------------------------------------------------------------------------------------------
+
+size_t salt;
+
+static size_t prng() {
+  salt = salt * 134775813 + 1;
+  return salt ^ ((salt >> 11) * 1822226723);
+}
+
+static inline size_t prng(size_t range) { return prng() % range; }
+
+static mdbx::default_buffer_pair prng_kv(size_t n, size_t space) {
+  space = (space + !space) * 1024 * 32 / RELIEF_FACTOR;
+  const size_t w = (n ^ 1455614549) * 1664525 + 1013904223;
+  const size_t k = (prng(42 + w % space) ^ 1725278851) * 433750991;
+  const size_t v = prng();
+  return mdbx::default_buffer_pair(mdbx::slice::wrap(k), mdbx::slice::wrap(v));
+}
+
+bool case3_put_a_lot(mdbx::env env) {
+  salt = size_t(std::chrono::high_resolution_clock::now().time_since_epoch().count());
+  auto txn = env.start_write();
+  auto map = txn.create_map("case3", mdbx::key_mode::ordinal, mdbx::value_mode::multi_ordinal);
+  for (size_t n = 0; n < 5555555 / RELIEF_FACTOR; ++n)
+    txn.upsert(map, prng_kv(n, 1));
+  txn.commit();
+
+  for (size_t t = 0; t < 555 / RELIEF_FACTOR; ++t) {
+    txn = env.start_write();
+    auto cursor = txn.open_cursor(map);
+    for (size_t n = 0; n < 111; ++n) {
+      auto v = std::vector<size_t>();
+      const auto r = 1 + prng(3);
+      if (r & 1) {
+        const auto k = prng_kv(n + t, 2).key;
+        for (size_t i = prng(42 + prng(111) * prng(111 / RELIEF_FACTOR)); i > 0; --i)
+          v.push_back(prng());
+        txn.put_multiple_samelength(map, k, v, mdbx::upsert);
+      }
+      if (r & 2) {
+        const auto k = prng_kv(n + t, 2).key;
+        if (cursor.seek(k)) {
+          v.clear();
+          for (size_t i = prng(42 + prng(111) * prng(111 / RELIEF_FACTOR)); i > 0; --i)
+            v.push_back(prng());
+          cursor.put_multiple_samelength(k, v, mdbx::upsert);
+        }
+      }
+    }
+    txn.commit();
+  }
+
+  return true;
+}
+
+int doit() {
+  mdbx::path db_filename = "test-dupfix-multiple";
+  mdbx::env_managed::remove(db_filename);
+  mdbx::env_managed env(db_filename, mdbx::env_managed::create_parameters(), mdbx::env::operate_parameters(3));
+
+  bool ok = case1_ordering(env);
+  ok = case2_batch_read(env) && ok;
+  ok = case3_put_a_lot(env) && ok;
+
+  if (ok) {
+    std::cout << "OK\n";
+    return EXIT_SUCCESS;
+  } else {
+    std::cerr << "Fail\n";
+    return EXIT_FAILURE;
+  }
+}
+
+int main(int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+  try {
+    return doit();
+  } catch (const std::exception &ex) {
+    std::cerr << "Exception: " << ex.what() << "\n";
+    return EXIT_FAILURE;
+  }
+}