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 <iosfwd> |
9 | #include <cerrno> |
10 | |
11 | using namespace boost::system; |
12 | |
13 | struct X |
14 | { |
15 | static int instances; |
16 | |
17 | int v_; |
18 | |
19 | explicit X( int v = 0 ): v_( v ) { ++instances; } |
20 | |
21 | X( X const& r ): v_( r.v_ ) { ++instances; } |
22 | |
23 | X& operator=( X const& ) = default; |
24 | |
25 | ~X() { --instances; } |
26 | }; |
27 | |
28 | bool operator==( X const & x1, X const & x2 ) |
29 | { |
30 | return x1.v_ == x2.v_; |
31 | } |
32 | |
33 | std::ostream& operator<<( std::ostream& os, X const & x ) |
34 | { |
35 | os << "X:" << x.v_; |
36 | return os; |
37 | } |
38 | |
39 | int X::instances = 0; |
40 | |
41 | struct Y |
42 | { |
43 | static int instances; |
44 | |
45 | int v_; |
46 | |
47 | explicit Y( int v = 0 ): v_( v ) { ++instances; } |
48 | |
49 | Y( Y const& r ) noexcept: v_( r.v_ ) { ++instances; } |
50 | |
51 | Y& operator=( Y const& ) = default; |
52 | |
53 | ~Y() { --instances; } |
54 | }; |
55 | |
56 | bool operator==( Y const & y1, Y const & y2 ) |
57 | { |
58 | return y1.v_ == y2.v_; |
59 | } |
60 | |
61 | std::ostream& operator<<( std::ostream& os, Y const & y ) |
62 | { |
63 | os << "Y:" << y.v_; |
64 | return os; |
65 | } |
66 | |
67 | int Y::instances = 0; |
68 | |
69 | int main() |
70 | { |
71 | // default-initialized lhs |
72 | |
73 | { |
74 | result<int> r; |
75 | result<int> r2; |
76 | |
77 | r2 = r; |
78 | |
79 | BOOST_TEST_EQ( r, r2 ); |
80 | } |
81 | |
82 | { |
83 | result<int> r; |
84 | result<int> r2( 1 ); |
85 | |
86 | r2 = r; |
87 | |
88 | BOOST_TEST_EQ( r, r2 ); |
89 | } |
90 | |
91 | { |
92 | result<int> r; |
93 | result<int> r2( ENOENT, generic_category() ); |
94 | |
95 | r2 = r; |
96 | |
97 | BOOST_TEST_EQ( r, r2 ); |
98 | } |
99 | |
100 | { |
101 | result<int> const r; |
102 | result<int> r2; |
103 | |
104 | r2 = r; |
105 | |
106 | BOOST_TEST_EQ( r, r2 ); |
107 | } |
108 | |
109 | { |
110 | result<int> const r; |
111 | result<int> r2( 1 ); |
112 | |
113 | r2 = r; |
114 | |
115 | BOOST_TEST_EQ( r, r2 ); |
116 | } |
117 | |
118 | { |
119 | result<int> const r; |
120 | result<int> r2( ENOENT, generic_category() ); |
121 | |
122 | r2 = r; |
123 | |
124 | BOOST_TEST_EQ( r, r2 ); |
125 | } |
126 | |
127 | BOOST_TEST_EQ( X::instances, 0 ); |
128 | |
129 | { |
130 | result<X> r; |
131 | result<X> r2; |
132 | |
133 | BOOST_TEST_EQ( X::instances, 2 ); |
134 | |
135 | r2 = r; |
136 | |
137 | BOOST_TEST_EQ( X::instances, 2 ); |
138 | |
139 | BOOST_TEST_EQ( r, r2 ); |
140 | } |
141 | |
142 | BOOST_TEST_EQ( X::instances, 0 ); |
143 | |
144 | { |
145 | result<X> r; |
146 | result<X> r2( 1 ); |
147 | |
148 | BOOST_TEST_EQ( X::instances, 2 ); |
149 | |
150 | r2 = r; |
151 | |
152 | BOOST_TEST_EQ( X::instances, 2 ); |
153 | |
154 | BOOST_TEST_EQ( r, r2 ); |
155 | } |
156 | |
157 | BOOST_TEST_EQ( X::instances, 0 ); |
158 | |
159 | { |
160 | result<X> r; |
161 | result<X> r2( ENOENT, generic_category() ); |
162 | |
163 | BOOST_TEST_EQ( X::instances, 1 ); |
164 | |
165 | r2 = r; |
166 | |
167 | BOOST_TEST_EQ( X::instances, 2 ); |
168 | |
169 | BOOST_TEST_EQ( r, r2 ); |
170 | } |
171 | |
172 | BOOST_TEST_EQ( X::instances, 0 ); |
173 | |
174 | { |
175 | result<X> const r; |
176 | result<X> r2; |
177 | |
178 | BOOST_TEST_EQ( X::instances, 2 ); |
179 | |
180 | r2 = r; |
181 | |
182 | BOOST_TEST_EQ( X::instances, 2 ); |
183 | |
184 | BOOST_TEST_EQ( r, r2 ); |
185 | } |
186 | |
187 | BOOST_TEST_EQ( X::instances, 0 ); |
188 | |
189 | { |
190 | result<X> const r; |
191 | result<X> r2( 1 ); |
192 | |
193 | BOOST_TEST_EQ( X::instances, 2 ); |
194 | |
195 | r2 = r; |
196 | |
197 | BOOST_TEST_EQ( X::instances, 2 ); |
198 | |
199 | BOOST_TEST_EQ( r, r2 ); |
200 | } |
201 | |
202 | BOOST_TEST_EQ( X::instances, 0 ); |
203 | |
204 | { |
205 | result<X> const r; |
206 | result<X> r2( ENOENT, generic_category() ); |
207 | |
208 | BOOST_TEST_EQ( X::instances, 1 ); |
209 | |
210 | r2 = r; |
211 | |
212 | BOOST_TEST_EQ( X::instances, 2 ); |
213 | |
214 | BOOST_TEST_EQ( r, r2 ); |
215 | } |
216 | |
217 | BOOST_TEST_EQ( X::instances, 0 ); |
218 | |
219 | // value lhs |
220 | |
221 | { |
222 | result<int> r( 0 ); |
223 | result<int> r2; |
224 | |
225 | r2 = r; |
226 | |
227 | BOOST_TEST_EQ( r, r2 ); |
228 | } |
229 | |
230 | { |
231 | result<int> r( 0 ); |
232 | result<int> r2( 1 ); |
233 | |
234 | r2 = r; |
235 | |
236 | BOOST_TEST_EQ( r, r2 ); |
237 | } |
238 | |
239 | { |
240 | result<int> r( 0 ); |
241 | result<int> r2( ENOENT, generic_category() ); |
242 | |
243 | r2 = r; |
244 | |
245 | BOOST_TEST_EQ( r, r2 ); |
246 | } |
247 | |
248 | { |
249 | result<int> const r( 0 ); |
250 | result<int> r2; |
251 | |
252 | r2 = r; |
253 | |
254 | BOOST_TEST_EQ( r, r2 ); |
255 | } |
256 | |
257 | { |
258 | result<int> const r( 0 ); |
259 | result<int> r2( 1 ); |
260 | |
261 | r2 = r; |
262 | |
263 | BOOST_TEST_EQ( r, r2 ); |
264 | } |
265 | |
266 | { |
267 | result<int> const r( 0 ); |
268 | result<int> r2( ENOENT, generic_category() ); |
269 | |
270 | r2 = r; |
271 | |
272 | BOOST_TEST_EQ( r, r2 ); |
273 | } |
274 | |
275 | BOOST_TEST_EQ( X::instances, 0 ); |
276 | |
277 | { |
278 | result<X> r( 1 ); |
279 | result<X> r2; |
280 | |
281 | BOOST_TEST_EQ( X::instances, 2 ); |
282 | |
283 | r2 = r; |
284 | |
285 | BOOST_TEST_EQ( X::instances, 2 ); |
286 | |
287 | BOOST_TEST_EQ( r, r2 ); |
288 | } |
289 | |
290 | BOOST_TEST_EQ( X::instances, 0 ); |
291 | |
292 | { |
293 | result<X> r( 1 ); |
294 | result<X> r2( 2 ); |
295 | |
296 | BOOST_TEST_EQ( X::instances, 2 ); |
297 | |
298 | r2 = r; |
299 | |
300 | BOOST_TEST_EQ( X::instances, 2 ); |
301 | |
302 | BOOST_TEST_EQ( r, r2 ); |
303 | } |
304 | |
305 | BOOST_TEST_EQ( X::instances, 0 ); |
306 | |
307 | { |
308 | result<X> r( 1 ); |
309 | result<X> r2( ENOENT, generic_category() ); |
310 | |
311 | BOOST_TEST_EQ( X::instances, 1 ); |
312 | |
313 | r2 = r; |
314 | |
315 | BOOST_TEST_EQ( X::instances, 2 ); |
316 | |
317 | BOOST_TEST_EQ( r, r2 ); |
318 | } |
319 | |
320 | BOOST_TEST_EQ( X::instances, 0 ); |
321 | |
322 | { |
323 | result<X> const r( 1 ); |
324 | result<X> r2; |
325 | |
326 | BOOST_TEST_EQ( X::instances, 2 ); |
327 | |
328 | r2 = r; |
329 | |
330 | BOOST_TEST_EQ( X::instances, 2 ); |
331 | |
332 | BOOST_TEST_EQ( r, r2 ); |
333 | } |
334 | |
335 | BOOST_TEST_EQ( X::instances, 0 ); |
336 | |
337 | { |
338 | result<X> const r( 1 ); |
339 | result<X> r2( 2 ); |
340 | |
341 | BOOST_TEST_EQ( X::instances, 2 ); |
342 | |
343 | r2 = r; |
344 | |
345 | BOOST_TEST_EQ( X::instances, 2 ); |
346 | |
347 | BOOST_TEST_EQ( r, r2 ); |
348 | } |
349 | |
350 | BOOST_TEST_EQ( X::instances, 0 ); |
351 | |
352 | { |
353 | result<X> const r( 1 ); |
354 | result<X> r2( ENOENT, generic_category() ); |
355 | |
356 | BOOST_TEST_EQ( X::instances, 1 ); |
357 | |
358 | r2 = r; |
359 | |
360 | BOOST_TEST_EQ( X::instances, 2 ); |
361 | |
362 | BOOST_TEST_EQ( r, r2 ); |
363 | } |
364 | |
365 | BOOST_TEST_EQ( X::instances, 0 ); |
366 | |
367 | // error lhs |
368 | |
369 | { |
370 | auto ec = make_error_code( e: errc::invalid_argument ); |
371 | |
372 | result<int> r( ec ); |
373 | result<int> r2; |
374 | |
375 | r2 = r; |
376 | |
377 | BOOST_TEST_EQ( r, r2 ); |
378 | } |
379 | |
380 | { |
381 | auto ec = make_error_code( e: errc::invalid_argument ); |
382 | |
383 | result<int> r( ec ); |
384 | result<int> r2( 1 ); |
385 | |
386 | r2 = r; |
387 | |
388 | BOOST_TEST_EQ( r, r2 ); |
389 | } |
390 | |
391 | { |
392 | auto ec = make_error_code( e: errc::invalid_argument ); |
393 | |
394 | result<int> r( ec ); |
395 | result<int> r2( ENOENT, generic_category() ); |
396 | |
397 | r2 = r; |
398 | |
399 | BOOST_TEST_EQ( r, r2 ); |
400 | } |
401 | |
402 | { |
403 | auto ec = make_error_code( e: errc::invalid_argument ); |
404 | |
405 | result<int> const r( ec ); |
406 | result<int> r2; |
407 | |
408 | r2 = r; |
409 | |
410 | BOOST_TEST_EQ( r, r2 ); |
411 | } |
412 | |
413 | { |
414 | auto ec = make_error_code( e: errc::invalid_argument ); |
415 | |
416 | result<int> const r( ec ); |
417 | result<int> r2( 1 ); |
418 | |
419 | r2 = r; |
420 | |
421 | BOOST_TEST_EQ( r, r2 ); |
422 | } |
423 | |
424 | { |
425 | auto ec = make_error_code( e: errc::invalid_argument ); |
426 | |
427 | result<int> const r( ec ); |
428 | result<int> r2( ENOENT, generic_category() ); |
429 | |
430 | r2 = r; |
431 | |
432 | BOOST_TEST_EQ( r, r2 ); |
433 | } |
434 | |
435 | BOOST_TEST_EQ( X::instances, 0 ); |
436 | |
437 | { |
438 | auto ec = make_error_code( e: errc::invalid_argument ); |
439 | |
440 | result<X> r( ec ); |
441 | result<X> r2; |
442 | |
443 | BOOST_TEST_EQ( X::instances, 1 ); |
444 | |
445 | r2 = r; |
446 | |
447 | BOOST_TEST_EQ( X::instances, 0 ); |
448 | |
449 | BOOST_TEST_EQ( r, r2 ); |
450 | } |
451 | |
452 | BOOST_TEST_EQ( X::instances, 0 ); |
453 | |
454 | { |
455 | auto ec = make_error_code( e: errc::invalid_argument ); |
456 | |
457 | result<X> r( ec ); |
458 | result<X> r2( 1 ); |
459 | |
460 | BOOST_TEST_EQ( X::instances, 1 ); |
461 | |
462 | r2 = r; |
463 | |
464 | BOOST_TEST_EQ( X::instances, 0 ); |
465 | |
466 | BOOST_TEST_EQ( r, r2 ); |
467 | } |
468 | |
469 | BOOST_TEST_EQ( X::instances, 0 ); |
470 | |
471 | { |
472 | auto ec = make_error_code( e: errc::invalid_argument ); |
473 | |
474 | result<X> r( ec ); |
475 | result<X> r2( ENOENT, generic_category() ); |
476 | |
477 | BOOST_TEST_EQ( X::instances, 0 ); |
478 | |
479 | r2 = r; |
480 | |
481 | BOOST_TEST_EQ( X::instances, 0 ); |
482 | |
483 | BOOST_TEST_EQ( r, r2 ); |
484 | } |
485 | |
486 | BOOST_TEST_EQ( X::instances, 0 ); |
487 | |
488 | { |
489 | auto ec = make_error_code( e: errc::invalid_argument ); |
490 | |
491 | result<X> const r( ec ); |
492 | result<X> r2; |
493 | |
494 | BOOST_TEST_EQ( X::instances, 1 ); |
495 | |
496 | r2 = r; |
497 | |
498 | BOOST_TEST_EQ( X::instances, 0 ); |
499 | |
500 | BOOST_TEST_EQ( r, r2 ); |
501 | } |
502 | |
503 | BOOST_TEST_EQ( X::instances, 0 ); |
504 | |
505 | { |
506 | auto ec = make_error_code( e: errc::invalid_argument ); |
507 | |
508 | result<X> const r( ec ); |
509 | result<X> r2( 1 ); |
510 | |
511 | BOOST_TEST_EQ( X::instances, 1 ); |
512 | |
513 | r2 = r; |
514 | |
515 | BOOST_TEST_EQ( X::instances, 0 ); |
516 | |
517 | BOOST_TEST_EQ( r, r2 ); |
518 | } |
519 | |
520 | BOOST_TEST_EQ( X::instances, 0 ); |
521 | |
522 | { |
523 | auto ec = make_error_code( e: errc::invalid_argument ); |
524 | |
525 | result<X> const r( ec ); |
526 | result<X> r2( ENOENT, generic_category() ); |
527 | |
528 | BOOST_TEST_EQ( X::instances, 0 ); |
529 | |
530 | r2 = r; |
531 | |
532 | BOOST_TEST_EQ( X::instances, 0 ); |
533 | |
534 | BOOST_TEST_EQ( r, r2 ); |
535 | } |
536 | |
537 | BOOST_TEST_EQ( X::instances, 0 ); |
538 | |
539 | // |
540 | |
541 | BOOST_TEST_EQ( Y::instances, 0 ); |
542 | |
543 | { |
544 | result<std::string, Y> r( 1 ); |
545 | result<std::string, Y> r2( 2 ); |
546 | |
547 | BOOST_TEST_EQ( Y::instances, 2 ); |
548 | |
549 | r2 = r; |
550 | |
551 | BOOST_TEST_EQ( Y::instances, 2 ); |
552 | |
553 | BOOST_TEST_EQ( r, r2 ); |
554 | } |
555 | |
556 | BOOST_TEST_EQ( Y::instances, 0 ); |
557 | |
558 | { |
559 | result<std::string, Y> r( 1 ); |
560 | result<std::string, Y> r2( "str" ); |
561 | |
562 | BOOST_TEST_EQ( Y::instances, 1 ); |
563 | |
564 | r2 = r; |
565 | |
566 | BOOST_TEST_EQ( Y::instances, 2 ); |
567 | |
568 | BOOST_TEST_EQ( r, r2 ); |
569 | } |
570 | |
571 | BOOST_TEST_EQ( Y::instances, 0 ); |
572 | |
573 | { |
574 | result<std::string, Y> const r( 1 ); |
575 | result<std::string, Y> r2( 2 ); |
576 | |
577 | BOOST_TEST_EQ( Y::instances, 2 ); |
578 | |
579 | r2 = r; |
580 | |
581 | BOOST_TEST_EQ( Y::instances, 2 ); |
582 | |
583 | BOOST_TEST_EQ( r, r2 ); |
584 | } |
585 | |
586 | BOOST_TEST_EQ( Y::instances, 0 ); |
587 | |
588 | { |
589 | result<std::string, Y> const r( 1 ); |
590 | result<std::string, Y> r2( "str" ); |
591 | |
592 | BOOST_TEST_EQ( Y::instances, 1 ); |
593 | |
594 | r2 = r; |
595 | |
596 | BOOST_TEST_EQ( Y::instances, 2 ); |
597 | |
598 | BOOST_TEST_EQ( r, r2 ); |
599 | } |
600 | |
601 | BOOST_TEST_EQ( Y::instances, 0 ); |
602 | |
603 | // void |
604 | |
605 | { |
606 | result<void> r; |
607 | result<void> r2; |
608 | |
609 | r2 = r; |
610 | |
611 | BOOST_TEST_EQ( r, r2 ); |
612 | } |
613 | |
614 | { |
615 | result<void> r; |
616 | result<void> r2( ENOENT, generic_category() ); |
617 | |
618 | r2 = r; |
619 | |
620 | BOOST_TEST_EQ( r, r2 ); |
621 | } |
622 | |
623 | { |
624 | result<void> const r; |
625 | result<void> r2; |
626 | |
627 | r2 = r; |
628 | |
629 | BOOST_TEST_EQ( r, r2 ); |
630 | } |
631 | |
632 | { |
633 | result<void> const r; |
634 | result<void> r2( ENOENT, generic_category() ); |
635 | |
636 | r2 = r; |
637 | |
638 | BOOST_TEST_EQ( r, r2 ); |
639 | } |
640 | |
641 | { |
642 | auto ec = make_error_code( e: errc::invalid_argument ); |
643 | |
644 | result<void> r( ec ); |
645 | result<void> r2; |
646 | |
647 | r2 = r; |
648 | |
649 | BOOST_TEST_EQ( r, r2 ); |
650 | } |
651 | |
652 | { |
653 | auto ec = make_error_code( e: errc::invalid_argument ); |
654 | |
655 | result<void> r( ec ); |
656 | result<void> r2( ENOENT, generic_category() ); |
657 | |
658 | r2 = r; |
659 | |
660 | BOOST_TEST_EQ( r, r2 ); |
661 | } |
662 | |
663 | { |
664 | auto ec = make_error_code( e: errc::invalid_argument ); |
665 | |
666 | result<void> const r( ec ); |
667 | result<void> r2; |
668 | |
669 | r2 = r; |
670 | |
671 | BOOST_TEST_EQ( r, r2 ); |
672 | } |
673 | |
674 | { |
675 | auto ec = make_error_code( e: errc::invalid_argument ); |
676 | |
677 | result<void> const r( ec ); |
678 | result<void> r2( ENOENT, generic_category() ); |
679 | |
680 | r2 = r; |
681 | |
682 | BOOST_TEST_EQ( r, r2 ); |
683 | } |
684 | |
685 | // reference |
686 | |
687 | { |
688 | int x1 = 1; |
689 | int x2 = 2; |
690 | |
691 | result<int&> r1( x1 ); |
692 | result<int&> r2( x2 ); |
693 | |
694 | r2 = r1; |
695 | |
696 | BOOST_TEST_EQ( x1, 1 ); |
697 | BOOST_TEST_EQ( x2, 2 ); |
698 | |
699 | BOOST_TEST_EQ( r1, r2 ); |
700 | BOOST_TEST_EQ( &*r1, &*r2 ); |
701 | } |
702 | |
703 | { |
704 | int const x1 = 1; |
705 | int const x2 = 2; |
706 | |
707 | result<int const&> r1( x1 ); |
708 | result<int const&> r2( x2 ); |
709 | |
710 | r2 = r1; |
711 | |
712 | BOOST_TEST_EQ( x1, 1 ); |
713 | BOOST_TEST_EQ( x2, 2 ); |
714 | |
715 | BOOST_TEST_EQ( r1, r2 ); |
716 | BOOST_TEST_EQ( &*r1, &*r2 ); |
717 | } |
718 | |
719 | { |
720 | int x1 = 1; |
721 | |
722 | result<int&> r1( x1 ); |
723 | result<int&> r2( ENOENT, generic_category() ); |
724 | |
725 | r2 = r1; |
726 | |
727 | BOOST_TEST_EQ( x1, 1 ); |
728 | |
729 | BOOST_TEST_EQ( r1, r2 ); |
730 | BOOST_TEST_EQ( &*r1, &*r2 ); |
731 | } |
732 | |
733 | { |
734 | int x1 = 1; |
735 | int x2 = 2; |
736 | |
737 | result<int&> const r1( x1 ); |
738 | result<int&> r2( x2 ); |
739 | |
740 | r2 = r1; |
741 | |
742 | BOOST_TEST_EQ( x1, 1 ); |
743 | BOOST_TEST_EQ( x2, 2 ); |
744 | |
745 | BOOST_TEST_EQ( r1, r2 ); |
746 | BOOST_TEST_EQ( &*r1, &*r2 ); |
747 | } |
748 | |
749 | { |
750 | int const x1 = 1; |
751 | int const x2 = 2; |
752 | |
753 | result<int const &> const r1( x1 ); |
754 | result<int const &> r2( x2 ); |
755 | |
756 | r2 = r1; |
757 | |
758 | BOOST_TEST_EQ( x1, 1 ); |
759 | BOOST_TEST_EQ( x2, 2 ); |
760 | |
761 | BOOST_TEST_EQ( r1, r2 ); |
762 | BOOST_TEST_EQ( &*r1, &*r2 ); |
763 | } |
764 | |
765 | { |
766 | int x1 = 1; |
767 | |
768 | result<int&> const r1( x1 ); |
769 | result<int&> r2( ENOENT, generic_category() ); |
770 | |
771 | r2 = r1; |
772 | |
773 | BOOST_TEST_EQ( x1, 1 ); |
774 | |
775 | BOOST_TEST_EQ( r1, r2 ); |
776 | BOOST_TEST_EQ( &*r1, &*r2 ); |
777 | } |
778 | |
779 | { |
780 | int x2 = 2; |
781 | |
782 | auto ec = make_error_code( e: errc::invalid_argument ); |
783 | |
784 | result<int&> r1( ec ); |
785 | result<int&> r2( x2 ); |
786 | |
787 | r2 = r1; |
788 | |
789 | BOOST_TEST_EQ( x2, 2 ); |
790 | |
791 | BOOST_TEST_EQ( r1, r2 ); |
792 | } |
793 | |
794 | { |
795 | auto ec = make_error_code( e: errc::invalid_argument ); |
796 | |
797 | result<int&> r1( ec ); |
798 | result<int&> r2( ENOENT, generic_category() ); |
799 | |
800 | r2 = r1; |
801 | |
802 | BOOST_TEST_EQ( r1, r2 ); |
803 | } |
804 | |
805 | { |
806 | int x2 = 2; |
807 | |
808 | auto ec = make_error_code( e: errc::invalid_argument ); |
809 | |
810 | result<int&> const r1( ec ); |
811 | result<int&> r2( x2 ); |
812 | |
813 | r2 = r1; |
814 | |
815 | BOOST_TEST_EQ( x2, 2 ); |
816 | |
817 | BOOST_TEST_EQ( r1, r2 ); |
818 | } |
819 | |
820 | { |
821 | auto ec = make_error_code( e: errc::invalid_argument ); |
822 | |
823 | result<int&> const r1( ec ); |
824 | result<int&> r2( ENOENT, generic_category() ); |
825 | |
826 | r2 = r1; |
827 | |
828 | BOOST_TEST_EQ( r1, r2 ); |
829 | } |
830 | |
831 | return boost::report_errors(); |
832 | } |
833 | |