diff --git a/CMakeLists.txt b/CMakeLists.txt
index e724b4dd..d82124a0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,11 +1,11 @@
-cmake_minimum_required(VERSION 3.26)
+cmake_minimum_required(VERSION 3.28)
 
-# NOTE: update executable name in .github/workflows/cmake.yml:25 when changing executable name in this file
+# NOTE: update executable name in .github/workflows/cmake.yml when changing executable name in this file
 # for now, the project name is used as the executable name
 set(MAIN_PROJECT_NAME "oop")
 set(MAIN_EXECUTABLE_NAME "${MAIN_PROJECT_NAME}")
-set(MAIN_PROJECT_LIB_NAME "${MAIN_PROJECT_NAME}_lib")
-set(MAIN_PROJECT_NO_SAN_LIB_NAME "${MAIN_PROJECT_NAME}_nslib")
+set(MAIN_LIBRARY_NAME "${MAIN_PROJECT_NAME}_lib")
+set(MAIN_LIBRARY_NO_SAN_NAME "${MAIN_PROJECT_NAME}_nslib")
 set(TESTS_PROJECT_NAME "${MAIN_PROJECT_NAME}_test")
 set(TESTS_EXECUTABLE_NAME "${TESTS_PROJECT_NAME}")
 
@@ -22,9 +22,10 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 include(cmake/Options.cmake)
 include(cmake/CompilerFlags.cmake)
 include(cmake/CopyHelper.cmake)
+include(cmake/RegisterTests.cmake)
 
+# include(CTest) declares BUILD_TESTING (default ON)
 include(CTest)
-enable_testing()
 ###############################################################################
 
 # external dependencies with FetchContent
@@ -55,15 +56,15 @@ enable_testing()
 
 ###############################################################################
 
-# NOTE: update executable name in .github/workflows/cmake.yml:25 when changing name here
-add_library(${MAIN_PROJECT_LIB_NAME})
-target_sources(${MAIN_PROJECT_LIB_NAME}
+# NOTE: update executable name in .github/workflows/cmake.yml when changing name here
+add_library(${MAIN_LIBRARY_NAME} STATIC)
+target_sources(${MAIN_LIBRARY_NAME}
     PRIVATE
         src/exemplu_test_oop/BankAccount.cpp
 )
 
-add_library(${MAIN_PROJECT_NO_SAN_LIB_NAME})
-target_sources(${MAIN_PROJECT_NO_SAN_LIB_NAME}
+add_library(${MAIN_LIBRARY_NO_SAN_NAME} STATIC)
+target_sources(${MAIN_LIBRARY_NO_SAN_NAME}
     PRIVATE
         src/exemplu_test_oop/BankAccount.cpp
 )
@@ -80,34 +81,34 @@ target_sources(${MAIN_EXECUTABLE_NAME}
 
 # NOTE: Add all defined targets (e.g. executables, libraries, etc. )
 # NOTE: RUN_SANITIZERS is optional, if it's not present it will default to true
-set_compiler_flags(RUN_SANITIZERS ${USE_ASAN} TARGET_NAMES ${MAIN_EXECUTABLE_NAME} ${MAIN_PROJECT_LIB_NAME})
-set_compiler_flags(RUN_SANITIZERS FALSE TARGET_NAMES ${MAIN_PROJECT_NO_SAN_LIB_NAME})
+set_compiler_flags(RUN_SANITIZERS ${USE_ASAN} TARGET_NAMES ${MAIN_EXECUTABLE_NAME} ${MAIN_LIBRARY_NAME})
+set_compiler_flags(RUN_SANITIZERS FALSE TARGET_NAMES ${MAIN_LIBRARY_NO_SAN_NAME})
 # set_compiler_flags(TARGET_NAMES ${MAIN_EXECUTABLE_NAME} ${FOO} ${BAR})
 # where ${FOO} and ${BAR} represent additional executables or libraries
 # you want to compile with the set compiler flags
 
 ###############################################################################
 
-target_include_directories(${MAIN_PROJECT_LIB_NAME} PUBLIC
+target_include_directories(${MAIN_LIBRARY_NAME} PUBLIC
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
 )
-target_include_directories(${MAIN_PROJECT_NO_SAN_LIB_NAME} PUBLIC
+target_include_directories(${MAIN_LIBRARY_NO_SAN_NAME} PUBLIC
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
 )
 target_include_directories(${MAIN_EXECUTABLE_NAME} PUBLIC
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
 )
-target_include_directories(${MAIN_PROJECT_LIB_NAME} SYSTEM PRIVATE
+target_include_directories(${MAIN_LIBRARY_NAME} SYSTEM PRIVATE
     ${CMAKE_SOURCE_DIR}/ext
 )
-target_include_directories(${MAIN_PROJECT_NO_SAN_LIB_NAME} SYSTEM PRIVATE
+target_include_directories(${MAIN_LIBRARY_NO_SAN_NAME} SYSTEM PRIVATE
     ${CMAKE_SOURCE_DIR}/ext
 )
 target_include_directories(${MAIN_EXECUTABLE_NAME} SYSTEM PRIVATE
     ${CMAKE_SOURCE_DIR}/ext
 )
 
-target_link_libraries(${MAIN_EXECUTABLE_NAME} PRIVATE ${MAIN_PROJECT_LIB_NAME})
+target_link_libraries(${MAIN_EXECUTABLE_NAME} PRIVATE ${MAIN_LIBRARY_NAME})
 
 ###############################################################################
 
@@ -119,26 +120,14 @@ target_link_libraries(${MAIN_EXECUTABLE_NAME} PRIVATE ${MAIN_PROJECT_LIB_NAME})
 
 ###############################################################################
 
-set(TEST_SOURCES_DIR ${CMAKE_SOURCE_DIR}/tests)
-set(BOOST_UT_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/ext/include/boost")
-
-add_executable(${TESTS_EXECUTABLE_NAME}
-    ${TEST_SOURCES_DIR}/main.cpp
-    ${TEST_SOURCES_DIR}/test_oop.cpp
-    ${TEST_SOURCES_DIR}/test_simplu.cpp
-)
-
-target_link_libraries(${TESTS_EXECUTABLE_NAME} PRIVATE ${MAIN_PROJECT_NO_SAN_LIB_NAME})
-target_include_directories(${TESTS_EXECUTABLE_NAME} SYSTEM PRIVATE ${BOOST_UT_INCLUDE_DIR})
-
-set_compiler_flags(RUN_SANITIZERS FALSE TARGET_NAMES ${TESTS_EXECUTABLE_NAME})
-
-add_test(NAME ${TESTS_EXECUTABLE_NAME} COMMAND ${TESTS_PROJECT_NAME})
+if(BUILD_TESTING)
+    add_subdirectory(tests)
+endif ()
 
 ###############################################################################
 
 # copy binaries to "bin" folder; these are uploaded as artifacts on each release
-# DESTINATION_DIR is set as "bin" in cmake/Options.cmake:6
+# DESTINATION_DIR is set as "bin" in cmake/Options.cmake
 install(TARGETS ${MAIN_EXECUTABLE_NAME} DESTINATION ${DESTINATION_DIR})
 if(APPLE)
     install(FILES launcher.command DESTINATION ${DESTINATION_DIR})
diff --git a/cmake/RegisterTests.cmake b/cmake/RegisterTests.cmake
new file mode 100644
index 00000000..d5439904
--- /dev/null
+++ b/cmake/RegisterTests.cmake
@@ -0,0 +1,122 @@
+###############################################################################
+# Framework agnostic registration of test executables with CTest.
+# No test framework code here, keep identical on every branch.
+#
+#   register_tests(<target>)                      one CTest test for the executable
+#   register_tests(<target> LIST_ARGS <arg> ...)  one CTest test per test case
+#
+# Options (all optional):
+#   LIST_ARGS <arg>          argument that prints the test cases, one per line
+#   LIST_NOISE <regex>       removed from every line of the listing, a line left
+#                            empty is not a test case
+#   SELECT_ARG <template>... argument that runs one case, <name> is the
+#                            placeholder, several arguments stay separate
+#   NAME_ESCAPE <characters> characters replaced by "?" in a selection argument,
+#                            for frameworks selecting by pattern instead of name
+#   TIMEOUT <seconds>        per test timeout, default 60
+#   LIST_TIMEOUT <seconds>   timeout for the listing run, default 60
+#   WORKING_DIRECTORY <dir>  default CMAKE_SOURCE_DIR
+#   TEST_LIST <variable>     set in the calling scope to the list of test names
+#   PROPERTIES <name value>  extra CTest test properties
+###############################################################################
+
+# CMAKE_CURRENT_LIST_DIR inside a function body is the file of the caller
+set(REGISTER_TESTS_MODULE_DIR "${CMAKE_CURRENT_LIST_DIR}")
+
+function(register_tests TARGET)
+    cmake_parse_arguments(PARSE_ARGV 1 ARG "" "LIST_ARGS;LIST_NOISE;NAME_ESCAPE;TIMEOUT;LIST_TIMEOUT;WORKING_DIRECTORY;TEST_LIST" "SELECT_ARG;PROPERTIES")
+
+    if(NOT TARGET ${TARGET})
+        message(FATAL_ERROR "register_tests: ${TARGET} is not a target")
+    endif()
+
+    if(ARG_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "register_tests: unknown arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED ARG_WORKING_DIRECTORY)
+        set(ARG_WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
+    endif()
+
+    if(NOT DEFINED ARG_TIMEOUT)
+        set(ARG_TIMEOUT 60)
+    endif()
+
+    if(NOT DEFINED ARG_LIST_TIMEOUT)
+        set(ARG_LIST_TIMEOUT 60)
+    endif()
+
+    if(NOT ARG_LIST_ARGS)
+        # plain assert() tests: nothing to enumerate
+        add_test(NAME ${TARGET} COMMAND ${TARGET})
+
+        set_tests_properties(${TARGET} PROPERTIES
+            WORKING_DIRECTORY "${ARG_WORKING_DIRECTORY}"
+            TIMEOUT "${ARG_TIMEOUT}"
+            ${ARG_PROPERTIES}
+        )
+
+        if(DEFINED ARG_TEST_LIST)
+            set(${ARG_TEST_LIST} ${TARGET} PARENT_SCOPE)
+        endif()
+
+        return()
+    endif()
+
+    # the cases are only known by running the executable, so discovery runs inside
+    # ctest, never during the build; same TEST_INCLUDE_FILES mechanism as
+    # gtest_discover_tests(DISCOVERY_MODE PRE_TEST)
+    get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+
+    set(file_base "${CMAKE_CURRENT_BINARY_DIR}/ctest_${TARGET}")
+    set(include_file "${file_base}_include.cmake")
+
+    if(GENERATOR_IS_MULTI_CONFIG)
+        set(tests_file "${file_base}_tests-$<CONFIG>.cmake")
+    else()
+        set(tests_file "${file_base}_tests.cmake")
+    endif()
+
+    # regenerated by cmake, it only includes the file written at test time
+    string(CONCAT include_content
+        "if(EXISTS \"$<TARGET_FILE:${TARGET}>\")"                                     "\n"
+        "  if(NOT EXISTS \"${tests_file}\" OR"                                        "\n"
+        "     NOT \"${tests_file}\" IS_NEWER_THAN \"$<TARGET_FILE:${TARGET}>\" OR\n"
+        "     NOT \"${tests_file}\" IS_NEWER_THAN \"\${CMAKE_CURRENT_LIST_FILE}\")\n"
+        "    include(\"${REGISTER_TESTS_MODULE_DIR}/RegisterTestsAddTests.cmake\")\n"
+        "    register_tests_discover("                                                "\n"
+        "      TEST_EXECUTABLE"    " [==[" "$<TARGET_FILE:${TARGET}>"     "]==]"      "\n"
+        "      TEST_WORKING_DIR"   " [==[" "${ARG_WORKING_DIRECTORY}"     "]==]"      "\n"
+        "      LIST_ARGS"          " [==[" "${ARG_LIST_ARGS}"             "]==]"      "\n"
+        "      LIST_NOISE"         " [==[" "${ARG_LIST_NOISE}"            "]==]"      "\n"
+        "      SELECT_ARG"         " [==[" "${ARG_SELECT_ARG}"            "]==]"      "\n"
+        "      NAME_ESCAPE"        " [==[" "${ARG_NAME_ESCAPE}"           "]==]"      "\n"
+        "      LIST_TIMEOUT"       " [==[" "${ARG_LIST_TIMEOUT}"          "]==]"      "\n"
+        "      TIMEOUT"            " [==[" "${ARG_TIMEOUT}"               "]==]"      "\n"
+        "      TEST_LIST"          " [==[" "${ARG_TEST_LIST}"             "]==]"      "\n"
+        "      TEST_PROPERTIES"    " [==[" "${ARG_PROPERTIES}"            "]==]"      "\n"
+        "      CTEST_FILE"         " [==[" "${tests_file}"                "]==]"      "\n"
+        "    )"                                                                       "\n"
+        "  endif()"                                                                   "\n"
+        "  include(\"${tests_file}\")"                                                "\n"
+        "else()"                                                                      "\n"
+        "  add_test(${TARGET}_NOT_BUILT ${TARGET}_NOT_BUILT)"                         "\n"
+        "endif()"                                                                     "\n"
+    )
+
+    if(GENERATOR_IS_MULTI_CONFIG)
+        foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
+            file(GENERATE OUTPUT "${file_base}_include-${config}.cmake" CONTENT "${include_content}" CONDITION $<CONFIG:${config}>)
+        endforeach()
+        file(WRITE "${include_file}" "include(\"${file_base}_include-\${CTEST_CONFIGURATION_TYPE}.cmake\")")
+    else()
+        file(GENERATE OUTPUT "${file_base}_include.cmake" CONTENT "${include_content}")
+        file(WRITE "${include_file}" "include(\"${file_base}_include.cmake\")")
+    endif()
+
+    set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES "${include_file}")
+
+    if(DEFINED ARG_TEST_LIST)
+        message(WARNING "register_tests: TEST_LIST is only set by ctest, after the cases were discovered")
+    endif()
+endfunction()
diff --git a/cmake/RegisterTestsAddTests.cmake b/cmake/RegisterTestsAddTests.cmake
new file mode 100644
index 00000000..820944e1
--- /dev/null
+++ b/cmake/RegisterTestsAddTests.cmake
@@ -0,0 +1,312 @@
+###############################################################################
+# Discovery half of cmake/RegisterTests.cmake: runs the test executable, turns
+# its list of test cases into add_test() calls and writes them to a file ctest
+# includes before running the tests.
+#
+# Framework agnostic, keep identical on every branch, see
+# cmake/RegisterTests.cmake
+#
+# add_command / generate_testname_guards / escape_square_brackets are taken from
+# CMake's own GoogleTestAddTests.cmake (BSD-3-Clause).
+###############################################################################
+
+function(add_command NAME TEST_NAME)
+    set(args "")
+    foreach(arg IN LISTS ARGN)
+        if(arg MATCHES "[^-./:a-zA-Z0-9_]")
+            string(APPEND args " [==[${arg}]==]")
+        else()
+            string(APPEND args " ${arg}")
+        endif()
+    endforeach()
+    string(APPEND script "${NAME}(${TEST_NAME} ${args})\n")
+    set(script "${script}" PARENT_SCOPE)
+endfunction()
+
+function(generate_testname_guards OUTPUT OPEN_GUARD_VAR CLOSE_GUARD_VAR)
+    set(open_guard "[=[")
+    set(close_guard "]=]")
+    set(counter 1)
+    while("${OUTPUT}" MATCHES "${close_guard}")
+        math(EXPR counter "${counter} + 1")
+        string(REPEAT "=" ${counter} equals)
+        set(open_guard "[${equals}[")
+        set(close_guard "]${equals}]")
+    endwhile()
+    set(${OPEN_GUARD_VAR} "${open_guard}" PARENT_SCOPE)
+    set(${CLOSE_GUARD_VAR} "${close_guard}" PARENT_SCOPE)
+endfunction()
+
+function(escape_square_brackets OUTPUT BRACKET PLACEHOLDER PLACEHOLDER_VAR OUTPUT_VAR)
+    if("${OUTPUT}" MATCHES "\\${BRACKET}")
+        set(placeholder "${PLACEHOLDER}")
+        while("${OUTPUT}" MATCHES "${placeholder}")
+            set(placeholder "${placeholder}_")
+        endwhile()
+        string(REPLACE "${BRACKET}" "${placeholder}" OUTPUT "${OUTPUT}")
+        set(${PLACEHOLDER_VAR} "${placeholder}" PARENT_SCOPE)
+        set(${OUTPUT_VAR} "${OUTPUT}" PARENT_SCOPE)
+    endif()
+endfunction()
+
+# replaces wildcard characters with "?", which still matches what it replaces
+function(escape_name_pattern NAME CHARACTERS OUT_NAME OUT_CHANGED)
+    string(LENGTH "${NAME}" length)
+    set(out "")
+    set(index 0)
+    set(changed FALSE)
+
+    while(index LESS length)
+        string(SUBSTRING "${NAME}" ${index} 1 char)
+        string(LENGTH "${char}" char_length)
+        string(FIND "${CHARACTERS}" "${char}" position)
+
+        if(char_length GREATER 0 AND position GREATER -1)
+            string(APPEND out "?")
+            set(changed TRUE)
+        else()
+            string(APPEND out "${char}")
+        endif()
+
+        math(EXPR index "${index} + 1")
+    endwhile()
+
+    set(${OUT_NAME} "${out}" PARENT_SCOPE)
+    set(${OUT_CHANGED} "${changed}" PARENT_SCOPE)
+endfunction()
+
+# same length and every character equal or matched by "?"
+function(matches_pattern PATTERN VALUE OUT_MATCH)
+    string(LENGTH "${PATTERN}" pattern_length)
+    string(LENGTH "${VALUE}" value_length)
+
+    if(NOT pattern_length EQUAL value_length)
+        set(${OUT_MATCH} FALSE PARENT_SCOPE)
+        return()
+    endif()
+
+    set(index 0)
+    while(index LESS pattern_length)
+        string(SUBSTRING "${PATTERN}" ${index} 1 pattern_char)
+        string(SUBSTRING "${VALUE}" ${index} 1 value_char)
+        string(FIND "?" "${pattern_char}" wildcard)
+
+        if(wildcard EQUAL -1 AND NOT "${pattern_char}" STREQUAL "${value_char}")
+            set(${OUT_MATCH} FALSE PARENT_SCOPE)
+            return()
+        endif()
+
+        math(EXPR index "${index} + 1")
+    endwhile()
+
+    set(${OUT_MATCH} TRUE PARENT_SCOPE)
+endfunction()
+
+# how many of the known cases a pattern selects
+function(count_matching_cases PATTERN NAMES OUT_COUNT)
+    set(count 0)
+
+    foreach(name IN LISTS NAMES)
+        matches_pattern("${PATTERN}" "${name}" matches)
+        if(matches)
+            math(EXPR count "${count} + 1")
+        endif()
+    endforeach()
+
+    set(${OUT_COUNT} ${count} PARENT_SCOPE)
+endfunction()
+
+function(register_tests_discover)
+    cmake_parse_arguments(PARSE_ARGV 0 ARG "" "TEST_EXECUTABLE;TEST_WORKING_DIR;LIST_ARGS;LIST_NOISE;SELECT_ARG;NAME_ESCAPE;LIST_TIMEOUT;TIMEOUT;TEST_LIST;CTEST_FILE" "TEST_PROPERTIES")
+
+    if(NOT EXISTS "${ARG_TEST_EXECUTABLE}")
+        message(FATAL_ERROR
+            "Specified test executable does not exist.\n"
+            "  Path: '${ARG_TEST_EXECUTABLE}'"
+        )
+    endif()
+
+    execute_process(
+        COMMAND "${ARG_TEST_EXECUTABLE}" ${ARG_LIST_ARGS}
+        WORKING_DIRECTORY "${ARG_TEST_WORKING_DIR}"
+        TIMEOUT ${ARG_LIST_TIMEOUT}
+        OUTPUT_VARIABLE output
+        ERROR_VARIABLE error_output
+        RESULT_VARIABLE result
+    )
+
+    # a failed listing is not the same as an empty one
+    if(NOT result EQUAL 0)
+        string(REPLACE "\n" "\n    " output "${output}${error_output}")
+        message(FATAL_ERROR
+            "Could not list the test cases of the test executable.\n"
+            "  Path: '${ARG_TEST_EXECUTABLE}'\n"
+            "  Working directory: '${ARG_TEST_WORKING_DIR}'\n"
+            "  Listing arguments: ${ARG_LIST_ARGS}\n"
+            "  Result: ${result}\n"
+            "  Output:\n"
+            "    ${output}\n"
+            "The listing runs the executable; a crash here (runtime library\n"
+            "missing next to it, wrong architecture) looks exactly like this."
+        )
+    endif()
+
+    string(ASCII 27 escape)
+    string(REGEX REPLACE "${escape}\\[[0-9;]*m" "" output "${output}")
+    string(REPLACE "\r" "" output "${output}")
+
+    # googletest indents the cases under a suite line, boost::ut lists flat names
+    string(FIND "${output}" "\n  " indent_position)
+
+    if(NOT indent_position EQUAL -1)
+        set(hierarchical TRUE)
+    else()
+        set(hierarchical FALSE)
+    endif()
+
+    string(LENGTH "${ARG_LIST_NOISE}" noise_length)
+
+    # brackets would end the guard written around a name
+    generate_testname_guards("${output}" open_guard close_guard)
+    escape_square_brackets("${output}" "[" "__osb" open_sb output)
+    escape_square_brackets("${output}" "]" "__csb" close_sb output)
+
+    string(REPLACE "\n" ";" lines "${output}")
+
+    set(names "")
+    set(suite "")
+
+    foreach(line IN LISTS lines)
+        # ^ and $ in a CMake regex are not per line, hence the per line noise removal
+        if(noise_length GREATER 0)
+            string(REGEX REPLACE "${ARG_LIST_NOISE}" "" line "${line}")
+        endif()
+
+        string(STRIP "${line}" stripped)
+        string(LENGTH "${stripped}" line_length)
+
+        if(line_length EQUAL 0)
+            continue()
+        endif()
+
+        if(hierarchical)
+            if(line MATCHES "^  +")
+                set(name "${suite}.${stripped}")
+                string(REGEX REPLACE " +#.*$" "" name "${name}")
+            else()
+                set(suite "${stripped}")
+                string(REGEX REPLACE "\\.( *#.*)?$" "" suite "${suite}")
+                continue()
+            endif()
+        else()
+            set(name "${stripped}")
+        endif()
+
+        # an option line of a usage message is not a test case
+        if(stripped MATCHES "^-")
+            message(FATAL_ERROR
+                "This does not look like a test case name, it looks like the\n"
+                "output of '${ARG_LIST_ARGS}' is not a list of test cases:\n"
+                "  '${stripped}'"
+            )
+        endif()
+
+        # ';' ends a CMake list, a newline or a quote breaks the generated script
+        if(name MATCHES "[;\n\"]")
+            message(FATAL_ERROR
+                "A test case name may not contain ';', a newline or a quote:\n"
+                "  '${name}'"
+            )
+        endif()
+
+        list(FIND names "${name}" duplicate)
+        if(NOT duplicate EQUAL -1)
+            # ctest test names are unique: a duplicate silently replaces the first
+            message(FATAL_ERROR
+                "Two test cases share the same name, test case names have to be\n"
+                "unique across all suites: '${name}'"
+            )
+        endif()
+
+        list(APPEND names "${name}")
+    endforeach()
+
+    list(LENGTH names count)
+
+    if(count EQUAL 0)
+        message(FATAL_ERROR
+            "No test case is registered by '${ARG_TEST_EXECUTABLE}'.\n"
+            "  Listing arguments: ${ARG_LIST_ARGS}\n"
+            "  Output:\n    ${output}\n"
+            "Register the suites (boost::ut: suite<\"...\">, googletest: TEST()),\n"
+            "refusing to report success for a test executable that runs nothing."
+        )
+    endif()
+
+    set(script "")
+    set(discovered "")
+
+    foreach(name IN LISTS names)
+        set(selection "${ARG_SELECT_ARG}")
+        string(LENGTH "${selection}" selection_length)
+
+        if(selection_length GREATER 0)
+            escape_name_pattern("${name}" "${ARG_NAME_ESCAPE}" pattern changed)
+
+            if(changed)
+                count_matching_cases("${pattern}" "${names}" matching)
+
+                # "?" matches any character: the escaped name could run a
+                # different case and still report success
+                if(NOT matching EQUAL 1)
+                    message(FATAL_ERROR
+                        "Cannot select the test case '${name}' on its own, its name\n"
+                        "contains a character the framework treats as a wildcard and\n"
+                        "the escaped name '${pattern}' matches ${matching} of the\n"
+                        "registered test cases. Rename the test case."
+                    )
+                endif()
+            endif()
+
+            string(REPLACE "<name>" "${pattern}" selection "${selection}")
+        endif()
+
+        if(open_sb)
+            string(REPLACE "${open_sb}" "[" name "${name}")
+        endif()
+
+        if(close_sb)
+            string(REPLACE "${close_sb}" "]" name "${name}")
+        endif()
+
+        set(guarded_name "${open_guard}${name}${close_guard}")
+
+        add_command(add_test
+            "${guarded_name}"
+            "${ARG_TEST_EXECUTABLE}"
+            ${selection}
+        )
+
+        add_command(set_tests_properties
+            "${guarded_name}"
+            PROPERTIES
+            WORKING_DIRECTORY "${ARG_TEST_WORKING_DIR}"
+            TIMEOUT "${ARG_TIMEOUT}"
+            ${ARG_PROPERTIES}
+        )
+
+        # unbalanced brackets would invalidate the generated list: registered, but
+        # left out of TEST_LIST
+        if(NOT "${name}" MATCHES [[(\[|\])]])
+            list(APPEND discovered "${name}")
+        endif()
+    endforeach()
+
+    string(LENGTH "${ARG_TEST_LIST}" test_list_length)
+
+    if(test_list_length GREATER 0)
+        add_command(set "" "${ARG_TEST_LIST}" "${discovered}")
+    endif()
+
+    file(WRITE "${ARG_CTEST_FILE}" "${script}")
+endfunction()
diff --git a/ext/include/boost/ut.hpp b/ext/include/boost/ut.hpp
index 8869d9fb..1b6200da 100644
--- a/ext/include/boost/ut.hpp
+++ b/ext/include/boost/ut.hpp
@@ -742,10 +742,16 @@ struct cfg {
       // clang-format on
   };
 
+  // LOCAL PATCH: options were matched as substrings, so an unknown option
+  // matched nothing, became a test name pattern and reported success
   static std::optional<cfg::option> find_arg(std::string_view arg) {
     for (const auto& option : cfg::options) {
-      if (std::get<0>(option).find(arg) != std::string::npos) {
-        return option;
+      for (const auto name : utility::split(std::get<0>(option), ' ')) {
+        const auto token =
+            name.ends_with(',') ? name.substr(0, name.size() - 1) : name;
+        if (token == arg) {
+          return option;
+        }
       }
     }
     return std::nullopt;
@@ -780,11 +786,8 @@ struct cfg {
       cfg::largc = argc;
       cfg::largv = argv;
     }
-    else
-    {
-      cfg::largc = 0;
-      cfg::largv = nullptr;
-    }
+    // LOCAL PATCH: clearing them here discarded the command line captured by
+    // the cmd_line_args constructor (GCC/Clang) and by __argv (MSVC)
     parse(cfg::largc, cfg::largv);
   }
 
@@ -794,25 +797,25 @@ struct cfg {
       executable_name = argv[0];
     }
     query_pattern = "";
-    bool found_first_option = false;
     for (auto i = 1U; i < n_args && argv != nullptr; i++) {
       std::string cmd(argv[i]);
       auto cmd_option = find_arg(cmd);
       if (!cmd_option.has_value()) {
-        if (found_first_option) {
+        // LOCAL PATCH: '-' starts an option wherever it appears, the usage
+        // line promises "[<test name|pattern|tags> ... ] options"
+        if (not cmd.empty() and cmd.front() == '-') {
           std::cerr << "unknown option: '" << cmd << "' run:" << std::endl;
           std::cerr << "'" << executable_name << " --help'" << std::endl;
           std::cerr << "for additional help" << std::endl;
           std::exit(-1);
         } else {
-          if (i > 1U) {
+          if (not query_pattern.empty()) {
             query_pattern.append(" ");
           }
           query_pattern.append(cmd);
         }
         continue;
       }
-      found_first_option = true;
       auto var = std::get<value_ref>(*cmd_option);
       const bool has_option_arg = !std::get<1>(*cmd_option).empty();
       if (!has_option_arg &&
diff --git a/scripts/cmake.sh b/scripts/cmake.sh
index da4b2104..0ff5ec90 100755
--- a/scripts/cmake.sh
+++ b/scripts/cmake.sh
@@ -3,6 +3,7 @@
 DEFAULT_BUILD_DIR="build"
 DEFAULT_BUILD_TYPE="Debug"
 DEFAULT_INSTALL_DIR="install_dir"
+DEFAULT_BUILD_TESTING='ON'
 
 # Pentru a folosi biblioteci instalate deja local cu FetchContent:
 # ./scripts/cmake.sh configure -e "-DFETCHCONTENT_BASE_DIR=~/.local/fetchcontent-deps"
@@ -16,10 +17,11 @@ configure() {
     BUILD_DIR="${DEFAULT_BUILD_DIR}"
     BUILD_TYPE="${DEFAULT_BUILD_TYPE}"
     INSTALL_DIR="${DEFAULT_INSTALL_DIR}"
+    BUILD_TESTING="${DEFAULT_BUILD_TESTING}"
     SOURCE_DIR="."
     CMAKE_OPTS=()
 
-    while getopts ":b:c:e:g:i:s:" opt; do
+    while getopts ":b:c:e:g:i:s:t:" opt; do
       case "${opt}" in
         b) BUILD_DIR="${OPTARG}"
         ;;
@@ -33,13 +35,20 @@ configure() {
         ;;
         s) SOURCE_DIR="${OPTARG}"
         ;;
+        t) BUILD_TESTING="${OPTARG}"
+           if [[ "${BUILD_TESTING}" != 'ON' && "${BUILD_TESTING}" != 'OFF' ]]; then
+            echo "Invalid value for -t: $BUILD_TESTING. Use ON or OFF."
+            exit 1
+           fi
+        ;;
         *) printf "Unknown option %s; available options: \n\
             -b (build dir)\n\
             -c (CMake config build type)\n\
             -e (extra CMake options)\n\
             -g (generator)\n\
             -i (install dir prefix)\n\
-            -s (source dir)\n"\
+            -s (source dir)\n\
+            -t (build tests ON/OFF -> -DBUILD_TESTING)\n"\
             "${opt}"
            exit 1
         ;;
@@ -51,6 +60,7 @@ configure() {
           -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
           -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
           -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
+          -DBUILD_TESTING="${BUILD_TESTING}" \
           "${CMAKE_OPTS[@]}"
 }
 
@@ -90,27 +100,34 @@ build() {
 }
 
 test() {
-    # ctest --test-dir build -C Debug --verbose --no-compress-output --output-on-failure
+    # bash ./scripts/run_tests.sh -b build -c Debug -r
     #
     BUILD_DIR="${DEFAULT_BUILD_DIR}"
-    BUILD_TYPE="${DCMAKE_BUILD_TYPE}"
+    BUILD_TYPE="${DEFAULT_BUILD_TYPE}"
+    RUN_TESTS_SCRIPT_OPTS=()    # -r: zero registered tests is an error, see scripts/run_tests.sh
 
-    while getopts ":b:c:" opt; do
+    while getopts ":b:c:r" opt; do
         case "${opt}" in
           b) BUILD_DIR="${OPTARG}"
           ;;
           c) BUILD_TYPE="${OPTARG}"
           ;;
+          r) RUN_TESTS_SCRIPT_OPTS+=("-r")
+          ;;
           *) printf "Unknown option %s; available options: \n\
               -b (build dir)\n\
-              -c (CMake config build type)\n"\
+              -c (CMake config build type)\n\
+              -r (fail when no test is registered)\n"\
               "${opt}"
             exit 1
           ;;
         esac
     done
 
-    ctest --test-dir "${BUILD_DIR}" -C "${BUILD_TYPE}" --verbose --no-compress-output --output-on-failure
+    bash "$(dirname "${BASH_SOURCE[0]}")/run_tests.sh" \
+          -b "${BUILD_DIR}" \
+          -c "${BUILD_TYPE}" \
+          "${RUN_TESTS_SCRIPT_OPTS[@]}"
 }
 
 install() {
@@ -142,7 +159,6 @@ install() {
           --prefix "${INSTALL_DIR}"
 }
 
-
 case "$1" in
     configure)
     shift
diff --git a/scripts/run_tests.sh b/scripts/run_tests.sh
new file mode 100755
index 00000000..5ba1a8a2
--- /dev/null
+++ b/scripts/run_tests.sh
@@ -0,0 +1,47 @@
+#!/usr/bin/bash
+
+# Runs the tests CTest registered in a configured build dir.
+# ctest exits 0 when it finds no tests, so -r makes 0 tests fail.
+
+BUILD_DIR=${BUILD_DIR:-build}
+BUILD_TYPE=${BUILD_TYPE:-Debug}
+REQUIRE_TESTS=false
+
+while getopts ":b:c:r" opt; do
+  case "${opt}" in
+    b) BUILD_DIR="${OPTARG}"
+    ;;
+    c) BUILD_TYPE="${OPTARG}"
+    ;;
+    r) REQUIRE_TESTS=true
+    ;;
+    *) printf "Unknown option %s; available options: \n\
+        -b (build dir)\n\
+        -c (CMake config build type)\n\
+        -r (fail when no test is registered)\n" "${opt}"
+      exit 1
+    ;;
+  esac
+done
+
+if [[ "${REQUIRE_TESTS}" = true ]]; then
+    # PRE_TEST discovery runs the test binary to produce the list
+    # report separately an empty list as "nothing registered" or "the binary will not start"
+    list_output="$(ctest --test-dir "${BUILD_DIR}" -C "${BUILD_TYPE}" -N 2>&1)"
+    list_rc=$?
+    if ! printf '%s' "${list_output}" | grep -q 'Test #1'; then
+        printf '%s\n' "${list_output}"
+        if [[ "${list_rc}" -ne 0 ]]; then
+            echo "Error: ctest could not list the tests of ${BUILD_DIR} (rc=${list_rc})."
+            echo "Discovery runs the test binary; a crash there (runtime library missing next"
+            echo "to it, wrong architecture) looks exactly like this."
+        else
+            echo "Error: no test is registered in ${BUILD_DIR}."
+            echo "Configure with -DBUILD_TESTING=ON and register the suites"
+            echo "(gtest_discover_tests / add_test). Refusing to report success."
+        fi
+        exit 1
+    fi
+fi
+
+ctest --test-dir "${BUILD_DIR}" -C "${BUILD_TYPE}" --output-on-failure
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 00000000..3c13e6a1
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,30 @@
+# no project(): nested projects reset PROJECT_SOURCE_DIR / PROJECT_NAME
+
+add_executable(${TESTS_EXECUTABLE_NAME}
+    main.cpp
+    test_oop.cpp
+    test_simplu.cpp
+)
+
+# target_link_libraries(${TESTS_EXECUTABLE_NAME} PRIVATE ${MAIN_LIBRARY_NAME})
+target_link_libraries(${TESTS_EXECUTABLE_NAME} PRIVATE ${MAIN_LIBRARY_NO_SAN_NAME})
+
+# header only dependency; SYSTEM so cppcheck and clang-tidy do not report warnings from it
+target_include_directories(${TESTS_EXECUTABLE_NAME} SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/ext/include/boost)
+
+# tests do not work with sanitizers on msvc
+set_compiler_flags(RUN_SANITIZERS FALSE TARGET_NAMES ${TESTS_EXECUTABLE_NAME})
+
+# one CTest test per test case, see cmake/RegisterTests.cmake
+#
+# ut lists its cases with --list-test-names-only and runs a single one when it is
+# given the case name, but that name is matched as a pattern where * ? ! . and \
+# are wildcards, so those characters are replaced with "?" (any single character)
+register_tests(${TESTS_EXECUTABLE_NAME}
+    LIST_ARGS   "--list-test-names-only"
+    LIST_NOISE  "UT starts [=]*|^Completed.*"
+    SELECT_ARG  "<name>"
+    NAME_ESCAPE ".*?!\\"
+)
+
+install(TARGETS ${TESTS_EXECUTABLE_NAME} DESTINATION ${DESTINATION_DIR})
diff --git a/tests/README_Tests.md b/tests/README_Tests.md
index da2e818c..a131c661 100644
--- a/tests/README_Tests.md
+++ b/tests/README_Tests.md
@@ -1,9 +1,20 @@
 Acest branch utilizează Boost-ext/ut, un framework de teste unitare modern, simplu și performant pentru C++.
 Boost-ext/ut oferă un API intuitiv, bazat pe expresii, ceea ce îl face ușor de integrat și citit.
 
-Fiecare fișier din `./tests` reprezintă o suită nouă de teste unitare, fiecare fiind adăugată
-cu `add_tests`. Acest lucru este făcut automat în [CMakeLists](../CMakeLists.txt). Toate testele vor fi rulate
-folosind [CTest](https://cmake.org/cmake/help/book/mastering-cmake/chapter/Testing%20With%20CMake%20and%20CTest.html).
+Fiecare fișier din `./tests` reprezintă o suită nouă de teste unitare. Testele sunt înregistrate
+în [CTest](https://cmake.org/cmake/help/book/mastering-cmake/chapter/Testing%20With%20CMake%20and%20CTest.html)
+cât se rulează, automat, în `tests/CMakeLists.txt` prin `register_tests` (vezi `cmake/RegisterTests.cmake`):
+câte o intrare pentru fiecare test, nu pentru tot executabilul.
+
+```bash
+ctest --test-dir build -N      # lista testelor înregistrate
+ctest --test-dir build -R "sum"   # rulează doar testele care se potrivesc
+```
+
+Lista este produsă de executabilul de teste (`--list-test-names-only`), de aceea:
+* numele unui test trebuie să fie unic între toate suitele (ctest nu acceptă două intrări cu același nume);
+* în nume nu folosi `*`, `?`, `!`, `.` sau `\` - ut alege un test dupa nume ca și cum ar fi un tipar,
+  iar aceste caractere devin metacaractere (dacă un nume devine ambiguu, înregistrarea eșuează zgomotos).
 
 Pentru a mări modularitatea soluției, vom pune toate fișierele scrise de noi într-o bibliotecă. Această abordare ne permite
 să refolosim codul deja construit în alte componente/aplicații. În cazul de față, compilăm fișierele sursă atunci
diff --git a/tests/main.cpp b/tests/main.cpp
index 10d190b6..4400c7f3 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -3,6 +3,14 @@
 extern boost::ut::suite<"simplu"> simplu_test_suite;
 extern boost::ut::suite<"oop"> oop_test_suite;
 
-int main() {
-    return 0;
-}
\ No newline at end of file
+// CLI args required by ut and ctest for registration and filtering
+int main(int argc, char** argv) {
+    boost::ut::run_cfg rc{};
+    rc.report_errors = true;
+    rc.argc = argc;
+    rc.argv = const_cast<const char**>(argv);
+
+    // older compilers reject a designated initializer here:
+    // cfg<>.run({.report_errors = true, .argc = argc, .argv = argv})
+    return boost::ut::cfg<>.run(rc) ? 1 : 0;
+}