1 use core::ops::DerefMut;
4 fn op1() -> Result<isize, &'static str> {
7 fn op2() -> Result<isize, &'static str> {
13 assert_eq!(op1().and(Ok(667)).unwrap(), 667);
14 assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(), "bad");
16 assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface");
17 assert_eq!(op2().and(Err::<i32, &'static str>("bad")).unwrap_err(), "sadface");
22 assert_eq!(op1().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap(), 667);
23 assert_eq!(op1().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(), "bad");
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");
31 assert_eq!(op1().or(Ok::<_, &'static str>(667)).unwrap(), 666);
32 assert_eq!(op1().or(Err("bad")).unwrap(), 666);
34 assert_eq!(op2().or(Ok::<_, &'static str>(667)).unwrap(), 667);
35 assert_eq!(op2().or(Err("bad")).unwrap_err(), "bad");
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);
43 assert_eq!(op2().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 667);
44 assert_eq!(op2().or_else(|e| Err::<isize, &'static str>(e)).unwrap_err(), "sadface");
49 assert!(Ok::<isize, isize>(1).map(|x| x + 1) == Ok(2));
50 assert!(Err::<isize, isize>(1).map(|x| x + 1) == Err(1));
54 fn test_impl_map_err() {
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));
61 let v: Result<Vec<isize>, ()> = (0..0).map(|_| Ok::<isize, ()>(0)).collect();
62 assert!(v == Ok(vec![]));
64 let v: Result<Vec<isize>, ()> = (0..3).map(|x| Ok::<isize, ()>(x)).collect();
65 assert!(v == Ok(vec![0, 1, 2]));
67 let v: Result<Vec<isize>, isize> = (0..3).map(|x| if x > 1 { Err(x) } else { Ok(x) }).collect();
70 // test that it does not take more elements than it needs
71 let mut functions: [Box<dyn Fn() -> Result<(), isize>>; 3] =
72 [box || Ok(()), box || Err(1), box || panic!()];
74 let v: Result<Vec<()>, isize> = functions.iter_mut().map(|f| (*f)()).collect();
79 fn test_fmt_default() {
80 let ok: Result<isize, &'static str> = Ok(100);
81 let err: Result<isize, &'static str> = Err("Err");
83 let s = format!("{:?}", ok);
84 assert_eq!(s, "Ok(100)");
85 let s = format!("{:?}", err);
86 assert_eq!(s, "Err(\"Err\")");
91 let ok: Result<isize, &'static str> = Ok(100);
92 let ok_err: Result<isize, &'static str> = Err("Err");
94 assert_eq!(ok.unwrap_or(50), 100);
95 assert_eq!(ok_err.unwrap_or(50), 50);
99 fn test_unwrap_or_else() {
100 fn handler(msg: &'static str) -> isize {
101 if msg == "I got this." { 50 } else { panic!("BadBad") }
104 let ok: Result<isize, &'static str> = Ok(100);
105 let ok_err: Result<isize, &'static str> = Err("I got this.");
107 assert_eq!(ok.unwrap_or_else(handler), 100);
108 assert_eq!(ok_err.unwrap_or_else(handler), 50);
113 pub fn test_unwrap_or_else_panic() {
114 fn handler(msg: &'static str) -> isize {
115 if msg == "I got this." { 50 } else { panic!("BadBad") }
118 let bad_err: Result<isize, &'static str> = Err("Unrecoverable mess.");
119 let _: isize = bad_err.unwrap_or_else(handler);
123 pub fn test_expect_ok() {
124 let ok: Result<isize, &'static str> = Ok(100);
125 assert_eq!(ok.expect("Unexpected error"), 100);
128 #[should_panic(expected = "Got expected error: \"All good\"")]
129 pub fn test_expect_err() {
130 let err: Result<isize, &'static str> = Err("All good");
131 err.expect("Got expected error");
135 pub fn test_expect_err_err() {
136 let ok: Result<&'static str, isize> = Err(100);
137 assert_eq!(ok.expect_err("Unexpected ok"), 100);
140 #[should_panic(expected = "Got expected ok: \"All good\"")]
141 pub fn test_expect_err_ok() {
142 let err: Result<&'static str, isize> = Ok("All good");
143 err.expect_err("Got expected ok");
148 let ok: Result<isize, &'static str> = Ok(100);
149 let mut it = ok.iter();
150 assert_eq!(it.size_hint(), (1, Some(1)));
151 assert_eq!(it.next(), Some(&100));
152 assert_eq!(it.size_hint(), (0, Some(0)));
153 assert!(it.next().is_none());
154 assert_eq!((&ok).into_iter().next(), Some(&100));
156 let err: Result<isize, &'static str> = Err("error");
157 assert_eq!(err.iter().next(), None);
161 pub fn test_iter_mut() {
162 let mut ok: Result<isize, &'static str> = Ok(100);
163 for loc in ok.iter_mut() {
166 assert_eq!(ok, Ok(200));
170 assert_eq!(ok, Ok(300));
172 let mut err: Result<isize, &'static str> = Err("error");
173 for loc in err.iter_mut() {
176 assert_eq!(err, Err("error"));
180 pub fn test_unwrap_or_default() {
181 assert_eq!(op1().unwrap_or_default(), 666);
182 assert_eq!(op2().unwrap_or_default(), 0);
186 pub fn test_into_ok() {
187 fn infallible_op() -> Result<isize, !> {
191 assert_eq!(infallible_op().into_ok(), 666);
194 impl From<MyNeverToken> for ! {
195 fn from(never: MyNeverToken) -> ! {
200 fn infallible_op2() -> Result<isize, MyNeverToken> {
204 assert_eq!(infallible_op2().into_ok(), 667);
209 fn try_result_some() -> Option<u8> {
213 assert_eq!(try_result_some(), Some(1));
215 fn try_result_none() -> Option<u8> {
216 let val = Err(NoneError)?;
219 assert_eq!(try_result_none(), None);
221 fn try_result_ok() -> Result<u8, u8> {
222 let result: Result<u8, u8> = Ok(1);
226 assert_eq!(try_result_ok(), Ok(1));
228 fn try_result_err() -> Result<u8, u8> {
229 let result: Result<u8, u8> = Err(1);
233 assert_eq!(try_result_err(), Err(1));
237 fn test_result_as_deref() {
238 // &Result<T: Deref, E>::Ok(T).as_deref() ->
239 // Result<&T::Deref::Target, &E>::Ok(&*T)
240 let ref_ok = &Result::Ok::<&i32, u8>(&42);
241 let expected_result = Result::Ok::<&i32, &u8>(&42);
242 assert_eq!(ref_ok.as_deref(), expected_result);
244 let ref_ok = &Result::Ok::<String, u32>(String::from("a result"));
245 let expected_result = Result::Ok::<&str, &u32>("a result");
246 assert_eq!(ref_ok.as_deref(), expected_result);
248 let ref_ok = &Result::Ok::<Vec<i32>, u32>(vec![1, 2, 3, 4, 5]);
249 let expected_result = Result::Ok::<&[i32], &u32>([1, 2, 3, 4, 5].as_slice());
250 assert_eq!(ref_ok.as_deref(), expected_result);
252 // &Result<T: Deref, E>::Err(T).as_deref() ->
253 // Result<&T::Deref::Target, &E>::Err(&*E)
255 let ref_err = &Result::Err::<&u8, i32>(val);
256 let expected_result = Result::Err::<&u8, &i32>(&val);
257 assert_eq!(ref_err.as_deref(), expected_result);
259 let s = String::from("an error");
260 let ref_err = &Result::Err::<&u32, String>(s.clone());
261 let expected_result = Result::Err::<&u32, &String>(&s);
262 assert_eq!(ref_err.as_deref(), expected_result);
264 let v = vec![5, 4, 3, 2, 1];
265 let ref_err = &Result::Err::<&u32, Vec<i32>>(v.clone());
266 let expected_result = Result::Err::<&u32, &Vec<i32>>(&v);
267 assert_eq!(ref_err.as_deref(), expected_result);
271 fn test_result_as_deref_mut() {
272 // &mut Result<T: DerefMut, E>::Ok(T).as_deref_mut() ->
273 // Result<&mut T::DerefMut::Target, &mut E>::Ok(&mut *T)
275 let mut expected_val = 42;
276 let mut_ok = &mut Result::Ok::<&mut i32, u8>(&mut val);
277 let expected_result = Result::Ok::<&mut i32, &mut u8>(&mut expected_val);
278 assert_eq!(mut_ok.as_deref_mut(), expected_result);
280 let mut expected_string = String::from("a result");
281 let mut_ok = &mut Result::Ok::<String, u32>(expected_string.clone());
282 let expected_result = Result::Ok::<&mut str, &mut u32>(expected_string.deref_mut());
283 assert_eq!(mut_ok.as_deref_mut(), expected_result);
285 let mut expected_vec = vec![1, 2, 3, 4, 5];
286 let mut_ok = &mut Result::Ok::<Vec<i32>, u32>(expected_vec.clone());
287 let expected_result = Result::Ok::<&mut [i32], &mut u32>(expected_vec.as_mut_slice());
288 assert_eq!(mut_ok.as_deref_mut(), expected_result);
290 // &mut Result<T: DerefMut, E>::Err(T).as_deref_mut() ->
291 // Result<&mut T, &mut E>::Err(&mut *E)
293 let mut_err = &mut Result::Err::<&mut u8, i32>(val);
294 let expected_result = Result::Err::<&mut u8, &mut i32>(&mut val);
295 assert_eq!(mut_err.as_deref_mut(), expected_result);
297 let mut expected_string = String::from("an error");
298 let mut_err = &mut Result::Err::<&mut u32, String>(expected_string.clone());
299 let expected_result = Result::Err::<&mut u32, &mut String>(&mut expected_string);
300 assert_eq!(mut_err.as_deref_mut(), expected_result);
302 let mut expected_vec = vec![5, 4, 3, 2, 1];
303 let mut_err = &mut Result::Err::<&mut u32, Vec<i32>>(expected_vec.clone());
304 let expected_result = Result::Err::<&mut u32, &mut Vec<i32>>(&mut expected_vec);
305 assert_eq!(mut_err.as_deref_mut(), expected_result);
310 // test that the methods of `Result` are usable in a const context
312 const RESULT: Result<usize, bool> = Ok(32);
314 const REF: Result<&usize, &bool> = RESULT.as_ref();
315 assert_eq!(REF, Ok(&32));
317 const IS_OK: bool = RESULT.is_ok();
320 const IS_ERR: bool = RESULT.is_err();