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