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// size_type erase(const key_type& k);
17
18#include <unordered_map>
19#include <string>
20#include <cassert>
21
22#include "../../../min_allocator.h"
23
24int main()
25{
26    {
27        typedef std::unordered_multimap<int, std::string> C;
28        typedef std::pair<int, std::string> P;
29        P a[] =
30        {
31            P(1, "one"),
32            P(2, "two"),
33            P(3, "three"),
34            P(4, "four"),
35            P(1, "four"),
36            P(2, "four"),
37        };
38        C c(a, a + sizeof(a)/sizeof(a[0]));
39        assert(c.erase(5) == 0);
40        assert(c.size() == 6);
41        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
42        Eq eq = c.equal_range(1);
43        assert(std::distance(eq.first, eq.second) == 2);
44        C::const_iterator k = eq.first;
45        assert(k->first == 1);
46        assert(k->second == "one");
47        ++k;
48        assert(k->first == 1);
49        assert(k->second == "four");
50        eq = c.equal_range(2);
51        assert(std::distance(eq.first, eq.second) == 2);
52        k = eq.first;
53        assert(k->first == 2);
54        assert(k->second == "two");
55        ++k;
56        assert(k->first == 2);
57        assert(k->second == "four");
58        eq = c.equal_range(3);
59        assert(std::distance(eq.first, eq.second) == 1);
60        k = eq.first;
61        assert(k->first == 3);
62        assert(k->second == "three");
63        eq = c.equal_range(4);
64        assert(std::distance(eq.first, eq.second) == 1);
65        k = eq.first;
66        assert(k->first == 4);
67        assert(k->second == "four");
68        assert(std::distance(c.begin(), c.end()) == c.size());
69        assert(std::distance(c.cbegin(), c.cend()) == c.size());
70
71        assert(c.erase(2) == 2);
72        assert(c.size() == 4);
73        eq = c.equal_range(1);
74        assert(std::distance(eq.first, eq.second) == 2);
75        k = eq.first;
76        assert(k->first == 1);
77        assert(k->second == "one");
78        ++k;
79        assert(k->first == 1);
80        assert(k->second == "four");
81        eq = c.equal_range(3);
82        assert(std::distance(eq.first, eq.second) == 1);
83        k = eq.first;
84        assert(k->first == 3);
85        assert(k->second == "three");
86        eq = c.equal_range(4);
87        assert(std::distance(eq.first, eq.second) == 1);
88        k = eq.first;
89        assert(k->first == 4);
90        assert(k->second == "four");
91        assert(std::distance(c.begin(), c.end()) == c.size());
92        assert(std::distance(c.cbegin(), c.cend()) == c.size());
93
94        assert(c.erase(2) == 0);
95        assert(c.size() == 4);
96        eq = c.equal_range(1);
97        assert(std::distance(eq.first, eq.second) == 2);
98        k = eq.first;
99        assert(k->first == 1);
100        assert(k->second == "one");
101        ++k;
102        assert(k->first == 1);
103        assert(k->second == "four");
104        eq = c.equal_range(3);
105        assert(std::distance(eq.first, eq.second) == 1);
106        k = eq.first;
107        assert(k->first == 3);
108        assert(k->second == "three");
109        eq = c.equal_range(4);
110        assert(std::distance(eq.first, eq.second) == 1);
111        k = eq.first;
112        assert(k->first == 4);
113        assert(k->second == "four");
114        assert(std::distance(c.begin(), c.end()) == c.size());
115        assert(std::distance(c.cbegin(), c.cend()) == c.size());
116
117        assert(c.erase(4) == 1);
118        assert(c.size() == 3);
119        eq = c.equal_range(1);
120        assert(std::distance(eq.first, eq.second) == 2);
121        k = eq.first;
122        assert(k->first == 1);
123        assert(k->second == "one");
124        ++k;
125        assert(k->first == 1);
126        assert(k->second == "four");
127        eq = c.equal_range(3);
128        assert(std::distance(eq.first, eq.second) == 1);
129        k = eq.first;
130        assert(k->first == 3);
131        assert(k->second == "three");
132        assert(std::distance(c.begin(), c.end()) == c.size());
133        assert(std::distance(c.cbegin(), c.cend()) == c.size());
134
135        assert(c.erase(4) == 0);
136        assert(c.size() == 3);
137        eq = c.equal_range(1);
138        assert(std::distance(eq.first, eq.second) == 2);
139        k = eq.first;
140        assert(k->first == 1);
141        assert(k->second == "one");
142        ++k;
143        assert(k->first == 1);
144        assert(k->second == "four");
145        eq = c.equal_range(3);
146        assert(std::distance(eq.first, eq.second) == 1);
147        k = eq.first;
148        assert(k->first == 3);
149        assert(k->second == "three");
150        assert(std::distance(c.begin(), c.end()) == c.size());
151        assert(std::distance(c.cbegin(), c.cend()) == c.size());
152
153        assert(c.erase(1) == 2);
154        assert(c.size() == 1);
155        eq = c.equal_range(3);
156        assert(std::distance(eq.first, eq.second) == 1);
157        k = eq.first;
158        assert(k->first == 3);
159        assert(k->second == "three");
160        assert(std::distance(c.begin(), c.end()) == c.size());
161        assert(std::distance(c.cbegin(), c.cend()) == c.size());
162
163        assert(c.erase(1) == 0);
164        assert(c.size() == 1);
165        eq = c.equal_range(3);
166        assert(std::distance(eq.first, eq.second) == 1);
167        k = eq.first;
168        assert(k->first == 3);
169        assert(k->second == "three");
170        assert(std::distance(c.begin(), c.end()) == c.size());
171        assert(std::distance(c.cbegin(), c.cend()) == c.size());
172
173        assert(c.erase(3) == 1);
174        assert(c.size() == 0);
175        eq = c.equal_range(3);
176        assert(std::distance(eq.first, eq.second) == 0);
177        assert(std::distance(c.begin(), c.end()) == c.size());
178        assert(std::distance(c.cbegin(), c.cend()) == c.size());
179
180        assert(c.erase(3) == 0);
181        assert(c.size() == 0);
182        eq = c.equal_range(3);
183        assert(std::distance(eq.first, eq.second) == 0);
184        assert(std::distance(c.begin(), c.end()) == c.size());
185        assert(std::distance(c.cbegin(), c.cend()) == c.size());
186    }
187#if __cplusplus >= 201103L
188    {
189        typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
190                            min_allocator<std::pair<const int, std::string>>> C;
191        typedef std::pair<int, std::string> P;
192        P a[] =
193        {
194            P(1, "one"),
195            P(2, "two"),
196            P(3, "three"),
197            P(4, "four"),
198            P(1, "four"),
199            P(2, "four"),
200        };
201        C c(a, a + sizeof(a)/sizeof(a[0]));
202        assert(c.erase(5) == 0);
203        assert(c.size() == 6);
204        typedef std::pair<C::const_iterator, C::const_iterator> Eq;
205        Eq eq = c.equal_range(1);
206        assert(std::distance(eq.first, eq.second) == 2);
207        C::const_iterator k = eq.first;
208        assert(k->first == 1);
209        assert(k->second == "one");
210        ++k;
211        assert(k->first == 1);
212        assert(k->second == "four");
213        eq = c.equal_range(2);
214        assert(std::distance(eq.first, eq.second) == 2);
215        k = eq.first;
216        assert(k->first == 2);
217        assert(k->second == "two");
218        ++k;
219        assert(k->first == 2);
220        assert(k->second == "four");
221        eq = c.equal_range(3);
222        assert(std::distance(eq.first, eq.second) == 1);
223        k = eq.first;
224        assert(k->first == 3);
225        assert(k->second == "three");
226        eq = c.equal_range(4);
227        assert(std::distance(eq.first, eq.second) == 1);
228        k = eq.first;
229        assert(k->first == 4);
230        assert(k->second == "four");
231        assert(std::distance(c.begin(), c.end()) == c.size());
232        assert(std::distance(c.cbegin(), c.cend()) == c.size());
233
234        assert(c.erase(2) == 2);
235        assert(c.size() == 4);
236        eq = c.equal_range(1);
237        assert(std::distance(eq.first, eq.second) == 2);
238        k = eq.first;
239        assert(k->first == 1);
240        assert(k->second == "one");
241        ++k;
242        assert(k->first == 1);
243        assert(k->second == "four");
244        eq = c.equal_range(3);
245        assert(std::distance(eq.first, eq.second) == 1);
246        k = eq.first;
247        assert(k->first == 3);
248        assert(k->second == "three");
249        eq = c.equal_range(4);
250        assert(std::distance(eq.first, eq.second) == 1);
251        k = eq.first;
252        assert(k->first == 4);
253        assert(k->second == "four");
254        assert(std::distance(c.begin(), c.end()) == c.size());
255        assert(std::distance(c.cbegin(), c.cend()) == c.size());
256
257        assert(c.erase(2) == 0);
258        assert(c.size() == 4);
259        eq = c.equal_range(1);
260        assert(std::distance(eq.first, eq.second) == 2);
261        k = eq.first;
262        assert(k->first == 1);
263        assert(k->second == "one");
264        ++k;
265        assert(k->first == 1);
266        assert(k->second == "four");
267        eq = c.equal_range(3);
268        assert(std::distance(eq.first, eq.second) == 1);
269        k = eq.first;
270        assert(k->first == 3);
271        assert(k->second == "three");
272        eq = c.equal_range(4);
273        assert(std::distance(eq.first, eq.second) == 1);
274        k = eq.first;
275        assert(k->first == 4);
276        assert(k->second == "four");
277        assert(std::distance(c.begin(), c.end()) == c.size());
278        assert(std::distance(c.cbegin(), c.cend()) == c.size());
279
280        assert(c.erase(4) == 1);
281        assert(c.size() == 3);
282        eq = c.equal_range(1);
283        assert(std::distance(eq.first, eq.second) == 2);
284        k = eq.first;
285        assert(k->first == 1);
286        assert(k->second == "one");
287        ++k;
288        assert(k->first == 1);
289        assert(k->second == "four");
290        eq = c.equal_range(3);
291        assert(std::distance(eq.first, eq.second) == 1);
292        k = eq.first;
293        assert(k->first == 3);
294        assert(k->second == "three");
295        assert(std::distance(c.begin(), c.end()) == c.size());
296        assert(std::distance(c.cbegin(), c.cend()) == c.size());
297
298        assert(c.erase(4) == 0);
299        assert(c.size() == 3);
300        eq = c.equal_range(1);
301        assert(std::distance(eq.first, eq.second) == 2);
302        k = eq.first;
303        assert(k->first == 1);
304        assert(k->second == "one");
305        ++k;
306        assert(k->first == 1);
307        assert(k->second == "four");
308        eq = c.equal_range(3);
309        assert(std::distance(eq.first, eq.second) == 1);
310        k = eq.first;
311        assert(k->first == 3);
312        assert(k->second == "three");
313        assert(std::distance(c.begin(), c.end()) == c.size());
314        assert(std::distance(c.cbegin(), c.cend()) == c.size());
315
316        assert(c.erase(1) == 2);
317        assert(c.size() == 1);
318        eq = c.equal_range(3);
319        assert(std::distance(eq.first, eq.second) == 1);
320        k = eq.first;
321        assert(k->first == 3);
322        assert(k->second == "three");
323        assert(std::distance(c.begin(), c.end()) == c.size());
324        assert(std::distance(c.cbegin(), c.cend()) == c.size());
325
326        assert(c.erase(1) == 0);
327        assert(c.size() == 1);
328        eq = c.equal_range(3);
329        assert(std::distance(eq.first, eq.second) == 1);
330        k = eq.first;
331        assert(k->first == 3);
332        assert(k->second == "three");
333        assert(std::distance(c.begin(), c.end()) == c.size());
334        assert(std::distance(c.cbegin(), c.cend()) == c.size());
335
336        assert(c.erase(3) == 1);
337        assert(c.size() == 0);
338        eq = c.equal_range(3);
339        assert(std::distance(eq.first, eq.second) == 0);
340        assert(std::distance(c.begin(), c.end()) == c.size());
341        assert(std::distance(c.cbegin(), c.cend()) == c.size());
342
343        assert(c.erase(3) == 0);
344        assert(c.size() == 0);
345        eq = c.equal_range(3);
346        assert(std::distance(eq.first, eq.second) == 0);
347        assert(std::distance(c.begin(), c.end()) == c.size());
348        assert(std::distance(c.cbegin(), c.cend()) == c.size());
349    }
350#endif
351}
352