src/libcore/tests/option.rs

   1 use core::option::*;
   2 use core::mem;
   3 use core::clone::Clone;
   4
   5 #[test]
   6 fn test_get_ptr() {
   7     unsafe {
   8         let x: Box<_> = box 0;
   9         let addr_x: *const isize = mem::transmute(&*x);
  10         let opt = Some(x);
  11         let y = opt.unwrap();
  12         let addr_y: *const isize = mem::transmute(&*y);
  13         assert_eq!(addr_x, addr_y);
  14     }
  15 }
  16
  17 #[test]
  18 fn test_get_str() {
  19     let x = "test".to_string();
  20     let addr_x = x.as_ptr();
  21     let opt = Some(x);
  22     let y = opt.unwrap();
  23     let addr_y = y.as_ptr();
  24     assert_eq!(addr_x, addr_y);
  25 }
  26
  27 #[test]
  28 fn test_get_resource() {
  29     use std::rc::Rc;
  30     use core::cell::RefCell;
  31
  32     struct R {
  33        i: Rc<RefCell<isize>>,
  34     }
  35
  36         impl Drop for R {
  37        fn drop(&mut self) {
  38             let ii = &*self.i;
  39             let i = *ii.borrow();
  40             *ii.borrow_mut() = i + 1;
  41         }
  42     }
  43
  44     fn r(i: Rc<RefCell<isize>>) -> R {
  45         R {
  46             i,
  47         }
  48     }
  49
  50     let i = Rc::new(RefCell::new(0));
  51     {
  52         let x = r(i.clone());
  53         let opt = Some(x);
  54         let _y = opt.unwrap();
  55     }
  56     assert_eq!(*i.borrow(), 1);
  57 }
  58
  59 #[test]
  60 fn test_option_dance() {
  61     let x = Some(());
  62     let mut y = Some(5);
  63     let mut y2 = 0;
  64     for _x in x {
  65         y2 = y.take().unwrap();
  66     }
  67     assert_eq!(y2, 5);
  68     assert!(y.is_none());
  69 }
  70
  71 #[test] #[should_panic]
  72 #[cfg(not(miri))]
  73 fn test_option_too_much_dance() {
  74     struct A;
  75     let mut y = Some(A);
  76     let _y2 = y.take().unwrap();
  77     let _y3 = y.take().unwrap();
  78 }
  79
  80 #[test]
  81 fn test_and() {
  82     let x: Option<isize> = Some(1);
  83     assert_eq!(x.and(Some(2)), Some(2));
  84     assert_eq!(x.and(None::<isize>), None);
  85
  86     let x: Option<isize> = None;
  87     assert_eq!(x.and(Some(2)), None);
  88     assert_eq!(x.and(None::<isize>), None);
  89 }
  90
  91 #[test]
  92 fn test_and_then() {
  93     let x: Option<isize> = Some(1);
  94     assert_eq!(x.and_then(|x| Some(x + 1)), Some(2));
  95     assert_eq!(x.and_then(|_| None::<isize>), None);
  96
  97     let x: Option<isize> = None;
  98     assert_eq!(x.and_then(|x| Some(x + 1)), None);
  99     assert_eq!(x.and_then(|_| None::<isize>), None);
 100 }
 101
 102 #[test]
 103 fn test_or() {
 104     let x: Option<isize> = Some(1);
 105     assert_eq!(x.or(Some(2)), Some(1));
 106     assert_eq!(x.or(None), Some(1));
 107
 108     let x: Option<isize> = None;
 109     assert_eq!(x.or(Some(2)), Some(2));
 110     assert_eq!(x.or(None), None);
 111 }
 112
 113 #[test]
 114 fn test_or_else() {
 115     let x: Option<isize> = Some(1);
 116     assert_eq!(x.or_else(|| Some(2)), Some(1));
 117     assert_eq!(x.or_else(|| None), Some(1));
 118
 119     let x: Option<isize> = None;
 120     assert_eq!(x.or_else(|| Some(2)), Some(2));
 121     assert_eq!(x.or_else(|| None), None);
 122 }
 123
 124 #[test]
 125 fn test_unwrap() {
 126     assert_eq!(Some(1).unwrap(), 1);
 127     let s = Some("hello".to_string()).unwrap();
 128     assert_eq!(s, "hello");
 129 }
 130
 131 #[test]
 132 #[should_panic]
 133 #[cfg(not(miri))]
 134 fn test_unwrap_panic1() {
 135     let x: Option<isize> = None;
 136     x.unwrap();
 137 }
 138
 139 #[test]
 140 #[should_panic]
 141 #[cfg(not(miri))]
 142 fn test_unwrap_panic2() {
 143     let x: Option<String> = None;
 144     x.unwrap();
 145 }
 146
 147 #[test]
 148 fn test_unwrap_or() {
 149     let x: Option<isize> = Some(1);
 150     assert_eq!(x.unwrap_or(2), 1);
 151
 152     let x: Option<isize> = None;
 153     assert_eq!(x.unwrap_or(2), 2);
 154 }
 155
 156 #[test]
 157 fn test_unwrap_or_else() {
 158     let x: Option<isize> = Some(1);
 159     assert_eq!(x.unwrap_or_else(|| 2), 1);
 160
 161     let x: Option<isize> = None;
 162     assert_eq!(x.unwrap_or_else(|| 2), 2);
 163 }
 164
 165 #[test]
 166 fn test_iter() {
 167     let val = 5;
 168
 169     let x = Some(val);
 170     let mut it = x.iter();
 171
 172     assert_eq!(it.size_hint(), (1, Some(1)));
 173     assert_eq!(it.next(), Some(&val));
 174     assert_eq!(it.size_hint(), (0, Some(0)));
 175     assert!(it.next().is_none());
 176
 177     let mut it = (&x).into_iter();
 178     assert_eq!(it.next(), Some(&val));
 179 }
 180
 181 #[test]
 182 fn test_mut_iter() {
 183     let mut val = 5;
 184     let new_val = 11;
 185
 186     let mut x = Some(val);
 187     {
 188         let mut it = x.iter_mut();
 189
 190         assert_eq!(it.size_hint(), (1, Some(1)));
 191
 192         match it.next() {
 193             Some(interior) => {
 194                 assert_eq!(*interior, val);
 195                 *interior = new_val;
 196             }
 197             None => assert!(false),
 198         }
 199
 200         assert_eq!(it.size_hint(), (0, Some(0)));
 201         assert!(it.next().is_none());
 202     }
 203     assert_eq!(x, Some(new_val));
 204
 205     let mut y = Some(val);
 206     let mut it = (&mut y).into_iter();
 207     assert_eq!(it.next(), Some(&mut val));
 208 }
 209
 210 #[test]
 211 fn test_ord() {
 212     let small = Some(1.0f64);
 213     let big = Some(5.0f64);
 214     let nan = Some(0.0f64/0.0);
 215     assert!(!(nan < big));
 216     assert!(!(nan > big));
 217     assert!(small < big);
 218     assert!(None < big);
 219     assert!(big > None);
 220 }
 221
 222 #[test]
 223 fn test_collect() {
 224     let v: Option<Vec<isize>> = (0..0).map(|_| Some(0)).collect();
 225     assert!(v == Some(vec![]));
 226
 227     let v: Option<Vec<isize>> = (0..3).map(|x| Some(x)).collect();
 228     assert!(v == Some(vec![0, 1, 2]));
 229
 230     let v: Option<Vec<isize>> = (0..3).map(|x| {
 231         if x > 1 { None } else { Some(x) }
 232     }).collect();
 233     assert!(v == None);
 234
 235     // test that it does not take more elements than it needs
 236     let mut functions: [Box<dyn Fn() -> Option<()>>; 3] =
 237         [box || Some(()), box || None, box || panic!()];
 238
 239     let v: Option<Vec<()>> = functions.iter_mut().map(|f| (*f)()).collect();
 240
 241     assert!(v == None);
 242 }
 243
 244 #[test]
 245 fn test_copied() {
 246     let val = 1;
 247     let val_ref = &val;
 248     let opt_none: Option<&'static u32> = None;
 249     let opt_ref = Some(&val);
 250     let opt_ref_ref = Some(&val_ref);
 251
 252     // None works
 253     assert_eq!(opt_none.clone(), None);
 254     assert_eq!(opt_none.copied(), None);
 255
 256     // Immutable ref works
 257     assert_eq!(opt_ref.clone(), Some(&val));
 258     assert_eq!(opt_ref.copied(), Some(1));
 259
 260     // Double Immutable ref works
 261     assert_eq!(opt_ref_ref.clone(), Some(&val_ref));
 262     assert_eq!(opt_ref_ref.clone().copied(), Some(&val));
 263     assert_eq!(opt_ref_ref.copied().copied(), Some(1));
 264 }
 265
 266 #[test]
 267 fn test_cloned() {
 268     let val = 1;
 269     let val_ref = &val;
 270     let opt_none: Option<&'static u32> = None;
 271     let opt_ref = Some(&val);
 272     let opt_ref_ref = Some(&val_ref);
 273
 274     // None works
 275     assert_eq!(opt_none.clone(), None);
 276     assert_eq!(opt_none.cloned(), None);
 277
 278     // Immutable ref works
 279     assert_eq!(opt_ref.clone(), Some(&val));
 280     assert_eq!(opt_ref.cloned(), Some(1));
 281
 282     // Double Immutable ref works
 283     assert_eq!(opt_ref_ref.clone(), Some(&val_ref));
 284     assert_eq!(opt_ref_ref.clone().cloned(), Some(&val));
 285     assert_eq!(opt_ref_ref.cloned().cloned(), Some(1));
 286 }
 287
 288 #[test]
 289 fn test_try() {
 290     fn try_option_some() -> Option<u8> {
 291         let val = Some(1)?;
 292         Some(val)
 293     }
 294     assert_eq!(try_option_some(), Some(1));
 295
 296     fn try_option_none() -> Option<u8> {
 297         let val = None?;
 298         Some(val)
 299     }
 300     assert_eq!(try_option_none(), None);
 301
 302     fn try_option_ok() -> Result<u8, NoneError> {
 303         let val = Some(1)?;
 304         Ok(val)
 305     }
 306     assert_eq!(try_option_ok(), Ok(1));
 307
 308     fn try_option_err() -> Result<u8, NoneError> {
 309         let val = None?;
 310         Ok(val)
 311     }
 312     assert_eq!(try_option_err(), Err(NoneError));
 313 }
 314
 315 #[test]
 316 fn test_option_deref() {
 317     // Some: &Option<T: Deref>::Some(T) -> Option<&T::Deref::Target>::Some(&*T)
 318     let ref_option = &Some(&42);
 319     assert_eq!(ref_option.deref(), Some(&42));
 320
 321     let ref_option = &Some(String::from("a result"));
 322     assert_eq!(ref_option.deref(), Some("a result"));
 323
 324     let ref_option = &Some(vec![1, 2, 3, 4, 5]);
 325     assert_eq!(ref_option.deref(), Some(&[1, 2, 3, 4, 5][..]));
 326
 327     // None: &Option<T: Deref>>::None -> None
 328     let ref_option: &Option<&i32> = &None;
 329     assert_eq!(ref_option.deref(), None);
 330 }
 331
 332 #[test]
 333 fn test_replace() {
 334     let mut x = Some(2);
 335     let old = x.replace(5);
 336
 337     assert_eq!(x, Some(5));
 338     assert_eq!(old, Some(2));
 339
 340     let mut x = None;
 341     let old = x.replace(3);
 342
 343     assert_eq!(x, Some(3));
 344     assert_eq!(old, None);
 345 }