[libc++][test] Replaces TEST_IS_CONSTANT_EVALUATED.

[Mordante]

Summary

When using GCC-12 in C++11 mode the TEST_IS_CONSTANT_EVALUATED macro
causes "tautological compare" errors. This replaces the macro with a
helper function. The function is based on @philnik's suggestion in
D126667.

[Mordante]

Fixes C++03 build.

[Mordante]

Fixes CI.

[Mordante]

I've rebased the GCC-12 CI changes (D126667) on top of this one and the GCC CI is happy (https://buildkite.com/llvm-project/libcxx-ci/builds/11560).
So that means the only tautological comparison issues where the constant evaluated messages.

libcxx/test/std/strings/string.view/string.view.comparison/not_equal.pass.cpp

58

I'll remove this comment before landing or the next upload whatever comes first.

[philnik]

LGTM % nits.

libcxx/test/support/constant_evaluated.h

18

Can't this be an anonymous enum? Or is this an extension?

27–31

I think I'd rather have this in it's own function instead of a macro.

[Mordante]

libcxx/test/support/constant_evaluated.h

18

No it can't; it's used as an argument to is_constant_evaluated.

27–31

But that function would also need macros, right?
I can add a function that only returns the status of "IS_CONSTANT_EVALUATED" and keep the version dependent logic here.

[jloser]

libcxx/test/std/strings/string.view/string.view.comparison/not_equal.pass.cpp

58

That's interesting. Why does it fail in C++17 mode?

[Mordante]

libcxx/test/std/strings/string.view/string.view.comparison/not_equal.pass.cpp

58

Initially I only used TestedCppVersion::Cpp20 which caused the build to file. After correcting this I forgot to remove this comment.

[ldionne]

While I have very little love for TEST_IS_CONSTANT_EVALUATED, I am not sure this increase in complexity for the reader is the right way to go forward in order to fix a (arguably kind of spurious) compiler warning. I'm eager to better understand the answer to the questions I've left and see if that makes me see this patch with different eyes.

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

58

So the goal of this patch is to get rid of tautological comparison warnings in GCC. However, I am not sure this is a proper solution to this. Indeed, !is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20 could easily be flagged as tautological by GCC (or Clang) if for example TEST_STD_VER >= 20 evaluates to true. It looks like we've simply increased the complexity of the expression enough for GCC not to be as clever as ourselves, and hence it doesn't produce the warning. In other words, I am not convinced this is a long term or robust solution to this issue.

79

I am not sure I understand what's the purpose of passing TestedCppVersion::CppNN to this function. Is there any case in which the NN version passed here should differ from the NN version used in the TEST_CONSTEXPR_CXXNN macro of the enclosing function? If not, then perhaps it doesn't really make sense to pass a standard version to this function? And if that's the case, then we're basically back to the TEST_IS_CONSTANT_EVALUATED macro again.

[ldionne]

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp

22

I think this is effectively what we want, unfortunately it makes the code pretty damn ugly because we would have to forward this bool across all function calls.

[Mordante]

Based on the review comments, I'm no longer pursuing this patch.

libcxx/test/libcxx/algorithms/robust_against_copying_comparators.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 #include <algorithm>
 #include <cassert>
 #include <compare>
 #include <cstddef>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 template <class T>
 struct Less {
     int *copies_;
     TEST_CONSTEXPR explicit Less(int *copies) : copies_(copies) {}
     TEST_CONSTEXPR_CXX14 Less(const Less& rhs) : copies_(rhs.copies_) { *copies_ += 1; }
     TEST_CONSTEXPR_CXX14 Less& operator=(const Less&) = default;
#endif
     (void)std::is_heap_until(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::is_partitioned(first, last, UnaryTrue<T>(&copies)); assert(copies == 0);
     (void)std::is_permutation(first, last, first2, Equal<T>(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 11
     (void)std::is_permutation(first, last, first2, last2, Equal<T>(&copies)); assert(copies == 0);
 #endif
     (void)std::is_sorted(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::is_sorted_until(first, last, Less<T>(&copies)); assert(copies == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED) { (void)std::inplace_merge(first, mid, last, Less<T>(&copies)); assert(copies == 0); }
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { (void)std::inplace_merge(first, mid, last, Less<T>(&copies)); assert(copies == 0); }
     (void)std::lexicographical_compare(first, last, first2, last2, Less<T>(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 17
     //(void)std::lexicographical_compare_three_way(first, last, first2, last2, ThreeWay(&copies)); assert(copies == 0);
 #endif
     (void)std::lower_bound(first, last, value, Less<T>(&copies)); assert(copies == 0);
     (void)std::make_heap(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::max(value, value, Less<T>(&copies)); assert(copies == 0);
 #if TEST_STD_VER >= 11
#endif
     (void)std::set_intersection(first, mid, mid, last, first2, Less<T>(&copies)); assert(copies == 0);
     (void)std::set_symmetric_difference(first, mid, mid, last, first2, Less<T>(&copies)); assert(copies == 0);
     (void)std::set_union(first, mid, mid, last, first2, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, first+3, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, first+4, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, first+5, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort(first, last, Less<T>(&copies)); assert(copies == 0);
     (void)std::sort_heap(first, last, Less<T>(&copies)); assert(copies == 0);
-    if (!TEST_IS_CONSTANT_EVALUATED) { (void)std::stable_partition(first, last, UnaryTrue<T>(&copies)); assert(copies == 0); }
-    if (!TEST_IS_CONSTANT_EVALUATED) { (void)std::stable_sort(first, last, Less<T>(&copies)); assert(copies == 0); }
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { (void)std::stable_partition(first, last, UnaryTrue<T>(&copies)); assert(copies == 0); }
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { (void)std::stable_sort(first, last, Less<T>(&copies)); assert(copies == 0); }
     (void)std::transform(first, last, first2, UnaryTransform<T>(&copies)); assert(copies == 0);
     (void)std::transform(first, mid, mid, first2, BinaryTransform<T>(&copies)); assert(copies == 0);
     (void)std::unique(first, last, Equal<T>(&copies)); assert(copies == 0);
     (void)std::unique_copy(first, last, first2, Equal<T>(&copies)); assert(copies == 0);
     (void)std::upper_bound(first, last, value, Less<T>(&copies)); assert(copies == 0);
 
     return true;
 }

libcxx/test/std/algorithms/robust_re_difference_type.compile.pass.cpp

 //   the semantics of a + n and a - n are, respectively,
 //   those of a + D(n) and a - D(n).
 
 #include <algorithm>
 #include <cstddef>
 #include <functional>
 #include <iterator>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 // This iterator rejects expressions like (a + n) and (a - n)
 // whenever n is of any type other than difference_type.
 //
 template<class It, class DifferenceType>
 class PickyIterator {
     It it_;

 #if TEST_STD_VER > 11
     (void)std::is_permutation(first, last, first2, last2);
     (void)std::is_permutation(first, last, first2, last2, std::equal_to<void*>());
 #endif
     (void)std::is_sorted(first, last);
     (void)std::is_sorted(first, last, std::less<void*>());
     (void)std::is_sorted_until(first, last);
     (void)std::is_sorted_until(first, last, std::less<void*>());
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::inplace_merge(first, mid, last);
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::inplace_merge(first, mid, last, std::less<void*>());
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) (void)std::inplace_merge(first, mid, last);
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) (void)std::inplace_merge(first, mid, last, std::less<void*>());
     (void)std::iter_swap(first, mid);
     (void)std::lexicographical_compare(first, last, first2, last2);
     (void)std::lexicographical_compare(first, last, first2, last2, std::less<void*>());
     // TODO: lexicographical_compare_three_way
     (void)std::lower_bound(first, last, value);
     (void)std::lower_bound(first, last, value, std::less<void*>());
     (void)std::make_heap(first, last);
     (void)std::make_heap(first, last, std::less<void*>());

 #if TEST_STD_VER > 17
     (void)std::shift_left(first, last, count);
     (void)std::shift_right(first, last, count);
 #endif
     (void)std::sort(first, last);
     (void)std::sort(first, last, std::less<void*>());
     (void)std::sort_heap(first, last);
     (void)std::sort_heap(first, last, std::less<void*>());
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::stable_partition(first, last, UnaryTrue());
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::stable_sort(first, last);
-    if (!TEST_IS_CONSTANT_EVALUATED) (void)std::stable_sort(first, last, std::less<void*>());
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) (void)std::stable_partition(first, last, UnaryTrue());
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) (void)std::stable_sort(first, last);
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) (void)std::stable_sort(first, last, std::less<void*>());
     (void)std::swap_ranges(first, last, first2);
     (void)std::transform(first, last, first2, UnaryTransform());
     (void)std::transform(first, mid, mid, first2, BinaryTransform());
     (void)std::unique(first, last);
     (void)std::unique(first, last, std::equal_to<void*>());
     (void)std::unique_copy(first, last, first2);
     (void)std::unique_copy(first, last, first2, std::equal_to<void*>());
     (void)std::upper_bound(first, last, value);

libcxx/test/std/strings/basic.string/string.access/at.pass.cpp

 //       reference at(size_type pos); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos)
 {
     const S& cs = s;
     if (pos < s.size())
     {
         assert(s.at(pos) == s[pos]);
         assert(cs.at(pos) == cs[pos]);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.at(pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.capacity/reserve_size.pass.cpp

 // This test relies on https://llvm.org/PR45368 being fixed, which isn't in
 // older Apple dylibs
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0}}
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(typename S::size_type min_cap, typename S::size_type erased_index, typename S::size_type res_arg)
 {
     S s(min_cap, 'a');
if (res_arg <= s.max_size())
         assert(s == s0);
         assert(s.capacity() >= res_arg);
         assert(s.capacity() >= s.size());
 #if TEST_STD_VER > 17
         assert(s.capacity() >= old_cap); // reserve never shrinks as of P0966 (C++20)
 #endif
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.reserve(res_arg);
             LIBCPP_ASSERT(s.__invariants());
             assert(false);
         }
         catch (std::length_error&)

libcxx/test/std/strings/basic.string/string.capacity/resize_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // void resize(size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, S expected)
 {
     if (n <= s.max_size())
     {
         s.resize(n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.resize(n);
             assert(false);
         }
         catch (std::length_error&)
         {

libcxx/test/std/strings/basic.string/string.capacity/resize_size_char.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // void resize(size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type n, typename S::value_type c, S expected)
 {
     if (n <= s.max_size())
     {
         s.resize(n, c);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.resize(n, c);
             assert(false);
         }
         catch (std::length_error&)
         {

libcxx/test/std/strings/basic.string/string.cons/T_size_size.pass.cpp

 //  Mostly we're testing string_view here
 
 #include <string>
 #include <string_view>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(SV sv, std::size_t pos, std::size_t n)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     typedef typename S::size_type Size;
     if (pos <= sv.size())
     {
         S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
         LIBCPP_ASSERT(s2.__invariants());
         assert(pos <= sv.size());
         std::size_t rlen = std::min(sv.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n));
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= sv.size())
         assert(pos <= sv.size());
         std::size_t rlen = std::min(sv.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), sv.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             S s2(sv, static_cast<Size>(pos), static_cast<Size>(n), a);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // basic_string(const basic_string& str, const Allocator& alloc); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct alloc_imp {
     bool active;
 
#if TEST_STD_VER >= 11
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     test(S(), A());
     test(S("1"), A());
     test(S("1234567890123456789012345678901234567890123456789012345678901234567890"), A());
   }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) {
+  if (!is_constant_evaluated(TestedCppVersion::Cpp20)) {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
     const char * p1 = "This is my first string";
     const char * p2 = "This is my second string";
 
     alloc_imp imp1;
     alloc_imp imp2;
     S s1(p1, A(&imp1));

libcxx/test/std/strings/basic.string/string.cons/substr.pass.cpp

 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <vector>
 #include <scoped_allocator>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S str, unsigned pos)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
 
     if (pos <= str.size())
     {
         S s2(str, pos);
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = str.size() - pos;
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             S s2(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             S s2(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos <= str.size())
         LIBCPP_ASSERT(s2.__invariants());
         typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             S s2(str, pos, n, a);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_append/T_size_size.pass.cpp

 // template <class T>
 //    basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20
 
 #include <string>
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
     {
         s.append(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.append(sv, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= sv.size())
     {
         s.append(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.append(sv, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class InputIterator>
 //   basic_string& append(InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("12345678901234567890""A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("12345678901234567890""ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
   }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
#endif
     test(s_short, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("hello\0", 6));
     test(s_long, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,
          std::string("Lorem ipsum dolor sit amet, consectetur/\0", 41));
 
     s_sneaky.reserve(12);
     test(s_sneaky, s_sneaky.data(), s_sneaky.data() + 6, std::string("hellohello\0", 11));
 
-     if (!TEST_IS_CONSTANT_EVALUATED) {
+     if (!is_constant_evaluated(TestedCppVersion::Cpp20)) {
        const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
        test(s_othertype, first + 2, first + 5, std::string("hellollo"));
      }
   }
 
   { // test with a move iterator that returns char&&
     typedef forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;

libcxx/test/std/strings/basic.string/string.modifiers/string_append/string_size_size.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   append(const basic_string<charT,traits>& str, size_type pos, size_type n = npos); // constexpr since C++20
 //  the "= npos" was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
     {
         s.append(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.append(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= str.size())
     {
         s.append(str, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.append(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/T_size_size.pass.cpp

 
 // template <class T>
 //    basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17, constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, SV sv, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.assign(sv, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= sv.size())
     {
         s.assign(sv, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.assign(sv, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class InputIterator>
 //   basic_string& assign(InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, It first, It last, S expected)
 {
test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1),
          S("A"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
     test(S("12345678901234567890"), cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
   }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/string_size_size.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   assign(const basic_string<charT,traits>& str, size_type pos, size_type n=npos); // constexpr since C++20
 // the =npos was added for C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, S str, typename S::size_type pos, typename S::size_type n, S expected)
 {
     if (pos <= str.size())
     {
         s.assign(str, pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.assign(str, pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

 {
     if (pos <= str.size())
     {
         s.assign(str, pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.assign(str, pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_copy/copy.pass.cpp

 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S str, typename S::value_type* s, typename S::size_type n,
      typename S::size_type pos)
 {
     const S& cs = str;
     if (pos <= cs.size())
     {
         typename S::size_type r = cs.copy(s, n, pos);
         typename S::size_type rlen = std::min(n, cs.size() - pos);
         assert(r == rlen);
         for (r = 0; r < rlen; ++r)
             assert(S::traits_type::eq(cs[pos+r], s[r]));
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             typename S::size_type r = cs.copy(s, n, pos);
             ((void)r); // Prevent unused warning
             assert(false);
         }
         catch (std::out_of_range&)

libcxx/test/std/strings/basic.string/string.modifiers/string_erase/size_size.pass.cpp

 
 // basic_string<charT,traits,Allocator>&
 //   erase(size_type pos = 0, size_type n = npos); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.erase(pos, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s[s.size()] == typename S::value_type());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.erase(pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
test(S s, typename S::size_type pos, S expected)
     if (pos <= old_size)
     {
         s.erase(pos);
         LIBCPP_ASSERT(s.__invariants());
         assert(s[s.size()] == typename S::value_type());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.erase(pos);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class InputIterator>
 //   iterator insert(const_iterator p, InputIterator first, InputIterator last); // constexpr since C++20
 
 #include <string>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::difference_type pos, It first, It last, S expected)
 {
#if TEST_STD_VER >= 11
     test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s), S("12345678901234567890"));
     test(S("12345678901234567890"), 3, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+1), S("123A45678901234567890"));
     test(S("12345678901234567890"), 15, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
     test(S("12345678901234567890"), 20, cpp17_input_iterator<const char*>(s), cpp17_input_iterator<const char*>(s+52),
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
   }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
#endif
     typedef std::string S;
     const uint8_t p[] = "ABCD";
 
     S s;
     s.insert(s.begin(), p, p + 4);
     assert(s == "ABCD");
   }
 
-  if (!TEST_IS_CONSTANT_EVALUATED) { // regression-test inserting into self in sneaky ways
+  if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { // regression-test inserting into self in sneaky ways
     std::string s_short = "hello";
     std::string s_long = "Lorem ipsum dolor sit amet, consectetur/";
     std::string s_othertype = "hello";
     const unsigned char *first = reinterpret_cast<const unsigned char*>(s_othertype.data());
 
     test(s_short, 0, s_short.data() + s_short.size(), s_short.data() + s_short.size() + 1,
          std::string("\0hello", 6));
     test(s_long, 0, s_long.data() + s_long.size(), s_long.data() + s_long.size() + 1,

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_T_size_size.pass.cpp

 //    basic_string& assign(size_type pos1, const T& t, size_type pos2, size_type n=npos); // C++17, constexpr since C++20
 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.insert(pos1, sv, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos1, sv, pos2, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
test_npos(S s, typename S::size_type pos1, SV sv, typename S::size_type pos2, S expected)
     S s0 = s;
     if (pos1 <= old_size && pos2 <= sv.size())
     {
         s.insert(pos1, sv, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos1, sv, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp

 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos, const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp

 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos, const charT* s, size_type n); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, const typename S::value_type* str,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos, str, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_size_char.pass.cpp

 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos, size_type n, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n,
      typename S::value_type str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, n, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos, n, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string.pass.cpp

 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos1, const basic_string& str); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/size_string_size_size.pass.cpp

 //   insert(size_type pos1, const basic_string<charT,traits,Allocator>& str,
 //          size_type pos2, size_type n=npos); // constexpr since C++20
 // the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, S str, typename S::size_type pos2,
      typename S::size_type n, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2, n);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos1, str, pos2, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {
test_npos(S s, typename S::size_type pos1, S str, typename S::size_type pos2, S expected)
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.insert(pos1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos1, str, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp

 
 // basic_string<charT,traits,Allocator>&
 //   insert(size_type pos, string_view sv); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.insert(pos, sv);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.insert(pos, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

 // template<class InputIterator>
 //   basic_string&
 //   replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); // constexpr since C++20
 
 #include <string>
 #include <iterator>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_iterators.h"
 
 template <class S, class It>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, It f, It l, S expected)
 {
TEST_CONSTEXPR_CXX20 bool test8()
     test(S("abcdefghijklmnopqrst"), 20, 0, str, str+20, S("abcdefghijklmnopqrst12345678901234567890"));
 
     return true;
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 bool test9() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-  if (!TEST_IS_CONSTANT_EVALUATED) { // test iterator operations that throw
+  if (!is_constant_evaluated(TestedCppVersion::Cpp20)) { // test iterator operations that throw
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_T_size_size.pass.cpp

 //
 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, typename S::size_type pos2, typename S::size_type n2,
      S expected)
if (pos1 <= old_size && pos2 <= sv.size())
         s.replace(pos1, n1, sv, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         SizeT xlen = std::min<SizeT>(n1, old_size - pos1);
         SizeT rlen = std::min<SizeT>(n2, sv.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos1, n1, sv, pos2, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos1 <= old_size && pos2 <= sv.size())
         s.replace(pos1, n1, sv, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         SizeT xlen = std::min<SizeT>(n1, old_size - pos1);
         SizeT rlen = std::min<SizeT>(S::npos, sv.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos1, n1, sv, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, const charT* s); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.replace(pos, n1, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = S::traits_type::length(str);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_pointer_size.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, const charT* s, size_type n2); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.replace(pos, n1, str, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_size_char.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos, size_type n1, size_type n2, charT c); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos, typename S::size_type n1,
      typename S::size_type n2, typename S::value_type c,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos <= old_size)
     {
         s.replace(pos, n1, n2, c);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos);
         typename S::size_type rlen = n2;
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos, n1, n2, c);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos1, size_type n1, const basic_string<charT,traits,Allocator>& str); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, S str, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
     {
         s.replace(pos1, n1, str);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = str.size();
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

 //           size_type pos2, size_type n2=npos); // constexpr since C++20
 //  the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1,
      S str, typename S::size_type pos2, typename S::size_type n2,
      S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size && pos2 <= str.size())
     {
         s.replace(pos1, n1, str, pos2, n2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(n2, str.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos1, n1, str, pos2, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {
if (pos1 <= old_size && pos2 <= str.size())
         s.replace(pos1, n1, str, pos2);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = std::min(S::npos, str.size() - pos2);
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos1, n1, str, pos2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp

 // basic_string<charT,traits,Allocator>&
 //   replace(size_type pos1, size_type n1, basic_string_view<charT,traits> sv); // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
 {
     const typename S::size_type old_size = s.size();
     S s0 = s;
     if (pos1 <= old_size)
     {
         s.replace(pos1, n1, sv);
         LIBCPP_ASSERT(s.__invariants());
         assert(s == expected);
         typename S::size_type xlen = std::min(n1, old_size - pos1);
         typename S::size_type rlen = sv.size();
         assert(s.size() == old_size - xlen + rlen);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             s.replace(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp

 //  Mostly we're testing string_view here
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv,      typename S::size_type pos2, typename S::size_type n2, int x)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > sv.size());
         }
     }
 #endif
 }
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test_npos(const S& s, typename S::size_type pos1, typename S::size_type n1,
           SV sv,      typename S::size_type pos2, int x)
 {
     static_assert((!std::is_same<S, SV>::value), "");
     if (pos1 <= s.size() && pos2 <= sv.size())
         assert(sign(s.compare(pos1, n1, sv, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp

 // int compare(size_type pos, size_type n1, const charT *s) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const typename S::value_type* str, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp

 // int compare(size_type pos, size_type n1, const charT *s, size_type n2) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n1,
      const typename S::value_type* str, typename S::size_type n2, int x)
 {
     if (pos <= s.size())
         assert(sign(s.compare(pos, n1, str, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // int compare(size_type pos1, size_type n1, const basic_string& str) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      const S& str, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, str)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp

 //  the "=npos" was added in C++14
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s,   typename S::size_type pos1, typename S::size_type n1,
      const S& str, typename S::size_type pos2, typename S::size_type n2, int x)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2, n2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {
             assert(pos1 > s.size() || pos2 > str.size());
         }
     }
 #endif
 }
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test_npos(const S& s,   typename S::size_type pos1, typename S::size_type n1,
           const S& str, typename S::size_type pos2, int x)
 {
     if (pos1 <= s.size() && pos2 <= str.size())
         assert(sign(s.compare(pos1, n1, str, pos2)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp

 // int compare(size_type pos1, size_type n1, basic_string_view sv) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "min_allocator.h"
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 int sign(int x)
 {
     if (x == 0)
         return 0;
     if (x < 0)
         return -1;
     return 1;
 }
 
 template <class S, class SV>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos1, typename S::size_type n1,
      SV sv, int x)
 {
     if (pos1 <= s.size())
         assert(sign(s.compare(pos1, n1, sv)) == sign(x));
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/basic.string/string.ops/string_substr/substr.pass.cpp

 
 // basic_string substr(size_type pos = 0, size_type n = npos) const; // constexpr since C++20
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
 test(const S& s, typename S::size_type pos, typename S::size_type n)
 {
     if (pos <= s.size())
     {
         S str = s.substr(pos, n);
         LIBCPP_ASSERT(str.__invariants());
         assert(pos <= s.size());
         typename S::size_type rlen = std::min(n, s.size() - pos);
         assert(str.size() == rlen);
         assert(S::traits_type::compare(s.data()+pos, str.data(), rlen) == 0);
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    else if (!TEST_IS_CONSTANT_EVALUATED)
+    else if (!is_constant_evaluated(TestedCppVersion::Cpp20))
     {
         try
         {
             S str = s.substr(pos, n);
             assert(false);
         }
         catch (std::out_of_range&)
         {

libcxx/test/std/strings/string.view/string.view.comparison/equal.pass.cpp

 // template<class charT, class traits>
 //   constexpr bool operator==(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>
 #include <string>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 
 template<class T>
 struct ConvertibleTo {
     T t_;
     TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i == j);
             assert((v[i] == v[j]) == expected);
             assert((v[i].data() == v[j]) == expected);
             assert((v[i] == v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) == v[j]) == expected);
             assert((v[i] == ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) == v[j]) == expected);
                 assert((v[i] == std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc == abc0def) == false);
     assert((abc == abcdef) == false);
     assert((abc0def == abc) == false);
     assert((abc0def == abcdef) == false);
     assert((abcdef == abc) == false);
     assert((abcdef == abc0def) == false);
 
     assert((abc.data() == abc0def) == false);
     assert((abc0def == abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) == abc0def) == false);
         assert((abc0def == std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/greater.pass.cpp

 // template<class charT, class traits>
 //   constexpr bool operator>(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>
 #include <string>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 
 template<class T>
 struct ConvertibleTo {
     T t_;
     TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i > j);
             assert((v[i] > v[j]) == expected);
             assert((v[i].data() > v[j]) == expected);
             assert((v[i] > v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) > v[j]) == expected);
             assert((v[i] > ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) > v[j]) == expected);
                 assert((v[i] > std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc > abc0def) == false);
     assert((abc > abcdef) == false);
     assert((abc0def > abc) == true);
     assert((abc0def > abcdef) == false);
     assert((abcdef > abc) == true);
     assert((abcdef > abc0def) == true);
 
     assert((abc.data() > abc0def) == false);
     assert((abc0def > abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) > abc0def) == false);
         assert((abc0def > std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/greater_equal.pass.cpp

 // template<class charT, class traits>
 //   constexpr bool operator>=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>
 #include <string>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 
 template<class T>
 struct ConvertibleTo {
     T t_;
     TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i >= j);
             assert((v[i] >= v[j]) == expected);
             assert((v[i].data() >= v[j]) == expected);
             assert((v[i] >= v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) >= v[j]) == expected);
             assert((v[i] >= ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) >= v[j]) == expected);
                 assert((v[i] >= std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc >= abc0def) == false);
     assert((abc >= abcdef) == false);
     assert((abc0def >= abc) == true);
     assert((abc0def >= abcdef) == false);
     assert((abcdef >= abc) == true);
     assert((abcdef >= abc0def) == true);
 
     assert((abc.data() >= abc0def) == false);
     assert((abc0def >= abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) >= abc0def) == false);
         assert((abc0def >= std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/less.pass.cpp

 // template<class charT, class traits>
 //   constexpr bool operator<(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>
 #include <string>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 
 template<class T>
 struct ConvertibleTo {
     T t_;
     TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i < j);
             assert((v[i] < v[j]) == expected);
             assert((v[i].data() < v[j]) == expected);
             assert((v[i] < v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) < v[j]) == expected);
             assert((v[i] < ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) < v[j]) == expected);
                 assert((v[i] < std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc < abc0def) == true);
     assert((abc < abcdef) == true);
     assert((abc0def < abc) == false);
     assert((abc0def < abcdef) == true);
     assert((abcdef < abc) == false);
     assert((abcdef < abc0def) == false);
 
     assert((abc.data() < abc0def) == true);
     assert((abc0def < abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) < abc0def) == true);
         assert((abc0def < std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/less_equal.pass.cpp

 // template<class charT, class traits>
 //   constexpr bool operator<=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>
 #include <string>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 
 template<class T>
 struct ConvertibleTo {
     T t_;
     TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i <= j);
             assert((v[i] <= v[j]) == expected);
             assert((v[i].data() <= v[j]) == expected);
             assert((v[i] <= v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) <= v[j]) == expected);
             assert((v[i] <= ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+            if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) <= v[j]) == expected);
                 assert((v[i] <= std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc <= abc0def) == true);
     assert((abc <= abcdef) == true);
     assert((abc0def <= abc) == false);
     assert((abc0def <= abcdef) == true);
     assert((abcdef <= abc) == false);
     assert((abcdef <= abc0def) == false);
 
     assert((abc.data() <= abc0def) == true);
     assert((abc0def <= abc.data()) == false);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) <= abc0def) == true);
         assert((abc0def <= std::basic_string<CharT, Traits>(abc)) == false);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/std/strings/string.view/string.view.comparison/not_equal.pass.cpp

 // template<class charT, class traits>
 //   constexpr bool operator!=(basic_string_view<charT, traits> lhs, basic_string_view<charT, traits> rhs);
 // (plus "sufficient additional overloads" to make implicit conversions work as intended)
 
 #include <string_view>
 #include <cassert>
 #include <string>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 #include "constexpr_char_traits.h"
 #include "make_string.h"
 
 template<class T>
 struct ConvertibleTo {
     T t_;
     TEST_CONSTEXPR explicit ConvertibleTo(T t) : t_(t) {}
for (int i = 0; i < 4; ++i) {
             // See http://eel.is/c++draft/string.view#tab:string.view.comparison.overloads
             bool expected = (i != j);
             assert((v[i] != v[j]) == expected);
             assert((v[i].data() != v[j]) == expected);
             assert((v[i] != v[j].data()) == expected);
             assert((ConvertibleTo<SV>(v[i]) != v[j]) == expected);
             assert((v[i] != ConvertibleTo<SV>(v[j])) == expected);
 
-            if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+      // fails in C++17
+            if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
                 assert((std::basic_string<CharT, Traits>(v[i]) != v[j]) == expected);
                 assert((v[i] != std::basic_string<CharT, Traits>(v[j])) == expected);
             }
         }
     }
 
     // Test its behavior with embedded null bytes.
     SV abc = SV(MAKE_CSTRING(CharT, "abc"));
     SV abc0def = SV(MAKE_CSTRING(CharT, "abc\0def"), 7);
     SV abcdef = SV(MAKE_CSTRING(CharT, "abcdef"));
     assert((abc != abc0def) == true);
     assert((abc != abcdef) == true);
     assert((abc0def != abc) == true);
     assert((abc0def != abcdef) == true);
     assert((abcdef != abc) == true);
     assert((abcdef != abc0def) == true);
 
     assert((abc.data() != abc0def) == true);
     assert((abc0def != abc.data()) == true);
 
-    if (!TEST_IS_CONSTANT_EVALUATED || TEST_STD_VER >= 20) {
+    if (!is_constant_evaluated(TestedCppVersion::Cpp14) || TEST_STD_VER >= 20) {
         assert((std::basic_string<CharT, Traits>(abc) != abc0def) == true);
         assert((abc0def != std::basic_string<CharT, Traits>(abc)) == true);
     }
 
     return true;
 }
 
 int main(int, char**)

libcxx/test/support/constant_evaluated.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_SUPPORT_CONSTANT_EVALUATED_H
+#define TEST_SUPPORT_CONSTANT_EVALUATED_H
+
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+
+namespace TestedCppVersion {
+enum Enum {
+  Cpp14,
+  Cpp17,
+  Cpp20,
+  Cpp23,
+};
+} // namespace TestedCppVersion
+
+TEST_CONSTEXPR_CXX14 bool is_constant_evaluated(TestedCppVersion::Enum version) {
+#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
+#  define IS_CONSTANT_EVALUATED std::is_constant_evaluated()
+#elif TEST_HAS_BUILTIN(__builtin_is_constant_evaluated)
+#  define IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated()
+#endif
+
+#ifndef IS_CONSTANT_EVALUATED
+  (void)version;
+  return false;
+#else
+
+  switch (version) {
+  case TestedCppVersion::Cpp14:
+    return IS_CONSTANT_EVALUATED && TEST_STD_VER > 11;
+  case TestedCppVersion::Cpp17:
+    return IS_CONSTANT_EVALUATED && TEST_STD_VER > 14;
+  case TestedCppVersion::Cpp20:
+    return IS_CONSTANT_EVALUATED && TEST_STD_VER > 17;
+  case TestedCppVersion::Cpp23:
+    return IS_CONSTANT_EVALUATED && TEST_STD_VER > 20;
+  }
+  assert(false);
+#  undef IS_CONSTANT_EVALUATED
+#endif
+}
+
+#endif // TEST_SUPPORT_CONSTANT_EVALUATED_H

libcxx/test/support/constexpr_char_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _CONSTEXPR_CHAR_TRAITS
 #define _CONSTEXPR_CHAR_TRAITS
 
 #include <string>
 #include <cassert>
 
+#include "constant_evaluated.h"
 #include "test_macros.h"
 
 template <class _CharT>
 struct constexpr_char_traits
 {
     typedef _CharT    char_type;
     typedef int       int_type;
     typedef std::streamoff off_type;
constexpr_char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
     }
     return __r;
 }
 
 template <class _CharT>
 TEST_CONSTEXPR_CXX14 _CharT*
 constexpr_char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
-    if (!TEST_IS_CONSTANT_EVALUATED) // fails in constexpr because we might be comparing unrelated pointers
+    if (!is_constant_evaluated(TestedCppVersion::Cpp20)) // fails in constexpr because we might be comparing unrelated pointers
         assert(__s2 < __s1 || __s2 >= __s1+__n);
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
 template <class _CharT>

libcxx/test/support/test_macros.h

 #endif
 
 #if TEST_STD_VER >= 11
 # define TEST_THROW_SPEC(...)
 #else
 # define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif
 
-#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
-# define TEST_IS_CONSTANT_EVALUATED std::is_constant_evaluated()
-#elif TEST_HAS_BUILTIN(__builtin_is_constant_evaluated)
-# define TEST_IS_CONSTANT_EVALUATED __builtin_is_constant_evaluated()
-#else
-# define TEST_IS_CONSTANT_EVALUATED false
-#endif
-
 #if TEST_STD_VER >= 14
 # define TEST_CONSTEXPR_CXX14 constexpr
 #else
 # define TEST_CONSTEXPR_CXX14
 #endif
 
 #if TEST_STD_VER >= 17
 # define TEST_CONSTEXPR_CXX17 constexpr