diff --git a/CMakeLists.txt b/CMakeLists.txt
index dc490a2814..502056f221 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -47,6 +47,10 @@ enable_testing()
 
 include(GNUInstallDirs)
 include(test-helpers)
+include(boost-test-discovery)
+add_p_test(NAME boost_test_discovery_test
+           COMMAND ${CMAKE_COMMAND} -DGENERATOR=${CMAKE_GENERATOR} -DCXX=${CMAKE_CXX_COMPILER} -DCONFIG=$<CONFIG>
+                   -P ${CMAKE_SOURCE_DIR}/cmake/test/boost-test-discovery-test.cmake)
 
 set(CLI_CLIENT_EXECUTABLE_NAME clio)
 set(NODE_EXECUTABLE_NAME nodeop)
diff --git a/cmake/boost-test-discovery-impl.cmake b/cmake/boost-test-discovery-impl.cmake
new file mode 100644
index 0000000000..c8b20134ba
--- /dev/null
+++ b/cmake/boost-test-discovery-impl.cmake
@@ -0,0 +1,177 @@
+# Implementation of boost_test_discover_tests() (boost-test-discovery.cmake). ctest runs it from the include script
+# that function generates, to list the executable's top-level units and write the CTest script registering them.
+
+# ctest reads test files with no policies set; functions keep the policies in effect where they are defined.
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.19)
+
+set(_BOOST_TEST_LIST_TIMEOUT_SECONDS 60)
+# Longer than one discovery can take, so a process waiting for the lock outlasts the one holding it.
+set(_BOOST_TEST_LOCK_TIMEOUT_SECONDS 180)
+# Stands for "no runtime" in the runtime loop: an empty element cannot be appended to an empty CMake list.
+set(_BOOST_TEST_NO_RUNTIME "<none>")
+
+# Quote a value as a CMake bracket argument; the trailing `]` covers a value ending in the start of the closing bracket.
+function(_boost_test_quote out value)
+   set(equals "")
+   string(FIND "${value}]" "]${equals}]" found)
+   while(NOT found EQUAL -1)
+      string(APPEND equals "=")
+      string(FIND "${value}]" "]${equals}]" found)
+   endwhile()
+   set(${out} "[${equals}[${value}]${equals}]" PARENT_SCOPE)
+endfunction()
+
+# Append `<command>(<quoted arguments>)` to the script held in the caller's `script` variable.
+function(_boost_test_append_command command)
+   set(line "${command}(")
+   foreach(argument IN LISTS ARGN)
+      _boost_test_quote(quoted "${argument}")
+      string(APPEND line " ${quoted}")
+   endforeach()
+   string(APPEND script "${line})\n")
+   set(script "${script}" PARENT_SCOPE)
+endfunction()
+
+# Append an entry that fails, echoing `message`, to the caller's `script`; ARGN holds its extra properties.
+function(_boost_test_append_failure name cmake_command message)
+   _boost_test_append_command(add_test "${name}" "${cmake_command}" -E echo "${message}")
+   _boost_test_append_command(set_tests_properties "${name}" PROPERTIES WILL_FAIL TRUE ${ARGN})
+   set(script "${script}" PARENT_SCOPE)
+endfunction()
+
+function(boost_test_discover_tests_impl)
+   # Lists arrive as single `;`-joined arguments; the ${ARGN} form splits them where PARSE_ARGV would not.
+   set(single_values EXECUTABLE TESTS_FILE INCLUDE_FILE FAILURE_NAME CMAKE_COMMAND WORKING_DIRECTORY NAME INCLUDE
+       EXCLUDE LOCK_TIMEOUT)
+   cmake_parse_arguments(arg "" "${single_values}" "NAME_STRIP;RUNTIMES;ARGS;PROPERTIES;COST_BY_NAME" ${ARGN})
+
+   # One ctest process discovers at a time, and one that waited finds the script already current. Without the lock the
+   # shared files are not this process's to touch, so it keeps the current list and reports why.
+   if(NOT DEFINED arg_LOCK_TIMEOUT)
+      set(arg_LOCK_TIMEOUT ${_BOOST_TEST_LOCK_TIMEOUT_SECONDS})
+   endif()
+   file(LOCK "${arg_TESTS_FILE}.lock" GUARD FUNCTION TIMEOUT ${arg_LOCK_TIMEOUT} RESULT_VARIABLE lock_result)
+   if(NOT lock_result STREQUAL "0")
+      set(script "")
+      _boost_test_append_failure("${arg_FAILURE_NAME}" "${arg_CMAKE_COMMAND}"
+                                 "cannot lock ${arg_TESTS_FILE}.lock: ${lock_result}" ${arg_PROPERTIES})
+      cmake_language(EVAL CODE "${script}")
+      return()
+   endif()
+   # The script is stale when the executable or the include script is newer (a tie counts) or this implementation
+   # changed.
+   if(EXISTS "${arg_TESTS_FILE}" AND
+      NOT "${arg_EXECUTABLE}" IS_NEWER_THAN "${arg_TESTS_FILE}" AND
+      NOT "${arg_INCLUDE_FILE}" IS_NEWER_THAN "${arg_TESTS_FILE}" AND
+      "${arg_TESTS_FILE}" IS_NEWER_THAN "${CMAKE_CURRENT_FUNCTION_LIST_FILE}")
+      return()
+   endif()
+
+   # The report sink keeps the listing apart from anything the executable prints, and overrides
+   # BOOST_TEST_REPORT_SINK in the environment.
+   set(listing "${arg_TESTS_FILE}.listing")
+   file(REMOVE "${listing}")
+   execute_process(COMMAND "${arg_EXECUTABLE}" --list_content "--report_sink=${listing}"
+                   WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}" TIMEOUT ${_BOOST_TEST_LIST_TIMEOUT_SECONDS}
+                   RESULT_VARIABLE result OUTPUT_VARIABLE output ERROR_VARIABLE output)
+   set(text "")
+   if(result EQUAL 0 AND EXISTS "${listing}")
+      file(READ "${listing}" text)
+   endif()
+   file(REMOVE "${listing}")
+
+   # Boost prints one unit per line: `<name>*` when enabled, `<name> ` when disabled by default, optionally followed
+   # by `: <description>`, with nested units indented. Nested lines and descriptions are cut before the text becomes a
+   # CMake list, whose `;` and `[` handling would otherwise split or merge lines. The sink holds nothing but the
+   # listing, so a line without a marker is still a unit, registered enabled.
+   string(REGEX REPLACE "\n [^\n]*" "" text "\n${text}")
+   string(REGEX REPLACE "([* ]): [^\n]*" "\\1" text "${text}")
+   string(REGEX MATCHALL "[^\n]+" lines "${text}")
+
+   set(script "# Generated from `${arg_EXECUTABLE} --list_content` by boost-test-discovery-impl.cmake.\n")
+   set(listed 0)
+   set(test_names "")
+   set(duplicates "")
+   foreach(line IN LISTS lines)
+      if(line MATCHES "^(.+)\\*$")
+         set(UNIT "${CMAKE_MATCH_1}")
+         set(enabled TRUE)
+      elseif(line MATCHES "^(.+) $")
+         set(UNIT "${CMAKE_MATCH_1}")
+         set(enabled FALSE)
+      else()
+         set(UNIT "${line}")
+         set(enabled TRUE)
+      endif()
+      math(EXPR listed "${listed} + 1")
+      if((arg_INCLUDE AND NOT UNIT MATCHES "${arg_INCLUDE}") OR (arg_EXCLUDE AND UNIT MATCHES "${arg_EXCLUDE}"))
+         continue()
+      endif()
+
+      set(NAME "${UNIT}")
+      foreach(pattern IN LISTS arg_NAME_STRIP)
+         string(REGEX REPLACE "${pattern}" "" NAME "${NAME}")
+      endforeach()
+      set(cost "")
+      list(LENGTH arg_COST_BY_NAME cost_values)
+      set(index 0)
+      while(index LESS cost_values AND NOT cost)
+         list(GET arg_COST_BY_NAME ${index} pattern)
+         math(EXPR index "${index} + 1")
+         if(NAME MATCHES "${pattern}")
+            list(GET arg_COST_BY_NAME ${index} cost)
+         endif()
+         math(EXPR index "${index} + 1")
+      endwhile()
+
+      set(runtimes ${arg_RUNTIMES})
+      if(NOT runtimes)
+         set(runtimes "${_BOOST_TEST_NO_RUNTIME}")
+      endif()
+      foreach(RUNTIME IN LISTS runtimes)
+         set(command "${arg_EXECUTABLE}" "--run_test=${UNIT}" ${arg_ARGS})
+         if(RUNTIME STREQUAL _BOOST_TEST_NO_RUNTIME)
+            set(RUNTIME "")
+         else()
+            list(APPEND command "--" "--${RUNTIME}")
+         endif()
+         string(CONFIGURE "${arg_NAME}" test_name @ONLY)
+         if(test_name IN_LIST test_names)
+            list(APPEND duplicates "${test_name}")
+         endif()
+         list(APPEND test_names "${test_name}")
+         _boost_test_append_command(add_test "${test_name}" ${command})
+         set(properties WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}" ${arg_PROPERTIES})
+         if(cost)
+            list(APPEND properties COST ${cost})
+         endif()
+         if(NOT enabled)
+            list(APPEND properties DISABLED TRUE)
+         endif()
+         _boost_test_append_command(set_tests_properties "${test_name}" PROPERTIES ${properties})
+      endforeach()
+   endforeach()
+
+   if(listed EQUAL 0)
+      # Register the failure directly and leave no tests file, so the next ctest run discovers again.
+      file(REMOVE "${arg_TESTS_FILE}")
+      set(script "")
+      _boost_test_append_failure("${arg_FAILURE_NAME}" "${arg_CMAKE_COMMAND}"
+                                 "${arg_EXECUTABLE} --list_content listed no test units (exit ${result}): ${output}"
+                                 ${arg_PROPERTIES})
+      cmake_language(EVAL CODE "${script}")
+      return()
+   endif()
+   if(duplicates)
+      # Units whose names coincide after NAME_STRIP would share one CTest name; report it until the executable changes.
+      list(REMOVE_DUPLICATES duplicates)
+      _boost_test_append_failure("${arg_FAILURE_NAME}" "${arg_CMAKE_COMMAND}"
+                                 "${arg_EXECUTABLE}: units map to the same test name: ${duplicates}" ${arg_PROPERTIES})
+   endif()
+   # Written beside the target and renamed into place, so a reader never includes a partial file.
+   file(WRITE "${arg_TESTS_FILE}.tmp" "${script}")
+   file(RENAME "${arg_TESTS_FILE}.tmp" "${arg_TESTS_FILE}")
+endfunction()
+
+cmake_policy(POP)
diff --git a/cmake/boost-test-discovery.cmake b/cmake/boost-test-discovery.cmake
new file mode 100644
index 0000000000..d42fa24d7d
--- /dev/null
+++ b/cmake/boost-test-discovery.cmake
@@ -0,0 +1,115 @@
+#[=======================================================================[
+boost_test_discover_tests(<target> NAME <template> [options...])
+
+Registers one CTest entry per top-level unit (a suite, or a test case declared outside any suite) of a Boost.Test
+executable. The units are read from the executable's own `--list_content` output when ctest starts, the way CMake's
+gtest_discover_tests(DISCOVERY_MODE PRE_TEST) works for GoogleTest, so adding or removing a suite needs no CMake edit.
+
+  NAME <template>                 CTest name. @UNIT@ is the Boost unit, @NAME@ the unit after NAME_STRIP, and
+                                  @RUNTIME@ the runtime when RUNTIMES is given.
+  NAME_STRIP <regex>...           Patterns removed from @UNIT@, in order, to form @NAME@.
+  RUNTIMES <runtime>...           One entry per unit per runtime, each run with `-- --<runtime>`.
+  INCLUDE <regex>                 Register only the units that match.
+  EXCLUDE <regex>                 Skip the units that match.
+  ARGS <arg>...                   Arguments after `--run_test=<unit>`.
+  WORKING_DIRECTORY <dir>         Defaults to CMAKE_BINARY_DIR.
+  PROPERTIES <name> <value>...    Single-valued test properties set on every entry.
+  COST_BY_NAME <regex> <cost>...  COST for the entries whose @NAME@ matches; the first match wins.
+
+A unit disabled by default is registered DISABLED. Until the executable is built a failing <target>_NOT_BUILT entry
+stands in, and if the executable cannot list its units a failing <target>_DISCOVERY_FAILED entry reports why. The list
+is cached until the executable or these options change.
+#]=======================================================================]
+
+set(_BOOST_TEST_DISCOVERY_IMPL "${CMAKE_CURRENT_LIST_DIR}/boost-test-discovery-impl.cmake")
+
+function(boost_test_discover_tests TARGET)
+   cmake_parse_arguments(PARSE_ARGV 1 arg "" "NAME;INCLUDE;EXCLUDE;WORKING_DIRECTORY"
+                         "NAME_STRIP;RUNTIMES;ARGS;PROPERTIES;COST_BY_NAME")
+   if(NOT arg_NAME OR arg_UNPARSED_ARGUMENTS)
+      message(FATAL_ERROR "boost_test_discover_tests(${TARGET}) needs NAME; unexpected: ${arg_UNPARSED_ARGUMENTS}")
+   endif()
+   # Lists reach the ctest-time implementation joined into single arguments, so no value may contain `;`.
+   foreach(option IN ITEMS NAME_STRIP RUNTIMES ARGS PROPERTIES COST_BY_NAME)
+      foreach(value IN LISTS arg_${option})
+         if(value MATCHES ";")
+            message(FATAL_ERROR "boost_test_discover_tests(${TARGET}): ${option} values cannot contain `;`: ${value}")
+         endif()
+      endforeach()
+   endforeach()
+   foreach(pairs IN ITEMS PROPERTIES COST_BY_NAME)
+      list(LENGTH arg_${pairs} length)
+      math(EXPR odd "${length} % 2")
+      if(odd)
+         message(FATAL_ERROR "boost_test_discover_tests(${TARGET}): ${pairs} takes pairs, got: ${arg_${pairs}}")
+      endif()
+   endforeach()
+   if(NOT arg_WORKING_DIRECTORY)
+      set(arg_WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
+   endif()
+
+   # Each call gets its own files and placeholder names, so one executable can be discovered with different options.
+   get_property(call TARGET ${TARGET} PROPERTY BOOST_TEST_DISCOVERY_CALLS)
+   if(NOT call)
+      set(call 0)
+   endif()
+   math(EXPR call "${call} + 1")
+   set_property(TARGET ${TARGET} PROPERTY BOOST_TEST_DISCOVERY_CALLS ${call})
+   set(placeholder ${TARGET})
+   if(call GREATER 1)
+      set(placeholder ${TARGET}_${call})
+   endif()
+   set(file_base "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}_discovery_${call}")
+   get_property(multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+   set(tests_file "${file_base}_tests.cmake")
+   if(multi_config)
+      set(tests_file "${file_base}_tests-$<CONFIG>.cmake")
+   endif()
+
+   set(placeholder_properties "")
+   foreach(value IN LISTS arg_PROPERTIES)
+      string(APPEND placeholder_properties " [==[${value}]==]")
+   endforeach()
+
+   # Runs when ctest reads this directory's tests; the implementation rediscovers only when the list is stale.
+   string(CONCAT content
+      "if(EXISTS [==[$<TARGET_FILE:${TARGET}>]==])\n"
+      "   include([==[${_BOOST_TEST_DISCOVERY_IMPL}]==])\n"
+      "   boost_test_discover_tests_impl(\n"
+      "      EXECUTABLE [==[$<TARGET_FILE:${TARGET}>]==]\n"
+      "      TESTS_FILE [==[${tests_file}]==]\n"
+      "      INCLUDE_FILE \"\${CMAKE_CURRENT_LIST_FILE}\"\n"
+      "      FAILURE_NAME [==[${placeholder}_DISCOVERY_FAILED]==]\n"
+      "      CMAKE_COMMAND [==[${CMAKE_COMMAND}]==]\n"
+      "      WORKING_DIRECTORY [==[${arg_WORKING_DIRECTORY}]==]\n"
+      "      NAME [==[${arg_NAME}]==]\n"
+      "      NAME_STRIP [==[${arg_NAME_STRIP}]==]\n"
+      "      RUNTIMES [==[${arg_RUNTIMES}]==]\n"
+      "      INCLUDE [==[${arg_INCLUDE}]==]\n"
+      "      EXCLUDE [==[${arg_EXCLUDE}]==]\n"
+      "      ARGS [==[${arg_ARGS}]==]\n"
+      "      PROPERTIES [==[${arg_PROPERTIES}]==]\n"
+      "      COST_BY_NAME [==[${arg_COST_BY_NAME}]==])\n"
+      "   if(EXISTS [==[${tests_file}]==])\n"
+      "      include([==[${tests_file}]==])\n"
+      "   endif()\n"
+      "else()\n"
+      "   add_test([==[${placeholder}_NOT_BUILT]==] [==[${placeholder}_NOT_BUILT]==])\n")
+   if(arg_PROPERTIES)
+      string(APPEND content
+         "   set_tests_properties([==[${placeholder}_NOT_BUILT]==] PROPERTIES${placeholder_properties})\n")
+   endif()
+   string(APPEND content "endif()\n")
+
+   # A multi-config generator gets one script per configuration, chosen by the configuration ctest runs (-C).
+   if(multi_config)
+      foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
+         file(GENERATE OUTPUT "${file_base}_include-${config}.cmake" CONTENT "${content}"
+              CONDITION $<CONFIG:${config}>)
+      endforeach()
+      file(WRITE "${file_base}_include.cmake" "include(\"${file_base}_include-\${CTEST_CONFIGURATION_TYPE}.cmake\")\n")
+   else()
+      file(GENERATE OUTPUT "${file_base}_include.cmake" CONTENT "${content}")
+   endif()
+   set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES "${file_base}_include.cmake")
+endfunction()
diff --git a/cmake/test-tools.cmake b/cmake/test-tools.cmake
index 151964bac7..092f0ab3a0 100644
--- a/cmake/test-tools.cmake
+++ b/cmake/test-tools.cmake
@@ -37,34 +37,3 @@ macro(unittest_target TARGET)
     link_native_exports(${TARGET})
 
 endmacro()
-
-macro(unittest_tests_add TARGET)
-    cmake_parse_arguments(ARG "" "" "UNITTEST_FILES" ${ARGN})
-    foreach(TEST_SUITE ${ARG_UNITTEST_FILES}) # create an independent target for each test suite
-        # GET TEST SUITE NAME
-        execute_process(
-                COMMAND
-                bash -c
-                "grep -E 'BOOST_AUTO_TEST_SUITE\\s*[(]' ${TEST_SUITE} | grep -vE '//.*BOOST_AUTO_TEST_SUITE\\s*[(]' | cut -d ')' -f 1 | cut -d '(' -f 2"
-                OUTPUT_VARIABLE SUITE_NAME
-                OUTPUT_STRIP_TRAILING_WHITESPACE) # get the test suite name from the *.cpp file
-
-        # IF NOT EMPTY, ADD TESTS
-        if(NOT "" STREQUAL "${SUITE_NAME}") # ignore empty lines
-            # TRIM TEST SUITE NAME
-            execute_process(
-                    COMMAND bash -c "echo ${SUITE_NAME} | sed -e 's/s$//' | sed -e 's/_test$//'"
-                    OUTPUT_VARIABLE TRIMMED_SUITE_NAME
-                    OUTPUT_STRIP_TRAILING_WHITESPACE) # trim "_test" or "_tests" from the end of ${SUITE_NAME}
-
-            # to run ${TARGET} with all log from blockchain displayed, put "--verbose" after "--", i.e. "unit_test -- --verbose"
-            foreach(RUNTIME ${SYSIO_WASM_RUNTIMES})
-                if(RUNTIME STREQUAL "native-module" AND NOT BUILD_SYSTEM_CONTRACTS)
-                    continue()
-                endif()
-                add_test(NAME ${TRIMMED_SUITE_NAME}_${TARGET}_${RUNTIME} COMMAND ${TARGET} --run_test=${SUITE_NAME} --report_level=detailed --color_output -- --${RUNTIME})
-            endforeach()
-
-        endif()
-    endforeach()
-endmacro()
diff --git a/cmake/test/boost-test-discovery-test.cmake b/cmake/test/boost-test-discovery-test.cmake
new file mode 100644
index 0000000000..c34e034851
--- /dev/null
+++ b/cmake/test/boost-test-discovery-test.cmake
@@ -0,0 +1,275 @@
+# Tests boost-test-discovery-impl.cmake against a stand-in test executable. Run with `cmake -P` from a scratch
+# directory; ctest runs it from the build directory.
+cmake_minimum_required(VERSION 3.19)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../boost-test-discovery-impl.cmake")
+
+set(work "${CMAKE_CURRENT_BINARY_DIR}/boost-test-discovery-test")
+file(REMOVE_RECURSE "${work}")
+file(MAKE_DIRECTORY "${work}")
+
+# add_test and set_tests_properties exist only while ctest reads its test files, so record the calls instead.
+function(add_test name)
+   list(JOIN ARGN " " command)
+   set_property(GLOBAL APPEND PROPERTY recorded_tests "${name}")
+   set_property(GLOBAL PROPERTY "command:${name}" "${command}")
+endfunction()
+function(set_tests_properties name)
+   list(JOIN ARGN " " properties)
+   set_property(GLOBAL APPEND_STRING PROPERTY "properties:${name}" " ${properties}")
+endfunction()
+
+function(expect_equal actual expected what)
+   if(NOT actual STREQUAL expected)
+      message(FATAL_ERROR "${what}:\n  expected [${expected}]\n  actual   [${actual}]")
+   endif()
+endfunction()
+
+function(expect_contains text part what)
+   string(FIND "${text}" "${part}" found)
+   if(found EQUAL -1)
+      message(FATAL_ERROR "${what}: [${part}] not in [${text}]")
+   endif()
+endfunction()
+
+# A stand-in for a Boost.Test executable: it writes a canned --list_content listing to the report sink and prints
+# noise on its own streams, as real executables may.
+function(make_executable name listing exit_code)
+   file(WRITE "${work}/${name}.listing" "${listing}")
+   file(WRITE "${work}/${name}.sh"
+      "#!/bin/sh\n"
+      "for argument in \"$@\"; do\n"
+      "   case \"$argument\" in --report_sink=*) sink=\"\${argument#--report_sink=}\";; esac\n"
+      "done\n"
+      "echo 'Random number generator seeded' ; echo 'stderr noise' >&2\n"
+      "cat '${work}/${name}.listing' > \"$sink\"\n"
+      "exit ${exit_code}\n")
+   file(CHMOD "${work}/${name}.sh" PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE)
+endfunction()
+
+# Discover with the given options, then load the generated script so its registrations are recorded.
+function(discover name)
+   set_property(GLOBAL PROPERTY recorded_tests "")
+   boost_test_discover_tests_impl(EXECUTABLE "${work}/${name}.sh" TESTS_FILE "${work}/${name}_tests.cmake"
+                                  FAILURE_NAME ${name}_DISCOVERY_FAILED CMAKE_COMMAND "${CMAKE_COMMAND}"
+                                  WORKING_DIRECTORY "${work}" ${ARGN})
+   if(EXISTS "${work}/${name}_tests.cmake")
+      include("${work}/${name}_tests.cmake")
+   endif()
+endfunction()
+
+# Built from escaped strings so the trailing space that marks a default-disabled unit survives editors.
+string(CONCAT listing
+   "alpha_tests*\n"
+   "    alpha_case*\n"
+   "beta_tests \n"
+   "    nested_suite*\n"
+   "        deep_case*\n"
+   "described_tests*: covers a;b and [the rest\n"
+   "quiet_one : disabled, with a description\n"
+   "tmpl_case<unsigned long>*\n"
+   "bare_tests\n"
+   "loose_case*\n")
+
+# Every top-level unit, each runtime, filters, name stripping, COST, default-disabled units and quoting.
+make_executable(full "${listing}" 0)
+# Lists arrive joined into single arguments, as the generated include script passes them.
+discover(full NAME "@NAME@_unit_test_@RUNTIME@" NAME_STRIP "s$;_test$" RUNTIMES "r1;r2" EXCLUDE "^loose"
+         ARGS "--report_level=detailed" PROPERTIES "LABELS;lane" COST_BY_NAME "^alpha$;500")
+get_property(tests GLOBAL PROPERTY recorded_tests)
+list(SORT tests)
+set(expected alpha_unit_test_r1 alpha_unit_test_r2 bare_unit_test_r1 bare_unit_test_r2 beta_unit_test_r1
+    beta_unit_test_r2 described_unit_test_r1 described_unit_test_r2 quiet_one_unit_test_r1 quiet_one_unit_test_r2
+    "tmpl_case<unsigned long>_unit_test_r1" "tmpl_case<unsigned long>_unit_test_r2")
+expect_equal("${tests}" "${expected}" "registered tests")
+get_property(command GLOBAL PROPERTY "command:alpha_unit_test_r2")
+expect_equal("${command}" "${work}/full.sh --run_test=alpha_tests --report_level=detailed -- --r2" "command")
+get_property(properties GLOBAL PROPERTY "properties:alpha_unit_test_r1")
+expect_equal("${properties}" " PROPERTIES WORKING_DIRECTORY ${work} LABELS lane COST 500" "enabled unit properties")
+get_property(properties GLOBAL PROPERTY "properties:quiet_one_unit_test_r1")
+expect_contains("${properties}" "DISABLED TRUE" "disabled unit with a description")
+get_property(properties GLOBAL PROPERTY "properties:beta_unit_test_r2")
+expect_contains("${properties}" "DISABLED TRUE" "disabled unit")
+get_property(properties GLOBAL PROPERTY "properties:described_unit_test_r1")
+string(FIND "${properties}" "DISABLED" found)
+expect_equal("${found}" "-1" "enabled unit with a description")
+
+# Without RUNTIMES each unit gets one entry and no runtime argument; INCLUDE narrows the units.
+discover(full NAME "contract.@UNIT@" INCLUDE "^alpha")
+get_property(tests GLOBAL PROPERTY recorded_tests)
+expect_equal("${tests}" "contract.alpha_tests" "single-entry registration")
+get_property(command GLOBAL PROPERTY "command:contract.alpha_tests")
+expect_equal("${command}" "${work}/full.sh --run_test=alpha_tests" "single-entry command")
+
+# A filter that matches none of the listed units registers nothing and is not a failure.
+discover(full NAME "@UNIT@" INCLUDE "^nothing_matches")
+get_property(tests GLOBAL PROPERTY recorded_tests)
+expect_equal("${tests}" "" "empty filter result")
+
+# An executable that cannot list its units registers a single failing entry and leaves no script behind, so the
+# next ctest run discovers again.
+make_executable(broken "${listing}" 3)
+discover(broken NAME "@UNIT@" PROPERTIES LABELS lane)
+get_property(tests GLOBAL PROPERTY recorded_tests)
+expect_equal("${tests}" "broken_DISCOVERY_FAILED" "failing listing")
+get_property(command GLOBAL PROPERTY "command:broken_DISCOVERY_FAILED")
+expect_contains("${command}" "(exit 3)" "failure message")
+get_property(properties GLOBAL PROPERTY "properties:broken_DISCOVERY_FAILED")
+expect_equal("${properties}" " PROPERTIES WILL_FAIL TRUE LABELS lane" "failure entry properties")
+if(EXISTS "${work}/broken_tests.cmake")
+   message(FATAL_ERROR "a failed discovery left a tests script behind")
+endif()
+
+# Units whose names coincide after NAME_STRIP are reported by a failing entry.
+make_executable(dups "dup_tests*\ndup_test*\n" 0)
+discover(dups NAME "@NAME@" NAME_STRIP "s$;_test$")
+get_property(tests GLOBAL PROPERTY recorded_tests)
+expect_equal("${tests}" "dup;dup;dups_DISCOVERY_FAILED" "colliding names")
+
+# Without the lock, discovery leaves the shared files alone, keeps the current list and reports why. Another process
+# holds the lock, since CMake crashes when one process locks a file twice, while this one tries once.
+make_executable(lockfail "${listing}" 0)
+file(WRITE "${work}/lockfail_tests.cmake" "# the current list\n")
+file(WRITE "${work}/hold.cmake"
+   "file(LOCK [==[${work}/lockfail_tests.cmake.lock]==])\n"
+   "file(TOUCH [==[${work}/held]==])\n"
+   "foreach(i RANGE 100)\n"
+   "   if(EXISTS [==[${work}/tried]==])\n      break()\n   endif()\n"
+   "   execute_process(COMMAND [==[${CMAKE_COMMAND}]==] -E sleep 0.1)\n"
+   "endforeach()\n")
+file(WRITE "${work}/try.cmake"
+   "foreach(i RANGE 100)\n"
+   "   if(EXISTS [==[${work}/held]==])\n      break()\n   endif()\n"
+   "   execute_process(COMMAND [==[${CMAKE_COMMAND}]==] -E sleep 0.1)\n"
+   "endforeach()\n"
+   "function(add_test name)\n   message(\"registered \${name} \${ARGN}\")\nendfunction()\n"
+   "function(set_tests_properties)\nendfunction()\n"
+   "include([==[${CMAKE_CURRENT_LIST_DIR}/../boost-test-discovery-impl.cmake]==])\n"
+   "boost_test_discover_tests_impl(EXECUTABLE [==[${work}/lockfail.sh]==]\n"
+   "   TESTS_FILE [==[${work}/lockfail_tests.cmake]==] FAILURE_NAME lockfail_DISCOVERY_FAILED\n"
+   "   CMAKE_COMMAND [==[${CMAKE_COMMAND}]==] WORKING_DIRECTORY [==[${work}]==] NAME @UNIT@ LOCK_TIMEOUT 0)\n"
+   "file(TOUCH [==[${work}/tried]==])\n")
+execute_process(COMMAND "${CMAKE_COMMAND}" -P "${work}/hold.cmake" COMMAND "${CMAKE_COMMAND}" -P "${work}/try.cmake"
+                OUTPUT_VARIABLE output ERROR_VARIABLE output TIMEOUT 60)
+expect_contains("${output}" "registered lockfail_DISCOVERY_FAILED" "failed lock")
+expect_contains("${output}" "cannot lock" "failed lock message")
+file(READ "${work}/lockfail_tests.cmake" kept)
+expect_equal("${kept}" "# the current list\n" "list kept without the lock")
+
+make_executable(empty "" 0)
+discover(empty NAME "@UNIT@")
+get_property(tests GLOBAL PROPERTY recorded_tests)
+expect_equal("${tests}" "empty_DISCOVERY_FAILED" "executable listing no units")
+
+# End to end: a tiny project using boost_test_discover_tests(), read back through ctest. GENERATOR, CXX and CONFIG let
+# the ctest entry build it the way the enclosing build is built; under a multi-config generator the nested configure,
+# build and every ctest call need CONFIG, which may be a custom configuration.
+get_filename_component(cmake_bin "${CMAKE_COMMAND}" DIRECTORY)
+set(ctest_command "${cmake_bin}/ctest")
+if(NOT GENERATOR)
+   set(GENERATOR Ninja)
+endif()
+set(configure_config "")
+set(build_config "")
+set(ctest_config "")
+if(CONFIG)
+   set(configure_config "-DCMAKE_CONFIGURATION_TYPES=${CONFIG}")
+   set(build_config --config "${CONFIG}")
+   set(ctest_config -C "${CONFIG}")
+endif()
+set(project "${work}/project")
+file(WRITE "${project}/listing.txt" "one_tests*\n    one_case*\ntwo_tests*\n")
+file(WRITE "${project}/fake.cpp" [==[
+// Stand-in for a Boost.Test executable: writes LISTING_FILE to the --report_sink file, and passes when run as a test.
+#include <fstream>
+#include <string>
+int main(int argc, char** argv) {
+   for (int i = 1; i < argc; ++i) {
+      const std::string argument = argv[i];
+      if (argument.rfind("--report_sink=", 0) == 0) {
+         std::ifstream listing(LISTING_FILE);
+         std::ofstream(argument.substr(14)) << listing.rdbuf();
+      }
+   }
+   return 0;
+}
+]==])
+file(WRITE "${project}/CMakeLists.txt"
+   "cmake_minimum_required(VERSION 3.19)\n"
+   "project(boost_test_discovery_e2e LANGUAGES CXX)\n"
+   "enable_testing()\n"
+   "include([==[${CMAKE_CURRENT_LIST_DIR}/../boost-test-discovery.cmake]==])\n"
+   "add_executable(fake fake.cpp)\n"
+   "set_target_properties(fake PROPERTIES RUNTIME_OUTPUT_DIRECTORY \"$<1:\${CMAKE_BINARY_DIR}>\")\n"
+   "target_compile_definitions(fake PRIVATE [==[LISTING_FILE=\"${project}/listing.txt\"]==])\n"
+   "boost_test_discover_tests(fake NAME e2e.@UNIT@.@RUNTIME@ RUNTIMES a b ARGS --x PROPERTIES LABELS lane TIMEOUT 7)\n")
+
+function(run what)
+   execute_process(COMMAND ${ARGN} RESULT_VARIABLE result OUTPUT_VARIABLE output ERROR_VARIABLE output)
+   if(NOT result EQUAL 0)
+      message(FATAL_ERROR "${what} failed (${result}):\n${output}")
+   endif()
+   set(output "${output}" PARENT_SCOPE)
+endfunction()
+
+# The test names ctest lists in `build`, in order.
+function(listed_tests out build)
+   run("ctest --show-only" "${ctest_command}" --show-only=json-v1 ${ARGN} WORKING_DIRECTORY "${build}")
+   string(JSON count LENGTH "${output}" tests)
+   set(names "")
+   if(count GREATER 0)
+      math(EXPR last "${count} - 1")
+      foreach(i RANGE ${last})
+         string(JSON name GET "${output}" tests ${i} name)
+         list(APPEND names "${name}")
+      endforeach()
+   endif()
+   list(SORT names)
+   set(${out} "${names}" PARENT_SCOPE)
+   set(json "${output}" PARENT_SCOPE)
+endfunction()
+
+set(compiler "")
+if(CXX)
+   set(compiler "-DCMAKE_CXX_COMPILER=${CXX}")
+endif()
+set(build "${work}/build")
+run("configure" "${CMAKE_COMMAND}" -S "${project}" -B "${build}" -G "${GENERATOR}" ${compiler} ${configure_config})
+listed_tests(tests "${build}" ${ctest_config})
+expect_equal("${tests}" "fake_NOT_BUILT" "before the executable is built")
+
+run("build" "${CMAKE_COMMAND}" --build "${build}" ${build_config})
+listed_tests(tests "${build}" ${ctest_config})
+expect_equal("${tests}" "e2e.one_tests.a;e2e.one_tests.b;e2e.two_tests.a;e2e.two_tests.b" "after the build")
+string(JSON length LENGTH "${json}" tests 0 command)
+math(EXPR last "${length} - 1")
+set(arguments "")
+foreach(i RANGE 1 ${last})
+   string(JSON argument GET "${json}" tests 0 command ${i})
+   list(APPEND arguments "${argument}")
+endforeach()
+expect_equal("${arguments}" "--run_test=one_tests;--x;--;--a" "discovered command")
+string(JSON properties GET "${json}" tests 0 properties)
+expect_contains("${properties}" "\"lane\"" "LABELS")
+expect_contains("${properties}" "\"TIMEOUT\"" "TIMEOUT")
+run("running the entries" "${ctest_command}" --output-on-failure ${ctest_config} WORKING_DIRECTORY "${build}")
+
+# A newer executable is listed again: a suite added to it appears without reconfiguring.
+file(APPEND "${project}/listing.txt" "three_tests*\n")
+execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep 1)
+file(TOUCH "${build}/fake")
+listed_tests(tests "${build}" ${ctest_config})
+list(LENGTH tests count)
+expect_equal("${count}" "6" "after the executable changed")
+
+if(GENERATOR STREQUAL "Ninja")
+   set(multi "${work}/multi")
+   run("configure multi-config" "${CMAKE_COMMAND}" -S "${project}" -B "${multi}" -G "Ninja Multi-Config" ${compiler})
+   run("build multi-config" "${CMAKE_COMMAND}" --build "${multi}" --config Debug)
+   listed_tests(tests "${multi}" -C Debug)
+   list(LENGTH tests count)
+   expect_equal("${count}" "6" "multi-config Debug")
+endif()
+
+file(REMOVE_RECURSE "${work}")
+message(STATUS "boost-test-discovery: all checks passed")
diff --git a/contracts/tests/CMakeLists.txt b/contracts/tests/CMakeLists.txt
index 953f1ab2b1..d689e596b8 100644
--- a/contracts/tests/CMakeLists.txt
+++ b/contracts/tests/CMakeLists.txt
@@ -37,147 +37,9 @@ target_link_libraries(${CONTRACT_UNIT_TEST_EXE}
 target_include_directories(${CONTRACT_UNIT_TEST_EXE} PRIVATE
         ${CMAKE_SOURCE_DIR}/libraries/opp/test/include)
 
-# Register every top-level Boost suite as a separate CTest process. The
-# processes share this executable but remain independently selectable and may
-# run concurrently under ctest -j.
-set(CONTRACT_SUITE_MACRO_PATTERN
-  "BOOST_(AUTO|FIXTURE|DATA)_TEST_SUITE[ \t\r\n]*\\([ \t\r\n]*([A-Za-z_][A-Za-z_0-9]*)[ \t\r\n]*[,)]")
-function(add_contract_suite SUITE_NAME SOURCE_FILE)
-  cmake_parse_arguments(SUITE "" "" "ACCOUNTS" ${ARGN})
-  if(SUITE_UNPARSED_ARGUMENTS)
-    message(FATAL_ERROR "Unexpected arguments for contract suite ${SUITE_NAME}: ${SUITE_UNPARSED_ARGUMENTS}")
-  endif()
-  if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE_FILE}")
-    message(FATAL_ERROR "Contract suite source is missing: ${SOURCE_FILE}")
-  endif()
-  file(READ "${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE_FILE}" _suite_source_text)
-  string(REGEX MATCH
-    "BOOST_(AUTO|FIXTURE|DATA)_TEST_SUITE[ \t\r\n]*\\([ \t\r\n]*${SUITE_NAME}[ \t\r\n]*[,)]"
-    _suite_declaration
-    "${_suite_source_text}")
-  if(NOT _suite_declaration)
-    message(FATAL_ERROR "Contract suite ${SUITE_NAME} is not declared in ${SOURCE_FILE}")
-  endif()
-  get_property(_registered_suites GLOBAL PROPERTY CONTRACT_REGISTERED_SUITES)
-  if(SUITE_NAME IN_LIST _registered_suites)
-    message(FATAL_ERROR "Contract suite ${SUITE_NAME} is registered twice")
-  endif()
-  set_property(GLOBAL APPEND PROPERTY CONTRACT_REGISTERED_SUITES ${SUITE_NAME})
-  set(_ctest_name "contract.${SUITE_NAME}")
-  add_test(
-    NAME ${_ctest_name}
-    COMMAND ${CONTRACT_UNIT_TEST_EXE}
-            --run_test=${SUITE_NAME}
-            --report_level=detailed
-    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
-  )
-  set_tests_properties(${_ctest_name} PROPERTIES
-    LABELS "contract;${SUITE_ACCOUNTS}"
-    TIMEOUT ${CONTRACT_UNIT_TEST_TIMEOUT_SECONDS}
-  )
-endfunction()
-
-# Every runnable top-level suite is visible here with its owning source.
-add_contract_suite(amm_math_tests amm_math_tests.cpp ACCOUNTS sysio.opp.common)
-add_contract_suite(council_math_tests council_math_tests.cpp ACCOUNTS sysio.councl)
-add_contract_suite(sysio_emissions_tests emissions_tests.cpp ACCOUNTS
-  sysio.dclaim sysio.epoch sysio.msig sysio.opreg
-  sysio.reserv sysio.system sysio.token sysio.uwrit)
-add_contract_suite(t5_emissions_tests emissions_tests.cpp ACCOUNTS
-  sysio.dclaim sysio.epoch sysio.msig sysio.opreg
-  sysio.reserv sysio.system sysio.token sysio.uwrit)
-add_contract_suite(sysio_producer_eligibility_tests emissions_tests.cpp ACCOUNTS
-  sysio.dclaim sysio.epoch sysio.msig sysio.opreg
-  sysio.reserv sysio.system sysio.token sysio.uwrit)
-add_contract_suite(sysio_producer_score_tests emissions_tests.cpp ACCOUNTS
-  sysio.dclaim sysio.epoch sysio.msig sysio.opreg
-  sysio.reserv sysio.system sysio.token sysio.uwrit)
-add_contract_suite(getpeerkeys_tests getpeerkeys_tests.cpp ACCOUNTS
-  sysio.msig sysio.system sysio.token)
-add_contract_suite(safe_ops_tests safe_ops_tests.cpp ACCOUNTS sysio.opp.common)
-add_contract_suite(sysio_authex_tests sysio.authex_tests.cpp ACCOUNTS sysio.authex)
-add_contract_suite(sysio_bios_if_tests sysio.bios_inst_fin_tests.cpp ACCOUNTS sysio.bios)
-add_contract_suite(sysio_chains_tests sysio.chains_tests.cpp ACCOUNTS sysio.chains)
-add_contract_suite(sysio_councl_tests sysio.councl_tests.cpp ACCOUNTS
-  sysio.councl sysio.msig sysio.system sysio.token)
-add_contract_suite(sysio_dclaim_tests sysio.dclaim_tests.cpp ACCOUNTS sysio.dclaim)
-add_contract_suite(sysio_dispatch_tests sysio.dispatch_tests.cpp ACCOUNTS
-  sysio.authex sysio.chains sysio.chalg sysio.epoch
-  sysio.msgch sysio.opreg sysio.opp.common sysio.reserv
-  sysio.system sysio.token sysio.uwrit)
-add_contract_suite(sysio_dispute_tests sysio.dispute_tests.cpp ACCOUNTS
-  sysio.chains sysio.chalg sysio.epoch sysio.msgch
-  sysio.msig sysio.opreg sysio.roa sysio.system
-  sysio.token sysio.uwrit)
-add_contract_suite(sysio_epoch_flushwtdw_tests sysio.epoch_flushwtdw_tests.cpp ACCOUNTS
-  sysio.chains sysio.epoch sysio.msgch sysio.opreg
-  sysio.system sysio.token sysio.uwrit)
-add_contract_suite(sysio_epoch_tests sysio.epoch_tests.cpp ACCOUNTS sysio.chains sysio.epoch)
-add_contract_suite(sysio_system_finalizer_key_tests sysio.finalizer_key_tests.cpp ACCOUNTS
-  sysio.msig sysio.opreg sysio.system sysio.token)
-add_contract_suite(sysio_inline_auth_tests sysio.inline_auth_tests.cpp ACCOUNTS sysio.system test.sendinline)
-add_contract_suite(sysio_system_limitauth_tests sysio.limitauth_tests.cpp ACCOUNTS
-  sysio.msig sysio.system sysio.token)
-add_contract_suite(sysio_liq_tests sysio.liq_tests.cpp ACCOUNTS
-  sysio.authex sysio.chains sysio.liq sysio.msgch
-  sysio.swap sysio.token sysio.tokens)
-add_contract_suite(sysio_msgch_chain_tests sysio.msgch_chain_tests.cpp ACCOUNTS
-  sysio.chains sysio.chalg sysio.epoch sysio.msgch
-  sysio.opreg sysio.roa sysio.system sysio.token
-  sysio.uwrit)
-add_contract_suite(sysio_msgch_tests sysio.msgch_tests.cpp ACCOUNTS
-  sysio.chains sysio.epoch sysio.msgch)
-add_contract_suite(sysio_msgch_envlog_tests sysio.msgch_tests.cpp ACCOUNTS
-  sysio.chains sysio.epoch sysio.msgch)
-add_contract_suite(sysio_msig_tests sysio.msig_tests.cpp ACCOUNTS
-  sysio.msig sysio.system sysio.token test.sendinline)
-add_contract_suite(sysio_opreg_tests sysio.opreg_tests.cpp ACCOUNTS
-  sysio.epoch sysio.opreg sysio.token)
-add_contract_suite(sysio_reserve_tests sysio.reserv_tests.cpp ACCOUNTS
-  sysio.authex sysio.chains sysio.msgch sysio.opp.common
-  sysio.reserv sysio.token)
-add_contract_suite(sysio_roa_tests sysio.roa_tests.cpp ACCOUNTS
-  sysio.authex sysio.msig sysio.roa sysio.system
-  sysio.token test.noop test.sendinline)
-add_contract_suite(sysio_snapshot_attest_tests sysio.snapshot_attest_tests.cpp ACCOUNTS
-  sysio.msig sysio.system sysio.token)
-add_contract_suite(sysio_swap_tests sysio.swap_tests.cpp ACCOUNTS
-  sysio.chains sysio.liq sysio.opp.common sysio.swap
-  sysio.token sysio.tokens test.badtoken)
-add_contract_suite(sysio_system_blockinfo_tests sysio.system_blockinfo_tests.cpp ACCOUNTS
-  sysio.msig sysio.system sysio.token test.blockinfo_tester)
-add_contract_suite(sysio_system_tests sysio.system_tests.cpp ACCOUNTS
-  sysio.bios sysio.msig sysio.system sysio.token)
-add_contract_suite(sysio_token_tests sysio.token_tests.cpp ACCOUNTS
-  sysio.msig sysio.system sysio.token)
-add_contract_suite(sysio_tokens_tests sysio.tokens_tests.cpp ACCOUNTS sysio.tokens)
-add_contract_suite(sysio_uwrit_tests sysio.uwrit_tests.cpp ACCOUNTS sysio.uwrit)
-add_contract_suite(sysio_wrap_tests sysio.wrap_tests.cpp ACCOUNTS sysio.msig sysio.wrap)
-add_contract_suite(twap_tests twap_tests.cpp ACCOUNTS sysio.opp.common)
-get_property(_registered_suites GLOBAL PROPERTY CONTRACT_REGISTERED_SUITES)
-
-# Fail at configure time when a source introduces a suite without registering it.
-# Contract tests must live in a named suite: file-scope test cases cannot be
-# discovered by this inventory and therefore cannot be registered separately.
-set(_source_suites)
-file(GLOB _contract_suite_sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
-foreach(_source IN LISTS _contract_suite_sources)
-  file(READ "${_source}" _source_text)
-  string(REGEX MATCHALL "${CONTRACT_SUITE_MACRO_PATTERN}" _suite_macros "${_source_text}")
-  foreach(_macro IN LISTS _suite_macros)
-    string(REGEX REPLACE "^${CONTRACT_SUITE_MACRO_PATTERN}$" "\\2" _declared_suite "${_macro}")
-    list(APPEND _source_suites ${_declared_suite})
-  endforeach()
-endforeach()
-list(REMOVE_DUPLICATES _source_suites)
-list(SORT _source_suites)
-list(SORT _registered_suites)
-set(_missing_suites ${_source_suites})
-list(REMOVE_ITEM _missing_suites ${_registered_suites})
-set(_extra_suites ${_registered_suites})
-list(REMOVE_ITEM _extra_suites ${_source_suites})
-if(_missing_suites OR _extra_suites)
-  message(FATAL_ERROR
-    "Contract suites declared but not registered: ${_missing_suites}; "
-    "registered but not declared: ${_extra_suites}")
-endif()
+# One CTest entry per top-level suite, contract.<suite>, discovered from the built executable. The entries share it
+# and can run concurrently under ctest -j.
+boost_test_discover_tests(${CONTRACT_UNIT_TEST_EXE}
+        NAME contract.@UNIT@
+        ARGS --report_level=detailed
+        PROPERTIES LABELS contract TIMEOUT ${CONTRACT_UNIT_TEST_TIMEOUT_SECONDS})
diff --git a/plugins/chain_plugin/test/CMakeLists.txt b/plugins/chain_plugin/test/CMakeLists.txt
index 42a397821e..f34b8a97e4 100644
--- a/plugins/chain_plugin/test/CMakeLists.txt
+++ b/plugins/chain_plugin/test/CMakeLists.txt
@@ -10,38 +10,6 @@ target_link_libraries( test_chain_plugin chain_plugin sysio_testing sysio_chain_
 target_include_directories(test_chain_plugin PRIVATE
         ${CMAKE_SOURCE_DIR}/unittests
         ${CMAKE_BINARY_DIR}/unittests/include)
-set(CHAIN_PLUGIN_TEST_CASES
-        chain_plugin_default_tests
-        chain_plugin_accepts_attested_auto_fetched_snapshot
-        chain_plugin_rejects_auto_fetched_snapshot_without_enabled_config
-        chain_plugin_accepts_trusted_manual_snapshot_without_attestation_table
-        snapshot_attestation_table_read_failure_policy
-        snapshot_attestation_table_read_timeout_policy
-        snapshot_attestation_table_read_retry_policy
-        snapshot_attestation_required_schema_policy
-        snapshot_attestation_enabled_config_policy
-        snapshot_attestation_record_tuple_policy
-        snapshot_endpoint_block_identity_policy
-        get_info_consumer_plugin_policy
-        chain_plugin_snapshot_endpoint_option_registration
-        outbound_http_global_option_registration
-        chain_plugin_snapshot_endpoint_option_validation
-        account_query_db_tests
-        block_channel_tests
-        trx_finality_status_processing_test
-        trx_retry_db_test
-        )
-
-if("sys-vm-oc" IN_LIST SYSIO_WASM_RUNTIMES)
-   list(APPEND CHAIN_PLUGIN_TEST_CASES
-           chain_plugin_default_sys_vm_oc_whitelist
-           chain_plugin_sys_vm_oc_whitelist
-           )
-endif()
-
-foreach(TEST_CASE IN LISTS CHAIN_PLUGIN_TEST_CASES)
-   add_p_test(
-           NAME test_chain_plugin_${TEST_CASE}
-           COMMAND plugins/chain_plugin/test/test_chain_plugin --run_test=${TEST_CASE} --report_level=detailed --color_output
-           )
-endforeach()
+boost_test_discover_tests(test_chain_plugin
+        NAME test_chain_plugin_@UNIT@
+        ARGS --report_level=detailed --color_output)
diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt
index 7bdbd6f72c..5f7da15d3d 100644
--- a/unittests/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -28,6 +28,13 @@ else()
   add_subdirectory(test-contracts)
 endif()
 
+# Runtimes the unit_test and wasm_spec_test entries run on. Native-module tests require .so files built by
+# add_native_contract (needs CDT).
+set(UNIT_TEST_RUNTIMES ${SYSIO_WASM_RUNTIMES})
+if(NOT BUILD_SYSTEM_CONTRACTS)
+  list(REMOVE_ITEM UNIT_TEST_RUNTIMES native-module)
+endif()
+
 if(NOT DISABLE_WASM_SPEC_TESTS)
   add_subdirectory(wasm-spec-tests/generated-tests)
 endif()
@@ -71,59 +78,29 @@ endif()
 
 ### MARK TEST SUITES FOR EXECUTION ###
 add_p_test(NAME protocol_feature_digest_unit_test COMMAND unit_test --run_test=protocol_feature_digest_tests --report_level=detailed --log_level=all --color_output)
-set(ctest_tests "protocol_feature_digest_tests")
-foreach(TEST_SUITE ${UNIT_TESTS}) # create an independent target for each test suite
-  execute_process(COMMAND sh -c "grep -E 'BOOST_AUTO_TEST_SUITE\\s*[(]' '${TEST_SUITE}' | grep -vE '//.*BOOST_AUTO_TEST_SUITE\\s*[(]' | cut -d ')' -f 1 | cut -d '(' -f 2" OUTPUT_VARIABLE SUITE_NAMES OUTPUT_STRIP_TRAILING_WHITESPACE) # get the test suite name from the *.cpp file
-  string(REPLACE "\n" ";" SUITE_NAMES "${SUITE_NAMES}")
-  foreach(SUITE_NAME IN LISTS SUITE_NAMES)
-    if (NOT "" STREQUAL "${SUITE_NAME}") # ignore empty lines
-      execute_process(COMMAND sh -c "echo ${SUITE_NAME} | sed -e 's/s$//' | sed -e 's/_test$//'" OUTPUT_VARIABLE TRIMMED_SUITE_NAME OUTPUT_STRIP_TRAILING_WHITESPACE) # trim "_test" or "_tests" from the end of ${SUITE_NAME}
-      # to run unit_test with all log from blockchain displayed, put "--verbose" after "--", i.e. "unit_test -- --verbose"
-      foreach(RUNTIME ${SYSIO_WASM_RUNTIMES})
-        # Native-module tests require .so files built by add_native_contract (needs CDT).
-        if(RUNTIME STREQUAL "native-module" AND NOT BUILD_SYSTEM_CONTRACTS)
-          continue()
-        endif()
-        add_p_test(NAME ${TRIMMED_SUITE_NAME}_unit_test_${RUNTIME} COMMAND unit_test --run_test=${SUITE_NAME} --report_level=detailed --log_level=all --color_output -- --${RUNTIME})
-        # add a duplicate test to run without fsgsbase instructions for a limited number of OC wasm tests
-        if(RUNTIME STREQUAL "sys-vm-oc" AND TRIMMED_SUITE_NAME MATCHES "^wasm_part")
-           add_p_test(NAME ${TRIMMED_SUITE_NAME}_unit_test_${RUNTIME}-nofsgs COMMAND unit_test --run_test=${SUITE_NAME} --report_level=detailed --log_level=all --color_output -- --${RUNTIME} COST 5000)
-           set_tests_properties(${TRIMMED_SUITE_NAME}_unit_test_${RUNTIME}-nofsgs PROPERTIES ENVIRONMENT "SYSIO_DISABLE_FSGSBASE=1")
-        endif()
-        # build list of tests to run during coverage testing
-        if(ctest_tests)
-          string(APPEND ctest_tests "|")
-        endif()
-        string(APPEND ctest_tests ${TRIMMED_SUITE_NAME}_unit_test_$RUNTIME)
-      endforeach()
-    endif()
-  endforeach()
-endforeach()
-set(ctest_tests "'${ctest_tests}' -j8") # surround test list string in apostrophies
-
-# The following tests are known to take the longest, bump up their cost (priority) so that they'll run first
-# even on fresh first time test runs before ctest auto-detects costs
-foreach(RUNTIME ${SYSIO_WASM_RUNTIMES})
-   if(RUNTIME STREQUAL "native-module" AND NOT BUILD_SYSTEM_CONTRACTS)
-      continue()
-   endif()
-   set_tests_properties(api_part1_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(api_part2_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(api_part3_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(checktime_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_part1_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_part2_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_part3_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_config_part1_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_config_part2_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_config_part3_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_config_part4_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(wasm_config_part5_unit_test_${RUNTIME} PROPERTIES COST 5000)
-   set_tests_properties(snapshot_part1_unit_test_${RUNTIME} PROPERTIES COST 4000)
-   set_tests_properties(snapshot_part2_unit_test_${RUNTIME} PROPERTIES COST 4000)
-   set_tests_properties(finality_unit_test_${RUNTIME} PROPERTIES COST 4000)
-   set_tests_properties(delay_unit_test_${RUNTIME} PROPERTIES COST 3000)
-endforeach()
+# One entry per suite per runtime, <suite without _tests>_unit_test_<runtime>, discovered from the built executable.
+# To run unit_test with all log from blockchain displayed, put "--verbose" after "--", i.e. "unit_test -- --verbose".
+# COST starts the longest suites first, even on a fresh run before ctest has measured them.
+boost_test_discover_tests(unit_test
+        NAME @NAME@_unit_test_@RUNTIME@
+        NAME_STRIP "s$" "_test$"
+        RUNTIMES ${UNIT_TEST_RUNTIMES}
+        EXCLUDE "^protocol_feature_digest_tests$" # registered above: it does not depend on the runtime
+        ARGS --report_level=detailed --log_level=all --color_output
+        COST_BY_NAME "^(api_part[1-3]|checktime|wasm_part[1-3]|wasm_config_part[1-5])$" 5000
+             "^(snapshot_part[12]|finality)$" 4000
+             "^delay$" 3000)
+if("sys-vm-oc" IN_LIST UNIT_TEST_RUNTIMES)
+  # The wasm_part suites also run on sys-vm-oc without fsgsbase instructions.
+  boost_test_discover_tests(unit_test
+          NAME @NAME@_unit_test_@RUNTIME@-nofsgs
+          NAME_STRIP "s$" "_test$"
+          RUNTIMES sys-vm-oc
+          INCLUDE "^wasm_part"
+          ARGS --report_level=detailed --log_level=all --color_output
+          PROPERTIES ENVIRONMENT SYSIO_DISABLE_FSGSBASE=1 COST 5000)
+endif()
+set(ctest_tests "'_unit_test_|^protocol_feature_digest_unit_test' -LE wasm_spec_tests -j8") # every unit_test entry
 
 ### COVERAGE TESTING ###
 if(ENABLE_COVERAGE_TESTING)
diff --git a/unittests/wasm-spec-tests/generated-tests/CMakeLists.txt b/unittests/wasm-spec-tests/generated-tests/CMakeLists.txt
index 626e108e50..dcf047c9d8 100644
--- a/unittests/wasm-spec-tests/generated-tests/CMakeLists.txt
+++ b/unittests/wasm-spec-tests/generated-tests/CMakeLists.txt
@@ -16,39 +16,12 @@ target_include_directories( wasm_spec_test PUBLIC
                             ${CMAKE_CURRENT_BINARY_DIR}/include )
 
 ### MARK TEST SUITES FOR EXECUTION ###
-foreach(TEST_SUITE ${WASM_TESTS}) # create an independent target for each test suite
-  execute_process(COMMAND bash -c "grep -Eo 'BOOST_DATA_TEST_CASE\\(\\w*' '${TEST_SUITE}' | cut -c 22-" OUTPUT_VARIABLE SUITE_NAME OUTPUT_STRIP_TRAILING_WHITESPACE) # get the test suite name from the *.cpp file
-  if (NOT "" STREQUAL "${SUITE_NAME}") # ignore empty lines
-    string(REPLACE "\n" ";" SN_LIST ${SUITE_NAME})
-    foreach(SN ${SN_LIST})
-      foreach(RUNTIME ${SYSIO_WASM_RUNTIMES})
-          if(RUNTIME STREQUAL "native-module" AND NOT BUILD_SYSTEM_CONTRACTS)
-            continue()
-          endif()
-          get_test_property(${SN}_unit_test_${RUNTIME} LABELS TEST_LABEL)
-          if ("NOTFOUND" STREQUAL "${TEST_LABEL}") # prevent duplicates
-            add_wasmspec_test(NAME ${SN}_unit_test_${RUNTIME} COMMAND wasm_spec_test --run_test=${SN} --report_level=detailed --color_output -- --${RUNTIME})
-            # build list of tests to run during coverage testing
-            if(ctest_tests)
-                string(APPEND ctest_tests "|")
-            endif()
-            string(APPEND ctest_tests "${SN}_unit_test_${RUNTIME}")
-          endif()
-      endforeach()
-    endforeach(SN)
-  endif()
-endforeach(TEST_SUITE)
-set(ctest_tests "'${ctest_tests}' -j8") # surround test list string in apostrophies
-
-# The following tests are known to take the longest, bump up their cost (priority) so that they'll run  first
-# even on fresh first time test runs before ctest auto-detects costs
-foreach(RUNTIME ${EOSIO_WASM_RUNTIMES})
-   set_tests_properties(memory_trap_1_check_throw_1_unit_test_${RUNTIME} PROPERTIES COST 4000)
-   set_tests_properties(memory_trap_1_check_throw_2_unit_test_${RUNTIME} PROPERTIES COST 4000)
-   set_tests_properties(conversions_0_check_throw_unit_test_${RUNTIME} PROPERTIES COST 2500)
-   set_tests_properties(unreachable_0_check_throw_unit_test_${RUNTIME} PROPERTIES COST 2500)
-   set_tests_properties(f64_0_pass_unit_test_${RUNTIME} PROPERTIES COST 2500)
-   set_tests_properties(f32_0_pass_unit_test_${RUNTIME} PROPERTIES COST 2500)
-   set_tests_properties(f32_cmp_0_pass_unit_test_${RUNTIME} PROPERTIES COST 2500)
-   set_tests_properties(f64_cmp_0_pass_unit_test_${RUNTIME} PROPERTIES COST 2500)
-endforeach()
+# One entry per generated test case per runtime, discovered from the built executable. COST starts the longest cases
+# first, even on a fresh run before ctest has measured them.
+boost_test_discover_tests(wasm_spec_test
+        NAME @UNIT@_unit_test_@RUNTIME@
+        RUNTIMES ${UNIT_TEST_RUNTIMES}
+        ARGS --report_level=detailed --color_output
+        PROPERTIES LABELS wasm_spec_tests
+        COST_BY_NAME "^memory_trap_1_check_throw_[12]$" 4000
+             "^(conversions|unreachable)_0_check_throw$|^(f32|f64|f32_cmp|f64_cmp)_0_pass$" 2500)