]>
Commit | Line | Data |
---|---|---|
1a4d82fc JJ |
1 | use core::cell::*; |
2 | use core::default::Default; | |
3 | use std::mem::drop; | |
4 | ||
5 | #[test] | |
6 | fn smoketest_cell() { | |
85aaf69f | 7 | let x = Cell::new(10); |
1a4d82fc JJ |
8 | assert!(x == Cell::new(10)); |
9 | assert!(x.get() == 10); | |
10 | x.set(20); | |
11 | assert!(x == Cell::new(20)); | |
12 | assert!(x.get() == 20); | |
13 | ||
85aaf69f | 14 | let y = Cell::new((30, 40)); |
1a4d82fc JJ |
15 | assert!(y == Cell::new((30, 40))); |
16 | assert!(y.get() == (30, 40)); | |
17 | } | |
18 | ||
83c7162d XL |
19 | #[test] |
20 | fn cell_update() { | |
21 | let x = Cell::new(10); | |
22 | ||
23 | assert_eq!(x.update(|x| x + 5), 15); | |
24 | assert_eq!(x.get(), 15); | |
25 | ||
26 | assert_eq!(x.update(|x| x / 3), 5); | |
27 | assert_eq!(x.get(), 5); | |
28 | } | |
29 | ||
1a4d82fc JJ |
30 | #[test] |
31 | fn cell_has_sensible_show() { | |
32 | let x = Cell::new("foo bar"); | |
33 | assert!(format!("{:?}", x).contains(x.get())); | |
34 | ||
35 | x.set("baz qux"); | |
36 | assert!(format!("{:?}", x).contains(x.get())); | |
37 | } | |
38 | ||
39 | #[test] | |
40 | fn ref_and_refmut_have_sensible_show() { | |
41 | let refcell = RefCell::new("foo"); | |
42 | ||
43 | let refcell_refmut = refcell.borrow_mut(); | |
44 | assert!(format!("{:?}", refcell_refmut).contains("foo")); | |
45 | drop(refcell_refmut); | |
46 | ||
47 | let refcell_ref = refcell.borrow(); | |
48 | assert!(format!("{:?}", refcell_ref).contains("foo")); | |
49 | drop(refcell_ref); | |
50 | } | |
51 | ||
52 | #[test] | |
53 | fn double_imm_borrow() { | |
85aaf69f | 54 | let x = RefCell::new(0); |
1a4d82fc JJ |
55 | let _b1 = x.borrow(); |
56 | x.borrow(); | |
57 | } | |
58 | ||
59 | #[test] | |
60 | fn no_mut_then_imm_borrow() { | |
85aaf69f | 61 | let x = RefCell::new(0); |
1a4d82fc | 62 | let _b1 = x.borrow_mut(); |
476ff2be | 63 | assert!(x.try_borrow().is_err()); |
1a4d82fc JJ |
64 | } |
65 | ||
66 | #[test] | |
67 | fn no_imm_then_borrow_mut() { | |
85aaf69f | 68 | let x = RefCell::new(0); |
1a4d82fc | 69 | let _b1 = x.borrow(); |
476ff2be | 70 | assert!(x.try_borrow_mut().is_err()); |
1a4d82fc JJ |
71 | } |
72 | ||
73 | #[test] | |
74 | fn no_double_borrow_mut() { | |
85aaf69f | 75 | let x = RefCell::new(0); |
476ff2be | 76 | assert!(x.try_borrow().is_ok()); |
1a4d82fc | 77 | let _b1 = x.borrow_mut(); |
476ff2be | 78 | assert!(x.try_borrow().is_err()); |
1a4d82fc JJ |
79 | } |
80 | ||
81 | #[test] | |
82 | fn imm_release_borrow_mut() { | |
85aaf69f | 83 | let x = RefCell::new(0); |
1a4d82fc JJ |
84 | { |
85 | let _b1 = x.borrow(); | |
86 | } | |
87 | x.borrow_mut(); | |
88 | } | |
89 | ||
90 | #[test] | |
91 | fn mut_release_borrow_mut() { | |
85aaf69f | 92 | let x = RefCell::new(0); |
1a4d82fc JJ |
93 | { |
94 | let _b1 = x.borrow_mut(); | |
95 | } | |
96 | x.borrow(); | |
97 | } | |
98 | ||
99 | #[test] | |
100 | fn double_borrow_single_release_no_borrow_mut() { | |
85aaf69f | 101 | let x = RefCell::new(0); |
1a4d82fc JJ |
102 | let _b1 = x.borrow(); |
103 | { | |
104 | let _b2 = x.borrow(); | |
105 | } | |
476ff2be SL |
106 | assert!(x.try_borrow().is_ok()); |
107 | assert!(x.try_borrow_mut().is_err()); | |
1a4d82fc JJ |
108 | } |
109 | ||
110 | #[test] | |
c34b1796 | 111 | #[should_panic] |
9fa01778 | 112 | #[cfg(not(miri))] // Miri does not support panics |
1a4d82fc | 113 | fn discard_doesnt_unborrow() { |
85aaf69f | 114 | let x = RefCell::new(0); |
1a4d82fc JJ |
115 | let _b = x.borrow(); |
116 | let _ = _b; | |
117 | let _b = x.borrow_mut(); | |
118 | } | |
119 | ||
120 | #[test] | |
62682a34 | 121 | fn ref_clone_updates_flag() { |
85aaf69f | 122 | let x = RefCell::new(0); |
1a4d82fc JJ |
123 | { |
124 | let b1 = x.borrow(); | |
476ff2be SL |
125 | assert!(x.try_borrow().is_ok()); |
126 | assert!(x.try_borrow_mut().is_err()); | |
1a4d82fc | 127 | { |
62682a34 | 128 | let _b2 = Ref::clone(&b1); |
476ff2be SL |
129 | assert!(x.try_borrow().is_ok()); |
130 | assert!(x.try_borrow_mut().is_err()); | |
1a4d82fc | 131 | } |
476ff2be SL |
132 | assert!(x.try_borrow().is_ok()); |
133 | assert!(x.try_borrow_mut().is_err()); | |
1a4d82fc | 134 | } |
476ff2be SL |
135 | assert!(x.try_borrow().is_ok()); |
136 | assert!(x.try_borrow_mut().is_ok()); | |
1a4d82fc JJ |
137 | } |
138 | ||
62682a34 SL |
139 | #[test] |
140 | fn ref_map_does_not_update_flag() { | |
141 | let x = RefCell::new(Some(5)); | |
142 | { | |
143 | let b1: Ref<Option<u32>> = x.borrow(); | |
476ff2be SL |
144 | assert!(x.try_borrow().is_ok()); |
145 | assert!(x.try_borrow_mut().is_err()); | |
62682a34 SL |
146 | { |
147 | let b2: Ref<u32> = Ref::map(b1, |o| o.as_ref().unwrap()); | |
148 | assert_eq!(*b2, 5); | |
476ff2be SL |
149 | assert!(x.try_borrow().is_ok()); |
150 | assert!(x.try_borrow_mut().is_err()); | |
62682a34 | 151 | } |
476ff2be SL |
152 | assert!(x.try_borrow().is_ok()); |
153 | assert!(x.try_borrow_mut().is_ok()); | |
62682a34 | 154 | } |
476ff2be SL |
155 | assert!(x.try_borrow().is_ok()); |
156 | assert!(x.try_borrow_mut().is_ok()); | |
62682a34 SL |
157 | } |
158 | ||
94b46f34 XL |
159 | #[test] |
160 | fn ref_map_split_updates_flag() { | |
161 | let x = RefCell::new([1, 2]); | |
162 | { | |
163 | let b1 = x.borrow(); | |
164 | assert!(x.try_borrow().is_ok()); | |
165 | assert!(x.try_borrow_mut().is_err()); | |
166 | { | |
167 | let (_b2, _b3) = Ref::map_split(b1, |slc| slc.split_at(1)); | |
168 | assert!(x.try_borrow().is_ok()); | |
169 | assert!(x.try_borrow_mut().is_err()); | |
170 | } | |
171 | assert!(x.try_borrow().is_ok()); | |
172 | assert!(x.try_borrow_mut().is_ok()); | |
173 | } | |
174 | assert!(x.try_borrow().is_ok()); | |
175 | assert!(x.try_borrow_mut().is_ok()); | |
176 | ||
177 | { | |
178 | let b1 = x.borrow_mut(); | |
179 | assert!(x.try_borrow().is_err()); | |
180 | assert!(x.try_borrow_mut().is_err()); | |
181 | { | |
182 | let (_b2, _b3) = RefMut::map_split(b1, |slc| slc.split_at_mut(1)); | |
183 | assert!(x.try_borrow().is_err()); | |
184 | assert!(x.try_borrow_mut().is_err()); | |
185 | drop(_b2); | |
186 | assert!(x.try_borrow().is_err()); | |
187 | assert!(x.try_borrow_mut().is_err()); | |
188 | } | |
189 | assert!(x.try_borrow().is_ok()); | |
190 | assert!(x.try_borrow_mut().is_ok()); | |
191 | } | |
192 | assert!(x.try_borrow().is_ok()); | |
193 | assert!(x.try_borrow_mut().is_ok()); | |
194 | } | |
195 | ||
196 | #[test] | |
197 | fn ref_map_split() { | |
198 | let x = RefCell::new([1, 2]); | |
199 | let (b1, b2) = Ref::map_split(x.borrow(), |slc| slc.split_at(1)); | |
200 | assert_eq!(*b1, [1]); | |
201 | assert_eq!(*b2, [2]); | |
202 | } | |
203 | ||
204 | #[test] | |
205 | fn ref_mut_map_split() { | |
206 | let x = RefCell::new([1, 2]); | |
207 | { | |
208 | let (mut b1, mut b2) = RefMut::map_split(x.borrow_mut(), |slc| slc.split_at_mut(1)); | |
209 | assert_eq!(*b1, [1]); | |
210 | assert_eq!(*b2, [2]); | |
211 | b1[0] = 2; | |
212 | b2[0] = 1; | |
213 | } | |
214 | assert_eq!(*x.borrow(), [2, 1]); | |
215 | } | |
216 | ||
62682a34 SL |
217 | #[test] |
218 | fn ref_map_accessor() { | |
219 | struct X(RefCell<(u32, char)>); | |
220 | impl X { | |
221 | fn accessor(&self) -> Ref<u32> { | |
222 | Ref::map(self.0.borrow(), |tuple| &tuple.0) | |
223 | } | |
224 | } | |
225 | let x = X(RefCell::new((7, 'z'))); | |
226 | let d: Ref<u32> = x.accessor(); | |
227 | assert_eq!(*d, 7); | |
228 | } | |
229 | ||
62682a34 SL |
230 | #[test] |
231 | fn ref_mut_map_accessor() { | |
232 | struct X(RefCell<(u32, char)>); | |
233 | impl X { | |
234 | fn accessor(&self) -> RefMut<u32> { | |
235 | RefMut::map(self.0.borrow_mut(), |tuple| &mut tuple.0) | |
236 | } | |
237 | } | |
238 | let x = X(RefCell::new((7, 'z'))); | |
239 | { | |
240 | let mut d: RefMut<u32> = x.accessor(); | |
241 | assert_eq!(*d, 7); | |
242 | *d += 1; | |
243 | } | |
244 | assert_eq!(*x.0.borrow(), (8, 'z')); | |
245 | } | |
246 | ||
1a4d82fc | 247 | #[test] |
5bcae85e | 248 | fn as_ptr() { |
c34b1796 | 249 | let c1: Cell<usize> = Cell::new(0); |
85aaf69f | 250 | c1.set(1); |
5bcae85e | 251 | assert_eq!(1, unsafe { *c1.as_ptr() }); |
1a4d82fc | 252 | |
c34b1796 | 253 | let c2: Cell<usize> = Cell::new(0); |
5bcae85e | 254 | unsafe { *c2.as_ptr() = 1; } |
85aaf69f | 255 | assert_eq!(1, c2.get()); |
1a4d82fc | 256 | |
c34b1796 | 257 | let r1: RefCell<usize> = RefCell::new(0); |
85aaf69f | 258 | *r1.borrow_mut() = 1; |
5bcae85e | 259 | assert_eq!(1, unsafe { *r1.as_ptr() }); |
1a4d82fc | 260 | |
c34b1796 | 261 | let r2: RefCell<usize> = RefCell::new(0); |
5bcae85e | 262 | unsafe { *r2.as_ptr() = 1; } |
85aaf69f | 263 | assert_eq!(1, *r2.borrow()); |
1a4d82fc JJ |
264 | } |
265 | ||
266 | #[test] | |
267 | fn cell_default() { | |
268 | let cell: Cell<u32> = Default::default(); | |
269 | assert_eq!(0, cell.get()); | |
270 | } | |
271 | ||
8bb4bdeb XL |
272 | #[test] |
273 | fn cell_set() { | |
274 | let cell = Cell::new(10); | |
275 | cell.set(20); | |
276 | assert_eq!(20, cell.get()); | |
277 | ||
278 | let cell = Cell::new("Hello".to_owned()); | |
279 | cell.set("World".to_owned()); | |
280 | assert_eq!("World".to_owned(), cell.into_inner()); | |
281 | } | |
282 | ||
283 | #[test] | |
284 | fn cell_replace() { | |
285 | let cell = Cell::new(10); | |
286 | assert_eq!(10, cell.replace(20)); | |
287 | assert_eq!(20, cell.get()); | |
288 | ||
289 | let cell = Cell::new("Hello".to_owned()); | |
290 | assert_eq!("Hello".to_owned(), cell.replace("World".to_owned())); | |
291 | assert_eq!("World".to_owned(), cell.into_inner()); | |
292 | } | |
293 | ||
294 | #[test] | |
295 | fn cell_into_inner() { | |
296 | let cell = Cell::new(10); | |
297 | assert_eq!(10, cell.into_inner()); | |
298 | ||
299 | let cell = Cell::new("Hello world".to_owned()); | |
300 | assert_eq!("Hello world".to_owned(), cell.into_inner()); | |
301 | } | |
302 | ||
1a4d82fc JJ |
303 | #[test] |
304 | fn refcell_default() { | |
305 | let cell: RefCell<u64> = Default::default(); | |
306 | assert_eq!(0, *cell.borrow()); | |
307 | } | |
d9579d0f AL |
308 | |
309 | #[test] | |
310 | fn unsafe_cell_unsized() { | |
311 | let cell: &UnsafeCell<[i32]> = &UnsafeCell::new([1, 2, 3]); | |
312 | { | |
313 | let val: &mut [i32] = unsafe { &mut *cell.get() }; | |
314 | val[0] = 4; | |
315 | val[2] = 5; | |
316 | } | |
317 | let comp: &mut [i32] = &mut [4, 2, 5]; | |
318 | assert_eq!(unsafe { &mut *cell.get() }, comp); | |
319 | } | |
320 | ||
b039eaaf SL |
321 | #[test] |
322 | fn refcell_unsized() { | |
323 | let cell: &RefCell<[i32]> = &RefCell::new([1, 2, 3]); | |
324 | { | |
325 | let b = &mut *cell.borrow_mut(); | |
326 | b[0] = 4; | |
327 | b[2] = 5; | |
328 | } | |
329 | let comp: &mut [i32] = &mut [4, 2, 5]; | |
330 | assert_eq!(&*cell.borrow(), comp); | |
331 | } | |
54a0048b SL |
332 | |
333 | #[test] | |
334 | fn refcell_ref_coercion() { | |
335 | let cell: RefCell<[i32; 3]> = RefCell::new([1, 2, 3]); | |
336 | { | |
337 | let mut cellref: RefMut<[i32; 3]> = cell.borrow_mut(); | |
338 | cellref[0] = 4; | |
339 | let mut coerced: RefMut<[i32]> = cellref; | |
340 | coerced[2] = 5; | |
341 | } | |
342 | { | |
343 | let comp: &mut [i32] = &mut [4, 2, 5]; | |
344 | let cellref: Ref<[i32; 3]> = cell.borrow(); | |
345 | assert_eq!(&*cellref, comp); | |
346 | let coerced: Ref<[i32]> = cellref; | |
347 | assert_eq!(&*coerced, comp); | |
348 | } | |
349 | } | |
3b2f2976 XL |
350 | |
351 | #[test] | |
352 | #[should_panic] | |
9fa01778 | 353 | #[cfg(not(miri))] // Miri does not support panics |
3b2f2976 XL |
354 | fn refcell_swap_borrows() { |
355 | let x = RefCell::new(0); | |
356 | let _b = x.borrow(); | |
357 | let y = RefCell::new(1); | |
358 | x.swap(&y); | |
359 | } | |
360 | ||
361 | #[test] | |
362 | #[should_panic] | |
9fa01778 | 363 | #[cfg(not(miri))] // Miri does not support panics |
3b2f2976 XL |
364 | fn refcell_replace_borrows() { |
365 | let x = RefCell::new(0); | |
366 | let _b = x.borrow(); | |
367 | x.replace(1); | |
368 | } |