]>
Commit | Line | Data |
---|---|---|
1a4d82fc JJ |
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() { | |
85aaf69f | 17 | let x = Cell::new(10); |
1a4d82fc JJ |
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 | ||
85aaf69f | 24 | let y = Cell::new((30, 40)); |
1a4d82fc JJ |
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() { | |
85aaf69f | 53 | let x = RefCell::new(0); |
1a4d82fc JJ |
54 | let _b1 = x.borrow(); |
55 | x.borrow(); | |
56 | } | |
57 | ||
58 | #[test] | |
59 | fn no_mut_then_imm_borrow() { | |
85aaf69f | 60 | let x = RefCell::new(0); |
1a4d82fc | 61 | let _b1 = x.borrow_mut(); |
85aaf69f | 62 | assert_eq!(x.borrow_state(), BorrowState::Writing); |
1a4d82fc JJ |
63 | } |
64 | ||
65 | #[test] | |
66 | fn no_imm_then_borrow_mut() { | |
85aaf69f | 67 | let x = RefCell::new(0); |
1a4d82fc | 68 | let _b1 = x.borrow(); |
85aaf69f | 69 | assert_eq!(x.borrow_state(), BorrowState::Reading); |
1a4d82fc JJ |
70 | } |
71 | ||
72 | #[test] | |
73 | fn no_double_borrow_mut() { | |
85aaf69f SL |
74 | let x = RefCell::new(0); |
75 | assert_eq!(x.borrow_state(), BorrowState::Unused); | |
1a4d82fc | 76 | let _b1 = x.borrow_mut(); |
85aaf69f | 77 | assert_eq!(x.borrow_state(), BorrowState::Writing); |
1a4d82fc JJ |
78 | } |
79 | ||
80 | #[test] | |
81 | fn imm_release_borrow_mut() { | |
85aaf69f | 82 | let x = RefCell::new(0); |
1a4d82fc JJ |
83 | { |
84 | let _b1 = x.borrow(); | |
85 | } | |
86 | x.borrow_mut(); | |
87 | } | |
88 | ||
89 | #[test] | |
90 | fn mut_release_borrow_mut() { | |
85aaf69f | 91 | let x = RefCell::new(0); |
1a4d82fc JJ |
92 | { |
93 | let _b1 = x.borrow_mut(); | |
94 | } | |
95 | x.borrow(); | |
96 | } | |
97 | ||
98 | #[test] | |
99 | fn double_borrow_single_release_no_borrow_mut() { | |
85aaf69f | 100 | let x = RefCell::new(0); |
1a4d82fc JJ |
101 | let _b1 = x.borrow(); |
102 | { | |
103 | let _b2 = x.borrow(); | |
104 | } | |
c34b1796 | 105 | assert_eq!(x.borrow_state(), BorrowState::Reading); |
1a4d82fc JJ |
106 | } |
107 | ||
108 | #[test] | |
c34b1796 | 109 | #[should_panic] |
1a4d82fc | 110 | fn discard_doesnt_unborrow() { |
85aaf69f | 111 | let x = RefCell::new(0); |
1a4d82fc JJ |
112 | let _b = x.borrow(); |
113 | let _ = _b; | |
114 | let _b = x.borrow_mut(); | |
115 | } | |
116 | ||
117 | #[test] | |
1a4d82fc | 118 | fn clone_ref_updates_flag() { |
85aaf69f | 119 | let x = RefCell::new(0); |
1a4d82fc JJ |
120 | { |
121 | let b1 = x.borrow(); | |
c34b1796 | 122 | assert_eq!(x.borrow_state(), BorrowState::Reading); |
1a4d82fc JJ |
123 | { |
124 | let _b2 = clone_ref(&b1); | |
c34b1796 | 125 | assert_eq!(x.borrow_state(), BorrowState::Reading); |
1a4d82fc | 126 | } |
c34b1796 | 127 | assert_eq!(x.borrow_state(), BorrowState::Reading); |
1a4d82fc | 128 | } |
c34b1796 | 129 | assert_eq!(x.borrow_state(), BorrowState::Unused); |
1a4d82fc JJ |
130 | } |
131 | ||
132 | #[test] | |
133 | fn as_unsafe_cell() { | |
c34b1796 | 134 | let c1: Cell<usize> = Cell::new(0); |
85aaf69f SL |
135 | c1.set(1); |
136 | assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() }); | |
1a4d82fc | 137 | |
c34b1796 | 138 | let c2: Cell<usize> = Cell::new(0); |
85aaf69f SL |
139 | unsafe { *c2.as_unsafe_cell().get() = 1; } |
140 | assert_eq!(1, c2.get()); | |
1a4d82fc | 141 | |
c34b1796 | 142 | let r1: RefCell<usize> = RefCell::new(0); |
85aaf69f SL |
143 | *r1.borrow_mut() = 1; |
144 | assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() }); | |
1a4d82fc | 145 | |
c34b1796 | 146 | let r2: RefCell<usize> = RefCell::new(0); |
85aaf69f SL |
147 | unsafe { *r2.as_unsafe_cell().get() = 1; } |
148 | assert_eq!(1, *r2.borrow()); | |
1a4d82fc JJ |
149 | } |
150 | ||
151 | #[test] | |
152 | fn cell_default() { | |
153 | let cell: Cell<u32> = Default::default(); | |
154 | assert_eq!(0, cell.get()); | |
155 | } | |
156 | ||
157 | #[test] | |
158 | fn refcell_default() { | |
159 | let cell: RefCell<u64> = Default::default(); | |
160 | assert_eq!(0, *cell.borrow()); | |
161 | } | |
d9579d0f AL |
162 | |
163 | #[test] | |
164 | fn unsafe_cell_unsized() { | |
165 | let cell: &UnsafeCell<[i32]> = &UnsafeCell::new([1, 2, 3]); | |
166 | { | |
167 | let val: &mut [i32] = unsafe { &mut *cell.get() }; | |
168 | val[0] = 4; | |
169 | val[2] = 5; | |
170 | } | |
171 | let comp: &mut [i32] = &mut [4, 2, 5]; | |
172 | assert_eq!(unsafe { &mut *cell.get() }, comp); | |
173 | } | |
174 | ||
175 | // FIXME(#25351) needs deeply nested coercions of DST structs. | |
176 | // #[test] | |
177 | // fn refcell_unsized() { | |
178 | // let cell: &RefCell<[i32]> = &RefCell::new([1, 2, 3]); | |
179 | // { | |
180 | // let b = &mut *cell.borrow_mut(); | |
181 | // b[0] = 4; | |
182 | // b[2] = 5; | |
183 | // } | |
184 | // let comp: &mut [i32] = &mut [4, 2, 5]; | |
185 | // assert_eq!(&*cell.borrow(), comp); | |
186 | // } |