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_filter_map_accessor() {
 163     struct X(RefCell<Result<u32, ()>>);
 164     impl X {
 165         fn accessor(&self) -> Option<Ref<u32>> {
 166             Ref::filter_map(self.0.borrow(), |r| r.as_ref().ok())
 167         }
 168     }
 169     let x = X(RefCell::new(Ok(7)));
 170     let d: Ref<u32> = x.accessor().unwrap();
 171     assert_eq!(*d, 7);
 172 }
 173
 174 #[test]
 175 fn ref_mut_map_accessor() {
 176     struct X(RefCell<(u32, char)>);
 177     impl X {
 178         fn accessor(&self) -> RefMut<u32> {
 179             RefMut::map(self.0.borrow_mut(), |tuple| &mut tuple.0)
 180         }
 181     }
 182     let x = X(RefCell::new((7, 'z')));
 183     {
 184         let mut d: RefMut<u32> = x.accessor();
 185         assert_eq!(*d, 7);
 186         *d += 1;
 187     }
 188     assert_eq!(*x.0.borrow(), (8, 'z'));
 189 }
 190
 191 #[test]
 192 fn ref_mut_filter_map_accessor() {
 193     struct X(RefCell<Result<u32, ()>>);
 194     impl X {
 195         fn accessor(&self) -> Option<RefMut<u32>> {
 196             RefMut::filter_map(self.0.borrow_mut(), |r| r.as_mut().ok())
 197         }
 198     }
 199     let x = X(RefCell::new(Ok(7)));
 200     {
 201         let mut d: RefMut<u32> = x.accessor().unwrap();
 202         assert_eq!(*d, 7);
 203         *d += 1;
 204     }
 205     assert_eq!(*x.0.borrow(), Ok(8));
 206 }
 207
 208 #[test]
 209 fn as_unsafe_cell() {
 210     let c1: Cell<usize> = Cell::new(0);
 211     c1.set(1);
 212     assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() });
 213
 214     let c2: Cell<usize> = Cell::new(0);
 215     unsafe { *c2.as_unsafe_cell().get() = 1; }
 216     assert_eq!(1, c2.get());
 217
 218     let r1: RefCell<usize> = RefCell::new(0);
 219     *r1.borrow_mut() = 1;
 220     assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() });
 221
 222     let r2: RefCell<usize> = RefCell::new(0);
 223     unsafe { *r2.as_unsafe_cell().get() = 1; }
 224     assert_eq!(1, *r2.borrow());
 225 }
 226
 227 #[test]
 228 fn cell_default() {
 229     let cell: Cell<u32> = Default::default();
 230     assert_eq!(0, cell.get());
 231 }
 232
 233 #[test]
 234 fn refcell_default() {
 235     let cell: RefCell<u64> = Default::default();
 236     assert_eq!(0, *cell.borrow());
 237 }
 238
 239 #[test]
 240 fn unsafe_cell_unsized() {
 241     let cell: &UnsafeCell<[i32]> = &UnsafeCell::new([1, 2, 3]);
 242     {
 243         let val: &mut [i32] = unsafe { &mut *cell.get() };
 244         val[0] = 4;
 245         val[2] = 5;
 246     }
 247     let comp: &mut [i32] = &mut [4, 2, 5];
 248     assert_eq!(unsafe { &mut *cell.get() }, comp);
 249 }
 250
 251 // FIXME(#25351) needs deeply nested coercions of DST structs.
 252 // #[test]
 253 // fn refcell_unsized() {
 254 //     let cell: &RefCell<[i32]> = &RefCell::new([1, 2, 3]);
 255 //     {
 256 //         let b = &mut *cell.borrow_mut();
 257 //         b[0] = 4;
 258 //         b[2] = 5;
 259 //     }
 260 //     let comp: &mut [i32] = &mut [4, 2, 5];
 261 //     assert_eq!(&*cell.borrow(), comp);
 262 // }