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