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 #include "../helpers/prefix.hpp"
10 #include <boost/unordered_map.hpp>
11 #include "../helpers/postfix.hpp"
12 
13 #include <iostream>
14 #include "../helpers/test.hpp"
15 #include "../objects/minimal.hpp"
16 #include "./compile_tests.hpp"
17 
18 // Explicit instantiation to catch compile-time errors
19 
20 template class boost::unordered_map<
21     int,
22     int,
23     boost::hash<int>,
24     std::equal_to<int>,
25     test::minimal::allocator<std::pair<int const, int> > >;
26 template class boost::unordered_multimap<
27     int,
28     int,
29     boost::hash<int>,
30     std::equal_to<int>,
31     test::minimal::allocator<std::pair<int const, int> > >;
32 
33 template class boost::unordered_map<
34     test::minimal::assignable,
35     test::minimal::default_assignable,
36     test::minimal::hash<test::minimal::assignable>,
37     test::minimal::equal_to<test::minimal::assignable>,
38     test::minimal::allocator<test::minimal::assignable> >;
39 template class boost::unordered_multimap<
40     test::minimal::assignable,
41     test::minimal::assignable,
42     test::minimal::hash<test::minimal::assignable>,
43     test::minimal::equal_to<test::minimal::assignable>,
44     test::minimal::allocator<test::minimal::assignable> >;
45 
UNORDERED_AUTO_TEST(test0)46 UNORDERED_AUTO_TEST(test0)
47 {
48     test::minimal::constructor_param x;
49 
50     typedef std::pair<test::minimal::assignable const,
51             test::minimal::assignable> value_type;
52     value_type value(x, x);
53 
54     std::cout<<"Test unordered_map.\n";
55 
56     boost::unordered_map<int, int> int_map;
57 
58     boost::unordered_map<int, int,
59         boost::hash<int>, std::equal_to<int>,
60         test::minimal::cxx11_allocator<std::pair<int const, int> >
61         > int_map2;
62 
63     boost::unordered_map<
64         test::minimal::assignable,
65         test::minimal::assignable,
66         test::minimal::hash<test::minimal::assignable>,
67         test::minimal::equal_to<test::minimal::assignable>,
68         test::minimal::allocator<value_type> > map;
69 
70     container_test(int_map, std::pair<int const, int>(0, 0));
71     container_test(int_map2, std::pair<int const, int>(0, 0));
72     container_test(map, value);
73 
74     std::cout<<"Test unordered_multimap.\n";
75 
76     boost::unordered_multimap<int, int> int_multimap;
77 
78     boost::unordered_multimap<int, int,
79         boost::hash<int>, std::equal_to<int>,
80         test::minimal::cxx11_allocator<std::pair<int const, int> >
81         > int_multimap2;
82 
83     boost::unordered_multimap<
84         test::minimal::assignable,
85         test::minimal::assignable,
86         test::minimal::hash<test::minimal::assignable>,
87         test::minimal::equal_to<test::minimal::assignable>,
88         test::minimal::allocator<value_type> > multimap;
89 
90     container_test(int_multimap, std::pair<int const, int>(0, 0));
91     container_test(int_multimap2, std::pair<int const, int>(0, 0));
92     container_test(multimap, value);
93 }
94 
UNORDERED_AUTO_TEST(equality_tests)95 UNORDERED_AUTO_TEST(equality_tests) {
96     typedef std::pair<
97             test::minimal::copy_constructible_equality_comparable const,
98             test::minimal::copy_constructible_equality_comparable> value_type;
99 
100     boost::unordered_map<int, int> int_map;
101 
102     boost::unordered_map<int, int,
103         boost::hash<int>, std::equal_to<int>,
104         test::minimal::cxx11_allocator<std::pair<int const, int> >
105         > int_map2;
106 
107     boost::unordered_map<
108         test::minimal::copy_constructible_equality_comparable,
109         test::minimal::copy_constructible_equality_comparable,
110         test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
111         test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
112         test::minimal::allocator<value_type> > map;
113 
114     equality_test(int_map);
115     equality_test(int_map2);
116     equality_test(map);
117 
118     boost::unordered_multimap<int, int> int_multimap;
119 
120     boost::unordered_multimap<int, int,
121         boost::hash<int>, std::equal_to<int>,
122         test::minimal::cxx11_allocator<std::pair<int const, int> >
123         > int_multimap2;
124 
125     boost::unordered_multimap<
126         test::minimal::copy_constructible_equality_comparable,
127         test::minimal::copy_constructible_equality_comparable,
128         test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
129         test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
130         test::minimal::allocator<value_type> > multimap;
131 
132     equality_test(int_multimap);
133     equality_test(int_multimap2);
134     equality_test(multimap);
135 }
136 
UNORDERED_AUTO_TEST(test1)137 UNORDERED_AUTO_TEST(test1) {
138     boost::hash<int> hash;
139     std::equal_to<int> equal_to;
140     int value = 0;
141     std::pair<int const, int> map_value(0, 0);
142 
143     std::cout<<"Test unordered_map.\n";
144 
145     boost::unordered_map<int, int> map;
146 
147     boost::unordered_map<int, int,
148         boost::hash<int>, std::equal_to<int>,
149         test::minimal::cxx11_allocator<std::pair<int const, int> >
150         > map2;
151 
152     unordered_unique_test(map, map_value);
153     unordered_map_test(map, value, value);
154     unordered_copyable_test(map, value, map_value, hash, equal_to);
155     unordered_map_functions(map, value, value);
156 
157     unordered_unique_test(map2, map_value);
158     unordered_map_test(map2, value, value);
159     unordered_copyable_test(map2, value, map_value, hash, equal_to);
160     unordered_map_functions(map2, value, value);
161 
162     std::cout<<"Test unordered_multimap.\n";
163 
164     boost::unordered_multimap<int, int> multimap;
165 
166     boost::unordered_multimap<int, int,
167         boost::hash<int>, std::equal_to<int>,
168         test::minimal::cxx11_allocator<std::pair<int const, int> >
169         > multimap2;
170 
171     unordered_equivalent_test(multimap, map_value);
172     unordered_map_test(multimap, value, value);
173     unordered_copyable_test(multimap, value, map_value, hash, equal_to);
174 
175     unordered_equivalent_test(multimap2, map_value);
176     unordered_map_test(multimap2, value, value);
177     unordered_copyable_test(multimap2, value, map_value, hash, equal_to);
178 }
179 
UNORDERED_AUTO_TEST(test2)180 UNORDERED_AUTO_TEST(test2)
181 {
182     test::minimal::constructor_param x;
183 
184     test::minimal::assignable assignable(x);
185     test::minimal::copy_constructible copy_constructible(x);
186     test::minimal::hash<test::minimal::assignable> hash(x);
187     test::minimal::equal_to<test::minimal::assignable> equal_to(x);
188 
189     typedef std::pair<test::minimal::assignable const,
190             test::minimal::assignable> map_value_type;
191     map_value_type map_value(assignable, assignable);
192 
193     std::cout<<"Test unordered_map.\n";
194 
195     boost::unordered_map<
196         test::minimal::assignable,
197         test::minimal::assignable,
198         test::minimal::hash<test::minimal::assignable>,
199         test::minimal::equal_to<test::minimal::assignable>,
200         test::minimal::allocator<map_value_type> > map;
201 
202     unordered_unique_test(map, map_value);
203     unordered_map_test(map, assignable, assignable);
204     unordered_copyable_test(map, assignable, map_value, hash, equal_to);
205     unordered_map_member_test(map, map_value);
206 
207     boost::unordered_map<
208         test::minimal::assignable,
209         test::minimal::default_assignable,
210         test::minimal::hash<test::minimal::assignable>,
211         test::minimal::equal_to<test::minimal::assignable>,
212         test::minimal::allocator<map_value_type> > map2;
213 
214     test::minimal::default_assignable default_assignable;
215 
216     unordered_map_functions(map2, assignable, default_assignable);
217 
218     std::cout<<"Test unordered_multimap.\n";
219 
220     boost::unordered_multimap<
221         test::minimal::assignable,
222         test::minimal::assignable,
223         test::minimal::hash<test::minimal::assignable>,
224         test::minimal::equal_to<test::minimal::assignable>,
225         test::minimal::allocator<map_value_type> > multimap;
226 
227     unordered_equivalent_test(multimap, map_value);
228     unordered_map_test(multimap, assignable, assignable);
229     unordered_copyable_test(multimap, assignable, map_value, hash, equal_to);
230     unordered_map_member_test(multimap, map_value);
231 }
232 
233 RUN_TESTS()
234