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
60struct Y1
61{
62 int v = 1;
63
64 Y1() = default;
65 Y1(Y1 const&) = delete;
66 Y1(Y1&&) = delete;
67};
68
69STATIC_ASSERT( !std::is_copy_constructible<Y1>::value );
70STATIC_ASSERT( !std::is_move_constructible<Y1>::value );
71
72struct Y2
73{
74 int v = 2;
75
76 Y2() = default;
77 Y2(Y2 const&) = delete;
78 Y2(Y2&&) = delete;
79};
80
81STATIC_ASSERT( !std::is_copy_constructible<Y2>::value );
82STATIC_ASSERT( !std::is_move_constructible<Y2>::value );
83
84struct Z1
85{
86 static int instances;
87
88 int v = 1;
89
90 Z1() { ++instances; }
91 ~Z1() { --instances; }
92
93 Z1(Z1 const&) = delete;
94 Z1(Z1&&) = delete;
95};
96
97int Z1::instances = 0;
98
99struct Z2
100{
101 static int instances;
102
103 int v = 2;
104
105 Z2() { ++instances; }
106 ~Z2() { --instances; }
107
108 Z2(Z2 const&) = delete;
109 Z2(Z2&&) = delete;
110};
111
112int Z2::instances = 0;
113
114int main()
115{
116 {
117 variant<int> v;
118 BOOST_TEST_EQ( get<0>(v), 0 );
119
120 v.emplace<0>( a: 1 );
121 BOOST_TEST_EQ( get<0>(v), 1 );
122
123 v.emplace<0>();
124 BOOST_TEST_EQ( get<0>(v), 0 );
125 }
126
127 {
128 variant<int, float> v;
129 BOOST_TEST_EQ( v.index(), 0 );
130 BOOST_TEST_EQ( get<0>(v), 0 );
131
132 v.emplace<0>( a: 1 );
133 BOOST_TEST_EQ( v.index(), 0 );
134 BOOST_TEST_EQ( get<0>(v), 1 );
135
136 v.emplace<1>( a: 3.14f );
137 BOOST_TEST_EQ( v.index(), 1 );
138 BOOST_TEST_EQ( get<1>(v), 3.14f );
139
140 v.emplace<1>();
141 BOOST_TEST_EQ( v.index(), 1 );
142 BOOST_TEST_EQ( get<1>(v), 0 );
143
144 v.emplace<0>();
145 BOOST_TEST_EQ( v.index(), 0 );
146 BOOST_TEST_EQ( get<0>(v), 0 );
147 }
148
149 {
150 variant<int, int, float, std::string> v;
151 BOOST_TEST_EQ( v.index(), 0 );
152 BOOST_TEST_EQ( get<0>(v), 0 );
153
154 v.emplace<0>( a: 1 );
155 BOOST_TEST_EQ( v.index(), 0 );
156 BOOST_TEST_EQ( get<0>(v), 1 );
157
158 v.emplace<1>();
159 BOOST_TEST_EQ( v.index(), 1 );
160 BOOST_TEST_EQ( get<1>(v), 0 );
161
162 v.emplace<1>( a: 1 );
163 BOOST_TEST_EQ( v.index(), 1 );
164 BOOST_TEST_EQ( get<1>(v), 1 );
165
166 v.emplace<2>( a: 3.14f );
167 BOOST_TEST_EQ( v.index(), 2 );
168 BOOST_TEST_EQ( get<2>(v), 3.14f );
169
170 v.emplace<2>();
171 BOOST_TEST_EQ( v.index(), 2 );
172 BOOST_TEST_EQ( get<2>(v), 0 );
173
174 v.emplace<3>( a: "s1" );
175 BOOST_TEST_EQ( v.index(), 3 );
176 BOOST_TEST_EQ( get<3>(v), std::string("s1") );
177
178 v.emplace<3>( a: "s2" );
179 BOOST_TEST_EQ( v.index(), 3 );
180 BOOST_TEST_EQ( get<3>(v), std::string("s2") );
181
182 v.emplace<3>();
183 BOOST_TEST_EQ( v.index(), 3 );
184 BOOST_TEST_EQ( get<3>(v), std::string() );
185
186 v.emplace<3>( il: { 'a', 'b' } );
187 BOOST_TEST_EQ( v.index(), 3 );
188 BOOST_TEST_EQ( get<3>(v), (std::string{ 'a', 'b'}) );
189
190 v.emplace<3>( il: { 'c', 'd' }, a: std::allocator<char>() );
191 BOOST_TEST_EQ( v.index(), 3 );
192 BOOST_TEST_EQ( get<3>(v), (std::string{ 'c', 'd'}) );
193 }
194
195 {
196 variant<X1, X2> v;
197 BOOST_TEST_EQ( v.index(), 0 );
198 BOOST_TEST_EQ( get<0>(v).v, 0 );
199
200 v.emplace<0>( a: 1 );
201 BOOST_TEST_EQ( v.index(), 0 );
202 BOOST_TEST_EQ( get<0>(v).v, 1 );
203
204 v.emplace<1>( a: 2 );
205 BOOST_TEST_EQ( v.index(), 1 );
206 BOOST_TEST_EQ( get<1>(v).v, 2 );
207
208 v.emplace<0>();
209 BOOST_TEST_EQ( v.index(), 0 );
210 BOOST_TEST_EQ( get<0>(v).v, 0 );
211
212 v.emplace<0>( a: 4 );
213 BOOST_TEST_EQ( v.index(), 0 );
214 BOOST_TEST_EQ( get<0>(v).v, 4 );
215
216 v.emplace<1>();
217
218 BOOST_TEST_EQ( v.index(), 1 );
219 BOOST_TEST_EQ( get<1>(v).v, 0 );
220
221 v.emplace<1>( a: 6 );
222 BOOST_TEST_EQ( v.index(), 1 );
223 BOOST_TEST_EQ( get<1>(v).v, 6 );
224
225 v.emplace<0>( a: 3 );
226 BOOST_TEST_EQ( v.index(), 0 );
227 BOOST_TEST_EQ( get<0>(v).v, 3 );
228
229 v.emplace<0>( a: 4 );
230 BOOST_TEST_EQ( v.index(), 0 );
231 BOOST_TEST_EQ( get<0>(v).v, 4 );
232 }
233
234 {
235 variant<Y1, Y2> v;
236 BOOST_TEST_EQ( v.index(), 0 );
237 BOOST_TEST_EQ( get<0>(v).v, 1 );
238
239 v.emplace<0>();
240 BOOST_TEST_EQ( v.index(), 0 );
241 BOOST_TEST_EQ( get<0>(v).v, 1 );
242
243 v.emplace<1>();
244 BOOST_TEST_EQ( v.index(), 1 );
245 BOOST_TEST_EQ( get<1>(v).v, 2 );
246
247 v.emplace<1>();
248 BOOST_TEST_EQ( v.index(), 1 );
249 BOOST_TEST_EQ( get<1>(v).v, 2 );
250
251 v.emplace<0>();
252 BOOST_TEST_EQ( v.index(), 0 );
253 BOOST_TEST_EQ( get<0>(v).v, 1 );
254 }
255
256 {
257 variant<Z1, Z2> v;
258 BOOST_TEST_EQ( v.index(), 0 );
259 BOOST_TEST_EQ( get<0>(v).v, 1 );
260 BOOST_TEST_EQ( Z1::instances, 1 );
261 BOOST_TEST_EQ( Z2::instances, 0 );
262
263 v.emplace<0>();
264 BOOST_TEST_EQ( v.index(), 0 );
265 BOOST_TEST_EQ( get<0>(v).v, 1 );
266 BOOST_TEST_EQ( Z1::instances, 1 );
267 BOOST_TEST_EQ( Z2::instances, 0 );
268
269 v.emplace<1>();
270 BOOST_TEST_EQ( v.index(), 1 );
271 BOOST_TEST_EQ( get<1>(v).v, 2 );
272 BOOST_TEST_EQ( Z1::instances, 0 );
273 BOOST_TEST_EQ( Z2::instances, 1 );
274
275 v.emplace<1>();
276 BOOST_TEST_EQ( v.index(), 1 );
277 BOOST_TEST_EQ( get<1>(v).v, 2 );
278 BOOST_TEST_EQ( Z1::instances, 0 );
279 BOOST_TEST_EQ( Z2::instances, 1 );
280
281 v.emplace<0>();
282 BOOST_TEST_EQ( v.index(), 0 );
283 BOOST_TEST_EQ( get<0>(v).v, 1 );
284 BOOST_TEST_EQ( Z1::instances, 1 );
285 BOOST_TEST_EQ( Z2::instances, 0 );
286 }
287
288 BOOST_TEST_EQ( Z1::instances, 0 );
289 BOOST_TEST_EQ( Z2::instances, 0 );
290
291 {
292 variant<monostate, monostate> v;
293 BOOST_TEST_EQ( v.index(), 0 );
294
295 v.emplace<0>();
296 BOOST_TEST_EQ( v.index(), 0 );
297
298 v.emplace<1>();
299 BOOST_TEST_EQ( v.index(), 1 );
300
301 v.emplace<1>();
302 BOOST_TEST_EQ( v.index(), 1 );
303
304 v.emplace<0>();
305 BOOST_TEST_EQ( v.index(), 0 );
306 }
307
308 {
309 variant<monostate, int> v;
310 BOOST_TEST_EQ( v.index(), 0 );
311
312 v.emplace<0>();
313 BOOST_TEST_EQ( v.index(), 0 );
314
315 v.emplace<1>();
316 BOOST_TEST_EQ( v.index(), 1 );
317
318 v.emplace<1>();
319 BOOST_TEST_EQ( v.index(), 1 );
320
321 v.emplace<0>();
322 BOOST_TEST_EQ( v.index(), 0 );
323 }
324
325 return boost::report_errors();
326}
327

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