]>
git.proxmox.com Git - rustc.git/blob - src/liballoc/tests/rc.rs
2 use std
::cell
::RefCell
;
3 use std
::cmp
::PartialEq
;
4 use std
::iter
::TrustedLen
;
6 use std
::rc
::{Rc, 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
: Rc
<[u32; 3]> = Rc
::new([3, 2, 1]);
23 let a
: Rc
<[u32]> = a
; // Unsizing
24 let b
: Rc
<[u32]> = Rc
::from(&[3, 2, 1][..]); // Conversion
27 // Exercise is_dangling() with a DST
28 let mut a
= Rc
::downgrade(&a
);
30 assert
!(a
.upgrade().is_some());
35 let a
: Rc
<u32> = Rc
::new(4);
36 let a
: Rc
<dyn Any
> = a
; // Unsizing
38 // Exercise is_dangling() with a DST
39 let mut a
= Rc
::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
= Rc
::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
= Rc
::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
= Rc
::new(TestEq(RefCell
::new(0)));
88 assert_eq
!(*x
.0.borrow(), 0);
91 const SHARED_ITER_MAX
: u16 = 100;
93 fn assert_trusted_len
<I
: TrustedLen
>(_
: &I
) {}
96 fn shared_from_iter_normal() {
97 // Exercise the base implementation for non-`TrustedLen` iterators.
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
);
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
);
108 // Clone a bit and let these get dropped.
110 let _rc_2
= rc
.clone();
111 let _rc_3
= rc
.clone();
112 let _rc_4
= Rc
::downgrade(&_rc_3
);
114 } // Drop what hasn't been here.
118 fn shared_from_iter_trustedlen_normal() {
119 // Exercise the `TrustedLen` implementation under normal circumstances
120 // where `size_hint()` matches `(_, Some(exact_len))`.
122 let iter
= (0..SHARED_ITER_MAX
).map(Box
::new
);
123 assert_trusted_len(&iter
);
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
));
131 // Clone a bit and let these get dropped.
133 let _rc_2
= rc
.clone();
134 let _rc_3
= rc
.clone();
135 let _rc_4
= Rc
::downgrade(&_rc_3
);
137 } // Drop what hasn't been here.
139 // Try a ZST to make sure it is handled well.
141 let iter
= (0..SHARED_ITER_MAX
).map(drop
);
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
));
147 let _rc_2
= rc
.clone();
148 let _rc_3
= rc
.clone();
149 let _rc_4
= Rc
::downgrade(&_rc_3
);
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.
159 let iter
= (0..SHARED_ITER_MAX
).map(|val
| match val
{
160 98 => panic
!("I've almost got 99 problems."),
163 assert_trusted_len(&iter
);
164 let _
= iter
.collect
::<Rc
<[_
]>>();
166 panic
!("I am unreachable.");
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>>>);
175 unsafe impl TrustedLen
for Iter {}
177 impl Iterator
for Iter
{
178 fn size_hint(&self) -> (usize, Option
<usize>) {
184 fn next(&mut self) -> Option
<Self::Item
> {
185 self.0.next().flatten()
189 let vec
= vec
![Some(Box
::new(42)), Some(Box
::new(24)), None
, Some(Box
::new(12))];
190 let iter
= Iter(vec
.into_iter());
191 assert_trusted_len(&iter
);
192 assert_eq
!(&[Box
::new(42), Box
::new(24)], &*iter
.collect
::<Rc
<[_
]>>());