src/libcoretest/option.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use core::option::*;
  12 use core::kinds::marker;
  13 use core::mem;
  14
  15 #[test]
  16 fn test_get_ptr() {
  17     unsafe {
  18         let x = box 0i;
  19         let addr_x: *const int = mem::transmute(&*x);
  20         let opt = Some(x);
  21         let y = opt.unwrap();
  22         let addr_y: *const int = mem::transmute(&*y);
  23         assert_eq!(addr_x, addr_y);
  24     }
  25 }
  26
  27 #[test]
  28 fn test_get_str() {
  29     let x = "test".to_string();
  30     let addr_x = x.as_slice().as_ptr();
  31     let opt = Some(x);
  32     let y = opt.unwrap();
  33     let addr_y = y.as_slice().as_ptr();
  34     assert_eq!(addr_x, addr_y);
  35 }
  36
  37 #[test]
  38 fn test_get_resource() {
  39     use std::rc::Rc;
  40     use core::cell::RefCell;
  41
  42     struct R {
  43        i: Rc<RefCell<int>>,
  44     }
  45
  46     #[unsafe_destructor]
  47     impl Drop for R {
  48        fn drop(&mut self) {
  49             let ii = &*self.i;
  50             let i = *ii.borrow();
  51             *ii.borrow_mut() = i + 1;
  52         }
  53     }
  54
  55     fn r(i: Rc<RefCell<int>>) -> R {
  56         R {
  57             i: i
  58         }
  59     }
  60
  61     let i = Rc::new(RefCell::new(0i));
  62     {
  63         let x = r(i.clone());
  64         let opt = Some(x);
  65         let _y = opt.unwrap();
  66     }
  67     assert_eq!(*i.borrow(), 1);
  68 }
  69
  70 #[test]
  71 fn test_option_dance() {
  72     let x = Some(());
  73     let mut y = Some(5i);
  74     let mut y2 = 0;
  75     for _x in x.iter() {
  76         y2 = y.take().unwrap();
  77     }
  78     assert_eq!(y2, 5);
  79     assert!(y.is_none());
  80 }
  81
  82 #[test] #[should_fail]
  83 fn test_option_too_much_dance() {
  84     let mut y = Some(marker::NoCopy);
  85     let _y2 = y.take().unwrap();
  86     let _y3 = y.take().unwrap();
  87 }
  88
  89 #[test]
  90 fn test_and() {
  91     let x: Option<int> = Some(1i);
  92     assert_eq!(x.and(Some(2i)), Some(2));
  93     assert_eq!(x.and(None::<int>), None);
  94
  95     let x: Option<int> = None;
  96     assert_eq!(x.and(Some(2i)), None);
  97     assert_eq!(x.and(None::<int>), None);
  98 }
  99
 100 #[test]
 101 fn test_and_then() {
 102     let x: Option<int> = Some(1);
 103     assert_eq!(x.and_then(|x| Some(x + 1)), Some(2));
 104     assert_eq!(x.and_then(|_| None::<int>), None);
 105
 106     let x: Option<int> = None;
 107     assert_eq!(x.and_then(|x| Some(x + 1)), None);
 108     assert_eq!(x.and_then(|_| None::<int>), None);
 109 }
 110
 111 #[test]
 112 fn test_or() {
 113     let x: Option<int> = Some(1);
 114     assert_eq!(x.or(Some(2)), Some(1));
 115     assert_eq!(x.or(None), Some(1));
 116
 117     let x: Option<int> = None;
 118     assert_eq!(x.or(Some(2)), Some(2));
 119     assert_eq!(x.or(None), None);
 120 }
 121
 122 #[test]
 123 fn test_or_else() {
 124     let x: Option<int> = Some(1);
 125     assert_eq!(x.or_else(|| Some(2)), Some(1));
 126     assert_eq!(x.or_else(|| None), Some(1));
 127
 128     let x: Option<int> = None;
 129     assert_eq!(x.or_else(|| Some(2)), Some(2));
 130     assert_eq!(x.or_else(|| None), None);
 131 }
 132
 133 #[test]
 134 #[allow(deprecated)]
 135 fn test_option_while_some() {
 136     let mut i = 0i;
 137     Some(10i).while_some(|j| {
 138         i += 1;
 139         if j > 0 {
 140             Some(j-1)
 141         } else {
 142             None
 143         }
 144     });
 145     assert_eq!(i, 11);
 146 }
 147
 148 #[test]
 149 fn test_unwrap() {
 150     assert_eq!(Some(1i).unwrap(), 1);
 151     let s = Some("hello".to_string()).unwrap();
 152     assert_eq!(s.as_slice(), "hello");
 153 }
 154
 155 #[test]
 156 #[should_fail]
 157 fn test_unwrap_fail1() {
 158     let x: Option<int> = None;
 159     x.unwrap();
 160 }
 161
 162 #[test]
 163 #[should_fail]
 164 fn test_unwrap_fail2() {
 165     let x: Option<String> = None;
 166     x.unwrap();
 167 }
 168
 169 #[test]
 170 fn test_unwrap_or() {
 171     let x: Option<int> = Some(1);
 172     assert_eq!(x.unwrap_or(2), 1);
 173
 174     let x: Option<int> = None;
 175     assert_eq!(x.unwrap_or(2), 2);
 176 }
 177
 178 #[test]
 179 fn test_unwrap_or_else() {
 180     let x: Option<int> = Some(1);
 181     assert_eq!(x.unwrap_or_else(|| 2), 1);
 182
 183     let x: Option<int> = None;
 184     assert_eq!(x.unwrap_or_else(|| 2), 2);
 185 }
 186
 187 #[test]
 188 #[allow(deprecated)]
 189 fn test_filtered() {
 190     let some_stuff = Some(42i);
 191     let modified_stuff = some_stuff.filtered(|&x| {x < 10});
 192     assert_eq!(some_stuff.unwrap(), 42);
 193     assert!(modified_stuff.is_none());
 194 }
 195
 196 #[test]
 197 fn test_iter() {
 198     let val = 5i;
 199
 200     let x = Some(val);
 201     let mut it = x.iter();
 202
 203     assert_eq!(it.size_hint(), (1, Some(1)));
 204     assert_eq!(it.next(), Some(&val));
 205     assert_eq!(it.size_hint(), (0, Some(0)));
 206     assert!(it.next().is_none());
 207 }
 208
 209 #[test]
 210 fn test_mut_iter() {
 211     let val = 5i;
 212     let new_val = 11i;
 213
 214     let mut x = Some(val);
 215     {
 216         let mut it = x.mut_iter();
 217
 218         assert_eq!(it.size_hint(), (1, Some(1)));
 219
 220         match it.next() {
 221             Some(interior) => {
 222                 assert_eq!(*interior, val);
 223                 *interior = new_val;
 224             }
 225             None => assert!(false),
 226         }
 227
 228         assert_eq!(it.size_hint(), (0, Some(0)));
 229         assert!(it.next().is_none());
 230     }
 231     assert_eq!(x, Some(new_val));
 232 }
 233
 234 #[test]
 235 fn test_ord() {
 236     let small = Some(1.0f64);
 237     let big = Some(5.0f64);
 238     let nan = Some(0.0f64/0.0);
 239     assert!(!(nan < big));
 240     assert!(!(nan > big));
 241     assert!(small < big);
 242     assert!(None < big);
 243     assert!(big > None);
 244 }
 245
 246 #[test]
 247 fn test_mutate() {
 248     let mut x = Some(3i);
 249     assert!(x.mutate(|i| i+1));
 250     assert_eq!(x, Some(4i));
 251     assert!(x.mutate_or_set(0, |i| i+1));
 252     assert_eq!(x, Some(5i));
 253     x = None;
 254     assert!(!x.mutate(|i| i+1));
 255     assert_eq!(x, None);
 256     assert!(!x.mutate_or_set(0i, |i| i+1));
 257     assert_eq!(x, Some(0i));
 258 }
 259
 260 #[test]
 261 #[allow(deprecated)]
 262 fn test_collect() {
 263     let v: Option<Vec<int>> = collect(range(0i, 0)
 264                                       .map(|_| Some(0i)));
 265     assert!(v == Some(vec![]));
 266
 267     let v: Option<Vec<int>> = collect(range(0i, 3)
 268                                       .map(|x| Some(x)));
 269     assert!(v == Some(vec![0, 1, 2]));
 270
 271     let v: Option<Vec<int>> = collect(range(0i, 3)
 272                                       .map(|x| if x > 1 { None } else { Some(x) }));
 273     assert!(v == None);
 274
 275     // test that it does not take more elements than it needs
 276     let mut functions = [|| Some(()), || None, || fail!()];
 277
 278     let v: Option<Vec<()>> = collect(functions.mut_iter().map(|f| (*f)()));
 279
 280     assert!(v == None);
 281 }