1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14, c++17
10// REQUIRES: stdlib=libc++
11
12// [alg.func.obj]
13// [algorithms.requirements]/2
14// [range.iter.ops.general]/2
15
16#include <algorithm>
17#include <concepts>
18#include <functional>
19#include <iterator>
20#include <memory>
21#include <random>
22#include <ranges>
23#include <type_traits>
24#include <utility>
25
26#include "test_macros.h"
27
28// Before P3136R1, niebloids were pedantically not CPOs, and they were *not* required to be semiregular or
29// even to have a declared type at all; they were specified as "magic" overload sets
30// whose names are not found by argument-dependent lookup and
31// which inhibit argument-dependent lookup if they are found via a `using`-declaration.
32//
33// As of P3136R1, niebloids (formally known as algorithm function objects) are required to be CPOs.
34//
35// libc++ implements niebloids in the same way as CPOs since LLVM 14;
36// therefore this file should stay in sync with ./cpo.compile.pass.cpp.
37
38template <class CPO, class... Args>
39constexpr bool test(CPO& o, Args&&...) {
40 static_assert(std::is_const_v<CPO>);
41 static_assert(std::is_class_v<CPO>);
42 static_assert(std::is_trivially_copyable_v<CPO>);
43 static_assert(std::is_trivially_default_constructible_v<CPO>);
44
45 auto p = o;
46 using T = decltype(p);
47
48 // The type of a customization point object, ignoring cv-qualifiers, shall model semiregular.
49 static_assert(std::semiregular<T>);
50
51 // The type T of a customization point object, ignoring cv-qualifiers, shall model...
52 static_assert(std::invocable<T&, Args...>);
53 static_assert(std::invocable<const T&, Args...>);
54 static_assert(std::invocable<T, Args...>);
55 static_assert(std::invocable<const T, Args...>);
56
57 return true;
58}
59
60int *p;
61int a[10];
62auto odd = [](int x) { return x % 2 != 0; };
63auto triple = [](int x) { return 3*x; };
64auto gen = [] { return 42; };
65std::mt19937 g;
66
67// [algorithm.syn]
68
69static_assert(test(std::ranges::adjacent_find, a));
70static_assert(test(std::ranges::all_of, a, odd));
71static_assert(test(std::ranges::any_of, a, odd));
72static_assert(test(std::ranges::binary_search, a, 42));
73static_assert(test(std::ranges::clamp, 42, 42, 42));
74#if TEST_STD_VER >= 23
75static_assert(test(std::ranges::contains, a, 42));
76static_assert(test(std::ranges::contains_subrange, a, a));
77#endif
78static_assert(test(std::ranges::copy, a, a));
79static_assert(test(std::ranges::copy_backward, a, a));
80static_assert(test(std::ranges::copy_if, a, a, odd));
81static_assert(test(std::ranges::copy_n, a, 10, a));
82static_assert(test(std::ranges::count, a, 42));
83static_assert(test(std::ranges::count_if, a, odd));
84#if TEST_STD_VER >= 23
85static_assert(test(std::ranges::ends_with, a, a));
86#endif
87static_assert(test(std::ranges::equal, a, a));
88static_assert(test(std::ranges::equal_range, a, 42));
89static_assert(test(std::ranges::fill, a, 42));
90static_assert(test(std::ranges::fill_n, a, 10, 42));
91static_assert(test(std::ranges::find, a, 42));
92static_assert(test(std::ranges::find_end, a, a));
93static_assert(test(std::ranges::find_first_of, a, a));
94static_assert(test(std::ranges::find_if, a, odd));
95static_assert(test(std::ranges::find_if_not, a, odd));
96#if TEST_STD_VER >= 23
97static_assert(test(std::ranges::find_last, a, 42));
98static_assert(test(std::ranges::find_last_if, a, odd));
99static_assert(test(std::ranges::find_last_if_not, a, odd));
100static_assert(test(std::ranges::fold_left, a, 0, std::plus()));
101static_assert(test(std::ranges::fold_left_with_iter, a, 0, std::plus()));
102#endif
103static_assert(test(std::ranges::for_each, a, odd));
104static_assert(test(std::ranges::for_each_n, a, 10, odd));
105static_assert(test(std::ranges::generate, a, gen));
106static_assert(test(std::ranges::generate_n, a, 10, gen));
107static_assert(test(std::ranges::includes, a, a));
108static_assert(test(std::ranges::inplace_merge, a, a+5));
109static_assert(test(std::ranges::is_heap, a));
110static_assert(test(std::ranges::is_heap_until, a));
111static_assert(test(std::ranges::is_partitioned, a, odd));
112static_assert(test(std::ranges::is_permutation, a, a));
113static_assert(test(std::ranges::is_sorted, a));
114static_assert(test(std::ranges::is_sorted_until, a));
115static_assert(test(std::ranges::lexicographical_compare, a, a));
116static_assert(test(std::ranges::lower_bound, a, 42));
117static_assert(test(std::ranges::make_heap, a));
118static_assert(test(std::ranges::max, a));
119static_assert(test(std::ranges::max_element, a));
120static_assert(test(std::ranges::merge, a, a, a));
121static_assert(test(std::ranges::min, a));
122static_assert(test(std::ranges::min_element, a));
123static_assert(test(std::ranges::minmax, a));
124static_assert(test(std::ranges::minmax_element, a));
125static_assert(test(std::ranges::mismatch, a, a));
126static_assert(test(std::ranges::move, a, a));
127static_assert(test(std::ranges::move_backward, a, a));
128static_assert(test(std::ranges::next_permutation, a));
129static_assert(test(std::ranges::none_of, a, odd));
130static_assert(test(std::ranges::nth_element, a, a+5));
131static_assert(test(std::ranges::partial_sort, a, a+5));
132static_assert(test(std::ranges::partial_sort_copy, a, a));
133static_assert(test(std::ranges::partition, a, odd));
134static_assert(test(std::ranges::partition_copy, a, a, a, odd));
135static_assert(test(std::ranges::partition_point, a, odd));
136static_assert(test(std::ranges::pop_heap, a));
137static_assert(test(std::ranges::prev_permutation, a));
138static_assert(test(std::ranges::push_heap, a));
139static_assert(test(std::ranges::remove, a, 42));
140static_assert(test(std::ranges::remove_copy, a, a, 42));
141static_assert(test(std::ranges::remove_copy_if, a, a, odd));
142static_assert(test(std::ranges::remove_if, a, odd));
143static_assert(test(std::ranges::replace, a, 42, 43));
144static_assert(test(std::ranges::replace_copy, a, a, 42, 43));
145static_assert(test(std::ranges::replace_copy_if, a, a, odd, 43));
146static_assert(test(std::ranges::replace_if, a, odd, 43));
147static_assert(test(std::ranges::reverse, a));
148static_assert(test(std::ranges::reverse_copy, a, a));
149static_assert(test(std::ranges::rotate, a, a+5));
150static_assert(test(std::ranges::rotate_copy, a, a+5, a));
151static_assert(test(std::ranges::sample, a, a, 5, g));
152static_assert(test(std::ranges::search, a, a));
153static_assert(test(std::ranges::search_n, a, 10, 42));
154static_assert(test(std::ranges::set_difference, a, a, a));
155static_assert(test(std::ranges::set_intersection, a, a, a));
156static_assert(test(std::ranges::set_symmetric_difference, a, a, a));
157static_assert(test(std::ranges::set_union, a, a, a));
158static_assert(test(std::ranges::shuffle, a, g));
159static_assert(test(std::ranges::sort, a));
160static_assert(test(std::ranges::sort_heap, a));
161static_assert(test(std::ranges::stable_partition, a, odd));
162static_assert(test(std::ranges::stable_sort, a));
163#if TEST_STD_VER > 20
164static_assert(test(std::ranges::starts_with, a, a));
165#endif
166static_assert(test(std::ranges::swap_ranges, a, a));
167static_assert(test(std::ranges::transform, a, a, triple));
168static_assert(test(std::ranges::unique, a));
169static_assert(test(std::ranges::unique_copy, a, a));
170static_assert(test(std::ranges::upper_bound, a, 42));
171
172// [memory.syn]
173
174static_assert(test(std::ranges::construct_at, a, 42));
175static_assert(test(std::ranges::destroy, a));
176static_assert(test(std::ranges::destroy, a, a+10));
177static_assert(test(std::ranges::destroy_at, a));
178static_assert(test(std::ranges::destroy_n, a, 10));
179static_assert(test(std::ranges::uninitialized_copy, a, a));
180static_assert(test(std::ranges::uninitialized_copy, a, a+10, a, a+10));
181static_assert(test(std::ranges::uninitialized_copy_n, a, 10, a, a+10));
182static_assert(test(std::ranges::uninitialized_default_construct, a));
183static_assert(test(std::ranges::uninitialized_default_construct, a, a+10));
184static_assert(test(std::ranges::uninitialized_default_construct_n, a, 10));
185static_assert(test(std::ranges::uninitialized_fill, a, 42));
186static_assert(test(std::ranges::uninitialized_fill, a, a+10, 42));
187static_assert(test(std::ranges::uninitialized_fill_n, a, 10, 42));
188static_assert(test(std::ranges::uninitialized_move, a, a));
189static_assert(test(std::ranges::uninitialized_move, a, a+10, a, a+10));
190static_assert(test(std::ranges::uninitialized_move_n, a, 10, a, a+10));
191static_assert(test(std::ranges::uninitialized_value_construct, a));
192static_assert(test(std::ranges::uninitialized_value_construct, a, a+10));
193static_assert(test(std::ranges::uninitialized_value_construct_n, a, 10));
194
195// [numeric.ops.overview] currently has no ranges algorithms. See P1813, P2214
196
197// [range.iter.ops]
198
199static_assert(test(std::ranges::advance, p, 5));
200static_assert(test(std::ranges::advance, p, 5, a+10));
201static_assert(test(std::ranges::advance, p, a+10));
202static_assert(test(std::ranges::distance, a));
203static_assert(test(std::ranges::distance, a, a+10));
204static_assert(test(std::ranges::next, a));
205static_assert(test(std::ranges::next, a, 5));
206static_assert(test(std::ranges::next, a, 5, a+10));
207static_assert(test(std::ranges::next, a, a+10));
208static_assert(test(std::ranges::prev, a+10));
209static_assert(test(std::ranges::prev, a+10, 5));
210static_assert(test(std::ranges::prev, a+10, 5, a));
211

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