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, c++20
10
11// <flat_map>
12
13#include <algorithm>
14#include <array>
15#include <cassert>
16#include <climits>
17#include <deque>
18#include <initializer_list>
19#include <list>
20#include <flat_map>
21#include <functional>
22#include <ranges>
23#include <tuple>
24#include <type_traits>
25#include <utility>
26#include <vector>
27
28#include "deduction_guides_sfinae_checks.h"
29#include "test_allocator.h"
30
31using P = std::pair<int, long>;
32using PC = std::pair<const int, long>;
33
34void test_copy() {
35 {
36 std::flat_map<long, short> source = {{1, 2}, {2, 3}};
37 std::flat_map s(source);
38 ASSERT_SAME_TYPE(decltype(s), decltype(source));
39 assert(s == source);
40 }
41 {
42 std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
43 std::flat_map s{source}; // braces instead of parens
44 ASSERT_SAME_TYPE(decltype(s), decltype(source));
45 assert(s == source);
46 }
47 {
48 std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
49 std::flat_map s(source, std::allocator<int>());
50 ASSERT_SAME_TYPE(decltype(s), decltype(source));
51 assert(s == source);
52 }
53}
54
55void test_containers() {
56 std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
57 std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
58 std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
59 std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
60 const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
61 {
62 std::flat_map s(ks, vs);
63
64 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
65 assert(std::ranges::equal(s, expected));
66 assert(s.keys().get_allocator().get_id() == 42);
67 assert(s.values().get_allocator().get_id() == 43);
68 }
69 {
70 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs);
71
72 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
73 assert(std::ranges::equal(s, expected));
74 assert(s.keys().get_allocator().get_id() == 42);
75 assert(s.values().get_allocator().get_id() == 43);
76 }
77 {
78 std::flat_map s(ks, vs, test_allocator<long>(0, 44));
79
80 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
81 assert(std::ranges::equal(s, expected));
82 assert(s.keys().get_allocator().get_id() == 44);
83 assert(s.values().get_allocator().get_id() == 44);
84 }
85 {
86 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, test_allocator<long>(0, 44));
87
88 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);
89 assert(std::ranges::equal(s, expected));
90 assert(s.keys().get_allocator().get_id() == 44);
91 assert(s.values().get_allocator().get_id() == 44);
92 }
93}
94
95void test_containers_compare() {
96 std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));
97 std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
98 std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
99 std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
100 const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
101 {
102 std::flat_map s(ks, vs, std::greater<int>());
103
104 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
105 assert(std::ranges::equal(s, expected));
106 assert(s.keys().get_allocator().get_id() == 42);
107 assert(s.values().get_allocator().get_id() == 43);
108 }
109 {
110 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>());
111
112 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
113 assert(std::ranges::equal(s, expected));
114 assert(s.keys().get_allocator().get_id() == 42);
115 assert(s.values().get_allocator().get_id() == 43);
116 }
117 {
118 std::flat_map s(ks, vs, std::greater<int>(), test_allocator<long>(0, 44));
119
120 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
121 assert(std::ranges::equal(s, expected));
122 assert(s.keys().get_allocator().get_id() == 44);
123 assert(s.values().get_allocator().get_id() == 44);
124 }
125 {
126 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>(), test_allocator<long>(0, 44));
127
128 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);
129 assert(std::ranges::equal(s, expected));
130 assert(s.keys().get_allocator().get_id() == 44);
131 assert(s.values().get_allocator().get_id() == 44);
132 }
133}
134
135void test_iter_iter() {
136 const P arr[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
137 const P sorted_arr[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};
138 const PC arrc[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
139 const PC sorted_arrc[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};
140 {
141 std::flat_map m(std::begin(arr), std::end(arr));
142
143 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
144 assert(std::ranges::equal(m, sorted_arr));
145 }
146 {
147 std::flat_map m(std::begin(arrc), std::end(arrc));
148
149 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
150 assert(std::ranges::equal(m, sorted_arr));
151 }
152 {
153 std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr));
154
155 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
156 assert(std::ranges::equal(m, sorted_arr));
157 }
158 {
159 std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc));
160
161 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
162 assert(std::ranges::equal(m, sorted_arr));
163 }
164 {
165 std::flat_map<int, short> mo;
166 std::flat_map m(mo.begin(), mo.end());
167 ASSERT_SAME_TYPE(decltype(m), decltype(mo));
168 }
169 {
170 std::flat_map<int, short> mo;
171 std::flat_map m(mo.cbegin(), mo.cend());
172 ASSERT_SAME_TYPE(decltype(m), decltype(mo));
173 }
174 {
175 std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};
176 std::flat_map s = {source, source + 3}; // flat_map(InputIterator, InputIterator)
177 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);
178 assert(s.size() == 3);
179 }
180 {
181 std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};
182 std::flat_map s{source, source + 3}; // flat_map(InputIterator, InputIterator)
183 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);
184 assert(s.size() == 3);
185 }
186 {
187 std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};
188 std::flat_map s{std::sorted_unique, source, source + 3}; // flat_map(sorted_unique_t, InputIterator, InputIterator)
189 static_assert(std::is_same_v<decltype(s), std::flat_map<int, int>>);
190 assert(s.size() == 3);
191 }
192}
193
194void test_iter_iter_compare() {
195 const P arr[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
196 const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
197 const PC arrc[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
198 const PC sorted_arrc[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
199 using C = std::greater<long long>;
200 {
201 std::flat_map m(std::begin(arr), std::end(arr), C());
202
203 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
204 assert(std::ranges::equal(m, sorted_arr));
205 }
206 {
207 std::flat_map m(std::begin(arrc), std::end(arrc), C());
208
209 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
210 assert(std::ranges::equal(m, sorted_arr));
211 }
212 {
213 std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C());
214
215 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
216 assert(std::ranges::equal(m, sorted_arr));
217 }
218 {
219 std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C());
220
221 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
222 assert(std::ranges::equal(m, sorted_arr));
223 }
224 {
225 std::flat_map<int, short> mo;
226 std::flat_map m(mo.begin(), mo.end(), C());
227 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, short, C>);
228 }
229 {
230 std::flat_map<int, short> mo;
231 std::flat_map m(mo.cbegin(), mo.cend(), C());
232 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, short, C>);
233 }
234}
235
236void test_initializer_list() {
237 const P sorted_arr[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};
238 {
239 std::flat_map m{std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};
240
241 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
242 assert(std::ranges::equal(m, sorted_arr));
243 }
244 {
245 std::flat_map m(std::sorted_unique, {std::pair{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}});
246
247 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);
248 assert(std::ranges::equal(m, sorted_arr));
249 }
250 {
251 std::flat_map s = {std::make_pair(1, 'a')}; // flat_map(initializer_list<pair<int, char>>)
252 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, char>);
253 assert(s.size() == 1);
254 }
255 {
256 using M = std::flat_map<int, short>;
257 M m;
258 std::flat_map s = {std::make_pair(m, m)}; // flat_map(initializer_list<pair<M, M>>)
259 ASSERT_SAME_TYPE(decltype(s), std::flat_map<M, M>);
260 assert(s.size() == 1);
261 assert(s[m] == m);
262 }
263}
264
265void test_initializer_list_compare() {
266 const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};
267 using C = std::greater<long long>;
268 {
269 std::flat_map m({std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}}, C());
270
271 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
272 assert(std::ranges::equal(m, sorted_arr));
273 }
274 {
275 std::flat_map m(std::sorted_unique, {std::pair{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}}, C());
276
277 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);
278 assert(std::ranges::equal(m, sorted_arr));
279 }
280}
281
282void test_from_range() {
283 std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
284 const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
285 {
286 std::flat_map s(std::from_range, r);
287 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>>);
288 assert(std::ranges::equal(s, expected));
289 }
290 {
291 std::flat_map s(std::from_range, r, test_allocator<long>(0, 42));
292 ASSERT_SAME_TYPE(
293 decltype(s),
294 std::flat_map<int,
295 short,
296 std::less<int>,
297 std::vector<int, test_allocator<int>>,
298 std::vector<short, test_allocator<short>>>);
299 assert(std::ranges::equal(s, expected));
300 assert(s.keys().get_allocator().get_id() == 42);
301 assert(s.values().get_allocator().get_id() == 42);
302 }
303}
304
305void test_from_range_compare() {
306 std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
307 const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
308 {
309 std::flat_map s(std::from_range, r, std::greater<int>());
310 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>>);
311 assert(std::ranges::equal(s, expected));
312 }
313 {
314 std::flat_map s(std::from_range, r, std::greater<int>(), test_allocator<long>(0, 42));
315 ASSERT_SAME_TYPE(
316 decltype(s),
317 std::flat_map<int,
318 short,
319 std::greater<int>,
320 std::vector<int, test_allocator<int>>,
321 std::vector<short, test_allocator<short>>>);
322 assert(std::ranges::equal(s, expected));
323 assert(s.keys().get_allocator().get_id() == 42);
324 assert(s.values().get_allocator().get_id() == 42);
325 }
326}
327
328int main(int, char**) {
329 // Each test function also tests the sorted_unique-prefixed and allocator-suffixed overloads.
330 test_copy();
331 test_containers();
332 test_containers_compare();
333 test_iter_iter();
334 test_iter_iter_compare();
335 test_initializer_list();
336 test_initializer_list_compare();
337 test_from_range();
338 test_from_range_compare();
339
340#if TEST_STD_VER >= 23
341 std::vector<std::pair<const int, float>> pair_vec = {{1, 1.1f}, {2, 2.2f}, {3, 3.3f}};
342 std::flat_map fm1(pair_vec.begin(), pair_vec.end());
343 ASSERT_SAME_TYPE(decltype(fm1), std::flat_map<int, float>);
344
345 std::vector<std::tuple<int, double>> tuple_vec = {{10, 1.1}, {20, 2.2}, {30, 3.3}};
346 std::flat_map fm2(tuple_vec.begin(), tuple_vec.end());
347 ASSERT_SAME_TYPE(decltype(fm2), std::flat_map<int, double>);
348
349 std::vector<std::array<long, 2>> array_vec = {{100L, 101L}, {200L, 201L}, {300L, 301L}};
350 std::flat_map fm3(array_vec.begin(), array_vec.end());
351 ASSERT_SAME_TYPE(decltype(fm3), std::flat_map<long, long>);
352
353 std::vector<std::pair<int, char>> non_const_key_pair_vec = {{5, 'a'}, {6, 'b'}};
354 std::flat_map fm4(non_const_key_pair_vec.begin(), non_const_key_pair_vec.end());
355 ASSERT_SAME_TYPE(decltype(fm4), std::flat_map<int, char>);
356#endif
357
358 AssociativeContainerDeductionGuidesSfinaeAway<std::flat_map, std::flat_map<int, short>>();
359
360 return 0;
361}
362

source code of libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp