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};
63
64struct Y2
65{
66 ~Y2() {}
67};
68
69struct Guard
70{
71 explicit Guard(int) {}
72 Guard(Guard&&) = delete;
73};
74
75int main()
76{
77 {
78 variant<int> v;
79 BOOST_TEST_EQ( get<0>(v), 0 );
80
81 v.emplace<int>( a: 1 );
82 BOOST_TEST_EQ( get<0>(v), 1 );
83
84 v.emplace<int>();
85 BOOST_TEST_EQ( get<0>(v), 0 );
86 }
87
88 {
89 variant<int, float> v;
90 BOOST_TEST_EQ( v.index(), 0 );
91 BOOST_TEST_EQ( get<0>(v), 0 );
92
93 v.emplace<int>( a: 1 );
94 BOOST_TEST_EQ( v.index(), 0 );
95 BOOST_TEST_EQ( get<0>(v), 1 );
96
97 v.emplace<float>( a: 3.14f );
98 BOOST_TEST_EQ( v.index(), 1 );
99 BOOST_TEST_EQ( get<1>(v), 3.14f );
100
101 v.emplace<float>();
102 BOOST_TEST_EQ( v.index(), 1 );
103 BOOST_TEST_EQ( get<1>(v), 0 );
104
105 v.emplace<int>();
106 BOOST_TEST_EQ( v.index(), 0 );
107 BOOST_TEST_EQ( get<0>(v), 0 );
108 }
109
110 {
111 variant<int, int, float, std::string> v;
112 BOOST_TEST_EQ( v.index(), 0 );
113 BOOST_TEST_EQ( get<0>(v), 0 );
114
115 v.emplace<float>( a: 3.14f );
116 BOOST_TEST_EQ( v.index(), 2 );
117 BOOST_TEST_EQ( get<2>(v), 3.14f );
118
119 v.emplace<float>();
120 BOOST_TEST_EQ( v.index(), 2 );
121 BOOST_TEST_EQ( get<2>(v), 0 );
122
123 v.emplace<std::string>( a: "s1" );
124 BOOST_TEST_EQ( v.index(), 3 );
125 BOOST_TEST_EQ( get<3>(v), std::string("s1") );
126
127 v.emplace<std::string>( a: "s2" );
128 BOOST_TEST_EQ( v.index(), 3 );
129 BOOST_TEST_EQ( get<3>(v), std::string("s2") );
130
131 v.emplace<std::string>();
132 BOOST_TEST_EQ( v.index(), 3 );
133 BOOST_TEST_EQ( get<3>(v), std::string() );
134
135 v.emplace<std::string>( il: { 'a', 'b' } );
136 BOOST_TEST_EQ( v.index(), 3 );
137 BOOST_TEST_EQ( get<3>(v), (std::string{ 'a', 'b' }) );
138
139 v.emplace<std::string>( il: { 'c', 'd' }, a: std::allocator<char>() );
140 BOOST_TEST_EQ( v.index(), 3 );
141 BOOST_TEST_EQ( get<3>(v), (std::string{ 'c', 'd' }) );
142 }
143
144 {
145 variant<X1, X2> v;
146 BOOST_TEST_EQ( v.index(), 0 );
147 BOOST_TEST_EQ( get<0>(v).v, 0 );
148
149 v.emplace<X1>( a: 1 );
150 BOOST_TEST_EQ( v.index(), 0 );
151 BOOST_TEST_EQ( get<0>(v).v, 1 );
152
153 v.emplace<X2>( a: 2 );
154 BOOST_TEST_EQ( v.index(), 1 );
155 BOOST_TEST_EQ( get<1>(v).v, 2 );
156
157 v.emplace<X1>();
158 BOOST_TEST_EQ( v.index(), 0 );
159 BOOST_TEST_EQ( get<0>(v).v, 0 );
160
161 v.emplace<X1>( a: 4 );
162 BOOST_TEST_EQ( v.index(), 0 );
163 BOOST_TEST_EQ( get<0>(v).v, 4 );
164
165 v.emplace<X2>();
166
167 BOOST_TEST_EQ( v.index(), 1 );
168 BOOST_TEST_EQ( get<1>(v).v, 0 );
169
170 v.emplace<X2>( a: 6 );
171 BOOST_TEST_EQ( v.index(), 1 );
172 BOOST_TEST_EQ( get<1>(v).v, 6 );
173
174 v.emplace<X1>( a: 3 );
175 BOOST_TEST_EQ( v.index(), 0 );
176 BOOST_TEST_EQ( get<0>(v).v, 3 );
177
178 v.emplace<X1>( a: 4 );
179 BOOST_TEST_EQ( v.index(), 0 );
180 BOOST_TEST_EQ( get<0>(v).v, 4 );
181 }
182
183 {
184 variant<Y1, Guard> v;
185 v.emplace<Guard>( a: 1 );
186 }
187
188 {
189 variant<Y2, Guard> v;
190 v.emplace<Guard>( a: 1 );
191 }
192
193 return boost::report_errors();
194}
195

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