1 | // Copyright 2017, 2021 Peter Dimov. |
2 | // Distributed under the Boost Software License, Version 1.0. |
3 | // https://www.boost.org/LICENSE_1_0.txt |
4 | |
5 | #include <boost/system/result.hpp> |
6 | #include <boost/core/lightweight_test.hpp> |
7 | #include <boost/core/lightweight_test_trait.hpp> |
8 | #include <string> |
9 | |
10 | using namespace boost::system; |
11 | |
12 | struct X |
13 | { |
14 | int v_; |
15 | |
16 | explicit X( int v = 0 ): v_( v ) {} |
17 | |
18 | X( X const& ) = default; |
19 | X& operator=( X const& ) = delete; |
20 | }; |
21 | |
22 | int main() |
23 | { |
24 | { |
25 | result<int> r; |
26 | |
27 | BOOST_TEST( r.has_value() ); |
28 | BOOST_TEST( !r.has_error() ); |
29 | |
30 | BOOST_TEST_EQ( r.error(), error_code() ); |
31 | } |
32 | |
33 | { |
34 | result<int> const r; |
35 | |
36 | BOOST_TEST( r.has_value() ); |
37 | BOOST_TEST( !r.has_error() ); |
38 | |
39 | BOOST_TEST_EQ( r.error(), error_code() ); |
40 | } |
41 | |
42 | { |
43 | BOOST_TEST( result<int>().has_value() ); |
44 | BOOST_TEST( !result<int>().has_error() ); |
45 | |
46 | BOOST_TEST_EQ( result<int>().error(), error_code() ); |
47 | } |
48 | |
49 | { |
50 | result<int> r( 1 ); |
51 | |
52 | BOOST_TEST( r.has_value() ); |
53 | BOOST_TEST( !r.has_error() ); |
54 | |
55 | BOOST_TEST_EQ( r.error(), error_code() ); |
56 | } |
57 | |
58 | { |
59 | result<int> const r( 1 ); |
60 | |
61 | BOOST_TEST( r.has_value() ); |
62 | BOOST_TEST( !r.has_error() ); |
63 | |
64 | BOOST_TEST_EQ( r.error(), error_code() ); |
65 | } |
66 | |
67 | { |
68 | BOOST_TEST( result<int>( 1 ).has_value() ); |
69 | BOOST_TEST( !result<int>( 1 ).has_error() ); |
70 | |
71 | BOOST_TEST_EQ( result<int>( 1 ).error(), error_code() ); |
72 | } |
73 | |
74 | { |
75 | auto ec = make_error_code( e: errc::invalid_argument ); |
76 | |
77 | result<int> r( ec ); |
78 | |
79 | BOOST_TEST( !r.has_value() ); |
80 | BOOST_TEST( r.has_error() ); |
81 | |
82 | BOOST_TEST_EQ( r.error(), ec ); |
83 | } |
84 | |
85 | { |
86 | auto ec = make_error_code( e: errc::invalid_argument ); |
87 | |
88 | result<int> const r( ec ); |
89 | |
90 | BOOST_TEST( !r.has_value() ); |
91 | BOOST_TEST( r.has_error() ); |
92 | |
93 | BOOST_TEST_EQ( r.error(), ec ); |
94 | } |
95 | |
96 | { |
97 | auto ec = make_error_code( e: errc::invalid_argument ); |
98 | |
99 | BOOST_TEST( !result<int>( ec ).has_value() ); |
100 | BOOST_TEST( result<int>( ec ).has_error() ); |
101 | |
102 | BOOST_TEST_EQ( result<int>( ec ).error(), ec ); |
103 | } |
104 | |
105 | { |
106 | result<std::string, X> r( 1 ); |
107 | |
108 | BOOST_TEST( !r.has_value() ); |
109 | BOOST_TEST( r.has_error() ); |
110 | |
111 | BOOST_TEST_EQ( r.error().v_, 1 ); |
112 | } |
113 | |
114 | { |
115 | result<std::string, X> const r( 1 ); |
116 | |
117 | BOOST_TEST( !r.has_value() ); |
118 | BOOST_TEST( r.has_error() ); |
119 | |
120 | BOOST_TEST_EQ( r.error().v_, 1 ); |
121 | } |
122 | |
123 | { |
124 | BOOST_TEST(( !result<std::string, X>( 1 ).has_value() )); |
125 | BOOST_TEST(( result<std::string, X>( 1 ).has_error() )); |
126 | |
127 | BOOST_TEST_EQ( (result<std::string, X>( 1 ).error().v_), 1 ); |
128 | } |
129 | |
130 | { |
131 | result<std::string, X> r( "s" ); |
132 | |
133 | BOOST_TEST( r.has_value() ); |
134 | BOOST_TEST( !r.has_error() ); |
135 | |
136 | BOOST_TEST_EQ( r.error().v_, 0 ); |
137 | } |
138 | |
139 | { |
140 | result<std::string, X> const r( "s" ); |
141 | |
142 | BOOST_TEST( r.has_value() ); |
143 | BOOST_TEST( !r.has_error() ); |
144 | |
145 | BOOST_TEST_EQ( r.error().v_, 0 ); |
146 | } |
147 | |
148 | { |
149 | BOOST_TEST(( result<std::string, X>( "s" ).has_value() )); |
150 | BOOST_TEST(( !result<std::string, X>( "s" ).has_error() )); |
151 | |
152 | BOOST_TEST_EQ( (result<std::string, X>( "s" ).error().v_), 0 ); |
153 | } |
154 | |
155 | // |
156 | |
157 | { |
158 | result<void> r; |
159 | |
160 | BOOST_TEST( r.has_value() ); |
161 | BOOST_TEST( !r.has_error() ); |
162 | |
163 | BOOST_TEST_EQ( r.error(), error_code() ); |
164 | } |
165 | |
166 | { |
167 | result<void> const r; |
168 | |
169 | BOOST_TEST( r.has_value() ); |
170 | BOOST_TEST( !r.has_error() ); |
171 | |
172 | BOOST_TEST_EQ( r.error(), error_code() ); |
173 | } |
174 | |
175 | { |
176 | BOOST_TEST( result<void>().has_value() ); |
177 | BOOST_TEST( !result<void>().has_error() ); |
178 | |
179 | BOOST_TEST_EQ( result<void>().error(), error_code() ); |
180 | } |
181 | |
182 | { |
183 | auto ec = make_error_code( e: errc::invalid_argument ); |
184 | |
185 | result<void> r( ec ); |
186 | |
187 | BOOST_TEST( !r.has_value() ); |
188 | BOOST_TEST( r.has_error() ); |
189 | |
190 | BOOST_TEST_EQ( r.error(), ec ); |
191 | } |
192 | |
193 | { |
194 | auto ec = make_error_code( e: errc::invalid_argument ); |
195 | |
196 | result<void> const r( ec ); |
197 | |
198 | BOOST_TEST( !r.has_value() ); |
199 | BOOST_TEST( r.has_error() ); |
200 | |
201 | BOOST_TEST_EQ( r.error(), ec ); |
202 | } |
203 | |
204 | { |
205 | auto ec = make_error_code( e: errc::invalid_argument ); |
206 | |
207 | BOOST_TEST( !result<void>( ec ).has_value() ); |
208 | BOOST_TEST( result<void>( ec ).has_error() ); |
209 | |
210 | BOOST_TEST_EQ( result<void>( ec ).error(), ec ); |
211 | } |
212 | |
213 | // |
214 | |
215 | { |
216 | int x1 = 1; |
217 | |
218 | result<int&> r( x1 ); |
219 | |
220 | BOOST_TEST( r.has_value() ); |
221 | BOOST_TEST( !r.has_error() ); |
222 | |
223 | BOOST_TEST_EQ( r.error(), error_code() ); |
224 | } |
225 | |
226 | { |
227 | int x1 = 1; |
228 | |
229 | result<int&> const r( x1 ); |
230 | |
231 | BOOST_TEST( r.has_value() ); |
232 | BOOST_TEST( !r.has_error() ); |
233 | |
234 | BOOST_TEST_EQ( r.error(), error_code() ); |
235 | } |
236 | |
237 | { |
238 | int x1 = 1; |
239 | |
240 | BOOST_TEST( result<int&>( x1 ).has_value() ); |
241 | BOOST_TEST( !result<int&>( x1 ).has_error() ); |
242 | |
243 | BOOST_TEST_EQ( result<int&>( x1 ).error(), error_code() ); |
244 | } |
245 | |
246 | { |
247 | auto ec = make_error_code( e: errc::invalid_argument ); |
248 | |
249 | result<int&> r( ec ); |
250 | |
251 | BOOST_TEST( !r.has_value() ); |
252 | BOOST_TEST( r.has_error() ); |
253 | |
254 | BOOST_TEST_EQ( r.error(), ec ); |
255 | } |
256 | |
257 | { |
258 | auto ec = make_error_code( e: errc::invalid_argument ); |
259 | |
260 | result<int&> const r( ec ); |
261 | |
262 | BOOST_TEST( !r.has_value() ); |
263 | BOOST_TEST( r.has_error() ); |
264 | |
265 | BOOST_TEST_EQ( r.error(), ec ); |
266 | } |
267 | |
268 | { |
269 | auto ec = make_error_code( e: errc::invalid_argument ); |
270 | |
271 | BOOST_TEST( !result<int&>( ec ).has_value() ); |
272 | BOOST_TEST( result<int&>( ec ).has_error() ); |
273 | |
274 | BOOST_TEST_EQ( result<int&>( ec ).error(), ec ); |
275 | } |
276 | |
277 | // |
278 | |
279 | return boost::report_errors(); |
280 | } |
281 | |