mdbxmou 0.1.26

package/deps/libmdbx/src/windows-import.c

@@ -0,0 +1,152 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#if defined(_WIN32) || defined(_WIN64)
+
+#include "internals.h"
+
+//------------------------------------------------------------------------------
+// Stub for slim read-write lock
+// Portion Copyright (C) 1995-2002 Brad Wilson
+
+static void WINAPI stub_srwlock_Init(osal_srwlock_t *srwl) { srwl->readerCount = srwl->writerCount = 0; }
+
+static void WINAPI stub_srwlock_AcquireShared(osal_srwlock_t *srwl) {
+  while (true) {
+    assert(srwl->writerCount >= 0 && srwl->readerCount >= 0);
+
+    //  If there's a writer already, spin without unnecessarily
+    //  interlocking the CPUs
+    if (srwl->writerCount != 0) {
+      SwitchToThread();
+      continue;
+    }
+
+    //  Add to the readers list
+    _InterlockedIncrement(&srwl->readerCount);
+
+    // Check for writers again (we may have been preempted). If
+    // there are no writers writing or waiting, then we're done.
+    if (srwl->writerCount == 0)
+      break;
+
+    // Remove from the readers list, spin, try again
+    _InterlockedDecrement(&srwl->readerCount);
+    SwitchToThread();
+  }
+}
+
+static void WINAPI stub_srwlock_ReleaseShared(osal_srwlock_t *srwl) {
+  assert(srwl->readerCount > 0);
+  _InterlockedDecrement(&srwl->readerCount);
+}
+
+static void WINAPI stub_srwlock_AcquireExclusive(osal_srwlock_t *srwl) {
+  while (true) {
+    assert(srwl->writerCount >= 0 && srwl->readerCount >= 0);
+
+    //  If there's a writer already, spin without unnecessarily
+    //  interlocking the CPUs
+    if (srwl->writerCount != 0) {
+      SwitchToThread();
+      continue;
+    }
+
+    // See if we can become the writer (expensive, because it inter-
+    // locks the CPUs, so writing should be an infrequent process)
+    if (_InterlockedExchange(&srwl->writerCount, 1) == 0)
+      break;
+  }
+
+  // Now we're the writer, but there may be outstanding readers.
+  // Spin until there aren't any more; new readers will wait now
+  // that we're the writer.
+  while (srwl->readerCount != 0) {
+    assert(srwl->writerCount >= 0 && srwl->readerCount >= 0);
+    SwitchToThread();
+  }
+}
+
+static void WINAPI stub_srwlock_ReleaseExclusive(osal_srwlock_t *srwl) {
+  assert(srwl->writerCount == 1 && srwl->readerCount >= 0);
+  srwl->writerCount = 0;
+}
+
+static uint64_t WINAPI stub_GetTickCount64(void) {
+  LARGE_INTEGER Counter, Frequency;
+  return (QueryPerformanceFrequency(&Frequency) && QueryPerformanceCounter(&Counter))
+             ? Counter.QuadPart * 1000ul / Frequency.QuadPart
+             : 0;
+}
+
+//------------------------------------------------------------------------------
+
+struct libmdbx_imports imports;
+
+#if __GNUC_PREREQ(8, 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif /* GCC/MINGW */
+
+#define MDBX_IMPORT(HANDLE, ENTRY) imports.ENTRY = (MDBX_##ENTRY)GetProcAddress(HANDLE, #ENTRY)
+
+void windows_import(void) {
+  const HINSTANCE hNtdll = GetModuleHandleA("ntdll.dll");
+  if (hNtdll) {
+    globals.running_under_Wine = !!GetProcAddress(hNtdll, "wine_get_version");
+    if (!globals.running_under_Wine) {
+      MDBX_IMPORT(hNtdll, NtFsControlFile);
+      MDBX_IMPORT(hNtdll, NtExtendSection);
+      ENSURE(nullptr, imports.NtExtendSection);
+    }
+  }
+
+  const HINSTANCE hKernel32dll = GetModuleHandleA("kernel32.dll");
+  if (hKernel32dll) {
+    MDBX_IMPORT(hKernel32dll, GetFileInformationByHandleEx);
+    MDBX_IMPORT(hKernel32dll, GetTickCount64);
+    if (!imports.GetTickCount64)
+      imports.GetTickCount64 = stub_GetTickCount64;
+    if (!globals.running_under_Wine) {
+      MDBX_IMPORT(hKernel32dll, SetFileInformationByHandle);
+      MDBX_IMPORT(hKernel32dll, GetVolumeInformationByHandleW);
+      MDBX_IMPORT(hKernel32dll, GetFinalPathNameByHandleW);
+      MDBX_IMPORT(hKernel32dll, PrefetchVirtualMemory);
+      MDBX_IMPORT(hKernel32dll, SetFileIoOverlappedRange);
+    }
+  }
+
+  const osal_srwlock_t_function srwlock_init =
+      (osal_srwlock_t_function)(hKernel32dll ? GetProcAddress(hKernel32dll, "InitializeSRWLock") : nullptr);
+  if (srwlock_init) {
+    imports.srwl_Init = srwlock_init;
+    imports.srwl_AcquireShared = (osal_srwlock_t_function)GetProcAddress(hKernel32dll, "AcquireSRWLockShared");
+    imports.srwl_ReleaseShared = (osal_srwlock_t_function)GetProcAddress(hKernel32dll, "ReleaseSRWLockShared");
+    imports.srwl_AcquireExclusive = (osal_srwlock_t_function)GetProcAddress(hKernel32dll, "AcquireSRWLockExclusive");
+    imports.srwl_ReleaseExclusive = (osal_srwlock_t_function)GetProcAddress(hKernel32dll, "ReleaseSRWLockExclusive");
+  } else {
+    imports.srwl_Init = stub_srwlock_Init;
+    imports.srwl_AcquireShared = stub_srwlock_AcquireShared;
+    imports.srwl_ReleaseShared = stub_srwlock_ReleaseShared;
+    imports.srwl_AcquireExclusive = stub_srwlock_AcquireExclusive;
+    imports.srwl_ReleaseExclusive = stub_srwlock_ReleaseExclusive;
+  }
+
+  const HINSTANCE hAdvapi32dll = GetModuleHandleA("advapi32.dll");
+  if (hAdvapi32dll) {
+    MDBX_IMPORT(hAdvapi32dll, RegGetValueA);
+  }
+
+  const HINSTANCE hOle32dll = GetModuleHandleA("ole32.dll");
+  if (hOle32dll) {
+    MDBX_IMPORT(hOle32dll, CoCreateGuid);
+  }
+}
+
+#undef MDBX_IMPORT
+
+#if __GNUC_PREREQ(8, 0)
+#pragma GCC diagnostic pop
+#endif /* GCC/MINGW */
+
+#endif /* Windows */

package/deps/libmdbx/src/windows-import.h

@@ -0,0 +1,128 @@
+/// \copyright SPDX-License-Identifier: Apache-2.0
+/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
+
+#pragma once
+
+typedef union osal_srwlock {
+  __anonymous_struct_extension__ struct {
+    long volatile readerCount;
+    long volatile writerCount;
+  };
+  RTL_SRWLOCK native;
+} osal_srwlock_t;
+
+typedef void(WINAPI *osal_srwlock_t_function)(osal_srwlock_t *);
+
+#if _WIN32_WINNT < 0x0600 /* prior to Windows Vista */
+typedef enum _FILE_INFO_BY_HANDLE_CLASS {
+  FileBasicInfo,
+  FileStandardInfo,
+  FileNameInfo,
+  FileRenameInfo,
+  FileDispositionInfo,
+  FileAllocationInfo,
+  FileEndOfFileInfo,
+  FileStreamInfo,
+  FileCompressionInfo,
+  FileAttributeTagInfo,
+  FileIdBothDirectoryInfo,
+  FileIdBothDirectoryRestartInfo,
+  FileIoPriorityHintInfo,
+  FileRemoteProtocolInfo,
+  MaximumFileInfoByHandleClass
+} FILE_INFO_BY_HANDLE_CLASS,
+    *PFILE_INFO_BY_HANDLE_CLASS;
+
+typedef struct _FILE_END_OF_FILE_INFO {
+  LARGE_INTEGER EndOfFile;
+} FILE_END_OF_FILE_INFO, *PFILE_END_OF_FILE_INFO;
+
+#define REMOTE_PROTOCOL_INFO_FLAG_LOOPBACK 0x00000001
+#define REMOTE_PROTOCOL_INFO_FLAG_OFFLINE 0x00000002
+
+typedef struct _FILE_REMOTE_PROTOCOL_INFO {
+  USHORT StructureVersion;
+  USHORT StructureSize;
+  DWORD Protocol;
+  USHORT ProtocolMajorVersion;
+  USHORT ProtocolMinorVersion;
+  USHORT ProtocolRevision;
+  USHORT Reserved;
+  DWORD Flags;
+  struct {
+    DWORD Reserved[8];
+  } GenericReserved;
+  struct {
+    DWORD Reserved[16];
+  } ProtocolSpecificReserved;
+} FILE_REMOTE_PROTOCOL_INFO, *PFILE_REMOTE_PROTOCOL_INFO;
+
+#endif /* _WIN32_WINNT < 0x0600 (prior to Windows Vista) */
+
+typedef BOOL(WINAPI *MDBX_GetFileInformationByHandleEx)(_In_ HANDLE hFile,
+                                                        _In_ FILE_INFO_BY_HANDLE_CLASS FileInformationClass,
+                                                        _Out_ LPVOID lpFileInformation, _In_ DWORD dwBufferSize);
+
+typedef BOOL(WINAPI *MDBX_GetVolumeInformationByHandleW)(
+    _In_ HANDLE hFile, _Out_opt_ LPWSTR lpVolumeNameBuffer, _In_ DWORD nVolumeNameSize,
+    _Out_opt_ LPDWORD lpVolumeSerialNumber, _Out_opt_ LPDWORD lpMaximumComponentLength,
+    _Out_opt_ LPDWORD lpFileSystemFlags, _Out_opt_ LPWSTR lpFileSystemNameBuffer, _In_ DWORD nFileSystemNameSize);
+
+typedef DWORD(WINAPI *MDBX_GetFinalPathNameByHandleW)(_In_ HANDLE hFile, _Out_ LPWSTR lpszFilePath,
+                                                      _In_ DWORD cchFilePath, _In_ DWORD dwFlags);
+
+typedef BOOL(WINAPI *MDBX_SetFileInformationByHandle)(_In_ HANDLE hFile,
+                                                      _In_ FILE_INFO_BY_HANDLE_CLASS FileInformationClass,
+                                                      _Out_ LPVOID lpFileInformation, _In_ DWORD dwBufferSize);
+
+typedef NTSTATUS(NTAPI *MDBX_NtFsControlFile)(IN HANDLE FileHandle, IN OUT HANDLE Event,
+                                              IN OUT PVOID /* PIO_APC_ROUTINE */ ApcRoutine, IN OUT PVOID ApcContext,
+                                              OUT PIO_STATUS_BLOCK IoStatusBlock, IN ULONG FsControlCode,
+                                              IN OUT PVOID InputBuffer, IN ULONG InputBufferLength,
+                                              OUT OPTIONAL PVOID OutputBuffer, IN ULONG OutputBufferLength);
+
+typedef uint64_t(WINAPI *MDBX_GetTickCount64)(void);
+
+#if !defined(_WIN32_WINNT_WIN8) || _WIN32_WINNT < _WIN32_WINNT_WIN8
+typedef struct _WIN32_MEMORY_RANGE_ENTRY {
+  PVOID VirtualAddress;
+  SIZE_T NumberOfBytes;
+} WIN32_MEMORY_RANGE_ENTRY, *PWIN32_MEMORY_RANGE_ENTRY;
+#endif /* Windows 8.x */
+
+typedef BOOL(WINAPI *MDBX_PrefetchVirtualMemory)(HANDLE hProcess, ULONG_PTR NumberOfEntries,
+                                                 PWIN32_MEMORY_RANGE_ENTRY VirtualAddresses, ULONG Flags);
+
+typedef enum _SECTION_INHERIT { ViewShare = 1, ViewUnmap = 2 } SECTION_INHERIT;
+
+typedef NTSTATUS(NTAPI *MDBX_NtExtendSection)(IN HANDLE SectionHandle, IN PLARGE_INTEGER NewSectionSize);
+
+typedef LSTATUS(WINAPI *MDBX_RegGetValueA)(HKEY hkey, LPCSTR lpSubKey, LPCSTR lpValue, DWORD dwFlags, LPDWORD pdwType,
+                                           PVOID pvData, LPDWORD pcbData);
+
+typedef long(WINAPI *MDBX_CoCreateGuid)(bin128_t *guid);
+
+NTSYSAPI ULONG RtlRandomEx(PULONG Seed);
+
+typedef BOOL(WINAPI *MDBX_SetFileIoOverlappedRange)(HANDLE FileHandle, PUCHAR OverlappedRangeStart, ULONG Length);
+
+struct libmdbx_imports {
+  osal_srwlock_t_function srwl_Init;
+  osal_srwlock_t_function srwl_AcquireShared;
+  osal_srwlock_t_function srwl_ReleaseShared;
+  osal_srwlock_t_function srwl_AcquireExclusive;
+  osal_srwlock_t_function srwl_ReleaseExclusive;
+  MDBX_NtExtendSection NtExtendSection;
+  MDBX_GetFileInformationByHandleEx GetFileInformationByHandleEx;
+  MDBX_GetVolumeInformationByHandleW GetVolumeInformationByHandleW;
+  MDBX_GetFinalPathNameByHandleW GetFinalPathNameByHandleW;
+  MDBX_SetFileInformationByHandle SetFileInformationByHandle;
+  MDBX_NtFsControlFile NtFsControlFile;
+  MDBX_PrefetchVirtualMemory PrefetchVirtualMemory;
+  MDBX_GetTickCount64 GetTickCount64;
+  MDBX_RegGetValueA RegGetValueA;
+  MDBX_SetFileIoOverlappedRange SetFileIoOverlappedRange;
+  MDBX_CoCreateGuid CoCreateGuid;
+};
+
+MDBX_INTERNAL void windows_import(void);

package/deps/libmdbx/test/CMakeLists.txt

@@ -0,0 +1,317 @@
+# Copyright (c) 2020-2025 Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> ###############################################
+# SPDX-License-Identifier: Apache-2.0
+
+if(NOT CMAKE_CXX_COMPILER_LOADED)
+  enable_language(CXX)
+  include(../cmake/compiler.cmake)
+endif()
+
+function(add_extra_test name)
+  set(options DISABLED)
+  set(oneValueArgs TIMEOUT)
+  set(multiValueArgs SOURCE LIBRARY DEPEND DLLPATH)
+  cmake_parse_arguments(params "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  if(params_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unknown keywords given to add_extra_test(): \"${params_UNPARSED_ARGUMENTS}\".")
+  endif()
+
+  macro(oops)
+    message(FATAL_ERROR "add_extra_test(): Opps, " ${ARGV})
+  endmacro()
+
+  if(NOT params_SOURCE)
+    set(params_SOURCE extra/${name}.c++)
+  endif()
+
+  set(target "test_extra_${name}")
+  add_executable(${target} ${params_SOURCE})
+  target_include_directories(${target} PRIVATE "${PROJECT_SOURCE_DIR}")
+  target_link_libraries(${target} ${TOOL_MDBX_LIB})
+  set_target_properties(${target} PROPERTIES SKIP_BUILD_RPATH FALSE BUILD_WITH_INSTALL_RPATH FALSE)
+
+  if(MDBX_BUILD_CXX AND MDBX_CXX_STANDARD)
+    set_target_properties(${target} PROPERTIES CXX_STANDARD ${MDBX_CXX_STANDARD} CXX_STANDARD_REQUIRED ON)
+  endif()
+
+  if(params_DEPEND)
+    add_dependencies(${target} ${params_DEPEND})
+  endif()
+
+  if(TOOL_MDBX_DLLCRUTCH)
+    string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UPPERCASE)
+    foreach(dep IN LISTS params_LIBRARY)
+      get_target_property(type ${dep} TYPE)
+      if(type STREQUAL SHARED_LIBRARY)
+        # Windows don't have RPATH feature, therefore we should prepare PATH or copy DLL(s)...
+        if(CMAKE_CONFIGURATION_TYPES)
+          # Could not provide static ENVIRONMENT property with configuration-depended path
+          set(dir FALSE)
+        else(CMAKE_CONFIGURATION_TYPES)
+          get_target_property(filename ${dep} IMPORTED_LOCATION_${CMAKE_BUILD_TYPE_UPPERCASE})
+          if(NOT filename)
+            get_target_property(filename ${dep} IMPORTED_LOCATION)
+          endif()
+          get_target_property(filename ${dep} LOCATION_${CMAKE_BUILD_TYPE_UPPERCASE})
+          if(NOT filename)
+            get_target_property(filename ${dep} LOCATION)
+          endif()
+          if(filename)
+            get_filename_component(dir ${filename} DIRECTORY)
+          else(filename)
+            get_target_property(dir ${dep} LIBRARY_OUTPUT_DIRECTORY_${CMAKE_BUILD_TYPE_UPPERCASE})
+            if(NOT dir)
+              get_target_property(dir ${dep} RUNTIME_OUTPUT_DIRECTORY_${CMAKE_BUILD_TYPE_UPPERCASE})
+            endif()
+            if(NOT dir)
+              get_target_property(dir ${dep} LIBRARY_OUTPUT_DIRECTORY)
+            endif()
+            if(NOT dir)
+              get_target_property(dir ${dep} RUNTIME_OUTPUT_DIRECTORY)
+            endif()
+          endif(filename)
+        endif(CMAKE_CONFIGURATION_TYPES)
+        if(dir)
+          list(APPEND params_DLLPATH ${dir})
+        else(dir)
+          # Path is configuration-depended or not available, should copy dll
+          add_custom_command(
+            TARGET ${target}
+            POST_BUILD
+            COMMAND if exist "$<TARGET_PDB_FILE:${dep}>" ${CMAKE_COMMAND} -E copy_if_different
+                    "$<TARGET_PDB_FILE:${dep}>" "$<TARGET_FILE_DIR:${target}>")
+          add_custom_command(
+            TARGET ${target}
+            POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:${dep}>" "$<TARGET_FILE_DIR:${target}>"
+            COMMENT "${TOOL_MDBX_DLLCRUTCH}: Copy shared library ${dep} for test ${target}")
+        endif(dir)
+      endif()
+    endforeach(dep)
+  endif(TOOL_MDBX_DLLCRUTCH)
+
+  if(NOT params_DISABLED AND NOT (CMAKE_CROSSCOMPILING AND NOT CMAKE_CROSSCOMPILING_EMULATOR))
+    add_test(extra_${name} ${MDBX_OUTPUT_DIR}/${target})
+    if(params_TIMEOUT)
+      if(MEMORYCHECK_COMMAND
+         OR CMAKE_MEMORYCHECK_COMMAND
+         OR ENABLE_MEMCHECK)
+        # FIXME: unless there are any other ideas how to fix the timeouts problem when testing under Valgrind.
+        math(EXPR params_TIMEOUT "${params_TIMEOUT} * 42")
+      endif()
+      set_tests_properties(extra_${name} PROPERTIES TIMEOUT ${params_TIMEOUT})
+    endif()
+    if(params_DLLPATH)
+      # Compose DLL's path in the ENVIRONMENT property
+      if(WIN32)
+        set(params_DLLPATH_ENV "${params_DLLPATH};$ENV{PATH}")
+      else()
+        set(params_DLLPATH_ENV "${params_DLLPATH}:$ENV{PATH}")
+        string(REPLACE ":" ";" params_DLLPATH_ENV "${params_DLLPATH_ENV}")
+      endif()
+      list(REMOVE_DUPLICATES params_DLLPATH_ENV)
+      if(WIN32)
+        string(REPLACE ";" "\\;" params_DLLPATH_ENV "${params_DLLPATH_ENV}")
+      else()
+        string(REPLACE ";" ":" params_DLLPATH_ENV "${params_DLLPATH_ENV}")
+      endif()
+      set_tests_properties(extra_${name} PROPERTIES ENVIRONMENT "PATH=${params_DLLPATH_ENV}")
+    endif()
+  endif()
+endfunction(add_extra_test)
+
+set(LIBMDBX_TEST_SOURCES
+    base.h++
+    cases.c++
+    chrono.c++
+    chrono.h++
+    config.c++
+    config.h++
+    copy.c++
+    dead.c++
+    hill.c++
+    jitter.c++
+    keygen.c++
+    keygen.h++
+    log.c++
+    log.h++
+    main.c++
+    osal.h++
+    osal-unix.c++
+    osal-windows.c++
+    test.c++
+    test.h++
+    try.c++
+    utils.c++
+    utils.h++
+    append.c++
+    ttl.c++
+    nested.c++
+    fork.c++)
+
+if(MDBX_BUILD_CXX)
+  add_extra_test(probe DISABLED)
+else()
+  probe_libcxx_filesystem()
+  list(APPEND LIBMDBX_TEST_SOURCES "${MDBX_SOURCE_DIR}/mdbx.c++" ../mdbx.h++)
+endif()
+
+add_executable(mdbx_test ${LIBMDBX_TEST_SOURCES})
+target_compile_definitions(mdbx_test PRIVATE MDBX_BUILD_TEST=1 MDBX_BUILD_CXX=1)
+
+if(MDBX_CXX_STANDARD)
+  set_target_properties(mdbx_test PROPERTIES CXX_STANDARD ${MDBX_CXX_STANDARD} CXX_STANDARD_REQUIRED ON)
+endif()
+
+set_target_properties(mdbx_test PROPERTIES INTERPROCEDURAL_OPTIMIZATION $<BOOL:${INTERPROCEDURAL_OPTIMIZATION}>)
+target_setup_options(mdbx_test)
+
+if(NOT MDBX_BUILD_CXX)
+  target_compile_definitions(mdbx_test PRIVATE MDBX_BUILD_CXX=1)
+  if(WIN32)
+    target_compile_definitions(mdbx_test PRIVATE MDBX_WITHOUT_MSVC_CRT=0)
+  endif()
+endif()
+
+if(NOT MDBX_BUILD_CXX AND LIBCXX_FILESYSTEM)
+  if(CMAKE_COMPILER_IS_ELBRUSCXX
+     AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 1.25.23
+     AND NOT CMAKE_VERSION VERSION_LESS 3.13)
+    target_link_options(mdbx_test PRIVATE "-Wl,--allow-multiple-definition")
+  endif()
+  target_link_libraries(mdbx_test ${LIBCXX_FILESYSTEM})
+endif()
+
+if(CMAKE_VERSION VERSION_LESS 3.1)
+  target_link_libraries(mdbx_test ${TOOL_MDBX_LIB} ${LIB_MATH} ${CMAKE_THREAD_LIBS_INIT})
+else()
+  target_link_libraries(mdbx_test ${TOOL_MDBX_LIB} ${LIB_MATH} Threads::Threads)
+endif()
+if(WIN32)
+  target_link_libraries(mdbx_test winmm.lib)
+endif()
+
+if(NOT SUBPROJECT)
+  if(UNIX)
+    add_executable(test_extra_pcrf extra/pcrf/pcrf_test.c)
+    target_include_directories(test_extra_pcrf PRIVATE "${PROJECT_SOURCE_DIR}")
+    target_link_libraries(test_extra_pcrf ${TOOL_MDBX_LIB})
+  endif()
+endif()
+
+# ######################################################################################################################
+
+if(CMAKE_CROSSCOMPILING AND NOT CMAKE_CROSSCOMPILING_EMULATOR)
+  message(WARNING "No emulator to run cross-compiled tests")
+  add_test(NAME fake_since_no_crosscompiling_emulator COMMAND ${CMAKE_COMMAND} -E echo
+                                                              "No emulator to run cross-compiled tests")
+else()
+
+  string(
+    RANDOM
+    LENGTH 9
+    ALPHABET "1234567890" test_seed)
+  message(STATUS "The ${test_seed} will be used for seeding tests. Re-run cmake to re-seed it.")
+
+  add_test(NAME smoke COMMAND ${MDBX_OUTPUT_DIR}/mdbx_test --loglevel=verbose --prng-seed=${test_seed} --progress
+                              --console=no --pathname=smoke.db --dont-cleanup-after basic)
+  set_tests_properties(smoke PROPERTIES TIMEOUT 600 RUN_SERIAL OFF)
+  if(MDBX_BUILD_TOOLS)
+    add_test(NAME smoke_chk COMMAND ${MDBX_OUTPUT_DIR}/mdbx_chk -nvv smoke.db)
+    set_tests_properties(
+      smoke_chk
+      PROPERTIES DEPENDS
+                 smoke
+                 TIMEOUT
+                 60
+                 FAIL_REGULAR_EXPRESSION
+                 "cooperative mode"
+                 REQUIRED_FILES
+                 smoke.db)
+    add_test(NAME smoke_chk_copy COMMAND ${MDBX_OUTPUT_DIR}/mdbx_chk -nvv smoke.db-copy)
+    set_tests_properties(
+      smoke_chk_copy
+      PROPERTIES DEPENDS
+                 smoke
+                 TIMEOUT
+                 60
+                 FAIL_REGULAR_EXPRESSION
+                 "cooperative mode"
+                 REQUIRED_FILES
+                 smoke.db-copy)
+  endif()
+
+  add_test(
+    NAME dupsort_writemap
+    COMMAND
+      ${MDBX_OUTPUT_DIR}/mdbx_test --loglevel=notice --prng-seed=${test_seed} --table=+data.fixed --keygen.split=29
+      --datalen=rnd --progress --console=no --repeat=2 --pathname=dupsort_writemap.db --dont-cleanup-after basic)
+  set_tests_properties(dupsort_writemap PROPERTIES TIMEOUT 3600 RUN_SERIAL OFF)
+  if(MDBX_BUILD_TOOLS)
+    add_test(NAME dupsort_writemap_chk COMMAND ${MDBX_OUTPUT_DIR}/mdbx_chk -nvvwc dupsort_writemap.db)
+    set_tests_properties(dupsort_writemap_chk PROPERTIES DEPENDS dupsort_writemap TIMEOUT 60 REQUIRED_FILES
+                                                         dupsort_writemap.db)
+    add_test(NAME dupsort_writemap_chk_copy COMMAND ${MDBX_OUTPUT_DIR}/mdbx_chk -nvvc dupsort_writemap.db-copy)
+    set_tests_properties(
+      dupsort_writemap_chk_copy
+      PROPERTIES DEPENDS
+                 dupsort_writemap
+                 TIMEOUT
+                 60
+                 FAIL_REGULAR_EXPRESSION
+                 "monopolistic mode"
+                 REQUIRED_FILES
+                 dupsort_writemap.db-copy)
+  endif()
+
+  add_test(NAME uniq_nested
+           COMMAND ${MDBX_OUTPUT_DIR}/mdbx_test --loglevel=notice --mode=-writemap,-nosync-safe,-lifo --progress
+                   --console=no --repeat=2 --pathname=uniq_nested.db --dont-cleanup-after basic)
+  set_tests_properties(uniq_nested PROPERTIES TIMEOUT 1800 RUN_SERIAL OFF)
+  if(MDBX_BUILD_TOOLS)
+    add_test(NAME uniq_nested_chk COMMAND ${MDBX_OUTPUT_DIR}/mdbx_chk -nvvw uniq_nested.db)
+    set_tests_properties(
+      uniq_nested_chk
+      PROPERTIES DEPENDS
+                 uniq_nested
+                 TIMEOUT
+                 60
+                 FAIL_REGULAR_EXPRESSION
+                 "cooperative mode"
+                 REQUIRED_FILES
+                 uniq_nested.db)
+    add_test(NAME uniq_nested_chk_copy COMMAND ${MDBX_OUTPUT_DIR}/mdbx_chk -nvv uniq_nested.db-copy)
+    set_tests_properties(
+      uniq_nested_chk_copy
+      PROPERTIES DEPENDS
+                 uniq_nested
+                 TIMEOUT
+                 60
+                 FAIL_REGULAR_EXPRESSION
+                 "cooperative mode"
+                 REQUIRED_FILES
+                 uniq_nested.db-copy)
+  endif()
+
+  if(NOT SUBPROJECT)
+    if(UNIX)
+      add_extra_test(upsert_alldups SOURCE extra/upsert_alldups.c)
+      add_extra_test(dupfix_addodd SOURCE extra/dupfix_addodd.c)
+    endif()
+    if(MDBX_BUILD_CXX)
+      if(NOT WIN32 OR NOT MDBX_CXX_STANDARD LESS 17)
+        add_extra_test(cursor_closing TIMEOUT 10800)
+        add_extra_test(early_close_dbi)
+        add_extra_test(maindb_ordinal)
+        add_extra_test(dupfix_multiple TIMEOUT 10800)
+        add_extra_test(doubtless_positioning TIMEOUT 10800)
+        add_extra_test(crunched_delete TIMEOUT 10800)
+        add_extra_test(dbi)
+        add_extra_test(open)
+        add_extra_test(txn)
+      endif()
+      add_extra_test(hex_base64_base58)
+    endif()
+  endif()
+
+endif()