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 fn test_option_too_much_dance() {
  73     struct A;
  74     let mut y = Some(A);
  75     let _y2 = y.take().unwrap();
  76     let _y3 = y.take().unwrap();
  77 }
  78
  79 #[test]
  80 fn test_and() {
  81     let x: Option<isize> = Some(1);
  82     assert_eq!(x.and(Some(2)), Some(2));
  83     assert_eq!(x.and(None::<isize>), None);
  84
  85     let x: Option<isize> = None;
  86     assert_eq!(x.and(Some(2)), None);
  87     assert_eq!(x.and(None::<isize>), None);
  88 }
  89
  90 #[test]
  91 fn test_and_then() {
  92     let x: Option<isize> = Some(1);
  93     assert_eq!(x.and_then(|x| Some(x + 1)), Some(2));
  94     assert_eq!(x.and_then(|_| None::<isize>), None);
  95
  96     let x: Option<isize> = None;
  97     assert_eq!(x.and_then(|x| Some(x + 1)), None);
  98     assert_eq!(x.and_then(|_| None::<isize>), None);
  99 }
 100
 101 #[test]
 102 fn test_or() {
 103     let x: Option<isize> = Some(1);
 104     assert_eq!(x.or(Some(2)), Some(1));
 105     assert_eq!(x.or(None), Some(1));
 106
 107     let x: Option<isize> = None;
 108     assert_eq!(x.or(Some(2)), Some(2));
 109     assert_eq!(x.or(None), None);
 110 }
 111
 112 #[test]
 113 fn test_or_else() {
 114     let x: Option<isize> = Some(1);
 115     assert_eq!(x.or_else(|| Some(2)), Some(1));
 116     assert_eq!(x.or_else(|| None), Some(1));
 117
 118     let x: Option<isize> = None;
 119     assert_eq!(x.or_else(|| Some(2)), Some(2));
 120     assert_eq!(x.or_else(|| None), None);
 121 }
 122
 123 #[test]
 124 fn test_unwrap() {
 125     assert_eq!(Some(1).unwrap(), 1);
 126     let s = Some("hello".to_string()).unwrap();
 127     assert_eq!(s, "hello");
 128 }
 129
 130 #[test]
 131 #[should_panic]
 132 fn test_unwrap_panic1() {
 133     let x: Option<isize> = None;
 134     x.unwrap();
 135 }
 136
 137 #[test]
 138 #[should_panic]
 139 fn test_unwrap_panic2() {
 140     let x: Option<String> = None;
 141     x.unwrap();
 142 }
 143
 144 #[test]
 145 fn test_unwrap_or() {
 146     let x: Option<isize> = Some(1);
 147     assert_eq!(x.unwrap_or(2), 1);
 148
 149     let x: Option<isize> = None;
 150     assert_eq!(x.unwrap_or(2), 2);
 151 }
 152
 153 #[test]
 154 fn test_unwrap_or_else() {
 155     let x: Option<isize> = Some(1);
 156     assert_eq!(x.unwrap_or_else(|| 2), 1);
 157
 158     let x: Option<isize> = None;
 159     assert_eq!(x.unwrap_or_else(|| 2), 2);
 160 }
 161
 162 #[test]
 163 fn test_iter() {
 164     let val = 5;
 165
 166     let x = Some(val);
 167     let mut it = x.iter();
 168
 169     assert_eq!(it.size_hint(), (1, Some(1)));
 170     assert_eq!(it.next(), Some(&val));
 171     assert_eq!(it.size_hint(), (0, Some(0)));
 172     assert!(it.next().is_none());
 173
 174     let mut it = (&x).into_iter();
 175     assert_eq!(it.next(), Some(&val));
 176 }
 177
 178 #[test]
 179 fn test_mut_iter() {
 180     let mut val = 5;
 181     let new_val = 11;
 182
 183     let mut x = Some(val);
 184     {
 185         let mut it = x.iter_mut();
 186
 187         assert_eq!(it.size_hint(), (1, Some(1)));
 188
 189         match it.next() {
 190             Some(interior) => {
 191                 assert_eq!(*interior, val);
 192                 *interior = new_val;
 193             }
 194             None => assert!(false),
 195         }
 196
 197         assert_eq!(it.size_hint(), (0, Some(0)));
 198         assert!(it.next().is_none());
 199     }
 200     assert_eq!(x, Some(new_val));
 201
 202     let mut y = Some(val);
 203     let mut it = (&mut y).into_iter();
 204     assert_eq!(it.next(), Some(&mut val));
 205 }
 206
 207 #[test]
 208 fn test_ord() {
 209     let small = Some(1.0f64);
 210     let big = Some(5.0f64);
 211     let nan = Some(0.0f64/0.0);
 212     assert!(!(nan < big));
 213     assert!(!(nan > big));
 214     assert!(small < big);
 215     assert!(None < big);
 216     assert!(big > None);
 217 }
 218
 219 #[test]
 220 fn test_collect() {
 221     let v: Option<Vec<isize>> = (0..0).map(|_| Some(0)).collect();
 222     assert!(v == Some(vec![]));
 223
 224     let v: Option<Vec<isize>> = (0..3).map(|x| Some(x)).collect();
 225     assert!(v == Some(vec![0, 1, 2]));
 226
 227     let v: Option<Vec<isize>> = (0..3).map(|x| {
 228         if x > 1 { None } else { Some(x) }
 229     }).collect();
 230     assert!(v == None);
 231
 232     // test that it does not take more elements than it needs
 233     let mut functions: [Box<dyn Fn() -> Option<()>>; 3] =
 234         [box || Some(()), box || None, box || panic!()];
 235
 236     let v: Option<Vec<()>> = functions.iter_mut().map(|f| (*f)()).collect();
 237
 238     assert!(v == None);
 239 }
 240
 241 #[test]
 242 fn test_copied() {
 243     let val = 1;
 244     let val_ref = &val;
 245     let opt_none: Option<&'static u32> = None;
 246     let opt_ref = Some(&val);
 247     let opt_ref_ref = Some(&val_ref);
 248
 249     // None works
 250     assert_eq!(opt_none.clone(), None);
 251     assert_eq!(opt_none.copied(), None);
 252
 253     // Immutable ref works
 254     assert_eq!(opt_ref.clone(), Some(&val));
 255     assert_eq!(opt_ref.copied(), Some(1));
 256
 257     // Double Immutable ref works
 258     assert_eq!(opt_ref_ref.clone(), Some(&val_ref));
 259     assert_eq!(opt_ref_ref.clone().copied(), Some(&val));
 260     assert_eq!(opt_ref_ref.copied().copied(), Some(1));
 261 }
 262
 263 #[test]
 264 fn test_cloned() {
 265     let val = 1;
 266     let val_ref = &val;
 267     let opt_none: Option<&'static u32> = None;
 268     let opt_ref = Some(&val);
 269     let opt_ref_ref = Some(&val_ref);
 270
 271     // None works
 272     assert_eq!(opt_none.clone(), None);
 273     assert_eq!(opt_none.cloned(), None);
 274
 275     // Immutable ref works
 276     assert_eq!(opt_ref.clone(), Some(&val));
 277     assert_eq!(opt_ref.cloned(), Some(1));
 278
 279     // Double Immutable ref works
 280     assert_eq!(opt_ref_ref.clone(), Some(&val_ref));
 281     assert_eq!(opt_ref_ref.clone().cloned(), Some(&val));
 282     assert_eq!(opt_ref_ref.cloned().cloned(), Some(1));
 283 }
 284
 285 #[test]
 286 fn test_try() {
 287     fn try_option_some() -> Option<u8> {
 288         let val = Some(1)?;
 289         Some(val)
 290     }
 291     assert_eq!(try_option_some(), Some(1));
 292
 293     fn try_option_none() -> Option<u8> {
 294         let val = None?;
 295         Some(val)
 296     }
 297     assert_eq!(try_option_none(), None);
 298
 299     fn try_option_ok() -> Result<u8, NoneError> {
 300         let val = Some(1)?;
 301         Ok(val)
 302     }
 303     assert_eq!(try_option_ok(), Ok(1));
 304
 305     fn try_option_err() -> Result<u8, NoneError> {
 306         let val = None?;
 307         Ok(val)
 308     }
 309     assert_eq!(try_option_err(), Err(NoneError));
 310 }
 311
 312 #[test]
 313 fn test_option_deref() {
 314     // Some: &Option<T: Deref>::Some(T) -> Option<&T::Deref::Target>::Some(&*T)
 315     let ref_option = &Some(&42);
 316     assert_eq!(ref_option.deref(), Some(&42));
 317
 318     let ref_option = &Some(String::from("a result"));
 319     assert_eq!(ref_option.deref(), Some("a result"));
 320
 321     let ref_option = &Some(vec![1, 2, 3, 4, 5]);
 322     assert_eq!(ref_option.deref(), Some(&[1, 2, 3, 4, 5][..]));
 323
 324     // None: &Option<T: Deref>>::None -> None
 325     let ref_option: &Option<&i32> = &None;
 326     assert_eq!(ref_option.deref(), None);
 327 }
 328
 329 #[test]
 330 fn test_replace() {
 331     let mut x = Some(2);
 332     let old = x.replace(5);
 333
 334     assert_eq!(x, Some(5));
 335     assert_eq!(old, Some(2));
 336
 337     let mut x = None;
 338     let old = x.replace(3);
 339
 340     assert_eq!(x, Some(3));
 341     assert_eq!(old, None);
 342 }