Drive-by: Unblock related test coverages in constant evaluation

For `stable_partition`, `ranges::stable_sort`, `std::stable_sort`,
`std::stable_partition`, and `std::inplace_merge`.

Author: frederick-vs-ja

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

@@ -230,10 +230,19 @@ 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 (!std::is_constant_evaluated()) { (void)std::ranges::stable_partition(first, last, UnaryTrue(&copies)); assert(copies == 0); }
-    if (!std::is_constant_evaluated()) { (void)std::ranges::stable_partition(a, UnaryTrue(&copies)); assert(copies == 0); }
-    if (!std::is_constant_evaluated()) { (void)std::ranges::stable_sort(first, last, Less(&copies)); assert(copies == 0); }
-    if (!std::is_constant_evaluated()) { (void)std::ranges::stable_sort(a, Less(&copies)); assert(copies == 0); }
+#if TEST_STD_VER < 26
+    if (!std::is_constant_evaluated())
+#endif
+    {
+      (void)std::ranges::stable_partition(first, last, UnaryTrue(&copies));
+      assert(copies == 0);
+      (void)std::ranges::stable_partition(a, UnaryTrue(&copies));
+      assert(copies == 0);
+      (void)std::ranges::stable_sort(first, last, Less(&copies));
+      assert(copies == 0);
+      (void)std::ranges::stable_sort(a, Less(&copies));
+      assert(copies == 0);
+    }
 #if TEST_STD_VER > 20
     (void)std::ranges::starts_with(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::starts_with(a, b, Equal(&copies)); assert(copies == 0);

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

@@ -235,10 +235,19 @@ 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 (!std::is_constant_evaluated()) { (void)std::ranges::stable_partition(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0); }
-    if (!std::is_constant_evaluated()) { (void)std::ranges::stable_partition(a, UnaryTrue(), Proj(&copies)); assert(copies == 0); }
-    if (!std::is_constant_evaluated()) { (void)std::ranges::stable_sort(first, last, Less(), Proj(&copies)); assert(copies == 0); }
-    if (!std::is_constant_evaluated()) { (void)std::ranges::stable_sort(a, Less(), Proj(&copies)); assert(copies == 0); }
+#if TEST_STD_VER < 26
+    if (!std::is_constant_evaluated())
+#endif
+    {
+      (void)std::ranges::stable_partition(first, last, UnaryTrue(), Proj(&copies));
+      assert(copies == 0);
+      (void)std::ranges::stable_partition(a, UnaryTrue(), Proj(&copies));
+      assert(copies == 0);
+      (void)std::ranges::stable_sort(first, last, Less(), Proj(&copies));
+      assert(copies == 0);
+      (void)std::ranges::stable_sort(a, Less(), Proj(&copies));
+      assert(copies == 0);
+    }
 #if TEST_STD_VER > 20
     (void)std::ranges::starts_with(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::starts_with(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);

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

@@ -15,23 +15,36 @@
 
 struct A {
     int i = 0;
-    bool operator<(const A& rhs) const { return i < rhs.i; }
-    static bool isEven(const A& a) { return a.i % 2 == 0; }
+    TEST_CONSTEXPR bool operator<(const A& rhs) const { return i < rhs.i; }
+    static TEST_CONSTEXPR bool isEven(const A& a) { return a.i % 2 == 0; }
 };
 
 void *operator new(std::size_t, A*) = delete;
 
-int main(int, char**)
-{
-    A a[4] = {};
-    std::sort(a, a+4);
-    std::sort(a, a+4, std::less<A>());
-    std::partition(a, a+4, A::isEven);
-    std::stable_sort(a, a+4);
-    std::stable_sort(a, a+4, std::less<A>());
-    std::stable_partition(a, a+4, A::isEven);
-    std::inplace_merge(a, a+2, a+4);
-    std::inplace_merge(a, a+2, a+4, std::less<A>());
-
-    return 0;
+TEST_CONSTEXPR_CXX20 bool test() {
+  A a[4] = {};
+  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
+  {
+    std::stable_sort(a, a + 4);
+    std::stable_sort(a, a + 4, std::less<A>());
+    std::stable_partition(a, a + 4, A::isEven);
+    std::inplace_merge(a, a + 2, a + 4);
+    std::inplace_merge(a, a + 2, a + 4, std::less<A>());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
+
+  return 0;
 }