1 
2 // Copyright 2006-2010 Daniel James.
3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5 
6 // clang-format off
7 #include "../helpers/prefix.hpp"
8 #include <boost/unordered_set.hpp>
9 #include <boost/unordered_map.hpp>
10 #include "../helpers/postfix.hpp"
11 // clang-format on
12 
13 #include "../helpers/test.hpp"
14 #include "../objects/test.hpp"
15 #include "../helpers/random_values.hpp"
16 #include "../helpers/tracker.hpp"
17 #include "../helpers/equivalent.hpp"
18 #include "../helpers/input_iterator.hpp"
19 #include "../helpers/invariants.hpp"
20 
21 namespace constructor_tests {
22 
23   test::seed_t initialize_seed(356730);
24 
25   template <class T>
constructor_tests1(T *,test::random_generator generator)26   void constructor_tests1(T*, test::random_generator generator)
27   {
28     typename T::hasher hf;
29     typename T::key_equal eq;
30     typename T::allocator_type al;
31 
32     UNORDERED_SUB_TEST("Construct 1")
33     {
34       test::check_instances check_;
35 
36       T x(0, hf, eq);
37       BOOST_TEST(x.empty());
38       BOOST_TEST(test::equivalent(x.hash_function(), hf));
39       BOOST_TEST(test::equivalent(x.key_eq(), eq));
40       BOOST_TEST(test::equivalent(x.get_allocator(), al));
41       test::check_equivalent_keys(x);
42     }
43 
44     UNORDERED_SUB_TEST("Construct 2")
45     {
46       test::check_instances check_;
47 
48       T x(100, hf);
49       BOOST_TEST(x.empty());
50       BOOST_TEST(x.bucket_count() >= 100);
51       BOOST_TEST(test::equivalent(x.hash_function(), hf));
52       BOOST_TEST(test::equivalent(x.key_eq(), eq));
53       BOOST_TEST(test::equivalent(x.get_allocator(), al));
54       test::check_equivalent_keys(x);
55     }
56 
57     UNORDERED_SUB_TEST("Construct 3")
58     {
59       test::check_instances check_;
60 
61       T x(2000);
62       BOOST_TEST(x.empty());
63       BOOST_TEST(x.bucket_count() >= 2000);
64       BOOST_TEST(test::equivalent(x.hash_function(), hf));
65       BOOST_TEST(test::equivalent(x.key_eq(), eq));
66       BOOST_TEST(test::equivalent(x.get_allocator(), al));
67       test::check_equivalent_keys(x);
68     }
69 
70     UNORDERED_SUB_TEST("Construct 4")
71     {
72       test::check_instances check_;
73 
74       T x;
75       BOOST_TEST(x.empty());
76       BOOST_TEST(test::equivalent(x.hash_function(), hf));
77       BOOST_TEST(test::equivalent(x.key_eq(), eq));
78       BOOST_TEST(test::equivalent(x.get_allocator(), al));
79       test::check_equivalent_keys(x);
80     }
81 
82     UNORDERED_SUB_TEST("Construct 5")
83     {
84       test::check_instances check_;
85 
86       test::random_values<T> v(1000, generator);
87       T x(v.begin(), v.end(), 10000, hf, eq);
88       BOOST_TEST(x.bucket_count() >= 10000);
89       BOOST_TEST(test::equivalent(x.hash_function(), hf));
90       BOOST_TEST(test::equivalent(x.key_eq(), eq));
91       BOOST_TEST(test::equivalent(x.get_allocator(), al));
92       test::check_container(x, v);
93       test::check_equivalent_keys(x);
94     }
95 
96     UNORDERED_SUB_TEST("Construct 6")
97     {
98       test::check_instances check_;
99 
100       test::random_values<T> v(10, generator);
101       T x(v.begin(), v.end(), 10000, hf);
102       BOOST_TEST(x.bucket_count() >= 10000);
103       BOOST_TEST(test::equivalent(x.hash_function(), hf));
104       BOOST_TEST(test::equivalent(x.key_eq(), eq));
105       BOOST_TEST(test::equivalent(x.get_allocator(), al));
106       test::check_container(x, v);
107       test::check_equivalent_keys(x);
108     }
109 
110     UNORDERED_SUB_TEST("Construct 7")
111     {
112       test::check_instances check_;
113 
114       test::random_values<T> v(100, generator);
115       T x(v.begin(), v.end(), 100);
116       BOOST_TEST(x.bucket_count() >= 100);
117       BOOST_TEST(test::equivalent(x.hash_function(), hf));
118       BOOST_TEST(test::equivalent(x.key_eq(), eq));
119       BOOST_TEST(test::equivalent(x.get_allocator(), al));
120       test::check_container(x, v);
121       test::check_equivalent_keys(x);
122     }
123 
124     UNORDERED_SUB_TEST("Construct 8")
125     {
126       test::check_instances check_;
127 
128       test::random_values<T> v(1, generator);
129       T x(v.begin(), v.end());
130       BOOST_TEST(test::equivalent(x.hash_function(), hf));
131       BOOST_TEST(test::equivalent(x.key_eq(), eq));
132       BOOST_TEST(test::equivalent(x.get_allocator(), al));
133       test::check_container(x, v);
134       test::check_equivalent_keys(x);
135     }
136 
137     UNORDERED_SUB_TEST("Construct 9")
138     {
139       test::check_instances check_;
140 
141       T x(0, hf, eq, al);
142       BOOST_TEST(x.empty());
143       BOOST_TEST(test::equivalent(x.hash_function(), hf));
144       BOOST_TEST(test::equivalent(x.key_eq(), eq));
145       BOOST_TEST(test::equivalent(x.get_allocator(), al));
146       test::check_equivalent_keys(x);
147     }
148 
149     UNORDERED_SUB_TEST("Construct 10")
150     {
151       test::check_instances check_;
152 
153       test::random_values<T> v(1000, generator);
154       T x(v.begin(), v.end(), 10000, hf, eq, al);
155       BOOST_TEST(x.bucket_count() >= 10000);
156       BOOST_TEST(test::equivalent(x.hash_function(), hf));
157       BOOST_TEST(test::equivalent(x.key_eq(), eq));
158       BOOST_TEST(test::equivalent(x.get_allocator(), al));
159       test::check_container(x, v);
160       test::check_equivalent_keys(x);
161     }
162 
163     UNORDERED_SUB_TEST("Construct 11")
164     {
165       test::check_instances check_;
166 
167       T x(al);
168       BOOST_TEST(x.empty());
169       BOOST_TEST(test::equivalent(x.hash_function(), hf));
170       BOOST_TEST(test::equivalent(x.key_eq(), eq));
171       BOOST_TEST(test::equivalent(x.get_allocator(), al));
172       test::check_equivalent_keys(x);
173     }
174   }
175 
176   template <class T>
constructor_tests2(T *,test::random_generator const & generator)177   void constructor_tests2(T*, test::random_generator const& generator)
178   {
179     typename T::hasher hf;
180     typename T::hasher hf1(1);
181     typename T::hasher hf2(2);
182     typename T::key_equal eq;
183     typename T::key_equal eq1(1);
184     typename T::key_equal eq2(2);
185     typename T::allocator_type al;
186     typename T::allocator_type al1(1);
187     typename T::allocator_type al2(2);
188 
189     UNORDERED_SUB_TEST("Construct 1")
190     {
191       test::check_instances check_;
192       T x(10000, hf1, eq1);
193       BOOST_TEST(x.bucket_count() >= 10000);
194       BOOST_TEST(test::equivalent(x.hash_function(), hf1));
195       BOOST_TEST(test::equivalent(x.key_eq(), eq1));
196       BOOST_TEST(test::equivalent(x.get_allocator(), al));
197       test::check_equivalent_keys(x);
198     }
199 
200     UNORDERED_SUB_TEST("Construct 2")
201     {
202       test::check_instances check_;
203       T x(100, hf1);
204       BOOST_TEST(x.empty());
205       BOOST_TEST(x.bucket_count() >= 100);
206       BOOST_TEST(test::equivalent(x.hash_function(), hf1));
207       BOOST_TEST(test::equivalent(x.key_eq(), eq));
208       BOOST_TEST(test::equivalent(x.get_allocator(), al));
209       test::check_equivalent_keys(x);
210     }
211 
212     UNORDERED_SUB_TEST("Construct 3")
213     {
214       test::check_instances check_;
215       test::random_values<T> v(100, generator);
216       T x(v.begin(), v.end(), 0, hf1, eq1);
217       BOOST_TEST(test::equivalent(x.hash_function(), hf1));
218       BOOST_TEST(test::equivalent(x.key_eq(), eq1));
219       BOOST_TEST(test::equivalent(x.get_allocator(), al));
220       test::check_container(x, v);
221       test::check_equivalent_keys(x);
222     }
223 
224     UNORDERED_SUB_TEST("Construct 4")
225     {
226       test::check_instances check_;
227       test::random_values<T> v(5, generator);
228       T x(v.begin(), v.end(), 1000, hf1);
229       BOOST_TEST(x.bucket_count() >= 1000);
230       BOOST_TEST(test::equivalent(x.hash_function(), hf1));
231       BOOST_TEST(test::equivalent(x.key_eq(), eq));
232       BOOST_TEST(test::equivalent(x.get_allocator(), al));
233       test::check_container(x, v);
234       test::check_equivalent_keys(x);
235     }
236 
237     UNORDERED_SUB_TEST("Construct 5")
238     {
239       test::check_instances check_;
240       test::random_values<T> v(100, generator);
241       T x(v.begin(), v.end(), 0, hf, eq, al1);
242       T y(x.begin(), x.end(), 0, hf1, eq1, al2);
243       test::check_container(x, v);
244       test::check_container(y, x);
245       test::check_equivalent_keys(x);
246       test::check_equivalent_keys(y);
247     }
248 
249     UNORDERED_SUB_TEST("Construct 6")
250     {
251       test::check_instances check_;
252       test::random_values<T> v(100, generator);
253       T x(v.begin(), v.end(), 0, hf1, eq1);
254       T y(x.begin(), x.end(), 0, hf, eq);
255       test::check_container(x, v);
256       test::check_container(y, x);
257       test::check_equivalent_keys(x);
258       test::check_equivalent_keys(y);
259     }
260 
261     UNORDERED_SUB_TEST("Construct 7")
262     {
263       test::check_instances check_;
264       test::random_values<T> v(100, generator);
265       T x(v.begin(), v.end(), 0, hf1, eq1);
266       T y(x.begin(), x.end(), 0, hf2, eq2);
267       test::check_container(x, v);
268       test::check_container(y, x);
269       test::check_equivalent_keys(x);
270       test::check_equivalent_keys(y);
271     }
272 
273     UNORDERED_SUB_TEST("Construct 8 - from input iterator")
274     {
275       test::check_instances check_;
276       test::random_values<T> v(100, generator);
277       typename test::random_values<T>::const_iterator v_begin = v.begin(),
278                                                       v_end = v.end();
279       T x(test::input_iterator(v_begin), test::input_iterator(v_end), 0, hf1,
280         eq1);
281       typename T::const_iterator x_begin = x.begin(), x_end = x.end();
282       T y(test::input_iterator(x_begin), test::input_iterator(x_end), 0, hf2,
283         eq2);
284       test::check_container(x, v);
285       test::check_container(y, x);
286       test::check_equivalent_keys(x);
287       test::check_equivalent_keys(y);
288     }
289 
290     UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator")
291     {
292       test::check_instances check_;
293       test::random_values<T> v(100, generator);
294       T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0, hf1,
295         eq1);
296       T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0, hf2,
297         eq2);
298       test::check_container(x, v);
299       test::check_container(y, x);
300       test::check_equivalent_keys(x);
301       test::check_equivalent_keys(y);
302     }
303 
304     UNORDERED_SUB_TEST("Construct 9")
305     {
306       test::check_instances check_;
307 
308       test::random_values<T> v(100, generator);
309       T x(50);
310       BOOST_TEST(x.bucket_count() >= 50);
311       x.max_load_factor(10);
312       BOOST_TEST(x.bucket_count() >= 50);
313       x.insert(v.begin(), v.end());
314       BOOST_TEST(x.bucket_count() >= 50);
315       test::check_container(x, v);
316       test::check_equivalent_keys(x);
317     }
318 
319 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
320     std::initializer_list<typename T::value_type> list;
321 
322     UNORDERED_SUB_TEST("Initializer list construct 1")
323     {
324       test::check_instances check_;
325 
326       T x(list);
327       BOOST_TEST(x.empty());
328       BOOST_TEST(test::equivalent(x.hash_function(), hf));
329       BOOST_TEST(test::equivalent(x.key_eq(), eq));
330       BOOST_TEST(test::equivalent(x.get_allocator(), al));
331     }
332 
333     UNORDERED_SUB_TEST("Initializer list construct 2")
334     {
335       test::check_instances check_;
336 
337       T x(list, 1000);
338       BOOST_TEST(x.empty());
339       BOOST_TEST(x.bucket_count() >= 1000);
340       BOOST_TEST(test::equivalent(x.hash_function(), hf));
341       BOOST_TEST(test::equivalent(x.key_eq(), eq));
342       BOOST_TEST(test::equivalent(x.get_allocator(), al));
343     }
344 
345     UNORDERED_SUB_TEST("Initializer list construct 3")
346     {
347       test::check_instances check_;
348 
349       T x(list, 10, hf1);
350       BOOST_TEST(x.empty());
351       BOOST_TEST(x.bucket_count() >= 10);
352       BOOST_TEST(test::equivalent(x.hash_function(), hf1));
353       BOOST_TEST(test::equivalent(x.key_eq(), eq));
354       BOOST_TEST(test::equivalent(x.get_allocator(), al));
355     }
356 
357     UNORDERED_SUB_TEST("Initializer list construct 4")
358     {
359       test::check_instances check_;
360 
361       T x(list, 10, hf1, eq1);
362       BOOST_TEST(x.empty());
363       BOOST_TEST(x.bucket_count() >= 10);
364       BOOST_TEST(test::equivalent(x.hash_function(), hf1));
365       BOOST_TEST(test::equivalent(x.key_eq(), eq1));
366       BOOST_TEST(test::equivalent(x.get_allocator(), al));
367     }
368 
369     UNORDERED_SUB_TEST("Initializer list construct 5")
370     {
371       test::check_instances check_;
372 
373       T x(list, 10, hf1, eq1, al1);
374       BOOST_TEST(x.empty());
375       BOOST_TEST(x.bucket_count() >= 10);
376       BOOST_TEST(test::equivalent(x.hash_function(), hf1));
377       BOOST_TEST(test::equivalent(x.key_eq(), eq1));
378       BOOST_TEST(test::equivalent(x.get_allocator(), al1));
379     }
380 #endif
381   }
382 
383   template <class T>
map_constructor_test(T *,test::random_generator const & generator)384   void map_constructor_test(T*, test::random_generator const& generator)
385   {
386     typedef test::list<
387       std::pair<typename T::key_type, typename T::mapped_type> >
388       list;
389     test::random_values<T> v(1000, generator);
390     list l(v.begin(), v.end());
391     T x(l.begin(), l.end());
392 
393     test::check_container(x, v);
394     test::check_equivalent_keys(x);
395   }
396 
397   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
398     std::allocator<test::object> >* test_map_std_alloc;
399 
400   boost::unordered_set<test::object, test::hash, test::equal_to,
401     test::allocator1<test::object> >* test_set;
402   boost::unordered_multiset<test::object, test::hash, test::equal_to,
403     test::allocator2<test::object> >* test_multiset;
404   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
405     test::allocator2<test::object> >* test_map;
406   boost::unordered_multimap<test::object, test::object, test::hash,
407     test::equal_to, test::allocator1<test::object> >* test_multimap;
408 
409   using test::default_generator;
410   using test::generate_collisions;
411   using test::limited_range;
412 
413   UNORDERED_TEST(constructor_tests1,
414     ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
415       (default_generator)(generate_collisions)(limited_range)))
416 
417   UNORDERED_TEST(constructor_tests2,
418     ((test_set)(test_multiset)(test_map)(test_multimap))(
419       (default_generator)(generate_collisions)(limited_range)))
420 
421   UNORDERED_TEST(map_constructor_test,
422     ((test_map_std_alloc)(test_map)(test_multimap))(
423       (default_generator)(generate_collisions)(limited_range)))
424 
425 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
426 
UNORDERED_AUTO_TEST(test_default_initializer_list)427   UNORDERED_AUTO_TEST (test_default_initializer_list) {
428     std::initializer_list<int> init;
429     boost::unordered_set<int> x1 = init;
430     BOOST_TEST(x1.empty());
431   }
432 
433 #endif
434 
435 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
436 
UNORDERED_AUTO_TEST(test_initializer_list)437   UNORDERED_AUTO_TEST (test_initializer_list) {
438     boost::unordered_set<int> x1 = {2, 10, 45, -5};
439     BOOST_TEST(x1.find(10) != x1.end());
440     BOOST_TEST(x1.find(46) == x1.end());
441   }
442 
443 #endif
444 }
445 
446 RUN_TESTS_QUIET()
447