src/libcore/tests/result.rs

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