diff --git a/libcudacxx/include/cuda/std/__utility/cmp.h b/libcudacxx/include/cuda/std/__utility/cmp.h
index 6aecd0a1e5c..c6d3ad962e9 100644
--- a/libcudacxx/include/cuda/std/__utility/cmp.h
+++ b/libcudacxx/include/cuda/std/__utility/cmp.h
@@ -20,7 +20,10 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/std/__concepts/concept_macros.h>
 #include <cuda/std/__type_traits/disjunction.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/integral_constant.h>
 #include <cuda/std/__type_traits/is_integral.h>
 #include <cuda/std/__type_traits/is_same.h>
 #include <cuda/std/__type_traits/is_signed.h>
@@ -31,39 +34,45 @@
 
 _CCCL_PUSH_MACROS
 
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4018) // required cast from signed to unsigned
+_CCCL_DIAG_SUPPRESS_MSVC(4388) // required cast from signed to larger unsigned
+_CCCL_DIAG_SUPPRESS_MSVC(4389) // signed/unsigned mismatch for == and !=
+
 _LIBCUDACXX_BEGIN_NAMESPACE_STD
 
-#if _CCCL_STD_VER > 2017
 template <class _Tp, class... _Up>
-struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...>
-{};
+using __is_same_as_any = __fold_or<_CCCL_TRAIT(is_same, _Tp, _Up)...>;
 
 template <class _Tp>
-concept __is_safe_integral_cmp =
-  is_integral_v<_Tp>
-  && !_IsSameAsAny<_Tp,
-                   bool,
-                   char,
-                   char16_t,
-                   char32_t
-#  ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
-                   ,
-                   char8_t
-#  endif
-#  ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
-                   ,
-                   wchar_t
-#  endif
-                   >::value;
-
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+struct __is_safe_integral_cmp
+    : bool_constant<_CCCL_TRAIT(is_integral, _Tp)
+                    && !__is_same_as_any<_Tp,
+                                         bool,
+                                         char,
+                                         char16_t,
+                                         char32_t
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+                                         ,
+                                         char8_t
+#endif // _LIBCUDACXX_NO_HAS_CHAR8_T
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+                                         ,
+                                         wchar_t
+#endif // _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+                                         >::value>
+{};
+
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept
 {
-  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+#if !defined(_CCCL_NO_IF_CONSTEXPR)
+  if constexpr (_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
   {
     return __t == __u;
   }
-  else if constexpr (is_signed_v<_Tp>)
+  else if constexpr (_CCCL_TRAIT(is_signed, _Tp))
   {
     return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u;
   }
@@ -71,22 +80,32 @@ _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept
   {
     return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
   }
+  _CCCL_UNREACHABLE();
+#else // ^^^ !_CCCL_NO_IF_CONSTEXPR ^^^ / vvv _CCCL_NO_IF_CONSTEXPR vvv
+  return ((_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
+            ? (__t == __u)
+            : (_CCCL_TRAIT(is_signed, _Tp) ? (__t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u)
+                                           : (__u < 0 ? false : __t == make_unsigned_t<_Up>(__u))));
+#endif // _CCCL_NO_IF_CONSTEXPR
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept
 {
   return !_CUDA_VSTD::cmp_equal(__t, __u);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept
 {
-  if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+#if !defined(_CCCL_NO_IF_CONSTEXPR)
+  if constexpr (_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
   {
     return __t < __u;
   }
-  else if constexpr (is_signed_v<_Tp>)
+  else if constexpr (_CCCL_TRAIT(is_signed, _Tp))
   {
     return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u;
   }
@@ -94,36 +113,48 @@ _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept
   {
     return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
   }
+  _CCCL_UNREACHABLE();
+#else // ^^^ !_CCCL_NO_IF_CONSTEXPR ^^^ / vvv _CCCL_NO_IF_CONSTEXPR vvv
+  return ((_CCCL_TRAIT(is_signed, _Tp) == _CCCL_TRAIT(is_signed, _Up))
+            ? (__t < __u)
+            : (_CCCL_TRAIT(is_signed, _Tp) ? (__t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u)
+                                           : (__u < 0 ? false : __t < make_unsigned_t<_Up>(__u))));
+#endif // _CCCL_NO_IF_CONSTEXPR
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept
 {
   return _CUDA_VSTD::cmp_less(__u, __t);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept
 {
   return !_CUDA_VSTD::cmp_greater(__t, __u);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept
 {
   return !_CUDA_VSTD::cmp_less(__t, __u);
 }
 
-template <__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
+_CCCL_TEMPLATE(class _Tp, class _Up)
+_CCCL_REQUIRES(__is_safe_integral_cmp<_Tp>::value _CCCL_AND __is_safe_integral_cmp<_Up>::value)
 _LIBCUDACXX_HIDE_FROM_ABI constexpr bool in_range(_Up __u) noexcept
 {
   return _CUDA_VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max())
       && _CUDA_VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
 }
-#endif // _CCCL_STD_VER > 2017
 
 _LIBCUDACXX_END_NAMESPACE_STD
 
+_CCCL_DIAG_POP
+
 _CCCL_POP_MACROS
 
 #endif // _LIBCUDACXX___UTILITY_CMP_H
diff --git a/libcudacxx/include/cuda/std/version b/libcudacxx/include/cuda/std/version
index 0762976d0d9..3b973a8bfab 100644
--- a/libcudacxx/include/cuda/std/version
+++ b/libcudacxx/include/cuda/std/version
@@ -43,11 +43,12 @@
 #  define __cccl_lib_exchange_function 201304L
 #  define __cccl_lib_expected          202211L
 // # define __cccl_lib_generic_associative_lookup           201304L
-#  define __cccl_lib_integer_sequence           201304L
-#  define __cccl_lib_integral_constant_callable 201304L
-#  define __cccl_lib_is_final                   201402L
-#  define __cccl_lib_is_null_pointer            201309L
-#  define __cccl_lib_make_reverse_iterator      201402L
+#  define __cccl_lib_integer_sequence             201304L
+#  define __cccl_lib_integer_comparison_functions 202002L
+#  define __cccl_lib_integral_constant_callable   201304L
+#  define __cccl_lib_is_final                     201402L
+#  define __cccl_lib_is_null_pointer              201309L
+#  define __cccl_lib_make_reverse_iterator        201402L
 // # define __cccl_lib_make_unique                          201304L
 #  if !_CCCL_COMPILER(MSVC) || _CCCL_STD_VER >= 2020
 #    define __cccl_lib_mdspan 202207L
@@ -178,7 +179,6 @@
 // #   define __cccl_lib_format                             202106L
 // # define __cccl_lib_generic_unordered_lookup             201811L
 // # define __cccl_lib_int_pow2                             202002L
-// # define __cccl_lib_integer_comparison_functions         202002L
 // # define __cccl_lib_interpolate                          201902L
 #  ifdef _CCCL_BUILTIN_IS_CONSTANT_EVALUATED
 #    define __cccl_lib_is_constant_evaluated 201811L
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp
index 4d715ff6940..3d0c0e8757b 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp
@@ -7,12 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
 // template<class T, class U>
-//   constexpr bool cmp_equal(T t, U u) noexcept;         // C++20
+//   constexpr bool cmp_equal(T t, U u) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/limits>
@@ -24,28 +22,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_cmp_equal1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test1()
 {
-  constexpr Tuple<T> tup;
+  constexpr Tuple<T> tup{};
   assert(cuda::std::cmp_equal(T(0), T(0)));
   assert(cuda::std::cmp_equal(T(10), T(10)));
   assert(cuda::std::cmp_equal(tup.min, tup.min));
@@ -68,10 +55,10 @@ __host__ __device__ constexpr void test_cmp_equal1()
 }
 
 template <typename T, typename U>
-__host__ __device__ constexpr void test_cmp_equal2()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test2()
 {
-  constexpr Tuple<T> ttup;
-  constexpr Tuple<U> utup;
+  constexpr Tuple<T> ttup{};
+  constexpr Tuple<U> utup{};
   assert(cuda::std::cmp_equal(T(0), U(0)));
   assert(cuda::std::cmp_equal(T(10), U(10)));
   assert(!cuda::std::cmp_equal(T(0), U(1)));
@@ -82,44 +69,42 @@ __host__ __device__ constexpr void test_cmp_equal2()
   assert(!cuda::std::cmp_equal(utup.min, ttup.max));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
-{
-  (test_cmp_equal1<Ts>(), ...);
-}
-
-template <class T, class... Us>
-__host__ __device__ constexpr void test2_impl(const cuda::std::tuple<Us...>&)
+template <class T>
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
-  (test_cmp_equal2<T, Us>(), ...);
-}
-
-template <class... Ts, class UTuple>
-__host__ __device__ constexpr void test2(const cuda::std::tuple<Ts...>&, const UTuple& utuple)
-{
-  (test2_impl<Ts>(utuple), ...);
+  test1<T>();
+#ifndef TEST_HAS_NO_INT128_T
+  test2<T, __int128_t>();
+  test2<T, __uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test2<T, unsigned long long>();
+  test2<T, long long>();
+  test2<T, unsigned long>();
+  test2<T, long>();
+  test2<T, unsigned int>();
+  test2<T, int>();
+  test2<T, unsigned short>();
+  test2<T, short>();
+  test2<T, unsigned char>();
+  test2<T, signed char>();
 }
 
-__host__ __device__ constexpr bool test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  cuda::std::tuple<
 #ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
-  test2(types, types);
+  test<__int128_t>();
+  test<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test<unsigned long long>();
+  test<long long>();
+  test<unsigned long>();
+  test<long>();
+  test<unsigned int>();
+  test<int>();
+  test<unsigned short>();
+  test<short>();
+  test<unsigned char>();
+  test<signed char>();
   return true;
 }
 
@@ -127,6 +112,8 @@ int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::cmp_equal(0, 0));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp
index 5ac4ed3cd0d..5c816949a69 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp
@@ -6,11 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
-//   constexpr bool cmp_greater(T t, U u) noexcept;       // C++20
+//   constexpr bool cmp_greater(T t, U u) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/limits>
@@ -22,28 +20,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_cmp_greater1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test1()
 {
-  constexpr Tuple<T> tup;
+  constexpr Tuple<T> tup{};
   assert(!cuda::std::cmp_greater(T(0), T(1)));
   assert(!cuda::std::cmp_greater(T(1), T(2)));
   assert(!cuda::std::cmp_greater(tup.min, tup.max));
@@ -59,57 +46,55 @@ __host__ __device__ constexpr void test_cmp_greater1()
   assert(cuda::std::cmp_greater(tup.max, 1));
   assert(cuda::std::cmp_greater(1, tup.min));
   assert(!cuda::std::cmp_greater(T(-1), T(-1)));
-  assert(cuda::std::cmp_greater(-2, tup.min) == cuda::std::is_signed_v<T>);
-  assert(!cuda::std::cmp_greater(tup.min, -2) == cuda::std::is_signed_v<T>);
+  assert(cuda::std::cmp_greater(-2, tup.min) == cuda::std::is_signed<T>::value);
+  assert(!cuda::std::cmp_greater(tup.min, -2) == cuda::std::is_signed<T>::value);
   assert(!cuda::std::cmp_greater(-2, tup.max));
   assert(cuda::std::cmp_greater(tup.max, -2));
 }
 
 template <typename T, typename U>
-__host__ __device__ constexpr void test_cmp_greater2()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test2()
 {
   assert(!cuda::std::cmp_greater(T(0), U(1)));
   assert(cuda::std::cmp_greater(T(1), U(0)));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
-{
-  (test_cmp_greater1<Ts>(), ...);
-}
-
-template <class T, class... Us>
-__host__ __device__ constexpr void test2_impl(const cuda::std::tuple<Us...>&)
+template <class T>
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
-  (test_cmp_greater2<T, Us>(), ...);
-}
-
-template <class... Ts, class UTuple>
-__host__ __device__ constexpr void test2(const cuda::std::tuple<Ts...>&, const UTuple& utuple)
-{
-  (test2_impl<Ts>(utuple), ...);
+  test1<T>();
+#ifndef TEST_HAS_NO_INT128_T
+  test2<T, __int128_t>();
+  test2<T, __uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test2<T, unsigned long long>();
+  test2<T, long long>();
+  test2<T, unsigned long>();
+  test2<T, long>();
+  test2<T, unsigned int>();
+  test2<T, int>();
+  test2<T, unsigned short>();
+  test2<T, short>();
+  test2<T, unsigned char>();
+  test2<T, signed char>();
 }
 
-__host__ __device__ constexpr bool test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  cuda::std::tuple<
 #ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
-  test2(types, types);
+  test<__int128_t>();
+  test<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test<unsigned long long>();
+  test<long long>();
+  test<unsigned long>();
+  test<long>();
+  test<unsigned int>();
+  test<int>();
+  test<unsigned short>();
+  test<short>();
+  test<unsigned char>();
+  test<signed char>();
   return true;
 }
 
@@ -117,6 +102,8 @@ int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::cmp_greater(1, 0));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp
index 38405a7a305..1c1d7729d2e 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp
@@ -6,11 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
-//   constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
+//   constexpr bool cmp_greater_equal(T t, U u) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/limits>
@@ -22,28 +20,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_cmp_greater_equal1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test1()
 {
-  constexpr Tuple<T> tup;
+  constexpr Tuple<T> tup{};
   assert(!cuda::std::cmp_greater_equal(T(0), T(1)));
   assert(!cuda::std::cmp_greater_equal(T(1), T(2)));
   assert(!cuda::std::cmp_greater_equal(tup.min, tup.max));
@@ -59,14 +46,14 @@ __host__ __device__ constexpr void test_cmp_greater_equal1()
   assert(cuda::std::cmp_greater_equal(tup.max, 1));
   assert(cuda::std::cmp_greater_equal(1, tup.min));
   assert(cuda::std::cmp_greater_equal(T(-1), T(-1)));
-  assert(cuda::std::cmp_greater_equal(-2, tup.min) == cuda::std::is_signed_v<T>);
-  assert(cuda::std::cmp_greater_equal(tup.min, -2) == cuda::std::is_unsigned_v<T>);
+  assert(cuda::std::cmp_greater_equal(-2, tup.min) == cuda::std::is_signed<T>::value);
+  assert(cuda::std::cmp_greater_equal(tup.min, -2) == cuda::std::is_unsigned<T>::value);
   assert(!cuda::std::cmp_greater_equal(-2, tup.max));
   assert(cuda::std::cmp_greater_equal(tup.max, -2));
 }
 
 template <typename T, typename U>
-__host__ __device__ constexpr void test_cmp_greater_equal2()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test2()
 {
   assert(!cuda::std::cmp_greater_equal(T(0), U(1)));
   assert(cuda::std::cmp_greater_equal(T(1), U(0)));
@@ -74,44 +61,42 @@ __host__ __device__ constexpr void test_cmp_greater_equal2()
   assert(cuda::std::cmp_greater_equal(T(1), U(1)));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
-{
-  (test_cmp_greater_equal1<Ts>(), ...);
-}
-
-template <class T, class... Us>
-__host__ __device__ constexpr void test2_impl(const cuda::std::tuple<Us...>&)
+template <class T>
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
-  (test_cmp_greater_equal2<T, Us>(), ...);
-}
-
-template <class... Ts, class UTuple>
-__host__ __device__ constexpr void test2(const cuda::std::tuple<Ts...>&, const UTuple& utuple)
-{
-  (test2_impl<Ts>(utuple), ...);
+  test1<T>();
+#ifndef TEST_HAS_NO_INT128_T
+  test2<T, __int128_t>();
+  test2<T, __uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test2<T, unsigned long long>();
+  test2<T, long long>();
+  test2<T, unsigned long>();
+  test2<T, long>();
+  test2<T, unsigned int>();
+  test2<T, int>();
+  test2<T, unsigned short>();
+  test2<T, short>();
+  test2<T, unsigned char>();
+  test2<T, signed char>();
 }
 
-__host__ __device__ constexpr bool test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  cuda::std::tuple<
 #ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
-  test2(types, types);
+  test<__int128_t>();
+  test<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test<unsigned long long>();
+  test<long long>();
+  test<unsigned long>();
+  test<long>();
+  test<unsigned int>();
+  test<int>();
+  test<unsigned short>();
+  test<short>();
+  test<unsigned char>();
+  test<signed char>();
   return true;
 }
 
@@ -119,6 +104,8 @@ int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::cmp_greater_equal(1, 0));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp
index 158c07a0c42..9ec369c28a3 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp
@@ -6,12 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
 // template<class T, class U>
-//   constexpr bool cmp_less(T t, U u) noexcept;          // C++20
+//   constexpr bool cmp_less(T t, U u) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/limits>
@@ -23,28 +21,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_cmp_less1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test1()
 {
-  constexpr Tuple<T> tup;
+  constexpr Tuple<T> tup{};
   assert(cuda::std::cmp_less(T(0), T(1)));
   assert(cuda::std::cmp_less(T(1), T(2)));
   assert(cuda::std::cmp_less(tup.min, tup.max));
@@ -60,57 +47,55 @@ __host__ __device__ constexpr void test_cmp_less1()
   assert(!cuda::std::cmp_less(tup.max, 1));
   assert(!cuda::std::cmp_less(1, tup.min));
   assert(!cuda::std::cmp_less(T(-1), T(-1)));
-  assert(!cuda::std::cmp_less(-2, tup.min) == cuda::std::is_signed_v<T>);
-  assert(cuda::std::cmp_less(tup.min, -2) == cuda::std::is_signed_v<T>);
+  assert(!cuda::std::cmp_less(-2, tup.min) == cuda::std::is_signed<T>::value);
+  assert(cuda::std::cmp_less(tup.min, -2) == cuda::std::is_signed<T>::value);
   assert(cuda::std::cmp_less(-2, tup.max));
   assert(!cuda::std::cmp_less(tup.max, -2));
 }
 
 template <typename T, typename U>
-__host__ __device__ constexpr void test_cmp_less2()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test2()
 {
   assert(cuda::std::cmp_less(T(0), U(1)));
   assert(!cuda::std::cmp_less(T(1), U(0)));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
-{
-  (test_cmp_less1<Ts>(), ...);
-}
-
-template <class T, class... Us>
-__host__ __device__ constexpr void test2_impl(const cuda::std::tuple<Us...>&)
+template <class T>
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
-  (test_cmp_less2<T, Us>(), ...);
-}
-
-template <class... Ts, class UTuple>
-__host__ __device__ constexpr void test2(const cuda::std::tuple<Ts...>&, const UTuple& utuple)
-{
-  (test2_impl<Ts>(utuple), ...);
+  test1<T>();
+#ifndef TEST_HAS_NO_INT128_T
+  test2<T, __int128_t>();
+  test2<T, __uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test2<T, unsigned long long>();
+  test2<T, long long>();
+  test2<T, unsigned long>();
+  test2<T, long>();
+  test2<T, unsigned int>();
+  test2<T, int>();
+  test2<T, unsigned short>();
+  test2<T, short>();
+  test2<T, unsigned char>();
+  test2<T, signed char>();
 }
 
-__host__ __device__ constexpr bool test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  cuda::std::tuple<
 #ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
-  test2(types, types);
+  test<__int128_t>();
+  test<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test<unsigned long long>();
+  test<long long>();
+  test<unsigned long>();
+  test<long>();
+  test<unsigned int>();
+  test<int>();
+  test<unsigned short>();
+  test<short>();
+  test<unsigned char>();
+  test<signed char>();
   return true;
 }
 
@@ -118,6 +103,8 @@ int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::cmp_less(0, 1));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp
index cce292b20e2..a33a248a493 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp
@@ -6,11 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
-//   constexpr bool cmp_less_equal(T t, U u) noexcept;    // C++20
+//   constexpr bool cmp_less_equal(T t, U u) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/limits>
@@ -22,28 +20,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_cmp_less_equal1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test1()
 {
-  constexpr Tuple<T> tup;
+  constexpr Tuple<T> tup{};
   assert(cuda::std::cmp_less_equal(T(0), T(0)));
   assert(cuda::std::cmp_less_equal(T(0), T(1)));
   assert(cuda::std::cmp_less_equal(tup.min, tup.max));
@@ -59,58 +46,56 @@ __host__ __device__ constexpr void test_cmp_less_equal1()
   assert(!cuda::std::cmp_less_equal(tup.max, 1));
   assert(!cuda::std::cmp_less_equal(1, tup.min));
   assert(cuda::std::cmp_less_equal(T(-1), T(-1)));
-  assert(!cuda::std::cmp_less_equal(-2, tup.min) == cuda::std::is_signed_v<T>);
-  assert(cuda::std::cmp_less_equal(tup.min, -2) == cuda::std::is_signed_v<T>);
+  assert(!cuda::std::cmp_less_equal(-2, tup.min) == cuda::std::is_signed<T>::value);
+  assert(cuda::std::cmp_less_equal(tup.min, -2) == cuda::std::is_signed<T>::value);
   assert(cuda::std::cmp_less_equal(-2, tup.max));
   assert(!cuda::std::cmp_less_equal(tup.max, -2));
 }
 
 template <typename T, typename U>
-__host__ __device__ constexpr void test_cmp_less_equal2()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test2()
 {
   assert(cuda::std::cmp_less_equal(T(0), U(1)));
   assert(cuda::std::cmp_less_equal(T(0), U(0)));
   assert(!cuda::std::cmp_less_equal(T(1), U(0)));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
-{
-  (test_cmp_less_equal1<Ts>(), ...);
-}
-
-template <class T, class... Us>
-__host__ __device__ constexpr void test2_impl(const cuda::std::tuple<Us...>&)
+template <class T>
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
-  (test_cmp_less_equal2<T, Us>(), ...);
-}
-
-template <class... Ts, class UTuple>
-__host__ __device__ constexpr void test2(const cuda::std::tuple<Ts...>&, const UTuple& utuple)
-{
-  (test2_impl<Ts>(utuple), ...);
+  test1<T>();
+#ifndef TEST_HAS_NO_INT128_T
+  test2<T, __int128_t>();
+  test2<T, __uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test2<T, unsigned long long>();
+  test2<T, long long>();
+  test2<T, unsigned long>();
+  test2<T, long>();
+  test2<T, unsigned int>();
+  test2<T, int>();
+  test2<T, unsigned short>();
+  test2<T, short>();
+  test2<T, unsigned char>();
+  test2<T, signed char>();
 }
 
-__host__ __device__ constexpr bool test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  cuda::std::tuple<
 #ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
-  test2(types, types);
+  test<__int128_t>();
+  test<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test<unsigned long long>();
+  test<long long>();
+  test<unsigned long>();
+  test<long>();
+  test<unsigned int>();
+  test<int>();
+  test<unsigned short>();
+  test<short>();
+  test<unsigned char>();
+  test<signed char>();
   return true;
 }
 
@@ -118,6 +103,8 @@ int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::cmp_less_equal(0, 1));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp
index c53781c23ba..383a4229d30 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp
@@ -6,12 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
 // template<class T, class U>
-//   constexpr bool cmp_not_equal(T t, U u) noexcept;     // C++20
+//   constexpr bool cmp_not_equal(T t, U u) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/limits>
@@ -23,28 +21,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_cmp_not_equal1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test1()
 {
-  constexpr Tuple<T> tup;
+  TEST_CONSTEXPR_CXX14 Tuple<T> tup{};
   assert(!cuda::std::cmp_not_equal(T(0), T(0)));
   assert(!cuda::std::cmp_not_equal(T(10), T(10)));
   assert(!cuda::std::cmp_not_equal(tup.min, tup.min));
@@ -66,10 +53,10 @@ __host__ __device__ constexpr void test_cmp_not_equal1()
 }
 
 template <typename T, typename U>
-__host__ __device__ constexpr void test_cmp_not_equal2()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test2()
 {
-  constexpr Tuple<T> ttup;
-  constexpr Tuple<U> utup;
+  TEST_CONSTEXPR_CXX14 Tuple<T> ttup;
+  TEST_CONSTEXPR_CXX14 Tuple<U> utup;
   assert(!cuda::std::cmp_not_equal(T(0), U(0)));
   assert(!cuda::std::cmp_not_equal(T(10), U(10)));
   assert(cuda::std::cmp_not_equal(T(0), U(1)));
@@ -80,44 +67,42 @@ __host__ __device__ constexpr void test_cmp_not_equal2()
   assert(cuda::std::cmp_not_equal(utup.min, ttup.max));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
-{
-  (test_cmp_not_equal1<Ts>(), ...);
-}
-
-template <class T, class... Us>
-__host__ __device__ constexpr void test2_impl(const cuda::std::tuple<Us...>&)
+template <class T>
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
-  (test_cmp_not_equal2<T, Us>(), ...);
-}
-
-template <class... Ts, class UTuple>
-__host__ __device__ constexpr void test2(const cuda::std::tuple<Ts...>&, const UTuple& utuple)
-{
-  (test2_impl<Ts>(utuple), ...);
+  test1<T>();
+#ifndef TEST_HAS_NO_INT128_T
+  test2<T, __int128_t>();
+  test2<T, __uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test2<T, unsigned long long>();
+  test2<T, long long>();
+  test2<T, unsigned long>();
+  test2<T, long>();
+  test2<T, unsigned int>();
+  test2<T, int>();
+  test2<T, unsigned short>();
+  test2<T, short>();
+  test2<T, unsigned char>();
+  test2<T, signed char>();
 }
 
-__host__ __device__ constexpr bool test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  cuda::std::tuple<
 #ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
-  test2(types, types);
+  test<__int128_t>();
+  test<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test<unsigned long long>();
+  test<long long>();
+  test<unsigned long>();
+  test<long>();
+  test<unsigned int>();
+  test<int>();
+  test<unsigned short>();
+  test<short>();
+  test<unsigned char>();
+  test<signed char>();
   return true;
 }
 
@@ -125,6 +110,8 @@ int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::cmp_not_equal(0, 0));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.fail.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.fail.cpp
index 8cdc1d755a0..2fab113df47 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.fail.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.fail.cpp
@@ -6,30 +6,28 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
 // template<class T, class U>
-//   constexpr bool cmp_equal(T t, U u) noexcept; // C++20
+//   constexpr bool cmp_equal(T t, U u) noexcept;
 
 // template<class T, class U>
-//   constexpr bool cmp_not_equal(T t, U u) noexcept; // C++20
+//   constexpr bool cmp_not_equal(T t, U u) noexcept;
 
 // template<class T, class U>
-//   constexpr bool cmp_less(T t, U u) noexcept; // C++20
+//   constexpr bool cmp_less(T t, U u) noexcept;
 
 // template<class T, class U>
-//   constexpr bool cmp_less_equal(T t, U u) noexcept; // C++20
+//   constexpr bool cmp_less_equal(T t, U u) noexcept;
 
 // template<class T, class U>
-//   constexpr bool cmp_greater(T t, U u) noexcept; // C++20
+//   constexpr bool cmp_greater(T t, U u) noexcept;
 
 // template<class T, class U>
-//   constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
+//   constexpr bool cmp_greater_equal(T t, U u) noexcept;
 
 // template<class R, class T>
-//   constexpr bool in_range(T t) noexcept;      // C++20
+//   constexpr bool in_range(T t) noexcept;
 
 #include <cuda/std/cstddef>
 #include <cuda/std/utility>
@@ -66,7 +64,7 @@ struct EmptyT
 {};
 
 template <class T>
-__host__ __device__ constexpr void test()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test()
 {
   cuda::std::cmp_equal(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_equal'}}
   cuda::std::cmp_equal(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_equal'}}
@@ -94,7 +92,7 @@ __host__ __device__ constexpr void test()
 }
 #ifndef TEST_HAS_NO_CHAR8_T
 template <class T>
-__host__ __device__ constexpr void test_char8t()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test_char8t()
 {
   cuda::std::cmp_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
   cuda::std::cmp_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
@@ -120,7 +118,7 @@ __host__ __device__ constexpr void test_char8t()
 #endif // TEST_HAS_NO_CHAR8_T
 
 template <class T>
-__host__ __device__ constexpr void test_uchars()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test_uchars()
 {
   cuda::std::cmp_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
   cuda::std::cmp_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
diff --git a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
index 634fee7b584..73bb106f77f 100644
--- a/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
+++ b/libcudacxx/test/libcudacxx/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
@@ -6,12 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
 // <utility>
 
 // template<class R, class T>
-//   constexpr bool in_range(T t) noexcept;               // C++20
+//   constexpr bool in_range(T t) noexcept;
 
 #include <cuda/std/cassert>
 #include <cuda/std/cstdint>
@@ -24,28 +22,17 @@
 template <typename T>
 struct Tuple
 {
-  T min;
-  T max;
-  T mid;
-  __host__ __device__ constexpr Tuple()
-  {
-    min = cuda::std::numeric_limits<T>::min();
-    max = cuda::std::numeric_limits<T>::max();
-    if constexpr (cuda::std::is_signed_v<T>)
-    {
-      mid = T(-1);
-    }
-    else
-    {
-      mid = max >> 1;
-    }
-  }
+  T min = cuda::std::numeric_limits<T>::min();
+  T max = cuda::std::numeric_limits<T>::max();
+  T mid = cuda::std::is_signed<T>::value ? T(-1) : max >> 1;
+
+  __host__ __device__ constexpr Tuple() noexcept {}
 };
 
 template <typename T>
-__host__ __device__ constexpr void test_in_range1()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test_in_range1()
 {
-  constexpr Tuple<T> tup;
+  constexpr Tuple<T> tup{};
   assert(cuda::std::in_range<T>(tup.min));
   assert(cuda::std::in_range<T>(tup.min + 1));
   assert(cuda::std::in_range<T>(tup.max));
@@ -55,10 +42,10 @@ __host__ __device__ constexpr void test_in_range1()
   assert(cuda::std::in_range<T>(tup.mid + 1));
 }
 
-__host__ __device__ constexpr void test_in_range()
+__host__ __device__ TEST_CONSTEXPR_CXX14 void test_in_range()
 {
-  constexpr Tuple<uint8_t> utup8;
-  constexpr Tuple<int8_t> stup8;
+  constexpr Tuple<uint8_t> utup8{};
+  constexpr Tuple<int8_t> stup8{};
   assert(!cuda::std::in_range<int8_t>(utup8.max));
   assert(cuda::std::in_range<short>(utup8.max));
   assert(!cuda::std::in_range<uint8_t>(stup8.min));
@@ -67,32 +54,23 @@ __host__ __device__ constexpr void test_in_range()
   assert(!cuda::std::in_range<uint8_t>(-1));
 }
 
-template <class... Ts>
-__host__ __device__ constexpr void test1(const cuda::std::tuple<Ts...>&)
+__host__ __device__ TEST_CONSTEXPR_CXX14 bool test()
 {
-  (test_in_range1<Ts>(), ...);
-}
-
-__host__ __device__ constexpr bool test()
-{
-  cuda::std::tuple<
-#ifndef TEST_HAS_NO_INT128_T
-    __int128_t,
-    __uint128_t,
-#endif
-    unsigned long long,
-    long long,
-    unsigned long,
-    long,
-    unsigned int,
-    int,
-    unsigned short,
-    short,
-    unsigned char,
-    signed char>
-    types;
-  test1(types);
   test_in_range();
+#ifndef TEST_HAS_NO_INT128_T
+  test_in_range1<__int128_t>();
+  test_in_range1<__uint128_t>();
+#endif // TEST_HAS_NO_INT128_T
+  test_in_range1<unsigned long long>();
+  test_in_range1<long long>();
+  test_in_range1<unsigned long>();
+  test_in_range1<long>();
+  test_in_range1<unsigned int>();
+  test_in_range1<int>();
+  test_in_range1<unsigned short>();
+  test_in_range1<short>();
+  test_in_range1<unsigned char>();
+  test_in_range1<signed char>();
   return true;
 }
 
@@ -100,6 +78,8 @@ int main(int, char**)
 {
   ASSERT_NOEXCEPT(cuda::std::in_range<int>(-1));
   test();
-  static_assert(test());
+#if TEST_STD_VER >= 2014
+  static_assert(test(), "");
+#endif // TEST_STD_VER >= 2014
   return 0;
 }