]>
Commit | Line | Data |
---|---|---|
416331ca | 1 | use core::ops::DerefMut; |
dfeec247 | 2 | use core::option::*; |
ea8adc8c | 3 | |
dfeec247 XL |
4 | fn op1() -> Result<isize, &'static str> { |
5 | Ok(666) | |
6 | } | |
7 | fn op2() -> Result<isize, &'static str> { | |
8 | Err("sadface") | |
9 | } | |
1a4d82fc JJ |
10 | |
11 | #[test] | |
d9579d0f | 12 | fn test_and() { |
85aaf69f | 13 | assert_eq!(op1().and(Ok(667)).unwrap(), 667); |
dfeec247 | 14 | assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(), "bad"); |
1a4d82fc | 15 | |
85aaf69f | 16 | assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface"); |
dfeec247 | 17 | assert_eq!(op2().and(Err::<i32, &'static str>("bad")).unwrap_err(), "sadface"); |
1a4d82fc JJ |
18 | } |
19 | ||
20 | #[test] | |
d9579d0f | 21 | fn test_and_then() { |
c34b1796 | 22 | assert_eq!(op1().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap(), 667); |
dfeec247 | 23 | assert_eq!(op1().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(), "bad"); |
1a4d82fc | 24 | |
dfeec247 XL |
25 | assert_eq!(op2().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap_err(), "sadface"); |
26 | assert_eq!(op2().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(), "sadface"); | |
1a4d82fc JJ |
27 | } |
28 | ||
29 | #[test] | |
d9579d0f | 30 | fn test_or() { |
c34b1796 | 31 | assert_eq!(op1().or(Ok::<_, &'static str>(667)).unwrap(), 666); |
1a4d82fc JJ |
32 | assert_eq!(op1().or(Err("bad")).unwrap(), 666); |
33 | ||
c34b1796 | 34 | assert_eq!(op2().or(Ok::<_, &'static str>(667)).unwrap(), 667); |
1a4d82fc JJ |
35 | assert_eq!(op2().or(Err("bad")).unwrap_err(), "bad"); |
36 | } | |
37 | ||
38 | #[test] | |
d9579d0f | 39 | fn test_or_else() { |
c34b1796 AL |
40 | assert_eq!(op1().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 666); |
41 | assert_eq!(op1().or_else(|e| Err::<isize, &'static str>(e)).unwrap(), 666); | |
1a4d82fc | 42 | |
c34b1796 | 43 | assert_eq!(op2().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 667); |
dfeec247 | 44 | assert_eq!(op2().or_else(|e| Err::<isize, &'static str>(e)).unwrap_err(), "sadface"); |
1a4d82fc JJ |
45 | } |
46 | ||
47 | #[test] | |
d9579d0f | 48 | fn test_impl_map() { |
c34b1796 AL |
49 | assert!(Ok::<isize, isize>(1).map(|x| x + 1) == Ok(2)); |
50 | assert!(Err::<isize, isize>(1).map(|x| x + 1) == Err(1)); | |
1a4d82fc JJ |
51 | } |
52 | ||
53 | #[test] | |
d9579d0f | 54 | fn test_impl_map_err() { |
c34b1796 AL |
55 | assert!(Ok::<isize, isize>(1).map_err(|x| x + 1) == Ok(1)); |
56 | assert!(Err::<isize, isize>(1).map_err(|x| x + 1) == Err(2)); | |
1a4d82fc JJ |
57 | } |
58 | ||
1a4d82fc JJ |
59 | #[test] |
60 | fn test_collect() { | |
c34b1796 | 61 | let v: Result<Vec<isize>, ()> = (0..0).map(|_| Ok::<isize, ()>(0)).collect(); |
1a4d82fc JJ |
62 | assert!(v == Ok(vec![])); |
63 | ||
c34b1796 | 64 | let v: Result<Vec<isize>, ()> = (0..3).map(|x| Ok::<isize, ()>(x)).collect(); |
1a4d82fc JJ |
65 | assert!(v == Ok(vec![0, 1, 2])); |
66 | ||
dfeec247 | 67 | let v: Result<Vec<isize>, isize> = (0..3).map(|x| if x > 1 { Err(x) } else { Ok(x) }).collect(); |
1a4d82fc JJ |
68 | assert!(v == Err(2)); |
69 | ||
70 | // test that it does not take more elements than it needs | |
8faf50e0 | 71 | let mut functions: [Box<dyn Fn() -> Result<(), isize>>; 3] = |
85aaf69f | 72 | [box || Ok(()), box || Err(1), box || panic!()]; |
1a4d82fc | 73 | |
c34b1796 | 74 | let v: Result<Vec<()>, isize> = functions.iter_mut().map(|f| (*f)()).collect(); |
1a4d82fc JJ |
75 | assert!(v == Err(1)); |
76 | } | |
1a4d82fc JJ |
77 | |
78 | #[test] | |
d9579d0f | 79 | fn test_fmt_default() { |
c34b1796 AL |
80 | let ok: Result<isize, &'static str> = Ok(100); |
81 | let err: Result<isize, &'static str> = Err("Err"); | |
1a4d82fc JJ |
82 | |
83 | let s = format!("{:?}", ok); | |
85aaf69f | 84 | assert_eq!(s, "Ok(100)"); |
1a4d82fc JJ |
85 | let s = format!("{:?}", err); |
86 | assert_eq!(s, "Err(\"Err\")"); | |
87 | } | |
88 | ||
89 | #[test] | |
d9579d0f | 90 | fn test_unwrap_or() { |
c34b1796 AL |
91 | let ok: Result<isize, &'static str> = Ok(100); |
92 | let ok_err: Result<isize, &'static str> = Err("Err"); | |
1a4d82fc JJ |
93 | |
94 | assert_eq!(ok.unwrap_or(50), 100); | |
95 | assert_eq!(ok_err.unwrap_or(50), 50); | |
96 | } | |
97 | ||
6a06907d XL |
98 | #[test] |
99 | fn test_ok_or_err() { | |
100 | let ok: Result<isize, isize> = Ok(100); | |
101 | let err: Result<isize, isize> = Err(200); | |
102 | ||
103 | assert_eq!(ok.into_ok_or_err(), 100); | |
104 | assert_eq!(err.into_ok_or_err(), 200); | |
105 | } | |
106 | ||
1a4d82fc | 107 | #[test] |
d9579d0f | 108 | fn test_unwrap_or_else() { |
c34b1796 | 109 | fn handler(msg: &'static str) -> isize { |
dfeec247 | 110 | if msg == "I got this." { 50 } else { panic!("BadBad") } |
1a4d82fc JJ |
111 | } |
112 | ||
c34b1796 AL |
113 | let ok: Result<isize, &'static str> = Ok(100); |
114 | let ok_err: Result<isize, &'static str> = Err("I got this."); | |
1a4d82fc JJ |
115 | |
116 | assert_eq!(ok.unwrap_or_else(handler), 100); | |
117 | assert_eq!(ok_err.unwrap_or_else(handler), 50); | |
118 | } | |
119 | ||
120 | #[test] | |
c34b1796 | 121 | #[should_panic] |
1a4d82fc | 122 | pub fn test_unwrap_or_else_panic() { |
c34b1796 | 123 | fn handler(msg: &'static str) -> isize { |
dfeec247 | 124 | if msg == "I got this." { 50 } else { panic!("BadBad") } |
1a4d82fc JJ |
125 | } |
126 | ||
c34b1796 | 127 | let bad_err: Result<isize, &'static str> = Err("Unrecoverable mess."); |
dfeec247 | 128 | let _: isize = bad_err.unwrap_or_else(handler); |
1a4d82fc | 129 | } |
62682a34 | 130 | |
5869c6ff XL |
131 | #[test] |
132 | fn test_unwrap_unchecked() { | |
133 | let ok: Result<isize, &'static str> = Ok(100); | |
134 | assert_eq!(unsafe { ok.unwrap_unchecked() }, 100); | |
135 | } | |
136 | ||
137 | #[test] | |
138 | fn test_unwrap_err_unchecked() { | |
139 | let ok_err: Result<isize, &'static str> = Err("Err"); | |
140 | assert_eq!(unsafe { ok_err.unwrap_err_unchecked() }, "Err"); | |
141 | } | |
142 | ||
62682a34 SL |
143 | #[test] |
144 | pub fn test_expect_ok() { | |
145 | let ok: Result<isize, &'static str> = Ok(100); | |
146 | assert_eq!(ok.expect("Unexpected error"), 100); | |
147 | } | |
148 | #[test] | |
dfeec247 | 149 | #[should_panic(expected = "Got expected error: \"All good\"")] |
62682a34 SL |
150 | pub fn test_expect_err() { |
151 | let err: Result<isize, &'static str> = Err("All good"); | |
152 | err.expect("Got expected error"); | |
153 | } | |
e9174d1e | 154 | |
32a655c1 SL |
155 | #[test] |
156 | pub fn test_expect_err_err() { | |
157 | let ok: Result<&'static str, isize> = Err(100); | |
158 | assert_eq!(ok.expect_err("Unexpected ok"), 100); | |
159 | } | |
160 | #[test] | |
dfeec247 | 161 | #[should_panic(expected = "Got expected ok: \"All good\"")] |
32a655c1 SL |
162 | pub fn test_expect_err_ok() { |
163 | let err: Result<&'static str, isize> = Ok("All good"); | |
164 | err.expect_err("Got expected ok"); | |
165 | } | |
166 | ||
e9174d1e SL |
167 | #[test] |
168 | pub fn test_iter() { | |
169 | let ok: Result<isize, &'static str> = Ok(100); | |
170 | let mut it = ok.iter(); | |
171 | assert_eq!(it.size_hint(), (1, Some(1))); | |
172 | assert_eq!(it.next(), Some(&100)); | |
173 | assert_eq!(it.size_hint(), (0, Some(0))); | |
174 | assert!(it.next().is_none()); | |
175 | assert_eq!((&ok).into_iter().next(), Some(&100)); | |
176 | ||
177 | let err: Result<isize, &'static str> = Err("error"); | |
178 | assert_eq!(err.iter().next(), None); | |
179 | } | |
180 | ||
181 | #[test] | |
182 | pub fn test_iter_mut() { | |
183 | let mut ok: Result<isize, &'static str> = Ok(100); | |
184 | for loc in ok.iter_mut() { | |
185 | *loc = 200; | |
186 | } | |
187 | assert_eq!(ok, Ok(200)); | |
188 | for loc in &mut ok { | |
189 | *loc = 300; | |
190 | } | |
191 | assert_eq!(ok, Ok(300)); | |
192 | ||
193 | let mut err: Result<isize, &'static str> = Err("error"); | |
194 | for loc in err.iter_mut() { | |
195 | *loc = 200; | |
196 | } | |
197 | assert_eq!(err, Err("error")); | |
198 | } | |
c30ab7b3 SL |
199 | |
200 | #[test] | |
201 | pub fn test_unwrap_or_default() { | |
202 | assert_eq!(op1().unwrap_or_default(), 666); | |
203 | assert_eq!(op2().unwrap_or_default(), 0); | |
204 | } | |
ea8adc8c | 205 | |
dfeec247 XL |
206 | #[test] |
207 | pub fn test_into_ok() { | |
208 | fn infallible_op() -> Result<isize, !> { | |
209 | Ok(666) | |
210 | } | |
211 | ||
212 | assert_eq!(infallible_op().into_ok(), 666); | |
213 | ||
214 | enum MyNeverToken {} | |
215 | impl From<MyNeverToken> for ! { | |
216 | fn from(never: MyNeverToken) -> ! { | |
217 | match never {} | |
218 | } | |
219 | } | |
220 | ||
221 | fn infallible_op2() -> Result<isize, MyNeverToken> { | |
222 | Ok(667) | |
223 | } | |
224 | ||
225 | assert_eq!(infallible_op2().into_ok(), 667); | |
226 | } | |
227 | ||
ea8adc8c XL |
228 | #[test] |
229 | fn test_try() { | |
230 | fn try_result_some() -> Option<u8> { | |
231 | let val = Ok(1)?; | |
232 | Some(val) | |
233 | } | |
234 | assert_eq!(try_result_some(), Some(1)); | |
235 | ||
236 | fn try_result_none() -> Option<u8> { | |
237 | let val = Err(NoneError)?; | |
238 | Some(val) | |
239 | } | |
240 | assert_eq!(try_result_none(), None); | |
241 | ||
242 | fn try_result_ok() -> Result<u8, u8> { | |
94b46f34 XL |
243 | let result: Result<u8, u8> = Ok(1); |
244 | let val = result?; | |
ea8adc8c XL |
245 | Ok(val) |
246 | } | |
247 | assert_eq!(try_result_ok(), Ok(1)); | |
248 | ||
249 | fn try_result_err() -> Result<u8, u8> { | |
94b46f34 XL |
250 | let result: Result<u8, u8> = Err(1); |
251 | let val = result?; | |
ea8adc8c XL |
252 | Ok(val) |
253 | } | |
254 | assert_eq!(try_result_err(), Err(1)); | |
255 | } | |
b7449926 XL |
256 | |
257 | #[test] | |
416331ca | 258 | fn test_result_as_deref() { |
dfeec247 | 259 | // &Result<T: Deref, E>::Ok(T).as_deref() -> |
b7449926 XL |
260 | // Result<&T::Deref::Target, &E>::Ok(&*T) |
261 | let ref_ok = &Result::Ok::<&i32, u8>(&42); | |
262 | let expected_result = Result::Ok::<&i32, &u8>(&42); | |
416331ca | 263 | assert_eq!(ref_ok.as_deref(), expected_result); |
b7449926 | 264 | |
dfeec247 | 265 | let ref_ok = &Result::Ok::<String, u32>(String::from("a result")); |
b7449926 | 266 | let expected_result = Result::Ok::<&str, &u32>("a result"); |
416331ca | 267 | assert_eq!(ref_ok.as_deref(), expected_result); |
b7449926 | 268 | |
dfeec247 | 269 | let ref_ok = &Result::Ok::<Vec<i32>, u32>(vec![1, 2, 3, 4, 5]); |
416331ca XL |
270 | let expected_result = Result::Ok::<&[i32], &u32>([1, 2, 3, 4, 5].as_slice()); |
271 | assert_eq!(ref_ok.as_deref(), expected_result); | |
b7449926 | 272 | |
3dfed10e XL |
273 | // &Result<T: Deref, E>::Err(T).as_deref() -> |
274 | // Result<&T::Deref::Target, &E>::Err(&*E) | |
275 | let val = 41; | |
276 | let ref_err = &Result::Err::<&u8, i32>(val); | |
277 | let expected_result = Result::Err::<&u8, &i32>(&val); | |
416331ca | 278 | assert_eq!(ref_err.as_deref(), expected_result); |
b7449926 | 279 | |
dfeec247 XL |
280 | let s = String::from("an error"); |
281 | let ref_err = &Result::Err::<&u32, String>(s.clone()); | |
282 | let expected_result = Result::Err::<&u32, &String>(&s); | |
416331ca | 283 | assert_eq!(ref_err.as_deref(), expected_result); |
b7449926 | 284 | |
dfeec247 XL |
285 | let v = vec![5, 4, 3, 2, 1]; |
286 | let ref_err = &Result::Err::<&u32, Vec<i32>>(v.clone()); | |
287 | let expected_result = Result::Err::<&u32, &Vec<i32>>(&v); | |
416331ca | 288 | assert_eq!(ref_err.as_deref(), expected_result); |
416331ca XL |
289 | } |
290 | ||
291 | #[test] | |
292 | fn test_result_as_deref_mut() { | |
3dfed10e XL |
293 | // &mut Result<T: DerefMut, E>::Ok(T).as_deref_mut() -> |
294 | // Result<&mut T::DerefMut::Target, &mut E>::Ok(&mut *T) | |
416331ca XL |
295 | let mut val = 42; |
296 | let mut expected_val = 42; | |
297 | let mut_ok = &mut Result::Ok::<&mut i32, u8>(&mut val); | |
298 | let expected_result = Result::Ok::<&mut i32, &mut u8>(&mut expected_val); | |
416331ca XL |
299 | assert_eq!(mut_ok.as_deref_mut(), expected_result); |
300 | ||
301 | let mut expected_string = String::from("a result"); | |
dfeec247 | 302 | let mut_ok = &mut Result::Ok::<String, u32>(expected_string.clone()); |
416331ca XL |
303 | let expected_result = Result::Ok::<&mut str, &mut u32>(expected_string.deref_mut()); |
304 | assert_eq!(mut_ok.as_deref_mut(), expected_result); | |
305 | ||
306 | let mut expected_vec = vec![1, 2, 3, 4, 5]; | |
dfeec247 | 307 | let mut_ok = &mut Result::Ok::<Vec<i32>, u32>(expected_vec.clone()); |
416331ca XL |
308 | let expected_result = Result::Ok::<&mut [i32], &mut u32>(expected_vec.as_mut_slice()); |
309 | assert_eq!(mut_ok.as_deref_mut(), expected_result); | |
310 | ||
3dfed10e XL |
311 | // &mut Result<T: DerefMut, E>::Err(T).as_deref_mut() -> |
312 | // Result<&mut T, &mut E>::Err(&mut *E) | |
416331ca | 313 | let mut val = 41; |
dfeec247 XL |
314 | let mut_err = &mut Result::Err::<&mut u8, i32>(val); |
315 | let expected_result = Result::Err::<&mut u8, &mut i32>(&mut val); | |
416331ca XL |
316 | assert_eq!(mut_err.as_deref_mut(), expected_result); |
317 | ||
318 | let mut expected_string = String::from("an error"); | |
319 | let mut_err = &mut Result::Err::<&mut u32, String>(expected_string.clone()); | |
dfeec247 | 320 | let expected_result = Result::Err::<&mut u32, &mut String>(&mut expected_string); |
416331ca XL |
321 | assert_eq!(mut_err.as_deref_mut(), expected_result); |
322 | ||
323 | let mut expected_vec = vec![5, 4, 3, 2, 1]; | |
324 | let mut_err = &mut Result::Err::<&mut u32, Vec<i32>>(expected_vec.clone()); | |
dfeec247 | 325 | let expected_result = Result::Err::<&mut u32, &mut Vec<i32>>(&mut expected_vec); |
416331ca | 326 | assert_eq!(mut_err.as_deref_mut(), expected_result); |
b7449926 | 327 | } |
1b1a35ee XL |
328 | |
329 | #[test] | |
330 | fn result_const() { | |
331 | // test that the methods of `Result` are usable in a const context | |
332 | ||
333 | const RESULT: Result<usize, bool> = Ok(32); | |
334 | ||
335 | const REF: Result<&usize, &bool> = RESULT.as_ref(); | |
336 | assert_eq!(REF, Ok(&32)); | |
337 | ||
338 | const IS_OK: bool = RESULT.is_ok(); | |
339 | assert!(IS_OK); | |
340 | ||
341 | const IS_ERR: bool = RESULT.is_err(); | |
342 | assert!(!IS_ERR) | |
343 | } | |
fc512014 XL |
344 | |
345 | #[test] | |
346 | fn result_opt_conversions() { | |
347 | #[derive(Copy, Clone, Debug, PartialEq)] | |
348 | struct BadNumErr; | |
349 | ||
350 | fn try_num(x: i32) -> Result<i32, BadNumErr> { | |
351 | if x <= 5 { Ok(x + 1) } else { Err(BadNumErr) } | |
352 | } | |
353 | ||
354 | type ResOpt = Result<Option<i32>, BadNumErr>; | |
355 | type OptRes = Option<Result<i32, BadNumErr>>; | |
356 | ||
357 | let mut x: ResOpt = Ok(Some(5)); | |
358 | let mut y: OptRes = Some(Ok(5)); | |
359 | assert_eq!(x, y.transpose()); | |
360 | assert_eq!(x.transpose(), y); | |
361 | ||
362 | x = Ok(None); | |
363 | y = None; | |
364 | assert_eq!(x, y.transpose()); | |
365 | assert_eq!(x.transpose(), y); | |
366 | ||
367 | x = Err(BadNumErr); | |
368 | y = Some(Err(BadNumErr)); | |
369 | assert_eq!(x, y.transpose()); | |
370 | assert_eq!(x.transpose(), y); | |
371 | ||
372 | let res: Result<Vec<i32>, BadNumErr> = (0..10) | |
373 | .map(|x| { | |
374 | let y = try_num(x)?; | |
375 | Ok(if y % 2 == 0 { Some(y - 1) } else { None }) | |
376 | }) | |
377 | .filter_map(Result::transpose) | |
378 | .collect(); | |
379 | ||
380 | assert_eq!(res, Err(BadNumErr)) | |
381 | } |