1 use core
::array
::{FixedSizeArray, IntoIter}
;
2 use core
::convert
::TryFrom
;
5 fn fixed_size_array() {
6 let mut array
= [0; 64];
7 let mut zero_sized
= [(); 64];
8 let mut empty_array
= [0; 0];
9 let mut empty_zero_sized
= [(); 0];
11 assert_eq
!(FixedSizeArray
::as_slice(&array
).len(), 64);
12 assert_eq
!(FixedSizeArray
::as_slice(&zero_sized
).len(), 64);
13 assert_eq
!(FixedSizeArray
::as_slice(&empty_array
).len(), 0);
14 assert_eq
!(FixedSizeArray
::as_slice(&empty_zero_sized
).len(), 0);
16 assert_eq
!(FixedSizeArray
::as_mut_slice(&mut array
).len(), 64);
17 assert_eq
!(FixedSizeArray
::as_mut_slice(&mut zero_sized
).len(), 64);
18 assert_eq
!(FixedSizeArray
::as_mut_slice(&mut empty_array
).len(), 0);
19 assert_eq
!(FixedSizeArray
::as_mut_slice(&mut empty_zero_sized
).len(), 0);
27 type Array
= [u8; $N
];
28 let array
: Array
= [0; $N
];
29 let slice
: &[u8] = &array
[..];
31 let result
= <&Array
>::try_from(slice
);
32 assert_eq
!(&array
, result
.unwrap());
38 10 11 12 13 14 15 16 17 18 19
39 20 21 22 23 24 25 26 27 28 29
45 fn iterator_collect() {
46 let arr
= [0, 1, 2, 5, 9];
47 let v
: Vec
<_
> = IntoIter
::new(arr
.clone()).collect();
48 assert_eq
!(&arr
[..], &v
[..]);
52 fn iterator_rev_collect() {
53 let arr
= [0, 1, 2, 5, 9];
54 let v
: Vec
<_
> = IntoIter
::new(arr
.clone()).rev().collect();
55 assert_eq
!(&v
[..], &[9, 5, 2, 1, 0]);
60 let v
= [0, 1, 2, 3, 4];
62 assert_eq
!(IntoIter
::new(v
.clone()).nth(i
).unwrap(), v
[i
]);
64 assert_eq
!(IntoIter
::new(v
.clone()).nth(v
.len()), None
);
66 let mut iter
= IntoIter
::new(v
);
67 assert_eq
!(iter
.nth(2).unwrap(), v
[2]);
68 assert_eq
!(iter
.nth(1).unwrap(), v
[4]);
73 let v
= [0, 1, 2, 3, 4];
74 assert_eq
!(IntoIter
::new(v
).last().unwrap(), 4);
75 assert_eq
!(IntoIter
::new([0]).last().unwrap(), 0);
77 let mut it
= IntoIter
::new([0, 9, 2, 4]);
78 assert_eq
!(it
.next_back(), Some(4));
79 assert_eq
!(it
.last(), Some(2));
84 let mut it
= IntoIter
::new([0, 2, 4, 6, 8]);
85 assert_eq
!(it
.next(), Some(0));
86 assert_eq
!(it
.next_back(), Some(8));
87 let mut clone
= it
.clone();
88 assert_eq
!(it
.next_back(), Some(6));
89 assert_eq
!(clone
.next_back(), Some(6));
90 assert_eq
!(it
.next_back(), Some(4));
91 assert_eq
!(clone
.next_back(), Some(4));
92 assert_eq
!(it
.next(), Some(2));
93 assert_eq
!(clone
.next(), Some(2));
98 let mut it
= IntoIter
::new([0, 9, 2]);
99 assert_eq
!(it
.next(), Some(0));
100 assert_eq
!(it
.next(), Some(9));
101 assert_eq
!(it
.next(), Some(2));
102 assert_eq
!(it
.next(), None
);
103 assert_eq
!(it
.next(), None
);
104 assert_eq
!(it
.next(), None
);
105 assert_eq
!(it
.next(), None
);
106 assert_eq
!(it
.next(), None
);
111 let mut it
= IntoIter
::new([0, 1, 2, 5, 9]);
112 assert_eq
!(it
.size_hint(), (5, Some(5)));
113 assert_eq
!(it
.len(), 5);
114 assert_eq
!(it
.is_empty(), false);
116 assert_eq
!(it
.next(), Some(0));
117 assert_eq
!(it
.size_hint(), (4, Some(4)));
118 assert_eq
!(it
.len(), 4);
119 assert_eq
!(it
.is_empty(), false);
121 assert_eq
!(it
.next_back(), Some(9));
122 assert_eq
!(it
.size_hint(), (3, Some(3)));
123 assert_eq
!(it
.len(), 3);
124 assert_eq
!(it
.is_empty(), false);
127 let it
= IntoIter
::new([] as [String
; 0]);
128 assert_eq
!(it
.size_hint(), (0, Some(0)));
129 assert_eq
!(it
.len(), 0);
130 assert_eq
!(it
.is_empty(), true);
134 fn iterator_count() {
135 let v
= [0, 1, 2, 3, 4];
136 assert_eq
!(IntoIter
::new(v
.clone()).count(), 5);
138 let mut iter2
= IntoIter
::new(v
);
141 assert_eq
!(iter2
.count(), 3);
145 fn iterator_flat_map() {
146 assert
!((0..5).flat_map(|i
| IntoIter
::new([2 * i
, 2 * i
+ 1])).eq(0..10));
150 fn iterator_debug() {
151 let arr
= [0, 1, 2, 5, 9];
152 assert_eq
!(format
!("{:?}", IntoIter
::new(arr
)), "IntoIter([0, 1, 2, 5, 9])",);
156 fn iterator_drops() {
157 use core
::cell
::Cell
;
159 // This test makes sure the correct number of elements are dropped. The `R`
160 // type is just a reference to a `Cell` that is incremented when an `R` is
164 struct Foo
<'a
>(&'a Cell
<usize>);
166 impl Drop
for Foo
<'_
> {
168 self.0.set(self.0.get() + 1);
172 fn five(i
: &Cell
<usize>) -> [Foo
<'_
>; 5] {
173 // This is somewhat verbose because `Foo` does not implement `Copy`
174 // since it implements `Drop`. Consequently, we cannot write
176 [Foo(i
), Foo(i
), Foo(i
), Foo(i
), Foo(i
)]
179 // Simple: drop new iterator.
180 let i
= Cell
::new(0);
182 IntoIter
::new(five(&i
));
184 assert_eq
!(i
.get(), 5);
186 // Call `next()` once.
187 let i
= Cell
::new(0);
189 let mut iter
= IntoIter
::new(five(&i
));
190 let _x
= iter
.next();
191 assert_eq
!(i
.get(), 0);
192 assert_eq
!(iter
.count(), 4);
193 assert_eq
!(i
.get(), 4);
195 assert_eq
!(i
.get(), 5);
197 // Check `clone` and calling `next`/`next_back`.
198 let i
= Cell
::new(0);
200 let mut iter
= IntoIter
::new(five(&i
));
202 assert_eq
!(i
.get(), 1);
204 assert_eq
!(i
.get(), 2);
206 let mut clone
= iter
.clone();
207 assert_eq
!(i
.get(), 2);
210 assert_eq
!(i
.get(), 3);
213 assert_eq
!(i
.get(), 4);
215 assert_eq
!(clone
.count(), 2);
216 assert_eq
!(i
.get(), 6);
218 assert_eq
!(i
.get(), 8);
221 let i
= Cell
::new(0);
223 let mut iter
= IntoIter
::new(five(&i
));
224 let _x
= iter
.nth(2);
225 assert_eq
!(i
.get(), 2);
226 let _y
= iter
.last();
227 assert_eq
!(i
.get(), 3);
229 assert_eq
!(i
.get(), 5);
231 // Check every element.
232 let i
= Cell
::new(0);
233 for (index
, _x
) in IntoIter
::new(five(&i
)).enumerate() {
234 assert_eq
!(i
.get(), index
);
236 assert_eq
!(i
.get(), 5);
238 let i
= Cell
::new(0);
239 for (index
, _x
) in IntoIter
::new(five(&i
)).rev().enumerate() {
240 assert_eq
!(i
.get(), index
);
242 assert_eq
!(i
.get(), 5);
245 // This test does not work on targets without panic=unwind support.
246 // To work around this problem, test is marked is should_panic, so it will
247 // be automagically skipped on unsuitable targets, such as
248 // wasm32-unknown-unkown.
250 // It means that we use panic for indicating success.
252 #[should_panic(expected = "test succeeded")]
253 fn array_default_impl_avoids_leaks_on_panic() {
254 use core
::sync
::atomic
::{AtomicUsize, Ordering::Relaxed}
;
255 static COUNTER
: AtomicUsize
= AtomicUsize
::new(0);
259 impl Default
for Bomb
{
260 fn default() -> Bomb
{
261 if COUNTER
.load(Relaxed
) == 3 {
262 panic
!("bomb limit exceeded");
265 COUNTER
.fetch_add(1, Relaxed
);
266 Bomb(COUNTER
.load(Relaxed
))
272 COUNTER
.fetch_sub(1, Relaxed
);
276 let res
= std
::panic
::catch_unwind(|| <[Bomb
; 5]>::default());
277 let panic_msg
= match res
{
278 Ok(_
) => unreachable
!(),
279 Err(p
) => p
.downcast
::<&'
static str>().unwrap(),
281 assert_eq
!(*panic_msg
, "bomb limit exceeded");
282 // check that all bombs are successfully dropped
283 assert_eq
!(COUNTER
.load(Relaxed
), 0);
284 panic
!("test succeeded")
288 fn empty_array_is_always_default() {
289 struct DoesNotImplDefault
;
291 let _arr
= <[DoesNotImplDefault
; 0]>::default();