diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 80b7c2870..737ddf32e 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -39,7 +39,7 @@ function(ConfigureTest TEST_NAME)
     set_target_properties(${TEST_NAME} PROPERTIES
                                        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/tests")
     target_compile_options(${TEST_NAME} PRIVATE --compiler-options=-Wall --compiler-options=-Wextra
-      --expt-extended-lambda --expt-relaxed-constexpr -Xcompiler -Wno-subobject-linkage)
+      --expt-extended-lambda -Xcompiler -Wno-subobject-linkage)
     catch_discover_tests(${TEST_NAME} EXTRA_ARGS --allow-running-no-tests)
 endfunction(ConfigureTest)
 
diff --git a/tests/static_map/custom_type_test.cu b/tests/static_map/custom_type_test.cu
index 2dcd542e2..0d1800456 100644
--- a/tests/static_map/custom_type_test.cu
+++ b/tests/static_map/custom_type_test.cu
@@ -154,7 +154,7 @@ TEMPLATE_TEST_CASE_SIG("User defined key and value type",
                               insert_values.end(),
                               found_values.begin(),
                               cuda::proclaim_return_type<bool>([] __device__(Value lhs, Value rhs) {
-                                return std::tie(lhs.f, lhs.s) == std::tie(rhs.f, rhs.s);
+                                return cuda::std::tie(lhs.f, lhs.s) == cuda::std::tie(rhs.f, rhs.s);
                               })));
   }
 
diff --git a/tests/static_multimap/custom_type_test.cu b/tests/static_multimap/custom_type_test.cu
index 8ddca9f5e..74210f5bd 100644
--- a/tests/static_multimap/custom_type_test.cu
+++ b/tests/static_multimap/custom_type_test.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2024, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@
 
 #include <cuco/static_multimap.cuh>
 
+#include <cuda/std/tuple>
 #include <thrust/device_vector.h>
 #include <thrust/execution_policy.h>
 #include <thrust/functional.h>
@@ -25,12 +26,9 @@
 #include <thrust/iterator/zip_iterator.h>
 #include <thrust/sort.h>
 #include <thrust/transform.h>
-#include <thrust/tuple.h>
 
 #include <catch2/catch_template_test_macros.hpp>
 
-#include <tuple>
-
 // User-defined key type
 struct key_pair {
   int32_t a;
@@ -48,7 +46,7 @@ struct hash_key_pair {
 struct key_pair_equals {
   __device__ bool operator()(const key_pair& lhs, const key_pair& rhs)
   {
-    return std::tie(lhs.a, lhs.b) == std::tie(rhs.a, rhs.b);
+    return cuda::std::tie(lhs.a, lhs.b) == cuda::std::tie(rhs.a, rhs.b);
   }
 };
 
diff --git a/tests/utility/hash_test.cu b/tests/utility/hash_test.cu
index bad467a75..5e0edda74 100644
--- a/tests/utility/hash_test.cu
+++ b/tests/utility/hash_test.cu
@@ -20,6 +20,7 @@
 #include <cuco/hash_functions.cuh>
 
 #include <cuda/std/cstddef>
+#include <cuda/std/limits>
 #include <thrust/device_vector.h>
 
 #include <catch2/catch_template_test_macros.hpp>
@@ -55,15 +56,15 @@ __global__ void check_identity_hash_result_kernel(OutputIter result)
 
   result[i++] = check_hash_result<cuco::identity_hash<signed char>>(0, 0);
   result[i++] = check_hash_result<cuco::identity_hash<signed char>>(
-    std::numeric_limits<signed char>::max(), std::numeric_limits<signed char>::max());
+    cuda::std::numeric_limits<signed char>::max(), cuda::std::numeric_limits<signed char>::max());
 
   result[i++] = check_hash_result<cuco::identity_hash<int32_t>>(0, 0);
   result[i++] = check_hash_result<cuco::identity_hash<int32_t>>(
-    std::numeric_limits<int32_t>::max(), std::numeric_limits<int32_t>::max());
+    cuda::std::numeric_limits<int32_t>::max(), cuda::std::numeric_limits<int32_t>::max());
 
   result[i++] = check_hash_result<cuco::identity_hash<int64_t>>(0, 0);
   result[i++] = check_hash_result<cuco::identity_hash<int64_t>>(
-    std::numeric_limits<int64_t>::max(), std::numeric_limits<int64_t>::max());
+    cuda::std::numeric_limits<int64_t>::max(), cuda::std::numeric_limits<int64_t>::max());
 }
 
 TEST_CASE("Test cuco::identity_hash", "")
@@ -72,15 +73,16 @@ TEST_CASE("Test cuco::identity_hash", "")
   {
     CHECK(check_hash_result<cuco::identity_hash<signed char>>(0, 0));
     CHECK(check_hash_result<cuco::identity_hash<signed char>>(
-      std::numeric_limits<signed char>::max(), std::numeric_limits<signed char>::max()));
+      cuda::std::numeric_limits<signed char>::max(),
+      cuda::std::numeric_limits<signed char>::max()));
 
     CHECK(check_hash_result<cuco::identity_hash<int32_t>>(0, 0));
-    CHECK(check_hash_result<cuco::identity_hash<int32_t>>(std::numeric_limits<int32_t>::max(),
-                                                          std::numeric_limits<int32_t>::max()));
+    CHECK(check_hash_result<cuco::identity_hash<int32_t>>(
+      cuda::std::numeric_limits<int32_t>::max(), cuda::std::numeric_limits<int32_t>::max()));
 
     CHECK(check_hash_result<cuco::identity_hash<int64_t>>(0, 0));
-    CHECK(check_hash_result<cuco::identity_hash<int64_t>>(std::numeric_limits<int64_t>::max(),
-                                                          std::numeric_limits<int64_t>::max()));
+    CHECK(check_hash_result<cuco::identity_hash<int64_t>>(
+      cuda::std::numeric_limits<int64_t>::max(), cuda::std::numeric_limits<int64_t>::max()));
   }
   SECTION("Check if device-generated hash values match the identity function.")
   {