2 use std::cell::RefCell;
3 use std::cmp::PartialEq;
4 use std::iter::TrustedLen;
6 use std::sync::{Arc, Weak};
11 let mut a = Weak::<Void>::new();
13 assert!(a.upgrade().is_none());
15 let mut a: Weak<dyn Any> = a; // Unsizing
17 assert!(a.upgrade().is_none());
22 let a: Arc<[u32; 3]> = Arc::new([3, 2, 1]);
23 let a: Arc<[u32]> = a; // Unsizing
24 let b: Arc<[u32]> = Arc::from(&[3, 2, 1][..]); // Conversion
27 // Exercise is_dangling() with a DST
28 let mut a = Arc::downgrade(&a);
30 assert!(a.upgrade().is_some());
35 let a: Arc<u32> = Arc::new(4);
36 let a: Arc<dyn Any> = a; // Unsizing
38 // Exercise is_dangling() with a DST
39 let mut a = Arc::downgrade(&a);
41 assert!(a.upgrade().is_some());
43 let mut b = Weak::<u32>::new();
45 assert!(b.upgrade().is_none());
46 let mut b: Weak<dyn Any> = b; // Unsizing
48 assert!(b.upgrade().is_none());
53 let x = Arc::new(f32::NAN);
60 struct TestPEq(RefCell<usize>);
61 impl PartialEq for TestPEq {
62 fn eq(&self, other: &TestPEq) -> bool {
63 *self.0.borrow_mut() += 1;
64 *other.0.borrow_mut() += 1;
68 let x = Arc::new(TestPEq(RefCell::new(0)));
71 assert_eq!(*x.0.borrow(), 4);
77 struct TestEq(RefCell<usize>);
78 impl PartialEq for TestEq {
79 fn eq(&self, other: &TestEq) -> bool {
80 *self.0.borrow_mut() += 1;
81 *other.0.borrow_mut() += 1;
85 let x = Arc::new(TestEq(RefCell::new(0)));
88 assert_eq!(*x.0.borrow(), 0);
91 // The test code below is identical to that in `rc.rs`.
92 // For better maintainability we therefore define this type alias.
95 const SHARED_ITER_MAX: u16 = 100;
97 fn assert_trusted_len<I: TrustedLen>(_: &I) {}
100 fn shared_from_iter_normal() {
101 // Exercise the base implementation for non-`TrustedLen` iterators.
103 // `Filter` is never `TrustedLen` since we don't
104 // know statically how many elements will be kept:
105 let iter = (0..SHARED_ITER_MAX).filter(|x| x % 2 == 0).map(Box::new);
107 // Collecting into a `Vec<T>` or `Rc<[T]>` should make no difference:
108 let vec = iter.clone().collect::<Vec<_>>();
109 let rc = iter.collect::<Rc<[_]>>();
110 assert_eq!(&*vec, &*rc);
112 // Clone a bit and let these get dropped.
114 let _rc_2 = rc.clone();
115 let _rc_3 = rc.clone();
116 let _rc_4 = Rc::downgrade(&_rc_3);
118 } // Drop what hasn't been here.
122 fn shared_from_iter_trustedlen_normal() {
123 // Exercise the `TrustedLen` implementation under normal circumstances
124 // where `size_hint()` matches `(_, Some(exact_len))`.
126 let iter = (0..SHARED_ITER_MAX).map(Box::new);
127 assert_trusted_len(&iter);
129 // Collecting into a `Vec<T>` or `Rc<[T]>` should make no difference:
130 let vec = iter.clone().collect::<Vec<_>>();
131 let rc = iter.collect::<Rc<[_]>>();
132 assert_eq!(&*vec, &*rc);
133 assert_eq!(mem::size_of::<Box<u16>>() * SHARED_ITER_MAX as usize, mem::size_of_val(&*rc));
135 // Clone a bit and let these get dropped.
137 let _rc_2 = rc.clone();
138 let _rc_3 = rc.clone();
139 let _rc_4 = Rc::downgrade(&_rc_3);
141 } // Drop what hasn't been here.
143 // Try a ZST to make sure it is handled well.
145 let iter = (0..SHARED_ITER_MAX).map(drop);
146 let vec = iter.clone().collect::<Vec<_>>();
147 let rc = iter.collect::<Rc<[_]>>();
148 assert_eq!(&*vec, &*rc);
149 assert_eq!(0, mem::size_of_val(&*rc));
151 let _rc_2 = rc.clone();
152 let _rc_3 = rc.clone();
153 let _rc_4 = Rc::downgrade(&_rc_3);
159 #[should_panic = "I've almost got 99 problems."]
160 fn shared_from_iter_trustedlen_panic() {
161 // Exercise the `TrustedLen` implementation when `size_hint()` matches
162 // `(_, Some(exact_len))` but where `.next()` drops before the last iteration.
163 let iter = (0..SHARED_ITER_MAX).map(|val| match val {
164 98 => panic!("I've almost got 99 problems."),
167 assert_trusted_len(&iter);
168 let _ = iter.collect::<Rc<[_]>>();
170 panic!("I am unreachable.");
174 fn shared_from_iter_trustedlen_no_fuse() {
175 // Exercise the `TrustedLen` implementation when `size_hint()` matches
176 // `(_, Some(exact_len))` but where the iterator does not behave in a fused manner.
177 struct Iter(std::vec::IntoIter<Option<Box<u8>>>);
179 unsafe impl TrustedLen for Iter {}
181 impl Iterator for Iter {
182 fn size_hint(&self) -> (usize, Option<usize>) {
188 fn next(&mut self) -> Option<Self::Item> {
189 self.0.next().flatten()
193 let vec = vec![Some(Box::new(42)), Some(Box::new(24)), None, Some(Box::new(12))];
194 let iter = Iter(vec.into_iter());
195 assert_trusted_len(&iter);
196 assert_eq!(&[Box::new(42), Box::new(24)], &*iter.collect::<Rc<[_]>>());
200 fn weak_may_dangle() {
201 fn hmm<'a>(val: &'a mut Weak<&'a str>) -> Weak<&'a str> {
205 // Without #[may_dangle] we get:
206 let mut val = Weak::new();
208 // ~~~~~~~~ borrowed value does not live long enough
210 // `val` dropped here while still borrowed
211 // borrow might be used here, when `val` is dropped and runs the `Drop` code for type `std::sync::Weak`