[libc++] Enable test for already written ranges algorithms

[Mordante]

Thanks! LGTM when the CI is happy.

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

 {
     T a[10] = {};
     T b[10] = {};
     T half[5] = {};
     T *first = a;
     T *mid = a+5;
     T *last = a+10;
     T *first2 = b;
-    //T *mid2 = b+5;
+    T *mid2 = b+5;
     T *last2 = b+10;
     void *value = nullptr;
     int count = 1;
 
     int copies = 0;
     (void)std::ranges::adjacent_find(first, last, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::adjacent_find(a, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::all_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::all_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::any_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::any_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::binary_search(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::binary_search(a, value, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::binary_search(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::binary_search(a, value, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::clamp(T(), T(), T(), Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(first, last, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(a, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(first, last, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(a, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 20
     //(void)std::ranges::ends_with(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
 #endif
     (void)std::ranges::equal(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::equal(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::equal_range(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::equal_range(a, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find(first, last, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find(a, value, Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::find_end(first, last, first2, mid2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::find_end(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::find_end(first, last, first2, mid2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::find_end(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_first_of(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_first_of(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_if(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_if_not(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_if_not(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::for_each(first, last, UnaryVoid(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::for_each(a, UnaryVoid(), Proj(&copies)); assert(copies == 0);
#endif
     (void)std::ranges::is_sorted(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (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 (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(first, mid, last, Less(), Proj(&copies)); assert(copies == 0); }
     //if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(a, mid, Less(), Proj(&copies)); assert(copies == 0); }
     (void)std::ranges::lexicographical_compare(first, last, first2, last2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::lexicographical_compare(a, b, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::lower_bound(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::lower_bound(a, value, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::lower_bound(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::lower_bound(a, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::make_heap(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::make_heap(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::max(T(), T(), Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::max({ T(), T() }, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::max(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::max_element(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::max_element(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::merge(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
#endif
     //(void)std::ranges::replace_copy(first, last, first2, value, T(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::replace_copy(a, first2, value, T(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::replace_copy_if(first, last, first2, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::replace_copy_if(a, first2, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace(first, last, value, T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace(a, value, T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace_if(first, last, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace_if(a, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::search(first, last, first2, mid2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::search(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::search_n(first, last, count, value, Equal(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::search_n(a, count, value, Equal(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::search(first, last, first2, mid2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::search(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::search_n(first, last, count, value, Equal(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::search_n(a, count, value, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_difference(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_difference(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_intersection(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_intersection(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_symmetric_difference(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_symmetric_difference(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_union(first, mid, mid, last, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::set_union(a, b, first2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
#endif
     (void)std::ranges::transform(first, last, first2, UnaryTransform(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, first2, UnaryTransform(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(first, mid, mid, last, first2, BinaryTransform(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, b, first2, BinaryTransform(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::unique(first, last, Equal(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::unique(a, Equal(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::unique_copy(first, last, first2, Equal(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::unique_copy(a, first2, Equal(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::upper_bound(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::upper_bound(a, value, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::upper_bound(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::upper_bound(a, value, Less(), Proj(&copies)); assert(copies == 0);
 
     return true;
 }
 
 int main(int, char**)
 {
     all_the_algorithms();
     static_assert(all_the_algorithms());
 
     return 0;
 }

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

void test_all() {
   std::array in2 = {4, 5, 6};
   auto mid = in.begin() + 1;
 
   std::array output = {4, 5, 6};
   auto out = output.begin();
   //auto out2 = output.begin() + 1;
 
   int x = 2;
-  //int count = 1;
+  int count = 1;
 
   in_pred(std::ranges::any_of, in, unary_pred);
   in_pred(std::ranges::all_of, in, unary_pred);
   in_pred(std::ranges::none_of, in, unary_pred);
   in_pred(std::ranges::find_if, in, unary_pred);
   in_pred(std::ranges::find_if_not, in, unary_pred);
   in2_pred(std::ranges::find_first_of, in, in2, binary_pred);
   in_pred(std::ranges::adjacent_find, in, binary_pred);
void test_all() {
   std::ranges::minmax(std::initializer_list<int>{1, 2}, binary_pred);
   std::ranges::minmax(in, binary_pred);
 
   in_pred(std::ranges::min_element, in, binary_pred);
   in_pred(std::ranges::max_element, in, binary_pred);
   in_pred(std::ranges::minmax_element, in, binary_pred);
   in_pred(std::ranges::count_if, in, unary_pred);
   //in2_pred(std::ranges::search, in, in2, binary_pred);
-  //std::ranges::search_n(in.begin(), in.end(), count, x, binary_pred);
-  //std::ranges::search_n(in, count, x, binary_pred);
-  //in2_pred(std::ranges::find_end, in, in2, binary_pred);
+  std::ranges::search_n(in.begin(), in.end(), count, x, binary_pred);
+  std::ranges::search_n(in, count, x, binary_pred);
+  in2_pred(std::ranges::find_end, in, in2, binary_pred);
   in_pred(std::ranges::is_partitioned, in, unary_pred);
   in_pred(std::ranges::is_sorted, in, binary_pred);
   in_pred(std::ranges::is_sorted_until, in, binary_pred);
   //in2_pred(std::ranges::includes, in, in2, binary_pred);
   //in_pred(std::ranges::is_heap, in, binary_pred);
   //in_pred(std::ranges::is_heap_until, in, binary_pred);
   //std::ranges::clamp(2, 1, 3, binary_pred);
   //in2_pred(std::ranges::is_permutation, in, in2, binary_pred);

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

void test_all() {
   std::ranges::minmax(std::initializer_list<Bar>{a, b}, &Foo::binary_pred, &Bar::val);
   std::ranges::minmax(in, &Foo::binary_pred, &Bar::val);
 
   in_pred(std::ranges::min_element, in, &Foo::binary_pred, &Bar::val);
   in_pred(std::ranges::max_element, in, &Foo::binary_pred, &Bar::val);
   in_pred(std::ranges::minmax_element, in, &Foo::binary_pred, &Bar::val);
   in_val(std::ranges::count, in, x, &Bar::val);
   in_pred(std::ranges::count_if, in, &Foo::unary_pred, &Bar::val);
-  //in2_pred(std::ranges::search, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  in2_pred(std::ranges::search, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   // search_n
-  //std::ranges::search_n(in.begin(), in.end(), count, x, &Foo::binary_pred, &Bar::val);
-  //std::ranges::search_n(in, count, x, &Foo::binary_pred, &Bar::val);
-  //in2_pred(std::ranges::find_end, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  std::ranges::search_n(in.begin(), in.end(), count, x, &Foo::binary_pred, &Bar::val);
+  std::ranges::search_n(in, count, x, &Foo::binary_pred, &Bar::val);
+  in2_pred(std::ranges::find_end, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   in_pred(std::ranges::is_partitioned, in, &Foo::unary_pred, &Bar::val);
   in_pred(std::ranges::is_sorted, in, &Foo::binary_pred, &Bar::val);
   in_pred(std::ranges::is_sorted_until, in, &Foo::binary_pred, &Bar::val);
   //in2_pred(std::ranges::includes, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   //in_pred(std::ranges::is_heap, in, &Foo::binary_pred, &Bar::val);
   //in_pred(std::ranges::is_heap_until, in, &Foo::binary_pred, &Bar::val);
   //std::ranges::clamp(b, a, c, &Foo::binary_pred);
   //in2_pred(std::ranges::is_permutation, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);