local_iterators.pass.cpp revision 06086258d3d8c48a916ec51c33e1ad8f46821b81 
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_map
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_map<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() >= 5);
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) == 1);
55        assert(i->first == 1);
56        assert(i->second == "one");
57
58        b = c.bucket(2);
59        i = c.begin(b);
60        j = c.end(b);
61        assert(std::distance(i, j) == 1);
62        assert(i->first == 2);
63        assert(i->second == "two");
64
65        b = c.bucket(3);
66        i = c.begin(b);
67        j = c.end(b);
68        assert(std::distance(i, j) == 1);
69        assert(i->first == 3);
70        assert(i->second == "three");
71
72        b = c.bucket(4);
73        i = c.begin(b);
74        j = c.end(b);
75        assert(std::distance(i, j) == 1);
76        assert(i->first == 4);
77        assert(i->second == "four");
78    }
79    {
80        typedef std::unordered_map<int, std::string> C;
81        typedef std::pair<int, std::string> P;
82        typedef C::const_local_iterator I;
83        P a[] =
84        {
85            P(1, "one"),
86            P(2, "two"),
87            P(3, "three"),
88            P(4, "four"),
89            P(1, "four"),
90            P(2, "four"),
91        };
92        const C c(a, a + sizeof(a)/sizeof(a[0]));
93        assert(c.bucket_count() >= 5);
94        C::size_type b = c.bucket(0);
95        I i = c.begin(b);
96        I j = c.end(b);
97        assert(std::distance(i, j) == 0);
98
99        b = c.bucket(1);
100        i = c.begin(b);
101        j = c.end(b);
102        assert(std::distance(i, j) == 1);
103        assert(i->first == 1);
104        assert(i->second == "one");
105
106        b = c.bucket(2);
107        i = c.begin(b);
108        j = c.end(b);
109        assert(std::distance(i, j) == 1);
110        assert(i->first == 2);
111        assert(i->second == "two");
112
113        b = c.bucket(3);
114        i = c.begin(b);
115        j = c.end(b);
116        assert(std::distance(i, j) == 1);
117        assert(i->first == 3);
118        assert(i->second == "three");
119
120        b = c.bucket(4);
121        i = c.begin(b);
122        j = c.end(b);
123        assert(std::distance(i, j) == 1);
124        assert(i->first == 4);
125        assert(i->second == "four");
126    }
127    {
128        typedef std::unordered_map<int, std::string> C;
129        typedef std::pair<int, std::string> P;
130        typedef C::const_local_iterator I;
131        P a[] =
132        {
133            P(1, "one"),
134            P(2, "two"),
135            P(3, "three"),
136            P(4, "four"),
137            P(1, "four"),
138            P(2, "four"),
139        };
140        C c(a, a + sizeof(a)/sizeof(a[0]));
141        assert(c.bucket_count() >= 5);
142        C::size_type b = c.bucket(0);
143        I i = c.cbegin(b);
144        I j = c.cend(b);
145        assert(std::distance(i, j) == 0);
146
147        b = c.bucket(1);
148        i = c.cbegin(b);
149        j = c.cend(b);
150        assert(std::distance(i, j) == 1);
151        assert(i->first == 1);
152        assert(i->second == "one");
153
154        b = c.bucket(2);
155        i = c.cbegin(b);
156        j = c.cend(b);
157        assert(std::distance(i, j) == 1);
158        assert(i->first == 2);
159        assert(i->second == "two");
160
161        b = c.bucket(3);
162        i = c.cbegin(b);
163        j = c.cend(b);
164        assert(std::distance(i, j) == 1);
165        assert(i->first == 3);
166        assert(i->second == "three");
167
168        b = c.bucket(4);
169        i = c.cbegin(b);
170        j = c.cend(b);
171        assert(std::distance(i, j) == 1);
172        assert(i->first == 4);
173        assert(i->second == "four");
174    }
175    {
176        typedef std::unordered_map<int, std::string> C;
177        typedef std::pair<int, std::string> P;
178        typedef C::const_local_iterator I;
179        P a[] =
180        {
181            P(1, "one"),
182            P(2, "two"),
183            P(3, "three"),
184            P(4, "four"),
185            P(1, "four"),
186            P(2, "four"),
187        };
188        const C c(a, a + sizeof(a)/sizeof(a[0]));
189        assert(c.bucket_count() >= 5);
190        C::size_type b = c.bucket(0);
191        I i = c.cbegin(b);
192        I j = c.cend(b);
193        assert(std::distance(i, j) == 0);
194
195        b = c.bucket(1);
196        i = c.cbegin(b);
197        j = c.cend(b);
198        assert(std::distance(i, j) == 1);
199        assert(i->first == 1);
200        assert(i->second == "one");
201
202        b = c.bucket(2);
203        i = c.cbegin(b);
204        j = c.cend(b);
205        assert(std::distance(i, j) == 1);
206        assert(i->first == 2);
207        assert(i->second == "two");
208
209        b = c.bucket(3);
210        i = c.cbegin(b);
211        j = c.cend(b);
212        assert(std::distance(i, j) == 1);
213        assert(i->first == 3);
214        assert(i->second == "three");
215
216        b = c.bucket(4);
217        i = c.cbegin(b);
218        j = c.cend(b);
219        assert(std::distance(i, j) == 1);
220        assert(i->first == 4);
221        assert(i->second == "four");
222    }
223#if __cplusplus >= 201103L
224    {
225        typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
226                            min_allocator<std::pair<const int, std::string>>> C;
227        typedef std::pair<int, std::string> P;
228        typedef C::local_iterator I;
229        P a[] =
230        {
231            P(1, "one"),
232            P(2, "two"),
233            P(3, "three"),
234            P(4, "four"),
235            P(1, "four"),
236            P(2, "four"),
237        };
238        C c(a, a + sizeof(a)/sizeof(a[0]));
239        assert(c.bucket_count() >= 5);
240        C::size_type b = c.bucket(0);
241        I i = c.begin(b);
242        I j = c.end(b);
243        assert(std::distance(i, j) == 0);
244
245        b = c.bucket(1);
246        i = c.begin(b);
247        j = c.end(b);
248        assert(std::distance(i, j) == 1);
249        assert(i->first == 1);
250        assert(i->second == "one");
251
252        b = c.bucket(2);
253        i = c.begin(b);
254        j = c.end(b);
255        assert(std::distance(i, j) == 1);
256        assert(i->first == 2);
257        assert(i->second == "two");
258
259        b = c.bucket(3);
260        i = c.begin(b);
261        j = c.end(b);
262        assert(std::distance(i, j) == 1);
263        assert(i->first == 3);
264        assert(i->second == "three");
265
266        b = c.bucket(4);
267        i = c.begin(b);
268        j = c.end(b);
269        assert(std::distance(i, j) == 1);
270        assert(i->first == 4);
271        assert(i->second == "four");
272    }
273    {
274        typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
275                            min_allocator<std::pair<const int, std::string>>> C;
276        typedef std::pair<int, std::string> P;
277        typedef C::const_local_iterator I;
278        P a[] =
279        {
280            P(1, "one"),
281            P(2, "two"),
282            P(3, "three"),
283            P(4, "four"),
284            P(1, "four"),
285            P(2, "four"),
286        };
287        const C c(a, a + sizeof(a)/sizeof(a[0]));
288        assert(c.bucket_count() >= 5);
289        C::size_type b = c.bucket(0);
290        I i = c.begin(b);
291        I j = c.end(b);
292        assert(std::distance(i, j) == 0);
293
294        b = c.bucket(1);
295        i = c.begin(b);
296        j = c.end(b);
297        assert(std::distance(i, j) == 1);
298        assert(i->first == 1);
299        assert(i->second == "one");
300
301        b = c.bucket(2);
302        i = c.begin(b);
303        j = c.end(b);
304        assert(std::distance(i, j) == 1);
305        assert(i->first == 2);
306        assert(i->second == "two");
307
308        b = c.bucket(3);
309        i = c.begin(b);
310        j = c.end(b);
311        assert(std::distance(i, j) == 1);
312        assert(i->first == 3);
313        assert(i->second == "three");
314
315        b = c.bucket(4);
316        i = c.begin(b);
317        j = c.end(b);
318        assert(std::distance(i, j) == 1);
319        assert(i->first == 4);
320        assert(i->second == "four");
321    }
322    {
323        typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
324                            min_allocator<std::pair<const int, std::string>>> C;
325        typedef std::pair<int, std::string> P;
326        typedef C::const_local_iterator I;
327        P a[] =
328        {
329            P(1, "one"),
330            P(2, "two"),
331            P(3, "three"),
332            P(4, "four"),
333            P(1, "four"),
334            P(2, "four"),
335        };
336        C c(a, a + sizeof(a)/sizeof(a[0]));
337        assert(c.bucket_count() >= 5);
338        C::size_type b = c.bucket(0);
339        I i = c.cbegin(b);
340        I j = c.cend(b);
341        assert(std::distance(i, j) == 0);
342
343        b = c.bucket(1);
344        i = c.cbegin(b);
345        j = c.cend(b);
346        assert(std::distance(i, j) == 1);
347        assert(i->first == 1);
348        assert(i->second == "one");
349
350        b = c.bucket(2);
351        i = c.cbegin(b);
352        j = c.cend(b);
353        assert(std::distance(i, j) == 1);
354        assert(i->first == 2);
355        assert(i->second == "two");
356
357        b = c.bucket(3);
358        i = c.cbegin(b);
359        j = c.cend(b);
360        assert(std::distance(i, j) == 1);
361        assert(i->first == 3);
362        assert(i->second == "three");
363
364        b = c.bucket(4);
365        i = c.cbegin(b);
366        j = c.cend(b);
367        assert(std::distance(i, j) == 1);
368        assert(i->first == 4);
369        assert(i->second == "four");
370    }
371    {
372        typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
373                            min_allocator<std::pair<const int, std::string>>> C;
374        typedef std::pair<int, std::string> P;
375        typedef C::const_local_iterator I;
376        P a[] =
377        {
378            P(1, "one"),
379            P(2, "two"),
380            P(3, "three"),
381            P(4, "four"),
382            P(1, "four"),
383            P(2, "four"),
384        };
385        const C c(a, a + sizeof(a)/sizeof(a[0]));
386        assert(c.bucket_count() >= 5);
387        C::size_type b = c.bucket(0);
388        I i = c.cbegin(b);
389        I j = c.cend(b);
390        assert(std::distance(i, j) == 0);
391
392        b = c.bucket(1);
393        i = c.cbegin(b);
394        j = c.cend(b);
395        assert(std::distance(i, j) == 1);
396        assert(i->first == 1);
397        assert(i->second == "one");
398
399        b = c.bucket(2);
400        i = c.cbegin(b);
401        j = c.cend(b);
402        assert(std::distance(i, j) == 1);
403        assert(i->first == 2);
404        assert(i->second == "two");
405
406        b = c.bucket(3);
407        i = c.cbegin(b);
408        j = c.cend(b);
409        assert(std::distance(i, j) == 1);
410        assert(i->first == 3);
411        assert(i->second == "three");
412
413        b = c.bucket(4);
414        i = c.cbegin(b);
415        j = c.cend(b);
416        assert(std::distance(i, j) == 1);
417        assert(i->first == 4);
418        assert(i->second == "four");
419    }
420#endif
421}
422