]>
Commit | Line | Data |
---|---|---|
8faf50e0 | 1 | use std::any::Any; |
0731742a XL |
2 | use std::cell::RefCell; |
3 | use std::cmp::PartialEq; | |
416331ca | 4 | use std::iter::TrustedLen; |
60c5eb7d XL |
5 | use std::mem; |
6 | use std::rc::{Rc, Weak}; | |
8faf50e0 XL |
7 | |
8 | #[test] | |
9 | fn uninhabited() { | |
10 | enum Void {} | |
11 | let mut a = Weak::<Void>::new(); | |
12 | a = a.clone(); | |
13 | assert!(a.upgrade().is_none()); | |
14 | ||
60c5eb7d | 15 | let mut a: Weak<dyn Any> = a; // Unsizing |
8faf50e0 XL |
16 | a = a.clone(); |
17 | assert!(a.upgrade().is_none()); | |
18 | } | |
19 | ||
20 | #[test] | |
21 | fn slice() { | |
22 | let a: Rc<[u32; 3]> = Rc::new([3, 2, 1]); | |
60c5eb7d XL |
23 | let a: Rc<[u32]> = a; // Unsizing |
24 | let b: Rc<[u32]> = Rc::from(&[3, 2, 1][..]); // Conversion | |
8faf50e0 XL |
25 | assert_eq!(a, b); |
26 | ||
27 | // Exercise is_dangling() with a DST | |
28 | let mut a = Rc::downgrade(&a); | |
29 | a = a.clone(); | |
30 | assert!(a.upgrade().is_some()); | |
31 | } | |
32 | ||
33 | #[test] | |
34 | fn trait_object() { | |
35 | let a: Rc<u32> = Rc::new(4); | |
60c5eb7d | 36 | let a: Rc<dyn Any> = a; // Unsizing |
8faf50e0 XL |
37 | |
38 | // Exercise is_dangling() with a DST | |
39 | let mut a = Rc::downgrade(&a); | |
40 | a = a.clone(); | |
41 | assert!(a.upgrade().is_some()); | |
42 | ||
43 | let mut b = Weak::<u32>::new(); | |
44 | b = b.clone(); | |
45 | assert!(b.upgrade().is_none()); | |
60c5eb7d | 46 | let mut b: Weak<dyn Any> = b; // Unsizing |
8faf50e0 XL |
47 | b = b.clone(); |
48 | assert!(b.upgrade().is_none()); | |
49 | } | |
0731742a XL |
50 | |
51 | #[test] | |
52 | fn float_nan_ne() { | |
ba9703b0 | 53 | let x = Rc::new(f32::NAN); |
0731742a XL |
54 | assert!(x != x); |
55 | assert!(!(x == x)); | |
56 | } | |
57 | ||
58 | #[test] | |
59 | fn partial_eq() { | |
60c5eb7d | 60 | struct TestPEq(RefCell<usize>); |
0731742a XL |
61 | impl PartialEq for TestPEq { |
62 | fn eq(&self, other: &TestPEq) -> bool { | |
63 | *self.0.borrow_mut() += 1; | |
64 | *other.0.borrow_mut() += 1; | |
65 | true | |
66 | } | |
67 | } | |
68 | let x = Rc::new(TestPEq(RefCell::new(0))); | |
69 | assert!(x == x); | |
70 | assert!(!(x != x)); | |
71 | assert_eq!(*x.0.borrow(), 4); | |
72 | } | |
73 | ||
74 | #[test] | |
75 | fn eq() { | |
76 | #[derive(Eq)] | |
60c5eb7d | 77 | struct TestEq(RefCell<usize>); |
0731742a XL |
78 | impl PartialEq for TestEq { |
79 | fn eq(&self, other: &TestEq) -> bool { | |
80 | *self.0.borrow_mut() += 1; | |
81 | *other.0.borrow_mut() += 1; | |
82 | true | |
83 | } | |
84 | } | |
85 | let x = Rc::new(TestEq(RefCell::new(0))); | |
86 | assert!(x == x); | |
87 | assert!(!(x != x)); | |
88 | assert_eq!(*x.0.borrow(), 0); | |
89 | } | |
416331ca XL |
90 | |
91 | const SHARED_ITER_MAX: u16 = 100; | |
92 | ||
93 | fn assert_trusted_len<I: TrustedLen>(_: &I) {} | |
94 | ||
95 | #[test] | |
96 | fn shared_from_iter_normal() { | |
97 | // Exercise the base implementation for non-`TrustedLen` iterators. | |
98 | { | |
99 | // `Filter` is never `TrustedLen` since we don't | |
100 | // know statically how many elements will be kept: | |
101 | let iter = (0..SHARED_ITER_MAX).filter(|x| x % 2 == 0).map(Box::new); | |
102 | ||
103 | // Collecting into a `Vec<T>` or `Rc<[T]>` should make no difference: | |
104 | let vec = iter.clone().collect::<Vec<_>>(); | |
105 | let rc = iter.collect::<Rc<[_]>>(); | |
106 | assert_eq!(&*vec, &*rc); | |
107 | ||
108 | // Clone a bit and let these get dropped. | |
109 | { | |
110 | let _rc_2 = rc.clone(); | |
111 | let _rc_3 = rc.clone(); | |
112 | let _rc_4 = Rc::downgrade(&_rc_3); | |
113 | } | |
114 | } // Drop what hasn't been here. | |
115 | } | |
116 | ||
117 | #[test] | |
118 | fn shared_from_iter_trustedlen_normal() { | |
119 | // Exercise the `TrustedLen` implementation under normal circumstances | |
120 | // where `size_hint()` matches `(_, Some(exact_len))`. | |
121 | { | |
122 | let iter = (0..SHARED_ITER_MAX).map(Box::new); | |
123 | assert_trusted_len(&iter); | |
124 | ||
125 | // Collecting into a `Vec<T>` or `Rc<[T]>` should make no difference: | |
126 | let vec = iter.clone().collect::<Vec<_>>(); | |
127 | let rc = iter.collect::<Rc<[_]>>(); | |
128 | assert_eq!(&*vec, &*rc); | |
129 | assert_eq!(mem::size_of::<Box<u16>>() * SHARED_ITER_MAX as usize, mem::size_of_val(&*rc)); | |
130 | ||
131 | // Clone a bit and let these get dropped. | |
132 | { | |
133 | let _rc_2 = rc.clone(); | |
134 | let _rc_3 = rc.clone(); | |
135 | let _rc_4 = Rc::downgrade(&_rc_3); | |
136 | } | |
137 | } // Drop what hasn't been here. | |
138 | ||
139 | // Try a ZST to make sure it is handled well. | |
140 | { | |
dfeec247 | 141 | let iter = (0..SHARED_ITER_MAX).map(drop); |
416331ca XL |
142 | let vec = iter.clone().collect::<Vec<_>>(); |
143 | let rc = iter.collect::<Rc<[_]>>(); | |
144 | assert_eq!(&*vec, &*rc); | |
145 | assert_eq!(0, mem::size_of_val(&*rc)); | |
146 | { | |
147 | let _rc_2 = rc.clone(); | |
148 | let _rc_3 = rc.clone(); | |
149 | let _rc_4 = Rc::downgrade(&_rc_3); | |
150 | } | |
151 | } | |
152 | } | |
153 | ||
154 | #[test] | |
155 | #[should_panic = "I've almost got 99 problems."] | |
156 | fn shared_from_iter_trustedlen_panic() { | |
157 | // Exercise the `TrustedLen` implementation when `size_hint()` matches | |
158 | // `(_, Some(exact_len))` but where `.next()` drops before the last iteration. | |
60c5eb7d XL |
159 | let iter = (0..SHARED_ITER_MAX).map(|val| match val { |
160 | 98 => panic!("I've almost got 99 problems."), | |
161 | _ => Box::new(val), | |
162 | }); | |
416331ca XL |
163 | assert_trusted_len(&iter); |
164 | let _ = iter.collect::<Rc<[_]>>(); | |
165 | ||
166 | panic!("I am unreachable."); | |
167 | } | |
168 | ||
169 | #[test] | |
170 | fn shared_from_iter_trustedlen_no_fuse() { | |
171 | // Exercise the `TrustedLen` implementation when `size_hint()` matches | |
172 | // `(_, Some(exact_len))` but where the iterator does not behave in a fused manner. | |
173 | struct Iter(std::vec::IntoIter<Option<Box<u8>>>); | |
174 | ||
175 | unsafe impl TrustedLen for Iter {} | |
176 | ||
177 | impl Iterator for Iter { | |
178 | fn size_hint(&self) -> (usize, Option<usize>) { | |
179 | (2, Some(2)) | |
180 | } | |
181 | ||
182 | type Item = Box<u8>; | |
183 | ||
184 | fn next(&mut self) -> Option<Self::Item> { | |
185 | self.0.next().flatten() | |
186 | } | |
187 | } | |
188 | ||
60c5eb7d | 189 | let vec = vec![Some(Box::new(42)), Some(Box::new(24)), None, Some(Box::new(12))]; |
416331ca XL |
190 | let iter = Iter(vec.into_iter()); |
191 | assert_trusted_len(&iter); | |
60c5eb7d | 192 | assert_eq!(&[Box::new(42), Box::new(24)], &*iter.collect::<Rc<[_]>>()); |
416331ca | 193 | } |