]>
git.proxmox.com Git - ceph.git/blob - ceph/src/boost/libs/optional/test/optional_test_move.cpp
1 // Copyright (C) 2014 - 2015 Andrzej Krzemienski.
3 // Use, modification, and distribution is subject to the Boost Software
4 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
7 // See http://www.boost.org/lib/optional for documentation.
9 // You are welcome to contact the author at:
13 #include "boost/optional/optional.hpp"
19 #include "boost/core/lightweight_test.hpp"
21 using boost::optional
;
24 //#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
25 //#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
27 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
32 sValueCopyConstructed
,
33 sValueMoveConstructed
,
48 OracleVal(int i
= 0) : s(sIntConstructed
), i(i
) {}
57 Oracle() : s(sDefaultConstructed
) {}
58 Oracle(const OracleVal
& v
) : s(sValueCopyConstructed
), val(v
) {}
59 Oracle(OracleVal
&& v
) : s(sValueMoveConstructed
), val(std::move(v
)) {v
.s
= sMovedFrom
;}
60 Oracle(const Oracle
& o
) : s(sCopyConstructed
), val(o
.val
) {}
61 Oracle(Oracle
&& o
) : s(sMoveConstructed
), val(std::move(o
.val
)) {o
.s
= sMovedFrom
;}
63 Oracle
& operator=(const OracleVal
& v
) { s
= sValueCopyAssigned
; val
= v
; return *this; }
64 Oracle
& operator=(OracleVal
&& v
) { s
= sValueMoveAssigned
; val
= std::move(v
); v
.s
= sMovedFrom
; return *this; }
65 Oracle
& operator=(const Oracle
& o
) { s
= sCopyAssigned
; val
= o
.val
; return *this; }
66 Oracle
& operator=(Oracle
&& o
) { s
= sMoveAssigned
; val
= std::move(o
.val
); o
.s
= sMovedFrom
; return *this; }
69 bool operator==( Oracle
const& a
, Oracle
const& b
) { return a
.val
.i
== b
.val
.i
; }
70 bool operator!=( Oracle
const& a
, Oracle
const& b
) { return a
.val
.i
!= b
.val
.i
; }
73 void test_move_ctor_from_U()
75 optional
<Oracle
> o1 ((OracleVal()));
77 BOOST_TEST(o1
->s
== sValueMoveConstructed
|| o1
->s
== sMoveConstructed
);
80 optional
<Oracle
> o2 (v1
);
82 BOOST_TEST(o2
->s
== sValueCopyConstructed
|| o2
->s
== sCopyConstructed
|| o2
->s
== sMoveConstructed
);
83 BOOST_TEST(v1
.s
== sIntConstructed
);
85 optional
<Oracle
> o3 (boost::move(v1
));
87 BOOST_TEST(o3
->s
== sValueMoveConstructed
|| o3
->s
== sMoveConstructed
);
88 BOOST_TEST(v1
.s
== sMovedFrom
);
91 void test_move_ctor_form_T()
93 optional
<Oracle
> o1 ((Oracle()));
95 BOOST_TEST(o1
->s
== sMoveConstructed
);
98 optional
<Oracle
> o2 (v1
);
100 BOOST_TEST(o2
->s
== sCopyConstructed
);
101 BOOST_TEST(v1
.s
== sDefaultConstructed
);
103 optional
<Oracle
> o3 (boost::move(v1
));
105 BOOST_TEST(o3
->s
== sMoveConstructed
);
106 BOOST_TEST(v1
.s
== sMovedFrom
);
109 void test_move_ctor_from_optional_T()
112 optional
<Oracle
> o2(boost::move(o1
));
117 optional
<Oracle
> o3((Oracle()));
118 optional
<Oracle
> o4(boost::move(o3
));
121 BOOST_TEST(o3
->s
== sMovedFrom
);
122 BOOST_TEST(o4
->s
== sMoveConstructed
);
124 optional
<Oracle
> o5((optional
<Oracle
>()));
127 optional
<Oracle
> o6((optional
<Oracle
>(Oracle())));
129 BOOST_TEST(o6
->s
== sMoveConstructed
);
131 optional
<Oracle
> o7(o6
); // does copy ctor from non-const lvalue compile?
134 void test_move_assign_from_U()
136 optional
<Oracle
> o1
= boost::none
; // test if additional ctors didn't break it
137 o1
= boost::none
; // test if additional assignments didn't break it
141 BOOST_TEST(o1
->s
== sValueMoveConstructed
);
145 BOOST_TEST(o1
->s
== sMoveAssigned
);
151 BOOST_TEST(o2
->s
== sValueCopyConstructed
);
152 BOOST_TEST(v1
.s
== sIntConstructed
);
155 BOOST_TEST(o2
->s
== sCopyAssigned
|| o2
->s
== sMoveAssigned
);
156 BOOST_TEST(v1
.s
== sIntConstructed
);
159 o3
= boost::move(v1
);
161 BOOST_TEST(o3
->s
== sValueMoveConstructed
);
162 BOOST_TEST(v1
.s
== sMovedFrom
);
165 void test_move_assign_from_T()
170 BOOST_TEST(o1
->s
== sMoveConstructed
);
174 BOOST_TEST(o1
->s
== sMoveAssigned
);
180 BOOST_TEST(o2
->s
== sCopyConstructed
);
181 BOOST_TEST(v1
.s
== sDefaultConstructed
);
184 BOOST_TEST(o2
->s
== sCopyAssigned
);
185 BOOST_TEST(v1
.s
== sDefaultConstructed
);
188 o3
= boost::move(v1
);
190 BOOST_TEST(o3
->s
== sMoveConstructed
);
191 BOOST_TEST(v1
.s
== sMovedFrom
);
194 void test_move_assign_from_optional_T()
198 o1
= optional
<Oracle
>();
200 optional
<Oracle
> o3((Oracle()));
203 BOOST_TEST(o3
->s
== sMoveConstructed
);
205 BOOST_TEST(o1
->s
== sCopyConstructed
);
207 o2
= boost::move(o3
);
209 BOOST_TEST(o3
->s
== sMovedFrom
);
211 BOOST_TEST(o2
->s
== sMoveConstructed
);
213 o2
= optional
<Oracle
>((Oracle()));
215 BOOST_TEST(o2
->s
== sMoveAssigned
);
222 MoveOnly(int v
) : val(v
) {}
223 MoveOnly(MoveOnly
&& rhs
) : val(rhs
.val
) { rhs
.val
= 0; }
224 void operator=(MoveOnly
&& rhs
) {val
= rhs
.val
; rhs
.val
= 0; }
227 MoveOnly(MoveOnly
const&);
228 void operator=(MoveOnly
const&);
230 friend class MoveOnlyB
;
233 void test_with_move_only()
235 optional
<MoveOnly
> o1
;
236 optional
<MoveOnly
> o2((MoveOnly(1)));
238 BOOST_TEST(o2
->val
== 1);
239 optional
<MoveOnly
> o3 (boost::move(o1
));
241 optional
<MoveOnly
> o4 (boost::move(o2
));
243 BOOST_TEST(o4
->val
== 1);
245 BOOST_TEST(o2
->val
== 0);
247 o3
= boost::move(o4
);
249 BOOST_TEST(o3
->val
== 1);
251 BOOST_TEST(o4
->val
== 0);
258 MoveOnlyB(int v
) : val(v
) {}
259 MoveOnlyB(MoveOnlyB
&& rhs
) : val(rhs
.val
) { rhs
.val
= 0; }
260 void operator=(MoveOnlyB
&& rhs
) {val
= rhs
.val
; rhs
.val
= 0; }
261 MoveOnlyB(MoveOnly
&& rhs
) : val(rhs
.val
) { rhs
.val
= 0; }
262 void operator=(MoveOnly
&& rhs
) {val
= rhs
.val
; rhs
.val
= 0; }
265 MoveOnlyB(MoveOnlyB
const&);
266 void operator=(MoveOnlyB
const&);
267 MoveOnlyB(MoveOnly
const&);
268 void operator=(MoveOnly
const&);
271 void test_move_assign_from_optional_U()
273 optional
<MoveOnly
> a((MoveOnly(2)));
274 optional
<MoveOnlyB
> b1
;
278 BOOST_TEST(b1
->val
== 2);
280 BOOST_TEST(a
->val
== 0);
285 BOOST_TEST(b1
->val
== 4);
288 void test_move_ctor_from_optional_U()
290 optional
<MoveOnly
> a((MoveOnly(2)));
291 optional
<MoveOnlyB
> b1(boost::move(a
));
294 BOOST_TEST(b1
->val
== 2);
296 BOOST_TEST(a
->val
== 0);
298 optional
<MoveOnlyB
> b2(( optional
<MoveOnly
>(( MoveOnly(4) )) ));
301 BOOST_TEST(b2
->val
== 4);
306 optional
<MoveOnly
> a((MoveOnly(2)));
307 optional
<MoveOnly
> b((MoveOnly(3)));
310 BOOST_TEST(a
->val
== 3);
311 BOOST_TEST(b
->val
== 2);
314 void test_optional_ref_to_movables()
317 optional
<MoveOnly
&> orm
= m
;
319 BOOST_TEST(m
.val
== 2);
321 optional
<MoveOnly
&> orm2
= orm
;
323 BOOST_TEST(m
.val
== 1);
324 BOOST_TEST(orm
->val
== 1);
326 optional
<MoveOnly
&> orm3
= boost::move(orm
);
328 BOOST_TEST(m
.val
== 4);
329 BOOST_TEST(orm
->val
== 4);
330 BOOST_TEST(orm2
->val
== 4);
337 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
338 test_move_ctor_from_U();
339 test_move_ctor_form_T();
340 test_move_ctor_from_optional_T();
341 test_move_ctor_from_optional_U();
342 test_move_assign_from_U();
343 test_move_assign_from_T();
344 test_move_assign_from_optional_T();
345 test_move_assign_from_optional_U();
346 test_with_move_only();
347 test_optional_ref_to_movables();
351 return boost::report_errors();