From d55f4d402197327971410c1d9469f4917c1a3960 Mon Sep 17 00:00:00 2001
From: kevin Heifner <kevin@wire.network>
Date: Tue, 29 Sep 2026 15:31:20 -0500
Subject: [PATCH 1/4] contract tests: register suites and their contract labels
 from the built binary

The hand-maintained contract suite registry failed configure whenever a source declared a suite it did not list, so two pull requests that each pass CI, one adding a suite and one changing the registry, break configure on master once both merge, as #618 and #634 did. Its hand-written contract labels had also drifted: eight entries lacked contracts their suites deploy.

After contracts_unit_test links, contracts/tools/discover_contract_suites.py reads the executable's --list_content=DOT listing and writes one CTest entry per top-level unit, so a new suite, or a test case declared outside any suite, is registered without a CMake edit. Each entry is labelled with the contracts referenced by the files that declare the unit, its test cases and their dependencies, and by the local headers those files include: accessor calls resolved through the accessor headers, and contract header includes. The sysio.bios and sysio.roa contracts that libtester deploys during default setup label every entry.

If the executable cannot list itself, a single failing contract.DISCOVERY_FAILED entry carrying every label reports the error, so the build and the other tests still run. Before the executable is built, a failing contract.NOT_BUILT entry stands in. Editing the script relinks the executable, which reruns discovery.
---
 contracts/tests/CMakeLists.txt                | 177 ++----
 contracts/tools/discover_contract_suites.py   | 469 ++++++++++++++++
 .../tests/test_discover_contract_suites.py    | 518 ++++++++++++++++++
 3 files changed, 1027 insertions(+), 137 deletions(-)
 create mode 100644 contracts/tools/discover_contract_suites.py
 create mode 100644 contracts/tools/tests/test_discover_contract_suites.py

diff --git a/contracts/tests/CMakeLists.txt b/contracts/tests/CMakeLists.txt
index 875399648d..9f223107a5 100644
--- a/contracts/tests/CMakeLists.txt
+++ b/contracts/tests/CMakeLists.txt
@@ -18,6 +18,10 @@ add_test(NAME contract_type_generator_test
         COMMAND ${Python3_EXECUTABLE} -m unittest discover
                 -s ${CMAKE_SOURCE_DIR}/contracts/tools/tests
                 -p test_generate_sysio_contract_types.py)
+add_test(NAME contract_suite_discovery_test
+        COMMAND ${Python3_EXECUTABLE} -m unittest discover
+                -s ${CMAKE_SOURCE_DIR}/contracts/tools/tests
+                -p test_discover_contract_suites.py)
 
 # build unit test executable
 file(GLOB UNIT_TESTS CONFIGURE_DEPENDS "*.cpp" "*.hpp") # find all unit test suites
@@ -37,140 +41,39 @@ 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_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_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)
-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()
+# Register every top-level Boost unit as its own CTest entry, contract.<unit>, so each can be selected alone and all
+# can run concurrently under ctest -j while sharing this executable. The linked executable's own listing is the
+# inventory, so a new suite needs no edit here. Each entry is labelled with the contracts its sources use plus the
+# ones libtester deploys during default setup.
+set(CONTRACT_SUITE_TEST_PREFIX contract.)
+set(CONTRACT_SUITE_LABEL contract)
+set(CONTRACT_SUITE_DISCOVERY_SCRIPT ${CMAKE_SOURCE_DIR}/contracts/tools/discover_contract_suites.py)
+set(CONTRACT_SUITE_TESTS_FILE ${CMAKE_CURRENT_BINARY_DIR}/${CONTRACT_UNIT_TEST_EXE}_suites.cmake)
+set(CONTRACT_SUITE_INCLUDE_FILE ${CMAKE_CURRENT_BINARY_DIR}/${CONTRACT_UNIT_TEST_EXE}_include.cmake)
+add_custom_command(TARGET ${CONTRACT_UNIT_TEST_EXE} POST_BUILD
+        COMMAND ${Python3_EXECUTABLE} ${CONTRACT_SUITE_DISCOVERY_SCRIPT}
+                --executable $<TARGET_FILE:${CONTRACT_UNIT_TEST_EXE}>
+                --working-directory ${CMAKE_BINARY_DIR}
+                --test-sources ${UNIT_TESTS}
+                --accessor-header ${CMAKE_CURRENT_SOURCE_DIR}/contracts.hpp.in
+                --accessor-header ${CMAKE_SOURCE_DIR}/unittests/test_contracts.hpp.in
+                --implicit-accessor-header ${CMAKE_SOURCE_DIR}/libraries/testing/contracts.cpp.in
+                --timeout ${CONTRACT_UNIT_TEST_TIMEOUT_SECONDS}
+                --test-argument=--report_level=detailed
+                --test-prefix ${CONTRACT_SUITE_TEST_PREFIX}
+                --base-label ${CONTRACT_SUITE_LABEL}
+                --output ${CONTRACT_SUITE_TESTS_FILE}
+        BYPRODUCTS ${CONTRACT_SUITE_TESTS_FILE}
+        COMMENT "Registering ${CONTRACT_UNIT_TEST_EXE} suites with CTest"
+        VERBATIM)
+# Relink, and so rediscover, when the discovery rules change and not only when a test source does.
+set_property(TARGET ${CONTRACT_UNIT_TEST_EXE} APPEND PROPERTY LINK_DEPENDS ${CONTRACT_SUITE_DISCOVERY_SCRIPT})
+# Until the executable is built, a placeholder entry fails instead of the contract suites silently not running.
+file(WRITE ${CONTRACT_SUITE_INCLUDE_FILE}
+        "if(EXISTS \"${CONTRACT_SUITE_TESTS_FILE}\")\n"
+        "  include(\"${CONTRACT_SUITE_TESTS_FILE}\")\n"
+        "else()\n"
+        "  add_test(${CONTRACT_SUITE_TEST_PREFIX}NOT_BUILT ${CONTRACT_UNIT_TEST_EXE}_NOT_BUILT)\n"
+        "  set_tests_properties(${CONTRACT_SUITE_TEST_PREFIX}NOT_BUILT PROPERTIES LABELS ${CONTRACT_SUITE_LABEL})\n"
+        "endif()\n")
+set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES ${CONTRACT_SUITE_INCLUDE_FILE})
diff --git a/contracts/tools/discover_contract_suites.py b/contracts/tools/discover_contract_suites.py
new file mode 100644
index 0000000000..34e6ba81f7
--- /dev/null
+++ b/contracts/tools/discover_contract_suites.py
@@ -0,0 +1,469 @@
+#!/usr/bin/env python3
+"""
+Register each top-level Boost.Test unit of a test executable as its own CTest entry.
+
+CMake runs this after `contracts_unit_test` links. The executable's `--list_content=DOT` output is
+the inventory, so adding a suite needs no CMake edit. Each entry is labelled with `contract` plus
+every contract its sources deploy or compile against: accessor references such as
+`contracts::liq_wasm()` and contract header includes such as `<sysio.opp.common/amm_math.hpp>`,
+scanned in the files that declare the unit, its test cases and their dependencies, and in the local
+headers those files include. Contracts the test library deploys during default tester setup label
+every entry.
+
+The labels over-approximate, since a helper in a shared header labels every suite that includes it.
+That is the safe direction for selecting tests by changed contract.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Boost.Test `--list_content=DOT` grammar (boost/test/impl/unit_test_main.ipp, dot_content_reporter)
+# ---------------------------------------------------------------------------
+
+DOT_NODE_RE = re.compile(r'^tu(?P<id>\d+)\[(?P<attrs>.*)\];$')
+DOT_PARENT_EDGE_RE = re.compile(r'^tu(?P<parent>\d+) -> tu(?P<child>\d+);$')
+DOT_DEPENDENCY_EDGE_RE = re.compile(r'^tu(?P<unit>\d+) -> tu(?P<dependency>\d+)\[[^\]]*\];$')
+DOT_LABEL_RE = re.compile(r'label="(?P<label>[^"]*)"')
+DOT_LOCATION_RE = re.compile(r'^(?P<file>.*)\((?P<line>\d+)\)$')
+DOT_MASTER_ATTR = 'peripheries=2'
+DOT_ENABLED_ATTR = 'color=green'
+DOT_LABEL_FIELD_SEPARATOR = '|'
+
+# ---------------------------------------------------------------------------
+# Contract artifact accessors, as defined by the headers passed with --accessor-header
+# ---------------------------------------------------------------------------
+
+# Every `*_wasm(`/`*_abi(` in an accessor header other than a loader call must map to a contract.
+ACCESSOR_TOKEN_RE = re.compile(r'\b(?P<name>\w+_(?:wasm|abi))\s*\(')
+ACCESSOR_LOADERS = frozenset({'read_wasm', 'read_abi'})
+ACCESSOR_FUNCTION_RE = re.compile(
+    r'\b(?P<name>\w+_(?:wasm|abi))\s*\([^;{}()]*\)[^;{}]*\{[^{}]*?"(?P<path>[^"]+\.(?:wasm|abi))"', re.S)
+ACCESSOR_MACRO_RE = re.compile(
+    r'^\s*MAKE_\w*WASM_ABI\(\s*(?P<prefix>\w+)\s*,\s*(?P<contract>[\w.]+)\s*,\s*[\w./-]+\s*\)', re.M)
+ACCESSOR_SUFFIXES = ('_wasm', '_abi')
+CONTRACT_PATH_RE = re.compile(r'/contracts/(?P<contract>sysio\.[\w.]+)/[^/]+\.(?:wasm|abi)$')
+TEST_CONTRACT_PATH_RE = re.compile(r'/test[_-]contracts/(?P<name>\w+?)(?:\.(?:wasm|abi)$|/)')
+SYSTEM_CONTRACT_PREFIX = 'sysio.'
+TEST_CONTRACT_LABEL_PREFIX = 'test.'
+
+# ---------------------------------------------------------------------------
+# Contract references in test sources
+# ---------------------------------------------------------------------------
+
+ACCESSOR_CALL_RE = re.compile(r'\b(?P<name>\w+_(?:wasm|abi))\s*\(')
+ACCESSOR_QUALIFIED_RE = re.compile(r'::\s*(?P<name>\w+_(?:wasm|abi))\b')
+INCLUDE_PATH_RE = re.compile(r'^[ \t]*#[ \t]*include[ \t]*[<"](?P<path>[^>"]+)[>"]', re.M)
+LOCAL_INCLUDE_RE = re.compile(r'^[ \t]*#[ \t]*include[ \t]*"(?P<path>[^"]+)"', re.M)
+# A contract's directory anywhere in an include path: <sysio.opp.common/...>, "../../contracts/sysio.roa/...".
+CONTRACT_COMPONENT_RE = re.compile(r'(?:^|/)(?P<contract>sysio\.[\w.]+)/')
+TEST_CONTRACT_COMPONENT_RE = re.compile(r'(?:^|/)test[_-]contracts/(?P<name>\w+)/')
+RAW_STRING_OPEN_RE = re.compile(r'R"(?P<delimiter>[^()\\\s]{0,16})\(')
+
+DEFAULT_TEST_PREFIX = 'contract.'
+DEFAULT_BASE_LABEL = 'contract'
+DISCOVERY_FAILED_NAME = 'DISCOVERY_FAILED'
+# The command line overrides BOOST_TEST_REPORT_SINK, which would otherwise divert the listing into a file.
+LIST_CONTENT_ARGUMENTS = ('--list_content=DOT', '--report_sink=stderr')
+LIST_CONTENT_TIMEOUT_SECONDS = 120
+LISTING_ERROR_TAIL_CHARACTERS = 4000
+# mkstemp creates 0600; the script is read by whoever runs ctest.
+GENERATED_FILE_MODE = 0o644
+
+
+class DiscoveryError(RuntimeError):
+    """A fault in discovery itself or its inputs; the build should fail."""
+
+
+class ListingError(DiscoveryError):
+    """The test executable could not produce its listing; its failure belongs in the test results."""
+
+
+@dataclass
+class TestUnit:
+    """A top-level Boost.Test unit: a suite or a test case declared outside any suite."""
+
+    name: str
+    enabled: bool
+    files: set[str] = field(default_factory=set)
+
+
+# ---------------------------------------------------------------------------
+# Inventory
+# ---------------------------------------------------------------------------
+
+def parse_dot(text: str) -> list[TestUnit]:
+    """Return the master suite's children, each with the files declaring it, its subtree and their dependencies.
+
+    Dependencies count because `--run_test` enables the units a selected unit depends on; depending on the master
+    suite runs everything.
+    """
+    nodes: dict[str, tuple[str, bool, str]] = {}
+    children: dict[str, list[str]] = {}
+    dependencies: dict[str, list[str]] = {}
+    master_id: str | None = None
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        node = DOT_NODE_RE.match(line)
+        if node:
+            attrs = node.group('attrs')
+            label = DOT_LABEL_RE.search(attrs)
+            if label is None:
+                raise DiscoveryError(f'test unit without a label: {line}')
+            if DOT_MASTER_ATTR in attrs.split(','):
+                master_id = node.group('id')
+                continue
+            fields = label.group('label').split(DOT_LABEL_FIELD_SEPARATOR)
+            location = DOT_LOCATION_RE.match(fields[1]) if len(fields) > 1 else None
+            if location is None:
+                raise DiscoveryError(f'test unit without a source location: {line}')
+            nodes[node.group('id')] = (fields[0], DOT_ENABLED_ATTR in attrs.split(','), location.group('file'))
+            continue
+        edge = DOT_PARENT_EDGE_RE.match(line)
+        if edge:
+            children.setdefault(edge.group('parent'), []).append(edge.group('child'))
+            continue
+        dependency = DOT_DEPENDENCY_EDGE_RE.match(line)
+        if dependency:
+            dependencies.setdefault(dependency.group('unit'), []).append(dependency.group('dependency'))
+
+    if master_id is None:
+        raise DiscoveryError('no master test suite in the --list_content=DOT output')
+
+    units = []
+    for unit_id in children.get(master_id, []):
+        files: set[str] = set()
+        visited: set[str] = set()
+        pending = [unit_id]
+        while pending:
+            current = pending.pop()
+            if current in visited:
+                continue
+            visited.add(current)
+            if current == master_id:
+                files.update(file for _, _, file in nodes.values())
+                continue
+            if current not in nodes:
+                raise DiscoveryError(f'edge to undeclared test unit tu{current}')
+            files.add(nodes[current][2])
+            pending.extend(children.get(current, []))
+            pending.extend(dependencies.get(current, []))
+        name, enabled, _ = nodes[unit_id]
+        units.append(TestUnit(name=name, enabled=enabled, files=files))
+    return sorted(units, key=lambda unit: unit.name)
+
+
+def list_test_units(executable: Path, working_directory: Path) -> list[TestUnit]:
+    """Run the executable's DOT listing and parse it."""
+    command = [str(executable), *LIST_CONTENT_ARGUMENTS]
+    try:
+        result = subprocess.run(command, cwd=working_directory, capture_output=True, text=True, errors='replace',
+                                timeout=LIST_CONTENT_TIMEOUT_SECONDS, check=False)
+    except (OSError, subprocess.TimeoutExpired) as error:
+        raise ListingError(f'cannot run {" ".join(command)}: {error}') from error
+    if result.returncode != 0:
+        raise ListingError(f'{" ".join(command)} exited with {result.returncode}:\n'
+                           f'{result.stderr[-LISTING_ERROR_TAIL_CHARACTERS:]}')
+    units = parse_dot(result.stderr + '\n' + result.stdout)
+    if not units:
+        raise ListingError(f'{executable} declares no test units')
+    return units
+
+
+# ---------------------------------------------------------------------------
+# Labels
+# ---------------------------------------------------------------------------
+
+def label_for_artifact(path: str) -> str | None:
+    """Map a contract artifact path to its label: `sysio.<name>`, or `test.<name>` for a test contract."""
+    contract = CONTRACT_PATH_RE.search(path)
+    if contract:
+        return contract.group('contract')
+    test_contract = TEST_CONTRACT_PATH_RE.search(path)
+    if test_contract:
+        return TEST_CONTRACT_LABEL_PREFIX + test_contract.group('name')
+    return None
+
+
+def label_for_contract(contract: str) -> str:
+    """Label a contract named by a MAKE_*_WASM_ABI invocation, whatever directory it is built in."""
+    return contract if contract.startswith(SYSTEM_CONTRACT_PREFIX) else TEST_CONTRACT_LABEL_PREFIX + contract
+
+
+def load_accessor_labels(headers: list[Path]) -> dict[str, set[str]]:
+    """Map each contract accessor name (`liq_wasm`, `sysio_system_abi`, ...) to its contract label.
+
+    An accessor the rules cannot map is an error: every suite calling it would otherwise lose that contract's
+    label without any sign.
+    """
+    accessors: dict[str, set[str]] = {}
+    tokens: dict[Path, set[str]] = {}
+    for header in headers:
+        text = strip_comments(header.read_text(encoding='utf-8', errors='replace'))
+        tokens[header] = {match.group('name') for match in ACCESSOR_TOKEN_RE.finditer(text)} - ACCESSOR_LOADERS
+        for match in ACCESSOR_FUNCTION_RE.finditer(text):
+            label = label_for_artifact(match.group('path'))
+            if label:
+                accessors.setdefault(match.group('name'), set()).add(label)
+        for match in ACCESSOR_MACRO_RE.finditer(text):
+            for suffix in ACCESSOR_SUFFIXES:
+                accessors.setdefault(match.group('prefix') + suffix, set()).add(
+                    label_for_contract(match.group('contract')))
+    for header, names in tokens.items():
+        unmapped = names - accessors.keys()
+        if unmapped:
+            raise DiscoveryError(f'{header}: no contract label for accessor(s) {", ".join(sorted(unmapped))}; '
+                                 'extend label_for_artifact or the accessor patterns to cover them')
+    if not accessors:
+        raise DiscoveryError('no contract accessors found in ' + ', '.join(str(h) for h in headers))
+    return accessors
+
+
+def strip_comments(text: str) -> str:
+    """Blank out C++ comments, keeping string and character literals and line structure intact."""
+    out: list[str] = []
+    i = 0
+    length = len(text)
+    while i < length:
+        char = text[i]
+        raw = RAW_STRING_OPEN_RE.match(text, i) if char == 'R' else None
+        if raw:
+            close = ')' + raw.group('delimiter') + '"'
+            end = text.find(close, raw.end())
+            end = length if end < 0 else end + len(close)
+            out.append(text[i:end])
+            i = end
+            continue
+        # A quote after a digit is a digit separator (2'000'000), not the start of a character literal.
+        if char == '"' or (char == "'" and not (i > 0 and text[i - 1].isdigit())):
+            end = i + 1
+            while end < length and text[end] != char and text[end] != '\n':
+                end += 2 if text[end] == '\\' else 1
+            end = min(end + 1, length)
+            out.append(text[i:end])
+            i = end
+        elif text.startswith('//', i):
+            end = text.find('\n', i)
+            i = length if end < 0 else end
+        elif text.startswith('/*', i):
+            end = text.find('*/', i + 2)
+            end = length if end < 0 else end + 2
+            out.append('\n' * text.count('\n', i, end))
+            i = end
+        else:
+            out.append(char)
+            i += 1
+    return ''.join(out)
+
+
+def scan_labels(sources: set[Path], accessors: dict[str, set[str]]) -> set[str]:
+    """Collect the contract labels referenced by the sources and, transitively, their local headers."""
+    labels: set[str] = set()
+    pending = sorted(sources)
+    visited: set[Path] = set()
+    while pending:
+        source = pending.pop()
+        if source in visited:
+            continue
+        visited.add(source)
+        text = strip_comments(source.read_text(encoding='utf-8', errors='replace'))
+        for pattern in (ACCESSOR_CALL_RE, ACCESSOR_QUALIFIED_RE):
+            for match in pattern.finditer(text):
+                labels |= accessors.get(match.group('name'), set())
+        for include in INCLUDE_PATH_RE.finditer(text):
+            path = include.group('path')
+            labels.update(match.group('contract') for match in CONTRACT_COMPONENT_RE.finditer(path))
+            labels.update(TEST_CONTRACT_LABEL_PREFIX + match.group('name')
+                          for match in TEST_CONTRACT_COMPONENT_RE.finditer(path))
+        for match in LOCAL_INCLUDE_RE.finditer(text):
+            header = (source.parent / match.group('path')).resolve()
+            if header.is_file() and header not in visited:
+                pending.append(header)
+    return labels
+
+
+def resolve_source(location: str, sources: list[Path]) -> list[Path]:
+    """Find the file a unit's location names.
+
+    An existing absolute path is taken as is. Otherwise `__FILE__` was rewritten, relative to the compile directory
+    (ccache's base_dir) or through a prefix map, so the location is matched to the target's own sources by the
+    longest shared trailing path; ties return every candidate.
+    """
+    path = Path(location)
+    if path.is_absolute() and path.is_file():
+        return [path.resolve()]
+    trailing = path.parts[::-1]
+    best = 0
+    matches: list[Path] = []
+    for source in sources:
+        shared = 0
+        for mine, theirs in zip(trailing, source.parts[::-1]):
+            if mine != theirs:
+                break
+            shared += 1
+        if shared and shared >= best:
+            if shared > best:
+                best, matches = shared, []
+            matches.append(source)
+    return matches
+
+
+def every_known_label(accessors: dict[str, set[str]], implicit: set[str], sources: list[Path]) -> set[str]:
+    """Every label any entry could carry, for entries whose own sources are unknown."""
+    return set().union(implicit, *accessors.values(), scan_labels(set(sources), accessors))
+
+
+def derive_labels(units: list[TestUnit], accessors: dict[str, set[str]], implicit: set[str],
+                  sources: list[Path]) -> dict[str, set[str]]:
+    """Label every unit; one whose sources cannot be found gets every known label, so it is never under-selected."""
+    labels: dict[str, set[str]] = {}
+    fallback: set[str] | None = None
+    for unit in units:
+        resolved = {file: resolve_source(file, sources) for file in unit.files}
+        missing = sorted(file for file, paths in resolved.items() if not paths)
+        if not missing:
+            labels[unit.name] = scan_labels({path for paths in resolved.values() for path in paths},
+                                            accessors) | implicit
+            continue
+        if fallback is None:
+            fallback = every_known_label(accessors, implicit, sources)
+        print(f'{Path(__file__).name}: warning: cannot find {", ".join(missing)} for {unit.name}; '
+              'labelling it with every known contract', file=sys.stderr)
+        labels[unit.name] = fallback
+    return labels
+
+
+# ---------------------------------------------------------------------------
+# CTest script
+# ---------------------------------------------------------------------------
+
+def bracket(value: str) -> str:
+    """Quote a value as a CMake bracket argument, which needs no escaping.
+
+    The trailing `]` accounts for a value that ends in the start of the closing bracket.
+    """
+    level = 0
+    while f']{"=" * level}]' in value + ']':
+        level += 1
+    equals = '=' * level
+    return f'[{equals}[{value}]{equals}]'
+
+
+def script_header(executable: Path) -> str:
+    """The first line of every generated script."""
+    return (f'# Generated by {Path(__file__).name} from `{executable.name} {" ".join(LIST_CONTENT_ARGUMENTS)}`. '
+            'Do not edit.')
+
+
+def render_properties(test_name: str, properties: list[str]) -> str:
+    """One `set_tests_properties` call."""
+    return f'set_tests_properties({test_name} PROPERTIES {" ".join(properties)})'
+
+
+def render_ctest(units: list[TestUnit], labels: dict[str, set[str]], executable: Path,
+                 working_directory: Path, timeout: int, test_arguments: list[str],
+                 test_prefix: str, base_label: str) -> str:
+    """Render one `add_test` and one `set_tests_properties` per unit, in name order."""
+    lines = [script_header(executable)]
+    for unit in units:
+        test_name = bracket(test_prefix + unit.name)
+        command = [str(executable), f'--run_test={unit.name}', *test_arguments]
+        lines.append(f'add_test({test_name} {" ".join(bracket(part) for part in command)})')
+        properties = [f'WORKING_DIRECTORY {bracket(str(working_directory))}', f'TIMEOUT {timeout}',
+                      f'LABELS {bracket(";".join([base_label, *sorted(labels[unit.name])]))}']
+        if not unit.enabled:
+            properties.append('DISABLED TRUE')
+        lines.append(render_properties(test_name, properties))
+    return '\n'.join(lines) + '\n'
+
+
+def render_listing_failure(message: str, labels: set[str], executable: Path, test_prefix: str,
+                           base_label: str) -> str:
+    """Render a single entry that fails with the listing error.
+
+    It carries every known label so that selecting by contract still runs, and fails on, it.
+    """
+    test_name = bracket(test_prefix + DISCOVERY_FAILED_NAME)
+    command = [sys.executable, '-c', 'import sys; sys.exit(sys.argv[1])', message]
+    return '\n'.join([script_header(executable),
+                      f'add_test({test_name} {" ".join(bracket(part) for part in command)})',
+                      render_properties(test_name, [f'LABELS {bracket(";".join([base_label, *sorted(labels)]))}'])
+                      ]) + '\n'
+
+
+def write_if_changed(path: Path, content: str) -> None:
+    """Replace the file atomically, leaving it untouched when the content is unchanged."""
+    if path.is_file() and path.read_text(encoding='utf-8', errors='replace') == content:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(dir=path.parent, prefix=f'.{path.name}.')
+    try:
+        with os.fdopen(descriptor, 'w', encoding='utf-8') as stream:
+            stream.write(content)
+        os.chmod(temporary, GENERATED_FILE_MODE)
+        os.replace(temporary, path)
+    except BaseException:
+        Path(temporary).unlink(missing_ok=True)
+        raise
+
+
+def run_cli(argv: list[str] | None = None) -> int:
+    """Discover the executable's top-level units and write the CTest script that registers them."""
+    parser = argparse.ArgumentParser(description=__doc__.strip().splitlines()[0])
+    parser.add_argument('--executable', type=Path, required=True, help='Boost.Test executable to inventory')
+    parser.add_argument('--working-directory', type=Path, required=True,
+                        help='directory the registered tests run in')
+    parser.add_argument('--test-sources', type=Path, nargs='+', required=True,
+                        help="the executable's own sources, which unit locations are matched against")
+    parser.add_argument('--accessor-header', type=Path, action='append', required=True,
+                        help='header defining contract accessors (repeatable)')
+    parser.add_argument('--implicit-accessor-header', type=Path, action='append', default=[],
+                        help='header defining accessors for contracts deployed during default test setup; '
+                             'they label every entry (repeatable)')
+    parser.add_argument('--timeout', type=int, required=True, help='CTest TIMEOUT for every entry, in seconds')
+    parser.add_argument('--output', type=Path, required=True, help='CTest script to write')
+    parser.add_argument('--test-argument', action='append', default=[],
+                        help='extra argument passed to every registered test (repeatable)')
+    parser.add_argument('--test-prefix', default=DEFAULT_TEST_PREFIX, help='prefix of every CTest name')
+    parser.add_argument('--base-label', default=DEFAULT_BASE_LABEL, help='label carried by every entry')
+    args = parser.parse_args(argv)
+
+    tool = Path(__file__).name
+    executable = args.executable.resolve()
+    sources = sorted(source.resolve() for source in args.test_sources)
+    try:
+        accessors = load_accessor_labels(args.accessor_header + args.implicit_accessor_header)
+        implicit = set()
+        if args.implicit_accessor_header:
+            implicit = set().union(*load_accessor_labels(args.implicit_accessor_header).values())
+        try:
+            units = list_test_units(executable, args.working_directory)
+        except ListingError as error:
+            # A plain rebuild does not relink an unchanged executable, and only a relink reruns discovery.
+            message = (f'{error}\nTo retry discovery after fixing the cause, touch {Path(__file__).resolve()} '
+                       f'and rebuild {executable.name}.')
+            print(f'{tool}: warning: {message}\nregistering a failing {args.test_prefix}{DISCOVERY_FAILED_NAME} '
+                  'entry', file=sys.stderr)
+            write_if_changed(args.output, render_listing_failure(
+                message, every_known_label(accessors, implicit, sources), executable, args.test_prefix,
+                args.base_label))
+            return 0
+        labels = derive_labels(units, accessors, implicit, sources)
+        write_if_changed(args.output, render_ctest(units, labels, executable, args.working_directory.resolve(),
+                                                   args.timeout, args.test_argument, args.test_prefix,
+                                                   args.base_label))
+    except (DiscoveryError, OSError, ValueError) as error:
+        print(f'{tool}: error: {error}', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(run_cli())
diff --git a/contracts/tools/tests/test_discover_contract_suites.py b/contracts/tools/tests/test_discover_contract_suites.py
new file mode 100644
index 0000000000..59430cace8
--- /dev/null
+++ b/contracts/tools/tests/test_discover_contract_suites.py
@@ -0,0 +1,518 @@
+"""Tests for contract test suite discovery and contract labelling."""
+
+from __future__ import annotations
+
+import contextlib
+import importlib.util
+import io
+import os
+import re
+import stat
+import subprocess
+import sys
+import tempfile
+import textwrap
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+DISCOVERY_PATH = Path(__file__).parents[1] / "discover_contract_suites.py"
+DISCOVERY_SPEC = importlib.util.spec_from_file_location("discover_contract_suites", DISCOVERY_PATH)
+if DISCOVERY_SPEC is None or DISCOVERY_SPEC.loader is None:
+    raise RuntimeError(f"Unable to load discovery script from {DISCOVERY_PATH}")
+DISCOVERY = importlib.util.module_from_spec(DISCOVERY_SPEC)
+sys.modules[DISCOVERY_SPEC.name] = DISCOVERY
+DISCOVERY_SPEC.loader.exec_module(DISCOVERY)
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[3]
+# A CMake bracket argument ends at the first closing bracket with the same number of `=`.
+BRACKET_ARGUMENT_RE = re.compile(r"\[(=*)\[(.*?)\]\1\]", re.S)
+REPOSITORY_ACCESSOR_HEADERS = [
+    REPOSITORY_ROOT / "contracts" / "tests" / "contracts.hpp.in",
+    REPOSITORY_ROOT / "unittests" / "test_contracts.hpp.in",
+    REPOSITORY_ROOT / "libraries" / "testing" / "contracts.cpp.in",
+]
+
+ACCESSOR_HEADER = """\
+struct contracts {
+   static std::vector<uint8_t> reserve_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.reserv/sysio.reserv.wasm"); }
+   static std::vector<char>    liq_abi() { return read_abi("${CMAKE_BINARY_DIR}/contracts/sysio.liq/sysio.liq.abi"); }
+   static std::vector<uint8_t> liq_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.liq/sysio.liq.wasm"); }
+   static std::vector<uint8_t> opreg_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.opreg/sysio.opreg.wasm"); }
+   static std::vector<uint8_t> token_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.token/sysio.token.wasm"); }
+   static std::string          dex_config_dir() { return "${CMAKE_SOURCE_DIR}/etc/config/dex"; }
+   struct util {
+      static std::vector<uint8_t> reject_all_wasm() { return read_wasm("${CMAKE_SOURCE_DIR}/contracts/test_contracts/reject_all.wasm"); }
+   };
+};
+[[maybe_unused]]
+static std::vector<uint8_t> blockinfo_tester_wasm()
+{
+   return sysio::testing::read_wasm(
+      "${CMAKE_BINARY_DIR}/contracts/test_contracts/blockinfo_tester/blockinfo_tester.wasm");
+}
+"""
+
+MACRO_ACCESSOR_HEADER = """\
+#define MAKE_READ_WASM_ABI(CN,C, D)                                                         \\
+   static std::vector<uint8_t> CN ## _wasm() {                                              \\
+      return read("${CMAKE_BINARY_DIR}/" #D "/" #C "/" #C ".wasm");                         \\
+   }
+         MAKE_READ_WASM_ABI(sysio_msig,   sysio.msig,   contracts)
+         MAKE_READ_WASM_ABI(noop,         noop,         unittests/test-contracts)
+         MAKE_READ_WASM_ABI(ibc,          ibc,          unittests/test-contracts/savanna)
+         MAKE_READ_WASM_ABI(fresh,        fresh,        unittests/some-new-directory)
+"""
+
+EMBEDDED_ACCESSOR_HEADER = """\
+MAKE_EMBEDDED_WASM_ABI(sysio_bios,                             sysio.bios, contracts)
+MAKE_EMBEDDED_WASM_ABI(sysio_roa,                              sysio.roa,  contracts)
+"""
+
+
+def dot_listing(root: Path) -> str:
+    """Return a Boost.Test DOT listing whose units are declared in files under root.
+
+    alpha_tests' only case depends on split_case, which beta_tests declares in beta_extra.cpp.
+    """
+    return textwrap.dedent(f"""\
+        Random number generator seeded to 1790706793
+        digraph G {{rankdir=LR;
+        tu1[shape=ellipse,peripheries=2,fontname=Helvetica,color=green,label="Master Test Suite"];
+        {{
+        tu2[shape=Mrecord,fontname=Helvetica,color=green,label="beta_tests|{root}/beta_tests.cpp(20)"];
+        tu1 -> tu2;
+        {{
+        tu65536[shape=Mrecord,fontname=Helvetica,color=green,label="split_case|{root}/beta_extra.cpp(7)|timeout=30"];
+        tu2 -> tu65536;
+        tu3[shape=Mrecord,fontname=Helvetica,color=yellow,label="nested_tests|{root}/beta_nested.cpp(3)|labels: @slow"];
+        tu2 -> tu3;
+        {{
+        tu65537[shape=Mrecord,fontname=Helvetica,color=green,label="deep_case|{root}/beta_nested.cpp(5)"];
+        tu3 -> tu65537;
+        }}
+        }}
+        tu4[shape=Mrecord,fontname=Helvetica,color=yellow,label="alpha_tests|{root}/alpha_tests.cpp(10)"];
+        tu1 -> tu4;
+        {{
+        tu65538[shape=Mrecord,fontname=Helvetica,color=green,label="first_case|{root}/alpha_tests.cpp(12)"];
+        tu4 -> tu65538;
+        tu65538 -> tu65536[color=red,style=dotted,constraint=false];
+        }}
+        tu65539[shape=Mrecord,fontname=Helvetica,color=green,label="loose_case|{root}/loose.cpp(1)"];
+        tu1 -> tu65539;
+        }}
+        }}
+        """)
+
+
+class TemporaryTreeTestCase(unittest.TestCase):
+    """Provide a temporary directory and a helper that writes files into it."""
+
+    def setUp(self) -> None:
+        """Create the temporary tree."""
+        self.temporary_directory = tempfile.TemporaryDirectory()
+        self.root = Path(self.temporary_directory.name).resolve()
+
+    def tearDown(self) -> None:
+        """Remove the temporary tree."""
+        self.temporary_directory.cleanup()
+
+    def write(self, relative: str, content: str | bytes) -> Path:
+        """Write content to a file under the temporary tree and return its path."""
+        path = self.root / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if isinstance(content, bytes):
+            path.write_bytes(content)
+        else:
+            path.write_text(content, encoding="utf-8")
+        return path
+
+
+class ParseDotTests(unittest.TestCase):
+    """Verify the Boost.Test DOT inventory parser."""
+
+    def test_top_level_units_carry_their_subtrees_and_dependencies_files(self) -> None:
+        """Only the master suite's children become units, each with the files of its subtree and dependencies."""
+        units = DISCOVERY.parse_dot(dot_listing(Path("/src")))
+        self.assertEqual([unit.name for unit in units], ["alpha_tests", "beta_tests", "loose_case"])
+        by_name = {unit.name: unit for unit in units}
+        self.assertEqual(by_name["beta_tests"].files,
+                         {"/src/beta_tests.cpp", "/src/beta_extra.cpp", "/src/beta_nested.cpp"})
+        self.assertEqual(by_name["alpha_tests"].files, {"/src/alpha_tests.cpp", "/src/beta_extra.cpp"})
+        self.assertEqual(by_name["loose_case"].files, {"/src/loose.cpp"})
+
+    def test_dependency_on_the_master_suite_brings_in_every_file(self) -> None:
+        """Depending on the master suite runs the whole executable, so every declared file counts."""
+        listing = dot_listing(Path("/src")).replace(
+            "tu1 -> tu65539;\n", "tu1 -> tu65539;\ntu65539 -> tu1[color=red,style=dotted,constraint=false];\n")
+        by_name = {unit.name: unit for unit in DISCOVERY.parse_dot(listing)}
+        self.assertEqual(by_name["loose_case"].files, {"/src/alpha_tests.cpp", "/src/beta_tests.cpp",
+                                                        "/src/beta_extra.cpp", "/src/beta_nested.cpp", "/src/loose.cpp"})
+
+    def test_default_status_follows_the_unit_color(self) -> None:
+        """A unit Boost reports as disabled by default (yellow) is not enabled."""
+        by_name = {unit.name: unit for unit in DISCOVERY.parse_dot(dot_listing(Path("/src")))}
+        self.assertFalse(by_name["alpha_tests"].enabled)
+        self.assertTrue(by_name["beta_tests"].enabled)
+        self.assertTrue(by_name["loose_case"].enabled)
+
+    def test_missing_master_suite_is_an_error(self) -> None:
+        """A listing without the master suite is rejected rather than read as empty."""
+        with self.assertRaises(DISCOVERY.DiscoveryError):
+            DISCOVERY.parse_dot("digraph G {rankdir=LR;\n}\n")
+
+    def test_unit_without_source_location_is_an_error(self) -> None:
+        """Every unit must name its declaring file, which labelling depends on."""
+        listing = ('tu1[shape=ellipse,peripheries=2,fontname=Helvetica,color=green,label="Master Test Suite"];\n'
+                   'tu2[shape=Mrecord,fontname=Helvetica,color=green,label="alpha_tests"];\n'
+                   'tu1 -> tu2;\n')
+        with self.assertRaises(DISCOVERY.DiscoveryError):
+            DISCOVERY.parse_dot(listing)
+
+    def test_edge_to_undeclared_unit_is_an_error(self) -> None:
+        """A parent edge must point at a declared unit."""
+        listing = ('tu1[shape=ellipse,peripheries=2,fontname=Helvetica,color=green,label="Master Test Suite"];\n'
+                   'tu1 -> tu9;\n')
+        with self.assertRaises(DISCOVERY.DiscoveryError):
+            DISCOVERY.parse_dot(listing)
+
+
+class AccessorLabelTests(TemporaryTreeTestCase):
+    """Verify the accessor-name to contract-label map."""
+
+    def test_function_and_macro_accessors_map_to_contract_labels(self) -> None:
+        """Explicit functions resolve through their artifact paths; macro invocations through the contract they name."""
+        headers = [self.write("contracts.hpp.in", ACCESSOR_HEADER),
+                   self.write("test_contracts.hpp.in", MACRO_ACCESSOR_HEADER),
+                   self.write("contracts.cpp.in", EMBEDDED_ACCESSOR_HEADER)]
+        accessors = DISCOVERY.load_accessor_labels(headers)
+        self.assertEqual(accessors["reserve_wasm"], {"sysio.reserv"})
+        self.assertEqual(accessors["liq_abi"], {"sysio.liq"})
+        self.assertEqual(accessors["reject_all_wasm"], {"test.reject_all"})
+        self.assertEqual(accessors["blockinfo_tester_wasm"], {"test.blockinfo_tester"})
+        self.assertEqual(accessors["sysio_msig_wasm"], {"sysio.msig"})
+        self.assertEqual(accessors["sysio_msig_abi"], {"sysio.msig"})
+        self.assertEqual(accessors["noop_wasm"], {"test.noop"})
+        self.assertEqual(accessors["ibc_wasm"], {"test.ibc"})
+        self.assertEqual(accessors["fresh_abi"], {"test.fresh"})
+        self.assertEqual(accessors["sysio_roa_abi"], {"sysio.roa"})
+        self.assertNotIn("CN_wasm", accessors)
+        self.assertNotIn("dex_config_dir", accessors)
+
+    def test_accessor_definitions_in_any_function_form_are_mapped(self) -> None:
+        """Parameters, specifiers and trailing return types do not hide a definition from the map."""
+        header = self.write("contracts.hpp.in", textwrap.dedent("""\
+            static std::vector<uint8_t> foo_wasm() noexcept { return read_wasm("/b/contracts/sysio.foo/sysio.foo.wasm"); }
+            static auto bar_wasm() -> std::vector<uint8_t> { return read_wasm("/b/contracts/sysio.bar/sysio.bar.wasm"); }
+            static std::vector<uint8_t> baz_wasm(bool v2) { return read_wasm("/b/contracts/sysio.baz/sysio.baz.wasm"); }
+            """))
+        accessors = DISCOVERY.load_accessor_labels([header])
+        self.assertEqual(accessors, {"foo_wasm": {"sysio.foo"}, "bar_wasm": {"sysio.bar"}, "baz_wasm": {"sysio.baz"}})
+
+    def test_accessor_without_a_contract_path_is_an_error(self) -> None:
+        """An accessor the label rules cannot map fails discovery instead of silently dropping a label."""
+        header = self.write("contracts.hpp.in",
+                            'static auto fixture_wasm() noexcept -> bytes { return read_wasm("/data/fixture.wasm"); }\n')
+        with self.assertRaisesRegex(DISCOVERY.DiscoveryError, "fixture_wasm"):
+            DISCOVERY.load_accessor_labels([header])
+
+    def test_accessor_the_patterns_cannot_parse_is_an_error(self) -> None:
+        """Every `*_wasm(` in an accessor header other than a loader call must map, whatever its parameter list."""
+        header = self.write("contracts.hpp.in", textwrap.dedent("""\
+            static std::vector<uint8_t> token_wasm() { return read_wasm("/b/contracts/sysio.token/sysio.token.wasm"); }
+            static std::vector<uint8_t> qux_wasm(std::function<void()> cb) { return read_wasm("/b/contracts/sysio.qux/sysio.qux.wasm"); }
+            """))
+        with self.assertRaisesRegex(DISCOVERY.DiscoveryError, "qux_wasm"):
+            DISCOVERY.load_accessor_labels([header])
+
+    def test_accessor_names_in_comments_are_ignored(self) -> None:
+        """A comment naming tester calls such as set_abi() is documentation, not an accessor to map."""
+        header = self.write("contracts.hpp.in", "/// Hand any *_abi() result to set_abi() via .data().\n" + ACCESSOR_HEADER)
+        self.assertEqual(DISCOVERY.load_accessor_labels([header])["liq_abi"], {"sysio.liq"})
+
+    def test_header_without_accessors_is_an_error(self) -> None:
+        """Pointing discovery at the wrong header fails instead of producing unlabelled entries."""
+        with self.assertRaises(DISCOVERY.DiscoveryError):
+            DISCOVERY.load_accessor_labels([self.write("empty.hpp.in", "#pragma once\n")])
+
+    def test_repository_accessor_headers_map_every_accessor(self) -> None:
+        """The real accessor headers parse, and every accessor they define maps to its contract."""
+        accessors = DISCOVERY.load_accessor_labels(REPOSITORY_ACCESSOR_HEADERS)
+        self.assertEqual(accessors["reserve_wasm"], {"sysio.reserv"})
+        self.assertEqual(accessors["system_abi"], {"sysio.system"})
+        self.assertEqual(accessors["badtoken_wasm"], {"test.badtoken"})
+        self.assertEqual(accessors["reenter_deposit_wasm"], {"test.reenter_deposit"})
+        self.assertEqual(accessors["sendinline_wasm"], {"test.sendinline"})
+        self.assertEqual(accessors["sysio_system_wasm"], {"sysio.system"})
+        self.assertEqual(accessors["noop_wasm"], {"test.noop"})
+        self.assertEqual(accessors["ibc_wasm"], {"test.ibc"})
+        self.assertEqual(accessors["sysio_bios_wasm"], {"sysio.bios"})
+        self.assertEqual(accessors["reject_all_wasm"], {"test.reject_all"})
+
+
+class StripCommentsTests(unittest.TestCase):
+    """Verify comment removal keeps code, literals, and line numbering."""
+
+    def test_comments_are_removed_and_lines_preserved(self) -> None:
+        """Line and block comments disappear; the newline count is unchanged."""
+        text = "a(); // contracts::liq_wasm()\n/* contracts::token_wasm()\n */ b();\n"
+        stripped = DISCOVERY.strip_comments(text)
+        self.assertNotIn("liq_wasm", stripped)
+        self.assertNotIn("token_wasm", stripped)
+        self.assertIn("a();", stripped)
+        self.assertIn("b();", stripped)
+        self.assertEqual(stripped.count("\n"), text.count("\n"))
+
+    def test_comment_markers_inside_literals_are_code(self) -> None:
+        """`//` and `/*` inside string, raw-string, and character literals do not start comments."""
+        text = ('auto u = "http://x"; contracts::liq_wasm();\n'
+                'auto r = R"x(/* not a comment )x"; contracts::token_wasm();\n'
+                "char c = '/'; contracts::opreg_wasm();\n")
+        stripped = DISCOVERY.strip_comments(text)
+        for accessor in ("liq_wasm", "token_wasm", "opreg_wasm"):
+            self.assertIn(accessor, stripped)
+
+    def test_digit_separator_does_not_open_a_character_literal(self) -> None:
+        """`2'000'000` leaves the trailing comment recognisable as a comment."""
+        stripped = DISCOVERY.strip_comments("f(int64_t(2'000'000)); // contracts::liq_wasm()\ng();\n")
+        self.assertNotIn("liq_wasm", stripped)
+        self.assertIn("g();", stripped)
+
+
+class ScanLabelsTests(TemporaryTreeTestCase):
+    """Verify contract labels are derived from test sources and their local headers."""
+
+    def setUp(self) -> None:
+        """Write the accessor header every scan resolves names against."""
+        super().setUp()
+        self.accessors = DISCOVERY.load_accessor_labels([self.write("contracts.hpp.in", ACCESSOR_HEADER)])
+
+    def test_accessor_calls_and_qualified_references_label_the_suite(self) -> None:
+        """Calls and qualified references count; unknown `*_wasm` helpers and comments do not."""
+        source = self.write("suite.cpp", textwrap.dedent("""\
+            void deploy() {
+               set_code(LIQ, contracts::liq_wasm());
+               deploy_with(&contracts::reserve_wasm);
+               set_code(X, notify_system_account_wasm());
+               // set_code(T, contracts::token_wasm());
+            }
+            """))
+        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors), {"sysio.liq", "sysio.reserv"})
+
+    def test_contract_header_includes_label_the_suite(self) -> None:
+        """Contract headers compiled into the test and test-contract headers count, however they are reached."""
+        source = self.write("tests/suite.cpp", textwrap.dedent("""\
+            #include <sysio.opp.common/amm_math.hpp>
+            #include "../sysio.councl/include/sysio.councl/council_math.hpp"
+            #include "../../contracts/sysio.roa/include/sysio.roa/roa.hpp"
+            #include <test-contracts/noop/noop.hpp>
+            #include "../test_contracts/blockinfo_tester/blockinfo_tester.hpp"
+            #include <test_contracts/badtoken/badtoken.hpp>
+            #include <test_contracts.hpp>
+            #include <sysio/opp/opp.hpp>
+            #include "contracts.hpp"
+            """))
+        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors),
+                         {"sysio.opp.common", "sysio.councl", "sysio.roa", "test.blockinfo_tester", "test.badtoken",
+                          "test.noop"})
+
+    def test_local_headers_are_followed_transitively_and_cycles_terminate(self) -> None:
+        """A deploy helper two headers away still labels the suite, and an include cycle ends."""
+        self.write("tester.hpp", '#include "support.hpp"\nvoid deploy_opreg_once() { contracts::opreg_wasm(); }\n')
+        self.write("support.hpp", '#include "tester.hpp"\nvoid reject() { contracts::util::reject_all_wasm(); }\n')
+        source = self.write("suite.cpp", '#include "tester.hpp"\n')
+        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors), {"sysio.opreg", "test.reject_all"})
+
+    def test_undecodable_bytes_do_not_stop_the_scan(self) -> None:
+        """A source with bytes that are not UTF-8 is still scanned."""
+        source = self.write("suite.cpp", b"// \xff\xfe latin-1 comment\nvoid f() { contracts::liq_wasm(); }\n")
+        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors), {"sysio.liq"})
+
+    def test_repository_suite_reaches_opreg_through_its_tester_header(self) -> None:
+        """getpeerkeys_tests deploys sysio.opreg only through sysio.system_tester.hpp's deploy_opreg_once."""
+        accessors = DISCOVERY.load_accessor_labels(REPOSITORY_ACCESSOR_HEADERS)
+        source = REPOSITORY_ROOT / "contracts" / "tests" / "getpeerkeys_tests.cpp"
+        self.assertIn("sysio.opreg", DISCOVERY.scan_labels({source}, accessors))
+
+
+class RenderTests(TemporaryTreeTestCase):
+    """Verify the generated CTest script."""
+
+    def test_entries_are_ordered_labelled_and_disabled_as_declared(self) -> None:
+        """Each unit becomes add_test plus properties; a default-disabled unit is registered DISABLED."""
+        units = [DISCOVERY.TestUnit("alpha_tests", False, {"/src/a.cpp"}),
+                 DISCOVERY.TestUnit("beta_tests", True, {"/src/b.cpp"})]
+        labels = {"alpha_tests": set(), "beta_tests": {"sysio.token", "sysio.liq"}}
+        script = DISCOVERY.render_ctest(units, labels, Path("/build/contracts_unit_test"), Path("/build"), 2700,
+                                        ["--report_level=detailed"], "contract.", "contract")
+        self.assertEqual(script.splitlines()[1:], [
+            "add_test([[contract.alpha_tests]] [[/build/contracts_unit_test]] [[--run_test=alpha_tests]] "
+            "[[--report_level=detailed]])",
+            "set_tests_properties([[contract.alpha_tests]] PROPERTIES WORKING_DIRECTORY [[/build]] TIMEOUT 2700 "
+            "LABELS [[contract]] DISABLED TRUE)",
+            "add_test([[contract.beta_tests]] [[/build/contracts_unit_test]] [[--run_test=beta_tests]] "
+            "[[--report_level=detailed]])",
+            "set_tests_properties([[contract.beta_tests]] PROPERTIES WORKING_DIRECTORY [[/build]] TIMEOUT 2700 "
+            "LABELS [[contract;sysio.liq;sysio.token]])",
+        ])
+
+    def test_bracket_quoting_outgrows_its_content(self) -> None:
+        """A value containing, or ending in the start of, a closing bracket gets a longer bracket."""
+        self.assertEqual(DISCOVERY.bracket("plain"), "[[plain]]")
+        self.assertEqual(DISCOVERY.bracket("a]]b"), "[=[a]]b]=]")
+        self.assertEqual(DISCOVERY.bracket("a]]b]=]c"), "[==[a]]b]=]c]==]")
+        self.assertEqual(DISCOVERY.bracket("a]"), "[=[a]]=]")
+        self.assertEqual(DISCOVERY.bracket("a]="), "[[a]=]]")
+        self.assertEqual(DISCOVERY.bracket("b]=]"), "[==[b]=]]==]")
+
+    def test_unchanged_script_is_not_rewritten(self) -> None:
+        """Identical content leaves the file (and its timestamp) alone; new content is readable by others."""
+        output = self.root / "suites.cmake"
+        DISCOVERY.write_if_changed(output, "first\n")
+        self.assertEqual(stat.S_IMODE(output.stat().st_mode), DISCOVERY.GENERATED_FILE_MODE)
+        os.utime(output, (1, 1))
+        DISCOVERY.write_if_changed(output, "first\n")
+        self.assertEqual(output.stat().st_mtime, 1)
+        DISCOVERY.write_if_changed(output, "second\n")
+        self.assertEqual(output.read_text(encoding="utf-8"), "second\n")
+
+    def test_failed_write_leaves_no_temporary_file(self) -> None:
+        """If the final rename fails, the previous script stays and no temporary file is left behind."""
+        output = self.root / "suites.cmake"
+        DISCOVERY.write_if_changed(output, "first\n")
+        with mock.patch.object(DISCOVERY.os, "replace", side_effect=OSError("disk full")):
+            with self.assertRaises(OSError):
+                DISCOVERY.write_if_changed(output, "second\n")
+        self.assertEqual([path.name for path in self.root.iterdir()], ["suites.cmake"])
+        self.assertEqual(output.read_text(encoding="utf-8"), "first\n")
+
+
+class CommandLineTests(TemporaryTreeTestCase):
+    """Run the script end to end against a stand-in test executable."""
+
+    def make_executable(self, listing: str, exit_code: int = 0) -> Path:
+        """Write a stand-in executable that prints the listing the way Boost does, to its report stream."""
+        self.write("listing.dot", listing)
+        expected_arguments = " ".join(DISCOVERY.LIST_CONTENT_ARGUMENTS)
+        executable = self.write("build/contracts_unit_test", textwrap.dedent(f"""\
+            #!/bin/sh
+            [ "$*" = "{expected_arguments}" ] || exit 64
+            echo "Random number generator seeded to 1"
+            cat "{self.root / 'listing.dot'}" >&2
+            exit {exit_code}
+            """))
+        executable.chmod(0o755)
+        return executable
+
+    def run_cli(self, executable: Path, *extra: str, sources: list[str] | None = None) -> tuple[int, str]:
+        """Invoke the command-line entry point with the arguments CMake passes; return its code and stderr."""
+        if sources is None:
+            sources = [str(path) for path in sorted(self.root.glob("*.cpp"))]
+        errors = io.StringIO()
+        with contextlib.redirect_stderr(errors):
+            code = DISCOVERY.run_cli([
+                "--executable", str(executable), "--working-directory", str(self.root / "build"),
+                "--test-sources", *sources, "--accessor-header", str(self.root / "contracts.hpp.in"),
+                "--timeout", "2700", "--test-argument=--report_level=detailed",
+                "--output", str(self.root / "suites.cmake"), *extra])
+        return code, errors.getvalue()
+
+    def script(self) -> str:
+        """The generated CTest script."""
+        return (self.root / "suites.cmake").read_text(encoding="utf-8")
+
+    def write_sources(self) -> None:
+        """Write the sources the stand-in listing declares its units in."""
+        self.write("contracts.hpp.in", ACCESSOR_HEADER)
+        self.write("beta_tests.cpp", "void f() { contracts::liq_wasm(); }\n")
+        self.write("beta_extra.cpp", "void g() { contracts::token_wasm(); }\n")
+        self.write("beta_nested.cpp", "#include <sysio.opp.common/twap.hpp>\n")
+        self.write("alpha_tests.cpp", "void h() {}\n")
+        self.write("loose.cpp", "void i() { contracts::opreg_wasm(); }\n")
+
+    def test_every_top_level_unit_is_registered_with_its_labels(self) -> None:
+        """Suites, their split and nested parts, dependencies, and a file-scope case are registered and labelled."""
+        self.write_sources()
+        self.assertEqual(self.run_cli(self.make_executable(dot_listing(self.root))), (0, ""))
+        script = self.script()
+        self.assertIn("LABELS [[contract;sysio.token]] DISABLED TRUE", script)
+        self.assertIn("LABELS [[contract;sysio.liq;sysio.opp.common;sysio.token]])", script)
+        self.assertIn("add_test([[contract.loose_case]]", script)
+        self.assertIn("LABELS [[contract;sysio.opreg]])", script)
+        self.assertEqual(script.count("add_test("), 3)
+
+    def test_contracts_deployed_by_default_test_setup_label_every_entry(self) -> None:
+        """Every entry carries the contracts from the implicit accessor header."""
+        self.write_sources()
+        self.write("contracts.cpp.in", EMBEDDED_ACCESSOR_HEADER)
+        code, _ = self.run_cli(self.make_executable(dot_listing(self.root)),
+                               "--implicit-accessor-header", str(self.root / "contracts.cpp.in"))
+        self.assertEqual(code, 0)
+        label_lines = [line for line in self.script().splitlines() if line.startswith("set_tests_properties(")]
+        self.assertEqual(len(label_lines), 3)
+        for line in label_lines:
+            self.assertIn(";sysio.bios;", line)
+            self.assertIn(";sysio.roa", line)
+
+    def test_rewritten_locations_match_the_executables_sources(self) -> None:
+        """Relative (ccache base_dir) and prefix-mapped locations resolve to the sources that were compiled."""
+        self.write_sources()
+        for root in (Path(".."), Path("../../.."), Path("/usr/src/wire-sysio/contracts/tests")):
+            self.assertEqual(self.run_cli(self.make_executable(dot_listing(root))), (0, ""), root)
+            self.assertIn("LABELS [[contract;sysio.liq;sysio.opp.common;sysio.token]])", self.script())
+
+    def test_unresolvable_location_gets_every_label_and_a_warning(self) -> None:
+        """A unit whose sources cannot be found is over-labelled, not dropped, and the build goes on."""
+        self.write_sources()
+        (self.root / "loose.cpp").unlink()
+        code, errors = self.run_cli(self.make_executable(dot_listing(self.root)))
+        self.assertEqual(code, 0)
+        self.assertIn("cannot find", errors)
+        loose = next(line for line in self.script().splitlines()
+                     if line.startswith("set_tests_properties([[contract.loose_case]]"))
+        for label in ("sysio.liq", "sysio.opp.common", "sysio.opreg", "sysio.reserv", "sysio.token", "test.reject_all"):
+            self.assertIn(label, loose)
+
+    def test_fallback_labels_come_from_every_source_when_nothing_resolves(self) -> None:
+        """With no location resolvable, a contract reached only through an include still labels every unit."""
+        self.write("contracts.hpp.in", ACCESSOR_HEADER)
+        other = self.write("other_tests.cpp", "#include <sysio.opp.common/twap.hpp>\n")
+        code, errors = self.run_cli(self.make_executable(dot_listing(Path("/nonexistent"))), sources=[str(other)])
+        self.assertEqual(code, 0)
+        self.assertEqual(errors.count("warning: cannot find"), 3)
+        for line in self.script().splitlines():
+            if line.startswith("set_tests_properties("):
+                self.assertIn(";sysio.opp.common;", line)
+
+    def test_failing_listing_registers_a_failing_entry(self) -> None:
+        """A test executable that cannot list itself becomes one failing entry carrying its error; the build goes on."""
+        self.write_sources()
+        code, errors = self.run_cli(self.make_executable(dot_listing(self.root), exit_code=3))
+        self.assertEqual(code, 0)
+        self.assertIn("exited with 3", errors)
+        script = self.script()
+        self.assertEqual(script.count("add_test("), 1)
+        add_test = script[script.index("add_test("):script.index("set_tests_properties(")]
+        name, *command = [match.group(2) for match in BRACKET_ARGUMENT_RE.finditer(add_test)]
+        self.assertEqual(name, "contract.DISCOVERY_FAILED")
+        result = subprocess.run(command, capture_output=True, text=True, check=False)
+        self.assertEqual(result.returncode, 1)
+        self.assertIn("exited with 3", result.stderr)
+        self.assertIn("To retry discovery", result.stderr)
+        labels = script[script.index("LABELS"):]
+        for label in ("contract;", "sysio.liq", "sysio.opp.common", "sysio.opreg", "test.reject_all"):
+            self.assertIn(label, labels)
+
+    def test_malformed_listing_fails_discovery(self) -> None:
+        """A listing discovery cannot parse is a fault in discovery, so the build fails."""
+        self.write_sources()
+        code, errors = self.run_cli(self.make_executable("digraph G {rankdir=LR;\n}\n"))
+        self.assertEqual(code, 1)
+        self.assertIn("no master test suite", errors)
+        self.assertFalse((self.root / "suites.cmake").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

From 43aa040f3d78c0962d07b3550926ce6854e3d619 Mon Sep 17 00:00:00 2001
From: kevin Heifner <kevin@wire.network>
Date: Wed, 30 Sep 2026 09:11:23 -0500
Subject: [PATCH 2/4] cmake: register Boost.Test suites discovered from the
 test binaries

Replace the Python discovery of contract suites with boost_test_discover_tests(), a plain-CMake module modeled on CMake's gtest_discover_tests(DISCOVERY_MODE PRE_TEST). When ctest starts, it lists a Boost.Test executable's top-level units with --list_content, caches the result until the executable changes, and registers one CTest entry per unit, so adding or removing a suite needs no CMake edit.

Use it for every per-suite registration: unit_test and wasm_spec_test, which grepped their sources at configure time and never saw test cases declared outside a suite, test_chain_plugin, whose case list was maintained by hand, and contracts_unit_test. Every existing entry keeps its name, command, working directory, labels, environment and COST, except that the contract entries now carry only the contract label; nothing read the per-contract labels, and they had drifted. The file-scope chainbase_type_heap_alloc and chainbase_type_segment_alloc cases now run, the wasm-spec COST hints now apply (their loop iterated an undefined EOSIO_WASM_RUNTIMES), and the coverage target's selector, which matched nothing, now selects the unit_test entries. The unused unittest_tests_add macro is removed.

A binary that cannot list itself fails a <target>_DISCOVERY_FAILED entry instead of the build, and a missing one a <target>_NOT_BUILT entry. boost_test_discovery_test covers the listing parser and, through a small project read back by ctest, the generated scripts.
---
 CMakeLists.txt                                |   4 +
 cmake/boost-test-discovery-impl.cmake         | 164 ++++++
 cmake/boost-test-discovery.cmake              | 115 ++++
 cmake/test-tools.cmake                        |  31 --
 cmake/test/boost-test-discovery-test.cmake    | 235 ++++++++
 contracts/tests/CMakeLists.txt                |  46 +-
 contracts/tools/discover_contract_suites.py   | 469 ----------------
 .../tests/test_discover_contract_suites.py    | 518 ------------------
 plugins/chain_plugin/test/CMakeLists.txt      |  38 +-
 unittests/CMakeLists.txt                      |  83 +--
 .../generated-tests/CMakeLists.txt            |  45 +-
 11 files changed, 566 insertions(+), 1182 deletions(-)
 create mode 100644 cmake/boost-test-discovery-impl.cmake
 create mode 100644 cmake/boost-test-discovery.cmake
 create mode 100644 cmake/test/boost-test-discovery-test.cmake
 delete mode 100644 contracts/tools/discover_contract_suites.py
 delete mode 100644 contracts/tools/tests/test_discover_contract_suites.py

diff --git a/CMakeLists.txt b/CMakeLists.txt
index dc490a2814..3d600fe0c9 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}
+                   -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..78796f4066
--- /dev/null
+++ b/cmake/boost-test-discovery-impl.cmake
@@ -0,0 +1,164 @@
+# 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)
+# 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.
+   cmake_parse_arguments(arg ""
+      "EXECUTABLE;TESTS_FILE;INCLUDE_FILE;FAILURE_NAME;CMAKE_COMMAND;WORKING_DIRECTORY;NAME;INCLUDE;EXCLUDE"
+      "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. The script is stale
+   # when the executable or the include script is newer (a tie counts) or this implementation changed.
+   file(LOCK "${arg_TESTS_FILE}.lock" GUARD FUNCTION TIMEOUT ${_BOOST_TEST_LIST_TIMEOUT_SECONDS}
+        RESULT_VARIABLE lock_result)
+   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..be3af9b0c9
--- /dev/null
+++ b/cmake/test/boost-test-discovery-test.cmake
@@ -0,0 +1,235 @@
+# 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")
+
+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 and CXX let the
+# ctest entry build it the way the enclosing build is built.
+get_filename_component(cmake_bin "${CMAKE_COMMAND}" DIRECTORY)
+set(ctest_command "${cmake_bin}/ctest")
+if(NOT GENERATOR)
+   set(GENERATOR Ninja)
+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"
+   "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})
+listed_tests(tests "${build}")
+expect_equal("${tests}" "fake_NOT_BUILT" "before the executable is built")
+
+run("build" "${CMAKE_COMMAND}" --build "${build}")
+listed_tests(tests "${build}")
+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 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}")
+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 9f223107a5..d689e596b8 100644
--- a/contracts/tests/CMakeLists.txt
+++ b/contracts/tests/CMakeLists.txt
@@ -18,10 +18,6 @@ add_test(NAME contract_type_generator_test
         COMMAND ${Python3_EXECUTABLE} -m unittest discover
                 -s ${CMAKE_SOURCE_DIR}/contracts/tools/tests
                 -p test_generate_sysio_contract_types.py)
-add_test(NAME contract_suite_discovery_test
-        COMMAND ${Python3_EXECUTABLE} -m unittest discover
-                -s ${CMAKE_SOURCE_DIR}/contracts/tools/tests
-                -p test_discover_contract_suites.py)
 
 # build unit test executable
 file(GLOB UNIT_TESTS CONFIGURE_DEPENDS "*.cpp" "*.hpp") # find all unit test suites
@@ -41,39 +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 unit as its own CTest entry, contract.<unit>, so each can be selected alone and all
-# can run concurrently under ctest -j while sharing this executable. The linked executable's own listing is the
-# inventory, so a new suite needs no edit here. Each entry is labelled with the contracts its sources use plus the
-# ones libtester deploys during default setup.
-set(CONTRACT_SUITE_TEST_PREFIX contract.)
-set(CONTRACT_SUITE_LABEL contract)
-set(CONTRACT_SUITE_DISCOVERY_SCRIPT ${CMAKE_SOURCE_DIR}/contracts/tools/discover_contract_suites.py)
-set(CONTRACT_SUITE_TESTS_FILE ${CMAKE_CURRENT_BINARY_DIR}/${CONTRACT_UNIT_TEST_EXE}_suites.cmake)
-set(CONTRACT_SUITE_INCLUDE_FILE ${CMAKE_CURRENT_BINARY_DIR}/${CONTRACT_UNIT_TEST_EXE}_include.cmake)
-add_custom_command(TARGET ${CONTRACT_UNIT_TEST_EXE} POST_BUILD
-        COMMAND ${Python3_EXECUTABLE} ${CONTRACT_SUITE_DISCOVERY_SCRIPT}
-                --executable $<TARGET_FILE:${CONTRACT_UNIT_TEST_EXE}>
-                --working-directory ${CMAKE_BINARY_DIR}
-                --test-sources ${UNIT_TESTS}
-                --accessor-header ${CMAKE_CURRENT_SOURCE_DIR}/contracts.hpp.in
-                --accessor-header ${CMAKE_SOURCE_DIR}/unittests/test_contracts.hpp.in
-                --implicit-accessor-header ${CMAKE_SOURCE_DIR}/libraries/testing/contracts.cpp.in
-                --timeout ${CONTRACT_UNIT_TEST_TIMEOUT_SECONDS}
-                --test-argument=--report_level=detailed
-                --test-prefix ${CONTRACT_SUITE_TEST_PREFIX}
-                --base-label ${CONTRACT_SUITE_LABEL}
-                --output ${CONTRACT_SUITE_TESTS_FILE}
-        BYPRODUCTS ${CONTRACT_SUITE_TESTS_FILE}
-        COMMENT "Registering ${CONTRACT_UNIT_TEST_EXE} suites with CTest"
-        VERBATIM)
-# Relink, and so rediscover, when the discovery rules change and not only when a test source does.
-set_property(TARGET ${CONTRACT_UNIT_TEST_EXE} APPEND PROPERTY LINK_DEPENDS ${CONTRACT_SUITE_DISCOVERY_SCRIPT})
-# Until the executable is built, a placeholder entry fails instead of the contract suites silently not running.
-file(WRITE ${CONTRACT_SUITE_INCLUDE_FILE}
-        "if(EXISTS \"${CONTRACT_SUITE_TESTS_FILE}\")\n"
-        "  include(\"${CONTRACT_SUITE_TESTS_FILE}\")\n"
-        "else()\n"
-        "  add_test(${CONTRACT_SUITE_TEST_PREFIX}NOT_BUILT ${CONTRACT_UNIT_TEST_EXE}_NOT_BUILT)\n"
-        "  set_tests_properties(${CONTRACT_SUITE_TEST_PREFIX}NOT_BUILT PROPERTIES LABELS ${CONTRACT_SUITE_LABEL})\n"
-        "endif()\n")
-set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES ${CONTRACT_SUITE_INCLUDE_FILE})
+# 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/contracts/tools/discover_contract_suites.py b/contracts/tools/discover_contract_suites.py
deleted file mode 100644
index 34e6ba81f7..0000000000
--- a/contracts/tools/discover_contract_suites.py
+++ /dev/null
@@ -1,469 +0,0 @@
-#!/usr/bin/env python3
-"""
-Register each top-level Boost.Test unit of a test executable as its own CTest entry.
-
-CMake runs this after `contracts_unit_test` links. The executable's `--list_content=DOT` output is
-the inventory, so adding a suite needs no CMake edit. Each entry is labelled with `contract` plus
-every contract its sources deploy or compile against: accessor references such as
-`contracts::liq_wasm()` and contract header includes such as `<sysio.opp.common/amm_math.hpp>`,
-scanned in the files that declare the unit, its test cases and their dependencies, and in the local
-headers those files include. Contracts the test library deploys during default tester setup label
-every entry.
-
-The labels over-approximate, since a helper in a shared header labels every suite that includes it.
-That is the safe direction for selecting tests by changed contract.
-"""
-from __future__ import annotations
-
-import argparse
-import os
-import re
-import subprocess
-import sys
-import tempfile
-from dataclasses import dataclass, field
-from pathlib import Path
-
-# ---------------------------------------------------------------------------
-# Boost.Test `--list_content=DOT` grammar (boost/test/impl/unit_test_main.ipp, dot_content_reporter)
-# ---------------------------------------------------------------------------
-
-DOT_NODE_RE = re.compile(r'^tu(?P<id>\d+)\[(?P<attrs>.*)\];$')
-DOT_PARENT_EDGE_RE = re.compile(r'^tu(?P<parent>\d+) -> tu(?P<child>\d+);$')
-DOT_DEPENDENCY_EDGE_RE = re.compile(r'^tu(?P<unit>\d+) -> tu(?P<dependency>\d+)\[[^\]]*\];$')
-DOT_LABEL_RE = re.compile(r'label="(?P<label>[^"]*)"')
-DOT_LOCATION_RE = re.compile(r'^(?P<file>.*)\((?P<line>\d+)\)$')
-DOT_MASTER_ATTR = 'peripheries=2'
-DOT_ENABLED_ATTR = 'color=green'
-DOT_LABEL_FIELD_SEPARATOR = '|'
-
-# ---------------------------------------------------------------------------
-# Contract artifact accessors, as defined by the headers passed with --accessor-header
-# ---------------------------------------------------------------------------
-
-# Every `*_wasm(`/`*_abi(` in an accessor header other than a loader call must map to a contract.
-ACCESSOR_TOKEN_RE = re.compile(r'\b(?P<name>\w+_(?:wasm|abi))\s*\(')
-ACCESSOR_LOADERS = frozenset({'read_wasm', 'read_abi'})
-ACCESSOR_FUNCTION_RE = re.compile(
-    r'\b(?P<name>\w+_(?:wasm|abi))\s*\([^;{}()]*\)[^;{}]*\{[^{}]*?"(?P<path>[^"]+\.(?:wasm|abi))"', re.S)
-ACCESSOR_MACRO_RE = re.compile(
-    r'^\s*MAKE_\w*WASM_ABI\(\s*(?P<prefix>\w+)\s*,\s*(?P<contract>[\w.]+)\s*,\s*[\w./-]+\s*\)', re.M)
-ACCESSOR_SUFFIXES = ('_wasm', '_abi')
-CONTRACT_PATH_RE = re.compile(r'/contracts/(?P<contract>sysio\.[\w.]+)/[^/]+\.(?:wasm|abi)$')
-TEST_CONTRACT_PATH_RE = re.compile(r'/test[_-]contracts/(?P<name>\w+?)(?:\.(?:wasm|abi)$|/)')
-SYSTEM_CONTRACT_PREFIX = 'sysio.'
-TEST_CONTRACT_LABEL_PREFIX = 'test.'
-
-# ---------------------------------------------------------------------------
-# Contract references in test sources
-# ---------------------------------------------------------------------------
-
-ACCESSOR_CALL_RE = re.compile(r'\b(?P<name>\w+_(?:wasm|abi))\s*\(')
-ACCESSOR_QUALIFIED_RE = re.compile(r'::\s*(?P<name>\w+_(?:wasm|abi))\b')
-INCLUDE_PATH_RE = re.compile(r'^[ \t]*#[ \t]*include[ \t]*[<"](?P<path>[^>"]+)[>"]', re.M)
-LOCAL_INCLUDE_RE = re.compile(r'^[ \t]*#[ \t]*include[ \t]*"(?P<path>[^"]+)"', re.M)
-# A contract's directory anywhere in an include path: <sysio.opp.common/...>, "../../contracts/sysio.roa/...".
-CONTRACT_COMPONENT_RE = re.compile(r'(?:^|/)(?P<contract>sysio\.[\w.]+)/')
-TEST_CONTRACT_COMPONENT_RE = re.compile(r'(?:^|/)test[_-]contracts/(?P<name>\w+)/')
-RAW_STRING_OPEN_RE = re.compile(r'R"(?P<delimiter>[^()\\\s]{0,16})\(')
-
-DEFAULT_TEST_PREFIX = 'contract.'
-DEFAULT_BASE_LABEL = 'contract'
-DISCOVERY_FAILED_NAME = 'DISCOVERY_FAILED'
-# The command line overrides BOOST_TEST_REPORT_SINK, which would otherwise divert the listing into a file.
-LIST_CONTENT_ARGUMENTS = ('--list_content=DOT', '--report_sink=stderr')
-LIST_CONTENT_TIMEOUT_SECONDS = 120
-LISTING_ERROR_TAIL_CHARACTERS = 4000
-# mkstemp creates 0600; the script is read by whoever runs ctest.
-GENERATED_FILE_MODE = 0o644
-
-
-class DiscoveryError(RuntimeError):
-    """A fault in discovery itself or its inputs; the build should fail."""
-
-
-class ListingError(DiscoveryError):
-    """The test executable could not produce its listing; its failure belongs in the test results."""
-
-
-@dataclass
-class TestUnit:
-    """A top-level Boost.Test unit: a suite or a test case declared outside any suite."""
-
-    name: str
-    enabled: bool
-    files: set[str] = field(default_factory=set)
-
-
-# ---------------------------------------------------------------------------
-# Inventory
-# ---------------------------------------------------------------------------
-
-def parse_dot(text: str) -> list[TestUnit]:
-    """Return the master suite's children, each with the files declaring it, its subtree and their dependencies.
-
-    Dependencies count because `--run_test` enables the units a selected unit depends on; depending on the master
-    suite runs everything.
-    """
-    nodes: dict[str, tuple[str, bool, str]] = {}
-    children: dict[str, list[str]] = {}
-    dependencies: dict[str, list[str]] = {}
-    master_id: str | None = None
-    for raw_line in text.splitlines():
-        line = raw_line.strip()
-        node = DOT_NODE_RE.match(line)
-        if node:
-            attrs = node.group('attrs')
-            label = DOT_LABEL_RE.search(attrs)
-            if label is None:
-                raise DiscoveryError(f'test unit without a label: {line}')
-            if DOT_MASTER_ATTR in attrs.split(','):
-                master_id = node.group('id')
-                continue
-            fields = label.group('label').split(DOT_LABEL_FIELD_SEPARATOR)
-            location = DOT_LOCATION_RE.match(fields[1]) if len(fields) > 1 else None
-            if location is None:
-                raise DiscoveryError(f'test unit without a source location: {line}')
-            nodes[node.group('id')] = (fields[0], DOT_ENABLED_ATTR in attrs.split(','), location.group('file'))
-            continue
-        edge = DOT_PARENT_EDGE_RE.match(line)
-        if edge:
-            children.setdefault(edge.group('parent'), []).append(edge.group('child'))
-            continue
-        dependency = DOT_DEPENDENCY_EDGE_RE.match(line)
-        if dependency:
-            dependencies.setdefault(dependency.group('unit'), []).append(dependency.group('dependency'))
-
-    if master_id is None:
-        raise DiscoveryError('no master test suite in the --list_content=DOT output')
-
-    units = []
-    for unit_id in children.get(master_id, []):
-        files: set[str] = set()
-        visited: set[str] = set()
-        pending = [unit_id]
-        while pending:
-            current = pending.pop()
-            if current in visited:
-                continue
-            visited.add(current)
-            if current == master_id:
-                files.update(file for _, _, file in nodes.values())
-                continue
-            if current not in nodes:
-                raise DiscoveryError(f'edge to undeclared test unit tu{current}')
-            files.add(nodes[current][2])
-            pending.extend(children.get(current, []))
-            pending.extend(dependencies.get(current, []))
-        name, enabled, _ = nodes[unit_id]
-        units.append(TestUnit(name=name, enabled=enabled, files=files))
-    return sorted(units, key=lambda unit: unit.name)
-
-
-def list_test_units(executable: Path, working_directory: Path) -> list[TestUnit]:
-    """Run the executable's DOT listing and parse it."""
-    command = [str(executable), *LIST_CONTENT_ARGUMENTS]
-    try:
-        result = subprocess.run(command, cwd=working_directory, capture_output=True, text=True, errors='replace',
-                                timeout=LIST_CONTENT_TIMEOUT_SECONDS, check=False)
-    except (OSError, subprocess.TimeoutExpired) as error:
-        raise ListingError(f'cannot run {" ".join(command)}: {error}') from error
-    if result.returncode != 0:
-        raise ListingError(f'{" ".join(command)} exited with {result.returncode}:\n'
-                           f'{result.stderr[-LISTING_ERROR_TAIL_CHARACTERS:]}')
-    units = parse_dot(result.stderr + '\n' + result.stdout)
-    if not units:
-        raise ListingError(f'{executable} declares no test units')
-    return units
-
-
-# ---------------------------------------------------------------------------
-# Labels
-# ---------------------------------------------------------------------------
-
-def label_for_artifact(path: str) -> str | None:
-    """Map a contract artifact path to its label: `sysio.<name>`, or `test.<name>` for a test contract."""
-    contract = CONTRACT_PATH_RE.search(path)
-    if contract:
-        return contract.group('contract')
-    test_contract = TEST_CONTRACT_PATH_RE.search(path)
-    if test_contract:
-        return TEST_CONTRACT_LABEL_PREFIX + test_contract.group('name')
-    return None
-
-
-def label_for_contract(contract: str) -> str:
-    """Label a contract named by a MAKE_*_WASM_ABI invocation, whatever directory it is built in."""
-    return contract if contract.startswith(SYSTEM_CONTRACT_PREFIX) else TEST_CONTRACT_LABEL_PREFIX + contract
-
-
-def load_accessor_labels(headers: list[Path]) -> dict[str, set[str]]:
-    """Map each contract accessor name (`liq_wasm`, `sysio_system_abi`, ...) to its contract label.
-
-    An accessor the rules cannot map is an error: every suite calling it would otherwise lose that contract's
-    label without any sign.
-    """
-    accessors: dict[str, set[str]] = {}
-    tokens: dict[Path, set[str]] = {}
-    for header in headers:
-        text = strip_comments(header.read_text(encoding='utf-8', errors='replace'))
-        tokens[header] = {match.group('name') for match in ACCESSOR_TOKEN_RE.finditer(text)} - ACCESSOR_LOADERS
-        for match in ACCESSOR_FUNCTION_RE.finditer(text):
-            label = label_for_artifact(match.group('path'))
-            if label:
-                accessors.setdefault(match.group('name'), set()).add(label)
-        for match in ACCESSOR_MACRO_RE.finditer(text):
-            for suffix in ACCESSOR_SUFFIXES:
-                accessors.setdefault(match.group('prefix') + suffix, set()).add(
-                    label_for_contract(match.group('contract')))
-    for header, names in tokens.items():
-        unmapped = names - accessors.keys()
-        if unmapped:
-            raise DiscoveryError(f'{header}: no contract label for accessor(s) {", ".join(sorted(unmapped))}; '
-                                 'extend label_for_artifact or the accessor patterns to cover them')
-    if not accessors:
-        raise DiscoveryError('no contract accessors found in ' + ', '.join(str(h) for h in headers))
-    return accessors
-
-
-def strip_comments(text: str) -> str:
-    """Blank out C++ comments, keeping string and character literals and line structure intact."""
-    out: list[str] = []
-    i = 0
-    length = len(text)
-    while i < length:
-        char = text[i]
-        raw = RAW_STRING_OPEN_RE.match(text, i) if char == 'R' else None
-        if raw:
-            close = ')' + raw.group('delimiter') + '"'
-            end = text.find(close, raw.end())
-            end = length if end < 0 else end + len(close)
-            out.append(text[i:end])
-            i = end
-            continue
-        # A quote after a digit is a digit separator (2'000'000), not the start of a character literal.
-        if char == '"' or (char == "'" and not (i > 0 and text[i - 1].isdigit())):
-            end = i + 1
-            while end < length and text[end] != char and text[end] != '\n':
-                end += 2 if text[end] == '\\' else 1
-            end = min(end + 1, length)
-            out.append(text[i:end])
-            i = end
-        elif text.startswith('//', i):
-            end = text.find('\n', i)
-            i = length if end < 0 else end
-        elif text.startswith('/*', i):
-            end = text.find('*/', i + 2)
-            end = length if end < 0 else end + 2
-            out.append('\n' * text.count('\n', i, end))
-            i = end
-        else:
-            out.append(char)
-            i += 1
-    return ''.join(out)
-
-
-def scan_labels(sources: set[Path], accessors: dict[str, set[str]]) -> set[str]:
-    """Collect the contract labels referenced by the sources and, transitively, their local headers."""
-    labels: set[str] = set()
-    pending = sorted(sources)
-    visited: set[Path] = set()
-    while pending:
-        source = pending.pop()
-        if source in visited:
-            continue
-        visited.add(source)
-        text = strip_comments(source.read_text(encoding='utf-8', errors='replace'))
-        for pattern in (ACCESSOR_CALL_RE, ACCESSOR_QUALIFIED_RE):
-            for match in pattern.finditer(text):
-                labels |= accessors.get(match.group('name'), set())
-        for include in INCLUDE_PATH_RE.finditer(text):
-            path = include.group('path')
-            labels.update(match.group('contract') for match in CONTRACT_COMPONENT_RE.finditer(path))
-            labels.update(TEST_CONTRACT_LABEL_PREFIX + match.group('name')
-                          for match in TEST_CONTRACT_COMPONENT_RE.finditer(path))
-        for match in LOCAL_INCLUDE_RE.finditer(text):
-            header = (source.parent / match.group('path')).resolve()
-            if header.is_file() and header not in visited:
-                pending.append(header)
-    return labels
-
-
-def resolve_source(location: str, sources: list[Path]) -> list[Path]:
-    """Find the file a unit's location names.
-
-    An existing absolute path is taken as is. Otherwise `__FILE__` was rewritten, relative to the compile directory
-    (ccache's base_dir) or through a prefix map, so the location is matched to the target's own sources by the
-    longest shared trailing path; ties return every candidate.
-    """
-    path = Path(location)
-    if path.is_absolute() and path.is_file():
-        return [path.resolve()]
-    trailing = path.parts[::-1]
-    best = 0
-    matches: list[Path] = []
-    for source in sources:
-        shared = 0
-        for mine, theirs in zip(trailing, source.parts[::-1]):
-            if mine != theirs:
-                break
-            shared += 1
-        if shared and shared >= best:
-            if shared > best:
-                best, matches = shared, []
-            matches.append(source)
-    return matches
-
-
-def every_known_label(accessors: dict[str, set[str]], implicit: set[str], sources: list[Path]) -> set[str]:
-    """Every label any entry could carry, for entries whose own sources are unknown."""
-    return set().union(implicit, *accessors.values(), scan_labels(set(sources), accessors))
-
-
-def derive_labels(units: list[TestUnit], accessors: dict[str, set[str]], implicit: set[str],
-                  sources: list[Path]) -> dict[str, set[str]]:
-    """Label every unit; one whose sources cannot be found gets every known label, so it is never under-selected."""
-    labels: dict[str, set[str]] = {}
-    fallback: set[str] | None = None
-    for unit in units:
-        resolved = {file: resolve_source(file, sources) for file in unit.files}
-        missing = sorted(file for file, paths in resolved.items() if not paths)
-        if not missing:
-            labels[unit.name] = scan_labels({path for paths in resolved.values() for path in paths},
-                                            accessors) | implicit
-            continue
-        if fallback is None:
-            fallback = every_known_label(accessors, implicit, sources)
-        print(f'{Path(__file__).name}: warning: cannot find {", ".join(missing)} for {unit.name}; '
-              'labelling it with every known contract', file=sys.stderr)
-        labels[unit.name] = fallback
-    return labels
-
-
-# ---------------------------------------------------------------------------
-# CTest script
-# ---------------------------------------------------------------------------
-
-def bracket(value: str) -> str:
-    """Quote a value as a CMake bracket argument, which needs no escaping.
-
-    The trailing `]` accounts for a value that ends in the start of the closing bracket.
-    """
-    level = 0
-    while f']{"=" * level}]' in value + ']':
-        level += 1
-    equals = '=' * level
-    return f'[{equals}[{value}]{equals}]'
-
-
-def script_header(executable: Path) -> str:
-    """The first line of every generated script."""
-    return (f'# Generated by {Path(__file__).name} from `{executable.name} {" ".join(LIST_CONTENT_ARGUMENTS)}`. '
-            'Do not edit.')
-
-
-def render_properties(test_name: str, properties: list[str]) -> str:
-    """One `set_tests_properties` call."""
-    return f'set_tests_properties({test_name} PROPERTIES {" ".join(properties)})'
-
-
-def render_ctest(units: list[TestUnit], labels: dict[str, set[str]], executable: Path,
-                 working_directory: Path, timeout: int, test_arguments: list[str],
-                 test_prefix: str, base_label: str) -> str:
-    """Render one `add_test` and one `set_tests_properties` per unit, in name order."""
-    lines = [script_header(executable)]
-    for unit in units:
-        test_name = bracket(test_prefix + unit.name)
-        command = [str(executable), f'--run_test={unit.name}', *test_arguments]
-        lines.append(f'add_test({test_name} {" ".join(bracket(part) for part in command)})')
-        properties = [f'WORKING_DIRECTORY {bracket(str(working_directory))}', f'TIMEOUT {timeout}',
-                      f'LABELS {bracket(";".join([base_label, *sorted(labels[unit.name])]))}']
-        if not unit.enabled:
-            properties.append('DISABLED TRUE')
-        lines.append(render_properties(test_name, properties))
-    return '\n'.join(lines) + '\n'
-
-
-def render_listing_failure(message: str, labels: set[str], executable: Path, test_prefix: str,
-                           base_label: str) -> str:
-    """Render a single entry that fails with the listing error.
-
-    It carries every known label so that selecting by contract still runs, and fails on, it.
-    """
-    test_name = bracket(test_prefix + DISCOVERY_FAILED_NAME)
-    command = [sys.executable, '-c', 'import sys; sys.exit(sys.argv[1])', message]
-    return '\n'.join([script_header(executable),
-                      f'add_test({test_name} {" ".join(bracket(part) for part in command)})',
-                      render_properties(test_name, [f'LABELS {bracket(";".join([base_label, *sorted(labels)]))}'])
-                      ]) + '\n'
-
-
-def write_if_changed(path: Path, content: str) -> None:
-    """Replace the file atomically, leaving it untouched when the content is unchanged."""
-    if path.is_file() and path.read_text(encoding='utf-8', errors='replace') == content:
-        return
-    path.parent.mkdir(parents=True, exist_ok=True)
-    descriptor, temporary = tempfile.mkstemp(dir=path.parent, prefix=f'.{path.name}.')
-    try:
-        with os.fdopen(descriptor, 'w', encoding='utf-8') as stream:
-            stream.write(content)
-        os.chmod(temporary, GENERATED_FILE_MODE)
-        os.replace(temporary, path)
-    except BaseException:
-        Path(temporary).unlink(missing_ok=True)
-        raise
-
-
-def run_cli(argv: list[str] | None = None) -> int:
-    """Discover the executable's top-level units and write the CTest script that registers them."""
-    parser = argparse.ArgumentParser(description=__doc__.strip().splitlines()[0])
-    parser.add_argument('--executable', type=Path, required=True, help='Boost.Test executable to inventory')
-    parser.add_argument('--working-directory', type=Path, required=True,
-                        help='directory the registered tests run in')
-    parser.add_argument('--test-sources', type=Path, nargs='+', required=True,
-                        help="the executable's own sources, which unit locations are matched against")
-    parser.add_argument('--accessor-header', type=Path, action='append', required=True,
-                        help='header defining contract accessors (repeatable)')
-    parser.add_argument('--implicit-accessor-header', type=Path, action='append', default=[],
-                        help='header defining accessors for contracts deployed during default test setup; '
-                             'they label every entry (repeatable)')
-    parser.add_argument('--timeout', type=int, required=True, help='CTest TIMEOUT for every entry, in seconds')
-    parser.add_argument('--output', type=Path, required=True, help='CTest script to write')
-    parser.add_argument('--test-argument', action='append', default=[],
-                        help='extra argument passed to every registered test (repeatable)')
-    parser.add_argument('--test-prefix', default=DEFAULT_TEST_PREFIX, help='prefix of every CTest name')
-    parser.add_argument('--base-label', default=DEFAULT_BASE_LABEL, help='label carried by every entry')
-    args = parser.parse_args(argv)
-
-    tool = Path(__file__).name
-    executable = args.executable.resolve()
-    sources = sorted(source.resolve() for source in args.test_sources)
-    try:
-        accessors = load_accessor_labels(args.accessor_header + args.implicit_accessor_header)
-        implicit = set()
-        if args.implicit_accessor_header:
-            implicit = set().union(*load_accessor_labels(args.implicit_accessor_header).values())
-        try:
-            units = list_test_units(executable, args.working_directory)
-        except ListingError as error:
-            # A plain rebuild does not relink an unchanged executable, and only a relink reruns discovery.
-            message = (f'{error}\nTo retry discovery after fixing the cause, touch {Path(__file__).resolve()} '
-                       f'and rebuild {executable.name}.')
-            print(f'{tool}: warning: {message}\nregistering a failing {args.test_prefix}{DISCOVERY_FAILED_NAME} '
-                  'entry', file=sys.stderr)
-            write_if_changed(args.output, render_listing_failure(
-                message, every_known_label(accessors, implicit, sources), executable, args.test_prefix,
-                args.base_label))
-            return 0
-        labels = derive_labels(units, accessors, implicit, sources)
-        write_if_changed(args.output, render_ctest(units, labels, executable, args.working_directory.resolve(),
-                                                   args.timeout, args.test_argument, args.test_prefix,
-                                                   args.base_label))
-    except (DiscoveryError, OSError, ValueError) as error:
-        print(f'{tool}: error: {error}', file=sys.stderr)
-        return 1
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(run_cli())
diff --git a/contracts/tools/tests/test_discover_contract_suites.py b/contracts/tools/tests/test_discover_contract_suites.py
deleted file mode 100644
index 59430cace8..0000000000
--- a/contracts/tools/tests/test_discover_contract_suites.py
+++ /dev/null
@@ -1,518 +0,0 @@
-"""Tests for contract test suite discovery and contract labelling."""
-
-from __future__ import annotations
-
-import contextlib
-import importlib.util
-import io
-import os
-import re
-import stat
-import subprocess
-import sys
-import tempfile
-import textwrap
-import unittest
-from pathlib import Path
-from unittest import mock
-
-
-DISCOVERY_PATH = Path(__file__).parents[1] / "discover_contract_suites.py"
-DISCOVERY_SPEC = importlib.util.spec_from_file_location("discover_contract_suites", DISCOVERY_PATH)
-if DISCOVERY_SPEC is None or DISCOVERY_SPEC.loader is None:
-    raise RuntimeError(f"Unable to load discovery script from {DISCOVERY_PATH}")
-DISCOVERY = importlib.util.module_from_spec(DISCOVERY_SPEC)
-sys.modules[DISCOVERY_SPEC.name] = DISCOVERY
-DISCOVERY_SPEC.loader.exec_module(DISCOVERY)
-
-REPOSITORY_ROOT = Path(__file__).resolve().parents[3]
-# A CMake bracket argument ends at the first closing bracket with the same number of `=`.
-BRACKET_ARGUMENT_RE = re.compile(r"\[(=*)\[(.*?)\]\1\]", re.S)
-REPOSITORY_ACCESSOR_HEADERS = [
-    REPOSITORY_ROOT / "contracts" / "tests" / "contracts.hpp.in",
-    REPOSITORY_ROOT / "unittests" / "test_contracts.hpp.in",
-    REPOSITORY_ROOT / "libraries" / "testing" / "contracts.cpp.in",
-]
-
-ACCESSOR_HEADER = """\
-struct contracts {
-   static std::vector<uint8_t> reserve_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.reserv/sysio.reserv.wasm"); }
-   static std::vector<char>    liq_abi() { return read_abi("${CMAKE_BINARY_DIR}/contracts/sysio.liq/sysio.liq.abi"); }
-   static std::vector<uint8_t> liq_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.liq/sysio.liq.wasm"); }
-   static std::vector<uint8_t> opreg_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.opreg/sysio.opreg.wasm"); }
-   static std::vector<uint8_t> token_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/contracts/sysio.token/sysio.token.wasm"); }
-   static std::string          dex_config_dir() { return "${CMAKE_SOURCE_DIR}/etc/config/dex"; }
-   struct util {
-      static std::vector<uint8_t> reject_all_wasm() { return read_wasm("${CMAKE_SOURCE_DIR}/contracts/test_contracts/reject_all.wasm"); }
-   };
-};
-[[maybe_unused]]
-static std::vector<uint8_t> blockinfo_tester_wasm()
-{
-   return sysio::testing::read_wasm(
-      "${CMAKE_BINARY_DIR}/contracts/test_contracts/blockinfo_tester/blockinfo_tester.wasm");
-}
-"""
-
-MACRO_ACCESSOR_HEADER = """\
-#define MAKE_READ_WASM_ABI(CN,C, D)                                                         \\
-   static std::vector<uint8_t> CN ## _wasm() {                                              \\
-      return read("${CMAKE_BINARY_DIR}/" #D "/" #C "/" #C ".wasm");                         \\
-   }
-         MAKE_READ_WASM_ABI(sysio_msig,   sysio.msig,   contracts)
-         MAKE_READ_WASM_ABI(noop,         noop,         unittests/test-contracts)
-         MAKE_READ_WASM_ABI(ibc,          ibc,          unittests/test-contracts/savanna)
-         MAKE_READ_WASM_ABI(fresh,        fresh,        unittests/some-new-directory)
-"""
-
-EMBEDDED_ACCESSOR_HEADER = """\
-MAKE_EMBEDDED_WASM_ABI(sysio_bios,                             sysio.bios, contracts)
-MAKE_EMBEDDED_WASM_ABI(sysio_roa,                              sysio.roa,  contracts)
-"""
-
-
-def dot_listing(root: Path) -> str:
-    """Return a Boost.Test DOT listing whose units are declared in files under root.
-
-    alpha_tests' only case depends on split_case, which beta_tests declares in beta_extra.cpp.
-    """
-    return textwrap.dedent(f"""\
-        Random number generator seeded to 1790706793
-        digraph G {{rankdir=LR;
-        tu1[shape=ellipse,peripheries=2,fontname=Helvetica,color=green,label="Master Test Suite"];
-        {{
-        tu2[shape=Mrecord,fontname=Helvetica,color=green,label="beta_tests|{root}/beta_tests.cpp(20)"];
-        tu1 -> tu2;
-        {{
-        tu65536[shape=Mrecord,fontname=Helvetica,color=green,label="split_case|{root}/beta_extra.cpp(7)|timeout=30"];
-        tu2 -> tu65536;
-        tu3[shape=Mrecord,fontname=Helvetica,color=yellow,label="nested_tests|{root}/beta_nested.cpp(3)|labels: @slow"];
-        tu2 -> tu3;
-        {{
-        tu65537[shape=Mrecord,fontname=Helvetica,color=green,label="deep_case|{root}/beta_nested.cpp(5)"];
-        tu3 -> tu65537;
-        }}
-        }}
-        tu4[shape=Mrecord,fontname=Helvetica,color=yellow,label="alpha_tests|{root}/alpha_tests.cpp(10)"];
-        tu1 -> tu4;
-        {{
-        tu65538[shape=Mrecord,fontname=Helvetica,color=green,label="first_case|{root}/alpha_tests.cpp(12)"];
-        tu4 -> tu65538;
-        tu65538 -> tu65536[color=red,style=dotted,constraint=false];
-        }}
-        tu65539[shape=Mrecord,fontname=Helvetica,color=green,label="loose_case|{root}/loose.cpp(1)"];
-        tu1 -> tu65539;
-        }}
-        }}
-        """)
-
-
-class TemporaryTreeTestCase(unittest.TestCase):
-    """Provide a temporary directory and a helper that writes files into it."""
-
-    def setUp(self) -> None:
-        """Create the temporary tree."""
-        self.temporary_directory = tempfile.TemporaryDirectory()
-        self.root = Path(self.temporary_directory.name).resolve()
-
-    def tearDown(self) -> None:
-        """Remove the temporary tree."""
-        self.temporary_directory.cleanup()
-
-    def write(self, relative: str, content: str | bytes) -> Path:
-        """Write content to a file under the temporary tree and return its path."""
-        path = self.root / relative
-        path.parent.mkdir(parents=True, exist_ok=True)
-        if isinstance(content, bytes):
-            path.write_bytes(content)
-        else:
-            path.write_text(content, encoding="utf-8")
-        return path
-
-
-class ParseDotTests(unittest.TestCase):
-    """Verify the Boost.Test DOT inventory parser."""
-
-    def test_top_level_units_carry_their_subtrees_and_dependencies_files(self) -> None:
-        """Only the master suite's children become units, each with the files of its subtree and dependencies."""
-        units = DISCOVERY.parse_dot(dot_listing(Path("/src")))
-        self.assertEqual([unit.name for unit in units], ["alpha_tests", "beta_tests", "loose_case"])
-        by_name = {unit.name: unit for unit in units}
-        self.assertEqual(by_name["beta_tests"].files,
-                         {"/src/beta_tests.cpp", "/src/beta_extra.cpp", "/src/beta_nested.cpp"})
-        self.assertEqual(by_name["alpha_tests"].files, {"/src/alpha_tests.cpp", "/src/beta_extra.cpp"})
-        self.assertEqual(by_name["loose_case"].files, {"/src/loose.cpp"})
-
-    def test_dependency_on_the_master_suite_brings_in_every_file(self) -> None:
-        """Depending on the master suite runs the whole executable, so every declared file counts."""
-        listing = dot_listing(Path("/src")).replace(
-            "tu1 -> tu65539;\n", "tu1 -> tu65539;\ntu65539 -> tu1[color=red,style=dotted,constraint=false];\n")
-        by_name = {unit.name: unit for unit in DISCOVERY.parse_dot(listing)}
-        self.assertEqual(by_name["loose_case"].files, {"/src/alpha_tests.cpp", "/src/beta_tests.cpp",
-                                                        "/src/beta_extra.cpp", "/src/beta_nested.cpp", "/src/loose.cpp"})
-
-    def test_default_status_follows_the_unit_color(self) -> None:
-        """A unit Boost reports as disabled by default (yellow) is not enabled."""
-        by_name = {unit.name: unit for unit in DISCOVERY.parse_dot(dot_listing(Path("/src")))}
-        self.assertFalse(by_name["alpha_tests"].enabled)
-        self.assertTrue(by_name["beta_tests"].enabled)
-        self.assertTrue(by_name["loose_case"].enabled)
-
-    def test_missing_master_suite_is_an_error(self) -> None:
-        """A listing without the master suite is rejected rather than read as empty."""
-        with self.assertRaises(DISCOVERY.DiscoveryError):
-            DISCOVERY.parse_dot("digraph G {rankdir=LR;\n}\n")
-
-    def test_unit_without_source_location_is_an_error(self) -> None:
-        """Every unit must name its declaring file, which labelling depends on."""
-        listing = ('tu1[shape=ellipse,peripheries=2,fontname=Helvetica,color=green,label="Master Test Suite"];\n'
-                   'tu2[shape=Mrecord,fontname=Helvetica,color=green,label="alpha_tests"];\n'
-                   'tu1 -> tu2;\n')
-        with self.assertRaises(DISCOVERY.DiscoveryError):
-            DISCOVERY.parse_dot(listing)
-
-    def test_edge_to_undeclared_unit_is_an_error(self) -> None:
-        """A parent edge must point at a declared unit."""
-        listing = ('tu1[shape=ellipse,peripheries=2,fontname=Helvetica,color=green,label="Master Test Suite"];\n'
-                   'tu1 -> tu9;\n')
-        with self.assertRaises(DISCOVERY.DiscoveryError):
-            DISCOVERY.parse_dot(listing)
-
-
-class AccessorLabelTests(TemporaryTreeTestCase):
-    """Verify the accessor-name to contract-label map."""
-
-    def test_function_and_macro_accessors_map_to_contract_labels(self) -> None:
-        """Explicit functions resolve through their artifact paths; macro invocations through the contract they name."""
-        headers = [self.write("contracts.hpp.in", ACCESSOR_HEADER),
-                   self.write("test_contracts.hpp.in", MACRO_ACCESSOR_HEADER),
-                   self.write("contracts.cpp.in", EMBEDDED_ACCESSOR_HEADER)]
-        accessors = DISCOVERY.load_accessor_labels(headers)
-        self.assertEqual(accessors["reserve_wasm"], {"sysio.reserv"})
-        self.assertEqual(accessors["liq_abi"], {"sysio.liq"})
-        self.assertEqual(accessors["reject_all_wasm"], {"test.reject_all"})
-        self.assertEqual(accessors["blockinfo_tester_wasm"], {"test.blockinfo_tester"})
-        self.assertEqual(accessors["sysio_msig_wasm"], {"sysio.msig"})
-        self.assertEqual(accessors["sysio_msig_abi"], {"sysio.msig"})
-        self.assertEqual(accessors["noop_wasm"], {"test.noop"})
-        self.assertEqual(accessors["ibc_wasm"], {"test.ibc"})
-        self.assertEqual(accessors["fresh_abi"], {"test.fresh"})
-        self.assertEqual(accessors["sysio_roa_abi"], {"sysio.roa"})
-        self.assertNotIn("CN_wasm", accessors)
-        self.assertNotIn("dex_config_dir", accessors)
-
-    def test_accessor_definitions_in_any_function_form_are_mapped(self) -> None:
-        """Parameters, specifiers and trailing return types do not hide a definition from the map."""
-        header = self.write("contracts.hpp.in", textwrap.dedent("""\
-            static std::vector<uint8_t> foo_wasm() noexcept { return read_wasm("/b/contracts/sysio.foo/sysio.foo.wasm"); }
-            static auto bar_wasm() -> std::vector<uint8_t> { return read_wasm("/b/contracts/sysio.bar/sysio.bar.wasm"); }
-            static std::vector<uint8_t> baz_wasm(bool v2) { return read_wasm("/b/contracts/sysio.baz/sysio.baz.wasm"); }
-            """))
-        accessors = DISCOVERY.load_accessor_labels([header])
-        self.assertEqual(accessors, {"foo_wasm": {"sysio.foo"}, "bar_wasm": {"sysio.bar"}, "baz_wasm": {"sysio.baz"}})
-
-    def test_accessor_without_a_contract_path_is_an_error(self) -> None:
-        """An accessor the label rules cannot map fails discovery instead of silently dropping a label."""
-        header = self.write("contracts.hpp.in",
-                            'static auto fixture_wasm() noexcept -> bytes { return read_wasm("/data/fixture.wasm"); }\n')
-        with self.assertRaisesRegex(DISCOVERY.DiscoveryError, "fixture_wasm"):
-            DISCOVERY.load_accessor_labels([header])
-
-    def test_accessor_the_patterns_cannot_parse_is_an_error(self) -> None:
-        """Every `*_wasm(` in an accessor header other than a loader call must map, whatever its parameter list."""
-        header = self.write("contracts.hpp.in", textwrap.dedent("""\
-            static std::vector<uint8_t> token_wasm() { return read_wasm("/b/contracts/sysio.token/sysio.token.wasm"); }
-            static std::vector<uint8_t> qux_wasm(std::function<void()> cb) { return read_wasm("/b/contracts/sysio.qux/sysio.qux.wasm"); }
-            """))
-        with self.assertRaisesRegex(DISCOVERY.DiscoveryError, "qux_wasm"):
-            DISCOVERY.load_accessor_labels([header])
-
-    def test_accessor_names_in_comments_are_ignored(self) -> None:
-        """A comment naming tester calls such as set_abi() is documentation, not an accessor to map."""
-        header = self.write("contracts.hpp.in", "/// Hand any *_abi() result to set_abi() via .data().\n" + ACCESSOR_HEADER)
-        self.assertEqual(DISCOVERY.load_accessor_labels([header])["liq_abi"], {"sysio.liq"})
-
-    def test_header_without_accessors_is_an_error(self) -> None:
-        """Pointing discovery at the wrong header fails instead of producing unlabelled entries."""
-        with self.assertRaises(DISCOVERY.DiscoveryError):
-            DISCOVERY.load_accessor_labels([self.write("empty.hpp.in", "#pragma once\n")])
-
-    def test_repository_accessor_headers_map_every_accessor(self) -> None:
-        """The real accessor headers parse, and every accessor they define maps to its contract."""
-        accessors = DISCOVERY.load_accessor_labels(REPOSITORY_ACCESSOR_HEADERS)
-        self.assertEqual(accessors["reserve_wasm"], {"sysio.reserv"})
-        self.assertEqual(accessors["system_abi"], {"sysio.system"})
-        self.assertEqual(accessors["badtoken_wasm"], {"test.badtoken"})
-        self.assertEqual(accessors["reenter_deposit_wasm"], {"test.reenter_deposit"})
-        self.assertEqual(accessors["sendinline_wasm"], {"test.sendinline"})
-        self.assertEqual(accessors["sysio_system_wasm"], {"sysio.system"})
-        self.assertEqual(accessors["noop_wasm"], {"test.noop"})
-        self.assertEqual(accessors["ibc_wasm"], {"test.ibc"})
-        self.assertEqual(accessors["sysio_bios_wasm"], {"sysio.bios"})
-        self.assertEqual(accessors["reject_all_wasm"], {"test.reject_all"})
-
-
-class StripCommentsTests(unittest.TestCase):
-    """Verify comment removal keeps code, literals, and line numbering."""
-
-    def test_comments_are_removed_and_lines_preserved(self) -> None:
-        """Line and block comments disappear; the newline count is unchanged."""
-        text = "a(); // contracts::liq_wasm()\n/* contracts::token_wasm()\n */ b();\n"
-        stripped = DISCOVERY.strip_comments(text)
-        self.assertNotIn("liq_wasm", stripped)
-        self.assertNotIn("token_wasm", stripped)
-        self.assertIn("a();", stripped)
-        self.assertIn("b();", stripped)
-        self.assertEqual(stripped.count("\n"), text.count("\n"))
-
-    def test_comment_markers_inside_literals_are_code(self) -> None:
-        """`//` and `/*` inside string, raw-string, and character literals do not start comments."""
-        text = ('auto u = "http://x"; contracts::liq_wasm();\n'
-                'auto r = R"x(/* not a comment )x"; contracts::token_wasm();\n'
-                "char c = '/'; contracts::opreg_wasm();\n")
-        stripped = DISCOVERY.strip_comments(text)
-        for accessor in ("liq_wasm", "token_wasm", "opreg_wasm"):
-            self.assertIn(accessor, stripped)
-
-    def test_digit_separator_does_not_open_a_character_literal(self) -> None:
-        """`2'000'000` leaves the trailing comment recognisable as a comment."""
-        stripped = DISCOVERY.strip_comments("f(int64_t(2'000'000)); // contracts::liq_wasm()\ng();\n")
-        self.assertNotIn("liq_wasm", stripped)
-        self.assertIn("g();", stripped)
-
-
-class ScanLabelsTests(TemporaryTreeTestCase):
-    """Verify contract labels are derived from test sources and their local headers."""
-
-    def setUp(self) -> None:
-        """Write the accessor header every scan resolves names against."""
-        super().setUp()
-        self.accessors = DISCOVERY.load_accessor_labels([self.write("contracts.hpp.in", ACCESSOR_HEADER)])
-
-    def test_accessor_calls_and_qualified_references_label_the_suite(self) -> None:
-        """Calls and qualified references count; unknown `*_wasm` helpers and comments do not."""
-        source = self.write("suite.cpp", textwrap.dedent("""\
-            void deploy() {
-               set_code(LIQ, contracts::liq_wasm());
-               deploy_with(&contracts::reserve_wasm);
-               set_code(X, notify_system_account_wasm());
-               // set_code(T, contracts::token_wasm());
-            }
-            """))
-        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors), {"sysio.liq", "sysio.reserv"})
-
-    def test_contract_header_includes_label_the_suite(self) -> None:
-        """Contract headers compiled into the test and test-contract headers count, however they are reached."""
-        source = self.write("tests/suite.cpp", textwrap.dedent("""\
-            #include <sysio.opp.common/amm_math.hpp>
-            #include "../sysio.councl/include/sysio.councl/council_math.hpp"
-            #include "../../contracts/sysio.roa/include/sysio.roa/roa.hpp"
-            #include <test-contracts/noop/noop.hpp>
-            #include "../test_contracts/blockinfo_tester/blockinfo_tester.hpp"
-            #include <test_contracts/badtoken/badtoken.hpp>
-            #include <test_contracts.hpp>
-            #include <sysio/opp/opp.hpp>
-            #include "contracts.hpp"
-            """))
-        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors),
-                         {"sysio.opp.common", "sysio.councl", "sysio.roa", "test.blockinfo_tester", "test.badtoken",
-                          "test.noop"})
-
-    def test_local_headers_are_followed_transitively_and_cycles_terminate(self) -> None:
-        """A deploy helper two headers away still labels the suite, and an include cycle ends."""
-        self.write("tester.hpp", '#include "support.hpp"\nvoid deploy_opreg_once() { contracts::opreg_wasm(); }\n')
-        self.write("support.hpp", '#include "tester.hpp"\nvoid reject() { contracts::util::reject_all_wasm(); }\n')
-        source = self.write("suite.cpp", '#include "tester.hpp"\n')
-        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors), {"sysio.opreg", "test.reject_all"})
-
-    def test_undecodable_bytes_do_not_stop_the_scan(self) -> None:
-        """A source with bytes that are not UTF-8 is still scanned."""
-        source = self.write("suite.cpp", b"// \xff\xfe latin-1 comment\nvoid f() { contracts::liq_wasm(); }\n")
-        self.assertEqual(DISCOVERY.scan_labels({source}, self.accessors), {"sysio.liq"})
-
-    def test_repository_suite_reaches_opreg_through_its_tester_header(self) -> None:
-        """getpeerkeys_tests deploys sysio.opreg only through sysio.system_tester.hpp's deploy_opreg_once."""
-        accessors = DISCOVERY.load_accessor_labels(REPOSITORY_ACCESSOR_HEADERS)
-        source = REPOSITORY_ROOT / "contracts" / "tests" / "getpeerkeys_tests.cpp"
-        self.assertIn("sysio.opreg", DISCOVERY.scan_labels({source}, accessors))
-
-
-class RenderTests(TemporaryTreeTestCase):
-    """Verify the generated CTest script."""
-
-    def test_entries_are_ordered_labelled_and_disabled_as_declared(self) -> None:
-        """Each unit becomes add_test plus properties; a default-disabled unit is registered DISABLED."""
-        units = [DISCOVERY.TestUnit("alpha_tests", False, {"/src/a.cpp"}),
-                 DISCOVERY.TestUnit("beta_tests", True, {"/src/b.cpp"})]
-        labels = {"alpha_tests": set(), "beta_tests": {"sysio.token", "sysio.liq"}}
-        script = DISCOVERY.render_ctest(units, labels, Path("/build/contracts_unit_test"), Path("/build"), 2700,
-                                        ["--report_level=detailed"], "contract.", "contract")
-        self.assertEqual(script.splitlines()[1:], [
-            "add_test([[contract.alpha_tests]] [[/build/contracts_unit_test]] [[--run_test=alpha_tests]] "
-            "[[--report_level=detailed]])",
-            "set_tests_properties([[contract.alpha_tests]] PROPERTIES WORKING_DIRECTORY [[/build]] TIMEOUT 2700 "
-            "LABELS [[contract]] DISABLED TRUE)",
-            "add_test([[contract.beta_tests]] [[/build/contracts_unit_test]] [[--run_test=beta_tests]] "
-            "[[--report_level=detailed]])",
-            "set_tests_properties([[contract.beta_tests]] PROPERTIES WORKING_DIRECTORY [[/build]] TIMEOUT 2700 "
-            "LABELS [[contract;sysio.liq;sysio.token]])",
-        ])
-
-    def test_bracket_quoting_outgrows_its_content(self) -> None:
-        """A value containing, or ending in the start of, a closing bracket gets a longer bracket."""
-        self.assertEqual(DISCOVERY.bracket("plain"), "[[plain]]")
-        self.assertEqual(DISCOVERY.bracket("a]]b"), "[=[a]]b]=]")
-        self.assertEqual(DISCOVERY.bracket("a]]b]=]c"), "[==[a]]b]=]c]==]")
-        self.assertEqual(DISCOVERY.bracket("a]"), "[=[a]]=]")
-        self.assertEqual(DISCOVERY.bracket("a]="), "[[a]=]]")
-        self.assertEqual(DISCOVERY.bracket("b]=]"), "[==[b]=]]==]")
-
-    def test_unchanged_script_is_not_rewritten(self) -> None:
-        """Identical content leaves the file (and its timestamp) alone; new content is readable by others."""
-        output = self.root / "suites.cmake"
-        DISCOVERY.write_if_changed(output, "first\n")
-        self.assertEqual(stat.S_IMODE(output.stat().st_mode), DISCOVERY.GENERATED_FILE_MODE)
-        os.utime(output, (1, 1))
-        DISCOVERY.write_if_changed(output, "first\n")
-        self.assertEqual(output.stat().st_mtime, 1)
-        DISCOVERY.write_if_changed(output, "second\n")
-        self.assertEqual(output.read_text(encoding="utf-8"), "second\n")
-
-    def test_failed_write_leaves_no_temporary_file(self) -> None:
-        """If the final rename fails, the previous script stays and no temporary file is left behind."""
-        output = self.root / "suites.cmake"
-        DISCOVERY.write_if_changed(output, "first\n")
-        with mock.patch.object(DISCOVERY.os, "replace", side_effect=OSError("disk full")):
-            with self.assertRaises(OSError):
-                DISCOVERY.write_if_changed(output, "second\n")
-        self.assertEqual([path.name for path in self.root.iterdir()], ["suites.cmake"])
-        self.assertEqual(output.read_text(encoding="utf-8"), "first\n")
-
-
-class CommandLineTests(TemporaryTreeTestCase):
-    """Run the script end to end against a stand-in test executable."""
-
-    def make_executable(self, listing: str, exit_code: int = 0) -> Path:
-        """Write a stand-in executable that prints the listing the way Boost does, to its report stream."""
-        self.write("listing.dot", listing)
-        expected_arguments = " ".join(DISCOVERY.LIST_CONTENT_ARGUMENTS)
-        executable = self.write("build/contracts_unit_test", textwrap.dedent(f"""\
-            #!/bin/sh
-            [ "$*" = "{expected_arguments}" ] || exit 64
-            echo "Random number generator seeded to 1"
-            cat "{self.root / 'listing.dot'}" >&2
-            exit {exit_code}
-            """))
-        executable.chmod(0o755)
-        return executable
-
-    def run_cli(self, executable: Path, *extra: str, sources: list[str] | None = None) -> tuple[int, str]:
-        """Invoke the command-line entry point with the arguments CMake passes; return its code and stderr."""
-        if sources is None:
-            sources = [str(path) for path in sorted(self.root.glob("*.cpp"))]
-        errors = io.StringIO()
-        with contextlib.redirect_stderr(errors):
-            code = DISCOVERY.run_cli([
-                "--executable", str(executable), "--working-directory", str(self.root / "build"),
-                "--test-sources", *sources, "--accessor-header", str(self.root / "contracts.hpp.in"),
-                "--timeout", "2700", "--test-argument=--report_level=detailed",
-                "--output", str(self.root / "suites.cmake"), *extra])
-        return code, errors.getvalue()
-
-    def script(self) -> str:
-        """The generated CTest script."""
-        return (self.root / "suites.cmake").read_text(encoding="utf-8")
-
-    def write_sources(self) -> None:
-        """Write the sources the stand-in listing declares its units in."""
-        self.write("contracts.hpp.in", ACCESSOR_HEADER)
-        self.write("beta_tests.cpp", "void f() { contracts::liq_wasm(); }\n")
-        self.write("beta_extra.cpp", "void g() { contracts::token_wasm(); }\n")
-        self.write("beta_nested.cpp", "#include <sysio.opp.common/twap.hpp>\n")
-        self.write("alpha_tests.cpp", "void h() {}\n")
-        self.write("loose.cpp", "void i() { contracts::opreg_wasm(); }\n")
-
-    def test_every_top_level_unit_is_registered_with_its_labels(self) -> None:
-        """Suites, their split and nested parts, dependencies, and a file-scope case are registered and labelled."""
-        self.write_sources()
-        self.assertEqual(self.run_cli(self.make_executable(dot_listing(self.root))), (0, ""))
-        script = self.script()
-        self.assertIn("LABELS [[contract;sysio.token]] DISABLED TRUE", script)
-        self.assertIn("LABELS [[contract;sysio.liq;sysio.opp.common;sysio.token]])", script)
-        self.assertIn("add_test([[contract.loose_case]]", script)
-        self.assertIn("LABELS [[contract;sysio.opreg]])", script)
-        self.assertEqual(script.count("add_test("), 3)
-
-    def test_contracts_deployed_by_default_test_setup_label_every_entry(self) -> None:
-        """Every entry carries the contracts from the implicit accessor header."""
-        self.write_sources()
-        self.write("contracts.cpp.in", EMBEDDED_ACCESSOR_HEADER)
-        code, _ = self.run_cli(self.make_executable(dot_listing(self.root)),
-                               "--implicit-accessor-header", str(self.root / "contracts.cpp.in"))
-        self.assertEqual(code, 0)
-        label_lines = [line for line in self.script().splitlines() if line.startswith("set_tests_properties(")]
-        self.assertEqual(len(label_lines), 3)
-        for line in label_lines:
-            self.assertIn(";sysio.bios;", line)
-            self.assertIn(";sysio.roa", line)
-
-    def test_rewritten_locations_match_the_executables_sources(self) -> None:
-        """Relative (ccache base_dir) and prefix-mapped locations resolve to the sources that were compiled."""
-        self.write_sources()
-        for root in (Path(".."), Path("../../.."), Path("/usr/src/wire-sysio/contracts/tests")):
-            self.assertEqual(self.run_cli(self.make_executable(dot_listing(root))), (0, ""), root)
-            self.assertIn("LABELS [[contract;sysio.liq;sysio.opp.common;sysio.token]])", self.script())
-
-    def test_unresolvable_location_gets_every_label_and_a_warning(self) -> None:
-        """A unit whose sources cannot be found is over-labelled, not dropped, and the build goes on."""
-        self.write_sources()
-        (self.root / "loose.cpp").unlink()
-        code, errors = self.run_cli(self.make_executable(dot_listing(self.root)))
-        self.assertEqual(code, 0)
-        self.assertIn("cannot find", errors)
-        loose = next(line for line in self.script().splitlines()
-                     if line.startswith("set_tests_properties([[contract.loose_case]]"))
-        for label in ("sysio.liq", "sysio.opp.common", "sysio.opreg", "sysio.reserv", "sysio.token", "test.reject_all"):
-            self.assertIn(label, loose)
-
-    def test_fallback_labels_come_from_every_source_when_nothing_resolves(self) -> None:
-        """With no location resolvable, a contract reached only through an include still labels every unit."""
-        self.write("contracts.hpp.in", ACCESSOR_HEADER)
-        other = self.write("other_tests.cpp", "#include <sysio.opp.common/twap.hpp>\n")
-        code, errors = self.run_cli(self.make_executable(dot_listing(Path("/nonexistent"))), sources=[str(other)])
-        self.assertEqual(code, 0)
-        self.assertEqual(errors.count("warning: cannot find"), 3)
-        for line in self.script().splitlines():
-            if line.startswith("set_tests_properties("):
-                self.assertIn(";sysio.opp.common;", line)
-
-    def test_failing_listing_registers_a_failing_entry(self) -> None:
-        """A test executable that cannot list itself becomes one failing entry carrying its error; the build goes on."""
-        self.write_sources()
-        code, errors = self.run_cli(self.make_executable(dot_listing(self.root), exit_code=3))
-        self.assertEqual(code, 0)
-        self.assertIn("exited with 3", errors)
-        script = self.script()
-        self.assertEqual(script.count("add_test("), 1)
-        add_test = script[script.index("add_test("):script.index("set_tests_properties(")]
-        name, *command = [match.group(2) for match in BRACKET_ARGUMENT_RE.finditer(add_test)]
-        self.assertEqual(name, "contract.DISCOVERY_FAILED")
-        result = subprocess.run(command, capture_output=True, text=True, check=False)
-        self.assertEqual(result.returncode, 1)
-        self.assertIn("exited with 3", result.stderr)
-        self.assertIn("To retry discovery", result.stderr)
-        labels = script[script.index("LABELS"):]
-        for label in ("contract;", "sysio.liq", "sysio.opp.common", "sysio.opreg", "test.reject_all"):
-            self.assertIn(label, labels)
-
-    def test_malformed_listing_fails_discovery(self) -> None:
-        """A listing discovery cannot parse is a fault in discovery, so the build fails."""
-        self.write_sources()
-        code, errors = self.run_cli(self.make_executable("digraph G {rankdir=LR;\n}\n"))
-        self.assertEqual(code, 1)
-        self.assertIn("no master test suite", errors)
-        self.assertFalse((self.root / "suites.cmake").exists())
-
-
-if __name__ == "__main__":
-    unittest.main()
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)

From a1a08439aaf0b7eca3f695ba75f34ff801b5dcba Mon Sep 17 00:00:00 2001
From: kevin Heifner <kevin@wire.network>
Date: Wed, 30 Sep 2026 10:24:02 -0500
Subject: [PATCH 3/4] cmake: act on the discovery lock result and thread the
 config through its test

A failed file(LOCK) was ignored, so a ctest process that timed out waiting for another's discovery went on to rewrite the shared listing and tests files without owning the lock. It now keeps the current list and registers a failing <target>_DISCOVERY_FAILED entry naming the lock error, and it waits 180 s, longer than one discovery can take, so a waiter outlasts a live holder. The regression test holds the lock from a second process and checks both.

Under a multi-config generator the regression test's nested project was multi-config too, but it built and ran ctest without a configuration, so the generated dispatcher included <target>_discovery_1_include-.cmake. The test now receives $<CONFIG> and passes it to the nested build and every ctest call, and pins the stand-in executable's output directory so multi-config generators add no configuration subdirectory.
---
 CMakeLists.txt                             |  2 +-
 cmake/boost-test-discovery-impl.cmake      | 27 ++++++++---
 cmake/test/boost-test-discovery-test.cmake | 52 +++++++++++++++++++---
 3 files changed, 66 insertions(+), 15 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d600fe0c9..502056f221 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -49,7 +49,7 @@ 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}
+           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)
diff --git a/cmake/boost-test-discovery-impl.cmake b/cmake/boost-test-discovery-impl.cmake
index 78796f4066..c8b20134ba 100644
--- a/cmake/boost-test-discovery-impl.cmake
+++ b/cmake/boost-test-discovery-impl.cmake
@@ -6,6 +6,8 @@ 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>")
 
@@ -40,14 +42,25 @@ endfunction()
 
 function(boost_test_discover_tests_impl)
    # Lists arrive as single `;`-joined arguments; the ${ARGN} form splits them where PARSE_ARGV would not.
-   cmake_parse_arguments(arg ""
-      "EXECUTABLE;TESTS_FILE;INCLUDE_FILE;FAILURE_NAME;CMAKE_COMMAND;WORKING_DIRECTORY;NAME;INCLUDE;EXCLUDE"
-      "NAME_STRIP;RUNTIMES;ARGS;PROPERTIES;COST_BY_NAME" ${ARGN})
+   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. The script is stale
-   # when the executable or the include script is newer (a tie counts) or this implementation changed.
-   file(LOCK "${arg_TESTS_FILE}.lock" GUARD FUNCTION TIMEOUT ${_BOOST_TEST_LIST_TIMEOUT_SECONDS}
-        RESULT_VARIABLE lock_result)
+   # 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
diff --git a/cmake/test/boost-test-discovery-test.cmake b/cmake/test/boost-test-discovery-test.cmake
index be3af9b0c9..9fb9520038 100644
--- a/cmake/test/boost-test-discovery-test.cmake
+++ b/cmake/test/boost-test-discovery-test.cmake
@@ -126,18 +126,55 @@ 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 and CXX let the
-# ctest entry build it the way the enclosing build is built.
+# 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; a multi-config generator needs CONFIG for the nested
+# build and every ctest call.
 get_filename_component(cmake_bin "${CMAKE_COMMAND}" DIRECTORY)
 set(ctest_command "${cmake_bin}/ctest")
 if(NOT GENERATOR)
    set(GENERATOR Ninja)
 endif()
+set(build_config "")
+set(ctest_config "")
+if(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" [==[
@@ -161,6 +198,7 @@ file(WRITE "${project}/CMakeLists.txt"
    "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")
 
@@ -195,11 +233,11 @@ if(CXX)
 endif()
 set(build "${work}/build")
 run("configure" "${CMAKE_COMMAND}" -S "${project}" -B "${build}" -G "${GENERATOR}" ${compiler})
-listed_tests(tests "${build}")
+listed_tests(tests "${build}" ${ctest_config})
 expect_equal("${tests}" "fake_NOT_BUILT" "before the executable is built")
 
-run("build" "${CMAKE_COMMAND}" --build "${build}")
-listed_tests(tests "${build}")
+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")
@@ -212,13 +250,13 @@ expect_equal("${arguments}" "--run_test=one_tests;--x;--;--a" "discovered comman
 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 WORKING_DIRECTORY "${build}")
+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}")
+listed_tests(tests "${build}" ${ctest_config})
 list(LENGTH tests count)
 expect_equal("${count}" "6" "after the executable changed")
 

From 0836c39832daa1d84df9e1f1ff5e75173725c7e5 Mon Sep 17 00:00:00 2001
From: kevin Heifner <kevin@wire.network>
Date: Wed, 30 Sep 2026 13:27:26 -0500
Subject: [PATCH 4/4] cmake: pass the configuration to the discovery test's
 nested configure

Under a multi-config generator with a custom configuration such as ASan, the regression test's nested project kept the generator's default configurations, so ctest -C ASan included a <target>_discovery_1_include-ASan.cmake that was never generated. The nested configure now gets CMAKE_CONFIGURATION_TYPES from the configuration under test.
---
 cmake/test/boost-test-discovery-test.cmake | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/cmake/test/boost-test-discovery-test.cmake b/cmake/test/boost-test-discovery-test.cmake
index 9fb9520038..c34e034851 100644
--- a/cmake/test/boost-test-discovery-test.cmake
+++ b/cmake/test/boost-test-discovery-test.cmake
@@ -162,16 +162,18 @@ 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; a multi-config generator needs CONFIG for the nested
-# build and every ctest call.
+# 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()
@@ -232,7 +234,7 @@ if(CXX)
    set(compiler "-DCMAKE_CXX_COMPILER=${CXX}")
 endif()
 set(build "${work}/build")
-run("configure" "${CMAKE_COMMAND}" -S "${project}" -B "${build}" -G "${GENERATOR}" ${compiler})
+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")