diff --git a/.ci/compile.sh b/.ci/compile.sh
index 823a31898..de4fac004 100755
--- a/.ci/compile.sh
+++ b/.ci/compile.sh
@@ -8,6 +8,7 @@
 # --suffix <suffix> renames package with this suffix, requires arg
 # --server compiles servatrice
 # --test runs tests
+# --sanitize builds with AddressSanitizer and UndefinedBehaviorSanitizer, gcc/clang only
 # --debug or --release sets the build type ie CMAKE_BUILD_TYPE
 # --ccache [<size>] uses ccache and shows stats, optionally provide size
 # --evict-ccache <age> runs ccache eviction based on given age after build
@@ -57,6 +58,10 @@ while [[ $# != 0 ]]; do
       MAKE_TEST=1
       shift
       ;;
+    '--sanitize')
+      MAKE_SANITIZE=1
+      shift
+      ;;
     '--debug')
       BUILDTYPE="Debug"
       shift
@@ -147,6 +152,14 @@ fi
 if [[ $MAKE_TEST ]]; then
   flags+=("-DTEST=1")
 fi
+if [[ $MAKE_SANITIZE ]]; then
+  flags+=("-DENABLE_SANITIZERS=ON")
+else
+  # The release-package step re-runs cmake in the same build dir, so an
+  # ENABLE_SANITIZERS=ON left over from the debug step would otherwise leak
+  # into the shipped binaries (libasan/libubsan Depends in the DEB).
+  flags+=("-DENABLE_SANITIZERS=OFF")
+fi
 if [[ $USE_CCACHE ]]; then
   flags+=("-DUSE_CCACHE=1")
   # PCH-aware caching is required or ccache refuses to cache any TU that
@@ -306,7 +319,25 @@ fi
 
 if [[ $MAKE_TEST ]]; then
   echo "::group::Run tests"
-  ctest -C "$BUILDTYPE" --output-on-failure
+  if [[ $MAKE_SANITIZE ]]; then
+    # detect_leaks=0: Qt and the sanitizers' own runtimes both leak at exit by design, and
+    # LeakSanitizer's default is aggressive enough to bury our real findings under hundreds
+    # of process-teardown reports. Malloc/free misuse and use-after-free are what ASan is for
+    # and they stay fully on.
+    # abort_on_error=1: a bad access leaves the process in an unusable state, so continuing
+    # only produces a second, more confusing report from the wreckage.
+    # UBSAN halt_on_error=1: without it UBSan prints "runtime error: ..." but the
+    # process exits 0 (recover mode), so gtest/ctest report a pass and the job
+    # stays green. Combined with -fno-sanitize-recover=undefined at compile time,
+    # the first finding aborts the test process with a non-zero exit.
+    export ASAN_OPTIONS="detect_leaks=0:abort_on_error=1:print_stacktrace=1:symbolize=1"
+    export UBSAN_OPTIONS="print_stacktrace=1:halt_on_error=1:symbolize=1"
+  fi
+  # Every TEST() is its own CTest entry, so the suite is process-spawn bound rather than CPU
+  # bound and -j recovers nearly all of the per-process overhead. The test binaries are safe to
+  # run concurrently: the only one that claims a fixed resource is single_instance_manager_test,
+  # which already scopes its local socket name to its own pid so parallel copies cannot collide.
+  ctest -C "$BUILDTYPE" --output-on-failure -j "${CTEST_JOBS:-4}"
   echo "::endgroup::"
 fi
 
diff --git a/.github/workflows/desktop-build.yml b/.github/workflows/desktop-build.yml
index 17c42b07d..57c2993f6 100644
--- a/.github/workflows/desktop-build.yml
+++ b/.github/workflows/desktop-build.yml
@@ -144,6 +144,11 @@ jobs:
 
             package: DEB
 
+            # The one leg that runs the suite under AddressSanitizer and
+            # UndefinedBehaviorSanitizer. Debian 13 and Fedora 44 keep covering the
+            # uninstrumented suite, so nothing is lost by instrumenting this one.
+            sanitize: yes
+
     name: ${{ matrix.distro }} ${{ matrix.version }}
     needs: configure
     runs-on: ubuntu-latest    # https://github.com/actions/runner-images
@@ -174,6 +179,8 @@ jobs:
       - name: "Build debug and test"
         if: matrix.test != 'skip'
         shell: bash
+        env:
+          sanitize: '${{ matrix.sanitize }}'
         run: |
           source .ci/docker.sh
           args=()
@@ -181,7 +188,10 @@ jobs:
           args+=(--ccache "$CCACHE_SIZE")
           args+=(--cmake-generator "$CMAKE_GENERATOR")
 
-          RUN --server --debug --test "${args[@]}"
+          extra=()
+          [[ $sanitize == yes ]] && extra+=(--sanitize)
+
+          RUN --server --debug --test "${extra[@]}" "${args[@]}"
 
       - name: "Build release package"
         id: build
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f51c636eb..ef8866e3a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,6 +22,8 @@ option(WITH_ORACLE "Build Cockatrice card database tool (Oracle)" ON)
 option(WITH_SERVER "Build Cockatrice server (Servatrice)" OFF)
 # Compile tests
 option(TEST "Build tests" OFF)
+# Build with AddressSanitizer and UndefinedBehaviorSanitizer
+option(ENABLE_SANITIZERS "Build with AddressSanitizer and UndefinedBehaviorSanitizer" OFF)
 # Use vcpkg regardless of OS
 option(USE_VCPKG "Use vcpkg regardless of OS" OFF)
 
@@ -211,6 +213,10 @@ else()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pipe")
 endif()
 
+# Always included, because it defines cockatrice_disable_sanitizers_for() for the vendored
+# trees. It only touches the global flags when ENABLE_SANITIZERS is on.
+include(Sanitizers)
+
 # GNU systems need to define the Mersenne exponent for the RNG to compile w/o warning
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
   add_definitions("-DSFMT_MEXP=19937")
diff --git a/cmake/FindQtRuntime.cmake b/cmake/FindQtRuntime.cmake
index ad52352de..2d74aca4d 100644
--- a/cmake/FindQtRuntime.cmake
+++ b/cmake/FindQtRuntime.cmake
@@ -40,7 +40,9 @@ endif()
 if(TEST)
   # Union of Qt modules required across all test targets (independent of application targets).
   # When adding a new test that needs additional Qt modules, add them here rather than in the test's CMakeLists.txt.
-  set(_TEST_NEEDED Concurrent Network Svg Widgets)
+  # Test is QtTest: it brings QAbstractItemModelTester and QSignalSpy, which are how the Qt model
+  # and signal contracts get verified without standing up a GUI.
+  set(_TEST_NEEDED Concurrent Network Svg Widgets Test)
 endif()
 
 set(REQUIRED_QT_COMPONENTS ${REQUIRED_QT_COMPONENTS} ${_SERVATRICE_NEEDED} ${_COCKATRICE_NEEDED} ${_ORACLE_NEEDED}
diff --git a/cmake/Sanitizers.cmake b/cmake/Sanitizers.cmake
new file mode 100644
index 000000000..2e5d794de
--- /dev/null
+++ b/cmake/Sanitizers.cmake
@@ -0,0 +1,109 @@
+# AddressSanitizer + UndefinedBehaviorSanitizer opt-in, plus per-source opt-out
+# Input: ENABLE_SANITIZERS
+# Defines: cockatrice_disable_sanitizers_for
+#
+# Included once from the root CMakeLists.txt, immediately after the per-compiler flag
+# block, so add_compile_options() reaches every library and executable defined below.
+
+include(CheckCXXSourceCompiles)
+
+# Opt a set of vendored sources out of instrumentation.
+#
+# cockatrice_disable_sanitizers_for(<source> ...)
+#
+# Sanitizer findings inside vendored code are not actionable for us, and letting them
+# through buries our own bugs in noise until everyone learns to skip the job.
+#
+# The sources must be named relative to the directory that compiles them. CMake resolves a
+# source-file property against the directory scope the target was declared in, so calling
+# this from the root with absolute paths silently does nothing. That is why the call sites
+# live next to the add_library/add_executable that pull the vendored code in.
+#
+# SKIP_PRECOMPILE_HEADERS is not optional. The precompiled header is built with the
+# sanitizer flags, so it defines __SANITIZE_ADDRESS__; a translation unit compiled with
+# -fno-sanitize=all does not, and GCC then refuses the PCH with
+# "not used because __SANITIZE_ADDRESS__ not defined", which is a fatal -Werror=invalid-pch
+# in the servatrice and oracle builds.
+function(cockatrice_disable_sanitizers_for)
+  if(NOT ENABLE_SANITIZERS)
+    return()
+  endif()
+  set_source_files_properties(${ARGN} PROPERTIES COMPILE_OPTIONS "-fno-sanitize=all" SKIP_PRECOMPILE_HEADERS ON)
+endfunction()
+
+if(ENABLE_SANITIZERS)
+  # Probe a flag the way it will actually be used: on the compile step AND the link step.
+  # check_cxx_compiler_flag() only probes the compile step, which makes every sanitizer
+  # flag look unsupported because linking an ASan object without -fsanitize=address leaves
+  # __asan_init undefined. That is a silent misconfiguration rather than an error, so the
+  # probe has to link.
+  function(cockatrice_probe_flag FLAG VARNAME)
+    set(CMAKE_REQUIRED_FLAGS "${FLAG}")
+    set(CMAKE_REQUIRED_LINK_OPTIONS "${FLAG}")
+    check_cxx_source_compiles("int main() { return 0; }" ${VARNAME})
+    unset(CMAKE_REQUIRED_FLAGS)
+    unset(CMAKE_REQUIRED_LINK_OPTIONS)
+  endfunction()
+
+  set(SANITIZER_FLAGS
+      -fsanitize=address,undefined
+      -fno-omit-frame-pointer
+      # UBSan defaults to recover mode: it prints "runtime error: ..." but the
+      # process exits 0, so gtest/ctest report a pass and CI stays green.
+      # -fno-sanitize-recover makes the first finding abort instead. This is
+      # probed like the other cosmetic flags, but CI also sets
+      # UBSAN_OPTIONS=halt_on_error=1 as the runtime-side guarantee.
+      -fno-sanitize-recover=undefined
+      # Qt builds QObject subclasses into raw storage and writes the vptr afterwards, which
+      # the vptr check reports on essentially every QObject instantiation. The check has no
+      # value for us because nothing outside moc-generated code inherits QObject, so it is
+      # off outright rather than suppressed piecemeal.
+      -fno-sanitize=vptr
+  )
+
+  # MSVC has no ASan/UBSan equivalent, and clang-cl would need /fsanitize=address plus a
+  # matching runtime link, which is a separate piece of work.
+  if(MSVC)
+    message(FATAL_ERROR "ENABLE_SANITIZERS is not supported with MSVC")
+  endif()
+
+  # Probe rather than assume, so an older toolchain gets the sanitizers it can support
+  # instead of failing the build on a flag it does not recognize.
+  set(SANITIZER_SUPPORTED_FLAGS)
+  foreach(FLAG ${SANITIZER_FLAGS})
+    string(MAKE_C_IDENTIFIER "COCKATRICE_HAS${FLAG}" _FLAG_VAR)
+    cockatrice_probe_flag("${FLAG}" ${_FLAG_VAR})
+    if(${_FLAG_VAR})
+      list(APPEND SANITIZER_SUPPORTED_FLAGS ${FLAG})
+    else()
+      message(STATUS "Sanitizers: ${FLAG} unsupported by ${CMAKE_CXX_COMPILER_ID}, skipping")
+    endif()
+  endforeach()
+
+  # The whole point of the option is the sanitizers, so an unsupported pair is fatal even
+  # though the cosmetic flags above are allowed to degrade.
+  if(NOT "-fsanitize=address,undefined" IN_LIST SANITIZER_SUPPORTED_FLAGS)
+    message(FATAL_ERROR "ENABLE_SANITIZERS requires -fsanitize=address,undefined, which "
+                        "${CMAKE_CXX_COMPILER_ID} does not accept"
+    )
+  endif()
+
+  add_compile_options(${SANITIZER_SUPPORTED_FLAGS})
+  add_link_options(-fsanitize=address,undefined)
+
+  # Recorded so the test tree can label its entries and a plain `make` at the same time
+  # cannot quietly disagree with what CI ran.
+  set(COCKATRICE_SANITIZERS
+      ON
+      CACHE INTERNAL "AddressSanitizer and UBSan are enabled"
+  )
+else()
+  # ENABLE_SANITIZERS is OFF, but COCKATRICE_SANITIZERS is CACHE INTERNAL, so a
+  # reused build dir (e.g. CI's release-package step reconfiguring the same dir
+  # after the sanitized debug step) would otherwise keep skipping NO_SANITIZE
+  # tests and keep the 300s discovery timeout. Reset it explicitly.
+  set(COCKATRICE_SANITIZERS
+      OFF
+      CACHE INTERNAL "AddressSanitizer and UBSan are enabled" FORCE
+  )
+endif()
diff --git a/libcockatrice_rng/CMakeLists.txt b/libcockatrice_rng/CMakeLists.txt
index b988c9d2f..16beffcfe 100644
--- a/libcockatrice_rng/CMakeLists.txt
+++ b/libcockatrice_rng/CMakeLists.txt
@@ -11,6 +11,9 @@ add_library(
                            libcockatrice/rng/sfmt/SFMT.c
 )
 
+# SFMT is vendored and its own headers trip UBSan's alignment and vptr checks.
+cockatrice_disable_sanitizers_for(libcockatrice/rng/sfmt/SFMT.c)
+
 target_include_directories(libcockatrice_rng PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 
 target_link_libraries(libcockatrice_rng PUBLIC ${QT_CORE_MODULE})
diff --git a/oracle/CMakeLists.txt b/oracle/CMakeLists.txt
index 0003b77ac..9b6863553 100644
--- a/oracle/CMakeLists.txt
+++ b/oracle/CMakeLists.txt
@@ -79,6 +79,8 @@ if(ZLIB_FOUND)
   include_directories(${ZLIB_INCLUDE_DIRS})
   add_definitions("-DHAS_ZLIB")
   list(APPEND oracle_SOURCES src/zip/unzip.cpp src/zip/zipglobal.cpp)
+  # minizip and zlib are vendored.
+  cockatrice_disable_sanitizers_for(src/zip/unzip.cpp src/zip/zipglobal.cpp)
 else()
   message(STATUS "Oracle: zlib not found; ZIP support disabled")
 endif()
@@ -89,6 +91,8 @@ if(LIBLZMA_FOUND)
   include_directories(${LIBLZMA_INCLUDE_DIRS})
   add_definitions("-DHAS_LZMA")
   list(APPEND oracle_SOURCES src/lzma/decompress.cpp)
+  # The LZMA SDK is vendored.
+  cockatrice_disable_sanitizers_for(src/lzma/decompress.cpp)
 else()
   message(STATUS "Oracle: LibLZMA not found; xz support disabled")
 endif()
diff --git a/servatrice/CMakeLists.txt b/servatrice/CMakeLists.txt
index 21f71a908..b176d8009 100644
--- a/servatrice/CMakeLists.txt
+++ b/servatrice/CMakeLists.txt
@@ -27,6 +27,11 @@ set(servatrice_SOURCES
 
 set(servatrice_RESOURCES servatrice.qrc)
 
+# Qxt SMTP is vendored.
+cockatrice_disable_sanitizers_for(
+  src/smtp/qxthmac.cpp src/smtp/qxtmailattachment.cpp src/smtp/qxtmailmessage.cpp src/smtp/qxtsmtp.cpp
+)
+
 if(WIN32)
   set(servatrice_SOURCES ${servatrice_SOURCES} servatrice.rc)
 endif(WIN32)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 2c288c6ce..c48e6c957 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -2,109 +2,10 @@
 # If a new test needs additional Qt modules, add them there — not in individual test CMakeLists.txt files.
 enable_testing()
 
-add_test(NAME dummy_test COMMAND dummy_test)
-add_test(NAME expression_test COMMAND expression_test)
-add_test(NAME clamped_arithmetic_test COMMAND clamped_arithmetic_test)
-add_test(NAME test_age_formatting COMMAND test_age_formatting)
-add_test(NAME password_hash_test COMMAND password_hash_test)
-add_test(NAME playmat_resolver_test COMMAND playmat_resolver_test)
-add_test(NAME server_card_counter_test COMMAND server_card_counter_test)
-add_test(NAME server_counter_test COMMAND server_counter_test)
-add_test(NAME server_rate_limiter_test COMMAND server_rate_limiter_test)
-add_test(NAME server_developer_role_test COMMAND server_developer_role_test)
-add_test(NAME server_game_join_test COMMAND server_game_join_test)
-add_test(NAME warning_categories_test COMMAND warning_categories_test)
-# The translation loader test compiles a .qm fixture, which needs lrelease from Qt Linguist.
-if(TARGET Qt6::lrelease)
-  add_test(NAME translation_loader_test COMMAND translation_loader_test)
-endif()
-add_test(NAME report_categories_test COMMAND report_categories_test)
-add_test(NAME lag_monitor_test COMMAND lag_monitor_test)
-add_test(NAME latency_tracker_test COMMAND latency_tracker_test)
-add_test(NAME metrics_registry_test COMMAND metrics_registry_test)
-add_test(NAME card_update_progress_test COMMAND card_update_progress_test)
-add_test(NAME loader_local_matching_test COMMAND loader_local_matching_test)
-
-add_test(NAME deck_hash_performance_test COMMAND deck_hash_performance_test)
-set_tests_properties(deck_hash_performance_test PROPERTIES TIMEOUT 15)
+include(GoogleTest)
 
 # Find GTest
 
-add_executable(dummy_test dummy_test.cpp)
-add_executable(expression_test expression_test.cpp)
-add_executable(clamped_arithmetic_test clamped_arithmetic_test.cpp)
-add_executable(test_age_formatting test_age_formatting.cpp)
-add_executable(password_hash_test password_hash_test.cpp)
-add_executable(playmat_resolver_test playmat_resolver_test.cpp)
-add_executable(deck_hash_performance_test deck_hash_performance_test.cpp)
-add_executable(server_card_counter_test server_card_counter_test.cpp)
-add_executable(server_counter_test server_counter_test.cpp)
-add_executable(server_rate_limiter_test server_rate_limiter_test.cpp)
-add_executable(server_developer_role_test server_developer_role_test.cpp)
-add_executable(server_game_join_test server_game_join_test.cpp)
-add_executable(warning_categories_test warning_categories_test.cpp)
-if(TARGET Qt6::lrelease)
-  add_executable(translation_loader_test translation_loader_test.cpp)
-
-  # QTranslator only accepts real .qm files, so the translation loader test gets one compiled from its
-  # own .ts fixture rather than a stub.
-  set(TRANSLATION_LOADER_TEST_QM "${CMAKE_CURRENT_BINARY_DIR}/translation_loader_test_de.qm")
-  add_custom_command(
-    OUTPUT "${TRANSLATION_LOADER_TEST_QM}"
-    COMMAND Qt6::lrelease "${CMAKE_CURRENT_SOURCE_DIR}/translation_loader_test.ts" -qm "${TRANSLATION_LOADER_TEST_QM}"
-    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/translation_loader_test.ts"
-    COMMENT "Compiling translation_loader_test.ts"
-  )
-  add_custom_target(translation_loader_test_qm DEPENDS "${TRANSLATION_LOADER_TEST_QM}")
-  add_dependencies(translation_loader_test translation_loader_test_qm)
-  target_compile_definitions(translation_loader_test PRIVATE TRANSLATION_LOADER_TEST_DIR="${CMAKE_CURRENT_BINARY_DIR}")
-
-  # A multi-config generator (MSBuild, Xcode) puts the executable in a per-config subdirectory while
-  # the .qm stays in the current binary directory, so copy the fixture next to the binary: that is the
-  # layout ABuildTreeFindsTheTranslationsNextToTheExecutable is about, and the only one it finds on
-  # those generators.
-  add_custom_command(
-    TARGET translation_loader_test
-    POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${TRANSLATION_LOADER_TEST_QM}"
-            "$<TARGET_FILE_DIR:translation_loader_test>/"
-    VERBATIM
-  )
-endif()
-add_executable(report_categories_test report_categories_test.cpp)
-add_executable(lag_monitor_test ${CMAKE_SOURCE_DIR}/cockatrice/src/client/lag_monitor.cpp lag_monitor_test.cpp)
-target_include_directories(lag_monitor_test PRIVATE ${CMAKE_SOURCE_DIR}/cockatrice/src)
-add_executable(latency_tracker_test latency_tracker_test.cpp)
-add_executable(metrics_registry_test ../servatrice/src/metrics_registry.cpp metrics_registry_test.cpp)
-add_executable(
-  card_update_progress_test ${CMAKE_SOURCE_DIR}/cockatrice/src/interface/card_database_update/card_update_progress.cpp
-                            card_update_progress_test.cpp
-)
-target_include_directories(card_update_progress_test PRIVATE ${CMAKE_SOURCE_DIR}/cockatrice/src)
-add_executable(
-  loader_local_matching_test
-  ${CMAKE_SOURCE_DIR}/cockatrice/src/interface/card_picture_loader/card_picture_loader_local.cpp
-  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/settings/cache_settings.cpp
-  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/settings/card_counter_settings.cpp
-  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/settings/shortcuts_settings.cpp
-  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/network/update/client/release_channel.cpp
-  ${VERSION_STRING_CPP}
-  loader_local_matching_test.cpp
-)
-target_include_directories(loader_local_matching_test PRIVATE ${CMAKE_SOURCE_DIR}/cockatrice/src)
-
-# Guard must match the condition for src/single_instance_manager.cpp in cockatrice/CMakeLists.txt.
-if(WITH_CLIENT)
-  add_executable(
-    single_instance_manager_test ${CMAKE_SOURCE_DIR}/cockatrice/src/single_instance_manager.cpp
-                                 single_instance_manager_test.cpp
-  )
-  target_include_directories(single_instance_manager_test PRIVATE ${CMAKE_SOURCE_DIR}/cockatrice/src)
-  target_include_directories(single_instance_manager_test PRIVATE ${CMAKE_SOURCE_DIR}/libcockatrice_utility)
-
-  add_test(NAME single_instance_manager_test COMMAND single_instance_manager_test)
-endif()
-
 find_package(GTest)
 
 if(NOT GTEST_FOUND)
@@ -129,93 +30,330 @@ if(NOT GTEST_FOUND)
   target_include_directories(gtest INTERFACE "$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/gtest-src/include>")
 
   set(GTEST_INCLUDE_DIRS "${CMAKE_BINARY_DIR}/gtest-src/include")
-  set(GTEST_BOTH_LIBRARIES gtest)
-  add_dependencies(dummy_test gtest)
-  add_dependencies(expression_test gtest)
-  add_dependencies(clamped_arithmetic_test gtest)
-  add_dependencies(test_age_formatting gtest)
-  add_dependencies(password_hash_test gtest)
-  add_dependencies(playmat_resolver_test gtest)
-  add_dependencies(deck_hash_performance_test gtest)
-  add_dependencies(server_card_counter_test gtest)
-  add_dependencies(server_counter_test gtest)
-  add_dependencies(server_rate_limiter_test gtest)
-  add_dependencies(server_developer_role_test gtest)
-  add_dependencies(server_game_join_test gtest)
-  add_dependencies(warning_categories_test gtest)
-  if(TARGET translation_loader_test)
-    add_dependencies(translation_loader_test gtest)
-  endif()
-  add_dependencies(report_categories_test gtest)
-  add_dependencies(lag_monitor_test gtest)
-  add_dependencies(latency_tracker_test gtest)
-  add_dependencies(metrics_registry_test gtest)
-  add_dependencies(card_update_progress_test gtest)
-  add_dependencies(loader_local_matching_test gtest)
-  add_dependencies(single_instance_manager_test gtest)
+  # gtest_main is not optional here. FindGTest sets GTEST_BOTH_LIBRARIES to both halves, so this
+  # has to match it or the two paths disagree about what provides main(). A test source that
+  # defines its own main() gets away with the omission; one that does not fails at link with
+  # `undefined reference to main` pointing at crt1.o, which names neither gtest nor this line.
+  set(GTEST_BOTH_LIBRARIES gtest gtest_main)
 endif()
 
+# Directory-scoped on purpose: the test subdirectories below add targets that include the
+# fetched gtest headers and do not repeat this path themselves.
 include_directories(${GTEST_INCLUDE_DIRS})
-target_link_libraries(dummy_test Threads::Threads ${GTEST_BOTH_LIBRARIES})
-target_link_libraries(expression_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES})
-target_link_libraries(
-  clamped_arithmetic_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  test_age_formatting libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  password_hash_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  playmat_resolver_test libcockatrice_deck_list libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  deck_hash_performance_test libcockatrice_deck_list libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  server_card_counter_test libcockatrice_network Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  server_counter_test libcockatrice_network Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  server_rate_limiter_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  server_developer_role_test libcockatrice_network libcockatrice_rng Threads::Threads ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  server_game_join_test libcockatrice_network_server_remote libcockatrice_rng Threads::Threads ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
-)
-target_link_libraries(
-  warning_categories_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-if(TARGET translation_loader_test)
+
+# --- Test registration ----------------------------------------------------------
+#
+# Every test target needs the same four steps: build the executable, depend on gtest when it
+# was fetched from source, link the shared test libraries, and hand the cases to CTest. The
+# `if(NOT GTEST_FOUND)` branch is the easy one to forget — omit it and the link fails with
+# undefined gtest symbols — so it lives here once instead of being repeated per test.
+#
+# This also replaces `add_test(NAME x COMMAND x)`. Naming the binary as a single CTest entry
+# hides which case failed and makes `ctest -R Suite.Case` impossible; discovery exposes each
+# TEST() as its own CTest entry instead.
+#
+# Labels: exactly one per test, because gtest_discover_tests() cannot carry more than one.
+# GoogleTestAddTests.cmake accumulates the generated script with `foreach(arg ${ARGN})`, so a
+# label list serialises as bare `LABELS ci server` in the CTestTestfile, and CTest reads only
+# the first value of a property and silently discards the rest. A label therefore classifies a
+# test into exactly one group, and the three groups cover every selection worth making:
+#
+#   ci      the default hermetic set, so `ctest -LE bench` runs everything but benchmarks
+#   server  servatrice-facing tests, so `ctest -L server` works
+#   bench   the slow suites, kept out of the default run
+#
+# A second label is a configure-time FATAL_ERROR rather than a line CTest quietly reads as one.
+# Anything orthogonal to a test's kind belongs in a helper flag beside the label, so it
+# composes with the group instead of competing for the single slot. NO_SANITIZE is such a flag.
+#
+# TIMEOUT is bounded per test because CTest's implicit default is 1500s: one hung socket wait
+# would otherwise stall CI for 25 minutes.
+#
+# EXTRA_LIBS is appended after the shared libraries so a caller adding a static archive (zlib,
+# lzma) keeps it last, which is where the linker needs it.
+
+function(cockatrice_add_test)
+  cmake_parse_arguments(
+    PARSE_ARGV 0 ARG "MANUAL;NO_SANITIZE" "NAME" "SOURCES;LIBS;LABELS;DEFINITIONS;INCLUDE_DIRS;EXTRA_LIBS"
+  )
+
+  if(NOT ARG_NAME OR NOT ARG_SOURCES)
+    message(FATAL_ERROR "cockatrice_add_test requires at least NAME and SOURCES")
+  endif()
+
+  add_executable(${ARG_NAME} ${ARG_SOURCES})
+
+  if(ARG_INCLUDE_DIRS)
+    target_include_directories(${ARG_NAME} PRIVATE ${ARG_INCLUDE_DIRS})
+  endif()
+
+  if(ARG_DEFINITIONS)
+    target_compile_definitions(${ARG_NAME} PRIVATE ${ARG_DEFINITIONS})
+  endif()
+
   target_link_libraries(
-    translation_loader_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
+    ${ARG_NAME} ${ARG_LIBS} Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES} ${ARG_EXTRA_LIBS}
+  )
+
+  # Only needed when gtest was downloaded and add_subdirectory'd above. An imported gtest
+  # target already carries its own dependency, so this must stay conditional.
+  if(NOT GTEST_FOUND)
+    add_dependencies(${ARG_NAME} gtest gtest_main)
+  endif()
+
+  # MANUAL targets are built but deliberately kept out of ctest: benchmarks that need a card
+  # database, hit the network, or measure RAM. Leaving them unregistered keeps CI hermetic
+  # and fast. They still link gtest so they can use TEST() without a second code path.
+  if(ARG_MANUAL)
+    return()
+  endif()
+
+  # NO_SANITIZE marks a target the sanitizer leg cannot run. Excluded by not handing its cases
+  # to CTest at all, rather than by a label, so the exclusion cannot rot into a line CTest
+  # quietly reads as something else. The target still builds, and still runs on the other legs.
+  if(ARG_NO_SANITIZE AND COCKATRICE_SANITIZERS)
+    return()
+  endif()
+
+  # One label only, per the note above. Rejecting a second loudly beats emitting a
+  # CTestTestfile line that CTest will quietly read as one label.
+  list(LENGTH ARG_LABELS _label_count)
+  if(_label_count GREATER 1)
+    message(FATAL_ERROR "${ARG_NAME}: pass at most one label, got '${ARG_LABELS}'")
+  endif()
+  if(NOT ARG_LABELS)
+    set(ARG_LABELS ci)
+  endif()
+
+  # GoogleTestAddTests defaults DISCOVERY_TIMEOUT to 5s, which is ample for a plain debug
+  # binary (--gtest_list_tests costs 0.04s) but not for an instrumented one (~2.8s cold, and
+  # discovery runs several binaries concurrently behind a -j build). Left at the default, a
+  # sanitizer build fails at the *link* step with a bare "Process terminated due to timeout"
+  # and no hint that discovery, not the test, is what is slow.
+  if(COCKATRICE_SANITIZERS)
+    set(_discovery_timeout 300)
+  else()
+    set(_discovery_timeout 60)
+  endif()
+
+  gtest_discover_tests(
+    ${ARG_NAME} DISCOVERY_MODE POST_BUILD DISCOVERY_TIMEOUT ${_discovery_timeout}
+    PROPERTIES LABELS "${ARG_LABELS}"
+    TIMEOUT 60
+  )
+endfunction()
+
+# Same wiring for targets that are built but deliberately kept out of ctest: benchmarks that
+# need a card database, hit the network, or measure RAM. A separate name rather than a MANUAL
+# flag spelled out at each call site, so "this is not in the CI suite" is visible in the CMake
+# file. Note the unquoted expansions: an unset multi-value keyword expands to zero arguments,
+# which is what lets this forward a caller's keywords verbatim without tripping the FATAL_ERROR
+# guard above on an empty list.
+function(cockatrice_add_manual_test)
+  cmake_parse_arguments(PARSE_ARGV 0 ARG "" "NAME" "SOURCES;LIBS;DEFINITIONS;INCLUDE_DIRS;EXTRA_LIBS")
+
+  cockatrice_add_test(
+    NAME
+    ${ARG_NAME}
+    SOURCES
+    ${ARG_SOURCES}
+    LIBS
+    ${ARG_LIBS}
+    DEFINITIONS
+    ${ARG_DEFINITIONS}
+    INCLUDE_DIRS
+    ${ARG_INCLUDE_DIRS}
+    EXTRA_LIBS
+    ${ARG_EXTRA_LIBS}
+    MANUAL
+  )
+endfunction()
+
+# --- Unit tests ------------------------------------------------------------------
+
+cockatrice_add_test(NAME expression_test SOURCES expression_test.cpp LIBS libcockatrice_utility)
+cockatrice_add_test(NAME clamped_arithmetic_test SOURCES clamped_arithmetic_test.cpp LIBS libcockatrice_utility)
+cockatrice_add_test(NAME test_age_formatting SOURCES test_age_formatting.cpp LIBS libcockatrice_utility)
+cockatrice_add_test(NAME password_hash_test SOURCES password_hash_test.cpp LIBS libcockatrice_utility)
+cockatrice_add_test(NAME report_categories_test SOURCES report_categories_test.cpp LIBS libcockatrice_utility)
+cockatrice_add_test(NAME warning_categories_test SOURCES warning_categories_test.cpp LIBS libcockatrice_utility)
+cockatrice_add_test(
+  NAME
+  playmat_resolver_test
+  SOURCES
+  playmat_resolver_test.cpp
+  LIBS
+  libcockatrice_deck_list
+  libcockatrice_utility
+)
+cockatrice_add_test(
+  NAME
+  server_rate_limiter_test
+  SOURCES
+  server_rate_limiter_test.cpp
+  LIBS
+  libcockatrice_utility
+  LABELS
+  server
+)
+cockatrice_add_test(
+  NAME
+  server_card_counter_test
+  SOURCES
+  server_card_counter_test.cpp
+  LIBS
+  libcockatrice_network
+  LABELS
+  server
+)
+cockatrice_add_test(
+  NAME
+  server_counter_test
+  SOURCES
+  server_counter_test.cpp
+  LIBS
+  libcockatrice_network
+  LABELS
+  server
+)
+cockatrice_add_test(
+  NAME
+  server_developer_role_test
+  NO_SANITIZE
+  SOURCES
+  server_developer_role_test.cpp
+  LIBS
+  libcockatrice_network
+  libcockatrice_rng
+  LABELS
+  server
+)
+cockatrice_add_test(
+  NAME
+  server_game_join_test
+  SOURCES
+  server_game_join_test.cpp
+  LIBS
+  libcockatrice_network_server_remote
+  libcockatrice_rng
+  LABELS
+  server
+)
+cockatrice_add_test(
+  NAME
+  latency_tracker_test
+  SOURCES
+  latency_tracker_test.cpp
+  LIBS
+  libcockatrice_network
+  LABELS
+  server
+)
+cockatrice_add_test(
+  NAME
+  lag_monitor_test
+  SOURCES
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/lag_monitor.cpp
+  lag_monitor_test.cpp
+  INCLUDE_DIRS
+  ${CMAKE_SOURCE_DIR}/cockatrice/src
+)
+cockatrice_add_test(
+  NAME
+  metrics_registry_test
+  SOURCES
+  ${CMAKE_SOURCE_DIR}/servatrice/src/metrics_registry.cpp
+  metrics_registry_test.cpp
+  INCLUDE_DIRS
+  ${CMAKE_SOURCE_DIR}/servatrice/src
+  LABELS
+  server
+)
+cockatrice_add_test(
+  NAME
+  card_update_progress_test
+  SOURCES
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/interface/card_database_update/card_update_progress.cpp
+  card_update_progress_test.cpp
+  INCLUDE_DIRS
+  ${CMAKE_SOURCE_DIR}/cockatrice/src
+)
+cockatrice_add_test(
+  NAME
+  loader_local_matching_test
+  SOURCES
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/interface/card_picture_loader/card_picture_loader_local.cpp
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/settings/cache_settings.cpp
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/settings/card_counter_settings.cpp
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/settings/shortcuts_settings.cpp
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/client/network/update/client/release_channel.cpp
+  ${VERSION_STRING_CPP}
+  loader_local_matching_test.cpp
+  LIBS
+  libcockatrice_settings
+  INCLUDE_DIRS
+  ${CMAKE_SOURCE_DIR}/cockatrice/src
+)
+cockatrice_add_test(
+  NAME
+  deck_hash_performance_test
+  SOURCES
+  deck_hash_performance_test.cpp
+  LIBS
+  libcockatrice_deck_list
+  libcockatrice_utility
+  LABELS
+  bench
+)
+
+# The translation loader test compiles a .qm fixture, which needs lrelease from Qt Linguist.
+if(TARGET Qt6::lrelease)
+  set(TRANSLATION_LOADER_TEST_QM "${CMAKE_CURRENT_BINARY_DIR}/translation_loader_test_de.qm")
+  add_custom_command(
+    OUTPUT "${TRANSLATION_LOADER_TEST_QM}"
+    COMMAND Qt6::lrelease "${CMAKE_CURRENT_SOURCE_DIR}/translation_loader_test.ts" -qm "${TRANSLATION_LOADER_TEST_QM}"
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/translation_loader_test.ts"
+    COMMENT "Compiling translation_loader_test.ts"
+  )
+  add_custom_target(translation_loader_test_qm DEPENDS "${TRANSLATION_LOADER_TEST_QM}")
+
+  cockatrice_add_test(
+    NAME
+    translation_loader_test
+    SOURCES
+    translation_loader_test.cpp
+    LIBS
+    libcockatrice_utility
+    DEFINITIONS
+    TRANSLATION_LOADER_TEST_DIR="${CMAKE_CURRENT_BINARY_DIR}"
+  )
+  add_dependencies(translation_loader_test translation_loader_test_qm)
+
+  # A multi-config generator (MSBuild, Xcode) puts the executable in a per-config subdirectory while
+  # the .qm stays in the current binary directory, so copy the fixture next to the binary: that is the
+  # layout ABuildTreeFindsTheTranslationsNextToTheExecutable is about, and the only one it finds on
+  # those generators.
+  add_custom_command(
+    TARGET translation_loader_test
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${TRANSLATION_LOADER_TEST_QM}"
+            "$<TARGET_FILE_DIR:translation_loader_test>/"
+    VERBATIM
   )
 endif()
-target_link_libraries(
-  report_categories_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_link_libraries(lag_monitor_test Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES})
-target_link_libraries(
-  latency_tracker_test libcockatrice_network Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_include_directories(metrics_registry_test PRIVATE ${CMAKE_SOURCE_DIR}/servatrice/src)
-target_link_libraries(metrics_registry_test ${TEST_QT_MODULES} Threads::Threads ${GTEST_BOTH_LIBRARIES})
-target_link_libraries(card_update_progress_test Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES})
-target_link_libraries(
-  loader_local_matching_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
 
+# Guard must match the condition for src/single_instance_manager.cpp in cockatrice/CMakeLists.txt.
 if(WITH_CLIENT)
-  target_link_libraries(single_instance_manager_test Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES})
+  cockatrice_add_test(
+    NAME
+    single_instance_manager_test
+    SOURCES
+    ${CMAKE_SOURCE_DIR}/cockatrice/src/single_instance_manager.cpp
+    single_instance_manager_test.cpp
+    INCLUDE_DIRS
+    ${CMAKE_SOURCE_DIR}/cockatrice/src
+    ${CMAKE_SOURCE_DIR}/libcockatrice_utility
+  )
 endif()
 
 add_subdirectory(card_zone_algorithms)
diff --git a/tests/card_zone_algorithms/CMakeLists.txt b/tests/card_zone_algorithms/CMakeLists.txt
index e03d8f77d..945f8a0ed 100644
--- a/tests/card_zone_algorithms/CMakeLists.txt
+++ b/tests/card_zone_algorithms/CMakeLists.txt
@@ -1,15 +1,4 @@
-add_executable(card_zone_algorithms_test card_zone_algorithms_test.cpp)
-
-target_include_directories(card_zone_algorithms_test PRIVATE ${CMAKE_SOURCE_DIR}/cockatrice/src/game/zones)
-
-target_link_libraries(
-  card_zone_algorithms_test
-  PRIVATE Threads::Threads
-  PRIVATE ${GTEST_BOTH_LIBRARIES}
+cockatrice_add_test(
+  NAME card_zone_algorithms_test SOURCES card_zone_algorithms_test.cpp INCLUDE_DIRS
+  ${CMAKE_SOURCE_DIR}/cockatrice/src/game/zones
 )
-
-add_test(NAME card_zone_algorithms_test COMMAND card_zone_algorithms_test)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(card_zone_algorithms_test gtest)
-endif()
diff --git a/tests/carddatabase/CMakeLists.txt b/tests/carddatabase/CMakeLists.txt
index 811cebc1d..22171a9e8 100644
--- a/tests/carddatabase/CMakeLists.txt
+++ b/tests/carddatabase/CMakeLists.txt
@@ -9,61 +9,46 @@ add_definitions("-DCARDDB_DATADIR=\"${CMAKE_CURRENT_SOURCE_DIR}/data/\"")
 # ------------------------
 # Card Database Test
 # ------------------------
-add_executable(carddatabase_test ${MOCKS_SOURCES} ${VERSION_STRING_CPP} carddatabase_test.cpp mocks.cpp)
-
-target_link_libraries(
+cockatrice_add_test(
+  NAME
   carddatabase_test
-  PRIVATE libcockatrice_card
-  PRIVATE Threads::Threads
-  PRIVATE ${GTEST_BOTH_LIBRARIES}
-  PRIVATE ${TEST_QT_MODULES}
+  SOURCES
+  ${VERSION_STRING_CPP}
+  carddatabase_test.cpp
+  mocks.cpp
+  LIBS
+  libcockatrice_card
 )
 
-add_test(NAME carddatabase_test COMMAND carddatabase_test)
-
-# ------------------------
-# Load Benchmark (manual, not run in CI)
-# ------------------------
-add_executable(load_benchmark ${MOCKS_SOURCES} ${VERSION_STRING_CPP} load_benchmark.cpp mocks.cpp)
-
-target_link_libraries(
-  load_benchmark
-  PRIVATE libcockatrice_card
-  PRIVATE libcockatrice_models
-  PRIVATE Threads::Threads
-  PRIVATE ${GTEST_BOTH_LIBRARIES}
-  PRIVATE ${TEST_QT_MODULES}
-)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(load_benchmark gtest)
-endif()
-
 # ------------------------
 # Filter String Test
 # (guard must match the condition for libcockatrice_filters in the root CMakeLists.txt)
 # ------------------------
 if(WITH_ORACLE OR WITH_CLIENT)
-  add_executable(filter_string_test ${MOCKS_SOURCES} ${VERSION_STRING_CPP} filter_string_test.cpp mocks.cpp)
-
-  target_link_libraries(
+  cockatrice_add_test(
+    NAME
     filter_string_test
-    PRIVATE libcockatrice_filters
-    PRIVATE Threads::Threads
-    PRIVATE ${GTEST_BOTH_LIBRARIES}
-    PRIVATE ${TEST_QT_MODULES}
+    SOURCES
+    ${VERSION_STRING_CPP}
+    filter_string_test.cpp
+    mocks.cpp
+    LIBS
+    libcockatrice_filters
   )
-
-  add_test(NAME filter_string_test COMMAND filter_string_test)
-
-  if(NOT GTEST_FOUND)
-    add_dependencies(filter_string_test gtest)
-  endif()
 endif()
 
 # ------------------------
-# Dependencies on gtest
+# Load Benchmark (manual, not run in CI)
 # ------------------------
-if(NOT GTEST_FOUND)
-  add_dependencies(carddatabase_test gtest)
-endif()
+cockatrice_add_manual_test(
+  NAME
+  load_benchmark
+  SOURCES
+  ${VERSION_STRING_CPP}
+  load_benchmark.cpp
+  mocks.cpp
+  LIBS
+  libcockatrice_card
+  libcockatrice_models
+  MANUAL
+)
diff --git a/tests/deck_list_model/CMakeLists.txt b/tests/deck_list_model/CMakeLists.txt
index e3096c559..cd7d693f3 100644
--- a/tests/deck_list_model/CMakeLists.txt
+++ b/tests/deck_list_model/CMakeLists.txt
@@ -1,33 +1,23 @@
-add_executable(deck_list_model_custom_zones_test ${VERSION_STRING_CPP} deck_list_model_custom_zones_test.cpp)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(deck_list_model_custom_zones_test gtest)
-endif()
-
-target_link_libraries(
+cockatrice_add_test(
+  NAME
   deck_list_model_custom_zones_test
+  SOURCES
+  ${VERSION_STRING_CPP}
+  deck_list_model_custom_zones_test.cpp
+  LIBS
   libcockatrice_models
   libcockatrice_card
   libcockatrice_deck_list
-  Threads::Threads
-  ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
 )
-add_test(NAME deck_list_model_custom_zones_test COMMAND deck_list_model_custom_zones_test)
 
-add_executable(deck_list_model_zone_integration_test ${VERSION_STRING_CPP} deck_list_model_zone_integration_test.cpp)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(deck_list_model_zone_integration_test gtest)
-endif()
-
-target_link_libraries(
+cockatrice_add_test(
+  NAME
   deck_list_model_zone_integration_test
+  SOURCES
+  ${VERSION_STRING_CPP}
+  deck_list_model_zone_integration_test.cpp
+  LIBS
   libcockatrice_models
   libcockatrice_card
   libcockatrice_deck_list
-  Threads::Threads
-  ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
 )
-add_test(NAME deck_list_model_zone_integration_test COMMAND deck_list_model_zone_integration_test)
diff --git a/tests/deck_list_zones/CMakeLists.txt b/tests/deck_list_zones/CMakeLists.txt
index 0710be94d..7af8fd187 100644
--- a/tests/deck_list_zones/CMakeLists.txt
+++ b/tests/deck_list_zones/CMakeLists.txt
@@ -1,10 +1 @@
-add_executable(deck_list_zones_test deck_list_zones_test.cpp)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(deck_list_zones_test gtest)
-endif()
-
-target_link_libraries(
-  deck_list_zones_test libcockatrice_deck_list Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-add_test(NAME deck_list_zones_test COMMAND deck_list_zones_test)
+cockatrice_add_test(NAME deck_list_zones_test SOURCES deck_list_zones_test.cpp LIBS libcockatrice_deck_list)
diff --git a/tests/dummy_test.cpp b/tests/dummy_test.cpp
deleted file mode 100644
index 8fd9c78dd..000000000
--- a/tests/dummy_test.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "gtest/gtest.h"
-#include <string>
-
-namespace
-{
-class FooTest : public ::testing::Test
-{
-};
-
-TEST(DummyTest, Works)
-{
-    ASSERT_EQ(1, 1) << "One is not equal to one";
-}
-} // namespace
-
-int main(int argc, char **argv)
-{
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}
\ No newline at end of file
diff --git a/tests/loading_from_clipboard/CMakeLists.txt b/tests/loading_from_clipboard/CMakeLists.txt
index 719d62f45..88711e457 100644
--- a/tests/loading_from_clipboard/CMakeLists.txt
+++ b/tests/loading_from_clipboard/CMakeLists.txt
@@ -1,12 +1,13 @@
 add_definitions("-DCARDDB_DATADIR=\"${CMAKE_CURRENT_SOURCE_DIR}/data/\"")
-add_executable(loading_from_clipboard_test ${VERSION_STRING_CPP} clipboard_testing.cpp loading_from_clipboard_test.cpp)
 
-if(NOT GTEST_FOUND)
-  add_dependencies(loading_from_clipboard_test gtest)
-endif()
-
-target_link_libraries(
-  loading_from_clipboard_test libcockatrice_deck_list libcockatrice_card Threads::Threads ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
+cockatrice_add_test(
+  NAME
+  loading_from_clipboard_test
+  SOURCES
+  ${VERSION_STRING_CPP}
+  clipboard_testing.cpp
+  loading_from_clipboard_test.cpp
+  LIBS
+  libcockatrice_deck_list
+  libcockatrice_card
 )
-add_test(NAME loading_from_clipboard_test COMMAND loading_from_clipboard_test)
diff --git a/tests/movecard_tests/CMakeLists.txt b/tests/movecard_tests/CMakeLists.txt
index 769047148..68d8fc84c 100755
--- a/tests/movecard_tests/CMakeLists.txt
+++ b/tests/movecard_tests/CMakeLists.txt
@@ -1,16 +1,11 @@
-add_executable(reverse_card_move_test reverse_card_move_test.cpp)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(reverse_card_move_test gtest)
-endif()
-
-target_link_libraries(
+cockatrice_add_test(
+  NAME
   reverse_card_move_test
-  PRIVATE libcockatrice_network_server_remote
-  PRIVATE libcockatrice_rng
-  PRIVATE Threads::Threads
-  PRIVATE ${GTEST_BOTH_LIBRARIES}
-  PRIVATE ${TEST_QT_MODULES}
+  SOURCES
+  reverse_card_move_test.cpp
+  LIBS
+  libcockatrice_network_server_remote
+  libcockatrice_rng
+  LABELS
+  server
 )
-
-add_test(NAME reverse_card_move_test COMMAND reverse_card_move_test)
diff --git a/tests/oracle/CMakeLists.txt b/tests/oracle/CMakeLists.txt
index 9bc5ee5be..c896c7960 100644
--- a/tests/oracle/CMakeLists.txt
+++ b/tests/oracle/CMakeLists.txt
@@ -1,37 +1,31 @@
-add_executable(parse_cipt_test ../../oracle/src/parsehelpers.cpp parse_cipt_test.cpp)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(parse_cipt_test gtest)
-endif()
-
-target_link_libraries(parse_cipt_test Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES})
-
-add_test(NAME parse_cipt_test COMMAND parse_cipt_test)
+cockatrice_add_test(NAME parse_cipt_test SOURCES ../../oracle/src/parsehelpers.cpp parse_cipt_test.cpp)
 
 # Oracle importer unit tests
-add_executable(
-  oracle_importer_test ${VERSION_STRING_CPP} ../../oracle/src/oracleimporter.cpp ../../oracle/src/parsehelpers.cpp
-                       ../../oracle/src/raw_json_scanner.cpp oracle_importer_test.cpp
+cockatrice_add_test(
+  NAME
+  oracle_importer_test
+  SOURCES
+  ${VERSION_STRING_CPP}
+  ../../oracle/src/oracleimporter.cpp
+  ../../oracle/src/parsehelpers.cpp
+  ../../oracle/src/raw_json_scanner.cpp
+  oracle_importer_test.cpp
+  LIBS
+  libcockatrice_card
+  libcockatrice_interfaces
 )
 
-if(NOT GTEST_FOUND)
-  add_dependencies(oracle_importer_test gtest)
-endif()
-
-target_link_libraries(
-  oracle_importer_test libcockatrice_card libcockatrice_interfaces Threads::Threads ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
-)
-
-add_test(NAME oracle_importer_test COMMAND oracle_importer_test)
-
 # Oracle importer benchmark tests (manual, not run in CI, incl. RAM benchmark)
 # Optional compression libs, mirrored from oracle/CMakeLists.txt, so the benchmark
 # can download and decompress whatever AllPrintings format the default URL selects.
+# add_definitions() is directory-scoped and order-independent, so HAS_ZLIB/HAS_LZMA also
+# reach the two unit tests above. That is harmless: those macros gate code only in
+# oracle/src/pages.cpp and oracle/src/pagetemplates.cpp, which no test target compiles.
 find_package(ZLIB)
 if(ZLIB_FOUND)
   add_definitions("-DHAS_ZLIB")
   set(_ORACLE_BENCH_EXTRA_SOURCES ../../oracle/src/zip/unzip.cpp ../../oracle/src/zip/zipglobal.cpp)
+  cockatrice_disable_sanitizers_for(${_ORACLE_BENCH_EXTRA_SOURCES})
   set(_ORACLE_BENCH_EXTRA_LIBRARIES ${ZLIB_LIBRARIES})
   include_directories(${ZLIB_INCLUDE_DIRS})
 else()
@@ -42,28 +36,27 @@ find_package(LibLZMA)
 if(LIBLZMA_FOUND)
   add_definitions("-DHAS_LZMA")
   list(APPEND _ORACLE_BENCH_EXTRA_SOURCES ../../oracle/src/lzma/decompress.cpp)
+  cockatrice_disable_sanitizers_for(../../oracle/src/lzma/decompress.cpp)
   list(APPEND _ORACLE_BENCH_EXTRA_LIBRARIES ${LIBLZMA_LIBRARIES})
   include_directories(${LIBLZMA_INCLUDE_DIRS})
 else()
   message(STATUS "Oracle tests: LibLZMA not found; xz download benchmark disabled")
 endif()
 
-add_executable(
-  oracle_importer_benchmark_test
-  ${VERSION_STRING_CPP} ../../oracle/src/oracleimporter.cpp ../../oracle/src/parsehelpers.cpp
-  ../../oracle/src/raw_json_scanner.cpp oracle_importer_benchmark_test.cpp ${_ORACLE_BENCH_EXTRA_SOURCES}
-)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(oracle_importer_benchmark_test gtest)
-endif()
-
-target_link_libraries(
+cockatrice_add_manual_test(
+  NAME
   oracle_importer_benchmark_test
+  SOURCES
+  ${VERSION_STRING_CPP}
+  ../../oracle/src/oracleimporter.cpp
+  ../../oracle/src/parsehelpers.cpp
+  ../../oracle/src/raw_json_scanner.cpp
+  oracle_importer_benchmark_test.cpp
+  ${_ORACLE_BENCH_EXTRA_SOURCES}
+  LIBS
   libcockatrice_card
   libcockatrice_interfaces
-  Threads::Threads
-  ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
+  EXTRA_LIBS
   ${_ORACLE_BENCH_EXTRA_LIBRARIES}
+  MANUAL
 )
diff --git a/tests/picture_loader_benchmark/CMakeLists.txt b/tests/picture_loader_benchmark/CMakeLists.txt
index a3b75fe88..0684f58f4 100644
--- a/tests/picture_loader_benchmark/CMakeLists.txt
+++ b/tests/picture_loader_benchmark/CMakeLists.txt
@@ -1,8 +1,10 @@
-# Manual benchmark hitting the real card image hosts. Not registered with
-# add_test(): it requires a cards.xml, touches the network for minutes at a
-# time, and needs network access. Build it explicitly and run by hand.
-add_executable(
+# Manual benchmark hitting the real card image hosts. Not registered with CTest: it requires a
+# cards.xml, touches the network for minutes at a time, and needs network access. Build it
+# explicitly and run by hand.
+cockatrice_add_manual_test(
+  NAME
   picture_loader_benchmark_test
+  SOURCES
   ${VERSION_STRING_CPP}
   ../../cockatrice/src/interface/card_picture_loader/card_picture_loader_local.cpp
   ../../cockatrice/src/interface/card_picture_loader/card_picture_to_load.cpp
@@ -11,16 +13,12 @@ add_executable(
   ../../cockatrice/src/client/settings/cache_settings.h
   picture_loader_benchmark.cpp
   settings_cache_mock.cpp
-)
-
-target_include_directories(picture_loader_benchmark_test PRIVATE ${CMAKE_SOURCE_DIR}/cockatrice/src)
-
-target_link_libraries(
-  picture_loader_benchmark_test
+  LIBS
   libcockatrice_card
   libcockatrice_settings
   libcockatrice_interfaces
   libcockatrice_utility
-  Threads::Threads
-  ${TEST_QT_MODULES}
+  INCLUDE_DIRS
+  ${CMAKE_SOURCE_DIR}/cockatrice/src
+  MANUAL
 )
diff --git a/tests/settings/CMakeLists.txt b/tests/settings/CMakeLists.txt
index 7ee32a645..98bed1f4b 100644
--- a/tests/settings/CMakeLists.txt
+++ b/tests/settings/CMakeLists.txt
@@ -1,26 +1,14 @@
-add_executable(settings_manager_test settings_manager_test.cpp)
-add_executable(settings_defaults_test settings_defaults_test.cpp)
-add_executable(settings_migration_test settings_migration_test.cpp)
+cockatrice_add_test(NAME settings_manager_test SOURCES settings_manager_test.cpp LIBS libcockatrice_settings)
 
-target_link_libraries(
-  settings_manager_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
+cockatrice_add_test(
+  NAME
+  settings_defaults_test
+  SOURCES
+  settings_defaults_test.cpp
+  LIBS
+  libcockatrice_settings
+  DEFINITIONS
+  SETTINGS_UNIT_TEST
 )
 
-target_link_libraries(
-  settings_defaults_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-target_compile_definitions(settings_defaults_test PRIVATE SETTINGS_UNIT_TEST)
-
-target_link_libraries(
-  settings_migration_test libcockatrice_settings Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
-)
-
-add_test(NAME settings_manager_test COMMAND settings_manager_test)
-add_test(NAME settings_defaults_test COMMAND settings_defaults_test)
-add_test(NAME settings_migration_test COMMAND settings_migration_test)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(settings_manager_test gtest)
-  add_dependencies(settings_defaults_test gtest)
-  add_dependencies(settings_migration_test gtest)
-endif()
+cockatrice_add_test(NAME settings_migration_test SOURCES settings_migration_test.cpp LIBS libcockatrice_settings)
diff --git a/tests/theme_migration/CMakeLists.txt b/tests/theme_migration/CMakeLists.txt
index ac202210e..93493ee5f 100644
--- a/tests/theme_migration/CMakeLists.txt
+++ b/tests/theme_migration/CMakeLists.txt
@@ -1,5 +1,7 @@
-add_executable(
+cockatrice_add_test(
+  NAME
   theme_migration_test
+  SOURCES
   ${CMAKE_SOURCE_DIR}/cockatrice/src/interface/theme_manager.cpp
   ${CMAKE_SOURCE_DIR}/cockatrice/src/interface/theme_config.cpp
   ${CMAKE_SOURCE_DIR}/cockatrice/src/interface/pixel_map_generator.cpp
@@ -9,22 +11,11 @@ add_executable(
   ${CMAKE_SOURCE_DIR}/cockatrice/src/client/network/update/client/release_channel.cpp
   ${VERSION_STRING_CPP}
   theme_migration_test.cpp
-)
-target_include_directories(theme_migration_test PRIVATE ${CMAKE_SOURCE_DIR}/cockatrice/src)
-
-target_link_libraries(
-  theme_migration_test
+  LIBS
   libcockatrice_settings
   libcockatrice_network
   libcockatrice_network_server_remote
   libcockatrice_protocol
-  Threads::Threads
-  ${GTEST_BOTH_LIBRARIES}
-  ${TEST_QT_MODULES}
+  INCLUDE_DIRS
+  ${CMAKE_SOURCE_DIR}/cockatrice/src
 )
-
-add_test(NAME theme_migration_test COMMAND theme_migration_test)
-
-if(NOT GTEST_FOUND)
-  add_dependencies(theme_migration_test gtest)
-endif()