1//////////////////////////////////////////////////////////////////////////////
2//
3// (C) Copyright Howard Hinnant 2009
4// (C) Copyright Ion Gaztanaga 2014-2014.
5//
6// Distributed under the Boost Software License, Version 1.0.
7// (See accompanying file LICENSE_1_0.txt or copy at
8// http://www.boost.org/LICENSE_1_0.txt)
9//
10// See http://www.boost.org/libs/move for documentation.
11//
12//////////////////////////////////////////////////////////////////////////////
13#include <boost/move/utility_core.hpp>
14#include <boost/move/unique_ptr.hpp>
15#include <boost/core/lightweight_test.hpp>
16
17//////////////////////////////////////////////
18//
19// The initial implementation of these tests
20// was written by Howard Hinnant.
21//
22// These test were later refactored grouping
23// and porting them to Boost.Move.
24//
25// Many thanks to Howard for releasing his C++03
26// unique_ptr implementation with such detailed
27// test cases.
28//
29//////////////////////////////////////////////
30
31#include "unique_ptr_test_utils_beg.hpp"
32
33namespace bml = ::boost::movelib;
34
35////////////////////////////////
36// unique_ptr_asgn_move_convert_defdel
37////////////////////////////////
38namespace unique_ptr_asgn_move_convert_defdel {
39
40void test()
41{
42 //Single unique_ptr
43 reset_counters();
44 {
45 bml::unique_ptr<B> s(new B);
46 A* p = s.get();
47 bml::unique_ptr<A> s2(new A);
48 BOOST_TEST(A::count == 2);
49 s2 = boost::move(t&: s);
50 BOOST_TEST(s2.get() == p);
51 BOOST_TEST(s.get() == 0);
52 BOOST_TEST(A::count == 1);
53 BOOST_TEST(B::count == 1);
54 }
55 BOOST_TEST(A::count == 0);
56 BOOST_TEST(B::count == 0);
57
58 //Unbounded array unique_ptr
59 reset_counters();
60 {
61 bml::unique_ptr<A[]> s(new A[2]);
62 A* p = s.get();
63 bml::unique_ptr<const A[]> s2(new const A[2]);
64 BOOST_TEST(A::count == 4);
65 s2 = boost::move(t&: s);
66 BOOST_TEST(s2.get() == p);
67 BOOST_TEST(s.get() == 0);
68 BOOST_TEST(A::count == 2);
69 }
70 BOOST_TEST(A::count == 0);
71 //Bounded array unique_ptr
72 reset_counters();
73 {
74 bml::unique_ptr<A[2]> s(new A[2]);
75 A* p = s.get();
76 bml::unique_ptr<const A[2]> s2(new const A[2]);
77 BOOST_TEST(A::count == 4);
78 s2 = boost::move(t&: s);
79 BOOST_TEST(s2.get() == p);
80 BOOST_TEST(s.get() == 0);
81 BOOST_TEST(A::count == 2);
82 }
83 {
84 BOOST_TEST(A::count == 0);
85 bml::unique_ptr<A[2]> s(new A[2]);
86 A* p = s.get();
87 bml::unique_ptr<const A[]> s2(new const A[2]);
88 BOOST_TEST(A::count == 4);
89 s2 = boost::move(t&: s);
90 BOOST_TEST(s2.get() == p);
91 BOOST_TEST(s.get() == 0);
92 BOOST_TEST(A::count == 2);
93 }
94 BOOST_TEST(A::count == 0);
95}
96
97} //namespace unique_ptr_asgn_move_convert_defdel{
98
99////////////////////////////////
100// unique_ptr_asgn_move_convert_movdel
101////////////////////////////////
102
103namespace unique_ptr_asgn_move_convert_movedel{
104
105void test()
106{
107 //Single unique_ptr
108 reset_counters();
109 {
110 bml::unique_ptr<B, move_constr_deleter<B> > s(new B);
111 A* p = s.get();
112 bml::unique_ptr<A, move_constr_deleter<A> > s2(new A);
113 BOOST_TEST(A::count == 2);
114 s2 = (boost::move(t&: s));
115 BOOST_TEST(s2.get() == p);
116 BOOST_TEST(s.get() == 0);
117 BOOST_TEST(A::count == 1);
118 BOOST_TEST(B::count == 1);
119 BOOST_TEST(s2.get_deleter().state() == 5);
120 BOOST_TEST(s.get_deleter().state() == 0);
121 }
122 BOOST_TEST(A::count == 0);
123 BOOST_TEST(B::count == 0);
124
125 //Unbounded array unique_ptr
126 reset_counters();
127 {
128 bml::unique_ptr<A[], move_constr_deleter<A[]> > s(new A[2]);
129 A* p = s.get();
130 bml::unique_ptr<const A[], move_constr_deleter<const A[]> > s2(new const A[2]);
131 BOOST_TEST(A::count == 4);
132 s2 = (boost::move(t&: s));
133 BOOST_TEST(s2.get() == p);
134 BOOST_TEST(s.get() == 0);
135 BOOST_TEST(A::count == 2);
136 BOOST_TEST(s2.get_deleter().state() == 5);
137 BOOST_TEST(s.get_deleter().state() == 0);
138 }
139 BOOST_TEST(A::count == 0);
140
141 //Bounded array unique_ptr
142 reset_counters();
143 {
144 bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s(new A[3]);
145 A* p = s.get();
146 bml::unique_ptr<const A[2], move_constr_deleter<const A[2]> > s2(new const A[2]);
147 BOOST_TEST(A::count == 5);
148 s2 = (boost::move(t&: s));
149 BOOST_TEST(s2.get() == p);
150 BOOST_TEST(s.get() == 0);
151 BOOST_TEST(A::count == 3);
152 BOOST_TEST(s2.get_deleter().state() == 5);
153 BOOST_TEST(s.get_deleter().state() == 0);
154 }
155 BOOST_TEST(A::count == 0);
156 reset_counters();
157 {
158 bml::unique_ptr<A[2], move_constr_deleter<A[3]> > s(new A[2]);
159 A* p = s.get();
160 bml::unique_ptr<const A[], move_constr_deleter<const A[]> > s2(new const A[2]);
161 BOOST_TEST(A::count == 4);
162 s2 = (boost::move(t&: s));
163 BOOST_TEST(s2.get() == p);
164 BOOST_TEST(s.get() == 0);
165 BOOST_TEST(A::count == 2);
166 BOOST_TEST(s2.get_deleter().state() == 5);
167 BOOST_TEST(s.get_deleter().state() == 0);
168 }
169 BOOST_TEST(A::count == 0);
170}
171
172} //namespace unique_ptr_asgn_move_convert_movedel{
173
174////////////////////////////////
175// unique_ptr_asgn_move_convert_copydelref
176////////////////////////////////
177
178namespace unique_ptr_asgn_move_convert_copydelref{
179
180// test converting move assignment with reference deleters
181
182void test()
183{
184 //Single unique_ptr
185 reset_counters();
186 {
187 copy_constr_deleter<B> db(5);
188 bml::unique_ptr<B, copy_constr_deleter<B>&> s(new B, db);
189 A* p = s.get();
190 copy_constr_deleter<A> da(6);
191 bml::unique_ptr<A, copy_constr_deleter<A>&> s2(new A, da);
192 s2 = boost::move(t&: s);
193 BOOST_TEST(s2.get() == p);
194 BOOST_TEST(s.get() == 0);
195 BOOST_TEST(A::count == 1);
196 BOOST_TEST(B::count == 1);
197 BOOST_TEST(s2.get_deleter().state() == 5);
198 }
199 BOOST_TEST(A::count == 0);
200 BOOST_TEST(B::count == 0);
201
202 //Unbounded array unique_ptr
203 reset_counters();
204 {
205 copy_constr_deleter<A[]> db(5);
206 bml::unique_ptr<A[], copy_constr_deleter<A[]>&> s(new A[2], db);
207 A* p = s.get();
208 copy_constr_deleter<const A[]> da(6);
209 bml::unique_ptr<const A[], copy_constr_deleter<const A[]>&> s2(new const A[2], da);
210 BOOST_TEST(A::count == 4);
211 s2 = boost::move(t&: s);
212 BOOST_TEST(s2.get() == p);
213 BOOST_TEST(s.get() == 0);
214 BOOST_TEST(A::count == 2);
215 BOOST_TEST(s2.get_deleter().state() == 5);
216 }
217 BOOST_TEST(A::count == 0);
218
219 //Bounded array unique_ptr
220 reset_counters();
221 {
222 copy_constr_deleter<A[2]> db(5);
223 bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s(new A[2], db);
224 A* p = s.get();
225 copy_constr_deleter<const A[2]> da(6);
226 bml::unique_ptr<const A[2], copy_constr_deleter<const A[2]>&> s2(new const A[2], da);
227 BOOST_TEST(A::count == 4);
228 s2 = boost::move(t&: s);
229 BOOST_TEST(s2.get() == p);
230 BOOST_TEST(s.get() == 0);
231 BOOST_TEST(A::count == 2);
232 BOOST_TEST(s2.get_deleter().state() == 5);
233 }
234 BOOST_TEST(A::count == 0);
235 reset_counters();
236 {
237 copy_constr_deleter<A[2]> db(5);
238 bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s(new A[2], db);
239 A* p = s.get();
240 copy_constr_deleter<const A[]> da(6);
241 bml::unique_ptr<const A[], copy_constr_deleter<const A[]>&> s2(new const A[2], da);
242 BOOST_TEST(A::count == 4);
243 s2 = boost::move(t&: s);
244 BOOST_TEST(s2.get() == p);
245 BOOST_TEST(s.get() == 0);
246 BOOST_TEST(A::count == 2);
247 BOOST_TEST(s2.get_deleter().state() == 5);
248 }
249 BOOST_TEST(A::count == 0);
250}
251
252} //namespace unique_ptr_asgn_move_convert_copydelref{
253
254////////////////////////////////
255// unique_ptr_asgn_move_defdel
256////////////////////////////////
257namespace unique_ptr_asgn_move_defdel {
258
259void test()
260{
261 //Single unique_ptr
262 reset_counters();
263 {
264 bml::unique_ptr<A> s1(new A);
265 A* p = s1.get();
266 bml::unique_ptr<A> s2(new A);
267 BOOST_TEST(A::count == 2);
268 s2 = boost::move(t&: s1);
269 BOOST_TEST(A::count == 1);
270 BOOST_TEST(s2.get() == p);
271 BOOST_TEST(s1.get() == 0);
272 }
273 BOOST_TEST(A::count == 0);
274
275 //Unbounded array unique_ptr
276 reset_counters();
277 {
278 bml::unique_ptr<A[]> s1(new A[2]);
279 A* p = s1.get();
280 bml::unique_ptr<A[]> s2(new A[2]);
281 BOOST_TEST(A::count == 4);
282 s2 = boost::move(t&: s1);
283 BOOST_TEST(A::count == 2);
284 BOOST_TEST(s2.get() == p);
285 BOOST_TEST(s1.get() == 0);
286 }
287 BOOST_TEST(A::count == 0);
288 //Bounded array unique_ptr
289 reset_counters();
290 {
291 bml::unique_ptr<A[2]> s1(new A[2]);
292 A* p = s1.get();
293 bml::unique_ptr<A[2]> s2(new A[2]);
294 BOOST_TEST(A::count == 4);
295 s2 = boost::move(t&: s1);
296 BOOST_TEST(A::count == 2);
297 BOOST_TEST(s2.get() == p);
298 BOOST_TEST(s1.get() == 0);
299 }
300 BOOST_TEST(A::count == 0);
301}
302
303} //unique_ptr_asgn_move_defdel
304
305////////////////////////////////
306// unique_ptr_asgn_move_movedel
307////////////////////////////////
308namespace unique_ptr_asgn_move_movedel {
309
310void test()
311{
312 //Single unique_ptr
313 reset_counters();
314 {
315 bml::unique_ptr<A, move_constr_deleter<A> > s1(new A);
316 A* p = s1.get();
317 bml::unique_ptr<A, move_constr_deleter<A> > s2(new A);
318 BOOST_TEST(A::count == 2);
319 s2 = boost::move(t&: s1);
320 BOOST_TEST(s2.get() == p);
321 BOOST_TEST(s1.get() == 0);
322 BOOST_TEST(A::count == 1);
323 BOOST_TEST(s2.get_deleter().state() == 5);
324 BOOST_TEST(s1.get_deleter().state() == 0);
325 }
326 BOOST_TEST(A::count == 0);
327
328 //Unbounded array unique_ptr
329 reset_counters();
330 {
331 bml::unique_ptr<A[], move_constr_deleter<A[]> > s1(new A[2]);
332 A* p = s1.get();
333 bml::unique_ptr<A[], move_constr_deleter<A[]> > s2(new A[2]);
334 BOOST_TEST(A::count == 4);
335 s2 = boost::move(t&: s1);
336 BOOST_TEST(s2.get() == p);
337 BOOST_TEST(s1.get() == 0);
338 BOOST_TEST(A::count == 2);
339 BOOST_TEST(s2.get_deleter().state() == 5);
340 BOOST_TEST(s1.get_deleter().state() == 0);
341 }
342 BOOST_TEST(A::count == 0);
343
344 BOOST_TEST(A::count == 0);
345 //Bounded array unique_ptr
346 reset_counters();
347 {
348 bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s1(new A[2]);
349 A* p = s1.get();
350 bml::unique_ptr<A[2], move_constr_deleter<A[2]> > s2(new A[2]);
351 BOOST_TEST(A::count == 4);
352 s2 = boost::move(t&: s1);
353 BOOST_TEST(s2.get() == p);
354 BOOST_TEST(s1.get() == 0);
355 BOOST_TEST(A::count == 2);
356 BOOST_TEST(s2.get_deleter().state() == 5);
357 BOOST_TEST(s1.get_deleter().state() == 0);
358 }
359 BOOST_TEST(A::count == 0);
360}
361
362} //unique_ptr_asgn_move_movedel
363
364////////////////////////////////
365// unique_ptr_asgn_move_copydelref
366////////////////////////////////
367namespace unique_ptr_asgn_move_copydelref {
368
369void test()
370{
371 //Single unique_ptr
372 reset_counters();
373 {
374 copy_constr_deleter<A> d1(5);
375 bml::unique_ptr<A, copy_constr_deleter<A>&> s1(new A, d1);
376 A* p = s1.get();
377 copy_constr_deleter<A> d2(6);
378 bml::unique_ptr<A, copy_constr_deleter<A>&> s2(new A, d2);
379 s2 = boost::move(t&: s1);
380 BOOST_TEST(s2.get() == p);
381 BOOST_TEST(s1.get() == 0);
382 BOOST_TEST(A::count == 1);
383 BOOST_TEST(d1.state() == 5);
384 BOOST_TEST(d2.state() == 5);
385 }
386 BOOST_TEST(A::count == 0);
387
388 //Unbounded array unique_ptr
389 reset_counters();
390 {
391 copy_constr_deleter<A[]> d1(5);
392 bml::unique_ptr<A[], copy_constr_deleter<A[]>&> s1(new A[2], d1);
393 A* p = s1.get();
394 copy_constr_deleter<A[]> d2(6);
395 bml::unique_ptr<A[], copy_constr_deleter<A[]>&> s2(new A[2], d2);
396 BOOST_TEST(A::count == 4);
397 s2 = boost::move(t&: s1);
398 BOOST_TEST(s2.get() == p);
399 BOOST_TEST(s1.get() == 0);
400 BOOST_TEST(A::count == 2);
401 BOOST_TEST(d1.state() == 5);
402 BOOST_TEST(d2.state() == 5);
403 }
404 BOOST_TEST(A::count == 0);
405 //Bounded array unique_ptr
406 reset_counters();
407 {
408 copy_constr_deleter<A[2]> d1(5);
409 bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s1(new A[2], d1);
410 A* p = s1.get();
411 copy_constr_deleter<A[2]> d2(6);
412 bml::unique_ptr<A[2], copy_constr_deleter<A[2]>&> s2(new A[2], d2);
413 BOOST_TEST(A::count == 4);
414 s2 = boost::move(t&: s1);
415 BOOST_TEST(s2.get() == p);
416 BOOST_TEST(s1.get() == 0);
417 BOOST_TEST(A::count == 2);
418 BOOST_TEST(d1.state() == 5);
419 BOOST_TEST(d2.state() == 5);
420 }
421 BOOST_TEST(A::count == 0);
422}
423
424} //unique_ptr_asgn_move_copydelref
425
426////////////////////////////////
427// main
428////////////////////////////////
429int main()
430{
431 //Assignment
432 unique_ptr_asgn_move_convert_defdel::test();
433 unique_ptr_asgn_move_convert_movedel::test();
434 unique_ptr_asgn_move_convert_copydelref::test();
435 unique_ptr_asgn_move_defdel::test();
436 unique_ptr_asgn_move_movedel::test();
437 unique_ptr_asgn_move_copydelref::test();
438
439 //Test results
440 return boost::report_errors();
441}
442
443#include "unique_ptr_test_utils_end.hpp"
444

source code of boost/libs/move/test/unique_ptr_assign.cpp