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