library/core/tests/result.rs

   1 use core::ops::DerefMut;
   2 use core::option::*;
   3
   4 fn op1() -> Result<isize, &'static str> {
   5     Ok(666)
   6 }
   7 fn op2() -> Result<isize, &'static str> {
   8     Err("sadface")
   9 }
  10
  11 #[test]
  12 fn test_and() {
  13     assert_eq!(op1().and(Ok(667)).unwrap(), 667);
  14     assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(), "bad");
  15
  16     assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface");
  17     assert_eq!(op2().and(Err::<i32, &'static str>("bad")).unwrap_err(), "sadface");
  18 }
  19
  20 #[test]
  21 fn test_and_then() {
  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");
  24
  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");
  27 }
  28
  29 #[test]
  30 fn test_or() {
  31     assert_eq!(op1().or(Ok::<_, &'static str>(667)).unwrap(), 666);
  32     assert_eq!(op1().or(Err("bad")).unwrap(), 666);
  33
  34     assert_eq!(op2().or(Ok::<_, &'static str>(667)).unwrap(), 667);
  35     assert_eq!(op2().or(Err("bad")).unwrap_err(), "bad");
  36 }
  37
  38 #[test]
  39 fn test_or_else() {
  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);
  42
  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");
  45 }
  46
  47 #[test]
  48 fn test_impl_map() {
  49     assert!(Ok::<isize, isize>(1).map(|x| x + 1) == Ok(2));
  50     assert!(Err::<isize, isize>(1).map(|x| x + 1) == Err(1));
  51 }
  52
  53 #[test]
  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));
  57 }
  58
  59 #[test]
  60 fn test_collect() {
  61     let v: Result<Vec<isize>, ()> = (0..0).map(|_| Ok::<isize, ()>(0)).collect();
  62     assert!(v == Ok(vec![]));
  63
  64     let v: Result<Vec<isize>, ()> = (0..3).map(|x| Ok::<isize, ()>(x)).collect();
  65     assert!(v == Ok(vec![0, 1, 2]));
  66
  67     let v: Result<Vec<isize>, isize> = (0..3).map(|x| if x > 1 { Err(x) } else { Ok(x) }).collect();
  68     assert!(v == Err(2));
  69
  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!()];
  73
  74     let v: Result<Vec<()>, isize> = functions.iter_mut().map(|f| (*f)()).collect();
  75     assert!(v == Err(1));
  76 }
  77
  78 #[test]
  79 fn test_fmt_default() {
  80     let ok: Result<isize, &'static str> = Ok(100);
  81     let err: Result<isize, &'static str> = Err("Err");
  82
  83     let s = format!("{ok:?}");
  84     assert_eq!(s, "Ok(100)");
  85     let s = format!("{err:?}");
  86     assert_eq!(s, "Err(\"Err\")");
  87 }
  88
  89 #[test]
  90 fn test_unwrap_or() {
  91     let ok: Result<isize, &'static str> = Ok(100);
  92     let ok_err: Result<isize, &'static str> = Err("Err");
  93
  94     assert_eq!(ok.unwrap_or(50), 100);
  95     assert_eq!(ok_err.unwrap_or(50), 50);
  96 }
  97
  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
 107 #[test]
 108 fn test_unwrap_or_else() {
 109     fn handler(msg: &'static str) -> isize {
 110         if msg == "I got this." { 50 } else { panic!("BadBad") }
 111     }
 112
 113     let ok: Result<isize, &'static str> = Ok(100);
 114     let ok_err: Result<isize, &'static str> = Err("I got this.");
 115
 116     assert_eq!(ok.unwrap_or_else(handler), 100);
 117     assert_eq!(ok_err.unwrap_or_else(handler), 50);
 118 }
 119
 120 #[test]
 121 #[should_panic]
 122 pub fn test_unwrap_or_else_panic() {
 123     fn handler(msg: &'static str) -> isize {
 124         if msg == "I got this." { 50 } else { panic!("BadBad") }
 125     }
 126
 127     let bad_err: Result<isize, &'static str> = Err("Unrecoverable mess.");
 128     let _: isize = bad_err.unwrap_or_else(handler);
 129 }
 130
 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
 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]
 149 #[should_panic(expected = "Got expected error: \"All good\"")]
 150 pub fn test_expect_err() {
 151     let err: Result<isize, &'static str> = Err("All good");
 152     err.expect("Got expected error");
 153 }
 154
 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]
 161 #[should_panic(expected = "Got expected ok: \"All good\"")]
 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
 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 }
 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 }
 205
 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
 228 #[test]
 229 pub fn test_into_err() {
 230     fn until_error_op() -> Result<!, isize> {
 231         Err(666)
 232     }
 233
 234     assert_eq!(until_error_op().into_err(), 666);
 235
 236     enum MyNeverToken {}
 237     impl From<MyNeverToken> for ! {
 238         fn from(never: MyNeverToken) -> ! {
 239             match never {}
 240         }
 241     }
 242
 243     fn until_error_op2() -> Result<MyNeverToken, isize> {
 244         Err(667)
 245     }
 246
 247     assert_eq!(until_error_op2().into_err(), 667);
 248 }
 249
 250 #[test]
 251 fn test_try() {
 252     fn try_result_ok() -> Result<u8, u32> {
 253         let result: Result<u8, u8> = Ok(1);
 254         let val = result?;
 255         Ok(val)
 256     }
 257     assert_eq!(try_result_ok(), Ok(1));
 258
 259     fn try_result_err() -> Result<u8, u32> {
 260         let result: Result<u8, u8> = Err(1);
 261         let val = result?;
 262         Ok(val)
 263     }
 264     assert_eq!(try_result_err(), Err(1));
 265 }
 266
 267 #[test]
 268 fn test_result_as_deref() {
 269     // &Result<T: Deref, E>::Ok(T).as_deref() ->
 270     //      Result<&T::Deref::Target, &E>::Ok(&*T)
 271     let ref_ok = &Result::Ok::<&i32, u8>(&42);
 272     let expected_result = Result::Ok::<&i32, &u8>(&42);
 273     assert_eq!(ref_ok.as_deref(), expected_result);
 274
 275     let ref_ok = &Result::Ok::<String, u32>(String::from("a result"));
 276     let expected_result = Result::Ok::<&str, &u32>("a result");
 277     assert_eq!(ref_ok.as_deref(), expected_result);
 278
 279     let ref_ok = &Result::Ok::<Vec<i32>, u32>(vec![1, 2, 3, 4, 5]);
 280     let expected_result = Result::Ok::<&[i32], &u32>([1, 2, 3, 4, 5].as_slice());
 281     assert_eq!(ref_ok.as_deref(), expected_result);
 282
 283     // &Result<T: Deref, E>::Err(T).as_deref() ->
 284     //      Result<&T::Deref::Target, &E>::Err(&*E)
 285     let val = 41;
 286     let ref_err = &Result::Err::<&u8, i32>(val);
 287     let expected_result = Result::Err::<&u8, &i32>(&val);
 288     assert_eq!(ref_err.as_deref(), expected_result);
 289
 290     let s = String::from("an error");
 291     let ref_err = &Result::Err::<&u32, String>(s.clone());
 292     let expected_result = Result::Err::<&u32, &String>(&s);
 293     assert_eq!(ref_err.as_deref(), expected_result);
 294
 295     let v = vec![5, 4, 3, 2, 1];
 296     let ref_err = &Result::Err::<&u32, Vec<i32>>(v.clone());
 297     let expected_result = Result::Err::<&u32, &Vec<i32>>(&v);
 298     assert_eq!(ref_err.as_deref(), expected_result);
 299 }
 300
 301 #[test]
 302 fn test_result_as_deref_mut() {
 303     // &mut Result<T: DerefMut, E>::Ok(T).as_deref_mut() ->
 304     //      Result<&mut T::DerefMut::Target, &mut E>::Ok(&mut *T)
 305     let mut val = 42;
 306     let mut expected_val = 42;
 307     let mut_ok = &mut Result::Ok::<&mut i32, u8>(&mut val);
 308     let expected_result = Result::Ok::<&mut i32, &mut u8>(&mut expected_val);
 309     assert_eq!(mut_ok.as_deref_mut(), expected_result);
 310
 311     let mut expected_string = String::from("a result");
 312     let mut_ok = &mut Result::Ok::<String, u32>(expected_string.clone());
 313     let expected_result = Result::Ok::<&mut str, &mut u32>(expected_string.deref_mut());
 314     assert_eq!(mut_ok.as_deref_mut(), expected_result);
 315
 316     let mut expected_vec = vec![1, 2, 3, 4, 5];
 317     let mut_ok = &mut Result::Ok::<Vec<i32>, u32>(expected_vec.clone());
 318     let expected_result = Result::Ok::<&mut [i32], &mut u32>(expected_vec.as_mut_slice());
 319     assert_eq!(mut_ok.as_deref_mut(), expected_result);
 320
 321     // &mut Result<T: DerefMut, E>::Err(T).as_deref_mut() ->
 322     //      Result<&mut T, &mut E>::Err(&mut *E)
 323     let mut val = 41;
 324     let mut_err = &mut Result::Err::<&mut u8, i32>(val);
 325     let expected_result = Result::Err::<&mut u8, &mut i32>(&mut val);
 326     assert_eq!(mut_err.as_deref_mut(), expected_result);
 327
 328     let mut expected_string = String::from("an error");
 329     let mut_err = &mut Result::Err::<&mut u32, String>(expected_string.clone());
 330     let expected_result = Result::Err::<&mut u32, &mut String>(&mut expected_string);
 331     assert_eq!(mut_err.as_deref_mut(), expected_result);
 332
 333     let mut expected_vec = vec![5, 4, 3, 2, 1];
 334     let mut_err = &mut Result::Err::<&mut u32, Vec<i32>>(expected_vec.clone());
 335     let expected_result = Result::Err::<&mut u32, &mut Vec<i32>>(&mut expected_vec);
 336     assert_eq!(mut_err.as_deref_mut(), expected_result);
 337 }
 338
 339 #[test]
 340 fn result_const() {
 341     // test that the methods of `Result` are usable in a const context
 342
 343     const RESULT: Result<usize, bool> = Ok(32);
 344
 345     const REF: Result<&usize, &bool> = RESULT.as_ref();
 346     assert_eq!(REF, Ok(&32));
 347
 348     const IS_OK: bool = RESULT.is_ok();
 349     assert!(IS_OK);
 350
 351     const IS_ERR: bool = RESULT.is_err();
 352     assert!(!IS_ERR)
 353 }
 354
 355 #[test]
 356 const fn result_const_mut() {
 357     let mut result: Result<usize, bool> = Ok(32);
 358
 359     {
 360         let as_mut = result.as_mut();
 361         match as_mut {
 362             Ok(v) => *v = 42,
 363             Err(_) => unreachable!(),
 364         }
 365     }
 366
 367     let mut result_err: Result<usize, bool> = Err(false);
 368
 369     {
 370         let as_mut = result_err.as_mut();
 371         match as_mut {
 372             Ok(_) => unreachable!(),
 373             Err(v) => *v = true,
 374         }
 375     }
 376 }
 377
 378 #[test]
 379 fn result_opt_conversions() {
 380     #[derive(Copy, Clone, Debug, PartialEq)]
 381     struct BadNumErr;
 382
 383     fn try_num(x: i32) -> Result<i32, BadNumErr> {
 384         if x <= 5 { Ok(x + 1) } else { Err(BadNumErr) }
 385     }
 386
 387     type ResOpt = Result<Option<i32>, BadNumErr>;
 388     type OptRes = Option<Result<i32, BadNumErr>>;
 389
 390     let mut x: ResOpt = Ok(Some(5));
 391     let mut y: OptRes = Some(Ok(5));
 392     assert_eq!(x, y.transpose());
 393     assert_eq!(x.transpose(), y);
 394
 395     x = Ok(None);
 396     y = None;
 397     assert_eq!(x, y.transpose());
 398     assert_eq!(x.transpose(), y);
 399
 400     x = Err(BadNumErr);
 401     y = Some(Err(BadNumErr));
 402     assert_eq!(x, y.transpose());
 403     assert_eq!(x.transpose(), y);
 404
 405     let res: Result<Vec<i32>, BadNumErr> = (0..10)
 406         .map(|x| {
 407             let y = try_num(x)?;
 408             Ok(if y % 2 == 0 { Some(y - 1) } else { None })
 409         })
 410         .filter_map(Result::transpose)
 411         .collect();
 412
 413     assert_eq!(res, Err(BadNumErr))
 414 }
 415
 416 #[test]
 417 fn result_try_trait_v2_branch() {
 418     use core::num::NonZeroU32;
 419     use core::ops::{ControlFlow::*, Try};
 420     assert_eq!(Ok::<i32, i32>(4).branch(), Continue(4));
 421     assert_eq!(Err::<i32, i32>(4).branch(), Break(Err(4)));
 422     let one = NonZeroU32::new(1).unwrap();
 423     assert_eq!(Ok::<(), NonZeroU32>(()).branch(), Continue(()));
 424     assert_eq!(Err::<(), NonZeroU32>(one).branch(), Break(Err(one)));
 425     assert_eq!(Ok::<NonZeroU32, ()>(one).branch(), Continue(one));
 426     assert_eq!(Err::<NonZeroU32, ()>(()).branch(), Break(Err(())));
 427 }