1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // <unordered_map>
11 
12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
13 //           class Alloc = allocator<pair<const Key, T>>>
14 // class unordered_multimap
15 
16 // template <class InputIterator>
17 //     unordered_multimap(InputIterator first, InputIterator last);
18 
19 #include <unordered_map>
20 #include <string>
21 #include <cassert>
22 #include <cfloat>
23 
24 #include "test_iterators.h"
25 #include "../../../NotConstructible.h"
26 #include "../../../test_compare.h"
27 #include "../../../test_hash.h"
28 #include "../../../test_allocator.h"
29 #include "../../../min_allocator.h"
30 
31 int main()
32 {
33     {
34         typedef std::unordered_multimap<int, std::string,
35                                    test_hash<std::hash<int> >,
36                                    test_compare<std::equal_to<int> >,
37                                    test_allocator<std::pair<const int, std::string> >
38                                    > C;
39         typedef std::pair<int, std::string> P;
40         P a[] =
41         {
42             P(1, "one"),
43             P(2, "two"),
44             P(3, "three"),
45             P(4, "four"),
46             P(1, "four"),
47             P(2, "four"),
48         };
49         C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
50         assert(c.bucket_count() >= 7);
51         assert(c.size() == 6);
52         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
53         Eq eq = c.equal_range(1);
54         assert(std::distance(eq.first, eq.second) == 2);
55         C::const_iterator i = eq.first;
56         assert(i->first == 1);
57         assert(i->second == "one");
58         ++i;
59         assert(i->first == 1);
60         assert(i->second == "four");
61         eq = c.equal_range(2);
62         assert(std::distance(eq.first, eq.second) == 2);
63         i = eq.first;
64         assert(i->first == 2);
65         assert(i->second == "two");
66         ++i;
67         assert(i->first == 2);
68         assert(i->second == "four");
69 
70         eq = c.equal_range(3);
71         assert(std::distance(eq.first, eq.second) == 1);
72         i = eq.first;
73         assert(i->first == 3);
74         assert(i->second == "three");
75         eq = c.equal_range(4);
76         assert(std::distance(eq.first, eq.second) == 1);
77         i = eq.first;
78         assert(i->first == 4);
79         assert(i->second == "four");
80         assert(std::distance(c.begin(), c.end()) == c.size());
81         assert(std::distance(c.cbegin(), c.cend()) == c.size());
82         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
83         assert(c.max_load_factor() == 1);
84         assert(c.hash_function() == test_hash<std::hash<int> >());
85         assert(c.key_eq() == test_compare<std::equal_to<int> >());
86         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
87     }
88 #if __cplusplus >= 201103L
89     {
90         typedef std::unordered_multimap<int, std::string,
91                                    test_hash<std::hash<int> >,
92                                    test_compare<std::equal_to<int> >,
93                                    min_allocator<std::pair<const int, std::string> >
94                                    > C;
95         typedef std::pair<int, std::string> P;
96         P a[] =
97         {
98             P(1, "one"),
99             P(2, "two"),
100             P(3, "three"),
101             P(4, "four"),
102             P(1, "four"),
103             P(2, "four"),
104         };
105         C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
106         assert(c.bucket_count() >= 7);
107         assert(c.size() == 6);
108         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
109         Eq eq = c.equal_range(1);
110         assert(std::distance(eq.first, eq.second) == 2);
111         C::const_iterator i = eq.first;
112         assert(i->first == 1);
113         assert(i->second == "one");
114         ++i;
115         assert(i->first == 1);
116         assert(i->second == "four");
117         eq = c.equal_range(2);
118         assert(std::distance(eq.first, eq.second) == 2);
119         i = eq.first;
120         assert(i->first == 2);
121         assert(i->second == "two");
122         ++i;
123         assert(i->first == 2);
124         assert(i->second == "four");
125 
126         eq = c.equal_range(3);
127         assert(std::distance(eq.first, eq.second) == 1);
128         i = eq.first;
129         assert(i->first == 3);
130         assert(i->second == "three");
131         eq = c.equal_range(4);
132         assert(std::distance(eq.first, eq.second) == 1);
133         i = eq.first;
134         assert(i->first == 4);
135         assert(i->second == "four");
136         assert(std::distance(c.begin(), c.end()) == c.size());
137         assert(std::distance(c.cbegin(), c.cend()) == c.size());
138         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
139         assert(c.max_load_factor() == 1);
140         assert(c.hash_function() == test_hash<std::hash<int> >());
141         assert(c.key_eq() == test_compare<std::equal_to<int> >());
142         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
143     }
144 #if _LIBCPP_STD_VER > 11
145     {
146         typedef std::pair<int, std::string> P;
147         typedef test_allocator<std::pair<const int, std::string>> A;
148         typedef test_hash<std::hash<int>> HF;
149         typedef test_compare<std::equal_to<int>> Comp;
150         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
151 
152         P arr[] =
153         {
154             P(1, "one"),
155             P(2, "two"),
156             P(3, "three"),
157             P(4, "four"),
158             P(1, "four"),
159             P(2, "four"),
160         };
161          A a(42);
162        C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a);
163         assert(c.bucket_count() >= 14);
164         assert(c.size() == 6);
165         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
166         Eq eq = c.equal_range(1);
167         assert(std::distance(eq.first, eq.second) == 2);
168         C::const_iterator i = eq.first;
169         assert(i->first == 1);
170         assert(i->second == "one");
171         ++i;
172         assert(i->first == 1);
173         assert(i->second == "four");
174         eq = c.equal_range(2);
175         assert(std::distance(eq.first, eq.second) == 2);
176         i = eq.first;
177         assert(i->first == 2);
178         assert(i->second == "two");
179         ++i;
180         assert(i->first == 2);
181         assert(i->second == "four");
182 
183         eq = c.equal_range(3);
184         assert(std::distance(eq.first, eq.second) == 1);
185         i = eq.first;
186         assert(i->first == 3);
187         assert(i->second == "three");
188         eq = c.equal_range(4);
189         assert(std::distance(eq.first, eq.second) == 1);
190         i = eq.first;
191         assert(i->first == 4);
192         assert(i->second == "four");
193         assert(std::distance(c.begin(), c.end()) == c.size());
194         assert(std::distance(c.cbegin(), c.cend()) == c.size());
195         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
196         assert(c.max_load_factor() == 1);
197         assert(c.hash_function() == HF());
198         assert(c.key_eq() == Comp());
199         assert(c.get_allocator() == a);
200         assert(!(c.get_allocator() == A()));
201     }
202     {
203         typedef std::pair<int, std::string> P;
204         typedef test_allocator<std::pair<const int, std::string>> A;
205         typedef test_hash<std::hash<int>> HF;
206         typedef test_compare<std::equal_to<int>> Comp;
207         typedef std::unordered_multimap<int, std::string, HF, Comp, A> C;
208 
209         P arr[] =
210         {
211             P(1, "one"),
212             P(2, "two"),
213             P(3, "three"),
214             P(4, "four"),
215             P(1, "four"),
216             P(2, "four"),
217         };
218         A a(42);
219         HF hf (43);
220         C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a );
221         assert(c.bucket_count() >= 12);
222         assert(c.size() == 6);
223         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
224         Eq eq = c.equal_range(1);
225         assert(std::distance(eq.first, eq.second) == 2);
226         C::const_iterator i = eq.first;
227         assert(i->first == 1);
228         assert(i->second == "one");
229         ++i;
230         assert(i->first == 1);
231         assert(i->second == "four");
232         eq = c.equal_range(2);
233         assert(std::distance(eq.first, eq.second) == 2);
234         i = eq.first;
235         assert(i->first == 2);
236         assert(i->second == "two");
237         ++i;
238         assert(i->first == 2);
239         assert(i->second == "four");
240 
241         eq = c.equal_range(3);
242         assert(std::distance(eq.first, eq.second) == 1);
243         i = eq.first;
244         assert(i->first == 3);
245         assert(i->second == "three");
246         eq = c.equal_range(4);
247         assert(std::distance(eq.first, eq.second) == 1);
248         i = eq.first;
249         assert(i->first == 4);
250         assert(i->second == "four");
251         assert(std::distance(c.begin(), c.end()) == c.size());
252         assert(std::distance(c.cbegin(), c.cend()) == c.size());
253         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
254         assert(c.max_load_factor() == 1);
255         assert(c.hash_function() == hf);
256         assert(!(c.hash_function() == HF()));
257         assert(c.key_eq() == Comp());
258         assert(c.get_allocator() == a);
259         assert(!(c.get_allocator() == A()));
260     }
261 #endif
262 #endif
263 }
264