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 // UNSUPPORTED: c++03
10 
11 // <map>
12 
13 // class map
14 
15 // map(map&& m, const allocator_type& a);
16 
17 #include <map>
18 #include <cassert>
19 #include <iterator>
20 
21 #include "test_macros.h"
22 #include "MoveOnly.h"
23 #include "../../../test_compare.h"
24 #include "test_allocator.h"
25 #include "min_allocator.h"
26 #include "Counter.h"
27 
28 int main(int, char**)
29 {
30     {
31         typedef std::pair<MoveOnly, MoveOnly> V;
32         typedef std::pair<const MoveOnly, MoveOnly> VC;
33         typedef test_less<MoveOnly> C;
34         typedef test_allocator<VC> A;
35         typedef std::map<MoveOnly, MoveOnly, C, A> M;
36         typedef std::move_iterator<V*> I;
37         V a1[] =
38         {
39             V(1, 1),
40             V(1, 2),
41             V(1, 3),
42             V(2, 1),
43             V(2, 2),
44             V(2, 3),
45             V(3, 1),
46             V(3, 2),
47             V(3, 3)
48         };
49         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
50         V a2[] =
51         {
52             V(1, 1),
53             V(1, 2),
54             V(1, 3),
55             V(2, 1),
56             V(2, 2),
57             V(2, 3),
58             V(3, 1),
59             V(3, 2),
60             V(3, 3)
61         };
62         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
63         M m3(std::move(m1), A(7));
64         assert(m3 == m2);
65         assert(m3.get_allocator() == A(7));
66         assert(m3.key_comp() == C(5));
67         LIBCPP_ASSERT(m1.empty());
68     }
69     {
70         typedef std::pair<MoveOnly, MoveOnly> V;
71         typedef std::pair<const MoveOnly, MoveOnly> VC;
72         typedef test_less<MoveOnly> C;
73         typedef test_allocator<VC> A;
74         typedef std::map<MoveOnly, MoveOnly, C, A> M;
75         typedef std::move_iterator<V*> I;
76         V a1[] =
77         {
78             V(1, 1),
79             V(1, 2),
80             V(1, 3),
81             V(2, 1),
82             V(2, 2),
83             V(2, 3),
84             V(3, 1),
85             V(3, 2),
86             V(3, 3)
87         };
88         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
89         V a2[] =
90         {
91             V(1, 1),
92             V(1, 2),
93             V(1, 3),
94             V(2, 1),
95             V(2, 2),
96             V(2, 3),
97             V(3, 1),
98             V(3, 2),
99             V(3, 3)
100         };
101         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
102         M m3(std::move(m1), A(5));
103         assert(m3 == m2);
104         assert(m3.get_allocator() == A(5));
105         assert(m3.key_comp() == C(5));
106         LIBCPP_ASSERT(m1.empty());
107     }
108     {
109         typedef std::pair<MoveOnly, MoveOnly> V;
110         typedef std::pair<const MoveOnly, MoveOnly> VC;
111         typedef test_less<MoveOnly> C;
112         typedef other_allocator<VC> A;
113         typedef std::map<MoveOnly, MoveOnly, C, A> M;
114         typedef std::move_iterator<V*> I;
115         V a1[] =
116         {
117             V(1, 1),
118             V(1, 2),
119             V(1, 3),
120             V(2, 1),
121             V(2, 2),
122             V(2, 3),
123             V(3, 1),
124             V(3, 2),
125             V(3, 3)
126         };
127         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A(7));
128         V a2[] =
129         {
130             V(1, 1),
131             V(1, 2),
132             V(1, 3),
133             V(2, 1),
134             V(2, 2),
135             V(2, 3),
136             V(3, 1),
137             V(3, 2),
138             V(3, 3)
139         };
140         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A(7));
141         M m3(std::move(m1), A(5));
142         assert(m3 == m2);
143         assert(m3.get_allocator() == A(5));
144         assert(m3.key_comp() == C(5));
145         LIBCPP_ASSERT(m1.empty());
146     }
147     {
148         typedef Counter<int> T;
149         typedef std::pair<int, T> V;
150         typedef std::pair<const int, T> VC;
151         typedef test_allocator<VC> A;
152         typedef std::less<int> C;
153         typedef std::map<const int, T, C, A> M;
154         typedef V* I;
155         Counter_base::gConstructed = 0;
156         {
157             V a1[] =
158             {
159                 V(1, 1),
160                 V(1, 2),
161                 V(1, 3),
162                 V(2, 1),
163                 V(2, 2),
164                 V(2, 3),
165                 V(3, 1),
166                 V(3, 2),
167                 V(3, 3)
168             };
169             const size_t num = sizeof(a1)/sizeof(a1[0]);
170             assert(Counter_base::gConstructed == num);
171 
172             M m1(I(a1), I(a1+num), C(), A());
173             assert(Counter_base::gConstructed == num+3);
174 
175             M m2(m1);
176             assert(m2 == m1);
177             assert(Counter_base::gConstructed == num+6);
178 
179             M m3(std::move(m1), A());
180             assert(m3 == m2);
181             LIBCPP_ASSERT(m1.empty());
182             assert(Counter_base::gConstructed >= (int)(num+6));
183             assert(Counter_base::gConstructed <= (int)(num+6+m1.size()));
184 
185             {
186             M m4(std::move(m2), A(5));
187             assert(Counter_base::gConstructed >= (int)(num+6));
188             assert(Counter_base::gConstructed <= (int)(num+6+m1.size()+m2.size()));
189             assert(m4 == m3);
190             LIBCPP_ASSERT(m2.empty());
191             }
192             assert(Counter_base::gConstructed >= (int)(num+3));
193             assert(Counter_base::gConstructed <= (int)(num+3+m1.size()+m2.size()));
194         }
195         assert(Counter_base::gConstructed == 0);
196     }
197     {
198         typedef std::pair<MoveOnly, MoveOnly> V;
199         typedef std::pair<const MoveOnly, MoveOnly> VC;
200         typedef test_less<MoveOnly> C;
201         typedef min_allocator<VC> A;
202         typedef std::map<MoveOnly, MoveOnly, C, A> M;
203         typedef std::move_iterator<V*> I;
204         V a1[] =
205         {
206             V(1, 1),
207             V(1, 2),
208             V(1, 3),
209             V(2, 1),
210             V(2, 2),
211             V(2, 3),
212             V(3, 1),
213             V(3, 2),
214             V(3, 3)
215         };
216         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A());
217         V a2[] =
218         {
219             V(1, 1),
220             V(1, 2),
221             V(1, 3),
222             V(2, 1),
223             V(2, 2),
224             V(2, 3),
225             V(3, 1),
226             V(3, 2),
227             V(3, 3)
228         };
229         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A());
230         M m3(std::move(m1), A());
231         assert(m3 == m2);
232         assert(m3.get_allocator() == A());
233         assert(m3.key_comp() == C(5));
234         LIBCPP_ASSERT(m1.empty());
235     }
236     {
237         typedef std::pair<MoveOnly, MoveOnly> V;
238         typedef std::pair<const MoveOnly, MoveOnly> VC;
239         typedef test_less<MoveOnly> C;
240         typedef explicit_allocator<VC> A;
241         typedef std::map<MoveOnly, MoveOnly, C, A> M;
242         typedef std::move_iterator<V*> I;
243         V a1[] =
244         {
245             V(1, 1),
246             V(1, 2),
247             V(1, 3),
248             V(2, 1),
249             V(2, 2),
250             V(2, 3),
251             V(3, 1),
252             V(3, 2),
253             V(3, 3)
254         };
255         M m1(I(a1), I(a1+sizeof(a1)/sizeof(a1[0])), C(5), A{});
256         V a2[] =
257         {
258             V(1, 1),
259             V(1, 2),
260             V(1, 3),
261             V(2, 1),
262             V(2, 2),
263             V(2, 3),
264             V(3, 1),
265             V(3, 2),
266             V(3, 3)
267         };
268         M m2(I(a2), I(a2+sizeof(a2)/sizeof(a2[0])), C(5), A{});
269         M m3(std::move(m1), A{});
270         assert(m3 == m2);
271         assert(m3.get_allocator() == A{});
272         assert(m3.key_comp() == C(5));
273         LIBCPP_ASSERT(m1.empty());
274     }
275 
276   return 0;
277 }
278