1
2// Copyright 2017 Peter Dimov.
3//
4// Distributed under the Boost Software License, Version 1.0.
5//
6// See accompanying file LICENSE_1_0.txt or copy at
7// http://www.boost.org/LICENSE_1_0.txt
8
9#include <boost/variant2/variant.hpp>
10#include <boost/core/lightweight_test.hpp>
11#include <boost/core/lightweight_test_trait.hpp>
12#include <type_traits>
13#include <utility>
14#include <string>
15
16using namespace boost::variant2;
17
18#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
19
20struct X1
21{
22 int v;
23
24 X1(): v(0) {}
25 explicit X1(int v): v(v) {}
26 X1(X1 const& r): v(r.v) {}
27 X1(X1&& r): v(r.v) {}
28 X1& operator=( X1 const& r ) { v = r.v; return *this; }
29 X1& operator=( X1&& r ) { v = r.v; return *this; }
30};
31
32inline bool operator==( X1 const& a, X1 const& b ) { return a.v == b.v; }
33
34STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
35STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
36STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
37STATIC_ASSERT( !std::is_nothrow_copy_assignable<X1>::value );
38STATIC_ASSERT( !std::is_nothrow_move_assignable<X1>::value );
39
40struct X2
41{
42 int v;
43
44 X2(): v(0) {}
45 explicit X2(int v): v(v) {}
46 X2(X2 const& r): v(r.v) {}
47 X2(X2&& r): v(r.v) {}
48 X2& operator=( X2 const& r ) { v = r.v; return *this; }
49 X2& operator=( X2&& r ) { v = r.v; return *this; }
50};
51
52inline bool operator==( X2 const& a, X2 const& b ) { return a.v == b.v; }
53
54STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
55STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
56STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
57STATIC_ASSERT( !std::is_nothrow_copy_assignable<X2>::value );
58STATIC_ASSERT( !std::is_nothrow_move_assignable<X2>::value );
59
60int main()
61{
62 {
63 variant<int> v;
64 BOOST_TEST_EQ( get<0>(v), 0 );
65
66 variant<int> v2( 1 );
67 BOOST_TEST_EQ( get<0>(v2), 1 );
68
69 swap( v, w&: v2 );
70 BOOST_TEST_EQ( get<0>(v), 1 );
71 BOOST_TEST_EQ( get<0>(v2), 0 );
72
73 variant<int> v3( 2 );
74 BOOST_TEST_EQ( get<0>(v3), 2 );
75
76 swap( v, w&: v3 );
77 BOOST_TEST_EQ( get<0>(v), 2 );
78 BOOST_TEST_EQ( get<0>(v3), 1 );
79 }
80
81 {
82 variant<int, float> v;
83
84 BOOST_TEST_EQ( v.index(), 0 );
85 BOOST_TEST_EQ( get<0>(v), 0 );
86
87 variant<int, float> v2( 1 );
88
89 BOOST_TEST_EQ( v2.index(), 0 );
90 BOOST_TEST_EQ( get<0>(v2), 1 );
91
92 swap( v, w&: v2 );
93
94 BOOST_TEST_EQ( v.index(), 0 );
95 BOOST_TEST_EQ( get<0>(v), 1 );
96
97 BOOST_TEST_EQ( v2.index(), 0 );
98 BOOST_TEST_EQ( get<0>(v2), 0 );
99
100 variant<int, float> v3( 3.14f );
101
102 BOOST_TEST_EQ( v3.index(), 1 );
103 BOOST_TEST_EQ( get<1>(v3), 3.14f );
104
105 swap( v, w&: v3 );
106
107 BOOST_TEST_EQ( v.index(), 1 );
108 BOOST_TEST_EQ( get<1>(v), 3.14f );
109
110 BOOST_TEST_EQ( v3.index(), 0 );
111 BOOST_TEST_EQ( get<0>(v3), 1 );
112
113 variant<int, float> v4( 3.15f );
114
115 BOOST_TEST_EQ( v4.index(), 1 );
116 BOOST_TEST_EQ( get<1>(v4), 3.15f );
117
118 swap( v, w&: v4 );
119
120 BOOST_TEST_EQ( v.index(), 1 );
121 BOOST_TEST_EQ( get<1>(v), 3.15f );
122
123 BOOST_TEST_EQ( v4.index(), 1 );
124 BOOST_TEST_EQ( get<1>(v4), 3.14f );
125 }
126
127 {
128 variant<int, int, float, std::string> v;
129
130 BOOST_TEST_EQ( v.index(), 0 );
131 BOOST_TEST_EQ( get<0>(v), 0 );
132
133 variant<int, int, float, std::string> v2( in_place_index_t<1>{}, 1 );
134
135 BOOST_TEST_EQ( v2.index(), 1 );
136 BOOST_TEST_EQ( get<1>(v2), 1 );
137
138 swap( v, w&: v2 );
139
140 BOOST_TEST_EQ( v.index(), 1 );
141 BOOST_TEST_EQ( get<1>(v), 1 );
142
143 BOOST_TEST_EQ( v2.index(), 0 );
144 BOOST_TEST_EQ( get<0>(v2), 0 );
145
146 variant<int, int, float, std::string> v3( 3.14f );
147
148 BOOST_TEST_EQ( v3.index(), 2 );
149 BOOST_TEST_EQ( get<2>(v3), 3.14f );
150
151 swap( v, w&: v3 );
152
153 BOOST_TEST_EQ( v.index(), 2 );
154 BOOST_TEST_EQ( get<2>(v), 3.14f );
155
156 BOOST_TEST_EQ( v3.index(), 1 );
157 BOOST_TEST_EQ( get<1>(v3), 1 );
158
159 variant<int, int, float, std::string> v4( 3.15f );
160
161 BOOST_TEST_EQ( v4.index(), 2 );
162 BOOST_TEST_EQ( get<2>(v4), 3.15f );
163
164 swap( v, w&: v4 );
165
166 BOOST_TEST_EQ( v.index(), 2 );
167 BOOST_TEST_EQ( get<2>(v), 3.15f );
168
169 BOOST_TEST_EQ( v4.index(), 2 );
170 BOOST_TEST_EQ( get<2>(v4), 3.14f );
171
172 variant<int, int, float, std::string> v5( "s1" );
173
174 BOOST_TEST_EQ( v5.index(), 3 );
175 BOOST_TEST_EQ( get<3>(v5), std::string("s1") );
176
177 swap( v, w&: v5 );
178
179 BOOST_TEST_EQ( v.index(), 3 );
180 BOOST_TEST_EQ( get<3>(v), std::string("s1") );
181
182 BOOST_TEST_EQ( v5.index(), 2 );
183 BOOST_TEST_EQ( get<2>(v5), 3.15f );
184
185 variant<int, int, float, std::string> v6( "s2" );
186
187 BOOST_TEST_EQ( v6.index(), 3 );
188 BOOST_TEST_EQ( get<3>(v6), std::string("s2") );
189
190 swap( v, w&: v6 );
191
192 BOOST_TEST_EQ( v.index(), 3 );
193 BOOST_TEST_EQ( get<3>(v), std::string("s2") );
194
195 BOOST_TEST_EQ( v6.index(), 3 );
196 BOOST_TEST_EQ( get<3>(v6), std::string("s1") );
197 }
198
199 {
200 variant<X1, X2> v;
201
202 BOOST_TEST_EQ( v.index(), 0 );
203 BOOST_TEST_EQ( get<0>(v).v, 0 );
204
205 variant<X1, X2> v2( X1{1} );
206
207 BOOST_TEST_EQ( v2.index(), 0 );
208 BOOST_TEST_EQ( get<0>(v2).v, 1 );
209
210 swap( v, w&: v2 );
211
212 BOOST_TEST_EQ( v.index(), 0 );
213 BOOST_TEST_EQ( get<0>(v).v, 1 );
214
215 BOOST_TEST_EQ( v2.index(), 0 );
216 BOOST_TEST_EQ( get<0>(v2).v, 0 );
217
218 variant<X1, X2> v3( in_place_index_t<1>{}, 2 );
219
220 BOOST_TEST_EQ( v3.index(), 1 );
221 BOOST_TEST_EQ( get<1>(v3).v, 2 );
222
223 swap( v, w&: v3 );
224
225 BOOST_TEST_EQ( v.index(), 1 );
226 BOOST_TEST_EQ( get<1>(v).v, 2 );
227
228 BOOST_TEST_EQ( v3.index(), 0 );
229 BOOST_TEST_EQ( get<0>(v3).v, 1 );
230
231 variant<X1, X2> v4( in_place_index_t<1>{}, 3 );
232
233 BOOST_TEST_EQ( v4.index(), 1 );
234 BOOST_TEST_EQ( get<1>(v4).v, 3 );
235
236 swap( v, w&: v4 );
237
238 BOOST_TEST_EQ( v.index(), 1 );
239 BOOST_TEST_EQ( get<1>(v).v, 3 );
240
241 BOOST_TEST_EQ( v4.index(), 1 );
242 BOOST_TEST_EQ( get<1>(v4).v, 2 );
243
244 variant<X1, X2> v5( in_place_index_t<0>{}, 4 );
245
246 BOOST_TEST_EQ( v5.index(), 0 );
247 BOOST_TEST_EQ( get<0>(v5).v, 4 );
248
249 swap( v, w&: v5 );
250
251 BOOST_TEST_EQ( v.index(), 0 );
252 BOOST_TEST_EQ( get<0>(v).v, 4 );
253
254 BOOST_TEST_EQ( v5.index(), 1 );
255 BOOST_TEST_EQ( get<1>(v5).v, 3 );
256 }
257
258 return boost::report_errors();
259}
260

source code of boost/libs/variant2/test/variant_swap.cpp