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