1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// <unordered_set>
10
11// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
12// class Alloc = allocator<Value>>
13// class unordered_multiset
14
15// local_iterator begin (size_type n);
16// local_iterator end (size_type n);
17// const_local_iterator begin (size_type n) const;
18// const_local_iterator end (size_type n) const;
19// const_local_iterator cbegin(size_type n) const;
20// const_local_iterator cend (size_type n) const;
21
22#include <unordered_set>
23#include <cassert>
24
25#include "test_macros.h"
26
27int main(int, char**) {
28 {
29 typedef std::unordered_multiset<int> C;
30 typedef int P;
31 typedef C::local_iterator I;
32 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
33 C c(a, a + sizeof(a) / sizeof(a[0]));
34 LIBCPP_ASSERT(c.bucket_count() == 7);
35 C::size_type b = c.bucket(key: 0);
36 I i = c.begin(b);
37 I j = c.end(b);
38 assert(std::distance(i, j) == 0);
39
40 b = c.bucket(key: 1);
41 i = c.begin(b);
42 j = c.end(b);
43 assert(std::distance(i, j) == 2);
44 assert(*i == 1);
45 ++i;
46 assert(*i == 1);
47 *i = 2;
48
49 b = c.bucket(key: 2);
50 i = c.begin(b);
51 j = c.end(b);
52 assert(std::distance(i, j) == 2);
53 assert(*i == 2);
54 ++i;
55 assert(*i == 2);
56
57 b = c.bucket(key: 3);
58 i = c.begin(b);
59 j = c.end(b);
60 assert(std::distance(i, j) == 1);
61 assert(*i == 3);
62
63 b = c.bucket(key: 4);
64 i = c.begin(b);
65 j = c.end(b);
66 assert(std::distance(i, j) == 1);
67 assert(*i == 4);
68
69 b = c.bucket(key: 5);
70 i = c.begin(b);
71 j = c.end(b);
72 assert(std::distance(i, j) == 0);
73
74 b = c.bucket(key: 6);
75 i = c.begin(b);
76 j = c.end(b);
77 assert(std::distance(i, j) == 0);
78 }
79 {
80 typedef std::unordered_multiset<int> C;
81 typedef int P;
82 typedef C::const_local_iterator I;
83 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
84 const C c(a, a + sizeof(a) / sizeof(a[0]));
85 LIBCPP_ASSERT(c.bucket_count() == 7);
86 C::size_type b = c.bucket(0);
87 I i = c.begin(b);
88 I j = c.end(b);
89 assert(std::distance(i, j) == 0);
90
91 b = c.bucket(1);
92 i = c.begin(b);
93 j = c.end(b);
94 assert(std::distance(i, j) == 2);
95 assert(*i == 1);
96 ++i;
97 assert(*i == 1);
98
99 b = c.bucket(2);
100 i = c.begin(b);
101 j = c.end(b);
102 assert(std::distance(i, j) == 2);
103 assert(*i == 2);
104 ++i;
105 assert(*i == 2);
106
107 b = c.bucket(3);
108 i = c.begin(b);
109 j = c.end(b);
110 assert(std::distance(i, j) == 1);
111 assert(*i == 3);
112
113 b = c.bucket(4);
114 i = c.begin(b);
115 j = c.end(b);
116 assert(std::distance(i, j) == 1);
117 assert(*i == 4);
118
119 b = c.bucket(5);
120 i = c.begin(b);
121 j = c.end(b);
122 assert(std::distance(i, j) == 0);
123
124 b = c.bucket(6);
125 i = c.begin(b);
126 j = c.end(b);
127 assert(std::distance(i, j) == 0);
128 }
129 {
130 typedef std::unordered_multiset<int> C;
131 typedef int P;
132 typedef C::const_local_iterator I;
133 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
134 C c(a, a + sizeof(a) / sizeof(a[0]));
135 LIBCPP_ASSERT(c.bucket_count() == 7);
136 C::size_type b = c.bucket(0);
137 I i = c.cbegin(b);
138 I j = c.cend(b);
139 assert(std::distance(i, j) == 0);
140
141 b = c.bucket(1);
142 i = c.cbegin(b);
143 j = c.cend(b);
144 assert(std::distance(i, j) == 2);
145 assert(*i == 1);
146 ++i;
147 assert(*i == 1);
148
149 b = c.bucket(2);
150 i = c.cbegin(b);
151 j = c.cend(b);
152 assert(std::distance(i, j) == 2);
153 assert(*i == 2);
154 ++i;
155 assert(*i == 2);
156
157 b = c.bucket(3);
158 i = c.cbegin(b);
159 j = c.cend(b);
160 assert(std::distance(i, j) == 1);
161 assert(*i == 3);
162
163 b = c.bucket(4);
164 i = c.cbegin(b);
165 j = c.cend(b);
166 assert(std::distance(i, j) == 1);
167 assert(*i == 4);
168
169 b = c.bucket(5);
170 i = c.cbegin(b);
171 j = c.cend(b);
172 assert(std::distance(i, j) == 0);
173
174 b = c.bucket(6);
175 i = c.cbegin(b);
176 j = c.cend(b);
177 assert(std::distance(i, j) == 0);
178 }
179 {
180 typedef std::unordered_multiset<int> C;
181 typedef int P;
182 typedef C::const_local_iterator I;
183 P a[] = {P(1), P(2), P(3), P(4), P(1), P(2)};
184 const C c(a, a + sizeof(a) / sizeof(a[0]));
185 LIBCPP_ASSERT(c.bucket_count() == 7);
186 C::size_type b = c.bucket(0);
187 I i = c.cbegin(b);
188 I j = c.cend(b);
189 assert(std::distance(i, j) == 0);
190
191 b = c.bucket(1);
192 i = c.cbegin(b);
193 j = c.cend(b);
194 assert(std::distance(i, j) == 2);
195 assert(*i == 1);
196 ++i;
197 assert(*i == 1);
198
199 b = c.bucket(2);
200 i = c.cbegin(b);
201 j = c.cend(b);
202 assert(std::distance(i, j) == 2);
203 assert(*i == 2);
204 ++i;
205 assert(*i == 2);
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 == 3);
212
213 b = c.bucket(4);
214 i = c.cbegin(b);
215 j = c.cend(b);
216 assert(std::distance(i, j) == 1);
217 assert(*i == 4);
218
219 b = c.bucket(5);
220 i = c.cbegin(b);
221 j = c.cend(b);
222 assert(std::distance(i, j) == 0);
223
224 b = c.bucket(6);
225 i = c.cbegin(b);
226 j = c.cend(b);
227 assert(std::distance(i, j) == 0);
228 }
229
230 return 0;
231}
232

source code of libcxx/test/std/containers/unord/unord.multiset/local_iterators.compile.fail.cpp