[libc++][test][NFC] Introduce TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED (#132593)

And use it for test cases that became constant-evaluation-suitable due
to P2562R1.

`TEST_STD_AT_LEAST_(20|23)_OR_RUNTIME_EVALUATED` are the precedents.

Author: frederick-vs-ja

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp

@@ -150,10 +150,7 @@ constexpr bool all_the_algorithms()
     (void)std::ranges::is_sorted(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(a, Less(&copies)); assert(copies == 0);
-#if TEST_STD_VER < 26
-    if (!std::is_constant_evaluated())
-#endif
-    {
+    if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
       (void)std::ranges::inplace_merge(first, mid, last, Less(&copies));
       assert(copies == 0);
       (void)std::ranges::inplace_merge(a, mid, Less(&copies));
@@ -230,10 +227,7 @@ constexpr bool all_the_algorithms()
     (void)std::ranges::sort(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::sort_heap(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::sort_heap(a, Less(&copies)); assert(copies == 0);
-#if TEST_STD_VER < 26
-    if (!std::is_constant_evaluated())
-#endif
-    {
+    if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
       (void)std::ranges::stable_partition(first, last, UnaryTrue(&copies));
       assert(copies == 0);
       (void)std::ranges::stable_partition(a, UnaryTrue(&copies));

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp

@@ -147,10 +147,7 @@ constexpr bool all_the_algorithms()
     (void)std::ranges::is_sorted(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(a, Less(), Proj(&copies)); assert(copies == 0);
-#if TEST_STD_VER < 26
-    if (!std::is_constant_evaluated())
-#endif
-    {
+    if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
       (void)std::ranges::inplace_merge(first, mid, last, Less(), Proj(&copies));
       assert(copies == 0);
       (void)std::ranges::inplace_merge(a, mid, Less(), Proj(&copies));
@@ -235,10 +232,7 @@ constexpr bool all_the_algorithms()
     (void)std::ranges::sort(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::sort_heap(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::sort_heap(a, Less(), Proj(&copies)); assert(copies == 0);
-#if TEST_STD_VER < 26
-    if (!std::is_constant_evaluated())
-#endif
-    {
+    if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
       (void)std::ranges::stable_partition(first, last, UnaryTrue(), Proj(&copies));
       assert(copies == 0);
       (void)std::ranges::stable_partition(a, UnaryTrue(), Proj(&copies));

libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp

@@ -197,25 +197,16 @@ constexpr bool test_all() {
     dangling_1st(std::ranges::shuffle, in, rand_gen());
   dangling_1st(std::ranges::unique, in);
   dangling_1st(std::ranges::partition, in, unary_pred);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     dangling_1st(std::ranges::stable_partition, in, unary_pred);
   }
   dangling_1st(std::ranges::sort, in);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     dangling_1st(std::ranges::stable_sort, in);
   }
   dangling_1st(std::ranges::partial_sort, in, mid);
   dangling_1st(std::ranges::nth_element, in, mid);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     dangling_1st(std::ranges::inplace_merge, in, mid);
   }
   dangling_1st(std::ranges::make_heap, in);

libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.pass.cpp

@@ -164,25 +164,16 @@ constexpr bool test_all() {
   // For `shuffle`, whether the given generator is invoked via `std::invoke` is not observable.
   test(std::ranges::unique, in, &Foo::binary_pred, &Bar::val);
   test(std::ranges::partition, in, &Foo::unary_pred, &Bar::val);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test(std::ranges::stable_partition, in, &Foo::unary_pred, &Bar::val);
   }
   test(std::ranges::sort, in, &Foo::binary_pred, &Bar::val);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test(std::ranges::stable_sort, in, &Foo::binary_pred, &Bar::val);
   }
   test_mid(std::ranges::partial_sort, in, mid, &Foo::binary_pred, &Bar::val);
   test_mid(std::ranges::nth_element, in, mid, &Foo::binary_pred, &Bar::val);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test_mid(std::ranges::inplace_merge, in, mid, &Foo::binary_pred, &Bar::val);
   }
   test(std::ranges::make_heap, in, &Foo::binary_pred, &Bar::val);

libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp

@@ -167,25 +167,16 @@ constexpr void run_tests() {
   }
   test(std::ranges::unique, in);
   test(std::ranges::partition, in, unary_pred);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test(std::ranges::stable_partition, in, unary_pred);
   }
   test(std::ranges::sort, in);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test(std::ranges::stable_sort, in);
   }
   test_mid(std::ranges::partial_sort, in, mid);
   test_mid(std::ranges::nth_element, in, mid);
-#if TEST_STD_VER < 26
-  if (!std::is_constant_evaluated())
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test_mid(std::ranges::inplace_merge, in, mid);
   }
   test(std::ranges::make_heap, in);

libcxx/test/std/algorithms/robust_against_adl_on_new.pass.cpp

@@ -26,10 +26,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
   std::sort(a, a + 4);
   std::sort(a, a + 4, std::less<A>());
   std::partition(a, a + 4, A::isEven);
-#if TEST_STD_VER < 26
-  if (!TEST_IS_CONSTANT_EVALUATED)
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     std::stable_sort(a, a + 4);
     std::stable_sort(a, a + 4, std::less<A>());
     std::stable_partition(a, a + 4, A::isEven);

libcxx/test/std/algorithms/robust_against_proxy_iterators_lifetime_bugs.pass.cpp

@@ -735,18 +735,12 @@ TEST_CONSTEXPR_CXX20 bool test() {
     test(simple_in, [&](I b, I e) { (void) std::shuffle(b, e, rand_gen()); });
   // TODO: unique
   test(simple_in, [&](I b, I e) { (void) std::partition(b, e, is_neg); });
-#if TEST_STD_VER < 26
-  if (!TEST_IS_CONSTANT_EVALUATED)
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test(simple_in, [&](I b, I e) { (void)std::stable_partition(b, e, is_neg); });
   }
   if (!TEST_IS_CONSTANT_EVALUATED)
     test(sort_test_in, [&](I b, I e) { (void)std::sort(b, e); });
-#if TEST_STD_VER < 26
-  if (!TEST_IS_CONSTANT_EVALUATED)
-#endif
-  {
+  if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
     test(sort_test_in, [&](I b, I e) { (void)std::stable_sort(b, e); });
   }
   // TODO: partial_sort

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

@@ -141,10 +141,7 @@ TEST_CONSTEXPR_CXX20 bool all_the_algorithms()
     (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_STD_VER < 26
-    if (!TEST_IS_CONSTANT_EVALUATED)
-#endif
-    {
+    if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
       (void)std::inplace_merge(first, mid, last);
       (void)std::inplace_merge(first, mid, last, std::less<void*>());
     }
@@ -245,10 +242,7 @@ TEST_CONSTEXPR_CXX20 bool all_the_algorithms()
     (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_STD_VER < 26
-    if (!TEST_IS_CONSTANT_EVALUATED)
-#endif
-    {
+    if (TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED) {
       (void)std::stable_partition(first, last, UnaryTrue());
       (void)std::stable_sort(first, last);
       (void)std::stable_sort(first, last, std::less<void*>());

libcxx/test/support/test_macros.h

@@ -148,16 +148,22 @@
 # define TEST_IS_CONSTANT_EVALUATED false
 #endif
 
+#if TEST_STD_VER >= 20
+#  define TEST_STD_AT_LEAST_20_OR_RUNTIME_EVALUATED true
+#else
+#  define TEST_STD_AT_LEAST_20_OR_RUNTIME_EVALUATED (!TEST_IS_CONSTANT_EVALUATED)
+#endif
+
 #if TEST_STD_VER >= 23
 #  define TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED true
 #else
 #  define TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED (!TEST_IS_CONSTANT_EVALUATED)
 #endif
 
-#if TEST_STD_VER >= 20
-#  define TEST_STD_AT_LEAST_20_OR_RUNTIME_EVALUATED true
+#if TEST_STD_VER >= 26
+#  define TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED true
 #else
-#  define TEST_STD_AT_LEAST_20_OR_RUNTIME_EVALUATED (!TEST_IS_CONSTANT_EVALUATED)
+#  define TEST_STD_AT_LEAST_26_OR_RUNTIME_EVALUATED (!TEST_IS_CONSTANT_EVALUATED)
 #endif
 
 #if TEST_STD_VER >= 14