[libc++][ranges][NFC] Consolidate range algorithm checks for returning `dangling`.

[var-const]

Summary

Also simplify the robust test files for non-boolean predicates and
omitting std::invoke.

[var-const]

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

39

I somehow missed this in the initial implementation -- variadics make things so much simpler.

[huixie90]

libcxx/include/__algorithm/ranges_remove_if.h

23

question. why do we need to include this header. borrowed_subrange_t is defined in subrange.h. can we consider dangling is a detail in borrowed_subrange_t?

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

34

this is not an issue for the test because the test doesn't actually run the code. but this is undefined behaviour.
the data_ pointer points to the temporary copy std::array arr and will be dangling immediately after the constructor returns

This makes me think that we should probably actually run the code?

35

is this one used apart from called by the other constructor?

53

a possible additional to the test is dangling_both

53

perhaps it is outside the scope of this test, but for the existing tests in set operations, for those tests that are testing that the second argument is dangling, it also verifies the first argument is a normal iterator which points to the correct place. (but it might be over-testing)

155

you can enable this test if you rebase the main. also I think this one also needs to test the 2nd case

[philnik]

I think we should run the dangling tests and check their outputs. In theory we could optimize on an algorithms returning ranges::dangling. For some algorithms this would work perfectly, but for others there are side-effects where the current tests would catch the problem while this test doesn't. The nonbool and invoke changes LGTM.

[var-const]

Address feedback, rebase.

[var-const]

In D129741#3651996, @philnik wrote:

I think we should run the dangling tests and check their outputs. In theory we could optimize on an algorithms returning ranges::dangling. For some algorithms this would work perfectly, but for others there are side-effects where the current tests would catch the problem while this test doesn't. The nonbool and invoke changes LGTM.

Made this a runtime test and added a TODO to check the non-dangling iterators. I'm not removing any existing tests yet, so this patch is strictly improving coverage even without checking the results (and I won't remove existing checks without adding an equivalent check here). Quite a few existing tests either don't check for dangling at all or just check the return type.

I'm not convinced this check is worthwhile, by the way -- I can't think of a case where an algorithm would produce incorrect output in presence of dangling but work correctly otherwise. But if these checks could be made very brief, I can add them (or won't object if someone else does).

libcxx/include/__algorithm/ranges_remove_if.h

23

I simply forgot that borrowed_subrange_t isn't defined in dangling.h. Thanks for catching this!

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

53

Re. dangling_both -- I thought about it and it seemed a little overkill, but since you mentioned it, I decided to add it anyway.

[huixie90]

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

45–46 ↗

(On Diff #445376)

I still prefer

decltype(auto) result = func(R(in), std::forward<Args>(args)...);
static_assert(std::same_as<decltype(result), ExpectedT>);

or

[[maybe_unused]] std::same_as<ExpectedT> decltype(auto) result = func(R(in), std::forward<Args>(args)...);

This way the tests actually run the algorithms instead of just checking the return type.

[var-const]

Address feedback and rebase.

[var-const]

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

45–46 ↗

(On Diff #445376)

Good point, done.

[var-const]

The Windows CI failure looks like a fluke.

[ldionne]

LGTM w/ comments. I think @philnik's comments have been addressed.

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

27

I think this should be a .pass.cpp.

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

28

I think this should be a .pass.cpp.

[var-const]

Address feedback.

[var-const]

Rebase on main.

[var-const]

Rebase on main.

libcxx/include/__algorithm/ranges_for_each_n.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 _LIBCPP___ALGORITHM_RANGES_FOR_EACH_N_H
 #define _LIBCPP___ALGORITHM_RANGES_FOR_EACH_N_H
 
 #include <__algorithm/in_fun_result.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/concepts.h>
-#include <__ranges/dangling.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 

libcxx/include/__algorithm/ranges_generate_n.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
-#include <__ranges/dangling.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)

libcxx/include/__algorithm/ranges_includes.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 _LIBCPP___ALGORITHM_RANGES_INCLUDES_H
 #define _LIBCPP___ALGORITHM_RANGES_INCLUDES_H
 
 #include <__algorithm/make_projected.h>
 #include <__algorithm/includes.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
-#include <__ranges/dangling.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)

libcxx/include/__algorithm/ranges_is_heap.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 _LIBCPP___ALGORITHM_RANGES_IS_HEAP_H
 #define _LIBCPP___ALGORITHM_RANGES_IS_HEAP_H
 
 #include <__algorithm/is_heap.h>
 #include <__algorithm/make_projected.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
-#include <__ranges/dangling.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)

libcxx/include/__algorithm/ranges_remove.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 _LIBCPP___ALGORITHM_RANGES_REMOVE_H
 #define _LIBCPP___ALGORITHM_RANGES_REMOVE_H
 #include <__config>
 
 #include <__algorithm/ranges_remove_if.h>
 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/permutable.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
 #include <__ranges/subrange.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)

libcxx/include/__algorithm/ranges_remove_if.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 _LIBCPP___ALGORITHM_RANGES_REMOVE_IF_H
 #define _LIBCPP___ALGORITHM_RANGES_REMOVE_IF_H
 #include <__config>
 
 #include <__algorithm/ranges_find_if.h>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/permutable.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
 #include <__ranges/subrange.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)

libcxx/include/__algorithm/ranges_search.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 _LIBCPP___ALGORITHM_RANGES_SEARCH_H
 #define _LIBCPP___ALGORITHM_RANGES_SEARCH_H
 
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/search.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/distance.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)

libcxx/include/__algorithm/ranges_search_n.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 _LIBCPP___ALGORITHM_RANGES_SEARCH_N_H
 #define _LIBCPP___ALGORITHM_RANGES_SEARCH_N_H
 
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/search_n.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/distance.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/indirectly_comparable.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

libcxx/test/std/algorithms/ranges_robust_against_dangling.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <algorithm>
+//
+// Range algorithms should return `std::ranges::dangling` when given a dangling range.
+
+#include <algorithm>
+
+#include <array>
+#include <concepts>
+#include <iterator>
+#include <ranges>
+#include <random>
+
+#include "test_iterators.h"
+
+struct NonBorrowedRange {
+  using Iter = int*;
+  using Sent = sentinel_wrapper<Iter>;
+
+  int* data_;
+  size_t size_;
+
+  template <size_t N>
+  constexpr explicit NonBorrowedRange(std::array<int, N> arr) : NonBorrowedRange{arr.data(), arr.size()} {}
+  constexpr NonBorrowedRange(int* d, size_t s) : data_{d}, size_{s} {}
+
+  constexpr Iter begin() const { return data_; };
+  constexpr Sent end() const { return Sent{data_ + size_}; };
+};
+
+using R = NonBorrowedRange;
+
+// (dangling_in, ...)
+template <class ExpectedT = std::ranges::dangling, class Func, std::ranges::range Input, class ...Args>
+void dangling_1st(Func&& func, Input& in, Args&& ...args) {
+  using ResultT = decltype(func(R(in), std::forward<Args>(args)...));
+  static_assert(std::same_as<ResultT, ExpectedT>);
+}
+
+// (in, dangling_in, ...)
+template <class ExpectedT = std::ranges::dangling, class Func, std::ranges::range Input, class ...Args>
+void dangling_2nd(Func&& func, Input& in1, Input& in2, Args&& ...args) {
+  using ResultT = decltype(func(in1, R(in2), std::forward<Args>(args)...));
+  static_assert(std::same_as<ResultT, ExpectedT>);
+}
+
+void test_all() {
+  using std::ranges::dangling;
+
+  using std::ranges::binary_transform_result;
+  using std::ranges::copy_result;
+  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::partial_sort_copy_result;
+  //using std::ranges::partition_copy_result;
+  //using std::ranges::remove_copy_result;
+  //using std::ranges::remove_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;
+  //using std::ranges::set_symmetric_difference_result;
+  //using std::ranges::set_union_result;
+  using std::ranges::swap_ranges_result;
+  using std::ranges::unary_transform_result;
+  //using std::ranges::unique_copy_result;
+
+  auto unary_pred = [](int i) { return i > 0; };
+  auto binary_pred = [](int i, int j) { return i < j; };
+  //auto gen = [] { return 42; };
+  //std::mt19937 rand_gen;
+
+  std::array in = {1, 2, 3};
+  std::array in2 = {4, 5, 6};
+
+  auto mid = in.begin() + 1;
+
+  std::array output = {7, 8, 9};
+  auto out = output.begin();
+  //auto out2 = output.begin() + 1;
+
+  int x = 2;
+  size_t count = 1;
+
+  dangling_1st(std::ranges::find, in, x);
+  dangling_1st(std::ranges::find_if, in, unary_pred);
+  dangling_1st(std::ranges::find_if_not, in, unary_pred);
+  dangling_1st(std::ranges::find_first_of, in, in2);
+  dangling_1st(std::ranges::adjacent_find, in);
+  dangling_1st<mismatch_result<dangling, int*>>(std::ranges::mismatch, in, in2);
+  dangling_2nd<mismatch_result<int*, dangling>>(std::ranges::mismatch, in, in2);
+  //dangling_1st(std::ranges::partition_point, in, unary_pred);
+  dangling_1st(std::ranges::lower_bound, in, x);
+  dangling_1st(std::ranges::upper_bound, in, x);
+  //dangling_1st(std::ranges::equal_range, in, x);
+  dangling_1st(std::ranges::min_element, in);
+  dangling_1st(std::ranges::max_element, in);
+  dangling_1st<minmax_result<dangling>>(std::ranges::minmax_element, in);
+  dangling_1st(std::ranges::search, in, in2);
+  dangling_1st(std::ranges::search_n, in, count, x);
+  dangling_1st(std::ranges::find_end, in, in2);
+  dangling_1st(std::ranges::is_sorted_until, in);
+  //dangling_1st(std::ranges::is_heap_until, in);
+  dangling_1st<for_each_result<dangling, decltype(unary_pred)>>(std::ranges::for_each, in, unary_pred);
+  dangling_1st<copy_result<dangling, int*>>(std::ranges::copy, in, out);
+  dangling_1st<copy_backward_result<dangling, int*>>(std::ranges::copy_backward, in, out);
+  dangling_1st<copy_if_result<dangling, int*>>(std::ranges::copy_if, in, out, unary_pred);
+  dangling_1st<move_result<dangling, int*>>(std::ranges::move, in, out);
+  dangling_1st<move_backward_result<dangling, int*>>(std::ranges::move_backward, in, out);
+  dangling_1st(std::ranges::fill, in, x);
+  { // transform
+    std::array out_transform = {false, true, true};
+    dangling_1st<unary_transform_result<dangling, bool*>>(std::ranges::transform, in, out_transform.begin(), unary_pred);
+    dangling_1st<binary_transform_result<dangling, int*, bool*>>(
+        std::ranges::transform, in, in2, out_transform.begin(), binary_pred);
+    dangling_2nd<binary_transform_result<int*, dangling, bool*>>(
+        std::ranges::transform, in, in2, out_transform.begin(), binary_pred);
+  }
+  //dangling_1st(std::ranges::generate, in, gen);
+  //dangling_1st<remove_copy_result<dangling, int*>>(std::ranges::remove_copy, in, out, x);
+  //dangling_1st<remove_copy_if_result<dangling, int*>>(std::ranges::remove_copy_if, in, out, unary_pred);
+  dangling_1st(std::ranges::replace, in, x, x);
+  dangling_1st(std::ranges::replace_if, in, std::identity{}, x);
+  //dangling_1st(std::ranges::replace_copy, in, out, x, x);
+  //dangling_1st(std::ranges::replace_copy_if, in, out, x, x);
+  dangling_1st<swap_ranges_result<dangling, int*>>(std::ranges::swap_ranges, in, in2);
+  dangling_2nd<swap_ranges_result<int*, dangling>>(std::ranges::swap_ranges, in, in2);
+  dangling_1st<reverse_copy_result<dangling, int*>>(std::ranges::reverse_copy, in, out);
+  dangling_1st<rotate_copy_result<dangling, int*>>(std::ranges::rotate_copy, in, mid, out);
+  //dangling_1st<unique_copy_result<dangling, int*>>(std::ranges::unique_copy, in, out);
+  //dangling_1st<partition_copy_result<dangling, int*, int*>>std::ranges::partition_copy(in, out, out2, unary_pred);
+  //dangling_1st<partial_sort_copy_result<dangling, int*>>(std::ranges::partial_sort_copy, in, in2);
+  //dangling_2nd<partial_sort_copy_result<int*, dangling>>(std::ranges::partial_sort_copy, in, in2);
+  dangling_1st<merge_result<dangling, int*, int*>>(std::ranges::merge, in, in2, out);
+  dangling_2nd<merge_result<int*, dangling, int*>>(std::ranges::merge, in, in2, out);
+  dangling_1st<set_difference_result<dangling, int*>>(std::ranges::set_difference, in, in2, out);
+  dangling_1st<set_intersection_result<dangling, int*, int*>>(std::ranges::set_intersection, in, in2, out);
+  dangling_2nd<set_intersection_result<int*, dangling, int*>>(std::ranges::set_intersection, in, in2, out);
+  //dangling_1st<set_symmetric_difference_result<dangling, int*>>(std::ranges::set_symmetric_difference, in, in2, out);
+  //dangling_1st<set_union_result<dangling, int*, int*>>(std::ranges::set_union, in, in2, out);
+  //dangling_2nd<set_union_result<int*, dangling, int*>>(std::ranges::set_union, in, in2, out);
+  dangling_1st(std::ranges::remove, in, x);
+  dangling_1st(std::ranges::remove_if, in, unary_pred);
+  //dangling_1st(std::ranges::reverse, in);
+  //dangling_1st(std::ranges::rotate, in, mid);
+  //dangling_1st(std::ranges::shuffle, in, rand_gen);
+  //dangling_1st(std::ranges::unique, in);
+  //dangling_1st(std::ranges::partition, in, binary_pred);
+  //dangling_1st(std::ranges::stable_partition, in, binary_pred);
+  dangling_1st(std::ranges::sort, in);
+  dangling_1st(std::ranges::stable_sort, in);
+  //dangling_1st(std::ranges::partial_sort, in, mid);
+  dangling_1st(std::ranges::nth_element, in, mid);
+  //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);
+}

libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.compile.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <array>
 #include <concepts>
 #include <initializer_list>
 #include <iterator>
 #include <ranges>
 
 #include "boolean_testable.h"
 
 auto unary_pred = [](int i) { return BooleanTestable(i > 0); };
 static_assert(!std::same_as<decltype(unary_pred(1)), bool>);
 static_assert(std::convertible_to<decltype(unary_pred(1)), bool>);
 
 auto binary_pred = [](int i, int j) { return BooleanTestable(i < j); };
 static_assert(!std::same_as<decltype(binary_pred(1, 2)), bool>);
 static_assert(std::convertible_to<decltype(binary_pred(1, 2)), bool>);
 
-// There are only a few typical signatures shared by most algorithms -- this set of helpers invokes both the
-// (iterator, sentinel, ...) and the (range, ...) overloads of the given niebloid.
+// Invokes both the (iterator, sentinel, ...) and the (range, ...) overloads of the given niebloid.
 
-// (in, pred)
-template <class Func, std::ranges::range Input, class Pred>
-void in_pred(Func&& func, Input& in, Pred& pred) {
-  func(in.begin(), in.end(), pred);
-  func(in, pred);
+// (in, ...)
+template <class Func, std::ranges::range Input, class ...Args>
+void test(Func&& func, Input& in, Args&& ...args) {
+  func(in.begin(), in.end(), std::forward<Args>(args)...);
+  func(in, std::forward<Args>(args)...);
 }
 
-// (in, val, pred)
-template <class Func, std::ranges::range Input, class T, class Pred>
-void in_val_pred(Func&& func, Input& in, T& value, Pred& pred) {
-  func(in.begin(), in.end(), value, pred);
-  func(in, value, pred);
-}
-
-// (in, out, pred)
-template <class Func, std::ranges::range Input, std::weakly_incrementable Output, class Pred>
-void in_out_pred(Func&& func, Input& in, Output& out, Pred& pred) {
-  func(in.begin(), in.end(), out, pred);
-  func(in, out, pred);
-}
-
-// (in1, in2, pred)
-template <class Func, std::ranges::range Input, class Pred>
-void in2_pred(Func&& func, Input& in1, Input& in2, Pred& pred) {
-  func(in1.begin(), in1.end(), in2.begin(), in2.end(), pred);
-  func(in1, in2, pred);
-}
-
-// (in1, in2, out, pred)
-template <class Func, std::ranges::range Input, std::weakly_incrementable Output, class Pred>
-void in2_out_pred(Func&& func, Input& in1, Input& in2, Output& out, Pred& pred) {
-  func(in1.begin(), in1.end(), in2.begin(), in2.end(), out, pred);
-  func(in1, in2, out, pred);
-}
-
-// (in, mid, pred)
-template <class Func, std::ranges::range Input, class Pred>
-void in_mid_pred(Func&& func, Input& in, std::ranges::iterator_t<Input>& mid, Pred& pred) {
-  func(in.begin(), mid, in.end(), pred);
-  func(in, mid, pred);
+// (in1, in2, ...)
+template <class Func, std::ranges::range Input, class ...Args>
+void test(Func&& func, Input& in1, Input& in2, Args&& ...args) {
+  func(in1.begin(), in1.end(), in2.begin(), in2.end(), std::forward<Args>(args)...);
+  func(in1, in2, std::forward<Args>(args)...);
 }
 
 void test_all() {
   std::array in = {1, 2, 3};
   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);
-  in2_pred(std::ranges::mismatch, in, in2, binary_pred);
-  in2_pred(std::ranges::equal, in, in2, binary_pred);
-  in2_pred(std::ranges::lexicographical_compare, in, in2, binary_pred);
-  //in_pred(std::ranges::partition_point, unary_pred);
-  in_val_pred(std::ranges::lower_bound, in, x, binary_pred);
-  in_val_pred(std::ranges::upper_bound, in, x, binary_pred);
-  //in_val_pred(std::ranges::equal_range, in, x, binary_pred);
-  in_val_pred(std::ranges::binary_search, in, x, binary_pred);
+  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_if, in, unary_pred);
+  test(std::ranges::find_if_not, in, unary_pred);
+  test(std::ranges::find_first_of, in, in2, binary_pred);
+  test(std::ranges::adjacent_find, in, binary_pred);
+  test(std::ranges::mismatch, in, in2, binary_pred);
+  test(std::ranges::equal, in, in2, binary_pred);
+  test(std::ranges::lexicographical_compare, in, in2, binary_pred);
+  //test(std::ranges::partition_point, unary_pred);
+  test(std::ranges::lower_bound, in, x, binary_pred);
+  test(std::ranges::upper_bound, in, x, binary_pred);
+  //test(std::ranges::equal_range, in, x, binary_pred);
+  test(std::ranges::binary_search, in, x, binary_pred);
 
   // min
   std::ranges::min(1, 2, binary_pred);
   std::ranges::min(std::initializer_list<int>{1, 2}, binary_pred);
   std::ranges::min(in, binary_pred);
   // max
   std::ranges::max(1, 2, binary_pred);
   std::ranges::max(std::initializer_list<int>{1, 2}, binary_pred);
   std::ranges::max(in, binary_pred);
   // minmax
   std::ranges::minmax(1, 2, binary_pred);
   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);
-  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);
+  test(std::ranges::min_element, in, binary_pred);
+  test(std::ranges::max_element, in, binary_pred);
+  test(std::ranges::minmax_element, in, binary_pred);
+  test(std::ranges::count_if, in, unary_pred);
+  test(std::ranges::search, in, in2, binary_pred);
+  test(std::ranges::search_n, in, count, x, binary_pred);
+  test(std::ranges::find_end, in, in2, binary_pred);
+  test(std::ranges::is_partitioned, in, unary_pred);
+  test(std::ranges::is_sorted, in, binary_pred);
+  test(std::ranges::is_sorted_until, in, binary_pred);
+  //test(std::ranges::includes, in, in2, binary_pred);
+  //test(std::ranges::is_heap, in, binary_pred);
+  //test(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);
-  in_out_pred(std::ranges::copy_if, in, out, unary_pred);
-  //in_out_pred(std::ranges::remove_copy_if, in, out, unary_pred);
-
-  // replace_if
-  //std::ranges::replace_if(in.begin(), in.end(), unary_pred, x);
-  //std::ranges::replace_if(in, unary_pred, x);
-  // replace_copy_if
-  //std::ranges::replace_copy_if(in.begin(), in.end(), out, unary_pred, x);
-  //std::ranges::replace_copy_if(in, out, unary_pred, x);
-
-  //in_out_pred(std::ranges::unique_copy, in, out, binary_pred);
-  // partition_copy
-  //std::ranges::partition_copy(in.begin(), in.end(), out, out2, unary_pred);
-  //std::ranges::partition_copy(in, out, out2, unary_pred);
-  //in2_pred(std::ranges::partial_sort_copy, in, in2, binary_pred);
-  in2_out_pred(std::ranges::merge, in, in2, out, binary_pred);
-  in2_out_pred(std::ranges::set_difference, in, in2, out, binary_pred);
-  //in2_out_pred(std::ranges::set_intersection, in, in2, out, binary_pred);
-  //in2_out_pred(std::ranges::set_symmetric_difference, in, in2, out, binary_pred);
-  //in2_out_pred(std::ranges::set_union, in, in2, out, binary_pred);
-  in_pred(std::ranges::remove_if, in, unary_pred);
-  //in_pred(std::ranges::unique, in, binary_pred);
-  //in_pred(std::ranges::partition, in, binary_pred);
-  //in_pred(std::ranges::stable_partition, in, binary_pred);
-  in_pred(std::ranges::sort, in, binary_pred);
-  in_pred(std::ranges::stable_sort, in, binary_pred);
-  //in_mid_pred(std::ranges::partial_sort, in, mid, binary_pred);
-  in_mid_pred(std::ranges::nth_element, in, mid, binary_pred);
-  //in_mid_pred(std::ranges::inplace_merge, in, mid, binary_pred);
-  in_pred(std::ranges::make_heap, in, binary_pred);
-  in_pred(std::ranges::push_heap, in, binary_pred);
-  in_pred(std::ranges::pop_heap, in, binary_pred);
-  in_pred(std::ranges::sort_heap, in, binary_pred);
-  //in_pred(std::ranges::prev_permutation, in, binary_pred);
-  //in_pred(std::ranges::next_permutation, in, binary_pred);
+  //test(std::ranges::is_permutation, in, in2, binary_pred);
+  test(std::ranges::copy_if, in, out, unary_pred);
+  //test(std::ranges::remove_copy_if, in, out, unary_pred);
+
+  //test(std::ranges::replace_if, in, unary_pred, x);
+  //test(std::ranges::replace_copy_if, in, out, unary_pred, x);
+
+  //test(std::ranges::unique_copy, in, out, binary_pred);
+  //test(std::ranges::partition_copy, in, out, out2, unary_pred);
+  //test(std::ranges::partial_sort_copy, in, in2, binary_pred);
+  test(std::ranges::merge, in, in2, out, binary_pred);
+  test(std::ranges::set_difference, in, in2, out, binary_pred);
+  //test(std::ranges::set_intersection, in, in2, out, binary_pred);
+  //test(std::ranges::set_symmetric_difference, in, in2, out, binary_pred);
+  //test(std::ranges::set_union, in, in2, out, binary_pred);
+  test(std::ranges::remove_if, in, unary_pred);
+  //test(std::ranges::unique, in, binary_pred);
+  //test(std::ranges::partition, in, binary_pred);
+  //test(std::ranges::stable_partition, in, binary_pred);
+  test(std::ranges::sort, in, binary_pred);
+  test(std::ranges::stable_sort, in, binary_pred);
+  //test(std::ranges::partial_sort, in, mid, binary_pred);
+  test(std::ranges::nth_element, in, mid, binary_pred);
+  //test(std::ranges::inplace_merge, in, mid, binary_pred);
+  test(std::ranges::make_heap, in, binary_pred);
+  test(std::ranges::push_heap, in, binary_pred);
+  test(std::ranges::pop_heap, in, binary_pred);
+  test(std::ranges::sort_heap, in, binary_pred);
+  //test(std::ranges::prev_permutation, in, binary_pred);
+  //test(std::ranges::next_permutation, in, binary_pred);
 }

libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.compile.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <initializer_list>
 #include <iterator>
 #include <ranges>
 
 struct Foo {
   int val;
   constexpr bool unary_pred() const { return val > 0; }
   constexpr bool binary_pred(const Foo& rhs) const { return val < rhs.val; }
   constexpr auto operator<=>(const Foo&) const = default;
 };
 
 struct Bar {
   Foo val;
   Bar create() const { return Bar(); }
 };
 
-// There are only a few typical signatures shared by most algorithms -- this set of helpers invokes both the
-// (iterator, sentinel, ...) and the (range, ...) overloads of the given niebloid.
+// Invokes both the (iterator, sentinel, ...) and the (range, ...) overloads of the given niebloid.
 
-// (in, val)
-template <class Func, std::ranges::range Input, class T, class Proj>
-void in_val(Func&& func, Input& in, const T& val, Proj&& proj) {
-  func(in.begin(), in.end(), val, proj);
-  func(in, val, proj);
+// (in, ...)
+template <class Func, std::ranges::range Input, class ...Args>
+void test(Func&& func, Input& in, Args&& ...args) {
+  func(in.begin(), in.end(), std::forward<Args>(args)...);
+  func(in, std::forward<Args>(args)...);
 }
 
-// (in, pred)
-template <class Func, std::ranges::range Input, class Pred, class Proj>
-void in_pred(Func&& func, Input& in, Pred&& pred, Proj&& proj) {
-  func(in.begin(), in.end(), pred, proj);
-  func(in, pred, proj);
-}
-
-// (in, val, pred)
-template <class Func, std::ranges::range Input, class T, class Pred, class Proj>
-void in_val_pred(Func&& func, Input& in, const T& val, Pred&& pred, Proj&& proj) {
-  func(in.begin(), in.end(), val, pred, proj);
-  func(in, val, pred, proj);
-}
-
-// (in1, in2, pred) -- two projections.
-template <class Func, std::ranges::range Input, class Pred, class Proj1, class Proj2>
-void in2_pred(Func&& func, Input& in1, Input& in2, Pred&& pred, Proj1&& proj1, Proj2&& proj2) {
-  func(in1.begin(), in1.end(), in2.begin(), in2.end(), pred, proj1, proj2);
-  func(in1, in2, pred, proj1, proj2);
-}
-
-// (in, out, pred)
-template <class Func, std::ranges::range Input, std::weakly_incrementable Output, class Pred, class Proj>
-void in_out_pred(Func&& func, Input& in, Output out, Pred&& pred, Proj&& proj) {
-  func(in.begin(), in.end(), out, pred, proj);
-  func(in, out, pred, proj);
-}
-
-// (in, mid, pred)
-template <class Func, std::ranges::range Input, std::input_iterator Iter, class Pred, class Proj>
-void in_mid_pred(Func&& func, Input& in, Iter mid, Pred&& pred, Proj&& proj) {
-  func(in.begin(), mid, in.end(), pred, proj);
-  func(in, mid, pred, proj);
-}
-
-// (in1, in2, out, pred) -- two projections.
-template <class Func, std::ranges::range Input, std::weakly_incrementable Output, class Pred, class Proj1, class Proj2>
-void in2_out_pred(Func&& func, Input& in1, Input& in2, Output out, Pred&& pred, Proj1&& proj1, Proj2&& proj2) {
-  func(in1.begin(), in1.end(), in2.begin(), in2.end(), out, pred, proj1, proj2);
-  func(in1, in2, out, pred, proj1, proj2);
+// (in1, in2, ...)
+template <class Func, std::ranges::range Input, class ...Args>
+void test(Func&& func, Input& in1, Input& in2, Args&& ...args) {
+  func(in1.begin(), in1.end(), in2.begin(), in2.end(), std::forward<Args>(args)...);
+  func(in1, in2, std::forward<Args>(args)...);
 }
 
 void test_all() {
   std::array in = {Bar{Foo{1}}, Bar{Foo{2}}, Bar{Foo{3}}};
   std::array in2 = {Bar{Foo{4}}, Bar{Foo{5}}, Bar{Foo{6}}};
   auto mid = in.begin() + 1;
 
   std::array output = {Bar{Foo{4}}, Bar{Foo{5}}, Bar{Foo{6}}};
   auto out = output.begin();
   //auto out2 = output.begin() + 1;
 
   Bar a{Foo{1}};
   Bar b{Foo{2}};
   //Bar c{Foo{3}};
 
   Foo x{2};
   size_t count = 1;
 
-  in_pred(std::ranges::any_of, in, &Foo::unary_pred, &Bar::val);
-  in_pred(std::ranges::all_of, in, &Foo::unary_pred, &Bar::val);
-  in_pred(std::ranges::none_of, in, &Foo::unary_pred, &Bar::val);
-  in_val(std::ranges::find, in, x, &Bar::val);
-  in_pred(std::ranges::find_if, in, &Foo::unary_pred, &Bar::val);
-  in_pred(std::ranges::find_if_not, in, &Foo::unary_pred, &Bar::val);
-  in2_pred(std::ranges::find_first_of, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
-  in_pred(std::ranges::adjacent_find, in, &Foo::binary_pred, &Bar::val);
-  in2_pred(std::ranges::mismatch, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
-  in2_pred(std::ranges::equal, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
-  in2_pred(std::ranges::lexicographical_compare, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
-  //in_pred(std::ranges::partition_point, in, &Foo::unary_pred, &Bar::val);
-  in_val_pred(std::ranges::lower_bound, in, x, &Foo::binary_pred, &Bar::val);
-  in_val_pred(std::ranges::upper_bound, in, x, &Foo::binary_pred, &Bar::val);
-  //in_val_pred(std::ranges::equal_range, in, x, &Foo::binary_pred, &Bar::val);
-  in_val_pred(std::ranges::binary_search, in, x, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::any_of, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::all_of, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::none_of, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::find, in, x, &Bar::val);
+  test(std::ranges::find_if, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::find_if_not, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::find_first_of, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::adjacent_find, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::mismatch, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::equal, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::lexicographical_compare, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  //test(std::ranges::partition_point, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::lower_bound, in, x, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::upper_bound, in, x, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::equal_range, in, x, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::binary_search, in, x, &Foo::binary_pred, &Bar::val);
 
   // min
   std::ranges::min(a, b, &Foo::binary_pred, &Bar::val);
   std::ranges::min(std::initializer_list<Bar>{a, b}, &Foo::binary_pred, &Bar::val);
   std::ranges::min(in, &Foo::binary_pred, &Bar::val);
   // max
   std::ranges::max(a, b, &Foo::binary_pred, &Bar::val);
   std::ranges::max(std::initializer_list<Bar>{a, b}, &Foo::binary_pred, &Bar::val);
   std::ranges::max(in, &Foo::binary_pred, &Bar::val);
   // minmax
   std::ranges::minmax(a, b, &Foo::binary_pred, &Bar::val);
   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);
-  // 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);
-  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);
+  test(std::ranges::min_element, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::max_element, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::minmax_element, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::count, in, x, &Bar::val);
+  test(std::ranges::count_if, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::search, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::search_n, in, count, x, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::find_end, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::is_partitioned, in, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::is_sorted, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::is_sorted_until, in, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::includes, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  //test(std::ranges::is_heap, in, &Foo::binary_pred, &Bar::val);
+  //test(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);
-  in_pred(std::ranges::for_each, in, &Foo::unary_pred, &Bar::val);
+  //test(std::ranges::is_permutation, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::for_each, in, &Foo::unary_pred, &Bar::val);
   std::ranges::for_each_n(in.begin(), count, &Foo::unary_pred, &Bar::val);
   // `copy`, `copy_n` and `copy_backward` have neither a projection nor a predicate.
-  in_out_pred(std::ranges::copy_if, in, out, &Foo::unary_pred, &Bar::val);
+  test(std::ranges::copy_if, in, out, &Foo::unary_pred, &Bar::val);
   // `move` and `move_backward` have neither a projection nor a predicate.
   // `fill` and `fill_n` have neither a projection nor a predicate.
   {
     std::array out_transform = {false, true, true};
-    in_out_pred(std::ranges::transform, in, out_transform.begin(), &Foo::unary_pred, &Bar::val);
+    test(std::ranges::transform, in, out_transform.begin(), &Foo::unary_pred, &Bar::val);
   }
-  // generate
-  //std::ranges::generate(in.begin(), in.end(), &Bar::create);
-  //std::ranges::generate(in, &Bar::create);
-  // generate_n
-  //std::ranges::generate(in.begin(), count, &Bar::create);
-  // remove_copy
-  //std::ranges::remove_copy(in.begin(), in.end(), out, x, &Bar::val);
-  //std::ranges::remove_copy(in, out, x, &Bar::val);
-  //in_out_pred(std::ranges::remove_copy_if, in, out, &Foo::unary_pred, &Bar::val);
+  //test(std::ranges::generate, in, &Bar::create);
+  //std::ranges::generate_n(in.begin(), count, &Bar::create);
+  //test(std::ranges::remove_copy, in, out, x, &Bar::val);
+  //test(std::ranges::remove_copy_if, in, out, &Foo::unary_pred, &Bar::val);
   // `replace*` algorithms only use the projection to compare the elements, not to write them.
-  // replace
-  std::ranges::replace(in.begin(), in.end(), x, a, &Bar::val);
-  std::ranges::replace(in, x, a, &Bar::val);
-  // replace_if
-  std::ranges::replace_if(in.begin(), in.end(), &Foo::unary_pred, a, &Bar::val);
-  std::ranges::replace_if(in, &Foo::unary_pred, a, &Bar::val);
-  // replace_copy
-  //std::ranges::replace_copy(in.begin(), in.end(), out, x, a, &Bar::val);
-  //std::ranges::replace_copy(in, out, x, a, &Bar::val);
-  // replace_copy_if
-  //std::ranges::replace_copy_if(in.begin(), in.end(), out, pred, a, &Bar::val);
-  //std::ranges::replace_copy_if(in, out, pred, a, &Bar::val);
+  test(std::ranges::replace, in, x, a, &Bar::val);
+  test(std::ranges::replace_if, in, &Foo::unary_pred, a, &Bar::val);
+  //test(std::ranges::replace_copy, in, out, x, a, &Bar::val);
+  //test(std::ranges::replace_copy_if, in, out, pred, a, &Bar::val);
   // `swap_ranges` has neither a projection nor a predicate.
   // `reverse_copy` has neither a projection nor a predicate.
   // `rotate_copy` has neither a projection nor a predicate.
   // `sample` has no requirement that the given generator be invoked via `std::invoke`.
-  //in_out_pred(std::ranges::unique_copy, in, out, &Foo::binary_pred, &Bar::val);
-  // partition_copy
-  //std::ranges::partition_copy(in.begin(), in.end(), out, out2, &Foo::unary_pred, &Bar::val);
-  //std::ranges::partition_copy(in, out, out2, &Foo::unary_pred, &Bar::val);
-  //in2_pred(std::ranges::partial_sort_copy, in, in2, &Foo::binary_pred, &Bar::val);
-  in2_out_pred(std::ranges::merge, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
-  in2_out_pred(std::ranges::set_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
-  //in2_out_pred(std::ranges::set_intersection, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
-  //in2_out_pred(std::ranges::set_symmetric_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
-  //in2_out_pred(std::ranges::set_union, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
-  in_val(std::ranges::remove, in, x, &Bar::val);
-  in_pred(std::ranges::remove_if, in, &Foo::unary_pred, &Bar::val);
+  //test(std::ranges::unique_copy, in, out, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::partition_copy, in, out, out2, &Foo::unary_pred, &Bar::val);
+  //test(std::ranges::partial_sort_copy, in, in2, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::merge, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::set_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+  //test(std::ranges::set_intersection, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+  //test(std::ranges::set_symmetric_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+  //test(std::ranges::set_union, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+  test(std::ranges::remove, in, x, &Bar::val);
+  test(std::ranges::remove_if, in, &Foo::unary_pred, &Bar::val);
   // `reverse` has neither a projection nor a predicate.
   // `rotate` has neither a projection nor a predicate.
   // `shuffle` has neither a projection nor a predicate.
-  //in_pred(std::ranges::unique, in, &Foo::binary_pred, &Bar::val);
-  //in_pred(std::ranges::partition, in, &Foo::binary_pred, &Bar::val);
-  //in_pred(std::ranges::stable_partition, in, &Foo::binary_pred, &Bar::val);
-  in_pred(std::ranges::sort, in, &Foo::binary_pred, &Bar::val);
-  in_pred(std::ranges::stable_sort, in, &Foo::binary_pred, &Bar::val);
-  //in_mid_pred(std::ranges::partial_sort, in, mid, binary_pred);
-  in_mid_pred(std::ranges::nth_element, in, mid, &Foo::binary_pred, &Bar::val);
-  //in_mid_pred(std::ranges::inplace_merge, in, mid, binary_pred);
-  in_pred(std::ranges::make_heap, in, &Foo::binary_pred, &Bar::val);
-  in_pred(std::ranges::push_heap, in, &Foo::binary_pred, &Bar::val);
-  in_pred(std::ranges::pop_heap, in, &Foo::binary_pred, &Bar::val);
-  in_pred(std::ranges::sort_heap, in, &Foo::binary_pred, &Bar::val);
-  //in_pred(std::ranges::prev_permutation, in, &Foo::binary_pred, &Bar::val);
-  //in_pred(std::ranges::next_permutation, in, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::unique, in, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::partition, in, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::stable_partition, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::sort, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::stable_sort, in, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::partial_sort, in, mid, binary_pred);
+  test(std::ranges::nth_element, in, mid, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::inplace_merge, in, mid, binary_pred);
+  test(std::ranges::make_heap, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::push_heap, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::pop_heap, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::sort_heap, in, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::prev_permutation, in, &Foo::binary_pred, &Bar::val);
+  //test(std::ranges::next_permutation, in, &Foo::binary_pred, &Bar::val);
 }