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// unordered_multimap& operator=(const unordered_multimap& u);
17
18#include <unordered_map>
19#include <string>
20#include <cassert>
21#include <cfloat>
22#include <cstddef>
23
24#include "test_macros.h"
25#include "../../../test_compare.h"
26#include "../../../test_hash.h"
27#include "test_allocator.h"
28#include "min_allocator.h"
29
30int main()
31{
32    {
33        typedef test_allocator<std::pair<const int, std::string> > A;
34        typedef std::unordered_multimap<int, std::string,
35                                   test_hash<std::hash<int> >,
36                                   test_compare<std::equal_to<int> >,
37                                   A
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 c0(a, a + sizeof(a)/sizeof(a[0]),
50            7,
51            test_hash<std::hash<int> >(8),
52            test_compare<std::equal_to<int> >(9),
53            A(10)
54           );
55        C c(a, a + 2,
56            7,
57            test_hash<std::hash<int> >(2),
58            test_compare<std::equal_to<int> >(3),
59            A(4)
60           );
61        c = c0;
62        LIBCPP_ASSERT(c.bucket_count() == 7);
63        assert(c.size() == 6);
64        C::const_iterator i = c.cbegin();
65        assert(i->first == 1);
66        assert(i->second == "one");
67        ++i;
68        assert(i->first == 1);
69        assert(i->second == "four");
70        ++i;
71        assert(i->first == 2);
72        assert(i->second == "two");
73        ++i;
74        assert(i->first == 2);
75        assert(i->second == "four");
76        ++i;
77        assert(i->first == 3);
78        assert(i->second == "three");
79        ++i;
80        assert(i->first == 4);
81        assert(i->second == "four");
82        assert(c.hash_function() == test_hash<std::hash<int> >(8));
83        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
84        assert(c.get_allocator() == A(4));
85        assert(!c.empty());
86        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
87        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
88        assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
89        assert(c.max_load_factor() == 1);
90    }
91    {
92        typedef std::unordered_multimap<int, std::string> C;
93        typedef std::pair<const int, std::string> P;
94        const P a[] =
95        {
96            P(1, "one"),
97            P(2, "two"),
98            P(3, "three"),
99            P(4, "four"),
100            P(1, "four"),
101            P(2, "four"),
102        };
103        C c(a, a+sizeof(a)/sizeof(a[0]));
104        C *p = &c;
105        c = *p;
106        assert(c.size() == 6);
107        assert(std::is_permutation(c.begin(), c.end(), a));
108    }
109    {
110        typedef other_allocator<std::pair<const int, std::string> > A;
111        typedef std::unordered_multimap<int, std::string,
112                                   test_hash<std::hash<int> >,
113                                   test_compare<std::equal_to<int> >,
114                                   A
115                                   > C;
116        typedef std::pair<int, std::string> P;
117        P a[] =
118        {
119            P(1, "one"),
120            P(2, "two"),
121            P(3, "three"),
122            P(4, "four"),
123            P(1, "four"),
124            P(2, "four"),
125        };
126        C c0(a, a + sizeof(a)/sizeof(a[0]),
127            7,
128            test_hash<std::hash<int> >(8),
129            test_compare<std::equal_to<int> >(9),
130            A(10)
131           );
132        C c(a, a + 2,
133            7,
134            test_hash<std::hash<int> >(2),
135            test_compare<std::equal_to<int> >(3),
136            A(4)
137           );
138        c = c0;
139        assert(c.bucket_count() >= 7);
140        assert(c.size() == 6);
141        C::const_iterator i = c.cbegin();
142        assert(i->first == 1);
143        assert(i->second == "one");
144        ++i;
145        assert(i->first == 1);
146        assert(i->second == "four");
147        ++i;
148        assert(i->first == 2);
149        assert(i->second == "two");
150        ++i;
151        assert(i->first == 2);
152        assert(i->second == "four");
153        ++i;
154        assert(i->first == 3);
155        assert(i->second == "three");
156        ++i;
157        assert(i->first == 4);
158        assert(i->second == "four");
159        assert(c.hash_function() == test_hash<std::hash<int> >(8));
160        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
161        assert(c.get_allocator() == A(10));
162        assert(!c.empty());
163        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
164        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
165        assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
166        assert(c.max_load_factor() == 1);
167    }
168#if TEST_STD_VER >= 11
169    {
170        typedef min_allocator<std::pair<const int, std::string> > A;
171        typedef std::unordered_multimap<int, std::string,
172                                   test_hash<std::hash<int> >,
173                                   test_compare<std::equal_to<int> >,
174                                   A
175                                   > C;
176        typedef std::pair<int, std::string> P;
177        P a[] =
178        {
179            P(1, "one"),
180            P(2, "two"),
181            P(3, "three"),
182            P(4, "four"),
183            P(1, "four"),
184            P(2, "four"),
185        };
186        C c0(a, a + sizeof(a)/sizeof(a[0]),
187            7,
188            test_hash<std::hash<int> >(8),
189            test_compare<std::equal_to<int> >(9),
190            A()
191           );
192        C c(a, a + 2,
193            7,
194            test_hash<std::hash<int> >(2),
195            test_compare<std::equal_to<int> >(3),
196            A()
197           );
198        c = c0;
199        LIBCPP_ASSERT(c.bucket_count() == 7);
200        assert(c.size() == 6);
201        C::const_iterator i = c.cbegin();
202        assert(i->first == 1);
203        assert(i->second == "one");
204        ++i;
205        assert(i->first == 1);
206        assert(i->second == "four");
207        ++i;
208        assert(i->first == 2);
209        assert(i->second == "two");
210        ++i;
211        assert(i->first == 2);
212        assert(i->second == "four");
213        ++i;
214        assert(i->first == 3);
215        assert(i->second == "three");
216        ++i;
217        assert(i->first == 4);
218        assert(i->second == "four");
219        assert(c.hash_function() == test_hash<std::hash<int> >(8));
220        assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
221        assert(c.get_allocator() == A());
222        assert(!c.empty());
223        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
224        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
225        assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
226        assert(c.max_load_factor() == 1);
227    }
228#endif
229}
230