1 
2 // Copyright 2006-2009 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 // This test creates the containers with members that meet their minimum
7 // requirements. Makes sure everything compiles and is defined correctly.
8 
9 // clang-format off
10 #include "../helpers/prefix.hpp"
11 #include <boost/unordered_set.hpp>
12 #include "../helpers/postfix.hpp"
13 // clang-format on
14 
15 #include "../helpers/test.hpp"
16 #include "../objects/minimal.hpp"
17 #include "./compile_tests.hpp"
18 
19 // Explicit instantiation to catch compile-time errors
20 
21 #define INSTANTIATE(type)                                                      \
22   template class boost::unordered::detail::instantiate_##type
23 
24 INSTANTIATE(set)<int, boost::hash<int>, std::equal_to<int>,
25   test::minimal::allocator<int> >;
26 INSTANTIATE(multiset)<int const, boost::hash<int>, std::equal_to<int>,
27   test::minimal::allocator<int> >;
28 
29 INSTANTIATE(set)<test::minimal::assignable const,
30   test::minimal::hash<test::minimal::assignable>,
31   test::minimal::equal_to<test::minimal::assignable>,
32   test::minimal::allocator<int> >;
33 INSTANTIATE(multiset)<test::minimal::assignable,
34   test::minimal::hash<test::minimal::assignable>,
35   test::minimal::equal_to<test::minimal::assignable>,
36   test::minimal::allocator<int> >;
37 
UNORDERED_AUTO_TEST(test0)38 UNORDERED_AUTO_TEST (test0) {
39   test::minimal::constructor_param x;
40 
41   test::minimal::assignable assignable(x);
42 
43   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
44 
45   boost::unordered_set<int> int_set;
46 
47   boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
48     test::minimal::cxx11_allocator<int> >
49     int_set2;
50 
51   boost::unordered_set<test::minimal::assignable,
52     test::minimal::hash<test::minimal::assignable>,
53     test::minimal::equal_to<test::minimal::assignable>,
54     test::minimal::allocator<test::minimal::assignable> >
55     set;
56 
57   container_test(int_set, 0);
58   container_test(int_set2, 0);
59   container_test(set, assignable);
60 
61   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
62 
63   boost::unordered_multiset<int> int_multiset;
64 
65   boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
66     test::minimal::cxx11_allocator<int> >
67     int_multiset2;
68 
69   boost::unordered_multiset<test::minimal::assignable,
70     test::minimal::hash<test::minimal::assignable>,
71     test::minimal::equal_to<test::minimal::assignable>,
72     test::minimal::allocator<test::minimal::assignable> >
73     multiset;
74 
75   container_test(int_multiset, 0);
76   container_test(int_multiset2, 0);
77   container_test(multiset, assignable);
78 }
79 
UNORDERED_AUTO_TEST(equality_tests)80 UNORDERED_AUTO_TEST (equality_tests) {
81   typedef test::minimal::copy_constructible_equality_comparable value_type;
82 
83   boost::unordered_set<int> int_set;
84 
85   boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
86     test::minimal::cxx11_allocator<int> >
87     int_set2;
88 
89   boost::unordered_set<test::minimal::copy_constructible_equality_comparable,
90     test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
91     test::minimal::equal_to<
92       test::minimal::copy_constructible_equality_comparable>,
93     test::minimal::allocator<value_type> >
94     set;
95 
96   equality_test(int_set);
97   equality_test(int_set2);
98   equality_test(set);
99 
100   boost::unordered_multiset<int> int_multiset;
101 
102   boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
103     test::minimal::cxx11_allocator<int> >
104     int_multiset2;
105 
106   boost::unordered_multiset<
107     test::minimal::copy_constructible_equality_comparable,
108     test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
109     test::minimal::equal_to<
110       test::minimal::copy_constructible_equality_comparable>,
111     test::minimal::allocator<value_type> >
112     multiset;
113 
114   equality_test(int_multiset);
115   equality_test(int_multiset2);
116   equality_test(multiset);
117 }
118 
UNORDERED_AUTO_TEST(test1)119 UNORDERED_AUTO_TEST (test1) {
120   boost::hash<int> hash;
121   std::equal_to<int> equal_to;
122   int value = 0;
123 
124   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl;
125 
126   boost::unordered_set<int> set;
127 
128   boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
129     test::minimal::cxx11_allocator<int> >
130     set2;
131 
132   unordered_unique_test(set, value);
133   unordered_set_test(set, value);
134   unordered_copyable_test(set, value, value, hash, equal_to);
135 
136   unordered_unique_test(set2, value);
137   unordered_set_test(set2, value);
138   unordered_copyable_test(set2, value, value, hash, equal_to);
139 
140   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
141 
142   boost::unordered_multiset<int> multiset;
143 
144   boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
145     test::minimal::cxx11_allocator<int> >
146     multiset2;
147 
148   unordered_equivalent_test(multiset, value);
149   unordered_set_test(multiset, value);
150   unordered_copyable_test(multiset, value, value, hash, equal_to);
151 
152   unordered_equivalent_test(multiset2, value);
153   unordered_set_test(multiset2, value);
154   unordered_copyable_test(multiset2, value, value, hash, equal_to);
155 }
156 
UNORDERED_AUTO_TEST(test2)157 UNORDERED_AUTO_TEST (test2) {
158   test::minimal::constructor_param x;
159 
160   test::minimal::assignable assignable(x);
161   test::minimal::copy_constructible copy_constructible(x);
162   test::minimal::hash<test::minimal::assignable> hash(x);
163   test::minimal::equal_to<test::minimal::assignable> equal_to(x);
164 
165   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
166 
167   boost::unordered_set<test::minimal::assignable,
168     test::minimal::hash<test::minimal::assignable>,
169     test::minimal::equal_to<test::minimal::assignable>,
170     test::minimal::allocator<test::minimal::assignable> >
171     set;
172 
173   unordered_unique_test(set, assignable);
174   unordered_set_test(set, assignable);
175   unordered_copyable_test(set, assignable, assignable, hash, equal_to);
176   unordered_set_member_test(set, assignable);
177 
178   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
179 
180   boost::unordered_multiset<test::minimal::assignable,
181     test::minimal::hash<test::minimal::assignable>,
182     test::minimal::equal_to<test::minimal::assignable>,
183     test::minimal::allocator<test::minimal::assignable> >
184     multiset;
185 
186   unordered_equivalent_test(multiset, assignable);
187   unordered_set_test(multiset, assignable);
188   unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
189   unordered_set_member_test(multiset, assignable);
190 }
191 
UNORDERED_AUTO_TEST(movable1_tests)192 UNORDERED_AUTO_TEST (movable1_tests) {
193   test::minimal::constructor_param x;
194 
195   test::minimal::movable1 movable1(x);
196   test::minimal::hash<test::minimal::movable1> hash(x);
197   test::minimal::equal_to<test::minimal::movable1> equal_to(x);
198 
199   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
200 
201   boost::unordered_set<test::minimal::movable1,
202     test::minimal::hash<test::minimal::movable1>,
203     test::minimal::equal_to<test::minimal::movable1>,
204     test::minimal::allocator<test::minimal::movable1> >
205     set;
206 
207   // unordered_unique_test(set, movable1);
208   unordered_set_test(set, movable1);
209   unordered_movable_test(set, movable1, movable1, hash, equal_to);
210 
211   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
212 
213   boost::unordered_multiset<test::minimal::movable1,
214     test::minimal::hash<test::minimal::movable1>,
215     test::minimal::equal_to<test::minimal::movable1>,
216     test::minimal::allocator<test::minimal::movable1> >
217     multiset;
218 
219   // unordered_equivalent_test(multiset, movable1);
220   unordered_set_test(multiset, movable1);
221   unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
222 }
223 
UNORDERED_AUTO_TEST(movable2_tests)224 UNORDERED_AUTO_TEST (movable2_tests) {
225   test::minimal::constructor_param x;
226 
227   test::minimal::movable2 movable2(x);
228   test::minimal::hash<test::minimal::movable2> hash(x);
229   test::minimal::equal_to<test::minimal::movable2> equal_to(x);
230 
231   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
232 
233   boost::unordered_set<test::minimal::movable2,
234     test::minimal::hash<test::minimal::movable2>,
235     test::minimal::equal_to<test::minimal::movable2>,
236     test::minimal::allocator<test::minimal::movable2> >
237     set;
238 
239   // unordered_unique_test(set, movable2);
240   unordered_set_test(set, movable2);
241   unordered_movable_test(set, movable2, movable2, hash, equal_to);
242 
243   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
244 
245   boost::unordered_multiset<test::minimal::movable2,
246     test::minimal::hash<test::minimal::movable2>,
247     test::minimal::equal_to<test::minimal::movable2>,
248     test::minimal::allocator<test::minimal::movable2> >
249     multiset;
250 
251   // unordered_equivalent_test(multiset, movable2);
252   unordered_set_test(multiset, movable2);
253   unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
254 }
255 
UNORDERED_AUTO_TEST(destructible_tests)256 UNORDERED_AUTO_TEST (destructible_tests) {
257   test::minimal::constructor_param x;
258 
259   test::minimal::destructible destructible(x);
260   test::minimal::hash<test::minimal::destructible> hash(x);
261   test::minimal::equal_to<test::minimal::destructible> equal_to(x);
262 
263   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
264 
265   boost::unordered_set<test::minimal::destructible,
266     test::minimal::hash<test::minimal::destructible>,
267     test::minimal::equal_to<test::minimal::destructible> >
268     set;
269 
270   unordered_destructible_test(set);
271 
272   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
273 
274   boost::unordered_multiset<test::minimal::destructible,
275     test::minimal::hash<test::minimal::destructible>,
276     test::minimal::equal_to<test::minimal::destructible> >
277     multiset;
278 
279   unordered_destructible_test(multiset);
280 }
281 
282 // Test for ambiguity when using key convertible from iterator
283 // See LWG2059
284 
285 struct lwg2059_key
286 {
287   int value;
288 
lwg2059_keylwg2059_key289   template <typename T> lwg2059_key(T v) : value(v) {}
290 };
291 
hash_value(lwg2059_key x)292 std::size_t hash_value(lwg2059_key x)
293 {
294   return static_cast<std::size_t>(x.value);
295 }
296 
operator ==(lwg2059_key x,lwg2059_key y)297 bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
298 
UNORDERED_AUTO_TEST(lwg2059)299 UNORDERED_AUTO_TEST (lwg2059) {
300   {
301     boost::unordered_set<lwg2059_key> x;
302     x.emplace(lwg2059_key(10));
303     x.erase(x.begin());
304   }
305 
306   {
307     boost::unordered_multiset<lwg2059_key> x;
308     x.emplace(lwg2059_key(10));
309     x.erase(x.begin());
310   }
311 }
312 
313 RUN_TESTS()
314