src/libcore/tests/result.rs

   1 use core::option::*;
   2
   3 fn op1() -> Result<isize, &'static str> { Ok(666) }
   4 fn op2() -> Result<isize, &'static str> { Err("sadface") }
   5
   6 #[test]
   7 fn test_and() {
   8     assert_eq!(op1().and(Ok(667)).unwrap(), 667);
   9     assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(),
  10                "bad");
  11
  12     assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface");
  13     assert_eq!(op2().and(Err::<i32,&'static str>("bad")).unwrap_err(),
  14                "sadface");
  15 }
  16
  17 #[test]
  18 fn test_and_then() {
  19     assert_eq!(op1().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap(), 667);
  20     assert_eq!(op1().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(),
  21                "bad");
  22
  23     assert_eq!(op2().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap_err(),
  24                "sadface");
  25     assert_eq!(op2().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(),
  26                "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(),
  45                "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| {
  69         if x > 1 { Err(x) } else { Ok(x) }
  70     }).collect();
  71     assert!(v == Err(2));
  72
  73     // test that it does not take more elements than it needs
  74     let mut functions: [Box<dyn Fn() -> Result<(), isize>>; 3] =
  75         [box || Ok(()), box || Err(1), box || panic!()];
  76
  77     let v: Result<Vec<()>, isize> = functions.iter_mut().map(|f| (*f)()).collect();
  78     assert!(v == Err(1));
  79 }
  80
  81 #[test]
  82 fn test_fmt_default() {
  83     let ok: Result<isize, &'static str> = Ok(100);
  84     let err: Result<isize, &'static str> = Err("Err");
  85
  86     let s = format!("{:?}", ok);
  87     assert_eq!(s, "Ok(100)");
  88     let s = format!("{:?}", err);
  89     assert_eq!(s, "Err(\"Err\")");
  90 }
  91
  92 #[test]
  93 fn test_unwrap_or() {
  94     let ok: Result<isize, &'static str> = Ok(100);
  95     let ok_err: Result<isize, &'static str> = Err("Err");
  96
  97     assert_eq!(ok.unwrap_or(50), 100);
  98     assert_eq!(ok_err.unwrap_or(50), 50);
  99 }
 100
 101 #[test]
 102 fn test_unwrap_or_else() {
 103     fn handler(msg: &'static str) -> isize {
 104         if msg == "I got this." {
 105             50
 106         } else {
 107             panic!("BadBad")
 108         }
 109     }
 110
 111     let ok: Result<isize, &'static str> = Ok(100);
 112     let ok_err: Result<isize, &'static str> = Err("I got this.");
 113
 114     assert_eq!(ok.unwrap_or_else(handler), 100);
 115     assert_eq!(ok_err.unwrap_or_else(handler), 50);
 116 }
 117
 118 #[test]
 119 #[should_panic]
 120 #[cfg(not(miri))] // Miri does not support panics
 121 pub fn test_unwrap_or_else_panic() {
 122     fn handler(msg: &'static str) -> isize {
 123         if msg == "I got this." {
 124             50
 125         } else {
 126             panic!("BadBad")
 127         }
 128     }
 129
 130     let bad_err: Result<isize, &'static str> = Err("Unrecoverable mess.");
 131     let _ : isize = bad_err.unwrap_or_else(handler);
 132 }
 133
 134
 135 #[test]
 136 pub fn test_expect_ok() {
 137     let ok: Result<isize, &'static str> = Ok(100);
 138     assert_eq!(ok.expect("Unexpected error"), 100);
 139 }
 140 #[test]
 141 #[should_panic(expected="Got expected error: \"All good\"")]
 142 #[cfg(not(miri))] // Miri does not support panics
 143 pub fn test_expect_err() {
 144     let err: Result<isize, &'static str> = Err("All good");
 145     err.expect("Got expected error");
 146 }
 147
 148
 149 #[test]
 150 pub fn test_expect_err_err() {
 151     let ok: Result<&'static str, isize> = Err(100);
 152     assert_eq!(ok.expect_err("Unexpected ok"), 100);
 153 }
 154 #[test]
 155 #[should_panic(expected="Got expected ok: \"All good\"")]
 156 #[cfg(not(miri))] // Miri does not support panics
 157 pub fn test_expect_err_ok() {
 158     let err: Result<&'static str, isize> = Ok("All good");
 159     err.expect_err("Got expected ok");
 160 }
 161
 162 #[test]
 163 pub fn test_iter() {
 164     let ok: Result<isize, &'static str> = Ok(100);
 165     let mut it = ok.iter();
 166     assert_eq!(it.size_hint(), (1, Some(1)));
 167     assert_eq!(it.next(), Some(&100));
 168     assert_eq!(it.size_hint(), (0, Some(0)));
 169     assert!(it.next().is_none());
 170     assert_eq!((&ok).into_iter().next(), Some(&100));
 171
 172     let err: Result<isize, &'static str> = Err("error");
 173     assert_eq!(err.iter().next(), None);
 174 }
 175
 176 #[test]
 177 pub fn test_iter_mut() {
 178     let mut ok: Result<isize, &'static str> = Ok(100);
 179     for loc in ok.iter_mut() {
 180         *loc = 200;
 181     }
 182     assert_eq!(ok, Ok(200));
 183     for loc in &mut ok {
 184         *loc = 300;
 185     }
 186     assert_eq!(ok, Ok(300));
 187
 188     let mut err: Result<isize, &'static str> = Err("error");
 189     for loc in err.iter_mut() {
 190         *loc = 200;
 191     }
 192     assert_eq!(err, Err("error"));
 193 }
 194
 195 #[test]
 196 pub fn test_unwrap_or_default() {
 197     assert_eq!(op1().unwrap_or_default(), 666);
 198     assert_eq!(op2().unwrap_or_default(), 0);
 199 }
 200
 201 #[test]
 202 fn test_try() {
 203     fn try_result_some() -> Option<u8> {
 204         let val = Ok(1)?;
 205         Some(val)
 206     }
 207     assert_eq!(try_result_some(), Some(1));
 208
 209     fn try_result_none() -> Option<u8> {
 210         let val = Err(NoneError)?;
 211         Some(val)
 212     }
 213     assert_eq!(try_result_none(), None);
 214
 215     fn try_result_ok() -> Result<u8, u8> {
 216         let result: Result<u8, u8> = Ok(1);
 217         let val = result?;
 218         Ok(val)
 219     }
 220     assert_eq!(try_result_ok(), Ok(1));
 221
 222     fn try_result_err() -> Result<u8, u8> {
 223         let result: Result<u8, u8> = Err(1);
 224         let val = result?;
 225         Ok(val)
 226     }
 227     assert_eq!(try_result_err(), Err(1));
 228 }
 229
 230 #[test]
 231 fn test_result_deref() {
 232     // &Result<T: Deref, E>::Ok(T).deref_ok() ->
 233     //      Result<&T::Deref::Target, &E>::Ok(&*T)
 234     let ref_ok = &Result::Ok::<&i32, u8>(&42);
 235     let expected_result = Result::Ok::<&i32, &u8>(&42);
 236     assert_eq!(ref_ok.deref_ok(), expected_result);
 237
 238     let ref_ok = &Result::Ok::<String, u32>(String::from("a result"));
 239     let expected_result = Result::Ok::<&str, &u32>("a result");
 240     assert_eq!(ref_ok.deref_ok(), expected_result);
 241
 242     let ref_ok = &Result::Ok::<Vec<i32>, u32>(vec![1, 2, 3, 4, 5]);
 243     let expected_result = Result::Ok::<&[i32], &u32>(&[1, 2, 3, 4, 5][..]);
 244     assert_eq!(ref_ok.deref_ok(), expected_result);
 245
 246     // &Result<T: Deref, E: Deref>::Ok(T).deref() ->
 247     //      Result<&T::Deref::Target, &E::Deref::Target>::Ok(&*T)
 248     let ref_ok = &Result::Ok::<&i32, &u8>(&42);
 249     let expected_result = Result::Ok::<&i32, &u8>(&42);
 250     assert_eq!(ref_ok.deref(), expected_result);
 251
 252     let ref_ok = &Result::Ok::<String, &u32>(String::from("a result"));
 253     let expected_result = Result::Ok::<&str, &u32>("a result");
 254     assert_eq!(ref_ok.deref(), expected_result);
 255
 256     let ref_ok = &Result::Ok::<Vec<i32>, &u32>(vec![1, 2, 3, 4, 5]);
 257     let expected_result = Result::Ok::<&[i32], &u32>(&[1, 2, 3, 4, 5][..]);
 258     assert_eq!(ref_ok.deref(), expected_result);
 259
 260     // &Result<T, E: Deref>::Err(T).deref_err() ->
 261     //      Result<&T, &E::Deref::Target>::Err(&*E)
 262     let ref_err = &Result::Err::<u8, &i32>(&41);
 263     let expected_result = Result::Err::<&u8, &i32>(&41);
 264     assert_eq!(ref_err.deref_err(), expected_result);
 265
 266     let ref_err = &Result::Err::<u32, String>(String::from("an error"));
 267     let expected_result = Result::Err::<&u32, &str>("an error");
 268     assert_eq!(ref_err.deref_err(), expected_result);
 269
 270     let ref_err = &Result::Err::<u32, Vec<i32>>(vec![5, 4, 3, 2, 1]);
 271     let expected_result = Result::Err::<&u32, &[i32]>(&[5, 4, 3, 2, 1][..]);
 272     assert_eq!(ref_err.deref_err(), expected_result);
 273
 274     // &Result<T: Deref, E: Deref>::Err(T).deref_err() ->
 275     //      Result<&T, &E::Deref::Target>::Err(&*E)
 276     let ref_err = &Result::Err::<&u8, &i32>(&41);
 277     let expected_result = Result::Err::<&u8, &i32>(&41);
 278     assert_eq!(ref_err.deref(), expected_result);
 279
 280     let ref_err = &Result::Err::<&u32, String>(String::from("an error"));
 281     let expected_result = Result::Err::<&u32, &str>("an error");
 282     assert_eq!(ref_err.deref(), expected_result);
 283
 284     let ref_err = &Result::Err::<&u32, Vec<i32>>(vec![5, 4, 3, 2, 1]);
 285     let expected_result = Result::Err::<&u32, &[i32]>(&[5, 4, 3, 2, 1][..]);
 286     assert_eq!(ref_err.deref(), expected_result);
 287
 288     // The following cases test calling deref_* with the wrong variant (i.e.
 289     // `deref_ok()` with a `Result::Err()`, or `deref_err()` with a `Result::Ok()`.
 290     // While unusual, these cases are supported to ensure that an `inner_deref`
 291     // call can still be made even when one of the Result types does not implement
 292     // `Deref` (for example, std::io::Error).
 293
 294     // &Result<T, E: Deref>::Ok(T).deref_err() ->
 295     //      Result<&T, &E::Deref::Target>::Ok(&T)
 296     let ref_ok = &Result::Ok::<i32, &u8>(42);
 297     let expected_result = Result::Ok::<&i32, &u8>(&42);
 298     assert_eq!(ref_ok.deref_err(), expected_result);
 299
 300     let ref_ok = &Result::Ok::<&str, &u32>("a result");
 301     let expected_result = Result::Ok::<&&str, &u32>(&"a result");
 302     assert_eq!(ref_ok.deref_err(), expected_result);
 303
 304     let ref_ok = &Result::Ok::<[i32; 5], &u32>([1, 2, 3, 4, 5]);
 305     let expected_result = Result::Ok::<&[i32; 5], &u32>(&[1, 2, 3, 4, 5]);
 306     assert_eq!(ref_ok.deref_err(), expected_result);
 307
 308     // &Result<T: Deref, E>::Err(E).deref_ok() ->
 309     //      Result<&T::Deref::Target, &E>::Err(&E)
 310     let ref_err = &Result::Err::<&u8, i32>(41);
 311     let expected_result = Result::Err::<&u8, &i32>(&41);
 312     assert_eq!(ref_err.deref_ok(), expected_result);
 313
 314     let ref_err = &Result::Err::<&u32, &str>("an error");
 315     let expected_result = Result::Err::<&u32, &&str>(&"an error");
 316     assert_eq!(ref_err.deref_ok(), expected_result);
 317
 318     let ref_err = &Result::Err::<&u32, [i32; 5]>([5, 4, 3, 2, 1]);
 319     let expected_result = Result::Err::<&u32, &[i32; 5]>(&[5, 4, 3, 2, 1]);
 320     assert_eq!(ref_err.deref_ok(), expected_result);
 321 }