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