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_filter_map_accessor() {
163 struct X(RefCell<Result<u32, ()>>);
165 fn accessor(&self) -> Option<Ref<u32>> {
166 Ref::filter_map(self.0.borrow(), |r| r.as_ref().ok())
169 let x = X(RefCell::new(Ok(7)));
170 let d: Ref<u32> = x.accessor().unwrap();
175 fn ref_mut_map_accessor() {
176 struct X(RefCell<(u32, char)>);
178 fn accessor(&self) -> RefMut<u32> {
179 RefMut::map(self.0.borrow_mut(), |tuple| &mut tuple.0)
182 let x = X(RefCell::new((7, 'z')));
184 let mut d: RefMut<u32> = x.accessor();
188 assert_eq!(*x.0.borrow(), (8, 'z'));
192 fn ref_mut_filter_map_accessor() {
193 struct X(RefCell<Result<u32, ()>>);
195 fn accessor(&self) -> Option<RefMut<u32>> {
196 RefMut::filter_map(self.0.borrow_mut(), |r| r.as_mut().ok())
199 let x = X(RefCell::new(Ok(7)));
201 let mut d: RefMut<u32> = x.accessor().unwrap();
205 assert_eq!(*x.0.borrow(), Ok(8));
209 fn as_unsafe_cell() {
210 let c1: Cell<usize> = Cell::new(0);
212 assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() });
214 let c2: Cell<usize> = Cell::new(0);
215 unsafe { *c2.as_unsafe_cell().get() = 1; }
216 assert_eq!(1, c2.get());
218 let r1: RefCell<usize> = RefCell::new(0);
219 *r1.borrow_mut() = 1;
220 assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() });
222 let r2: RefCell<usize> = RefCell::new(0);
223 unsafe { *r2.as_unsafe_cell().get() = 1; }
224 assert_eq!(1, *r2.borrow());
229 let cell: Cell<u32> = Default::default();
230 assert_eq!(0, cell.get());
234 fn refcell_default() {
235 let cell: RefCell<u64> = Default::default();
236 assert_eq!(0, *cell.borrow());
240 fn unsafe_cell_unsized() {
241 let cell: &UnsafeCell<[i32]> = &UnsafeCell::new([1, 2, 3]);
243 let val: &mut [i32] = unsafe { &mut *cell.get() };
247 let comp: &mut [i32] = &mut [4, 2, 5];
248 assert_eq!(unsafe { &mut *cell.get() }, comp);
251 // FIXME(#25351) needs deeply nested coercions of DST structs.
253 // fn refcell_unsized() {
254 // let cell: &RefCell<[i32]> = &RefCell::new([1, 2, 3]);
256 // let b = &mut *cell.borrow_mut();
260 // let comp: &mut [i32] = &mut [4, 2, 5];
261 // assert_eq!(&*cell.borrow(), comp);