]>
git.proxmox.com Git - rustc.git/blob - src/libcore/tests/cell.rs
2 use core
::default::Default
;
8 assert_eq
!(x
, Cell
::new(10));
9 assert_eq
!(x
.get(), 10);
11 assert_eq
!(x
, Cell
::new(20));
12 assert_eq
!(x
.get(), 20);
14 let y
= Cell
::new((30, 40));
15 assert_eq
!(y
, Cell
::new((30, 40)));
16 assert_eq
!(y
.get(), (30, 40));
21 let x
= Cell
::new(10);
23 assert_eq
!(x
.update(|x
| x
+ 5), 15);
24 assert_eq
!(x
.get(), 15);
26 assert_eq
!(x
.update(|x
| x
/ 3), 5);
27 assert_eq
!(x
.get(), 5);
31 fn cell_has_sensible_show() {
32 let x
= Cell
::new("foo bar");
33 assert
!(format
!("{:?}", x
).contains(x
.get()));
36 assert
!(format
!("{:?}", x
).contains(x
.get()));
40 fn ref_and_refmut_have_sensible_show() {
41 let refcell
= RefCell
::new("foo");
43 let refcell_refmut
= refcell
.borrow_mut();
44 assert
!(format
!("{:?}", refcell_refmut
).contains("foo"));
47 let refcell_ref
= refcell
.borrow();
48 assert
!(format
!("{:?}", refcell_ref
).contains("foo"));
53 fn double_imm_borrow() {
54 let x
= RefCell
::new(0);
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());
67 fn no_imm_then_borrow_mut() {
68 let x
= RefCell
::new(0);
70 assert
!(x
.try_borrow_mut().is_err());
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());
82 fn imm_release_borrow_mut() {
83 let x
= RefCell
::new(0);
91 fn mut_release_borrow_mut() {
92 let x
= RefCell
::new(0);
94 let _b1
= x
.borrow_mut();
100 fn double_borrow_single_release_no_borrow_mut() {
101 let x
= RefCell
::new(0);
102 let _b1
= x
.borrow();
104 let _b2
= x
.borrow();
106 assert
!(x
.try_borrow().is_ok());
107 assert
!(x
.try_borrow_mut().is_err());
112 fn discard_doesnt_unborrow() {
113 let x
= RefCell
::new(0);
116 let _b
= x
.borrow_mut();
120 fn ref_clone_updates_flag() {
121 let x
= RefCell
::new(0);
124 assert
!(x
.try_borrow().is_ok());
125 assert
!(x
.try_borrow_mut().is_err());
127 let _b2
= Ref
::clone(&b1
);
128 assert
!(x
.try_borrow().is_ok());
129 assert
!(x
.try_borrow_mut().is_err());
131 assert
!(x
.try_borrow().is_ok());
132 assert
!(x
.try_borrow_mut().is_err());
134 assert
!(x
.try_borrow().is_ok());
135 assert
!(x
.try_borrow_mut().is_ok());
139 fn ref_map_does_not_update_flag() {
140 let x
= RefCell
::new(Some(5));
142 let b1
: Ref
<'_
, Option
<u32>> = x
.borrow();
143 assert
!(x
.try_borrow().is_ok());
144 assert
!(x
.try_borrow_mut().is_err());
146 let b2
: Ref
<'_
, u32> = Ref
::map(b1
, |o
| o
.as_ref().unwrap());
148 assert
!(x
.try_borrow().is_ok());
149 assert
!(x
.try_borrow_mut().is_err());
151 assert
!(x
.try_borrow().is_ok());
152 assert
!(x
.try_borrow_mut().is_ok());
154 assert
!(x
.try_borrow().is_ok());
155 assert
!(x
.try_borrow_mut().is_ok());
159 fn ref_map_split_updates_flag() {
160 let x
= RefCell
::new([1, 2]);
163 assert
!(x
.try_borrow().is_ok());
164 assert
!(x
.try_borrow_mut().is_err());
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());
170 assert
!(x
.try_borrow().is_ok());
171 assert
!(x
.try_borrow_mut().is_ok());
173 assert
!(x
.try_borrow().is_ok());
174 assert
!(x
.try_borrow_mut().is_ok());
177 let b1
= x
.borrow_mut();
178 assert
!(x
.try_borrow().is_err());
179 assert
!(x
.try_borrow_mut().is_err());
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());
185 assert
!(x
.try_borrow().is_err());
186 assert
!(x
.try_borrow_mut().is_err());
188 assert
!(x
.try_borrow().is_ok());
189 assert
!(x
.try_borrow_mut().is_ok());
191 assert
!(x
.try_borrow().is_ok());
192 assert
!(x
.try_borrow_mut().is_ok());
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]);
204 fn ref_mut_map_split() {
205 let x
= RefCell
::new([1, 2]);
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]);
213 assert_eq
!(*x
.borrow(), [2, 1]);
217 fn ref_map_accessor() {
218 struct X(RefCell
<(u32, char)>);
220 fn accessor(&self) -> Ref
<'_
, u32> {
221 Ref
::map(self.0.borrow(), |tuple
| &tuple
.0)
224 let x
= X(RefCell
::new((7, 'z'
)));
225 let d
: Ref
<'_
, u32> = x
.accessor();
230 fn ref_mut_map_accessor() {
231 struct X(RefCell
<(u32, char)>);
233 fn accessor(&self) -> RefMut
<'_
, u32> {
234 RefMut
::map(self.0.borrow_mut(), |tuple
| &mut tuple
.0)
237 let x
= X(RefCell
::new((7, 'z'
)));
239 let mut d
: RefMut
<'_
, u32> = x
.accessor();
243 assert_eq
!(*x
.0.borrow(), (8, 'z'
));
248 let c1
: Cell
<usize> = Cell
::new(0);
250 assert_eq
!(1, unsafe { *c1.as_ptr() }
);
252 let c2
: Cell
<usize> = Cell
::new(0);
256 assert_eq
!(1, c2
.get());
258 let r1
: RefCell
<usize> = RefCell
::new(0);
259 *r1
.borrow_mut() = 1;
260 assert_eq
!(1, unsafe { *r1.as_ptr() }
);
262 let r2
: RefCell
<usize> = RefCell
::new(0);
266 assert_eq
!(1, *r2
.borrow());
271 let cell
: Cell
<u32> = Default
::default();
272 assert_eq
!(0, cell
.get());
277 let cell
= Cell
::new(10);
279 assert_eq
!(20, cell
.get());
281 let cell
= Cell
::new("Hello".to_owned());
282 cell
.set("World".to_owned());
283 assert_eq
!("World".to_owned(), cell
.into_inner());
288 let cell
= Cell
::new(10);
289 assert_eq
!(10, cell
.replace(20));
290 assert_eq
!(20, cell
.get());
292 let cell
= Cell
::new("Hello".to_owned());
293 assert_eq
!("Hello".to_owned(), cell
.replace("World".to_owned()));
294 assert_eq
!("World".to_owned(), cell
.into_inner());
298 fn cell_into_inner() {
299 let cell
= Cell
::new(10);
300 assert_eq
!(10, cell
.into_inner());
302 let cell
= Cell
::new("Hello world".to_owned());
303 assert_eq
!("Hello world".to_owned(), cell
.into_inner());
307 fn refcell_default() {
308 let cell
: RefCell
<u64> = Default
::default();
309 assert_eq
!(0, *cell
.borrow());
313 fn unsafe_cell_unsized() {
314 let cell
: &UnsafeCell
<[i32]> = &UnsafeCell
::new([1, 2, 3]);
316 let val
: &mut [i32] = unsafe { &mut *cell.get() }
;
320 let comp
: &mut [i32] = &mut [4, 2, 5];
321 assert_eq
!(unsafe { &mut *cell.get() }
, comp
);
325 fn refcell_unsized() {
326 let cell
: &RefCell
<[i32]> = &RefCell
::new([1, 2, 3]);
328 let b
= &mut *cell
.borrow_mut();
332 let comp
: &mut [i32] = &mut [4, 2, 5];
333 assert_eq
!(&*cell
.borrow(), comp
);
337 fn refcell_ref_coercion() {
338 let cell
: RefCell
<[i32; 3]> = RefCell
::new([1, 2, 3]);
340 let mut cellref
: RefMut
<'_
, [i32; 3]> = cell
.borrow_mut();
342 let mut coerced
: RefMut
<'_
, [i32]> = cellref
;
346 let comp
: &mut [i32] = &mut [4, 2, 5];
347 let cellref
: Ref
<'_
, [i32; 3]> = cell
.borrow();
348 assert_eq
!(&*cellref
, comp
);
349 let coerced
: Ref
<'_
, [i32]> = cellref
;
350 assert_eq
!(&*coerced
, comp
);
356 fn refcell_swap_borrows() {
357 let x
= RefCell
::new(0);
359 let y
= RefCell
::new(1);
365 fn refcell_replace_borrows() {
366 let x
= RefCell
::new(0);