From 8aaeb2959b77fd8e27172737b21dd9247904b511 Mon Sep 17 00:00:00 2001
From: Allison Piper <alliepiper16@gmail.com>
Date: Mon, 7 Oct 2024 18:37:22 -0400
Subject: [PATCH] Consolidate header testing infra. (#2460)

---
 CMakeLists.txt                                |   1 +
 cmake/CCCLGenerateHeaderTests.cmake           | 111 ++++++++++++++++++
 .../header_test.in => cmake/header_test.cu.in |  59 +++++-----
 cub/cmake/CubHeaderTesting.cmake              |  24 ++--
 cub/cmake/header_test.in                      |  72 ------------
 cudax/cmake/cudaxHeaderTesting.cmake          |  38 +++---
 cudax/cmake/header_test.in.cu                 |  20 +++-
 thrust/cmake/ThrustHeaderTesting.cmake        |  94 +++++++--------
 8 files changed, 226 insertions(+), 193 deletions(-)
 create mode 100644 cmake/CCCLGenerateHeaderTests.cmake
 rename thrust/cmake/header_test.in => cmake/header_test.cu.in (52%)
 delete mode 100644 cub/cmake/header_test.in

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f87ad146174..5e9f68c14eb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -58,6 +58,7 @@ if (CCCL_TOPLEVEL_PROJECT)
   include(cmake/CCCLBuildCompilerTargets.cmake)
   include(cmake/CCCLClangdCompileInfo.cmake)
   include(cmake/CCCLConfigureTarget.cmake)
+  include(cmake/CCCLGenerateHeaderTests.cmake)
   include(cmake/CCCLGetDependencies.cmake)
 
   cccl_build_compiler_targets()
diff --git a/cmake/CCCLGenerateHeaderTests.cmake b/cmake/CCCLGenerateHeaderTests.cmake
new file mode 100644
index 00000000000..e483b194513
--- /dev/null
+++ b/cmake/CCCLGenerateHeaderTests.cmake
@@ -0,0 +1,111 @@
+# Usage:
+# cccl_generate_header_tests(<target_name> <project_include_path>
+#                            [cccl_configure_target options]
+#                            [LANGUAGE <CXX|CUDA>]
+#                            [HEADER_TEMPLATE <template>]
+#                            [GLOBS <glob1> [glob2 ...]]
+#                            [EXCLUDES <glob1> [glob2 ...]]
+#                            [HEADERS <header1> [header2 ...]]
+# )
+#
+# Options:
+# target_name: The name of the meta-target that will build this set of header tests.
+# project_include_path: The path to the project's include directory, relative to <CCCL_SOURCE_DIR>.
+# cccl_configure_target options: Options to pass to cccl_configure_target. Must appear before any other named arguments.
+# LANGUAGE: The language to use for the header tests. Defaults to CUDA.
+# HEADER_TEMPLATE: A file that will be used as a template for each header test. The template will be configured for each header.
+# GLOBS: All files that match these globbing patterns will be included in the header tests, unless they also match EXCLUDES.
+# EXCLUDES: Files that match these globbing patterns will be excluded from the header tests.
+# HEADERS: An explicit list of headers to include in the header tests.
+#
+# Notes:
+# - The header globs are applied relative to <project_include_path>.
+# - If no HEADER_TEMPLATE is provided, a default template will be used.
+# - The HEADER_TEMPLATE will be configured for each header, with the following variables:
+#   - @header@: The path to the target header, relative to <project_include_path>.
+function(cccl_generate_header_tests target_name project_include_path)
+  set(options)
+  set(oneValueArgs LANGUAGE HEADER_TEMPLATE)
+  set(multiValueArgs GLOBS EXCLUDES HEADERS DEFINES)
+  cmake_parse_arguments(CGHT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  # Setup defaults
+  if (NOT DEFINED CGHT_LANGUAGE)
+    set(CGHT_LANGUAGE CUDA)
+  endif()
+
+  if (NOT DEFINED CGHT_HEADER_TEMPLATE)
+    set(CGHT_HEADER_TEMPLATE "${CCCL_SOURCE_DIR}/cmake/header_test.cu.in")
+  endif()
+
+  # Derived vars:
+  if (${CGHT_LANGUAGE} STREQUAL "CXX")
+    set(extension "cpp")
+  elseif(${CGHT_LANGUAGE} STREQUAL "CUDA")
+    set(extension "cu")
+  else()
+    message(FATAL_ERROR "Unsupported language: ${CGHT_LANGUAGE}")
+  endif()
+
+  set(cccl_configure_target_options ${CGHT_UNPARSED_ARGUMENTS})
+  set(base_path "${CCCL_SOURCE_DIR}/${project_include_path}")
+
+  # Prepend the basepath to all globbing expressions:
+  if (DEFINED CGHT_GLOBS)
+    set(globs)
+    foreach (glob IN LISTS CGHT_GLOBS)
+      list(APPEND globs "${base_path}/${glob}")
+    endforeach()
+    set(CGHT_GLOBS ${globs})
+  endif()
+  if (DEFINED CGHT_EXCLUDES)
+    set(excludes)
+    foreach (exclude IN LISTS CGHT_EXCLUDES)
+      list(APPEND excludes "${base_path}/${exclude}")
+    endforeach()
+    set(CGHT_EXCLUDES ${excludes})
+  endif()
+
+  # Determine header list
+  set(headers)
+
+  # Add globs:
+  if (DEFINED CGHT_GLOBS)
+    file(GLOB_RECURSE headers
+      RELATIVE "${base_path}"
+      CONFIGURE_DEPENDS
+      ${CGHT_GLOBS}
+    )
+  endif()
+
+  # Remove excludes:
+  if (DEFINED CGHT_EXCLUDES)
+    file(GLOB_RECURSE header_excludes
+      RELATIVE "${base_path}"
+      CONFIGURE_DEPENDS
+      ${CGHT_EXCLUDES}
+    )
+    list(REMOVE_ITEM headers ${header_excludes})
+  endif()
+
+  # Add explicit headers:
+  if (DEFINED CGHT_HEADERS)
+    list(APPEND headers ${CGHT_HEADERS})
+  endif()
+
+  # Cleanup:
+  list(REMOVE_DUPLICATES headers)
+
+  # Configure header templates:
+  set(header_srcs)
+  foreach (header IN LISTS headers)
+    set(header_src "${CMAKE_CURRENT_BINARY_DIR}/headers/${target_name}/${header}.${extension}")
+    configure_file(${CGHT_HEADER_TEMPLATE} ${header_src} @ONLY)
+    list(APPEND header_srcs ${header_src})
+  endforeach()
+
+  # Object library that compiles each header:
+  add_library(${target_name} OBJECT ${header_srcs})
+  cccl_configure_target(${target_name} ${cccl_configure_target_options})
+
+endfunction()
diff --git a/thrust/cmake/header_test.in b/cmake/header_test.cu.in
similarity index 52%
rename from thrust/cmake/header_test.in
rename to cmake/header_test.cu.in
index 292fe16526c..051cecb18aa 100644
--- a/thrust/cmake/header_test.in
+++ b/cmake/header_test.cu.in
@@ -1,20 +1,14 @@
 // This source file checks that:
-// 1) Header <thrust/${header}> compiles without error.
+// 1) Header <@header@> compiles without error.
 // 2) Common macro collisions with platform/system headers are avoided.
+// 3) half/bf16 aren't included when these are explicitly disabled.
 
-// Turn off failures for certain configurations:
-#define THRUST_CPP11_REQUIRED_NO_ERROR
-#define THRUST_CPP14_REQUIRED_NO_ERROR
-#define THRUST_MODERN_GCC_REQUIRED_NO_ERROR
-
-#ifndef THRUST_IGNORE_MACRO_CHECKS
-
-// Define THRUST_MACRO_CHECK(macro, header), which emits a diagnostic indicating
+// Define CCCL_HEADER_MACRO_CHECK(macro, header), which emits a diagnostic indicating
 // a potential macro collision and halts.
 //
 // Hacky way to build a string, but it works on all tested platforms.
-#define THRUST_MACRO_CHECK(MACRO, HEADER)                                      \
-  THRUST_MACRO_CHECK_IMPL(Identifier MACRO should not be used from Thrust      \
+#define CCCL_HEADER_MACRO_CHECK(MACRO, HEADER)                                      \
+  CCCL_HEADER_MACRO_CHECK_IMPL(Identifier MACRO should not be used from Thrust      \
                           headers due to conflicts with HEADER macros.)
 
 // Use raw platform macros instead of the CCCL macros since we
@@ -24,34 +18,37 @@
 #if defined(_MSC_VER) // MSVC
 
 // Fake up an error for MSVC
-#define THRUST_MACRO_CHECK_IMPL(msg)                                           \
-  /* Print message that looks like an error: */                                \
-  __pragma(message(__FILE__ ":" THRUST_MACRO_CHECK_IMPL0(__LINE__)             \
-                   ": error: " #msg))                                          \
-  /* abort compilation due to static_assert or syntax error: */                \
+#define CCCL_HEADER_MACRO_CHECK_IMPL(msg)                                           \
+  /* Print message that looks like an error: */                                     \
+  __pragma(message(__FILE__ ":" CCCL_HEADER_MACRO_CHECK_IMPL0(__LINE__)             \
+                   ": error: " #msg))                                               \
+  /* abort compilation due to static_assert or syntax error: */                     \
   static_assert(false, #msg);
-#define THRUST_MACRO_CHECK_IMPL0(x) THRUST_MACRO_CHECK_IMPL1(x)
-#define THRUST_MACRO_CHECK_IMPL1(x) #x
+#define CCCL_HEADER_MACRO_CHECK_IMPL0(x) CCCL_HEADER_MACRO_CHECK_IMPL1(x)
+#define CCCL_HEADER_MACRO_CHECK_IMPL1(x) #x
 
 #elif defined(__clang__) || defined(__GNUC__)
 
 // GCC/clang are easy:
-#define THRUST_MACRO_CHECK_IMPL(msg) THRUST_MACRO_CHECK_IMPL0(GCC error #msg)
-#define THRUST_MACRO_CHECK_IMPL0(expr) _Pragma(#expr)
+#define CCCL_HEADER_MACRO_CHECK_IMPL(msg) CCCL_HEADER_MACRO_CHECK_IMPL0(GCC error #msg)
+#define CCCL_HEADER_MACRO_CHECK_IMPL0(expr) _Pragma(#expr)
+
+#endif // msvc vs. the world
 
-#endif
+// May be defined to skip macro check for certain configurations.
+#ifndef CCCL_IGNORE_HEADER_MACRO_CHECKS
 
 // complex.h conflicts
-#define I THRUST_MACRO_CHECK('I', complex.h)
+#define I CCCL_HEADER_MACRO_CHECK('I', complex.h)
 
 // windows.h conflicts
-#define small THRUST_MACRO_CHECK('small', windows.h)
+#define small CCCL_HEADER_MACRO_CHECK('small', windows.h)
 // We can't enable these checks without breaking some builds -- some standard
 // library implementations unconditionally `#undef` these macros, which then
 // causes random failures later.
 // Leaving these commented out as a warning: Here be dragons.
-//#define min(...) THRUST_MACRO_CHECK('min', windows.h)
-//#define max(...) THRUST_MACRO_CHECK('max', windows.h)
+//#define min(...) CCCL_HEADER_MACRO_CHECK('min', windows.h)
+//#define max(...) CCCL_HEADER_MACRO_CHECK('max', windows.h)
 
 #ifdef _WIN32
 // On Windows, make sure any include of Windows.h (e.g. via NVTX) does not define the checked macros
@@ -59,23 +56,23 @@
 #endif // _WIN32
 
 // termios.h conflicts (NVIDIA/thrust#1547)
-#define B0 THRUST_MACRO_CHECK("B0", termios.h)
+#define B0 CCCL_HEADER_MACRO_CHECK("B0", termios.h)
 
-#endif // THRUST_IGNORE_MACRO_CHECKS
+#endif // CCCL_IGNORE_HEADER_MACRO_CHECKS
 
-#include <thrust/${header}>
+#include <@header@>
 
 #if defined(CCCL_DISABLE_BF16_SUPPORT)
 #if defined(__CUDA_BF16_TYPES_EXIST__)
-#error Thrust should not include cuda_bf16.h when BF16 support is disabled
+#error We should not include cuda_bf16.h when BF16 support is disabled
 #endif // __CUDA_BF16_TYPES_EXIST__
 #endif // CCCL_DISABLE_BF16_SUPPORT
 
 #if defined(CCCL_DISABLE_FP16_SUPPORT)
 #if defined(__CUDA_FP16_TYPES_EXIST__)
-#error Thrust should not include cuda_fp16.h when half support is disabled
+#error We should not include cuda_fp16.h when half support is disabled
 #endif // __CUDA_FP16_TYPES_EXIST__
 #if defined(__CUDA_BF16_TYPES_EXIST__)
-#error Thrust should not include cuda_bf16.h when half support is disabled
+#error We should not include cuda_bf16.h when half support is disabled
 #endif // __CUDA_BF16_TYPES_EXIST__
 #endif // CCCL_DISABLE_FP16_SUPPORT
diff --git a/cub/cmake/CubHeaderTesting.cmake b/cub/cmake/CubHeaderTesting.cmake
index fdf9be3be48..bf2cf6e2e99 100644
--- a/cub/cmake/CubHeaderTesting.cmake
+++ b/cub/cmake/CubHeaderTesting.cmake
@@ -7,25 +7,17 @@
 # Meta target for all configs' header builds:
 add_custom_target(cub.all.headers)
 
-file(GLOB_RECURSE headers
-  RELATIVE "${CUB_SOURCE_DIR}/cub"
-  CONFIGURE_DEPENDS
-  cub/*.cuh
-)
-
-set(headertest_srcs)
-foreach (header IN LISTS headers)
-  set(headertest_src "headers/${header}.cu")
-  configure_file("${CUB_SOURCE_DIR}/cmake/header_test.in" "${headertest_src}")
-  list(APPEND headertest_srcs "${headertest_src}")
-endforeach()
-
 function(cub_add_header_test label definitions)
   foreach(cub_target IN LISTS CUB_TARGETS)
+    cub_get_target_property(config_dialect ${cub_target} DIALECT)
     cub_get_target_property(config_prefix ${cub_target} PREFIX)
 
     set(headertest_target ${config_prefix}.headers.${label})
-    add_library(${headertest_target} OBJECT ${headertest_srcs})
+
+    cccl_generate_header_tests(${headertest_target} cub
+      DIALECT ${config_dialect}
+      GLOBS "cub/*.cuh"
+    )
     target_link_libraries(${headertest_target} PUBLIC ${cub_target})
     target_compile_definitions(${headertest_target} PRIVATE ${definitions})
     cub_clone_target_properties(${headertest_target} ${cub_target})
@@ -47,11 +39,11 @@ set(header_definitions
   "THRUST_WRAPPED_NAMESPACE=wrapped_thrust"
   "CUB_WRAPPED_NAMESPACE=wrapped_cub"
   "CCCL_DISABLE_BF16_SUPPORT")
-cub_add_header_test(bf16 "${header_definitions}")
+cub_add_header_test(no_bf16 "${header_definitions}")
 
 # Check that half support can be disabled
 set(header_definitions
   "THRUST_WRAPPED_NAMESPACE=wrapped_thrust"
   "CUB_WRAPPED_NAMESPACE=wrapped_cub"
   "CCCL_DISABLE_FP16_SUPPORT")
-cub_add_header_test(half "${header_definitions}")
+cub_add_header_test(no_half "${header_definitions}")
diff --git a/cub/cmake/header_test.in b/cub/cmake/header_test.in
deleted file mode 100644
index 300fa6abb94..00000000000
--- a/cub/cmake/header_test.in
+++ /dev/null
@@ -1,72 +0,0 @@
-// This source file checks that:
-// 1) Header <cub/${header}> compiles without error.
-// 2) Common macro collisions with platform/system headers are avoided.
-
-// Define CUB_MACRO_CHECK(macro, header), which emits a diagnostic indicating
-// a potential macro collision and halts.
-//
-// Use raw platform macros instead of the CCCL macros since we
-// don't want to #include any headers other than the one being tested.
-//
-// This is only implemented for MSVC/GCC/Clang.
-#if defined(_MSC_VER) // MSVC
-
-// Fake up an error for MSVC
-#define CUB_MACRO_CHECK_IMPL(msg)                                              \
-  /* Print message that looks like an error: */                                \
-  __pragma(message(__FILE__ ":" CUB_MACRO_CHECK_IMPL0(__LINE__)                \
-                   ": error: " #msg))                                          \
-  /* abort compilation due to static_assert or syntax error: */                \
-  static_assert(false, #msg);
-#define CUB_MACRO_CHECK_IMPL0(x) CUB_MACRO_CHECK_IMPL1(x)
-#define CUB_MACRO_CHECK_IMPL1(x) #x
-
-#elif defined(__clang__) || defined(__GNUC__)
-
-// GCC/clang are easy:
-#define CUB_MACRO_CHECK_IMPL(msg) CUB_MACRO_CHECK_IMPL0(GCC error #msg)
-#define CUB_MACRO_CHECK_IMPL0(expr) _Pragma(#expr)
-
-#endif
-
-// Hacky way to build a string, but it works on all tested platforms.
-#define CUB_MACRO_CHECK(MACRO, HEADER)                                         \
-  CUB_MACRO_CHECK_IMPL(Identifier MACRO should not be used from CUB            \
-                       headers due to conflicts with HEADER macros.)
-
-// complex.h conflicts
-#define I CUB_MACRO_CHECK('I', complex.h)
-
-// windows.h conflicts
-#define small CUB_MACRO_CHECK('small', windows.h)
-// We can't enable these checks without breaking some builds -- some standard
-// library implementations unconditionally `#undef` these macros, which then
-// causes random failures later.
-// Leaving these commented out as a warning: Here be dragons.
-//#define min(...) CUB_MACRO_CHECK('min', windows.h)
-//#define max(...) CUB_MACRO_CHECK('max', windows.h)
-
-#ifdef _WIN32
-// On Windows, make sure any include of Windows.h (e.g. via NVTX) does not define the checked macros
-#  define WIN32_LEAN_AND_MEAN
-#endif // _WIN32
-
-// termios.h conflicts (NVIDIA/thrust#1547)
-#define B0 CUB_MACRO_CHECK("B0", termios.h)
-
-#include <cub/${header}>
-
-#if defined(CCCL_DISABLE_BF16_SUPPORT)
-#if defined(__CUDA_BF16_TYPES_EXIST__)
-#error CUB should not include cuda_bf16.h when BF16 support is disabled
-#endif // __CUDA_BF16_TYPES_EXIST__
-#endif // CCCL_DISABLE_BF16_SUPPORT
-
-#if defined(CCCL_DISABLE_FP16_SUPPORT)
-#if defined(__CUDA_FP16_TYPES_EXIST__)
-#error CUB should not include cuda_fp16.h when half support is disabled
-#endif // __CUDA_FP16_TYPES_EXIST__
-#if defined(__CUDA_BF16_TYPES_EXIST__)
-#error CUB should not include cuda_bf16.h when half support is disabled
-#endif // __CUDA_BF16_TYPES_EXIST__
-#endif // CCCL_DISABLE_FP16_SUPPORT
diff --git a/cudax/cmake/cudaxHeaderTesting.cmake b/cudax/cmake/cudaxHeaderTesting.cmake
index 824b1a4fda7..6c81b529525 100644
--- a/cudax/cmake/cudaxHeaderTesting.cmake
+++ b/cudax/cmake/cudaxHeaderTesting.cmake
@@ -7,35 +7,27 @@
 # Meta target for all configs' header builds:
 add_custom_target(cudax.all.headers)
 
-file(GLOB_RECURSE headers
-  RELATIVE "${cudax_SOURCE_DIR}/include"
-  CONFIGURE_DEPENDS1
-  "${cudax_SOURCE_DIR}/include/*.cuh"
-  "${cudax_SOURCE_DIR}/include/*.h"
-)
-
-# The following internal headers are not required to compile independently:
-list(REMOVE_ITEM headers
-  "cuda/experimental/__async/prologue.cuh"
-  "cuda/experimental/__async/epilogue.cuh"
-)
-
-set(headertest_srcs)
-foreach (header IN LISTS headers)
-  set(headertest_src "headers/${header}.cu")
-  configure_file("${cudax_SOURCE_DIR}/cmake/header_test.in.cu" "${headertest_src}")
-  list(APPEND headertest_srcs "${headertest_src}")
-endforeach()
-
 function(cudax_add_header_test label definitions)
   foreach(cn_target IN LISTS cudax_TARGETS)
+    cudax_get_target_property(config_dialect ${cn_target} DIALECT)
     cudax_get_target_property(config_prefix ${cn_target} PREFIX)
 
     set(headertest_target ${config_prefix}.headers.${label})
-    add_library(${headertest_target} OBJECT ${headertest_srcs})
+    cccl_generate_header_tests(${headertest_target} cudax/include
+      DIALECT ${config_dialect}
+      # The cudax header template removes the check for the `small` macro.
+      HEADER_TEMPLATE "${cudax_SOURCE_DIR}/cmake/header_test.in.cu"
+      GLOBS "cuda/experimental/*.cuh"
+      EXCLUDES
+        # The following internal headers are not required to compile independently:
+        "cuda/experimental/__async/prologue.cuh"
+        "cuda/experimental/__async/epilogue.cuh"
+    )
     target_link_libraries(${headertest_target} PUBLIC ${cn_target})
-    target_compile_definitions(${headertest_target} PRIVATE ${definitions}
-                               "-DLIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE")
+    target_compile_definitions(${headertest_target} PRIVATE
+      ${definitions}
+      "-DLIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE"
+    )
     cudax_clone_target_properties(${headertest_target} ${cn_target})
 
     add_dependencies(cudax.all.headers ${headertest_target})
diff --git a/cudax/cmake/header_test.in.cu b/cudax/cmake/header_test.in.cu
index fd2df1987dc..1e31b2e63df 100644
--- a/cudax/cmake/header_test.in.cu
+++ b/cudax/cmake/header_test.in.cu
@@ -1,6 +1,7 @@
 // This source file checks that:
-// 1) Header <${header}> compiles without error.
+// 1) Header <@header@> compiles without error.
 // 2) Common macro collisions with platform/system headers are avoided.
+// 3) half/bf16 aren't included when these are explicitly disabled.
 
 // Define CUDAX_MACRO_CHECK(macro, header), which emits a diagnostic indicating
 // a potential macro collision and halts.
@@ -47,4 +48,19 @@
 // termios.h conflicts (NVIDIA/thrust#1547)
 #define B0 CUDAX_MACRO_CHECK("B0", termios.h)
 
-#include <${header}>
+#include <@header@>
+
+#if defined(CCCL_DISABLE_BF16_SUPPORT)
+#  if defined(__CUDA_BF16_TYPES_EXIST__)
+#    error We should not include cuda_bf16.h when BF16 support is disabled
+#  endif // __CUDA_BF16_TYPES_EXIST__
+#endif // CCCL_DISABLE_BF16_SUPPORT
+
+#if defined(CCCL_DISABLE_FP16_SUPPORT)
+#  if defined(__CUDA_FP16_TYPES_EXIST__)
+#    error We should not include cuda_fp16.h when half support is disabled
+#  endif // __CUDA_FP16_TYPES_EXIST__
+#  if defined(__CUDA_BF16_TYPES_EXIST__)
+#    error We should not include cuda_bf16.h when half support is disabled
+#  endif // __CUDA_BF16_TYPES_EXIST__
+#endif // CCCL_DISABLE_FP16_SUPPORT
diff --git a/thrust/cmake/ThrustHeaderTesting.cmake b/thrust/cmake/ThrustHeaderTesting.cmake
index 5a10912864b..d90521c8d7d 100644
--- a/thrust/cmake/ThrustHeaderTesting.cmake
+++ b/thrust/cmake/ThrustHeaderTesting.cmake
@@ -10,12 +10,19 @@ add_custom_target(thrust.all.headers)
 function(thrust_add_header_test thrust_target label definitions)
   thrust_get_target_property(config_host ${thrust_target} HOST)
   thrust_get_target_property(config_device ${thrust_target} DEVICE)
+  thrust_get_target_property(config_dialect ${thrust_target} DIALECT)
   thrust_get_target_property(config_prefix ${thrust_target} PREFIX)
   set(config_systems ${config_host} ${config_device})
 
   string(TOLOWER "${config_host}" host_lower)
   string(TOLOWER "${config_device}" device_lower)
 
+  if (config_device STREQUAL "CUDA")
+    set(lang CUDA)
+  else()
+    set(lang CXX)
+  endif()
+
   # GLOB ALL THE THINGS
   set(headers_globs thrust/*.h)
   set(headers_exclude_systems_globs thrust/system/*/*)
@@ -31,14 +38,14 @@ function(thrust_add_header_test thrust_target label definitions)
 
   # Get all .h files...
   file(GLOB_RECURSE headers
-    RELATIVE "${Thrust_SOURCE_DIR}/thrust"
+    RELATIVE "${Thrust_SOURCE_DIR}"
     CONFIGURE_DEPENDS
     ${headers_globs}
   )
 
   # ...then remove all system specific headers...
   file(GLOB_RECURSE headers_exclude_systems
-    RELATIVE "${Thrust_SOURCE_DIR}/thrust"
+    RELATIVE "${Thrust_SOURCE_DIR}"
     CONFIGURE_DEPENDS
     ${headers_exclude_systems_globs}
   )
@@ -46,7 +53,7 @@ function(thrust_add_header_test thrust_target label definitions)
 
   # ...then add all headers specific to the selected host and device systems back again...
   file(GLOB_RECURSE headers_systems
-    RELATIVE ${Thrust_SOURCE_DIR}/thrust
+    RELATIVE "${Thrust_SOURCE_DIR}"
     CONFIGURE_DEPENDS
     ${headers_systems_globs}
   )
@@ -54,7 +61,7 @@ function(thrust_add_header_test thrust_target label definitions)
 
   # ...and remove all the detail headers (also removing the detail headers from the selected systems).
   file(GLOB_RECURSE headers_exclude_details
-    RELATIVE "${Thrust_SOURCE_DIR}/thrust"
+    RELATIVE "${Thrust_SOURCE_DIR}"
     CONFIGURE_DEPENDS
     ${headers_exclude_details_globs}
   )
@@ -62,14 +69,14 @@ function(thrust_add_header_test thrust_target label definitions)
 
   # List of headers that aren't implemented for all backends, but are implemented for CUDA.
   set(partially_implemented_CUDA
-    async/copy.h
-    async/for_each.h
-    async/reduce.h
-    async/scan.h
-    async/sort.h
-    async/transform.h
-    event.h
-    future.h
+    thrust/async/copy.h
+    thrust/async/for_each.h
+    thrust/async/reduce.h
+    thrust/async/scan.h
+    thrust/async/sort.h
+    thrust/async/transform.h
+    thrust/event.h
+    thrust/future.h
   )
 
   # List of headers that aren't implemented for all backends, but are implemented for CPP.
@@ -93,9 +100,10 @@ function(thrust_add_header_test thrust_target label definitions)
   )
   list(REMOVE_DUPLICATES partially_implemented)
 
-  set(headertest_srcs)
-
-  foreach (header IN LISTS headers)
+  # Filter the partially implemented headers:
+  set(headers_tmp ${headers})
+  set(headers)
+  foreach (header IN LISTS headers_tmp)
     if ("${header}" IN_LIST partially_implemented)
       # This header is partially implemented on _some_ backends...
       if (NOT "${header}" IN_LIST partially_implemented_${config_device})
@@ -103,22 +111,22 @@ function(thrust_add_header_test thrust_target label definitions)
         continue()
       endif()
     endif()
-
-    set(headertest_src_ext .cpp)
-    if ("CUDA" STREQUAL "${config_device}")
-      set(headertest_src_ext .cu)
-    endif()
-
-    set(headertest_src "headers/${config_prefix}/${header}${headertest_src_ext}")
-    configure_file("${Thrust_SOURCE_DIR}/cmake/header_test.in" "${headertest_src}")
-
-    list(APPEND headertest_srcs "${headertest_src}")
+    list(APPEND headers ${header})
   endforeach()
 
   set(headertest_target ${config_prefix}.headers.${label})
-  add_library(${headertest_target} OBJECT ${headertest_srcs})
+  cccl_generate_header_tests(${headertest_target} thrust
+    DIALECT ${config_dialect}
+    LANGUAGE ${lang}
+    HEADERS ${headers}
+  )
   target_link_libraries(${headertest_target} PUBLIC ${thrust_target})
-  target_compile_definitions(${headertest_target} PRIVATE ${header_definitions})
+  target_compile_definitions(${headertest_target} PRIVATE
+    ${header_definitions}
+    "THRUST_CPP11_REQUIRED_NO_ERROR"
+    "THRUST_CPP14_REQUIRED_NO_ERROR"
+    "THRUST_MODERN_GCC_REQUIRED_NO_ERROR"
+  )
   thrust_clone_target_properties(${headertest_target} ${thrust_target})
 
   if ("CUDA" STREQUAL "${config_device}")
@@ -128,9 +136,7 @@ function(thrust_add_header_test thrust_target label definitions)
   # Disable macro checks on TBB; the TBB atomic implementation uses `I` and
   # our checks will issue false errors.
   if ("TBB" IN_LIST config_systems)
-    target_compile_definitions(${headertest_target}
-      PRIVATE THRUST_IGNORE_MACRO_CHECKS
-    )
+    target_compile_definitions(${headertest_target} PRIVATE CCCL_IGNORE_HEADER_MACRO_CHECKS)
   endif()
 
   thrust_fix_clang_nvcc_build_for(${headertest_target})
@@ -140,39 +146,29 @@ function(thrust_add_header_test thrust_target label definitions)
 endfunction()
 
 foreach(thrust_target IN LISTS THRUST_TARGETS)
+  thrust_add_header_test(${thrust_target} base "")
+
   # Wrap Thrust/CUB in a custom namespace to check proper use of ns macros:
   set(header_definitions
     "THRUST_WRAPPED_NAMESPACE=wrapped_thrust"
     "CUB_WRAPPED_NAMESPACE=wrapped_cub")
-  thrust_add_header_test(${thrust_target} base "${header_definitions}")
+  thrust_add_header_test(${thrust_target} wrap "${header_definitions}")
 
   # We need to ensure that the different dispatch mechanisms work
-  set(header_definitions
-    "THRUST_WRAPPED_NAMESPACE=wrapped_thrust"
-    "CUB_WRAPPED_NAMESPACE=wrapped_cub"
-    "THRUST_FORCE_32_BIT_OFFSET_TYPE")
+  set(header_definitions "THRUST_FORCE_32_BIT_OFFSET_TYPE")
   thrust_add_header_test(${thrust_target} offset_32 "${header_definitions}")
 
-  set(header_definitions
-    "THRUST_WRAPPED_NAMESPACE=wrapped_thrust"
-    "CUB_WRAPPED_NAMESPACE=wrapped_cub"
-    "THRUST_FORCE_64_BIT_OFFSET_TYPE")
+  set(header_definitions "THRUST_FORCE_64_BIT_OFFSET_TYPE")
   thrust_add_header_test(${thrust_target} offset_64 "${header_definitions}")
 
   thrust_get_target_property(config_device ${thrust_target} DEVICE)
   if ("CUDA" STREQUAL "${config_device}")
     # Check that BF16 support can be disabled
-    set(header_definitions
-      "THRUST_WRAPPED_NAMESPACE=wrapped_thrust"
-      "CUB_WRAPPED_NAMESPACE=wrapped_cub"
-      "CCCL_DISABLE_BF16_SUPPORT")
-    thrust_add_header_test(${thrust_target} bf16 "${header_definitions}")
+    set(header_definitions "CCCL_DISABLE_BF16_SUPPORT")
+    thrust_add_header_test(${thrust_target} no_bf16 "${header_definitions}")
 
     # Check that half support can be disabled
-    set(header_definitions
-      "THRUST_WRAPPED_NAMESPACE=wrapped_thrust"
-      "CUB_WRAPPED_NAMESPACE=wrapped_cub"
-      "CCCL_DISABLE_FP16_SUPPORT")
-    thrust_add_header_test(${thrust_target} half "${header_definitions}")
+    set(header_definitions "CCCL_DISABLE_FP16_SUPPORT")
+    thrust_add_header_test(${thrust_target} no_half "${header_definitions}")
   endif()
 endforeach ()