1
2// Copyright 2006-2010 Daniel James.
3// Copyright (C) 2022-2023 Christian Mazakas
4// Distributed under the Boost Software License, Version 1.0. (See accompanying
5// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6
7#include "../helpers/unordered.hpp"
8
9#include "../helpers/equivalent.hpp"
10#include "../helpers/input_iterator.hpp"
11#include "../helpers/invariants.hpp"
12#include "../helpers/random_values.hpp"
13#include "../helpers/test.hpp"
14#include "../helpers/tracker.hpp"
15#include "../objects/test.hpp"
16
17#include <vector>
18
19namespace constructor_tests {
20
21 test::seed_t initialize_seed(356730);
22
23 template <class T>
24 void constructor_tests1(T*, test::random_generator generator)
25 {
26 typename T::hasher hf;
27 typename T::key_equal eq;
28 typename T::allocator_type al;
29
30 UNORDERED_SUB_TEST("Construct 1")
31 {
32 test::check_instances check_;
33
34 T x(0, hf, eq);
35 BOOST_TEST(x.empty());
36 BOOST_TEST(test::equivalent(x.hash_function(), hf));
37 BOOST_TEST(test::equivalent(x.key_eq(), eq));
38 BOOST_TEST(test::equivalent(x.get_allocator(), al));
39 test::check_equivalent_keys(x);
40 }
41
42 UNORDERED_SUB_TEST("Construct 2")
43 {
44 test::check_instances check_;
45
46 T x(100, hf);
47 BOOST_TEST(x.empty());
48 BOOST_TEST(x.bucket_count() >= 100);
49 BOOST_TEST(test::equivalent(x.hash_function(), hf));
50 BOOST_TEST(test::equivalent(x.key_eq(), eq));
51 BOOST_TEST(test::equivalent(x.get_allocator(), al));
52 test::check_equivalent_keys(x);
53 }
54
55 UNORDERED_SUB_TEST("Construct 3")
56 {
57 test::check_instances check_;
58
59 T x(2000);
60 BOOST_TEST(x.empty());
61 BOOST_TEST(x.bucket_count() >= 2000);
62 BOOST_TEST(test::equivalent(x.hash_function(), hf));
63 BOOST_TEST(test::equivalent(x.key_eq(), eq));
64 BOOST_TEST(test::equivalent(x.get_allocator(), al));
65 test::check_equivalent_keys(x);
66 }
67
68 UNORDERED_SUB_TEST("Construct 4")
69 {
70 test::check_instances check_;
71
72 T x;
73 BOOST_TEST(x.empty());
74 BOOST_TEST(test::equivalent(x.hash_function(), hf));
75 BOOST_TEST(test::equivalent(x.key_eq(), eq));
76 BOOST_TEST(test::equivalent(x.get_allocator(), al));
77 test::check_equivalent_keys(x);
78 }
79
80 UNORDERED_SUB_TEST("Construct 5")
81 {
82 test::check_instances check_;
83
84 test::random_values<T> v(1000, generator);
85 T x(v.begin(), v.end(), 10000, hf, eq);
86 BOOST_TEST(x.bucket_count() >= 10000);
87 BOOST_TEST(test::equivalent(x.hash_function(), hf));
88 BOOST_TEST(test::equivalent(x.key_eq(), eq));
89 BOOST_TEST(test::equivalent(x.get_allocator(), al));
90 test::check_container(x, v);
91 test::check_equivalent_keys(x);
92 }
93
94 UNORDERED_SUB_TEST("Construct 6")
95 {
96 test::check_instances check_;
97
98 test::random_values<T> v(10, generator);
99 T x(v.begin(), v.end(), 10000, hf);
100 BOOST_TEST(x.bucket_count() >= 10000);
101 BOOST_TEST(test::equivalent(x.hash_function(), hf));
102 BOOST_TEST(test::equivalent(x.key_eq(), eq));
103 BOOST_TEST(test::equivalent(x.get_allocator(), al));
104 test::check_container(x, v);
105 test::check_equivalent_keys(x);
106 }
107
108 UNORDERED_SUB_TEST("Construct 7")
109 {
110 test::check_instances check_;
111
112 test::random_values<T> v(100, generator);
113 T x(v.begin(), v.end(), 100);
114 BOOST_TEST(x.bucket_count() >= 100);
115 BOOST_TEST(test::equivalent(x.hash_function(), hf));
116 BOOST_TEST(test::equivalent(x.key_eq(), eq));
117 BOOST_TEST(test::equivalent(x.get_allocator(), al));
118 test::check_container(x, v);
119 test::check_equivalent_keys(x);
120 }
121
122 UNORDERED_SUB_TEST("Construct 8")
123 {
124 test::check_instances check_;
125
126 test::random_values<T> v(1, generator);
127 T x(v.begin(), v.end());
128 BOOST_TEST(test::equivalent(x.hash_function(), hf));
129 BOOST_TEST(test::equivalent(x.key_eq(), eq));
130 BOOST_TEST(test::equivalent(x.get_allocator(), al));
131 test::check_container(x, v);
132 test::check_equivalent_keys(x);
133 }
134
135 UNORDERED_SUB_TEST("Construct 9")
136 {
137 test::check_instances check_;
138
139 T x(0, hf, eq, al);
140 BOOST_TEST(x.empty());
141 BOOST_TEST(test::equivalent(x.hash_function(), hf));
142 BOOST_TEST(test::equivalent(x.key_eq(), eq));
143 BOOST_TEST(test::equivalent(x.get_allocator(), al));
144 test::check_equivalent_keys(x);
145 }
146
147 UNORDERED_SUB_TEST("Construct 10")
148 {
149 test::check_instances check_;
150
151 test::random_values<T> v(1000, generator);
152 T x(v.begin(), v.end(), 10000, hf, eq, al);
153 BOOST_TEST(x.bucket_count() >= 10000);
154 BOOST_TEST(test::equivalent(x.hash_function(), hf));
155 BOOST_TEST(test::equivalent(x.key_eq(), eq));
156 BOOST_TEST(test::equivalent(x.get_allocator(), al));
157 test::check_container(x, v);
158 test::check_equivalent_keys(x);
159 }
160
161 UNORDERED_SUB_TEST("Construct 11")
162 {
163 test::check_instances check_;
164
165 T x(al);
166 BOOST_TEST(x.empty());
167 BOOST_TEST(test::equivalent(x.hash_function(), hf));
168 BOOST_TEST(test::equivalent(x.key_eq(), eq));
169 BOOST_TEST(test::equivalent(x.get_allocator(), al));
170 test::check_equivalent_keys(x);
171 }
172
173 UNORDERED_SUB_TEST("Construct 12")
174 {
175 test::check_instances check_;
176
177 test::random_values<T> v(1000, generator);
178 T x(v.begin(), v.end(), al);
179 BOOST_TEST(test::equivalent(x.get_allocator(), al));
180 test::check_container(x, v);
181 }
182 }
183
184 template <class T>
185 void constructor_tests2(T*, test::random_generator const& generator)
186 {
187 typename T::hasher hf;
188 typename T::hasher hf1(1);
189 typename T::hasher hf2(2);
190 typename T::key_equal eq;
191 typename T::key_equal eq1(1);
192 typename T::key_equal eq2(2);
193 typename T::allocator_type al;
194 typename T::allocator_type al1(1);
195 typename T::allocator_type al2(2);
196
197 UNORDERED_SUB_TEST("Construct 1")
198 {
199 test::check_instances check_;
200 T x(10000, hf1, eq1);
201 BOOST_TEST(x.bucket_count() >= 10000);
202 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
203 BOOST_TEST(test::equivalent(x.key_eq(), eq1));
204 BOOST_TEST(test::equivalent(x.get_allocator(), al));
205 test::check_equivalent_keys(x);
206 }
207
208 UNORDERED_SUB_TEST("Construct 2")
209 {
210 test::check_instances check_;
211 T x(100, hf1);
212 BOOST_TEST(x.empty());
213 BOOST_TEST(x.bucket_count() >= 100);
214 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
215 BOOST_TEST(test::equivalent(x.key_eq(), eq));
216 BOOST_TEST(test::equivalent(x.get_allocator(), al));
217 test::check_equivalent_keys(x);
218 }
219
220 UNORDERED_SUB_TEST("Construct 3")
221 {
222 test::check_instances check_;
223 test::random_values<T> v(100, generator);
224 T x(v.begin(), v.end(), 0, hf1, eq1);
225 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
226 BOOST_TEST(test::equivalent(x.key_eq(), eq1));
227 BOOST_TEST(test::equivalent(x.get_allocator(), al));
228 test::check_container(x, v);
229 test::check_equivalent_keys(x);
230 }
231
232 UNORDERED_SUB_TEST("Construct 4")
233 {
234 test::check_instances check_;
235 test::random_values<T> v(5, generator);
236 T x(v.begin(), v.end(), 1000, hf1);
237 BOOST_TEST(x.bucket_count() >= 1000);
238 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
239 BOOST_TEST(test::equivalent(x.key_eq(), eq));
240 BOOST_TEST(test::equivalent(x.get_allocator(), al));
241 test::check_container(x, v);
242 test::check_equivalent_keys(x);
243 }
244
245 UNORDERED_SUB_TEST("Construct 5")
246 {
247 test::check_instances check_;
248 test::random_values<T> v(100, generator);
249 T x(v.begin(), v.end(), 0, hf, eq, al1);
250 T y(x.begin(), x.end(), 0, hf1, eq1, al2);
251 test::check_container(x, v);
252 test::check_container(y, x);
253 test::check_equivalent_keys(x);
254 test::check_equivalent_keys(y);
255 }
256
257 UNORDERED_SUB_TEST("Construct 6")
258 {
259 test::check_instances check_;
260 test::random_values<T> v(100, generator);
261 T x(v.begin(), v.end(), 0, hf1, eq1);
262 T y(x.begin(), x.end(), 0, hf, eq);
263 test::check_container(x, v);
264 test::check_container(y, x);
265 test::check_equivalent_keys(x);
266 test::check_equivalent_keys(y);
267 }
268
269 UNORDERED_SUB_TEST("Construct 7")
270 {
271 test::check_instances check_;
272 test::random_values<T> v(100, generator);
273 T x(v.begin(), v.end(), 0, hf1, eq1);
274 T y(x.begin(), x.end(), 0, hf2, eq2);
275 test::check_container(x, v);
276 test::check_container(y, x);
277 test::check_equivalent_keys(x);
278 test::check_equivalent_keys(y);
279 }
280
281 UNORDERED_SUB_TEST("Construct 8 - from input iterator")
282 {
283 test::check_instances check_;
284 test::random_values<T> v(100, generator);
285 typename test::random_values<T>::const_iterator v_begin = v.begin(),
286 v_end = v.end();
287 T x(test::input_iterator(v_begin), test::input_iterator(v_end), 0, hf1,
288 eq1);
289 typename T::const_iterator x_begin = x.begin(), x_end = x.end();
290 T y(test::input_iterator(x_begin), test::input_iterator(x_end), 0, hf2,
291 eq2);
292 test::check_container(x, v);
293 test::check_container(y, x);
294 test::check_equivalent_keys(x);
295 test::check_equivalent_keys(y);
296 }
297
298 UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator")
299 {
300 test::check_instances check_;
301 test::random_values<T> v(100, generator);
302 T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0, hf1,
303 eq1);
304 T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0, hf2,
305 eq2);
306 test::check_container(x, v);
307 test::check_container(y, x);
308 test::check_equivalent_keys(x);
309 test::check_equivalent_keys(y);
310 }
311
312 UNORDERED_SUB_TEST("Construct 9")
313 {
314 test::check_instances check_;
315
316 test::random_values<T> v(100, generator);
317 T x(50);
318 BOOST_TEST(x.bucket_count() >= 50);
319 x.max_load_factor(10);
320 BOOST_TEST(x.bucket_count() >= 50);
321 x.insert(v.begin(), v.end());
322 BOOST_TEST(x.bucket_count() >= 50);
323 test::check_container(x, v);
324 test::check_equivalent_keys(x);
325 }
326
327 typedef typename T::value_type value_type;
328
329 std::initializer_list<value_type> list;
330
331 test::random_values<T> v(3, generator);
332 std::vector<value_type> vec(v.begin(), v.end());
333 BOOST_ASSERT(vec.size() >= 3);
334
335 // create a new vector here because erase() requires assignability which is
336 // deleted for some of the test types
337 //
338 std::vector<value_type> expected(vec.begin(), vec.begin() + 3);
339
340 UNORDERED_SUB_TEST("Initializer list construct 1")
341 {
342 test::check_instances check_;
343
344 {
345 T x(list);
346 BOOST_TEST(x.empty());
347 BOOST_TEST(test::equivalent(x.hash_function(), hf));
348 BOOST_TEST(test::equivalent(x.key_eq(), eq));
349 BOOST_TEST(test::equivalent(x.get_allocator(), al));
350 }
351
352 {
353 T x{vec[0], vec[1], vec[2]};
354 BOOST_TEST_NOT(x.empty());
355 BOOST_TEST_GT(x.bucket_count(), 0u);
356 BOOST_TEST(test::equivalent(x.hash_function(), hf));
357 BOOST_TEST(test::equivalent(x.key_eq(), eq));
358 BOOST_TEST(test::equivalent(x.get_allocator(), al));
359 test::check_container(x, expected);
360 }
361 }
362
363 UNORDERED_SUB_TEST("Initializer list construct 2")
364 {
365 test::check_instances check_;
366
367 {
368 T x(list, 1000);
369 BOOST_TEST(x.empty());
370 BOOST_TEST(x.bucket_count() >= 1000);
371 BOOST_TEST(test::equivalent(x.hash_function(), hf));
372 BOOST_TEST(test::equivalent(x.key_eq(), eq));
373 BOOST_TEST(test::equivalent(x.get_allocator(), al));
374 }
375
376 {
377 T x({vec[0], vec[1], vec[2]}, 1000);
378 BOOST_TEST_NOT(x.empty());
379 BOOST_TEST(x.bucket_count() >= 1000);
380 BOOST_TEST(test::equivalent(x.hash_function(), hf));
381 BOOST_TEST(test::equivalent(x.key_eq(), eq));
382 BOOST_TEST(test::equivalent(x.get_allocator(), al));
383 test::check_container(x, expected);
384 }
385 }
386
387 UNORDERED_SUB_TEST("Initializer list construct 3")
388 {
389 {
390 test::check_instances check_;
391
392 T x(list, 10, hf1);
393 BOOST_TEST(x.empty());
394 BOOST_TEST(x.bucket_count() >= 10);
395 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
396 BOOST_TEST(test::equivalent(x.key_eq(), eq));
397 BOOST_TEST(test::equivalent(x.get_allocator(), al));
398 }
399
400 {
401 test::check_instances check_;
402
403 T x({vec[0], vec[1], vec[2]}, 10, hf1);
404 BOOST_TEST_NOT(x.empty());
405 BOOST_TEST(x.bucket_count() >= 10);
406 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
407 BOOST_TEST(test::equivalent(x.key_eq(), eq));
408 BOOST_TEST(test::equivalent(x.get_allocator(), al));
409 test::check_container(x, expected);
410 }
411 }
412
413 UNORDERED_SUB_TEST("Initializer list construct 4")
414 {
415 {
416 test::check_instances check_;
417
418 T x(list, 10, hf1, eq1);
419 BOOST_TEST(x.empty());
420 BOOST_TEST(x.bucket_count() >= 10);
421 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
422 BOOST_TEST(test::equivalent(x.key_eq(), eq1));
423 BOOST_TEST(test::equivalent(x.get_allocator(), al));
424 }
425
426 {
427 test::check_instances check_;
428
429 T x({vec[0], vec[1], vec[2]}, 10, hf1, eq1);
430 BOOST_TEST_NOT(x.empty());
431 BOOST_TEST(x.bucket_count() >= 10);
432 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
433 BOOST_TEST(test::equivalent(x.key_eq(), eq1));
434 BOOST_TEST(test::equivalent(x.get_allocator(), al));
435 test::check_container(x, expected);
436 }
437 }
438
439 UNORDERED_SUB_TEST("Initializer list construct 5")
440 {
441 {
442 test::check_instances check_;
443
444 T x(list, 10, hf1, eq1, al1);
445 BOOST_TEST(x.empty());
446 BOOST_TEST(x.bucket_count() >= 10);
447 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
448 BOOST_TEST(test::equivalent(x.key_eq(), eq1));
449 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
450 }
451
452 {
453 test::check_instances check_;
454
455 T x({vec[0], vec[1], vec[2]}, 10, hf1, eq1, al1);
456 BOOST_TEST_NOT(x.empty());
457 BOOST_TEST(x.bucket_count() >= 10);
458 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
459 BOOST_TEST(test::equivalent(x.key_eq(), eq1));
460 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
461 test::check_container(x, expected);
462 }
463 }
464
465 UNORDERED_SUB_TEST("Initializer list construct 6")
466 {
467 {
468 test::check_instances check_;
469
470 T x(list, 10, al1);
471 BOOST_TEST(x.empty());
472 BOOST_TEST(x.bucket_count() >= 10);
473 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
474 }
475
476 {
477 test::check_instances check_;
478
479 T x({vec[0], vec[1], vec[2]}, 10, al1);
480 BOOST_TEST_NOT(x.empty());
481 BOOST_TEST(x.bucket_count() >= 10);
482 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
483 test::check_container(x, expected);
484 }
485 }
486
487 UNORDERED_SUB_TEST("Initializer list construct 7")
488 {
489 {
490 test::check_instances check_;
491
492 T x(list, 10, hf1, al1);
493 BOOST_TEST(x.empty());
494 BOOST_TEST(x.bucket_count() >= 10);
495 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
496 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
497 }
498
499 {
500 test::check_instances check_;
501
502 T x({vec[0], vec[1], vec[2]}, 10, hf1, al1);
503 BOOST_TEST_NOT(x.empty());
504 BOOST_TEST(x.bucket_count() >= 10);
505 BOOST_TEST(test::equivalent(x.hash_function(), hf1));
506 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
507 test::check_container(x, expected);
508 }
509 }
510
511 UNORDERED_SUB_TEST("Initializer list construct 8")
512 {
513 test::check_instances check_;
514
515 {
516 T x(list, al1);
517 BOOST_TEST(x.empty());
518 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
519 }
520
521 {
522 T x({vec[0], vec[1], vec[2]}, al1);
523 BOOST_TEST(test::equivalent(x.get_allocator(), al1));
524 test::check_container(x, expected);
525 }
526 }
527 }
528
529 template <class T>
530 void no_alloc_default_construct_test(T*, test::random_generator)
531 {
532
533#ifdef BOOST_UNORDERED_FOA_TESTS
534 using allocator_type = typename T::allocator_type;
535 using value_type =
536 typename boost::allocator_value_type<allocator_type>::type;
537 using pointer = typename boost::allocator_pointer<allocator_type>::type;
538 static_assert(std::is_same<pointer, value_type*>::value,
539 "only raw pointers for this test");
540#endif
541
542 UNORDERED_SUB_TEST("Construct 1")
543 {
544 T x;
545 BOOST_TEST_EQ(x.bucket_count(), 0u);
546 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
547 }
548
549 UNORDERED_SUB_TEST("Construct 2")
550 {
551 {
552 T x(0);
553 BOOST_TEST_EQ(x.bucket_count(), 0u);
554 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
555 }
556
557 {
558 T x(1);
559 BOOST_TEST_GT(x.bucket_count(), 0u);
560 BOOST_TEST_GT(test::detail::tracker.count_allocations, 0u);
561 }
562 }
563
564 UNORDERED_SUB_TEST("Construct 3")
565 {
566 test::random_values<T> v;
567 T x(v.begin(), v.end());
568 BOOST_TEST_EQ(x.bucket_count(), 0u);
569 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
570 }
571
572 UNORDERED_SUB_TEST("Construct 4")
573 {
574 {
575 test::random_values<T> v;
576 T x(v.begin(), v.end(), 0);
577 BOOST_TEST_EQ(x.bucket_count(), 0u);
578 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
579 }
580
581 {
582 test::random_values<T> v;
583 T x(v.begin(), v.end(), 1);
584 BOOST_TEST_GT(x.bucket_count(), 0u);
585 BOOST_TEST_GT(test::detail::tracker.count_allocations, 0u);
586 }
587 }
588
589 UNORDERED_SUB_TEST("Construct 5")
590 {
591 typename T::allocator_type al;
592
593 {
594 T x(al);
595 BOOST_TEST_EQ(x.bucket_count(), 0u);
596 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
597 }
598 }
599
600 UNORDERED_SUB_TEST("Construct 6")
601 {
602 typename T::allocator_type al;
603
604 T x(0, al);
605 BOOST_TEST_EQ(x.bucket_count(), 0u);
606 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
607 }
608
609 UNORDERED_SUB_TEST("Initializer list 1")
610 {
611 std::initializer_list<typename T::value_type> list;
612 T x(list);
613 BOOST_TEST_EQ(x.bucket_count(), 0u);
614 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
615 }
616
617 UNORDERED_SUB_TEST("Initializer list 2")
618 {
619 {
620 std::initializer_list<typename T::value_type> list;
621 T x(list, 0);
622 BOOST_TEST_EQ(x.bucket_count(), 0u);
623 BOOST_TEST_EQ(test::detail::tracker.count_allocations, 0u);
624 }
625
626 {
627 std::initializer_list<typename T::value_type> list;
628 T x(list, 1);
629 BOOST_TEST_GT(x.bucket_count(), 0u);
630 BOOST_TEST_GT(test::detail::tracker.count_allocations, 0u);
631 }
632 }
633 }
634
635 template <class T>
636 void map_constructor_test(T*, test::random_generator const& generator)
637 {
638 typedef test::list<
639 std::pair<typename T::key_type, typename T::mapped_type> >
640 list;
641 test::random_values<T> v(1000, generator);
642 list l(v.begin(), v.end());
643 T x(l.begin(), l.end());
644
645 test::check_container(x, v);
646 test::check_equivalent_keys(x);
647 }
648
649 using test::default_generator;
650 using test::generate_collisions;
651 using test::limited_range;
652
653#ifdef BOOST_UNORDERED_FOA_TESTS
654 boost::unordered_flat_map<test::object, test::object, test::hash,
655 test::equal_to, std::allocator<test::object> >* test_map_std_alloc;
656
657 boost::unordered_flat_set<test::object, test::hash, test::equal_to,
658 test::allocator1<test::object> >* test_set_raw_ptr;
659 boost::unordered_node_set<test::object, test::hash, test::equal_to,
660 test::allocator1<test::object> >* test_node_set_raw_ptr;
661 boost::unordered_flat_map<test::object, test::object, test::hash,
662 test::equal_to, test::allocator1<test::object> >* test_map_raw_ptr;
663 boost::unordered_node_map<test::object, test::object, test::hash,
664 test::equal_to, test::allocator1<test::object> >* test_node_map_raw_ptr;
665
666 boost::unordered_flat_set<test::object, test::hash, test::equal_to,
667 test::allocator1<test::object> >* test_set;
668 boost::unordered_node_set<test::object, test::hash, test::equal_to,
669 test::allocator1<test::object> >* test_node_set;
670 boost::unordered_flat_map<test::object, test::object, test::hash,
671 test::equal_to, test::allocator2<test::object> >* test_map;
672 boost::unordered_node_map<test::object, test::object, test::hash,
673 test::equal_to, test::allocator2<test::object> >* test_node_map;
674
675 UNORDERED_TEST(constructor_tests1,
676 ((test_map_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
677 (default_generator)(generate_collisions)(limited_range)))
678
679 UNORDERED_TEST(constructor_tests2,
680 ((test_set)(test_node_set)(test_map)(test_node_map))(
681 (default_generator)(generate_collisions)(limited_range)))
682
683 UNORDERED_TEST(map_constructor_test,
684 ((test_map_std_alloc)(test_map)(test_node_map))(
685 (default_generator)(generate_collisions)(limited_range)))
686
687 UNORDERED_TEST(no_alloc_default_construct_test,
688 ((test_set_raw_ptr)(test_node_set_raw_ptr)(test_map_raw_ptr)(test_node_map_raw_ptr))(
689 (default_generator)(generate_collisions)(limited_range)))
690#else
691 boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
692 std::allocator<test::object> >* test_map_std_alloc;
693
694 boost::unordered_set<test::object, test::hash, test::equal_to,
695 test::allocator1<test::object> >* test_set;
696 boost::unordered_multiset<test::object, test::hash, test::equal_to,
697 test::allocator2<test::object> >* test_multiset;
698 boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
699 test::allocator2<test::object> >* test_map;
700 boost::unordered_multimap<test::object, test::object, test::hash,
701 test::equal_to, test::allocator1<test::object> >* test_multimap;
702
703 UNORDERED_TEST(constructor_tests1,
704 ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
705 (default_generator)(generate_collisions)(limited_range)))
706
707 UNORDERED_TEST(constructor_tests2,
708 ((test_set)(test_multiset)(test_map)(test_multimap))(
709 (default_generator)(generate_collisions)(limited_range)))
710
711 UNORDERED_TEST(map_constructor_test,
712 ((test_map_std_alloc)(test_map)(test_multimap))(
713 (default_generator)(generate_collisions)(limited_range)))
714
715 UNORDERED_TEST(no_alloc_default_construct_test,
716 ((test_set)(test_multiset)(test_map)(test_multimap))(
717 (default_generator)(generate_collisions)(limited_range)))
718#endif
719
720 UNORDERED_AUTO_TEST (test_default_initializer_list) {
721 std::initializer_list<int> init;
722#ifdef BOOST_UNORDERED_FOA_TESTS
723 boost::unordered_flat_set<int> x1 = init;
724 boost::unordered_node_set<int> x2 = init;
725 BOOST_TEST(x2.empty());
726#else
727 boost::unordered_set<int> x1 = init;
728#endif
729 BOOST_TEST(x1.empty());
730 }
731
732 UNORDERED_AUTO_TEST (test_initializer_list) {
733#ifdef BOOST_UNORDERED_FOA_TESTS
734 boost::unordered_flat_set<int> x1 = {2, 10, 45, -5};
735 boost::unordered_node_set<int> x2 = {2, 10, 45, -5};
736 BOOST_TEST(x2.find(10) != x2.end());
737 BOOST_TEST(x2.find(46) == x2.end());
738#else
739 boost::unordered_set<int> x1 = {2, 10, 45, -5};
740#endif
741
742 BOOST_TEST(x1.find(10) != x1.end());
743 BOOST_TEST(x1.find(46) == x1.end());
744 }
745} // namespace constructor_tests
746
747RUN_TESTS_QUIET()
748

source code of boost/libs/unordered/test/unordered/constructor_tests.cpp