src/libcore/tests/cell.rs

   1 use core::cell::*;
   2 use core::default::Default;
   3 use std::mem::drop;
   4
   5 #[test]
   6 fn smoketest_cell() {
   7     let x = Cell::new(10);
   8     assert_eq!(x, Cell::new(10));
   9     assert_eq!(x.get(), 10);
  10     x.set(20);
  11     assert_eq!(x, Cell::new(20));
  12     assert_eq!(x.get(), 20);
  13
  14     let y = Cell::new((30, 40));
  15     assert_eq!(y, Cell::new((30, 40)));
  16     assert_eq!(y.get(), (30, 40));
  17 }
  18
  19 #[test]
  20 fn cell_update() {
  21     let x = Cell::new(10);
  22
  23     assert_eq!(x.update(|x| x + 5), 15);
  24     assert_eq!(x.get(), 15);
  25
  26     assert_eq!(x.update(|x| x / 3), 5);
  27     assert_eq!(x.get(), 5);
  28 }
  29
  30 #[test]
  31 fn cell_has_sensible_show() {
  32     let x = Cell::new("foo bar");
  33     assert!(format!("{:?}", x).contains(x.get()));
  34
  35     x.set("baz qux");
  36     assert!(format!("{:?}", x).contains(x.get()));
  37 }
  38
  39 #[test]
  40 fn ref_and_refmut_have_sensible_show() {
  41     let refcell = RefCell::new("foo");
  42
  43     let refcell_refmut = refcell.borrow_mut();
  44     assert!(format!("{:?}", refcell_refmut).contains("foo"));
  45     drop(refcell_refmut);
  46
  47     let refcell_ref = refcell.borrow();
  48     assert!(format!("{:?}", refcell_ref).contains("foo"));
  49     drop(refcell_ref);
  50 }
  51
  52 #[test]
  53 fn double_imm_borrow() {
  54     let x = RefCell::new(0);
  55     let _b1 = x.borrow();
  56     x.borrow();
  57 }
  58
  59 #[test]
  60 fn no_mut_then_imm_borrow() {
  61     let x = RefCell::new(0);
  62     let _b1 = x.borrow_mut();
  63     assert!(x.try_borrow().is_err());
  64 }
  65
  66 #[test]
  67 fn no_imm_then_borrow_mut() {
  68     let x = RefCell::new(0);
  69     let _b1 = x.borrow();
  70     assert!(x.try_borrow_mut().is_err());
  71 }
  72
  73 #[test]
  74 fn no_double_borrow_mut() {
  75     let x = RefCell::new(0);
  76     assert!(x.try_borrow().is_ok());
  77     let _b1 = x.borrow_mut();
  78     assert!(x.try_borrow().is_err());
  79 }
  80
  81 #[test]
  82 fn imm_release_borrow_mut() {
  83     let x = RefCell::new(0);
  84     {
  85         let _b1 = x.borrow();
  86     }
  87     x.borrow_mut();
  88 }
  89
  90 #[test]
  91 fn mut_release_borrow_mut() {
  92     let x = RefCell::new(0);
  93     {
  94         let _b1 = x.borrow_mut();
  95     }
  96     x.borrow();
  97 }
  98
  99 #[test]
 100 fn double_borrow_single_release_no_borrow_mut() {
 101     let x = RefCell::new(0);
 102     let _b1 = x.borrow();
 103     {
 104         let _b2 = x.borrow();
 105     }
 106     assert!(x.try_borrow().is_ok());
 107     assert!(x.try_borrow_mut().is_err());
 108 }
 109
 110 #[test]
 111 #[should_panic]
 112 fn discard_doesnt_unborrow() {
 113     let x = RefCell::new(0);
 114     let _b = x.borrow();
 115     let _ = _b;
 116     let _b = x.borrow_mut();
 117 }
 118
 119 #[test]
 120 fn ref_clone_updates_flag() {
 121     let x = RefCell::new(0);
 122     {
 123         let b1 = x.borrow();
 124         assert!(x.try_borrow().is_ok());
 125         assert!(x.try_borrow_mut().is_err());
 126         {
 127             let _b2 = Ref::clone(&b1);
 128             assert!(x.try_borrow().is_ok());
 129             assert!(x.try_borrow_mut().is_err());
 130         }
 131         assert!(x.try_borrow().is_ok());
 132         assert!(x.try_borrow_mut().is_err());
 133     }
 134     assert!(x.try_borrow().is_ok());
 135     assert!(x.try_borrow_mut().is_ok());
 136 }
 137
 138 #[test]
 139 fn ref_map_does_not_update_flag() {
 140     let x = RefCell::new(Some(5));
 141     {
 142         let b1: Ref<'_, Option<u32>> = x.borrow();
 143         assert!(x.try_borrow().is_ok());
 144         assert!(x.try_borrow_mut().is_err());
 145         {
 146             let b2: Ref<'_, u32> = Ref::map(b1, |o| o.as_ref().unwrap());
 147             assert_eq!(*b2, 5);
 148             assert!(x.try_borrow().is_ok());
 149             assert!(x.try_borrow_mut().is_err());
 150         }
 151         assert!(x.try_borrow().is_ok());
 152         assert!(x.try_borrow_mut().is_ok());
 153     }
 154     assert!(x.try_borrow().is_ok());
 155     assert!(x.try_borrow_mut().is_ok());
 156 }
 157
 158 #[test]
 159 fn ref_map_split_updates_flag() {
 160     let x = RefCell::new([1, 2]);
 161     {
 162         let b1 = x.borrow();
 163         assert!(x.try_borrow().is_ok());
 164         assert!(x.try_borrow_mut().is_err());
 165         {
 166             let (_b2, _b3) = Ref::map_split(b1, |slc| slc.split_at(1));
 167             assert!(x.try_borrow().is_ok());
 168             assert!(x.try_borrow_mut().is_err());
 169         }
 170         assert!(x.try_borrow().is_ok());
 171         assert!(x.try_borrow_mut().is_ok());
 172     }
 173     assert!(x.try_borrow().is_ok());
 174     assert!(x.try_borrow_mut().is_ok());
 175
 176     {
 177         let b1 = x.borrow_mut();
 178         assert!(x.try_borrow().is_err());
 179         assert!(x.try_borrow_mut().is_err());
 180         {
 181             let (_b2, _b3) = RefMut::map_split(b1, |slc| slc.split_at_mut(1));
 182             assert!(x.try_borrow().is_err());
 183             assert!(x.try_borrow_mut().is_err());
 184             drop(_b2);
 185             assert!(x.try_borrow().is_err());
 186             assert!(x.try_borrow_mut().is_err());
 187         }
 188         assert!(x.try_borrow().is_ok());
 189         assert!(x.try_borrow_mut().is_ok());
 190     }
 191     assert!(x.try_borrow().is_ok());
 192     assert!(x.try_borrow_mut().is_ok());
 193 }
 194
 195 #[test]
 196 fn ref_map_split() {
 197     let x = RefCell::new([1, 2]);
 198     let (b1, b2) = Ref::map_split(x.borrow(), |slc| slc.split_at(1));
 199     assert_eq!(*b1, [1]);
 200     assert_eq!(*b2, [2]);
 201 }
 202
 203 #[test]
 204 fn ref_mut_map_split() {
 205     let x = RefCell::new([1, 2]);
 206     {
 207         let (mut b1, mut b2) = RefMut::map_split(x.borrow_mut(), |slc| slc.split_at_mut(1));
 208         assert_eq!(*b1, [1]);
 209         assert_eq!(*b2, [2]);
 210         b1[0] = 2;
 211         b2[0] = 1;
 212     }
 213     assert_eq!(*x.borrow(), [2, 1]);
 214 }
 215
 216 #[test]
 217 fn ref_map_accessor() {
 218     struct X(RefCell<(u32, char)>);
 219     impl X {
 220         fn accessor(&self) -> Ref<'_, u32> {
 221             Ref::map(self.0.borrow(), |tuple| &tuple.0)
 222         }
 223     }
 224     let x = X(RefCell::new((7, 'z')));
 225     let d: Ref<'_, u32> = x.accessor();
 226     assert_eq!(*d, 7);
 227 }
 228
 229 #[test]
 230 fn ref_mut_map_accessor() {
 231     struct X(RefCell<(u32, char)>);
 232     impl X {
 233         fn accessor(&self) -> RefMut<'_, u32> {
 234             RefMut::map(self.0.borrow_mut(), |tuple| &mut tuple.0)
 235         }
 236     }
 237     let x = X(RefCell::new((7, 'z')));
 238     {
 239         let mut d: RefMut<'_ ,u32> = x.accessor();
 240         assert_eq!(*d, 7);
 241         *d += 1;
 242     }
 243     assert_eq!(*x.0.borrow(), (8, 'z'));
 244 }
 245
 246 #[test]
 247 fn as_ptr() {
 248     let c1: Cell<usize> = Cell::new(0);
 249     c1.set(1);
 250     assert_eq!(1, unsafe { *c1.as_ptr() });
 251
 252     let c2: Cell<usize> = Cell::new(0);
 253     unsafe { *c2.as_ptr() = 1; }
 254     assert_eq!(1, c2.get());
 255
 256     let r1: RefCell<usize> = RefCell::new(0);
 257     *r1.borrow_mut() = 1;
 258     assert_eq!(1, unsafe { *r1.as_ptr() });
 259
 260     let r2: RefCell<usize> = RefCell::new(0);
 261     unsafe { *r2.as_ptr() = 1; }
 262     assert_eq!(1, *r2.borrow());
 263 }
 264
 265 #[test]
 266 fn cell_default() {
 267     let cell: Cell<u32> = Default::default();
 268     assert_eq!(0, cell.get());
 269 }
 270
 271 #[test]
 272 fn cell_set() {
 273     let cell = Cell::new(10);
 274     cell.set(20);
 275     assert_eq!(20, cell.get());
 276
 277     let cell = Cell::new("Hello".to_owned());
 278     cell.set("World".to_owned());
 279     assert_eq!("World".to_owned(), cell.into_inner());
 280 }
 281
 282 #[test]
 283 fn cell_replace() {
 284     let cell = Cell::new(10);
 285     assert_eq!(10, cell.replace(20));
 286     assert_eq!(20, cell.get());
 287
 288     let cell = Cell::new("Hello".to_owned());
 289     assert_eq!("Hello".to_owned(), cell.replace("World".to_owned()));
 290     assert_eq!("World".to_owned(), cell.into_inner());
 291 }
 292
 293 #[test]
 294 fn cell_into_inner() {
 295     let cell = Cell::new(10);
 296     assert_eq!(10, cell.into_inner());
 297
 298     let cell = Cell::new("Hello world".to_owned());
 299     assert_eq!("Hello world".to_owned(), cell.into_inner());
 300 }
 301
 302 #[test]
 303 fn refcell_default() {
 304     let cell: RefCell<u64> = Default::default();
 305     assert_eq!(0, *cell.borrow());
 306 }
 307
 308 #[test]
 309 fn unsafe_cell_unsized() {
 310     let cell: &UnsafeCell<[i32]> = &UnsafeCell::new([1, 2, 3]);
 311     {
 312         let val: &mut [i32] = unsafe { &mut *cell.get() };
 313         val[0] = 4;
 314         val[2] = 5;
 315     }
 316     let comp: &mut [i32] = &mut [4, 2, 5];
 317     assert_eq!(unsafe { &mut *cell.get() }, comp);
 318 }
 319
 320 #[test]
 321 fn refcell_unsized() {
 322     let cell: &RefCell<[i32]> = &RefCell::new([1, 2, 3]);
 323     {
 324         let b = &mut *cell.borrow_mut();
 325         b[0] = 4;
 326         b[2] = 5;
 327     }
 328     let comp: &mut [i32] = &mut [4, 2, 5];
 329     assert_eq!(&*cell.borrow(), comp);
 330 }
 331
 332 #[test]
 333 fn refcell_ref_coercion() {
 334     let cell: RefCell<[i32; 3]> = RefCell::new([1, 2, 3]);
 335     {
 336         let mut cellref: RefMut<'_, [i32; 3]> = cell.borrow_mut();
 337         cellref[0] = 4;
 338         let mut coerced: RefMut<'_, [i32]> = cellref;
 339         coerced[2] = 5;
 340     }
 341     {
 342         let comp: &mut [i32] = &mut [4, 2, 5];
 343         let cellref: Ref<'_, [i32; 3]> = cell.borrow();
 344         assert_eq!(&*cellref, comp);
 345         let coerced: Ref<'_, [i32]> = cellref;
 346         assert_eq!(&*coerced, comp);
 347     }
 348 }
 349
 350 #[test]
 351 #[should_panic]
 352 fn refcell_swap_borrows() {
 353     let x = RefCell::new(0);
 354     let _b = x.borrow();
 355     let y = RefCell::new(1);
 356     x.swap(&y);
 357 }
 358
 359 #[test]
 360 #[should_panic]
 361 fn refcell_replace_borrows() {
 362     let x = RefCell::new(0);
 363     let _b = x.borrow();
 364     x.replace(1);
 365 }