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.
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.
12 use core::default::Default;
17 let x = Cell::new(10);
18 assert!(x == Cell::new(10));
19 assert!(x.get() == 10);
21 assert!(x == Cell::new(20));
22 assert!(x.get() == 20);
24 let y = Cell::new((30, 40));
25 assert!(y == Cell::new((30, 40)));
26 assert!(y.get() == (30, 40));
30 fn cell_has_sensible_show() {
31 let x = Cell::new("foo bar");
32 assert!(format!("{:?}", x).contains(x.get()));
35 assert!(format!("{:?}", x).contains(x.get()));
39 fn ref_and_refmut_have_sensible_show() {
40 let refcell = RefCell::new("foo");
42 let refcell_refmut = refcell.borrow_mut();
43 assert!(format!("{:?}", refcell_refmut).contains("foo"));
46 let refcell_ref = refcell.borrow();
47 assert!(format!("{:?}", refcell_ref).contains("foo"));
52 fn double_imm_borrow() {
53 let x = RefCell::new(0);
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);
66 fn no_imm_then_borrow_mut() {
67 let x = RefCell::new(0);
69 assert_eq!(x.borrow_state(), BorrowState::Reading);
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);
81 fn imm_release_borrow_mut() {
82 let x = RefCell::new(0);
90 fn mut_release_borrow_mut() {
91 let x = RefCell::new(0);
93 let _b1 = x.borrow_mut();
99 fn double_borrow_single_release_no_borrow_mut() {
100 let x = RefCell::new(0);
101 let _b1 = x.borrow();
103 let _b2 = x.borrow();
105 assert_eq!(x.borrow_state(), BorrowState::Reading);
110 fn discard_doesnt_unborrow() {
111 let x = RefCell::new(0);
114 let _b = x.borrow_mut();
118 fn ref_clone_updates_flag() {
119 let x = RefCell::new(0);
122 assert_eq!(x.borrow_state(), BorrowState::Reading);
124 let _b2 = Ref::clone(&b1);
125 assert_eq!(x.borrow_state(), BorrowState::Reading);
127 assert_eq!(x.borrow_state(), BorrowState::Reading);
129 assert_eq!(x.borrow_state(), BorrowState::Unused);
133 fn ref_map_does_not_update_flag() {
134 let x = RefCell::new(Some(5));
136 let b1: Ref<Option<u32>> = x.borrow();
137 assert_eq!(x.borrow_state(), BorrowState::Reading);
139 let b2: Ref<u32> = Ref::map(b1, |o| o.as_ref().unwrap());
141 assert_eq!(x.borrow_state(), BorrowState::Reading);
143 assert_eq!(x.borrow_state(), BorrowState::Unused);
145 assert_eq!(x.borrow_state(), BorrowState::Unused);
149 fn ref_map_accessor() {
150 struct X(RefCell<(u32, char)>);
152 fn accessor(&self) -> Ref<u32> {
153 Ref::map(self.0.borrow(), |tuple| &tuple.0)
156 let x = X(RefCell::new((7, 'z')));
157 let d: Ref<u32> = x.accessor();
162 fn ref_mut_map_accessor() {
163 struct X(RefCell<(u32, char)>);
165 fn accessor(&self) -> RefMut<u32> {
166 RefMut::map(self.0.borrow_mut(), |tuple| &mut tuple.0)
169 let x = X(RefCell::new((7, 'z')));
171 let mut d: RefMut<u32> = x.accessor();
175 assert_eq!(*x.0.borrow(), (8, 'z'));
179 fn as_unsafe_cell() {
180 let c1: Cell<usize> = Cell::new(0);
182 assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() });
184 let c2: Cell<usize> = Cell::new(0);
185 unsafe { *c2.as_unsafe_cell().get() = 1; }
186 assert_eq!(1, c2.get());
188 let r1: RefCell<usize> = RefCell::new(0);
189 *r1.borrow_mut() = 1;
190 assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() });
192 let r2: RefCell<usize> = RefCell::new(0);
193 unsafe { *r2.as_unsafe_cell().get() = 1; }
194 assert_eq!(1, *r2.borrow());
199 let cell: Cell<u32> = Default::default();
200 assert_eq!(0, cell.get());
204 fn refcell_default() {
205 let cell: RefCell<u64> = Default::default();
206 assert_eq!(0, *cell.borrow());
210 fn unsafe_cell_unsized() {
211 let cell: &UnsafeCell<[i32]> = &UnsafeCell::new([1, 2, 3]);
213 let val: &mut [i32] = unsafe { &mut *cell.get() };
217 let comp: &mut [i32] = &mut [4, 2, 5];
218 assert_eq!(unsafe { &mut *cell.get() }, comp);
222 fn refcell_unsized() {
223 let cell: &RefCell<[i32]> = &RefCell::new([1, 2, 3]);
225 let b = &mut *cell.borrow_mut();
229 let comp: &mut [i32] = &mut [4, 2, 5];
230 assert_eq!(&*cell.borrow(), comp);
234 fn refcell_ref_coercion() {
235 let cell: RefCell<[i32; 3]> = RefCell::new([1, 2, 3]);
237 let mut cellref: RefMut<[i32; 3]> = cell.borrow_mut();
239 let mut coerced: RefMut<[i32]> = cellref;
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);