1// Copyright 2017, 2021, 2022 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
8using namespace boost::system;
9
10struct X
11{
12 int v_;
13};
14
15struct Y
16{
17 int v_;
18
19 explicit Y( int v ): v_( v ) {}
20 Y( X x ): v_( x.v_) {}
21
22 Y( Y const& ) = delete;
23 Y& operator=( Y const& ) = delete;
24
25 Y( Y&& r ): v_( r.v_ )
26 {
27 r.v_ = 0;
28 }
29
30 Y& operator=( Y&& ) = delete;
31};
32
33struct E
34{
35};
36
37result<int, E> fi()
38{
39 return 2;
40}
41
42result<int, E> fi2()
43{
44 return E();
45}
46
47result<Y, E> fy()
48{
49 return Y{ 2 };
50}
51
52result<Y, E> fy2()
53{
54 return E();
55}
56
57result<int&, E> fri()
58{
59 static int x = 2;
60 return x;
61}
62
63result<int&, E> fri2()
64{
65 return E();
66}
67
68result<void, E> fv()
69{
70 return {};
71}
72
73result<void, E> fv2()
74{
75 return E();
76}
77
78int main()
79{
80 {
81 result<int> r( 1 );
82
83 int x = r | fi | 3;
84
85 BOOST_TEST_EQ( x, 1 );
86 }
87
88 {
89 result<int> const r( 1 );
90
91 int x = r | fi | 3;
92
93 BOOST_TEST_EQ( x, 1 );
94 }
95
96 {
97 int x = result<int>( 1 ) | fi | 3;
98
99 BOOST_TEST_EQ( x, 1 );
100 }
101
102 {
103 result<int> r( 1 );
104
105 int x = r | fi2 | 3;
106
107 BOOST_TEST_EQ( x, 1 );
108 }
109
110 {
111 result<int> const r( 1 );
112
113 int x = r | fi2 | 3;
114
115 BOOST_TEST_EQ( x, 1 );
116 }
117
118 {
119 int x = result<int>( 1 ) | fi2 | 3;
120
121 BOOST_TEST_EQ( x, 1 );
122 }
123
124 {
125 result<int> r( in_place_error );
126
127 int x = r | fi | 3;
128
129 BOOST_TEST_EQ( x, 2 );
130 }
131
132 {
133 result<int> const r( in_place_error );
134
135 int x = r | fi | 3;
136
137 BOOST_TEST_EQ( x, 2 );
138 }
139
140 {
141 int x = result<int>( in_place_error ) | fi | 3;
142
143 BOOST_TEST_EQ( x, 2 );
144 }
145
146 {
147 result<int> r( in_place_error );
148
149 int x = r | fi2 | 3;
150
151 BOOST_TEST_EQ( x, 3 );
152 }
153
154 {
155 result<int> const r( in_place_error );
156
157 int x = r | fi2 | 3;
158
159 BOOST_TEST_EQ( x, 3 );
160 }
161
162 {
163 int x = result<int>( in_place_error ) | fi2 | 3;
164
165 BOOST_TEST_EQ( x, 3 );
166 }
167
168 {
169 Y y = result<X>( X{.v_: 1} ) | fy | X{.v_: 3};
170
171 BOOST_TEST_EQ( y.v_, 1 );
172 }
173
174 {
175 Y y = result<X>( X{.v_: 1} ) | fy2 | X{.v_: 3};
176
177 BOOST_TEST_EQ( y.v_, 1 );
178 }
179
180 {
181 Y y = result<X, E>( in_place_error ) | fy | X{.v_: 3};
182
183 BOOST_TEST_EQ( y.v_, 2 );
184 }
185
186 {
187 Y y = result<X, E>( in_place_error ) | fy2 | Y{3};
188
189 BOOST_TEST_EQ( y.v_, 3 );
190 }
191
192 {
193 int x1 = 1;
194 int x3 = 3;
195
196 result<int&> r( x1 );
197
198 int& x = r | fri | x3;
199
200 BOOST_TEST_EQ( &x, &x1 );
201 }
202
203 {
204 int x1 = 1;
205 int x3 = 3;
206
207 result<int&> const r( x1 );
208
209 int& x = r | fri | x3;
210
211 BOOST_TEST_EQ( &x, &x1 );
212 }
213
214 {
215 int x1 = 1;
216 int x3 = 3;
217
218 int& x = result<int&>( x1 ) | fri | x3;
219
220 BOOST_TEST_EQ( &x, &x1 );
221 }
222
223 {
224 int x1 = 1;
225 int x3 = 3;
226
227 result<int&> r( x1 );
228
229 int& x = r | fri2 | x3;
230
231 BOOST_TEST_EQ( &x, &x1 );
232 }
233
234 {
235 int x1 = 1;
236 int x3 = 3;
237
238 result<int&> const r( x1 );
239
240 int& x = r | fri2 | x3;
241
242 BOOST_TEST_EQ( &x, &x1 );
243 }
244
245 {
246 int x1 = 1;
247 int x3 = 3;
248
249 int& x = result<int&>( x1 ) | fri2 | x3;
250
251 BOOST_TEST_EQ( &x, &x1 );
252 }
253
254 {
255 int x3 = 3;
256
257 result<int&, E> r( in_place_error );
258
259 int& x = r | fri | x3;
260
261 BOOST_TEST_EQ( &x, &*fri() );
262 }
263
264 {
265 int x3 = 3;
266
267 result<int&, E> const r( in_place_error );
268
269 int& x = r | fri | x3;
270
271 BOOST_TEST_EQ( &x, &*fri() );
272 }
273
274 {
275 int x3 = 3;
276
277 int& x = result<int&, E>( in_place_error ) | fri | x3;
278
279 BOOST_TEST_EQ( &x, &*fri() );
280 }
281
282 {
283 int x3 = 3;
284
285 result<int&, E> r( in_place_error );
286
287 int& x = r | fri2 | x3;
288
289 BOOST_TEST_EQ( &x, &x3 );
290 }
291
292 {
293 int x3 = 3;
294
295 result<int&, E> const r( in_place_error );
296
297 int& x = r | fri2 | x3;
298
299 BOOST_TEST_EQ( &x, &x3 );
300 }
301
302 {
303 int x3 = 3;
304
305 int& x = result<int&, E>( in_place_error ) | fri2 | x3;
306
307 BOOST_TEST_EQ( &x, &x3 );
308 }
309
310 {
311 result<void> r;
312 result<void, E> r2 = r | fv;
313
314 BOOST_TEST( r2.has_value() );
315 }
316
317 {
318 result<void> r;
319 result<void, E> r2 = r | fv2;
320
321 BOOST_TEST( r2.has_value() );
322 }
323
324 {
325 result<void> r( in_place_error );
326 result<void, E> r2 = r | fv;
327
328 BOOST_TEST( r2.has_value() );
329 }
330
331 {
332 result<void> r( in_place_error );
333 result<void, E> r2 = r | fv2;
334
335 BOOST_TEST( r2.has_error() );
336 }
337
338 {
339 result<void, E> r2 = result<void>() | fv;
340 BOOST_TEST( r2.has_value() );
341 }
342
343 {
344 result<void, E> r2 = result<void>() | fv2;
345 BOOST_TEST( r2.has_value() );
346 }
347
348 {
349 result<void, E> r2 = result<void>( in_place_error ) | fv;
350 BOOST_TEST( r2.has_value() );
351 }
352
353 {
354 result<void, E> r2 = result<void>( in_place_error ) | fv2;
355 BOOST_TEST( r2.has_error() );
356 }
357
358 return boost::report_errors();
359}
360

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