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// <multimap>
10
11// class multimap
12
13// pair<iterator, iterator> equal_range(const key_type& k);
14// pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
15
16#include <map>
17#include <cassert>
18
19#include "test_macros.h"
20#include "min_allocator.h"
21#include "private_constructor.h"
22#include "is_transparent.h"
23
24int main(int, char**) {
25 typedef std::pair<const int, double> V;
26 {
27 typedef std::multimap<int, double> M;
28 {
29 typedef std::pair<M::iterator, M::iterator> R;
30 V ar[] = {V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3)};
31 M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
32 R r = m.equal_range(x: 4);
33 assert(r.first == m.begin());
34 assert(r.second == m.begin());
35 r = m.equal_range(x: 5);
36 assert(r.first == m.begin());
37 assert(r.second == std::next(m.begin(), 3));
38 r = m.equal_range(x: 6);
39 assert(r.first == std::next(m.begin(), 3));
40 assert(r.second == std::next(m.begin(), 3));
41 r = m.equal_range(x: 7);
42 assert(r.first == std::next(m.begin(), 3));
43 assert(r.second == std::next(m.begin(), 6));
44 r = m.equal_range(x: 8);
45 assert(r.first == std::next(m.begin(), 6));
46 assert(r.second == std::next(m.begin(), 6));
47 r = m.equal_range(x: 9);
48 assert(r.first == std::next(m.begin(), 6));
49 assert(r.second == std::next(m.begin(), 9));
50 r = m.equal_range(x: 10);
51 assert(r.first == m.end());
52 assert(r.second == m.end());
53 }
54 {
55 typedef std::pair<M::const_iterator, M::const_iterator> R;
56 V ar[] = {V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3)};
57 const M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
58 R r = m.equal_range(x: 4);
59 assert(r.first == m.begin());
60 assert(r.second == m.begin());
61 r = m.equal_range(x: 5);
62 assert(r.first == m.begin());
63 assert(r.second == std::next(m.begin(), 3));
64 r = m.equal_range(x: 6);
65 assert(r.first == std::next(m.begin(), 3));
66 assert(r.second == std::next(m.begin(), 3));
67 r = m.equal_range(x: 7);
68 assert(r.first == std::next(m.begin(), 3));
69 assert(r.second == std::next(m.begin(), 6));
70 r = m.equal_range(x: 8);
71 assert(r.first == std::next(m.begin(), 6));
72 assert(r.second == std::next(m.begin(), 6));
73 r = m.equal_range(x: 9);
74 assert(r.first == std::next(m.begin(), 6));
75 assert(r.second == std::next(m.begin(), 9));
76 r = m.equal_range(x: 10);
77 assert(r.first == m.end());
78 assert(r.second == m.end());
79 }
80 }
81#if TEST_STD_VER >= 11
82 {
83 typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M;
84 {
85 typedef std::pair<M::iterator, M::iterator> R;
86 V ar[] = {V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3)};
87 M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
88 R r = m.equal_range(4);
89 assert(r.first == m.begin());
90 assert(r.second == m.begin());
91 r = m.equal_range(5);
92 assert(r.first == m.begin());
93 assert(r.second == std::next(m.begin(), 3));
94 r = m.equal_range(6);
95 assert(r.first == std::next(m.begin(), 3));
96 assert(r.second == std::next(m.begin(), 3));
97 r = m.equal_range(7);
98 assert(r.first == std::next(m.begin(), 3));
99 assert(r.second == std::next(m.begin(), 6));
100 r = m.equal_range(8);
101 assert(r.first == std::next(m.begin(), 6));
102 assert(r.second == std::next(m.begin(), 6));
103 r = m.equal_range(9);
104 assert(r.first == std::next(m.begin(), 6));
105 assert(r.second == std::next(m.begin(), 9));
106 r = m.equal_range(10);
107 assert(r.first == m.end());
108 assert(r.second == m.end());
109 }
110 {
111 typedef std::pair<M::const_iterator, M::const_iterator> R;
112 V ar[] = {V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3)};
113 const M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
114 R r = m.equal_range(4);
115 assert(r.first == m.begin());
116 assert(r.second == m.begin());
117 r = m.equal_range(5);
118 assert(r.first == m.begin());
119 assert(r.second == std::next(m.begin(), 3));
120 r = m.equal_range(6);
121 assert(r.first == std::next(m.begin(), 3));
122 assert(r.second == std::next(m.begin(), 3));
123 r = m.equal_range(7);
124 assert(r.first == std::next(m.begin(), 3));
125 assert(r.second == std::next(m.begin(), 6));
126 r = m.equal_range(8);
127 assert(r.first == std::next(m.begin(), 6));
128 assert(r.second == std::next(m.begin(), 6));
129 r = m.equal_range(9);
130 assert(r.first == std::next(m.begin(), 6));
131 assert(r.second == std::next(m.begin(), 9));
132 r = m.equal_range(10);
133 assert(r.first == m.end());
134 assert(r.second == m.end());
135 }
136 }
137#endif
138#if TEST_STD_VER > 11
139 {
140 typedef std::multimap<int, double, std::less<>> M;
141
142 typedef std::pair<M::iterator, M::iterator> R;
143 V ar[] = {V(5, 1), V(5, 2), V(5, 3), V(7, 1), V(7, 2), V(7, 3), V(9, 1), V(9, 2), V(9, 3)};
144 M m(ar, ar + sizeof(ar) / sizeof(ar[0]));
145 R r = m.equal_range(4);
146 assert(r.first == m.begin());
147 assert(r.second == m.begin());
148 r = m.equal_range(5);
149 assert(r.first == m.begin());
150 assert(r.second == std::next(m.begin(), 3));
151 r = m.equal_range(6);
152 assert(r.first == std::next(m.begin(), 3));
153 assert(r.second == std::next(m.begin(), 3));
154 r = m.equal_range(7);
155 assert(r.first == std::next(m.begin(), 3));
156 assert(r.second == std::next(m.begin(), 6));
157 r = m.equal_range(8);
158 assert(r.first == std::next(m.begin(), 6));
159 assert(r.second == std::next(m.begin(), 6));
160 r = m.equal_range(9);
161 assert(r.first == std::next(m.begin(), 6));
162 assert(r.second == std::next(m.begin(), 9));
163 r = m.equal_range(10);
164 assert(r.first == m.end());
165 assert(r.second == m.end());
166
167 r = m.equal_range(C2Int(4));
168 assert(r.first == m.begin());
169 assert(r.second == m.begin());
170 r = m.equal_range(C2Int(5));
171 assert(r.first == m.begin());
172 assert(r.second == std::next(m.begin(), 3));
173 r = m.equal_range(C2Int(6));
174 assert(r.first == std::next(m.begin(), 3));
175 assert(r.second == std::next(m.begin(), 3));
176 r = m.equal_range(C2Int(7));
177 assert(r.first == std::next(m.begin(), 3));
178 assert(r.second == std::next(m.begin(), 6));
179 r = m.equal_range(C2Int(8));
180 assert(r.first == std::next(m.begin(), 6));
181 assert(r.second == std::next(m.begin(), 6));
182 r = m.equal_range(C2Int(9));
183 assert(r.first == std::next(m.begin(), 6));
184 assert(r.second == std::next(m.begin(), 9));
185 r = m.equal_range(C2Int(10));
186 assert(r.first == m.end());
187 assert(r.second == m.end());
188 }
189
190 {
191 typedef PrivateConstructor PC;
192 typedef std::multimap<PC, double, std::less<>> M;
193 typedef std::pair<M::iterator, M::iterator> R;
194
195 M m;
196 m.insert(std::make_pair<PC, double>(PC::make(5), 1));
197 m.insert(std::make_pair<PC, double>(PC::make(5), 2));
198 m.insert(std::make_pair<PC, double>(PC::make(5), 3));
199 m.insert(std::make_pair<PC, double>(PC::make(7), 1));
200 m.insert(std::make_pair<PC, double>(PC::make(7), 2));
201 m.insert(std::make_pair<PC, double>(PC::make(7), 3));
202 m.insert(std::make_pair<PC, double>(PC::make(9), 1));
203 m.insert(std::make_pair<PC, double>(PC::make(9), 2));
204 m.insert(std::make_pair<PC, double>(PC::make(9), 3));
205
206 // assert(m.size() == 9);
207 R r = m.equal_range(4);
208 assert(r.first == m.begin());
209 assert(r.second == m.begin());
210 r = m.equal_range(5);
211 assert(r.first == m.begin());
212 assert(r.second == std::next(m.begin(), 3));
213 r = m.equal_range(6);
214 assert(r.first == std::next(m.begin(), 3));
215 assert(r.second == std::next(m.begin(), 3));
216 r = m.equal_range(7);
217 assert(r.first == std::next(m.begin(), 3));
218 assert(r.second == std::next(m.begin(), 6));
219 r = m.equal_range(8);
220 assert(r.first == std::next(m.begin(), 6));
221 assert(r.second == std::next(m.begin(), 6));
222 r = m.equal_range(9);
223 assert(r.first == std::next(m.begin(), 6));
224 assert(r.second == std::next(m.begin(), 9));
225 r = m.equal_range(10);
226 assert(r.first == m.end());
227 assert(r.second == m.end());
228 }
229#endif
230
231 return 0;
232}
233

source code of libcxx/test/std/containers/associative/multimap/multimap.ops/equal_range.pass.cpp