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