1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
1| |#![allow(unused_assignments)]
2| |// expect-exit-status-1
3| |
4| 6|fn call(return_error: bool) -> Result<(),()> {
5| 6| if return_error {
6| 1| Err(())
7| | } else {
8| 5| Ok(())
9| | }
10| 6|}
11| |
12| 1|fn test1() -> Result<(),()> {
13| 1| let mut
14| 1| countdown = 10
15| | ;
16| | for
17| | _
18| | in
19| 6| 0..10
20| | {
21| 6| countdown
22| 6| -= 1
23| 6| ;
24| 6| if
25| 6| countdown < 5
26| | {
27| 1| call(/*return_error=*/ true)?;
28| 0| call(/*return_error=*/ false)?;
29| | }
30| | else
31| | {
32| 5| call(/*return_error=*/ false)?;
^0
33| | }
34| | }
35| 0| Ok(())
36| 1|}
37| |
38| |struct Thing1;
39| |impl Thing1 {
40| 18| fn get_thing_2(&self, return_error: bool) -> Result<Thing2,()> {
41| 18| if return_error {
42| 1| Err(())
43| | } else {
44| 17| Ok(Thing2{})
45| | }
46| 18| }
47| |}
48| |
49| |struct Thing2;
50| |impl Thing2 {
51| 17| fn call(&self, return_error: bool) -> Result<u32,()> {
52| 17| if return_error {
53| 2| Err(())
54| | } else {
55| 15| Ok(57)
56| | }
57| 17| }
58| |}
59| |
60| 1|fn test2() -> Result<(),()> {
61| 1| let thing1 = Thing1{};
62| 1| let mut
63| 1| countdown = 10
64| | ;
65| | for
66| | _
67| | in
68| 6| 0..10
69| | {
70| 6| countdown
71| 6| -= 1
72| 6| ;
73| 6| if
74| 6| countdown < 5
75| | {
76| 1| thing1.get_thing_2(/*err=*/ false)?.call(/*err=*/ true).expect_err("call should fail");
^0
77| 1| thing1
78| 1| .
79| 1| get_thing_2(/*return_error=*/ false)
80| 0| ?
81| | .
82| 1| call(/*return_error=*/ true)
83| 1| .
84| 1| expect_err(
85| 1| "call should fail"
86| 1| );
87| 1| let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ true)?;
^0 ^0 ^0
88| 0| assert_eq!(val, 57);
89| 0| let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ false)?;
90| 0| assert_eq!(val, 57);
91| | }
92| | else
93| | {
94| 5| let val = thing1.get_thing_2(/*return_error=*/ false)?.call(/*return_error=*/ false)?;
^0 ^0
95| 5| assert_eq!(val, 57);
96| 5| let val = thing1
97| 5| .get_thing_2(/*return_error=*/ false)?
^0
98| 5| .call(/*return_error=*/ false)?;
^0
99| 5| assert_eq!(val, 57);
100| 5| let val = thing1
101| 5| .get_thing_2(/*return_error=*/ false)
102| 0| ?
103| 5| .call(/*return_error=*/ false)
104| 0| ?
105| | ;
106| 5| assert_eq!(val, 57);
107| | }
108| | }
109| 0| Ok(())
110| 1|}
111| |
112| 1|fn main() -> Result<(),()> {
113| 1| test1().expect_err("test1 should fail");
114| 1| test2()
115| 1| ?
116| | ;
117| 0| Ok(())
118| 1|}
|
