[libc++][ranges][NFC] Make sure all implemented algorithms are enabled in "robust" tests.

[var-const]

Summary

Also fix std::find_first_of (which accidentally copied the predicate
in the implementation).

libcxx/include/__algorithm/find_first_of.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator1 __find_first_of_ce(_ForwardIterator1 __first1,
                                                                    _ForwardIterator1 __last1,
                                                                    _ForwardIterator2 __first2,
-                                                                   _ForwardIterator2 __last2, _BinaryPredicate __pred) {
+                                                                   _ForwardIterator2 __last2,
+                                                                   _BinaryPredicate&& __pred) {
   for (; __first1 != __last1; ++__first1)
     for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
       if (__pred(*__first1, *__j))
         return __first1;
   return __last1;
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>

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

#endif
     (void)std::ranges::find_first_of(a, b, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::find_if(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::find_if(a, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::find_if_not(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::find_if_not(a, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::for_each(first, last, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
     (void)std::ranges::for_each(a, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
     (void)std::ranges::for_each_n(first, count, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
-    //(void)std::ranges::generate(first, last, NullaryValue(&copies)); assert(copies == 0);
-    //(void)std::ranges::generate(a, NullaryValue(&copies)); assert(copies == 0);
-    //(void)std::ranges::generate_n(first, count, NullaryValue(&copies)); assert(copies == 0);
+    (void)std::ranges::generate(first, last, NullaryValue(&copies)); assert(copies == 0);
+    (void)std::ranges::generate(a, NullaryValue(&copies)); assert(copies == 0);
+    (void)std::ranges::generate_n(first, count, NullaryValue(&copies)); assert(copies == 0);
     (void)std::ranges::includes(first, last, first2, last2, Less(&copies)); assert(copies == 0);
     (void)std::ranges::includes(a, b, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_heap(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_heap(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_heap_until(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_heap_until(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_partitioned(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::is_partitioned(a, UnaryTrue(&copies)); assert(copies == 0);

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

#endif
     (void)std::count_if(first, last, UnaryTrue<T>(&copies)); assert(copies == 0);
     (void)std::copy_if(first, last, first2, UnaryTrue<T>(&copies)); assert(copies == 0);
     (void)std::equal(first, last, first2, Equal<T>(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 11
     (void)std::equal(first, last, first2, last2, Equal<T>(&copies)); assert(copies == 0);
 #endif
     (void)std::equal_range(first, last, value, Less<T>(&copies)); assert(copies == 0);
     (void)std::find_end(first, last, first2, mid2, Equal<T>(&copies)); assert(copies == 0);
-    //(void)std::find_first_of(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
+    (void)std::find_first_of(first, last, first2, last2, Equal<T>(&copies)); assert(copies == 0);
     (void)std::find_if(first, last, UnaryTrue<T>(&copies)); assert(copies == 0);
     (void)std::find_if_not(first, last, UnaryTrue<T>(&copies)); assert(copies == 0);
     (void)std::for_each(first, last, UnaryVoid<T>(&copies)); assert(copies == 1); copies = 0;
 #if TEST_STD_VER > 14
     (void)std::for_each_n(first, count, UnaryVoid<T>(&copies)); assert(copies == 0);
 #endif
     (void)std::generate(first, last, NullaryValue<T>(&copies)); assert(copies == 0);
     (void)std::generate_n(first, count, NullaryValue<T>(&copies)); assert(copies == 0);

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

 static_assert(std::is_same_v<in_out_result<int, long>, copy_backward_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, move_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, move_backward_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, partial_sort_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, remove_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, remove_copy_if_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, replace_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, replace_copy_if_result<int, long>>);
-// static_assert(std::is_same_v<in_out_result<int, long>, reverse_copy_result<int, long>>);
-// static_assert(std::is_same_v<in_out_result<int, long>, rotate_copy_result<int, long>>);
+static_assert(std::is_same_v<in_out_result<int, long>, reverse_copy_result<int, long>>);
+static_assert(std::is_same_v<in_out_result<int, long>, rotate_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, set_difference_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, unary_transform_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_copy_n_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_move_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_move_n_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, unique_copy_result<int, long>>);
 

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

constexpr bool test_all() {
   using std::ranges::copy_backward_result;
   using std::ranges::copy_if_result;
   using std::ranges::for_each_result;
   using std::ranges::merge_result;
   using std::ranges::minmax_result;
   using std::ranges::mismatch_result;
   using std::ranges::move_result;
   using std::ranges::move_backward_result;
+  using std::ranges::next_permutation_result;
   using std::ranges::partial_sort_copy_result;
   using std::ranges::partition_copy_result;
+  using std::ranges::prev_permutation_result;
   using std::ranges::remove_copy_result;
   using std::ranges::remove_copy_if_result;
   using std::ranges::replace_copy_result;
   using std::ranges::replace_copy_if_result;
   using std::ranges::reverse_copy_result;
   using std::ranges::rotate_copy_result;
   using std::ranges::set_difference_result;
   using std::ranges::set_intersection_result;
constexpr bool test_all() {
   dangling_1st(std::ranges::partial_sort, in, mid);
   dangling_1st(std::ranges::nth_element, in, mid);
   if (!std::is_constant_evaluated())
     dangling_1st(std::ranges::inplace_merge, in, mid);
   dangling_1st(std::ranges::make_heap, in);
   dangling_1st(std::ranges::push_heap, in);
   dangling_1st(std::ranges::pop_heap, in);
   dangling_1st(std::ranges::sort_heap, in);
-  //dangling_1st(std::ranges::prev_permutation, in);
-  //dangling_1st(std::ranges::next_permutation, in);
+  dangling_1st<prev_permutation_result<dangling>>(std::ranges::prev_permutation, in);
+  dangling_1st<next_permutation_result<dangling>>(std::ranges::next_permutation, in);
 
   return true;
 }
 
 int main(int, char**) {
   test_all();
   static_assert(test_all());
 
   return 0;
 }

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

constexpr void run_tests() {
   ProxyIterator out2{output.begin() + 1};
   ProxyIterator out_end{output.end()};
 
   T num{2};
   Proxy<T&> x{num};
   int count = 1;
 
   auto unary_pred = [](const Proxy<T&>&) { return true; };
-  //auto binary_pred = [](const Proxy<T>&, const Proxy<T>&) { return return false; };
   auto binary_func = [](const Proxy<T>&, const Proxy<T>&) -> Proxy<T> { return Proxy<T>(T()); };
   auto gen = [] { return Proxy<T>(T{42}); };
 
   test(std::ranges::any_of, in, unary_pred);
   test(std::ranges::all_of, in, unary_pred);
   test(std::ranges::none_of, in, unary_pred);
   test(std::ranges::find, in, x);
   test(std::ranges::find_if, in, unary_pred);
   test(std::ranges::find_if_not, in, unary_pred);
   test(std::ranges::find_first_of, in, in2);
   test(std::ranges::adjacent_find, in);
   test(std::ranges::mismatch, in, in2);
   test(std::ranges::equal, in, in2);
   test(std::ranges::lexicographical_compare, in, in2);
   test(std::ranges::partition_point, in, unary_pred);
   test(std::ranges::lower_bound, in, x);
   test(std::ranges::upper_bound, in, x);
-  //test(std::ranges::equal_range, in, x);
+  test(std::ranges::equal_range, in, x);
   test(std::ranges::binary_search, in, x);
 
   test(std::ranges::min_element, in);
   test(std::ranges::max_element, in);
   test(std::ranges::minmax_element, in);
   test(std::ranges::count, in, x);
   test(std::ranges::count_if, in, unary_pred);
   test(std::ranges::search, in, in2);
constexpr void run_tests() {
   test_mid(std::ranges::partial_sort, in, mid);
   test_mid(std::ranges::nth_element, in, mid);
   if (!std::is_constant_evaluated())
     test_mid(std::ranges::inplace_merge, in, mid);
   test(std::ranges::make_heap, in);
   test(std::ranges::push_heap, in);
   test(std::ranges::pop_heap, in);
   test(std::ranges::sort_heap, in);
-  //test(std::ranges::prev_permutation, in);
-  //test(std::ranges::next_permutation, in);
+  test(std::ranges::prev_permutation, in);
+  test(std::ranges::next_permutation, in);
 
   // The algorithms that work on uninitialized memory have constraints that prevent proxy iterators from being used with
   // them.
 }
 
 constexpr bool test_all() {
   run_tests<int>();
   run_tests<MoveOnly>();

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

constexpr bool test(CPO& o, Args&&...) {
   return true;
 }
 
 int *p;
 int a[10];
 auto odd = [](int x) { return x % 2 != 0; };
 auto triple = [](int x) { return 3*x; };
 auto gen = [] { return 42; };
-//auto plus = [](int x, int y) { return x == y; };
 std::mt19937 g;
 
 // [algorithm.syn]
 
 static_assert(test(std::ranges::adjacent_find, a));
 static_assert(test(std::ranges::all_of, a, odd));
 static_assert(test(std::ranges::any_of, a, odd));
 static_assert(test(std::ranges::binary_search, a, 42));
 static_assert(test(std::ranges::clamp, 42, 42, 42));
 static_assert(test(std::ranges::copy, a, a));
 static_assert(test(std::ranges::copy_backward, a, a));
 static_assert(test(std::ranges::copy_if, a, a, odd));
 static_assert(test(std::ranges::copy_n, a, 10, a));
 static_assert(test(std::ranges::count, a, 42));
 static_assert(test(std::ranges::count_if, a, odd));
 //static_assert(test(std::ranges::ends_with, a, a));
 static_assert(test(std::ranges::equal, a, a));
 static_assert(test(std::ranges::equal_range, a, 42));
 static_assert(test(std::ranges::fill, a, 42));
 static_assert(test(std::ranges::fill_n, a, 10, 42));
 static_assert(test(std::ranges::find, a, 42));
 static_assert(test(std::ranges::find_end, a, a));
-//static_assert(test(std::ranges::find_first_of, a, a));
+static_assert(test(std::ranges::find_first_of, a, a));
 static_assert(test(std::ranges::find_if, a, odd));
 static_assert(test(std::ranges::find_if_not, a, odd));
 static_assert(test(std::ranges::for_each, a, odd));
 static_assert(test(std::ranges::for_each_n, a, 10, odd));
 static_assert(test(std::ranges::generate, a, gen));
 static_assert(test(std::ranges::generate_n, a, 10, gen));
 static_assert(test(std::ranges::includes, a, a));
 static_assert(test(std::ranges::inplace_merge, a, a+5));

 static_assert(test(std::ranges::merge, a, a, a));
 static_assert(test(std::ranges::min, a));
 static_assert(test(std::ranges::min_element, a));
 static_assert(test(std::ranges::minmax, a));
 static_assert(test(std::ranges::minmax_element, a));
 static_assert(test(std::ranges::mismatch, a, a));
 static_assert(test(std::ranges::move, a, a));
 static_assert(test(std::ranges::move_backward, a, a));
-//static_assert(test(std::ranges::next_permutation, a));
+static_assert(test(std::ranges::next_permutation, a));
 static_assert(test(std::ranges::none_of, a, odd));
 static_assert(test(std::ranges::nth_element, a, a+5));
 static_assert(test(std::ranges::partial_sort, a, a+5));
 static_assert(test(std::ranges::partial_sort_copy, a, a));
 static_assert(test(std::ranges::partition, a, odd));
 static_assert(test(std::ranges::partition_copy, a, a, a, odd));
 static_assert(test(std::ranges::partition_point, a, odd));
 static_assert(test(std::ranges::pop_heap, a));
-//static_assert(test(std::ranges::prev_permutation, a));
+static_assert(test(std::ranges::prev_permutation, a));
 static_assert(test(std::ranges::push_heap, a));
 static_assert(test(std::ranges::remove, a, 42));
 static_assert(test(std::ranges::remove_copy, a, a, 42));
 static_assert(test(std::ranges::remove_copy_if, a, a, odd));
 static_assert(test(std::ranges::remove_if, a, odd));
 static_assert(test(std::ranges::replace, a, 42, 43));
 static_assert(test(std::ranges::replace_copy, a, a, 42, 43));
 static_assert(test(std::ranges::replace_copy_if, a, a, odd, 43));