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
10using namespace boost::system;
11
12struct 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
22int 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

source code of boost/libs/system/test/result_error_access.cpp