src/libcoretest/cell.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::cell::*;
  12 use core::default::Default;
  13 use std::mem::drop;
  14
  15 #[test]
  16 fn smoketest_cell() {
  17     let x = Cell::new(10);
  18     assert!(x == Cell::new(10));
  19     assert!(x.get() == 10);
  20     x.set(20);
  21     assert!(x == Cell::new(20));
  22     assert!(x.get() == 20);
  23
  24     let y = Cell::new((30, 40));
  25     assert!(y == Cell::new((30, 40)));
  26     assert!(y.get() == (30, 40));
  27 }
  28
  29 #[test]
  30 fn cell_has_sensible_show() {
  31     let x = Cell::new("foo bar");
  32     assert!(format!("{:?}", x).contains(x.get()));
  33
  34     x.set("baz qux");
  35     assert!(format!("{:?}", x).contains(x.get()));
  36 }
  37
  38 #[test]
  39 fn ref_and_refmut_have_sensible_show() {
  40     let refcell = RefCell::new("foo");
  41
  42     let refcell_refmut = refcell.borrow_mut();
  43     assert!(format!("{:?}", refcell_refmut).contains("foo"));
  44     drop(refcell_refmut);
  45
  46     let refcell_ref = refcell.borrow();
  47     assert!(format!("{:?}", refcell_ref).contains("foo"));
  48     drop(refcell_ref);
  49 }
  50
  51 #[test]
  52 fn double_imm_borrow() {
  53     let x = RefCell::new(0);
  54     let _b1 = x.borrow();
  55     x.borrow();
  56 }
  57
  58 #[test]
  59 fn no_mut_then_imm_borrow() {
  60     let x = RefCell::new(0);
  61     let _b1 = x.borrow_mut();
  62     assert_eq!(x.borrow_state(), BorrowState::Writing);
  63 }
  64
  65 #[test]
  66 fn no_imm_then_borrow_mut() {
  67     let x = RefCell::new(0);
  68     let _b1 = x.borrow();
  69     assert_eq!(x.borrow_state(), BorrowState::Reading);
  70 }
  71
  72 #[test]
  73 fn no_double_borrow_mut() {
  74     let x = RefCell::new(0);
  75     assert_eq!(x.borrow_state(), BorrowState::Unused);
  76     let _b1 = x.borrow_mut();
  77     assert_eq!(x.borrow_state(), BorrowState::Writing);
  78 }
  79
  80 #[test]
  81 fn imm_release_borrow_mut() {
  82     let x = RefCell::new(0);
  83     {
  84         let _b1 = x.borrow();
  85     }
  86     x.borrow_mut();
  87 }
  88
  89 #[test]
  90 fn mut_release_borrow_mut() {
  91     let x = RefCell::new(0);
  92     {
  93         let _b1 = x.borrow_mut();
  94     }
  95     x.borrow();
  96 }
  97
  98 #[test]
  99 fn double_borrow_single_release_no_borrow_mut() {
 100     let x = RefCell::new(0);
 101     let _b1 = x.borrow();
 102     {
 103         let _b2 = x.borrow();
 104     }
 105     assert_eq!(x.borrow_state(), BorrowState::Reading);
 106 }
 107
 108 #[test]
 109 #[should_panic]
 110 fn discard_doesnt_unborrow() {
 111     let x = RefCell::new(0);
 112     let _b = x.borrow();
 113     let _ = _b;
 114     let _b = x.borrow_mut();
 115 }
 116
 117 #[test]
 118 fn ref_clone_updates_flag() {
 119     let x = RefCell::new(0);
 120     {
 121         let b1 = x.borrow();
 122         assert_eq!(x.borrow_state(), BorrowState::Reading);
 123         {
 124             let _b2 = Ref::clone(&b1);
 125             assert_eq!(x.borrow_state(), BorrowState::Reading);
 126         }
 127         assert_eq!(x.borrow_state(), BorrowState::Reading);
 128     }
 129     assert_eq!(x.borrow_state(), BorrowState::Unused);
 130 }
 131
 132 #[test]
 133 fn ref_map_does_not_update_flag() {
 134     let x = RefCell::new(Some(5));
 135     {
 136         let b1: Ref<Option<u32>> = x.borrow();
 137         assert_eq!(x.borrow_state(), BorrowState::Reading);
 138         {
 139             let b2: Ref<u32> = Ref::map(b1, |o| o.as_ref().unwrap());
 140             assert_eq!(*b2, 5);
 141             assert_eq!(x.borrow_state(), BorrowState::Reading);
 142         }
 143         assert_eq!(x.borrow_state(), BorrowState::Unused);
 144     }
 145     assert_eq!(x.borrow_state(), BorrowState::Unused);
 146 }
 147
 148 #[test]
 149 fn ref_map_accessor() {
 150     struct X(RefCell<(u32, char)>);
 151     impl X {
 152         fn accessor(&self) -> Ref<u32> {
 153             Ref::map(self.0.borrow(), |tuple| &tuple.0)
 154         }
 155     }
 156     let x = X(RefCell::new((7, 'z')));
 157     let d: Ref<u32> = x.accessor();
 158     assert_eq!(*d, 7);
 159 }
 160
 161 #[test]
 162 fn ref_mut_map_accessor() {
 163     struct X(RefCell<(u32, char)>);
 164     impl X {
 165         fn accessor(&self) -> RefMut<u32> {
 166             RefMut::map(self.0.borrow_mut(), |tuple| &mut tuple.0)
 167         }
 168     }
 169     let x = X(RefCell::new((7, 'z')));
 170     {
 171         let mut d: RefMut<u32> = x.accessor();
 172         assert_eq!(*d, 7);
 173         *d += 1;
 174     }
 175     assert_eq!(*x.0.borrow(), (8, 'z'));
 176 }
 177
 178 #[test]
 179 fn as_unsafe_cell() {
 180     let c1: Cell<usize> = Cell::new(0);
 181     c1.set(1);
 182     assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() });
 183
 184     let c2: Cell<usize> = Cell::new(0);
 185     unsafe { *c2.as_unsafe_cell().get() = 1; }
 186     assert_eq!(1, c2.get());
 187
 188     let r1: RefCell<usize> = RefCell::new(0);
 189     *r1.borrow_mut() = 1;
 190     assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() });
 191
 192     let r2: RefCell<usize> = RefCell::new(0);
 193     unsafe { *r2.as_unsafe_cell().get() = 1; }
 194     assert_eq!(1, *r2.borrow());
 195 }
 196
 197 #[test]
 198 fn cell_default() {
 199     let cell: Cell<u32> = Default::default();
 200     assert_eq!(0, cell.get());
 201 }
 202
 203 #[test]
 204 fn refcell_default() {
 205     let cell: RefCell<u64> = Default::default();
 206     assert_eq!(0, *cell.borrow());
 207 }
 208
 209 #[test]
 210 fn unsafe_cell_unsized() {
 211     let cell: &UnsafeCell<[i32]> = &UnsafeCell::new([1, 2, 3]);
 212     {
 213         let val: &mut [i32] = unsafe { &mut *cell.get() };
 214         val[0] = 4;
 215         val[2] = 5;
 216     }
 217     let comp: &mut [i32] = &mut [4, 2, 5];
 218     assert_eq!(unsafe { &mut *cell.get() }, comp);
 219 }
 220
 221 #[test]
 222 fn refcell_unsized() {
 223     let cell: &RefCell<[i32]> = &RefCell::new([1, 2, 3]);
 224     {
 225         let b = &mut *cell.borrow_mut();
 226         b[0] = 4;
 227         b[2] = 5;
 228     }
 229     let comp: &mut [i32] = &mut [4, 2, 5];
 230     assert_eq!(&*cell.borrow(), comp);
 231 }
 232
 233 #[test]
 234 fn refcell_ref_coercion() {
 235     let cell: RefCell<[i32; 3]> = RefCell::new([1, 2, 3]);
 236     {
 237         let mut cellref: RefMut<[i32; 3]> = cell.borrow_mut();
 238         cellref[0] = 4;
 239         let mut coerced: RefMut<[i32]> = cellref;
 240         coerced[2] = 5;
 241     }
 242     {
 243         let comp: &mut [i32] = &mut [4, 2, 5];
 244         let cellref: Ref<[i32; 3]> = cell.borrow();
 245         assert_eq!(&*cellref, comp);
 246         let coerced: Ref<[i32]> = cellref;
 247         assert_eq!(&*coerced, comp);
 248     }
 249 }
 250
 251