1 files changed, 131 insertions, 0 deletions
diff --git a/test/tx/cmake/thread_transition/CMakeLists.txt b/test/tx/cmake/thread_transition/CMakeLists.txt
new file mode 100644
index 00000000..342ca839
--- /dev/null
+++ b/test/tx/cmake/thread_transition/CMakeLists.txt
@@ -0,0 +1,131 @@
+# Portions of this file were generated with AI assistance.
+
+cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+cmake_policy(SET CMP0057 NEW)
+
+project(thread_transition_test LANGUAGES C)
+
+set(REPO_ROOT ${CMAKE_CURRENT_LIST_DIR}/../../../..)
+set(SOURCE_DIR ${REPO_ROOT}/test/tx/thread_transition)
+
+# TX_NOT_INTERRUPTABLE and TX_DISABLE_ERROR_CHECKING are not among the five build
+# configurations this tree compiles, and the tree builds the whole ThreadX library
+# once per configuration, so neither can be reached from inside the regression
+# suite. Both matter to the completion and termination transitions:
+#
+#   - TX_NOT_INTERRUPTABLE selects a different transition, in which the exit
+#     notification callback runs with interrupts disabled and the interruptable
+#     suspension path -- which is what sets and clears the transition marker in the
+#     configurations the tree does build -- is not used at all. The marker is set
+#     and cleared there by stores that exist only in that configuration, and a
+#     marker left set would make a normally completed thread permanently
+#     undeletable.
+#
+#   - TX_DISABLE_ERROR_CHECKING removes the _txe_ wrappers, so the public names bind
+#     straight to the core services. The refusal lives in the core services for that
+#     reason, and the way to show it is to call the public names in a build with no
+#     wrappers.
+#
+# So the four sources that change are compiled directly into a test executable, once
+# per combination, with recorders standing behind the scheduler services they call.
+# That is the same technique the module manager tests in this tree use, for the same
+# reason: the code under test cannot be reached through the library the suite links.
+#
+# These executables are deliberately left out of the coverage instrumentation. The
+# same source compiled under different feature macros has a different line set, and
+# merging those into the union the coverage report takes would confuse the figure
+# rather than add to it. The coverage figure belongs to the five configurations the
+# tree builds, and every line this change adds outside a TX_NOT_INTERRUPTABLE guard
+# is in them.
+
+set(transition_kernel_sources
+    ${REPO_ROOT}/common/src/tx_thread_shell_entry.c
+    ${REPO_ROOT}/common/src/tx_thread_terminate.c
+    ${REPO_ROOT}/common/src/tx_thread_delete.c
+    ${REPO_ROOT}/common/src/tx_thread_reset.c
+    ${REPO_ROOT}/common/src/txe_thread_delete.c
+    ${REPO_ROOT}/common/src/txe_thread_reset.c
+    ${REPO_ROOT}/common/src/txe_thread_terminate.c
+    ${REPO_ROOT}/common/src/tx_thread_initialize.c)
+
+set(transition_sources
+    ${SOURCE_DIR}/threadx_thread_transition_configuration_test.c
+    ${transition_kernel_sources})
+
+# The shim goes on the kernel sources only, not on the test. It defines
+# TX_SOURCE_CODE, which is what tells tx_api.h to leave the public service names
+# unmapped so that internal sources can use the core names; the test needs the
+# opposite, because calling the public names and letting tx_api.h decide what they
+# bind to is exactly what the TX_DISABLE_ERROR_CHECKING configuration is here to
+# demonstrate.
+if(MSVC)
+  set(transition_kernel_compile_options
+      "/FI${SOURCE_DIR}/threadx_thread_transition_host_test_port.h")
+  set(transition_undefine_options /UTX_ENABLE_EVENT_TRACE
+                                  /UTX_ENABLE_EVENT_LOG)
+else()
+  set(transition_kernel_compile_options
+      "-include;${SOURCE_DIR}/threadx_thread_transition_host_test_port.h")
+  set(transition_undefine_options -UTX_ENABLE_EVENT_TRACE
+                                  -UTX_ENABLE_EVENT_LOG)
+endif()
+
+set_source_files_properties(
+  ${transition_kernel_sources}
+  DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+  PROPERTIES COMPILE_OPTIONS "${transition_kernel_compile_options}")
+
+# Each entry is a test-name suffix, a colon, and the feature macros that define the
+# configuration, separated by "|". A semicolon cannot be used as that separator: it
+# is CMake's own list separator, so the foreach below would iterate the macros
+# instead of the configurations.
+set(transition_configurations
+    "ni:TX_NOT_INTERRUPTABLE"
+    "ni_no_error_checking:TX_NOT_INTERRUPTABLE|TX_DISABLE_ERROR_CHECKING"
+    "ni_no_notify:TX_NOT_INTERRUPTABLE|TX_DISABLE_NOTIFY_CALLBACKS"
+    "no_error_checking:TX_DISABLE_ERROR_CHECKING")
+
+foreach(configuration ${transition_configurations})
+
+  string(REPLACE ":" ";" configuration_parts ${configuration})
+  list(GET configuration_parts 0 configuration_name)
+  list(GET configuration_parts 1 configuration_macro_text)
+  string(REPLACE "|" ";" configuration_macros ${configuration_macro_text})
+
+  set(test_name threadx_thread_transition_${configuration_name}_test)
+  # Keep the internal target name short.  CMake includes it in every object path,
+  # and the descriptive test name can otherwise reach the legacy MSVC MAX_PATH
+  # boundary in a normally nested Windows worktree.
+  set(test_target tx_tt_${configuration_name})
+
+  add_executable(${test_target} ${transition_sources})
+
+  target_include_directories(
+    ${test_target}
+    PRIVATE ${SOURCE_DIR}
+            ${REPO_ROOT}/common/inc
+            ${REPO_ROOT}/ports/${THREADX_ARCH}/${THREADX_TOOLCHAIN}/inc)
+
+  target_compile_definitions(${test_target} PRIVATE ${configuration_macros})
+
+  # This directory is configured once per build configuration of the tree, so
+  # these executables inherit whichever feature macros that configuration sets --
+  # which is useful, since it means the two configurations above are also seen in
+  # combination with stack checking and with the other four. The one that cannot
+  # be inherited is event tracing: the trace macros in these sources reference the
+  # trace component's buffer and registry, and this harness links four kernel
+  # sources rather than the library, so the references would not resolve. The
+  # trace insertions in these same sources are covered by the tree's own
+  # trace_build configuration, where the whole library is linked, so nothing is
+  # lost by turning tracing off here. Event logging is turned off for the same
+  # reason; no configuration of the tree enables it.
+  #
+  # The undefine options have to reach the test source as well as the kernel sources,
+  # because TX_ENABLE_EVENT_TRACE is visible to tx_api.h and the two must agree on
+  # what the headers declare. Target compile options land after the directory's
+  # definition flags on the command line, which is what makes them effective.
+  target_compile_options(${test_target} PRIVATE ${transition_undefine_options})
+
+  add_test(${CMAKE_BUILD_TYPE}::${test_name} ${test_target})
+
+endforeach()