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
main()29 int 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