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// <algorithm>
10
11#include <algorithm>
12#include <cstddef>
13#include <functional>
14#include <iterator>
15
16#include "test_macros.h"
17
18struct Incomplete;
19template<class T> struct Holder { T t; };
20
21template<class>
22struct ConvertibleToIntegral {
23 TEST_CONSTEXPR operator int() const { return 1; }
24};
25
26struct Tester {
27 using Element = Holder<Incomplete>*;
28 Element data[10] = {};
29};
30
31struct UnaryVoid { TEST_CONSTEXPR_CXX14 void operator()(void*) const {} };
32struct UnaryTrue { TEST_CONSTEXPR bool operator()(void*) const { return true; } };
33struct NullaryValue { TEST_CONSTEXPR std::nullptr_t operator()() const { return nullptr; } };
34struct UnaryTransform { TEST_CONSTEXPR std::nullptr_t operator()(void*) const { return nullptr; } };
35struct BinaryTransform { TEST_CONSTEXPR std::nullptr_t operator()(void*, void*) const { return nullptr; } };
36
37TEST_CONSTEXPR_CXX20 bool all_the_algorithms()
38{
39 Tester t;
40 Tester u;
41 Holder<Incomplete> **first = t.data;
42 Holder<Incomplete> **mid = t.data+5;
43 Holder<Incomplete> **last = t.data+10;
44 Holder<Incomplete> **first2 = u.data;
45 Holder<Incomplete> **mid2 = u.data+5;
46 Holder<Incomplete> **last2 = u.data+10;
47 Tester::Element value = nullptr;
48 ConvertibleToIntegral<Tester::Element> count;
49
50 (void)std::adjacent_find(first: first, last: last);
51 (void)std::adjacent_find(first: first, last: last, binary_pred: std::equal_to<void*>());
52#if TEST_STD_VER >= 11
53 (void)std::all_of(first, last, UnaryTrue());
54 (void)std::any_of(first, last, UnaryTrue());
55#endif
56 (void)std::binary_search(first: first, last: last, val: value);
57 (void)std::binary_search(first: first, last: last, val: value, comp: std::less<void*>());
58#if TEST_STD_VER > 17
59 (void)std::clamp(value, value, value);
60 (void)std::clamp(value, value, value, std::less<void*>());
61#endif
62 (void)std::copy(first: first, last: last, result: first2);
63 (void)std::copy_backward(first: first, last: last, result: last2);
64 (void)std::copy_n(first: first, n: count, result: first2);
65 (void)std::count(first: first, last: last, value: value);
66 (void)std::count_if(first: first, last: last, pred: UnaryTrue());
67 (void)std::distance(first: first, last: last);
68 (void)std::equal(first1: first, last1: last, first2: first2);
69 (void)std::equal(first1: first, last1: last, first2: first2, binary_pred: std::equal_to<void*>());
70#if TEST_STD_VER > 11
71 (void)std::equal(first, last, first2, last2);
72 (void)std::equal(first, last, first2, last2, std::equal_to<void*>());
73#endif
74 (void)std::equal_range(first: first, last: last, val: value);
75 (void)std::equal_range(first: first, last: last, val: value, comp: std::less<void*>());
76 (void)std::fill(first: first, last: last, value: value);
77 (void)std::fill_n(first: first, n: count, value: value);
78 (void)std::find(first: first, last: last, val: value);
79 (void)std::find_end(first1: first, last1: last, first2: first2, last2: mid2);
80 (void)std::find_end(first1: first, last1: last, first2: first2, last2: mid2, comp: std::equal_to<void*>());
81 (void)std::find_if(first: first, last: last, pred: UnaryTrue());
82 (void)std::find_if_not(first: first, last: last, pred: UnaryTrue());
83 (void)std::for_each(first: first, last: last, f: UnaryVoid());
84#if TEST_STD_VER > 14
85 (void)std::for_each_n(first, count, UnaryVoid());
86#endif
87 (void)std::generate(first: first, last: last, gen: NullaryValue());
88 (void)std::generate_n(first: first, n: count, gen: NullaryValue());
89 (void)std::includes(first1: first, last1: last, first2: first2, last2: last2);
90 (void)std::includes(first1: first, last1: last, first2: first2, last2: last2, comp: std::less<void*>());
91 (void)std::is_heap(first: first, last: last);
92 (void)std::is_heap(first: first, last: last, comp: std::less<void*>());
93 (void)std::is_heap_until(first: first, last: last);
94 (void)std::is_heap_until(first: first, last: last, comp: std::less<void*>());
95 (void)std::is_partitioned(first: first, last: last, pred: UnaryTrue());
96 (void)std::is_permutation(first1: first, last1: last, first2: first2);
97 (void)std::is_permutation(first1: first, last1: last, first2: first2, pred: std::equal_to<void*>());
98#if TEST_STD_VER > 11
99 (void)std::is_permutation(first, last, first2, last2);
100 (void)std::is_permutation(first, last, first2, last2, std::equal_to<void*>());
101#endif
102 (void)std::is_sorted(first: first, last: last);
103 (void)std::is_sorted(first: first, last: last, comp: std::less<void*>());
104 (void)std::is_sorted_until(first: first, last: last);
105 (void)std::is_sorted_until(first: first, last: last, comp: std::less<void*>());
106 // RELIES ON ADL SWAP (void)std::inplace_merge(first, mid, last);
107 // RELIES ON ADL SWAP (void)std::inplace_merge(first, mid, last, std::less<void*>());
108 // RELIES ON ADL SWAP (void)std::iter_swap(first, mid);
109 (void)std::lexicographical_compare(first1: first, last1: last, first2: first2, last2: last2);
110 (void)std::lexicographical_compare(first1: first, last1: last, first2: first2, last2: last2, comp: std::less<void*>());
111#if TEST_STD_VER > 17
112 (void)std::lexicographical_compare_three_way(first, last, first2, last2);
113 (void)std::lexicographical_compare_three_way(first, last, first2, last2, std::compare_three_way());
114#endif
115 (void)std::lower_bound(first: first, last: last, val: value);
116 (void)std::lower_bound(first: first, last: last, val: value, comp: std::less<void*>());
117 (void)std::make_heap(first: first, last: last);
118 (void)std::make_heap(first: first, last: last, comp: std::less<void*>());
119 (void)std::max(a: value, b: value);
120 (void)std::max(a: value, b: value, comp: std::less<void*>());
121#if TEST_STD_VER >= 11
122 (void)std::max({ value, value });
123 (void)std::max({ value, value }, std::less<void*>());
124#endif
125 (void)std::max_element(first: first, last: last);
126 (void)std::max_element(first: first, last: last, comp: std::less<void*>());
127 (void)std::merge(first1: first, last1: mid, first2: mid, last2: last, result: first2);
128 (void)std::merge(first1: first, last1: mid, first2: mid, last2: last, result: first2, comp: std::less<void*>());
129 (void)std::min(a: value, b: value);
130 (void)std::min(a: value, b: value, comp: std::less<void*>());
131#if TEST_STD_VER >= 11
132 (void)std::min({ value, value });
133 (void)std::min({ value, value }, std::less<void*>());
134#endif
135 (void)std::min_element(first: first, last: last);
136 (void)std::min_element(first: first, last: last, comp: std::less<void*>());
137 (void)std::minmax(a: value, b: value);
138 (void)std::minmax(a: value, b: value, comp: std::less<void*>());
139#if TEST_STD_VER >= 11
140 (void)std::minmax({ value, value });
141 (void)std::minmax({ value, value }, std::less<void*>());
142#endif
143 (void)std::minmax_element(first: first, last: last);
144 (void)std::minmax_element(first: first, last: last, comp: std::less<void*>());
145 (void)std::mismatch(first1: first, last1: last, first2: first2);
146 (void)std::mismatch(first1: first, last1: last, first2: first2, binary_pred: std::equal_to<void*>());
147#if TEST_STD_VER > 11
148 (void)std::mismatch(first, last, first2, last2);
149 (void)std::mismatch(first, last, first2, last2, std::equal_to<void*>());
150#endif
151 (void)std::move(first: first, last: last, result: first2);
152 (void)std::move_backward(first: first, last: last, result: last2);
153 // RELIES ON ADL SWAP (void)std::next_permutation(first, last);
154 // RELIES ON ADL SWAP (void)std::next_permutation(first, last, std::less<void*>());
155#if TEST_STD_VER >= 11
156 (void)std::none_of(first, last, UnaryTrue());
157#endif
158 // RELIES ON ADL SWAP (void)std::nth_element(first, mid, last);
159 // RELIES ON ADL SWAP (void)std::nth_element(first, mid, last, std::less<void*>());
160 // RELIES ON ADL SWAP (void)std::partial_sort(first, mid, last);
161 // RELIES ON ADL SWAP (void)std::partial_sort(first, mid, last, std::less<void*>());
162 (void)std::partial_sort_copy(first: first, last: last, result_first: first2, result_last: mid2);
163 (void)std::partial_sort_copy(first: first, last: last, result_first: first2, result_last: mid2, comp: std::less<void*>());
164 // RELIES ON ADL SWAP (void)std::partition(first, last, UnaryTrue());
165 (void)std::partition_copy(first: first, last: last, out_true: first2, out_false: last2, pred: UnaryTrue());
166 (void)std::partition_point(first: first, last: last, pred: UnaryTrue());
167 (void)std::pop_heap(first: first, last: last);
168 (void)std::pop_heap(first: first, last: last, comp: std::less<void*>());
169 // RELIES ON ADL SWAP (void)std::prev_permutation(first, last);
170 // RELIES ON ADL SWAP (void)std::prev_permutation(first, last, std::less<void*>());
171 (void)std::push_heap(first: first, last: last);
172 (void)std::push_heap(first: first, last: last, comp: std::less<void*>());
173 (void)std::remove(first: first, last: last, value: value);
174 (void)std::remove_copy(first: first, last: last, result: first2, value: value);
175 (void)std::remove_copy_if(first: first, last: last, result: first2, pred: UnaryTrue());
176 (void)std::remove_if(first: first, last: last, pred: UnaryTrue());
177 (void)std::replace(first: first, last: last, old_value: value, new_value: value);
178 (void)std::replace_copy(first: first, last: last, result: first2, old_value: value, new_value: value);
179 (void)std::replace_copy_if(first: first, last: last, result: first2, pred: UnaryTrue(), new_value: value);
180 (void)std::replace_if(first: first, last: last, pred: UnaryTrue(), new_value: value);
181 // RELIES ON ADL SWAP (void)std::reverse(first, last);
182 (void)std::reverse_copy(first: first, last: last, result: first2);
183 // RELIES ON ADL SWAP (void)std::rotate(first, mid, last);
184 (void)std::rotate_copy(first: first, middle: mid, last: last, result: first2);
185 (void)std::search(first1: first, last1: last, first2: first2, last2: mid2);
186 (void)std::search(first1: first, last1: last, first2: first2, last2: mid2, predicate: std::equal_to<void*>());
187 (void)std::search_n(first: first, last: last, count: count, val: value);
188 (void)std::search_n(first: first, last: last, count: count, val: value, binary_pred: std::equal_to<void*>());
189 (void)std::set_difference(first1: first, last1: mid, first2: mid, last2: last, result: first2);
190 (void)std::set_difference(first1: first, last1: mid, first2: mid, last2: last, result: first2, comp: std::less<void*>());
191 (void)std::set_intersection(first1: first, last1: mid, first2: mid, last2: last, result: first2);
192 (void)std::set_intersection(first1: first, last1: mid, first2: mid, last2: last, result: first2, comp: std::less<void*>());
193 (void)std::set_symmetric_difference(first1: first, last1: mid, first2: mid, last2: last, result: first2);
194 (void)std::set_symmetric_difference(first1: first, last1: mid, first2: mid, last2: last, result: first2, comp: std::less<void*>());
195 (void)std::set_union(first1: first, last1: mid, first2: mid, last2: last, result: first2);
196 (void)std::set_union(first1: first, last1: mid, first2: mid, last2: last, result: first2, comp: std::less<void*>());
197#if TEST_STD_VER > 17
198 (void)std::shift_left(first, last, count);
199 (void)std::shift_right(first, last, count);
200#endif
201 // RELIES ON ADL SWAP (void)std::sort(first, last);
202 // RELIES ON ADL SWAP (void)std::sort(first, last, std::less<void*>());
203 (void)std::sort_heap(first: first, last: last);
204 (void)std::sort_heap(first: first, last: last, comp: std::less<void*>());
205 // RELIES ON ADL SWAP (void)std::stable_partition(first, last, UnaryTrue());
206 // RELIES ON ADL SWAP (void)std::stable_sort(first, last);
207 // RELIES ON ADL SWAP (void)std::stable_sort(first, last, std::less<void*>());
208 // RELIES ON ADL SWAP (void)std::swap_ranges(first, last, first2);
209 (void)std::transform(first: first, last: last, result: first2, unary_op: UnaryTransform());
210 (void)std::transform(first1: first, last1: mid, first2: mid, result: first2, binary_op: BinaryTransform());
211 (void)std::unique(first: first, last: last);
212 (void)std::unique(first: first, last: last, binary_pred: std::equal_to<void*>());
213 (void)std::unique_copy(first: first, last: last, result: first2);
214 (void)std::unique_copy(first: first, last: last, result: first2, binary_pred: std::equal_to<void*>());
215 (void)std::upper_bound(first: first, last: last, val: value);
216 (void)std::upper_bound(first: first, last: last, val: value, comp: std::less<void*>());
217
218 return true;
219}
220
221void test()
222{
223 all_the_algorithms();
224#if TEST_STD_VER > 17
225 static_assert(all_the_algorithms());
226#endif
227}
228

source code of libcxx/test/std/algorithms/robust_against_adl.compile.pass.cpp