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// local_iterator       begin (size_type n);
17// local_iterator       end   (size_type n);
18// const_local_iterator begin (size_type n) const;
19// const_local_iterator end   (size_type n) const;
20// const_local_iterator cbegin(size_type n) const;
21// const_local_iterator cend  (size_type n) const;
22
23#include <unordered_map>
24#include <string>
25#include <cassert>
26
27#include "../../min_allocator.h"
28
29int main()
30{
31    {
32        typedef std::unordered_multimap<int, std::string> C;
33        typedef std::pair<int, std::string> P;
34        typedef C::local_iterator I;
35        P a[] =
36        {
37            P(1, "one"),
38            P(2, "two"),
39            P(3, "three"),
40            P(4, "four"),
41            P(1, "four"),
42            P(2, "four"),
43        };
44        C c(a, a + sizeof(a)/sizeof(a[0]));
45        assert(c.bucket_count() >= 7);
46        C::size_type b = c.bucket(0);
47        I i = c.begin(b);
48        I j = c.end(b);
49        assert(std::distance(i, j) == 0);
50
51        b = c.bucket(1);
52        i = c.begin(b);
53        j = c.end(b);
54        assert(std::distance(i, j) == 2);
55        assert(i->first == 1);
56        assert(i->second == "one");
57        ++i;
58        assert(i->first == 1);
59        assert(i->second == "four");
60
61        b = c.bucket(2);
62        i = c.begin(b);
63        j = c.end(b);
64        assert(std::distance(i, j) == 2);
65        assert(i->first == 2);
66        assert(i->second == "two");
67        ++i;
68        assert(i->first == 2);
69        assert(i->second == "four");
70
71        b = c.bucket(3);
72        i = c.begin(b);
73        j = c.end(b);
74        assert(std::distance(i, j) == 1);
75        assert(i->first == 3);
76        assert(i->second == "three");
77
78        b = c.bucket(4);
79        i = c.begin(b);
80        j = c.end(b);
81        assert(std::distance(i, j) == 1);
82        assert(i->first == 4);
83        assert(i->second == "four");
84
85        b = c.bucket(5);
86        i = c.begin(b);
87        j = c.end(b);
88        assert(std::distance(i, j) == 0);
89
90        b = c.bucket(6);
91        i = c.begin(b);
92        j = c.end(b);
93        assert(std::distance(i, j) == 0);
94    }
95    {
96        typedef std::unordered_multimap<int, std::string> C;
97        typedef std::pair<int, std::string> P;
98        typedef C::const_local_iterator I;
99        P a[] =
100        {
101            P(1, "one"),
102            P(2, "two"),
103            P(3, "three"),
104            P(4, "four"),
105            P(1, "four"),
106            P(2, "four"),
107        };
108        const C c(a, a + sizeof(a)/sizeof(a[0]));
109        assert(c.bucket_count() >= 7);
110        C::size_type b = c.bucket(0);
111        I i = c.begin(b);
112        I j = c.end(b);
113        assert(std::distance(i, j) == 0);
114
115        b = c.bucket(1);
116        i = c.begin(b);
117        j = c.end(b);
118        assert(std::distance(i, j) == 2);
119        assert(i->first == 1);
120        assert(i->second == "one");
121        ++i;
122        assert(i->first == 1);
123        assert(i->second == "four");
124
125        b = c.bucket(2);
126        i = c.begin(b);
127        j = c.end(b);
128        assert(std::distance(i, j) == 2);
129        assert(i->first == 2);
130        assert(i->second == "two");
131        ++i;
132        assert(i->first == 2);
133        assert(i->second == "four");
134
135        b = c.bucket(3);
136        i = c.begin(b);
137        j = c.end(b);
138        assert(std::distance(i, j) == 1);
139        assert(i->first == 3);
140        assert(i->second == "three");
141
142        b = c.bucket(4);
143        i = c.begin(b);
144        j = c.end(b);
145        assert(std::distance(i, j) == 1);
146        assert(i->first == 4);
147        assert(i->second == "four");
148
149        b = c.bucket(5);
150        i = c.begin(b);
151        j = c.end(b);
152        assert(std::distance(i, j) == 0);
153
154        b = c.bucket(6);
155        i = c.begin(b);
156        j = c.end(b);
157        assert(std::distance(i, j) == 0);
158    }
159    {
160        typedef std::unordered_multimap<int, std::string> C;
161        typedef std::pair<int, std::string> P;
162        typedef C::const_local_iterator I;
163        P a[] =
164        {
165            P(1, "one"),
166            P(2, "two"),
167            P(3, "three"),
168            P(4, "four"),
169            P(1, "four"),
170            P(2, "four"),
171        };
172        C c(a, a + sizeof(a)/sizeof(a[0]));
173        assert(c.bucket_count() >= 7);
174        C::size_type b = c.bucket(0);
175        I i = c.cbegin(b);
176        I j = c.cend(b);
177        assert(std::distance(i, j) == 0);
178
179        b = c.bucket(1);
180        i = c.cbegin(b);
181        j = c.cend(b);
182        assert(std::distance(i, j) == 2);
183        assert(i->first == 1);
184        assert(i->second == "one");
185        ++i;
186        assert(i->first == 1);
187        assert(i->second == "four");
188
189        b = c.bucket(2);
190        i = c.cbegin(b);
191        j = c.cend(b);
192        assert(std::distance(i, j) == 2);
193        assert(i->first == 2);
194        assert(i->second == "two");
195        ++i;
196        assert(i->first == 2);
197        assert(i->second == "four");
198
199        b = c.bucket(3);
200        i = c.cbegin(b);
201        j = c.cend(b);
202        assert(std::distance(i, j) == 1);
203        assert(i->first == 3);
204        assert(i->second == "three");
205
206        b = c.bucket(4);
207        i = c.cbegin(b);
208        j = c.cend(b);
209        assert(std::distance(i, j) == 1);
210        assert(i->first == 4);
211        assert(i->second == "four");
212
213        b = c.bucket(5);
214        i = c.cbegin(b);
215        j = c.cend(b);
216        assert(std::distance(i, j) == 0);
217
218        b = c.bucket(6);
219        i = c.cbegin(b);
220        j = c.cend(b);
221        assert(std::distance(i, j) == 0);
222    }
223    {
224        typedef std::unordered_multimap<int, std::string> C;
225        typedef std::pair<int, std::string> P;
226        typedef C::const_local_iterator I;
227        P a[] =
228        {
229            P(1, "one"),
230            P(2, "two"),
231            P(3, "three"),
232            P(4, "four"),
233            P(1, "four"),
234            P(2, "four"),
235        };
236        const C c(a, a + sizeof(a)/sizeof(a[0]));
237        assert(c.bucket_count() >= 7);
238        C::size_type b = c.bucket(0);
239        I i = c.cbegin(b);
240        I j = c.cend(b);
241        assert(std::distance(i, j) == 0);
242
243        b = c.bucket(1);
244        i = c.cbegin(b);
245        j = c.cend(b);
246        assert(std::distance(i, j) == 2);
247        assert(i->first == 1);
248        assert(i->second == "one");
249        ++i;
250        assert(i->first == 1);
251        assert(i->second == "four");
252
253        b = c.bucket(2);
254        i = c.cbegin(b);
255        j = c.cend(b);
256        assert(std::distance(i, j) == 2);
257        assert(i->first == 2);
258        assert(i->second == "two");
259        ++i;
260        assert(i->first == 2);
261        assert(i->second == "four");
262
263        b = c.bucket(3);
264        i = c.cbegin(b);
265        j = c.cend(b);
266        assert(std::distance(i, j) == 1);
267        assert(i->first == 3);
268        assert(i->second == "three");
269
270        b = c.bucket(4);
271        i = c.cbegin(b);
272        j = c.cend(b);
273        assert(std::distance(i, j) == 1);
274        assert(i->first == 4);
275        assert(i->second == "four");
276
277        b = c.bucket(5);
278        i = c.cbegin(b);
279        j = c.cend(b);
280        assert(std::distance(i, j) == 0);
281
282        b = c.bucket(6);
283        i = c.cbegin(b);
284        j = c.cend(b);
285        assert(std::distance(i, j) == 0);
286    }
287#if __cplusplus >= 201103L
288    {
289        typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
290                            min_allocator<std::pair<const int, std::string>>> C;
291        typedef std::pair<int, std::string> P;
292        typedef C::local_iterator I;
293        P a[] =
294        {
295            P(1, "one"),
296            P(2, "two"),
297            P(3, "three"),
298            P(4, "four"),
299            P(1, "four"),
300            P(2, "four"),
301        };
302        C c(a, a + sizeof(a)/sizeof(a[0]));
303        assert(c.bucket_count() >= 7);
304        C::size_type b = c.bucket(0);
305        I i = c.begin(b);
306        I j = c.end(b);
307        assert(std::distance(i, j) == 0);
308
309        b = c.bucket(1);
310        i = c.begin(b);
311        j = c.end(b);
312        assert(std::distance(i, j) == 2);
313        assert(i->first == 1);
314        assert(i->second == "one");
315        ++i;
316        assert(i->first == 1);
317        assert(i->second == "four");
318
319        b = c.bucket(2);
320        i = c.begin(b);
321        j = c.end(b);
322        assert(std::distance(i, j) == 2);
323        assert(i->first == 2);
324        assert(i->second == "two");
325        ++i;
326        assert(i->first == 2);
327        assert(i->second == "four");
328
329        b = c.bucket(3);
330        i = c.begin(b);
331        j = c.end(b);
332        assert(std::distance(i, j) == 1);
333        assert(i->first == 3);
334        assert(i->second == "three");
335
336        b = c.bucket(4);
337        i = c.begin(b);
338        j = c.end(b);
339        assert(std::distance(i, j) == 1);
340        assert(i->first == 4);
341        assert(i->second == "four");
342
343        b = c.bucket(5);
344        i = c.begin(b);
345        j = c.end(b);
346        assert(std::distance(i, j) == 0);
347
348        b = c.bucket(6);
349        i = c.begin(b);
350        j = c.end(b);
351        assert(std::distance(i, j) == 0);
352    }
353    {
354        typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
355                            min_allocator<std::pair<const int, std::string>>> C;
356        typedef std::pair<int, std::string> P;
357        typedef C::const_local_iterator I;
358        P a[] =
359        {
360            P(1, "one"),
361            P(2, "two"),
362            P(3, "three"),
363            P(4, "four"),
364            P(1, "four"),
365            P(2, "four"),
366        };
367        const C c(a, a + sizeof(a)/sizeof(a[0]));
368        assert(c.bucket_count() >= 7);
369        C::size_type b = c.bucket(0);
370        I i = c.begin(b);
371        I j = c.end(b);
372        assert(std::distance(i, j) == 0);
373
374        b = c.bucket(1);
375        i = c.begin(b);
376        j = c.end(b);
377        assert(std::distance(i, j) == 2);
378        assert(i->first == 1);
379        assert(i->second == "one");
380        ++i;
381        assert(i->first == 1);
382        assert(i->second == "four");
383
384        b = c.bucket(2);
385        i = c.begin(b);
386        j = c.end(b);
387        assert(std::distance(i, j) == 2);
388        assert(i->first == 2);
389        assert(i->second == "two");
390        ++i;
391        assert(i->first == 2);
392        assert(i->second == "four");
393
394        b = c.bucket(3);
395        i = c.begin(b);
396        j = c.end(b);
397        assert(std::distance(i, j) == 1);
398        assert(i->first == 3);
399        assert(i->second == "three");
400
401        b = c.bucket(4);
402        i = c.begin(b);
403        j = c.end(b);
404        assert(std::distance(i, j) == 1);
405        assert(i->first == 4);
406        assert(i->second == "four");
407
408        b = c.bucket(5);
409        i = c.begin(b);
410        j = c.end(b);
411        assert(std::distance(i, j) == 0);
412
413        b = c.bucket(6);
414        i = c.begin(b);
415        j = c.end(b);
416        assert(std::distance(i, j) == 0);
417    }
418    {
419        typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
420                            min_allocator<std::pair<const int, std::string>>> C;
421        typedef std::pair<int, std::string> P;
422        typedef C::const_local_iterator I;
423        P a[] =
424        {
425            P(1, "one"),
426            P(2, "two"),
427            P(3, "three"),
428            P(4, "four"),
429            P(1, "four"),
430            P(2, "four"),
431        };
432        C c(a, a + sizeof(a)/sizeof(a[0]));
433        assert(c.bucket_count() >= 7);
434        C::size_type b = c.bucket(0);
435        I i = c.cbegin(b);
436        I j = c.cend(b);
437        assert(std::distance(i, j) == 0);
438
439        b = c.bucket(1);
440        i = c.cbegin(b);
441        j = c.cend(b);
442        assert(std::distance(i, j) == 2);
443        assert(i->first == 1);
444        assert(i->second == "one");
445        ++i;
446        assert(i->first == 1);
447        assert(i->second == "four");
448
449        b = c.bucket(2);
450        i = c.cbegin(b);
451        j = c.cend(b);
452        assert(std::distance(i, j) == 2);
453        assert(i->first == 2);
454        assert(i->second == "two");
455        ++i;
456        assert(i->first == 2);
457        assert(i->second == "four");
458
459        b = c.bucket(3);
460        i = c.cbegin(b);
461        j = c.cend(b);
462        assert(std::distance(i, j) == 1);
463        assert(i->first == 3);
464        assert(i->second == "three");
465
466        b = c.bucket(4);
467        i = c.cbegin(b);
468        j = c.cend(b);
469        assert(std::distance(i, j) == 1);
470        assert(i->first == 4);
471        assert(i->second == "four");
472
473        b = c.bucket(5);
474        i = c.cbegin(b);
475        j = c.cend(b);
476        assert(std::distance(i, j) == 0);
477
478        b = c.bucket(6);
479        i = c.cbegin(b);
480        j = c.cend(b);
481        assert(std::distance(i, j) == 0);
482    }
483    {
484        typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
485                            min_allocator<std::pair<const int, std::string>>> C;
486        typedef std::pair<int, std::string> P;
487        typedef C::const_local_iterator I;
488        P a[] =
489        {
490            P(1, "one"),
491            P(2, "two"),
492            P(3, "three"),
493            P(4, "four"),
494            P(1, "four"),
495            P(2, "four"),
496        };
497        const C c(a, a + sizeof(a)/sizeof(a[0]));
498        assert(c.bucket_count() >= 7);
499        C::size_type b = c.bucket(0);
500        I i = c.cbegin(b);
501        I j = c.cend(b);
502        assert(std::distance(i, j) == 0);
503
504        b = c.bucket(1);
505        i = c.cbegin(b);
506        j = c.cend(b);
507        assert(std::distance(i, j) == 2);
508        assert(i->first == 1);
509        assert(i->second == "one");
510        ++i;
511        assert(i->first == 1);
512        assert(i->second == "four");
513
514        b = c.bucket(2);
515        i = c.cbegin(b);
516        j = c.cend(b);
517        assert(std::distance(i, j) == 2);
518        assert(i->first == 2);
519        assert(i->second == "two");
520        ++i;
521        assert(i->first == 2);
522        assert(i->second == "four");
523
524        b = c.bucket(3);
525        i = c.cbegin(b);
526        j = c.cend(b);
527        assert(std::distance(i, j) == 1);
528        assert(i->first == 3);
529        assert(i->second == "three");
530
531        b = c.bucket(4);
532        i = c.cbegin(b);
533        j = c.cend(b);
534        assert(std::distance(i, j) == 1);
535        assert(i->first == 4);
536        assert(i->second == "four");
537
538        b = c.bucket(5);
539        i = c.cbegin(b);
540        j = c.cend(b);
541        assert(std::distance(i, j) == 0);
542
543        b = c.bucket(6);
544        i = c.cbegin(b);
545        j = c.cend(b);
546        assert(std::distance(i, j) == 0);
547    }
548#endif
549}
550