2 use core
::cmp
::Ordering
;
3 use core
::mem
::MaybeUninit
;
4 use core
::result
::Result
::{Err, Ok}
;
9 let b
= [1, 2, 3, 5, 5];
10 assert_eq
!(b
.iter().position(|&v
| v
== 9), None
);
11 assert_eq
!(b
.iter().position(|&v
| v
== 5), Some(3));
12 assert_eq
!(b
.iter().position(|&v
| v
== 3), Some(2));
13 assert_eq
!(b
.iter().position(|&v
| v
== 0), None
);
18 let b
= [1, 2, 3, 5, 5];
19 assert_eq
!(b
.iter().rposition(|&v
| v
== 9), None
);
20 assert_eq
!(b
.iter().rposition(|&v
| v
== 5), Some(4));
21 assert_eq
!(b
.iter().rposition(|&v
| v
== 3), Some(2));
22 assert_eq
!(b
.iter().rposition(|&v
| v
== 0), None
);
26 fn test_binary_search() {
28 assert_eq
!(b
.binary_search(&5), Err(0));
31 assert_eq
!(b
.binary_search(&3), Err(0));
32 assert_eq
!(b
.binary_search(&4), Ok(0));
33 assert_eq
!(b
.binary_search(&5), Err(1));
35 let b
= [1, 2, 4, 6, 8, 9];
36 assert_eq
!(b
.binary_search(&5), Err(3));
37 assert_eq
!(b
.binary_search(&6), Ok(3));
38 assert_eq
!(b
.binary_search(&7), Err(4));
39 assert_eq
!(b
.binary_search(&8), Ok(4));
41 let b
= [1, 2, 4, 5, 6, 8];
42 assert_eq
!(b
.binary_search(&9), Err(6));
44 let b
= [1, 2, 4, 6, 7, 8, 9];
45 assert_eq
!(b
.binary_search(&6), Ok(3));
46 assert_eq
!(b
.binary_search(&5), Err(3));
47 assert_eq
!(b
.binary_search(&8), Ok(5));
49 let b
= [1, 2, 4, 5, 6, 8, 9];
50 assert_eq
!(b
.binary_search(&7), Err(5));
51 assert_eq
!(b
.binary_search(&0), Err(0));
53 let b
= [1, 3, 3, 3, 7];
54 assert_eq
!(b
.binary_search(&0), Err(0));
55 assert_eq
!(b
.binary_search(&1), Ok(0));
56 assert_eq
!(b
.binary_search(&2), Err(1));
57 assert
!(match b
.binary_search(&3) {
61 assert
!(match b
.binary_search(&3) {
65 assert_eq
!(b
.binary_search(&4), Err(4));
66 assert_eq
!(b
.binary_search(&5), Err(4));
67 assert_eq
!(b
.binary_search(&6), Err(4));
68 assert_eq
!(b
.binary_search(&7), Ok(4));
69 assert_eq
!(b
.binary_search(&8), Err(5));
71 let b
= [(); usize::MAX
];
72 assert_eq
!(b
.binary_search(&()), Ok(usize::MAX
/ 2));
76 fn test_binary_search_by_overflow() {
77 let b
= [(); usize::MAX
];
78 assert_eq
!(b
.binary_search_by(|_
| Ordering
::Equal
), Ok(usize::MAX
/ 2));
79 assert_eq
!(b
.binary_search_by(|_
| Ordering
::Greater
), Err(0));
80 assert_eq
!(b
.binary_search_by(|_
| Ordering
::Less
), Err(usize::MAX
));
84 // Test implementation specific behavior when finding equivalent elements.
85 // It is ok to break this test but when you do a crater run is highly advisable.
86 fn test_binary_search_implementation_details() {
87 let b
= [1, 1, 2, 2, 3, 3, 3];
88 assert_eq
!(b
.binary_search(&1), Ok(1));
89 assert_eq
!(b
.binary_search(&2), Ok(3));
90 assert_eq
!(b
.binary_search(&3), Ok(5));
91 let b
= [1, 1, 1, 1, 1, 3, 3, 3, 3];
92 assert_eq
!(b
.binary_search(&1), Ok(4));
93 assert_eq
!(b
.binary_search(&3), Ok(7));
94 let b
= [1, 1, 1, 1, 3, 3, 3, 3, 3];
95 assert_eq
!(b
.binary_search(&1), Ok(2));
96 assert_eq
!(b
.binary_search(&3), Ok(4));
100 fn test_partition_point() {
101 let b
: [i32; 0] = [];
102 assert_eq
!(b
.partition_point(|&x
| x
< 5), 0);
105 assert_eq
!(b
.partition_point(|&x
| x
< 3), 0);
106 assert_eq
!(b
.partition_point(|&x
| x
< 4), 0);
107 assert_eq
!(b
.partition_point(|&x
| x
< 5), 1);
109 let b
= [1, 2, 4, 6, 8, 9];
110 assert_eq
!(b
.partition_point(|&x
| x
< 5), 3);
111 assert_eq
!(b
.partition_point(|&x
| x
< 6), 3);
112 assert_eq
!(b
.partition_point(|&x
| x
< 7), 4);
113 assert_eq
!(b
.partition_point(|&x
| x
< 8), 4);
115 let b
= [1, 2, 4, 5, 6, 8];
116 assert_eq
!(b
.partition_point(|&x
| x
< 9), 6);
118 let b
= [1, 2, 4, 6, 7, 8, 9];
119 assert_eq
!(b
.partition_point(|&x
| x
< 6), 3);
120 assert_eq
!(b
.partition_point(|&x
| x
< 5), 3);
121 assert_eq
!(b
.partition_point(|&x
| x
< 8), 5);
123 let b
= [1, 2, 4, 5, 6, 8, 9];
124 assert_eq
!(b
.partition_point(|&x
| x
< 7), 5);
125 assert_eq
!(b
.partition_point(|&x
| x
< 0), 0);
127 let b
= [1, 3, 3, 3, 7];
128 assert_eq
!(b
.partition_point(|&x
| x
< 0), 0);
129 assert_eq
!(b
.partition_point(|&x
| x
< 1), 0);
130 assert_eq
!(b
.partition_point(|&x
| x
< 2), 1);
131 assert_eq
!(b
.partition_point(|&x
| x
< 3), 1);
132 assert_eq
!(b
.partition_point(|&x
| x
< 4), 4);
133 assert_eq
!(b
.partition_point(|&x
| x
< 5), 4);
134 assert_eq
!(b
.partition_point(|&x
| x
< 6), 4);
135 assert_eq
!(b
.partition_point(|&x
| x
< 7), 4);
136 assert_eq
!(b
.partition_point(|&x
| x
< 8), 5);
140 fn test_iterator_advance_by() {
141 let v
= &[0, 1, 2, 3, 4];
143 for i
in 0..=v
.len() {
144 let mut iter
= v
.iter();
145 iter
.advance_by(i
).unwrap();
146 assert_eq
!(iter
.as_slice(), &v
[i
..]);
149 let mut iter
= v
.iter();
150 assert_eq
!(iter
.advance_by(v
.len() + 1), Err(v
.len()));
151 assert_eq
!(iter
.as_slice(), &[]);
153 let mut iter
= v
.iter();
154 iter
.advance_by(3).unwrap();
155 assert_eq
!(iter
.as_slice(), &v
[3..]);
156 iter
.advance_by(2).unwrap();
157 assert_eq
!(iter
.as_slice(), &[]);
158 iter
.advance_by(0).unwrap();
162 fn test_iterator_advance_back_by() {
163 let v
= &[0, 1, 2, 3, 4];
165 for i
in 0..=v
.len() {
166 let mut iter
= v
.iter();
167 iter
.advance_back_by(i
).unwrap();
168 assert_eq
!(iter
.as_slice(), &v
[..v
.len() - i
]);
171 let mut iter
= v
.iter();
172 assert_eq
!(iter
.advance_back_by(v
.len() + 1), Err(v
.len()));
173 assert_eq
!(iter
.as_slice(), &[]);
175 let mut iter
= v
.iter();
176 iter
.advance_back_by(3).unwrap();
177 assert_eq
!(iter
.as_slice(), &v
[..v
.len() - 3]);
178 iter
.advance_back_by(2).unwrap();
179 assert_eq
!(iter
.as_slice(), &[]);
180 iter
.advance_back_by(0).unwrap();
184 fn test_iterator_nth() {
185 let v
: &[_
] = &[0, 1, 2, 3, 4];
186 for i
in 0..v
.len() {
187 assert_eq
!(v
.iter().nth(i
).unwrap(), &v
[i
]);
189 assert_eq
!(v
.iter().nth(v
.len()), None
);
191 let mut iter
= v
.iter();
192 assert_eq
!(iter
.nth(2).unwrap(), &v
[2]);
193 assert_eq
!(iter
.nth(1).unwrap(), &v
[4]);
197 fn test_iterator_nth_back() {
198 let v
: &[_
] = &[0, 1, 2, 3, 4];
199 for i
in 0..v
.len() {
200 assert_eq
!(v
.iter().nth_back(i
).unwrap(), &v
[v
.len() - i
- 1]);
202 assert_eq
!(v
.iter().nth_back(v
.len()), None
);
204 let mut iter
= v
.iter();
205 assert_eq
!(iter
.nth_back(2).unwrap(), &v
[2]);
206 assert_eq
!(iter
.nth_back(1).unwrap(), &v
[0]);
210 fn test_iterator_last() {
211 let v
: &[_
] = &[0, 1, 2, 3, 4];
212 assert_eq
!(v
.iter().last().unwrap(), &4);
213 assert_eq
!(v
[..1].iter().last().unwrap(), &0);
217 fn test_iterator_count() {
218 let v
: &[_
] = &[0, 1, 2, 3, 4];
219 assert_eq
!(v
.iter().count(), 5);
221 let mut iter2
= v
.iter();
224 assert_eq
!(iter2
.count(), 3);
228 fn test_chunks_count() {
229 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
231 assert_eq
!(c
.count(), 2);
233 let v2
: &[i32] = &[0, 1, 2, 3, 4];
234 let c2
= v2
.chunks(2);
235 assert_eq
!(c2
.count(), 3);
237 let v3
: &[i32] = &[];
238 let c3
= v3
.chunks(2);
239 assert_eq
!(c3
.count(), 0);
243 fn test_chunks_nth() {
244 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
245 let mut c
= v
.chunks(2);
246 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
247 assert_eq
!(c
.next().unwrap(), &[4, 5]);
249 let v2
: &[i32] = &[0, 1, 2, 3, 4];
250 let mut c2
= v2
.chunks(3);
251 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4]);
252 assert_eq
!(c2
.next(), None
);
256 fn test_chunks_next() {
257 let v
= [0, 1, 2, 3, 4, 5];
258 let mut c
= v
.chunks(2);
259 assert_eq
!(c
.next().unwrap(), &[0, 1]);
260 assert_eq
!(c
.next().unwrap(), &[2, 3]);
261 assert_eq
!(c
.next().unwrap(), &[4, 5]);
262 assert_eq
!(c
.next(), None
);
264 let v
= [0, 1, 2, 3, 4, 5, 6, 7];
265 let mut c
= v
.chunks(3);
266 assert_eq
!(c
.next().unwrap(), &[0, 1, 2]);
267 assert_eq
!(c
.next().unwrap(), &[3, 4, 5]);
268 assert_eq
!(c
.next().unwrap(), &[6, 7]);
269 assert_eq
!(c
.next(), None
);
273 fn test_chunks_next_back() {
274 let v
= [0, 1, 2, 3, 4, 5];
275 let mut c
= v
.chunks(2);
276 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
277 assert_eq
!(c
.next_back().unwrap(), &[2, 3]);
278 assert_eq
!(c
.next_back().unwrap(), &[0, 1]);
279 assert_eq
!(c
.next_back(), None
);
281 let v
= [0, 1, 2, 3, 4, 5, 6, 7];
282 let mut c
= v
.chunks(3);
283 assert_eq
!(c
.next_back().unwrap(), &[6, 7]);
284 assert_eq
!(c
.next_back().unwrap(), &[3, 4, 5]);
285 assert_eq
!(c
.next_back().unwrap(), &[0, 1, 2]);
286 assert_eq
!(c
.next_back(), None
);
290 fn test_chunks_nth_back() {
291 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
292 let mut c
= v
.chunks(2);
293 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
294 assert_eq
!(c
.next().unwrap(), &[0, 1]);
295 assert_eq
!(c
.next(), None
);
297 let v2
: &[i32] = &[0, 1, 2, 3, 4];
298 let mut c2
= v2
.chunks(3);
299 assert_eq
!(c2
.nth_back(1).unwrap(), &[0, 1, 2]);
300 assert_eq
!(c2
.next(), None
);
301 assert_eq
!(c2
.next_back(), None
);
303 let v3
: &[i32] = &[0, 1, 2, 3, 4];
304 let mut c3
= v3
.chunks(10);
305 assert_eq
!(c3
.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
306 assert_eq
!(c3
.next(), None
);
308 let v4
: &[i32] = &[0, 1, 2];
309 let mut c4
= v4
.chunks(10);
310 assert_eq
!(c4
.nth_back(1_000_000_000usize
), None
);
314 fn test_chunks_last() {
315 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
317 assert_eq
!(c
.last().unwrap()[1], 5);
319 let v2
: &[i32] = &[0, 1, 2, 3, 4];
320 let c2
= v2
.chunks(2);
321 assert_eq
!(c2
.last().unwrap()[0], 4);
325 fn test_chunks_zip() {
326 let v1
: &[i32] = &[0, 1, 2, 3, 4];
327 let v2
: &[i32] = &[6, 7, 8, 9, 10];
332 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
333 .collect
::<Vec
<_
>>();
334 assert_eq
!(res
, vec
![14, 22, 14]);
338 fn test_chunks_mut_count() {
339 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
340 let c
= v
.chunks_mut(3);
341 assert_eq
!(c
.count(), 2);
343 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
344 let c2
= v2
.chunks_mut(2);
345 assert_eq
!(c2
.count(), 3);
347 let v3
: &mut [i32] = &mut [];
348 let c3
= v3
.chunks_mut(2);
349 assert_eq
!(c3
.count(), 0);
353 fn test_chunks_mut_nth() {
354 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
355 let mut c
= v
.chunks_mut(2);
356 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
357 assert_eq
!(c
.next().unwrap(), &[4, 5]);
359 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
360 let mut c2
= v2
.chunks_mut(3);
361 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4]);
362 assert_eq
!(c2
.next(), None
);
366 fn test_chunks_mut_nth_back() {
367 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
368 let mut c
= v
.chunks_mut(2);
369 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
370 assert_eq
!(c
.next().unwrap(), &[0, 1]);
372 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
373 let mut c1
= v1
.chunks_mut(3);
374 assert_eq
!(c1
.nth_back(1).unwrap(), &[0, 1, 2]);
375 assert_eq
!(c1
.next(), None
);
377 let v3
: &mut [i32] = &mut [0, 1, 2, 3, 4];
378 let mut c3
= v3
.chunks_mut(10);
379 assert_eq
!(c3
.nth_back(0).unwrap(), &[0, 1, 2, 3, 4]);
380 assert_eq
!(c3
.next(), None
);
382 let v4
: &mut [i32] = &mut [0, 1, 2];
383 let mut c4
= v4
.chunks_mut(10);
384 assert_eq
!(c4
.nth_back(1_000_000_000usize
), None
);
388 fn test_chunks_mut_last() {
389 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
390 let c
= v
.chunks_mut(2);
391 assert_eq
!(c
.last().unwrap(), &[4, 5]);
393 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
394 let c2
= v2
.chunks_mut(2);
395 assert_eq
!(c2
.last().unwrap(), &[4]);
399 fn test_chunks_mut_zip() {
400 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
401 let v2
: &[i32] = &[6, 7, 8, 9, 10];
403 for (a
, b
) in v1
.chunks_mut(2).zip(v2
.chunks(2)) {
404 let sum
= b
.iter().sum
::<i32>();
409 assert_eq
!(v1
, [13, 14, 19, 20, 14]);
413 fn test_chunks_mut_zip_aliasing() {
414 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
415 let v2
: &[i32] = &[6, 7, 8, 9, 10];
417 let mut it
= v1
.chunks_mut(2).zip(v2
.chunks(2));
418 let first
= it
.next().unwrap();
419 let _
= it
.next().unwrap();
420 assert_eq
!(first
, (&mut [0, 1][..], &[6, 7][..]));
424 fn test_chunks_exact_mut_zip_aliasing() {
425 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
426 let v2
: &[i32] = &[6, 7, 8, 9, 10];
428 let mut it
= v1
.chunks_exact_mut(2).zip(v2
.chunks(2));
429 let first
= it
.next().unwrap();
430 let _
= it
.next().unwrap();
431 assert_eq
!(first
, (&mut [0, 1][..], &[6, 7][..]));
435 fn test_rchunks_mut_zip_aliasing() {
436 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
437 let v2
: &[i32] = &[6, 7, 8, 9, 10];
439 let mut it
= v1
.rchunks_mut(2).zip(v2
.chunks(2));
440 let first
= it
.next().unwrap();
441 let _
= it
.next().unwrap();
442 assert_eq
!(first
, (&mut [3, 4][..], &[6, 7][..]));
446 fn test_rchunks_exact_mut_zip_aliasing() {
447 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
448 let v2
: &[i32] = &[6, 7, 8, 9, 10];
450 let mut it
= v1
.rchunks_exact_mut(2).zip(v2
.chunks(2));
451 let first
= it
.next().unwrap();
452 let _
= it
.next().unwrap();
453 assert_eq
!(first
, (&mut [3, 4][..], &[6, 7][..]));
457 fn test_chunks_exact_count() {
458 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
459 let c
= v
.chunks_exact(3);
460 assert_eq
!(c
.count(), 2);
462 let v2
: &[i32] = &[0, 1, 2, 3, 4];
463 let c2
= v2
.chunks_exact(2);
464 assert_eq
!(c2
.count(), 2);
466 let v3
: &[i32] = &[];
467 let c3
= v3
.chunks_exact(2);
468 assert_eq
!(c3
.count(), 0);
472 fn test_chunks_exact_nth() {
473 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
474 let mut c
= v
.chunks_exact(2);
475 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
476 assert_eq
!(c
.next().unwrap(), &[4, 5]);
478 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
479 let mut c2
= v2
.chunks_exact(3);
480 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
481 assert_eq
!(c2
.next(), None
);
485 fn test_chunks_exact_nth_back() {
486 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
487 let mut c
= v
.chunks_exact(2);
488 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
489 assert_eq
!(c
.next().unwrap(), &[0, 1]);
490 assert_eq
!(c
.next(), None
);
492 let v2
: &[i32] = &[0, 1, 2, 3, 4];
493 let mut c2
= v2
.chunks_exact(3);
494 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
495 assert_eq
!(c2
.next(), None
);
496 assert_eq
!(c2
.next_back(), None
);
498 let v3
: &[i32] = &[0, 1, 2, 3, 4];
499 let mut c3
= v3
.chunks_exact(10);
500 assert_eq
!(c3
.nth_back(0), None
);
504 fn test_chunks_exact_last() {
505 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
506 let c
= v
.chunks_exact(2);
507 assert_eq
!(c
.last().unwrap(), &[4, 5]);
509 let v2
: &[i32] = &[0, 1, 2, 3, 4];
510 let c2
= v2
.chunks_exact(2);
511 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
515 fn test_chunks_exact_remainder() {
516 let v
: &[i32] = &[0, 1, 2, 3, 4];
517 let c
= v
.chunks_exact(2);
518 assert_eq
!(c
.remainder(), &[4]);
522 fn test_chunks_exact_zip() {
523 let v1
: &[i32] = &[0, 1, 2, 3, 4];
524 let v2
: &[i32] = &[6, 7, 8, 9, 10];
528 .zip(v2
.chunks_exact(2))
529 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
530 .collect
::<Vec
<_
>>();
531 assert_eq
!(res
, vec
![14, 22]);
535 fn test_chunks_exact_mut_count() {
536 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
537 let c
= v
.chunks_exact_mut(3);
538 assert_eq
!(c
.count(), 2);
540 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
541 let c2
= v2
.chunks_exact_mut(2);
542 assert_eq
!(c2
.count(), 2);
544 let v3
: &mut [i32] = &mut [];
545 let c3
= v3
.chunks_exact_mut(2);
546 assert_eq
!(c3
.count(), 0);
550 fn test_chunks_exact_mut_nth() {
551 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
552 let mut c
= v
.chunks_exact_mut(2);
553 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
554 assert_eq
!(c
.next().unwrap(), &[4, 5]);
556 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
557 let mut c2
= v2
.chunks_exact_mut(3);
558 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
559 assert_eq
!(c2
.next(), None
);
563 fn test_chunks_exact_mut_nth_back() {
564 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
565 let mut c
= v
.chunks_exact_mut(2);
566 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
567 assert_eq
!(c
.next().unwrap(), &[0, 1]);
568 assert_eq
!(c
.next(), None
);
570 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
571 let mut c2
= v2
.chunks_exact_mut(3);
572 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
573 assert_eq
!(c2
.next(), None
);
574 assert_eq
!(c2
.next_back(), None
);
576 let v3
: &mut [i32] = &mut [0, 1, 2, 3, 4];
577 let mut c3
= v3
.chunks_exact_mut(10);
578 assert_eq
!(c3
.nth_back(0), None
);
582 fn test_chunks_exact_mut_last() {
583 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
584 let c
= v
.chunks_exact_mut(2);
585 assert_eq
!(c
.last().unwrap(), &[4, 5]);
587 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
588 let c2
= v2
.chunks_exact_mut(2);
589 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
593 fn test_chunks_exact_mut_remainder() {
594 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4];
595 let c
= v
.chunks_exact_mut(2);
596 assert_eq
!(c
.into_remainder(), &[4]);
600 fn test_chunks_exact_mut_zip() {
601 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
602 let v2
: &[i32] = &[6, 7, 8, 9, 10];
604 for (a
, b
) in v1
.chunks_exact_mut(2).zip(v2
.chunks_exact(2)) {
605 let sum
= b
.iter().sum
::<i32>();
610 assert_eq
!(v1
, [13, 14, 19, 20, 4]);
614 fn test_array_chunks_infer() {
615 let v
: &[i32] = &[0, 1, 2, 3, 4, -4];
616 let c
= v
.array_chunks();
617 for &[a
, b
, c
] in c
{
618 assert_eq
!(a
+ b
+ c
, 3);
621 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
622 let total
= v2
.array_chunks().map(|&[a
, b
]| a
* b
).sum
::<i32>();
623 assert_eq
!(total
, 2 * 3 + 4 * 5);
627 fn test_array_chunks_count() {
628 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
629 let c
= v
.array_chunks
::<3>();
630 assert_eq
!(c
.count(), 2);
632 let v2
: &[i32] = &[0, 1, 2, 3, 4];
633 let c2
= v2
.array_chunks
::<2>();
634 assert_eq
!(c2
.count(), 2);
636 let v3
: &[i32] = &[];
637 let c3
= v3
.array_chunks
::<2>();
638 assert_eq
!(c3
.count(), 0);
642 fn test_array_chunks_nth() {
643 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
644 let mut c
= v
.array_chunks
::<2>();
645 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
646 assert_eq
!(c
.next().unwrap(), &[4, 5]);
648 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
649 let mut c2
= v2
.array_chunks
::<3>();
650 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
651 assert_eq
!(c2
.next(), None
);
655 fn test_array_chunks_nth_back() {
656 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
657 let mut c
= v
.array_chunks
::<2>();
658 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
659 assert_eq
!(c
.next().unwrap(), &[0, 1]);
660 assert_eq
!(c
.next(), None
);
662 let v2
: &[i32] = &[0, 1, 2, 3, 4];
663 let mut c2
= v2
.array_chunks
::<3>();
664 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
665 assert_eq
!(c2
.next(), None
);
666 assert_eq
!(c2
.next_back(), None
);
668 let v3
: &[i32] = &[0, 1, 2, 3, 4];
669 let mut c3
= v3
.array_chunks
::<10>();
670 assert_eq
!(c3
.nth_back(0), None
);
674 fn test_array_chunks_last() {
675 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
676 let c
= v
.array_chunks
::<2>();
677 assert_eq
!(c
.last().unwrap(), &[4, 5]);
679 let v2
: &[i32] = &[0, 1, 2, 3, 4];
680 let c2
= v2
.array_chunks
::<2>();
681 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
685 fn test_array_chunks_remainder() {
686 let v
: &[i32] = &[0, 1, 2, 3, 4];
687 let c
= v
.array_chunks
::<2>();
688 assert_eq
!(c
.remainder(), &[4]);
692 fn test_array_chunks_zip() {
693 let v1
: &[i32] = &[0, 1, 2, 3, 4];
694 let v2
: &[i32] = &[6, 7, 8, 9, 10];
698 .zip(v2
.array_chunks
::<2>())
699 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
700 .collect
::<Vec
<_
>>();
701 assert_eq
!(res
, vec
![14, 22]);
705 fn test_array_chunks_mut_infer() {
706 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
707 for a
in v
.array_chunks_mut() {
708 let sum
= a
.iter().sum
::<i32>();
711 assert_eq
!(v
, &[3, 3, 3, 12, 12, 12, 6]);
713 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
714 v2
.array_chunks_mut().for_each(|[a
, b
]| core
::mem
::swap(a
, b
));
715 assert_eq
!(v2
, &[1, 0, 3, 2, 5, 4, 6]);
719 fn test_array_chunks_mut_count() {
720 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
721 let c
= v
.array_chunks_mut
::<3>();
722 assert_eq
!(c
.count(), 2);
724 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
725 let c2
= v2
.array_chunks_mut
::<2>();
726 assert_eq
!(c2
.count(), 2);
728 let v3
: &mut [i32] = &mut [];
729 let c3
= v3
.array_chunks_mut
::<2>();
730 assert_eq
!(c3
.count(), 0);
734 fn test_array_chunks_mut_nth() {
735 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
736 let mut c
= v
.array_chunks_mut
::<2>();
737 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
738 assert_eq
!(c
.next().unwrap(), &[4, 5]);
740 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
741 let mut c2
= v2
.array_chunks_mut
::<3>();
742 assert_eq
!(c2
.nth(1).unwrap(), &[3, 4, 5]);
743 assert_eq
!(c2
.next(), None
);
747 fn test_array_chunks_mut_nth_back() {
748 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
749 let mut c
= v
.array_chunks_mut
::<2>();
750 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
751 assert_eq
!(c
.next().unwrap(), &[0, 1]);
752 assert_eq
!(c
.next(), None
);
754 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
755 let mut c2
= v2
.array_chunks_mut
::<3>();
756 assert_eq
!(c2
.nth_back(0).unwrap(), &[0, 1, 2]);
757 assert_eq
!(c2
.next(), None
);
758 assert_eq
!(c2
.next_back(), None
);
760 let v3
: &mut [i32] = &mut [0, 1, 2, 3, 4];
761 let mut c3
= v3
.array_chunks_mut
::<10>();
762 assert_eq
!(c3
.nth_back(0), None
);
766 fn test_array_chunks_mut_last() {
767 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
768 let c
= v
.array_chunks_mut
::<2>();
769 assert_eq
!(c
.last().unwrap(), &[4, 5]);
771 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
772 let c2
= v2
.array_chunks_mut
::<2>();
773 assert_eq
!(c2
.last().unwrap(), &[2, 3]);
777 fn test_array_chunks_mut_remainder() {
778 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4];
779 let c
= v
.array_chunks_mut
::<2>();
780 assert_eq
!(c
.into_remainder(), &[4]);
784 fn test_array_chunks_mut_zip() {
785 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
786 let v2
: &[i32] = &[6, 7, 8, 9, 10];
788 for (a
, b
) in v1
.array_chunks_mut
::<2>().zip(v2
.array_chunks
::<2>()) {
789 let sum
= b
.iter().sum
::<i32>();
794 assert_eq
!(v1
, [13, 14, 19, 20, 4]);
798 fn test_array_windows_infer() {
799 let v
: &[i32] = &[0, 1, 0, 1];
800 assert_eq
!(v
.array_windows
::<2>().count(), 3);
801 let c
= v
.array_windows();
803 assert_eq
!(a
+ b
, 1);
806 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
807 let total
= v2
.array_windows().map(|&[a
, b
, c
]| a
+ b
+ c
).sum
::<i32>();
808 assert_eq
!(total
, 3 + 6 + 9 + 12 + 15);
812 fn test_array_windows_count() {
813 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
814 let c
= v
.array_windows
::<3>();
815 assert_eq
!(c
.count(), 4);
817 let v2
: &[i32] = &[0, 1, 2, 3, 4];
818 let c2
= v2
.array_windows
::<6>();
819 assert_eq
!(c2
.count(), 0);
821 let v3
: &[i32] = &[];
822 let c3
= v3
.array_windows
::<2>();
823 assert_eq
!(c3
.count(), 0);
825 let v4
: &[()] = &[(); usize::MAX
];
826 let c4
= v4
.array_windows
::<1>();
827 assert_eq
!(c4
.count(), usize::MAX
);
831 fn test_array_windows_nth() {
832 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
833 let snd
= v
.array_windows
::<4>().nth(1);
834 assert_eq
!(snd
, Some(&[1, 2, 3, 4]));
835 let mut arr_windows
= v
.array_windows
::<2>();
836 assert_ne
!(arr_windows
.nth(0), arr_windows
.nth(0));
837 let last
= v
.array_windows
::<3>().last();
838 assert_eq
!(last
, Some(&[3, 4, 5]));
842 fn test_array_windows_nth_back() {
843 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
844 let snd
= v
.array_windows
::<4>().nth_back(1);
845 assert_eq
!(snd
, Some(&[1, 2, 3, 4]));
846 let mut arr_windows
= v
.array_windows
::<2>();
847 assert_ne
!(arr_windows
.nth_back(0), arr_windows
.nth_back(0));
851 fn test_rchunks_count() {
852 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
853 let c
= v
.rchunks(3);
854 assert_eq
!(c
.count(), 2);
856 let v2
: &[i32] = &[0, 1, 2, 3, 4];
857 let c2
= v2
.rchunks(2);
858 assert_eq
!(c2
.count(), 3);
860 let v3
: &[i32] = &[];
861 let c3
= v3
.rchunks(2);
862 assert_eq
!(c3
.count(), 0);
866 fn test_rchunks_nth() {
867 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
868 let mut c
= v
.rchunks(2);
869 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
870 assert_eq
!(c
.next().unwrap(), &[0, 1]);
872 let v2
: &[i32] = &[0, 1, 2, 3, 4];
873 let mut c2
= v2
.rchunks(3);
874 assert_eq
!(c2
.nth(1).unwrap(), &[0, 1]);
875 assert_eq
!(c2
.next(), None
);
879 fn test_rchunks_nth_back() {
880 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
881 let mut c
= v
.rchunks(2);
882 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
883 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
885 let v2
: &[i32] = &[0, 1, 2, 3, 4];
886 let mut c2
= v2
.rchunks(3);
887 assert_eq
!(c2
.nth_back(1).unwrap(), &[2, 3, 4]);
888 assert_eq
!(c2
.next_back(), None
);
892 fn test_rchunks_next() {
893 let v
= [0, 1, 2, 3, 4, 5];
894 let mut c
= v
.rchunks(2);
895 assert_eq
!(c
.next().unwrap(), &[4, 5]);
896 assert_eq
!(c
.next().unwrap(), &[2, 3]);
897 assert_eq
!(c
.next().unwrap(), &[0, 1]);
898 assert_eq
!(c
.next(), None
);
900 let v
= [0, 1, 2, 3, 4, 5, 6, 7];
901 let mut c
= v
.rchunks(3);
902 assert_eq
!(c
.next().unwrap(), &[5, 6, 7]);
903 assert_eq
!(c
.next().unwrap(), &[2, 3, 4]);
904 assert_eq
!(c
.next().unwrap(), &[0, 1]);
905 assert_eq
!(c
.next(), None
);
909 fn test_rchunks_next_back() {
910 let v
= [0, 1, 2, 3, 4, 5];
911 let mut c
= v
.rchunks(2);
912 assert_eq
!(c
.next_back().unwrap(), &[0, 1]);
913 assert_eq
!(c
.next_back().unwrap(), &[2, 3]);
914 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
915 assert_eq
!(c
.next_back(), None
);
917 let v
= [0, 1, 2, 3, 4, 5, 6, 7];
918 let mut c
= v
.rchunks(3);
919 assert_eq
!(c
.next_back().unwrap(), &[0, 1]);
920 assert_eq
!(c
.next_back().unwrap(), &[2, 3, 4]);
921 assert_eq
!(c
.next_back().unwrap(), &[5, 6, 7]);
922 assert_eq
!(c
.next_back(), None
);
926 fn test_rchunks_last() {
927 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
928 let c
= v
.rchunks(2);
929 assert_eq
!(c
.last().unwrap()[1], 1);
931 let v2
: &[i32] = &[0, 1, 2, 3, 4];
932 let c2
= v2
.rchunks(2);
933 assert_eq
!(c2
.last().unwrap()[0], 0);
937 fn test_rchunks_zip() {
938 let v1
: &[i32] = &[0, 1, 2, 3, 4];
939 let v2
: &[i32] = &[6, 7, 8, 9, 10];
944 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
945 .collect
::<Vec
<_
>>();
946 assert_eq
!(res
, vec
![26, 18, 6]);
950 fn test_rchunks_mut_count() {
951 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
952 let c
= v
.rchunks_mut(3);
953 assert_eq
!(c
.count(), 2);
955 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
956 let c2
= v2
.rchunks_mut(2);
957 assert_eq
!(c2
.count(), 3);
959 let v3
: &mut [i32] = &mut [];
960 let c3
= v3
.rchunks_mut(2);
961 assert_eq
!(c3
.count(), 0);
965 fn test_rchunks_mut_nth() {
966 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
967 let mut c
= v
.rchunks_mut(2);
968 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
969 assert_eq
!(c
.next().unwrap(), &[0, 1]);
971 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
972 let mut c2
= v2
.rchunks_mut(3);
973 assert_eq
!(c2
.nth(1).unwrap(), &[0, 1]);
974 assert_eq
!(c2
.next(), None
);
978 fn test_rchunks_mut_nth_back() {
979 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
980 let mut c
= v
.rchunks_mut(2);
981 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
982 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
984 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
985 let mut c2
= v2
.rchunks_mut(3);
986 assert_eq
!(c2
.nth_back(1).unwrap(), &[2, 3, 4]);
987 assert_eq
!(c2
.next_back(), None
);
991 fn test_rchunks_mut_next() {
992 let mut v
= [0, 1, 2, 3, 4, 5];
993 let mut c
= v
.rchunks_mut(2);
994 assert_eq
!(c
.next().unwrap(), &mut [4, 5]);
995 assert_eq
!(c
.next().unwrap(), &mut [2, 3]);
996 assert_eq
!(c
.next().unwrap(), &mut [0, 1]);
997 assert_eq
!(c
.next(), None
);
999 let mut v
= [0, 1, 2, 3, 4, 5, 6, 7];
1000 let mut c
= v
.rchunks_mut(3);
1001 assert_eq
!(c
.next().unwrap(), &mut [5, 6, 7]);
1002 assert_eq
!(c
.next().unwrap(), &mut [2, 3, 4]);
1003 assert_eq
!(c
.next().unwrap(), &mut [0, 1]);
1004 assert_eq
!(c
.next(), None
);
1008 fn test_rchunks_mut_next_back() {
1009 let mut v
= [0, 1, 2, 3, 4, 5];
1010 let mut c
= v
.rchunks_mut(2);
1011 assert_eq
!(c
.next_back().unwrap(), &mut [0, 1]);
1012 assert_eq
!(c
.next_back().unwrap(), &mut [2, 3]);
1013 assert_eq
!(c
.next_back().unwrap(), &mut [4, 5]);
1014 assert_eq
!(c
.next_back(), None
);
1016 let mut v
= [0, 1, 2, 3, 4, 5, 6, 7];
1017 let mut c
= v
.rchunks_mut(3);
1018 assert_eq
!(c
.next_back().unwrap(), &mut [0, 1]);
1019 assert_eq
!(c
.next_back().unwrap(), &mut [2, 3, 4]);
1020 assert_eq
!(c
.next_back().unwrap(), &mut [5, 6, 7]);
1021 assert_eq
!(c
.next_back(), None
);
1025 fn test_rchunks_mut_last() {
1026 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1027 let c
= v
.rchunks_mut(2);
1028 assert_eq
!(c
.last().unwrap(), &[0, 1]);
1030 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
1031 let c2
= v2
.rchunks_mut(2);
1032 assert_eq
!(c2
.last().unwrap(), &[0]);
1036 fn test_rchunks_mut_zip() {
1037 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
1038 let v2
: &[i32] = &[6, 7, 8, 9, 10];
1040 for (a
, b
) in v1
.rchunks_mut(2).zip(v2
.rchunks(2)) {
1041 let sum
= b
.iter().sum
::<i32>();
1046 assert_eq
!(v1
, [6, 16, 17, 22, 23]);
1050 fn test_rchunks_exact_count() {
1051 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1052 let c
= v
.rchunks_exact(3);
1053 assert_eq
!(c
.count(), 2);
1055 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1056 let c2
= v2
.rchunks_exact(2);
1057 assert_eq
!(c2
.count(), 2);
1059 let v3
: &[i32] = &[];
1060 let c3
= v3
.rchunks_exact(2);
1061 assert_eq
!(c3
.count(), 0);
1065 fn test_rchunks_exact_nth() {
1066 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1067 let mut c
= v
.rchunks_exact(2);
1068 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
1069 assert_eq
!(c
.next().unwrap(), &[0, 1]);
1071 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
1072 let mut c2
= v2
.rchunks_exact(3);
1073 assert_eq
!(c2
.nth(1).unwrap(), &[1, 2, 3]);
1074 assert_eq
!(c2
.next(), None
);
1078 fn test_rchunks_exact_nth_back() {
1079 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1080 let mut c
= v
.rchunks_exact(2);
1081 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
1082 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
1084 let v2
: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
1085 let mut c2
= v2
.rchunks_exact(3);
1086 assert_eq
!(c2
.nth_back(1).unwrap(), &[4, 5, 6]);
1087 assert_eq
!(c2
.next(), None
);
1091 fn test_rchunks_exact_last() {
1092 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1093 let c
= v
.rchunks_exact(2);
1094 assert_eq
!(c
.last().unwrap(), &[0, 1]);
1096 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1097 let c2
= v2
.rchunks_exact(2);
1098 assert_eq
!(c2
.last().unwrap(), &[1, 2]);
1102 fn test_rchunks_exact_remainder() {
1103 let v
: &[i32] = &[0, 1, 2, 3, 4];
1104 let c
= v
.rchunks_exact(2);
1105 assert_eq
!(c
.remainder(), &[0]);
1109 fn test_rchunks_exact_zip() {
1110 let v1
: &[i32] = &[0, 1, 2, 3, 4];
1111 let v2
: &[i32] = &[6, 7, 8, 9, 10];
1115 .zip(v2
.rchunks_exact(2))
1116 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
1117 .collect
::<Vec
<_
>>();
1118 assert_eq
!(res
, vec
![26, 18]);
1122 fn test_rchunks_exact_mut_count() {
1123 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1124 let c
= v
.rchunks_exact_mut(3);
1125 assert_eq
!(c
.count(), 2);
1127 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
1128 let c2
= v2
.rchunks_exact_mut(2);
1129 assert_eq
!(c2
.count(), 2);
1131 let v3
: &mut [i32] = &mut [];
1132 let c3
= v3
.rchunks_exact_mut(2);
1133 assert_eq
!(c3
.count(), 0);
1137 fn test_rchunks_exact_mut_nth() {
1138 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1139 let mut c
= v
.rchunks_exact_mut(2);
1140 assert_eq
!(c
.nth(1).unwrap(), &[2, 3]);
1141 assert_eq
!(c
.next().unwrap(), &[0, 1]);
1143 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1144 let mut c2
= v2
.rchunks_exact_mut(3);
1145 assert_eq
!(c2
.nth(1).unwrap(), &[1, 2, 3]);
1146 assert_eq
!(c2
.next(), None
);
1150 fn test_rchunks_exact_mut_nth_back() {
1151 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1152 let mut c
= v
.rchunks_exact_mut(2);
1153 assert_eq
!(c
.nth_back(1).unwrap(), &[2, 3]);
1154 assert_eq
!(c
.next_back().unwrap(), &[4, 5]);
1156 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
1157 let mut c2
= v2
.rchunks_exact_mut(3);
1158 assert_eq
!(c2
.nth_back(1).unwrap(), &[4, 5, 6]);
1159 assert_eq
!(c2
.next(), None
);
1163 fn test_rchunks_exact_mut_last() {
1164 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
1165 let c
= v
.rchunks_exact_mut(2);
1166 assert_eq
!(c
.last().unwrap(), &[0, 1]);
1168 let v2
: &mut [i32] = &mut [0, 1, 2, 3, 4];
1169 let c2
= v2
.rchunks_exact_mut(2);
1170 assert_eq
!(c2
.last().unwrap(), &[1, 2]);
1174 fn test_rchunks_exact_mut_remainder() {
1175 let v
: &mut [i32] = &mut [0, 1, 2, 3, 4];
1176 let c
= v
.rchunks_exact_mut(2);
1177 assert_eq
!(c
.into_remainder(), &[0]);
1181 fn test_rchunks_exact_mut_zip() {
1182 let v1
: &mut [i32] = &mut [0, 1, 2, 3, 4];
1183 let v2
: &[i32] = &[6, 7, 8, 9, 10];
1185 for (a
, b
) in v1
.rchunks_exact_mut(2).zip(v2
.rchunks_exact(2)) {
1186 let sum
= b
.iter().sum
::<i32>();
1191 assert_eq
!(v1
, [0, 16, 17, 22, 23]);
1195 fn chunks_mut_are_send_and_sync() {
1196 use std
::cell
::Cell
;
1197 use std
::slice
::{ChunksExactMut, ChunksMut, RChunksExactMut, RChunksMut}
;
1198 use std
::sync
::MutexGuard
;
1200 fn assert_send_and_sync()
1202 ChunksMut
<'
static, Cell
<i32>>: Send
,
1203 ChunksMut
<'
static, MutexGuard
<'
static, u32>>: Sync
,
1204 ChunksExactMut
<'
static, Cell
<i32>>: Send
,
1205 ChunksExactMut
<'
static, MutexGuard
<'
static, u32>>: Sync
,
1206 RChunksMut
<'
static, Cell
<i32>>: Send
,
1207 RChunksMut
<'
static, MutexGuard
<'
static, u32>>: Sync
,
1208 RChunksExactMut
<'
static, Cell
<i32>>: Send
,
1209 RChunksExactMut
<'
static, MutexGuard
<'
static, u32>>: Sync
,
1213 assert_send_and_sync();
1217 fn test_windows_count() {
1218 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1219 let c
= v
.windows(3);
1220 assert_eq
!(c
.count(), 4);
1222 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1223 let c2
= v2
.windows(6);
1224 assert_eq
!(c2
.count(), 0);
1226 let v3
: &[i32] = &[];
1227 let c3
= v3
.windows(2);
1228 assert_eq
!(c3
.count(), 0);
1230 let v4
= &[(); usize::MAX
];
1231 let c4
= v4
.windows(1);
1232 assert_eq
!(c4
.count(), usize::MAX
);
1236 fn test_windows_nth() {
1237 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1238 let mut c
= v
.windows(2);
1239 assert_eq
!(c
.nth(2).unwrap()[1], 3);
1240 assert_eq
!(c
.next().unwrap()[0], 3);
1242 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1243 let mut c2
= v2
.windows(4);
1244 assert_eq
!(c2
.nth(1).unwrap()[1], 2);
1245 assert_eq
!(c2
.next(), None
);
1249 fn test_windows_nth_back() {
1250 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1251 let mut c
= v
.windows(2);
1252 assert_eq
!(c
.nth_back(2).unwrap()[0], 2);
1253 assert_eq
!(c
.next_back().unwrap()[1], 2);
1255 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1256 let mut c2
= v2
.windows(4);
1257 assert_eq
!(c2
.nth_back(1).unwrap()[1], 1);
1258 assert_eq
!(c2
.next_back(), None
);
1262 fn test_windows_last() {
1263 let v
: &[i32] = &[0, 1, 2, 3, 4, 5];
1264 let c
= v
.windows(2);
1265 assert_eq
!(c
.last().unwrap()[1], 5);
1267 let v2
: &[i32] = &[0, 1, 2, 3, 4];
1268 let c2
= v2
.windows(2);
1269 assert_eq
!(c2
.last().unwrap()[0], 3);
1273 fn test_windows_zip() {
1274 let v1
: &[i32] = &[0, 1, 2, 3, 4];
1275 let v2
: &[i32] = &[6, 7, 8, 9, 10];
1280 .map(|(a
, b
)| a
.iter().sum
::<i32>() + b
.iter().sum
::<i32>())
1281 .collect
::<Vec
<_
>>();
1283 assert_eq
!(res
, [14, 18, 22, 26]);
1288 fn test_iter_ref_consistency() {
1289 use std
::fmt
::Debug
;
1291 fn test
<T
: Copy
+ Debug
+ PartialEq
>(x
: T
) {
1292 let v
: &[T
] = &[x
, x
, x
];
1293 let v_ptrs
: [*const T
; 3] = match v
{
1294 [ref v1
, ref v2
, ref v3
] => [v1
as *const _
, v2
as *const _
, v3
as *const _
],
1295 _
=> unreachable
!(),
1301 assert_eq
!(&v
[i
] as *const _
, v_ptrs
[i
]); // check the v_ptrs array, just to be sure
1302 let nth
= v
.iter().nth(i
).unwrap();
1303 assert_eq
!(nth
as *const _
, v_ptrs
[i
]);
1305 assert_eq
!(v
.iter().nth(len
), None
, "nth(len) should return None");
1307 // stepping through with nth(0)
1309 let mut it
= v
.iter();
1311 let next
= it
.nth(0).unwrap();
1312 assert_eq
!(next
as *const _
, v_ptrs
[i
]);
1314 assert_eq
!(it
.nth(0), None
);
1319 let mut it
= v
.iter();
1321 let remaining
= len
- i
;
1322 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1324 let next
= it
.next().unwrap();
1325 assert_eq
!(next
as *const _
, v_ptrs
[i
]);
1327 assert_eq
!(it
.size_hint(), (0, Some(0)));
1328 assert_eq
!(it
.next(), None
, "The final call to next() should return None");
1333 let mut it
= v
.iter();
1335 let remaining
= len
- i
;
1336 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1338 let prev
= it
.next_back().unwrap();
1339 assert_eq
!(prev
as *const _
, v_ptrs
[remaining
- 1]);
1341 assert_eq
!(it
.size_hint(), (0, Some(0)));
1342 assert_eq
!(it
.next_back(), None
, "The final call to next_back() should return None");
1346 fn test_mut
<T
: Copy
+ Debug
+ PartialEq
>(x
: T
) {
1347 let v
: &mut [T
] = &mut [x
, x
, x
];
1348 let v_ptrs
: [*mut T
; 3] = match v
{
1349 [ref v1
, ref v2
, ref v3
] => {
1350 [v1
as *const _
as *mut _
, v2
as *const _
as *mut _
, v3
as *const _
as *mut _
]
1352 _
=> unreachable
!(),
1358 assert_eq
!(&mut v
[i
] as *mut _
, v_ptrs
[i
]); // check the v_ptrs array, just to be sure
1359 let nth
= v
.iter_mut().nth(i
).unwrap();
1360 assert_eq
!(nth
as *mut _
, v_ptrs
[i
]);
1362 assert_eq
!(v
.iter().nth(len
), None
, "nth(len) should return None");
1364 // stepping through with nth(0)
1366 let mut it
= v
.iter();
1368 let next
= it
.nth(0).unwrap();
1369 assert_eq
!(next
as *const _
, v_ptrs
[i
]);
1371 assert_eq
!(it
.nth(0), None
);
1376 let mut it
= v
.iter_mut();
1378 let remaining
= len
- i
;
1379 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1381 let next
= it
.next().unwrap();
1382 assert_eq
!(next
as *mut _
, v_ptrs
[i
]);
1384 assert_eq
!(it
.size_hint(), (0, Some(0)));
1385 assert_eq
!(it
.next(), None
, "The final call to next() should return None");
1390 let mut it
= v
.iter_mut();
1392 let remaining
= len
- i
;
1393 assert_eq
!(it
.size_hint(), (remaining
, Some(remaining
)));
1395 let prev
= it
.next_back().unwrap();
1396 assert_eq
!(prev
as *mut _
, v_ptrs
[remaining
- 1]);
1398 assert_eq
!(it
.size_hint(), (0, Some(0)));
1399 assert_eq
!(it
.next_back(), None
, "The final call to next_back() should return None");
1403 // Make sure iterators and slice patterns yield consistent addresses for various types,
1407 test([0u32; 0]); // ZST with alignment > 0
1410 test_mut([0u32; 0]); // ZST with alignment > 0
1413 // The current implementation of SliceIndex fails to handle methods
1414 // orthogonally from range types; therefore, it is worth testing
1415 // all of the indexing operations on each input.
1417 // This checks all six indexing methods, given an input range that
1418 // should succeed. (it is NOT suitable for testing invalid inputs)
1419 macro_rules
! assert_range_eq
{
1420 ($arr
:expr
, $range
:expr
, $expected
:expr
) => {
1422 let mut expected
= $expected
;
1425 let expected
: &[_
] = &expected
;
1427 assert_eq
!(&s
[$range
], expected
, "(in assertion for: index)");
1428 assert_eq
!(s
.get($range
), Some(expected
), "(in assertion for: get)");
1431 s
.get_unchecked($range
),
1433 "(in assertion for: get_unchecked)",
1438 let s
: &mut [_
] = &mut arr
;
1439 let expected
: &mut [_
] = &mut expected
;
1441 assert_eq
!(&mut s
[$range
], expected
, "(in assertion for: index_mut)",);
1444 Some(&mut expected
[..]),
1445 "(in assertion for: get_mut)",
1449 s
.get_unchecked_mut($range
),
1451 "(in assertion for: get_unchecked_mut)",
1458 // Make sure the macro can actually detect bugs,
1459 // because if it can't, then what are we even doing here?
1461 // (Be aware this only demonstrates the ability to detect bugs
1462 // in the FIRST method that panics, as the macro is not designed
1463 // to be used in `should_panic`)
1465 #[should_panic(expected = "out of range")]
1466 fn assert_range_eq_can_fail_by_panic() {
1467 assert_range_eq
!([0, 1, 2], 0..5, [0, 1, 2]);
1470 // (Be aware this only demonstrates the ability to detect bugs
1471 // in the FIRST method it calls, as the macro is not designed
1472 // to be used in `should_panic`)
1474 #[should_panic(expected = "==")]
1475 fn assert_range_eq_can_fail_by_inequality() {
1476 assert_range_eq
!([0, 1, 2], 0..2, [0, 1, 2]);
1479 // Test cases for bad index operations.
1481 // This generates `should_panic` test cases for Index/IndexMut
1482 // and `None` test cases for get/get_mut.
1483 macro_rules
! panic_cases
{
1485 // each test case needs a unique name to namespace the tests
1486 in mod $case_name
:ident
{
1491 // one or more similar inputs for which data[input] succeeds,
1492 // and the corresponding output as an array. This helps validate
1493 // "critical points" where an input range straddles the boundary
1494 // between valid and invalid.
1495 // (such as the input `len..len`, which is just barely valid)
1497 good
: data
[$good
:expr
] == $output
:expr
;
1500 bad
: data
[$bad
:expr
];
1501 message
: $expect_msg
:expr
;
1505 #[allow(unused_imports)]
1506 use core
::ops
::Bound
;
1512 $
( assert_range_eq
!($data
, $good
, $output
); )*
1516 assert_eq
!(v
.get($bad
), None
, "(in None assertion for get)");
1520 let v
: &mut [_
] = &mut v
;
1521 assert_eq
!(v
.get_mut($bad
), None
, "(in None assertion for get_mut)");
1526 #[should_panic(expected = $expect_msg)]
1534 #[should_panic(expected = $expect_msg)]
1535 fn index_mut_fail() {
1537 let v
: &mut [_
] = &mut v
;
1538 let _v
= &mut v
[$bad
];
1546 let v
= [0, 1, 2, 3, 4, 5];
1548 assert_range_eq
!(v
, .., [0, 1, 2, 3, 4, 5]);
1549 assert_range_eq
!(v
, ..2, [0, 1]);
1550 assert_range_eq
!(v
, ..=1, [0, 1]);
1551 assert_range_eq
!(v
, 2.., [2, 3, 4, 5]);
1552 assert_range_eq
!(v
, 1..4, [1, 2, 3]);
1553 assert_range_eq
!(v
, 1..=3, [1, 2, 3]);
1557 in mod rangefrom_len
{
1558 data
: [0, 1, 2, 3, 4, 5];
1560 good
: data
[6..] == [];
1562 message
: "out of range";
1565 in mod rangeto_len
{
1566 data
: [0, 1, 2, 3, 4, 5];
1568 good
: data
[..6] == [0, 1, 2, 3, 4, 5];
1570 message
: "out of range";
1573 in mod rangetoinclusive_len
{
1574 data
: [0, 1, 2, 3, 4, 5];
1576 good
: data
[..=5] == [0, 1, 2, 3, 4, 5];
1578 message
: "out of range";
1581 in mod rangeinclusive_len
{
1582 data
: [0, 1, 2, 3, 4, 5];
1584 good
: data
[0..=5] == [0, 1, 2, 3, 4, 5];
1586 message
: "out of range";
1589 in mod range_len_len
{
1590 data
: [0, 1, 2, 3, 4, 5];
1592 good
: data
[6..6] == [];
1594 message
: "out of range";
1597 in mod rangeinclusive_len_len
{
1598 data
: [0, 1, 2, 3, 4, 5];
1600 good
: data
[6..=5] == [];
1602 message
: "out of range";
1605 in mod boundpair_len
{
1606 data
: [0, 1, 2, 3, 4, 5];
1608 good
: data
[(Bound
::Included(6), Bound
::Unbounded
)] == [];
1609 good
: data
[(Bound
::Unbounded
, Bound
::Included(5))] == [0, 1, 2, 3, 4, 5];
1610 good
: data
[(Bound
::Unbounded
, Bound
::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1611 good
: data
[(Bound
::Included(0), Bound
::Included(5))] == [0, 1, 2, 3, 4, 5];
1612 good
: data
[(Bound
::Included(0), Bound
::Excluded(6))] == [0, 1, 2, 3, 4, 5];
1613 good
: data
[(Bound
::Included(2), Bound
::Excluded(4))] == [2, 3];
1614 good
: data
[(Bound
::Excluded(1), Bound
::Included(4))] == [2, 3, 4];
1615 good
: data
[(Bound
::Excluded(5), Bound
::Excluded(6))] == [];
1616 good
: data
[(Bound
::Included(6), Bound
::Excluded(6))] == [];
1617 good
: data
[(Bound
::Excluded(5), Bound
::Included(5))] == [];
1618 good
: data
[(Bound
::Included(6), Bound
::Included(5))] == [];
1619 bad
: data
[(Bound
::Unbounded
, Bound
::Included(6))];
1620 message
: "out of range";
1625 in mod rangeinclusive_exhausted
{
1626 data
: [0, 1, 2, 3, 4, 5];
1628 good
: data
[0..=5] == [0, 1, 2, 3, 4, 5];
1630 let mut iter
= 0..=5;
1631 iter
.by_ref().count(); // exhaust it
1635 // 0..=6 is out of range before exhaustion, so it
1636 // stands to reason that it still would be after.
1638 let mut iter
= 0..=6;
1639 iter
.by_ref().count(); // exhaust it
1642 message
: "out of range";
1647 in mod range_neg_width
{
1648 data
: [0, 1, 2, 3, 4, 5];
1650 good
: data
[4..4] == [];
1652 message
: "but ends at";
1655 in mod rangeinclusive_neg_width
{
1656 data
: [0, 1, 2, 3, 4, 5];
1658 good
: data
[4..=3] == [];
1660 message
: "but ends at";
1663 in mod boundpair_neg_width
{
1664 data
: [0, 1, 2, 3, 4, 5];
1666 good
: data
[(Bound
::Included(4), Bound
::Excluded(4))] == [];
1667 bad
: data
[(Bound
::Included(4), Bound
::Excluded(3))];
1668 message
: "but ends at";
1673 in mod rangeinclusive_overflow
{
1676 // note: using 0 specifically ensures that the result of overflowing is 0..0,
1677 // so that `get` doesn't simply return None for the wrong reason.
1678 bad
: data
[0 ..= usize::MAX
];
1679 message
: "maximum usize";
1682 in mod rangetoinclusive_overflow
{
1685 bad
: data
[..= usize::MAX
];
1686 message
: "maximum usize";
1689 in mod boundpair_overflow_end
{
1692 bad
: data
[(Bound
::Unbounded
, Bound
::Included(usize::MAX
))];
1693 message
: "maximum usize";
1696 in mod boundpair_overflow_start
{
1699 bad
: data
[(Bound
::Excluded(usize::MAX
), Bound
::Unbounded
)];
1700 message
: "maximum usize";
1706 fn test_find_rfind() {
1707 let v
= [0, 1, 2, 3, 4, 5];
1708 let mut iter
= v
.iter();
1709 let mut i
= v
.len();
1710 while let Some(&elt
) = iter
.rfind(|_
| true) {
1712 assert_eq
!(elt
, v
[i
]);
1715 assert_eq
!(v
.iter().rfind(|&&x
| x
<= 3), Some(&3));
1719 fn test_iter_folds() {
1720 let a
= [1, 2, 3, 4, 5]; // len>4 so the unroll is used
1721 assert_eq
!(a
.iter().fold(0, |acc
, &x
| 2 * acc
+ x
), 57);
1722 assert_eq
!(a
.iter().rfold(0, |acc
, &x
| 2 * acc
+ x
), 129);
1723 let fold
= |acc
: i32, &x
| acc
.checked_mul(2)?
.checked_add(x
);
1724 assert_eq
!(a
.iter().try_fold(0, &fold
), Some(57));
1725 assert_eq
!(a
.iter().try_rfold(0, &fold
), Some(129));
1727 // short-circuiting try_fold, through other methods
1728 let a
= [0, 1, 2, 3, 5, 5, 5, 7, 8, 9];
1729 let mut iter
= a
.iter();
1730 assert_eq
!(iter
.position(|&x
| x
== 3), Some(3));
1731 assert_eq
!(iter
.rfind(|&&x
| x
== 5), Some(&5));
1732 assert_eq
!(iter
.len(), 2);
1736 fn test_rotate_left() {
1737 const N
: usize = 600;
1738 let a
: &mut [_
] = &mut [0; N
];
1747 assert_eq
!(a
[(i
+ k
) % N
], i
);
1752 fn test_rotate_right() {
1753 const N
: usize = 600;
1754 let a
: &mut [_
] = &mut [0; N
];
1762 assert_eq
!(a
[(i
+ 42) % N
], i
);
1767 #[cfg_attr(miri, ignore)] // Miri is too slow
1768 fn brute_force_rotate_test_0() {
1769 // In case of edge cases involving multiple algorithms
1773 let mut v
= Vec
::with_capacity(len
);
1777 v
[..].rotate_right(s
);
1778 for i
in 0..v
.len() {
1779 assert_eq
!(v
[i
], v
.len().wrapping_add(i
.wrapping_sub(s
)) % v
.len());
1786 fn brute_force_rotate_test_1() {
1787 // `ptr_rotate` covers so many kinds of pointer usage, that this is just a good test for
1788 // pointers in general. This uses a `[usize; 4]` to hit all algorithms without overwhelming miri
1792 let mut v
: Vec
<[usize; 4]> = Vec
::with_capacity(len
);
1794 v
.push([i
, 0, 0, 0]);
1796 v
[..].rotate_right(s
);
1797 for i
in 0..v
.len() {
1798 assert_eq
!(v
[i
][0], v
.len().wrapping_add(i
.wrapping_sub(s
)) % v
.len());
1805 #[cfg(not(target_arch = "wasm32"))]
1806 fn sort_unstable() {
1807 use core
::cmp
::Ordering
::{Equal, Greater, Less}
;
1808 use core
::slice
::heapsort
;
1809 use rand
::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng}
;
1811 // Miri is too slow (but still need to `chain` to make the types match)
1812 let lens
= if cfg
!(miri
) { (2..20).chain(0..0) }
else { (2..25).chain(500..510) }
;
1813 let rounds
= if cfg
!(miri
) { 1 }
else { 100 }
;
1815 let mut v
= [0; 600];
1816 let mut tmp
= [0; 600];
1817 let mut rng
= StdRng
::from_entropy();
1820 let v
= &mut v
[0..len
];
1821 let tmp
= &mut tmp
[0..len
];
1823 for &modulus
in &[5, 10, 100, 1000] {
1824 for _
in 0..rounds
{
1826 v
[i
] = rng
.gen
::<i32>() % modulus
;
1829 // Sort in default order.
1830 tmp
.copy_from_slice(v
);
1831 tmp
.sort_unstable();
1832 assert
!(tmp
.windows(2).all(|w
| w
[0] <= w
[1]));
1834 // Sort in ascending order.
1835 tmp
.copy_from_slice(v
);
1836 tmp
.sort_unstable_by(|a
, b
| a
.cmp(b
));
1837 assert
!(tmp
.windows(2).all(|w
| w
[0] <= w
[1]));
1839 // Sort in descending order.
1840 tmp
.copy_from_slice(v
);
1841 tmp
.sort_unstable_by(|a
, b
| b
.cmp(a
));
1842 assert
!(tmp
.windows(2).all(|w
| w
[0] >= w
[1]));
1844 // Test heapsort using `<` operator.
1845 tmp
.copy_from_slice(v
);
1846 heapsort(tmp
, |a
, b
| a
< b
);
1847 assert
!(tmp
.windows(2).all(|w
| w
[0] <= w
[1]));
1849 // Test heapsort using `>` operator.
1850 tmp
.copy_from_slice(v
);
1851 heapsort(tmp
, |a
, b
| a
> b
);
1852 assert
!(tmp
.windows(2).all(|w
| w
[0] >= w
[1]));
1857 // Sort using a completely random comparison function.
1858 // This will reorder the elements *somehow*, but won't panic.
1859 for i
in 0..v
.len() {
1862 v
.sort_unstable_by(|_
, _
| *[Less
, Equal
, Greater
].choose(&mut rng
).unwrap());
1864 for i
in 0..v
.len() {
1865 assert_eq
!(v
[i
], i
as i32);
1868 // Should not panic.
1869 [0i32; 0].sort_unstable();
1870 [(); 10].sort_unstable();
1871 [(); 100].sort_unstable();
1873 let mut v
= [0xDEADBEEFu64];
1875 assert
!(v
== [0xDEADBEEF]);
1879 #[cfg(not(target_arch = "wasm32"))]
1880 #[cfg_attr(miri, ignore)] // Miri is too slow
1881 fn select_nth_unstable() {
1882 use core
::cmp
::Ordering
::{Equal, Greater, Less}
;
1883 use rand
::rngs
::StdRng
;
1884 use rand
::seq
::SliceRandom
;
1885 use rand
::{Rng, SeedableRng}
;
1887 let mut rng
= StdRng
::from_entropy();
1889 for len
in (2..21).chain(500..501) {
1890 let mut orig
= vec
![0; len
];
1892 for &modulus
in &[5, 10, 1000] {
1895 orig
[i
] = rng
.gen
::<i32>() % modulus
;
1899 let mut v
= orig
.clone();
1904 // Sort in default order.
1905 for pivot
in 0..len
{
1906 let mut v
= orig
.clone();
1907 v
.select_nth_unstable(pivot
);
1909 assert_eq
!(v_sorted
[pivot
], v
[pivot
]);
1911 for j
in pivot
..len
{
1912 assert
!(v
[i
] <= v
[j
]);
1917 // Sort in ascending order.
1918 for pivot
in 0..len
{
1919 let mut v
= orig
.clone();
1920 let (left
, pivot
, right
) = v
.select_nth_unstable_by(pivot
, |a
, b
| a
.cmp(b
));
1922 assert_eq
!(left
.len() + right
.len(), len
- 1);
1925 assert
!(l
<= pivot
);
1926 for r
in right
.iter_mut() {
1928 assert
!(pivot
<= r
);
1933 // Sort in descending order.
1934 let sort_descending_comparator
= |a
: &i32, b
: &i32| b
.cmp(a
);
1935 let v_sorted_descending
= {
1936 let mut v
= orig
.clone();
1937 v
.sort_by(sort_descending_comparator
);
1941 for pivot
in 0..len
{
1942 let mut v
= orig
.clone();
1943 v
.select_nth_unstable_by(pivot
, sort_descending_comparator
);
1945 assert_eq
!(v_sorted_descending
[pivot
], v
[pivot
]);
1947 for j
in pivot
..len
{
1948 assert
!(v
[j
] <= v
[i
]);
1956 // Sort at index using a completely random comparison function.
1957 // This will reorder the elements *somehow*, but won't panic.
1958 let mut v
= [0; 500];
1959 for i
in 0..v
.len() {
1963 for pivot
in 0..v
.len() {
1964 v
.select_nth_unstable_by(pivot
, |_
, _
| *[Less
, Equal
, Greater
].choose(&mut rng
).unwrap());
1966 for i
in 0..v
.len() {
1967 assert_eq
!(v
[i
], i
as i32);
1971 // Should not panic.
1972 [(); 10].select_nth_unstable(0);
1973 [(); 10].select_nth_unstable(5);
1974 [(); 10].select_nth_unstable(9);
1975 [(); 100].select_nth_unstable(0);
1976 [(); 100].select_nth_unstable(50);
1977 [(); 100].select_nth_unstable(99);
1979 let mut v
= [0xDEADBEEFu64];
1980 v
.select_nth_unstable(0);
1981 assert
!(v
== [0xDEADBEEF]);
1985 #[should_panic(expected = "index 0 greater than length of slice")]
1986 fn select_nth_unstable_zero_length() {
1987 [0i32; 0].select_nth_unstable(0);
1991 #[should_panic(expected = "index 20 greater than length of slice")]
1992 fn select_nth_unstable_past_length() {
1993 [0i32; 10].select_nth_unstable(20);
1997 use core
::slice
::memchr
::{memchr, memrchr}
;
1999 // test fallback implementations on all platforms
2002 assert_eq
!(Some(0), memchr(b'a'
, b
"a"));
2006 fn matches_begin() {
2007 assert_eq
!(Some(0), memchr(b'a'
, b
"aaaa"));
2012 assert_eq
!(Some(4), memchr(b'z'
, b
"aaaaz"));
2017 assert_eq
!(Some(4), memchr(b'
\x00'
, b
"aaaa\x00"));
2021 fn matches_past_nul() {
2022 assert_eq
!(Some(5), memchr(b'z'
, b
"aaaa\x00z"));
2026 fn no_match_empty() {
2027 assert_eq
!(None
, memchr(b'a'
, b
""));
2032 assert_eq
!(None
, memchr(b'a'
, b
"xyz"));
2036 fn matches_one_reversed() {
2037 assert_eq
!(Some(0), memrchr(b'a'
, b
"a"));
2041 fn matches_begin_reversed() {
2042 assert_eq
!(Some(3), memrchr(b'a'
, b
"aaaa"));
2046 fn matches_end_reversed() {
2047 assert_eq
!(Some(0), memrchr(b'z'
, b
"zaaaa"));
2051 fn matches_nul_reversed() {
2052 assert_eq
!(Some(4), memrchr(b'
\x00'
, b
"aaaa\x00"));
2056 fn matches_past_nul_reversed() {
2057 assert_eq
!(Some(0), memrchr(b'z'
, b
"z\x00aaaa"));
2061 fn no_match_empty_reversed() {
2062 assert_eq
!(None
, memrchr(b'a'
, b
""));
2066 fn no_match_reversed() {
2067 assert_eq
!(None
, memrchr(b'a'
, b
"xyz"));
2071 fn each_alignment_reversed() {
2072 let mut data
= [1u8; 64];
2076 for start
in 0..16 {
2077 assert_eq
!(Some(pos
- start
), memrchr(needle
, &data
[start
..]));
2083 fn test_align_to_simple() {
2084 let bytes
= [1u8, 2, 3, 4, 5, 6, 7];
2085 let (prefix
, aligned
, suffix
) = unsafe { bytes.align_to::<u16>() }
;
2086 assert_eq
!(aligned
.len(), 3);
2087 assert
!(prefix
== [1] || suffix
== [7]);
2088 let expect1
= [1 << 8 | 2, 3 << 8 | 4, 5 << 8 | 6];
2089 let expect2
= [1 | 2 << 8, 3 | 4 << 8, 5 | 6 << 8];
2090 let expect3
= [2 << 8 | 3, 4 << 8 | 5, 6 << 8 | 7];
2091 let expect4
= [2 | 3 << 8, 4 | 5 << 8, 6 | 7 << 8];
2093 aligned
== expect1
|| aligned
== expect2
|| aligned
== expect3
|| aligned
== expect4
,
2094 "aligned={:?} expected={:?} || {:?} || {:?} || {:?}",
2104 fn test_align_to_zst() {
2105 let bytes
= [1, 2, 3, 4, 5, 6, 7];
2106 let (prefix
, aligned
, suffix
) = unsafe { bytes.align_to::<()>() }
;
2107 assert_eq
!(aligned
.len(), 0);
2108 assert
!(prefix
== [1, 2, 3, 4, 5, 6, 7] || suffix
== [1, 2, 3, 4, 5, 6, 7]);
2112 fn test_align_to_non_trivial() {
2114 struct U64(u64, u64);
2116 struct U64U64U32(u64, u64, u32);
2127 let (prefix
, aligned
, suffix
) = unsafe { data.align_to::<U64U64U32>() }
;
2128 assert_eq
!(aligned
.len(), 4);
2129 assert_eq
!(prefix
.len() + suffix
.len(), 2);
2133 fn test_align_to_empty_mid() {
2136 // Make sure that we do not create empty unaligned slices for the mid part, even when the
2137 // overall slice is too short to contain an aligned address.
2138 let bytes
= [1, 2, 3, 4, 5, 6, 7];
2140 for offset
in 0..4 {
2141 let (_
, mid
, _
) = unsafe { bytes[offset..offset + 1].align_to::<Chunk>() }
;
2142 assert_eq
!(mid
.as_ptr() as usize % mem
::align_of
::<Chunk
>(), 0);
2147 fn test_align_to_mut_aliasing() {
2148 let mut val
= [1u8, 2, 3, 4, 5];
2149 // `align_to_mut` used to create `mid` in a way that there was some intermediate
2150 // incorrect aliasing, invalidating the resulting `mid` slice.
2151 let (begin
, mid
, end
) = unsafe { val.align_to_mut::<[u8; 2]>() }
;
2152 assert
!(begin
.len() == 0);
2153 assert
!(end
.len() == 1);
2155 assert_eq
!(val
, [3, 4, 3, 4, 5])
2159 fn test_slice_partition_dedup_by() {
2160 let mut slice
: [i32; 9] = [1, -1, 2, 3, 1, -5, 5, -2, 2];
2162 let (dedup
, duplicates
) = slice
.partition_dedup_by(|a
, b
| a
.abs() == b
.abs());
2164 assert_eq
!(dedup
, [1, 2, 3, 1, -5, -2]);
2165 assert_eq
!(duplicates
, [5, -1, 2]);
2169 fn test_slice_partition_dedup_empty() {
2170 let mut slice
: [i32; 0] = [];
2172 let (dedup
, duplicates
) = slice
.partition_dedup();
2174 assert_eq
!(dedup
, []);
2175 assert_eq
!(duplicates
, []);
2179 fn test_slice_partition_dedup_one() {
2180 let mut slice
= [12];
2182 let (dedup
, duplicates
) = slice
.partition_dedup();
2184 assert_eq
!(dedup
, [12]);
2185 assert_eq
!(duplicates
, []);
2189 fn test_slice_partition_dedup_multiple_ident() {
2190 let mut slice
= [12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
2192 let (dedup
, duplicates
) = slice
.partition_dedup();
2194 assert_eq
!(dedup
, [12, 11]);
2195 assert_eq
!(duplicates
, [12, 12, 12, 12, 11, 11, 11, 11, 11]);
2199 fn test_slice_partition_dedup_partialeq() {
2201 struct Foo(i32, i32);
2203 impl PartialEq
for Foo
{
2204 fn eq(&self, other
: &Foo
) -> bool
{
2209 let mut slice
= [Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
2211 let (dedup
, duplicates
) = slice
.partition_dedup();
2213 assert_eq
!(dedup
, [Foo(0, 1), Foo(1, 7)]);
2214 assert_eq
!(duplicates
, [Foo(0, 5), Foo(1, 9)]);
2218 fn test_copy_within() {
2219 // Start to end, with a RangeTo.
2220 let mut bytes
= *b
"Hello, World!";
2221 bytes
.copy_within(..3, 10);
2222 assert_eq
!(&bytes
, b
"Hello, WorHel");
2224 // End to start, with a RangeFrom.
2225 let mut bytes
= *b
"Hello, World!";
2226 bytes
.copy_within(10.., 0);
2227 assert_eq
!(&bytes
, b
"ld!lo, World!");
2229 // Overlapping, with a RangeInclusive.
2230 let mut bytes
= *b
"Hello, World!";
2231 bytes
.copy_within(0..=11, 1);
2232 assert_eq
!(&bytes
, b
"HHello, World");
2234 // Whole slice, with a RangeFull.
2235 let mut bytes
= *b
"Hello, World!";
2236 bytes
.copy_within(.., 0);
2237 assert_eq
!(&bytes
, b
"Hello, World!");
2239 // Ensure that copying at the end of slice won't cause UB.
2240 let mut bytes
= *b
"Hello, World!";
2241 bytes
.copy_within(13..13, 5);
2242 assert_eq
!(&bytes
, b
"Hello, World!");
2243 bytes
.copy_within(5..5, 13);
2244 assert_eq
!(&bytes
, b
"Hello, World!");
2248 #[should_panic(expected = "range end index 14 out of range for slice of length 13")]
2249 fn test_copy_within_panics_src_too_long() {
2250 let mut bytes
= *b
"Hello, World!";
2251 // The length is only 13, so 14 is out of bounds.
2252 bytes
.copy_within(10..14, 0);
2256 #[should_panic(expected = "dest is out of bounds")]
2257 fn test_copy_within_panics_dest_too_long() {
2258 let mut bytes
= *b
"Hello, World!";
2259 // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds.
2260 bytes
.copy_within(0..4, 10);
2264 #[should_panic(expected = "slice index starts at 2 but ends at 1")]
2265 fn test_copy_within_panics_src_inverted() {
2266 let mut bytes
= *b
"Hello, World!";
2267 // 2 is greater than 1, so this range is invalid.
2268 bytes
.copy_within(2..1, 0);
2271 #[should_panic(expected = "attempted to index slice up to maximum usize")]
2272 fn test_copy_within_panics_src_out_of_bounds() {
2273 let mut bytes
= *b
"Hello, World!";
2274 // an inclusive range ending at usize::MAX would make src_end overflow
2275 bytes
.copy_within(usize::MAX
..=usize::MAX
, 0);
2279 fn test_is_sorted() {
2280 let empty
: [i32; 0] = [];
2282 assert
!([1, 2, 2, 9].is_sorted());
2283 assert
!(![1, 3, 2].is_sorted());
2284 assert
!([0].is_sorted());
2285 assert
!(empty
.is_sorted());
2286 assert
!(![0.0, 1.0, f32::NAN
].is_sorted());
2287 assert
!([-2, -1, 0, 3].is_sorted());
2288 assert
!(![-2i32, -1, 0, 3].is_sorted_by_key(|n
| n
.abs()));
2289 assert
!(!["c", "bb", "aaa"].is_sorted());
2290 assert
!(["c", "bb", "aaa"].is_sorted_by_key(|s
| s
.len()));
2294 fn test_slice_run_destructors() {
2295 // Make sure that destructors get run on slice literals
2300 impl<'a
> Drop
for Foo
<'a
> {
2301 fn drop(&mut self) {
2302 self.x
.set(self.x
.get() + 1);
2306 fn foo(x
: &Cell
<isize>) -> Foo
<'_
> {
2310 let x
= &Cell
::new(0);
2314 assert_eq
!(l
[0].x
.get(), 0);
2317 assert_eq
!(x
.get(), 1);
2321 fn test_const_from_ref() {
2322 const VALUE
: &i32 = &1;
2323 const SLICE
: &[i32] = core
::slice
::from_ref(VALUE
);
2325 assert
!(core
::ptr
::eq(VALUE
, &SLICE
[0]))
2329 fn test_slice_fill_with_uninit() {
2330 // This should not UB. See #87891
2331 let mut a
= [MaybeUninit
::<u8>::uninit(); 10];
2332 a
.fill(MaybeUninit
::uninit());
2337 let mut x
= ["a", "b", "c", "d"];
2339 assert_eq
!(x
, ["a", "d", "c", "b"]);
2341 assert_eq
!(x
, ["b", "d", "c", "a"]);
2346 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2347 fn index_a_equals_len() {
2348 let mut x
= ["a", "b", "c", "d"];
2353 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 4")]
2354 fn index_b_equals_len() {
2355 let mut x
= ["a", "b", "c", "d"];
2360 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2361 fn index_a_greater_than_len() {
2362 let mut x
= ["a", "b", "c", "d"];
2367 #[should_panic(expected = "index out of bounds: the len is 4 but the index is 5")]
2368 fn index_b_greater_than_len() {
2369 let mut x
= ["a", "b", "c", "d"];
2375 fn slice_split_array_mut() {
2376 let v
= &mut [1, 2, 3, 4, 5, 6][..];
2379 let (left
, right
) = v
.split_array_mut
::<0>();
2380 assert_eq
!(left
, &mut []);
2381 assert_eq
!(right
, [1, 2, 3, 4, 5, 6]);
2385 let (left
, right
) = v
.split_array_mut
::<6>();
2386 assert_eq
!(left
, &mut [1, 2, 3, 4, 5, 6]);
2387 assert_eq
!(right
, []);
2392 fn slice_rsplit_array_mut() {
2393 let v
= &mut [1, 2, 3, 4, 5, 6][..];
2396 let (left
, right
) = v
.rsplit_array_mut
::<0>();
2397 assert_eq
!(left
, [1, 2, 3, 4, 5, 6]);
2398 assert_eq
!(right
, &mut []);
2402 let (left
, right
) = v
.rsplit_array_mut
::<6>();
2403 assert_eq
!(left
, []);
2404 assert_eq
!(right
, &mut [1, 2, 3, 4, 5, 6]);
2409 fn split_as_slice() {
2410 let arr
= [1, 2, 3, 4, 5, 6];
2411 let mut split
= arr
.split(|v
| v
% 2 == 0);
2412 assert_eq
!(split
.as_slice(), &[1, 2, 3, 4, 5, 6]);
2413 assert
!(split
.next().is_some());
2414 assert_eq
!(split
.as_slice(), &[3, 4, 5, 6]);
2415 assert
!(split
.next().is_some());
2416 assert
!(split
.next().is_some());
2417 assert_eq
!(split
.as_slice(), &[]);
2422 fn slice_split_array_ref_out_of_bounds() {
2423 let v
= &[1, 2, 3, 4, 5, 6][..];
2425 let _
= v
.split_array_ref
::<7>();
2430 fn slice_split_array_mut_out_of_bounds() {
2431 let v
= &mut [1, 2, 3, 4, 5, 6][..];
2433 let _
= v
.split_array_mut
::<7>();
2438 fn slice_rsplit_array_ref_out_of_bounds() {
2439 let v
= &[1, 2, 3, 4, 5, 6][..];
2441 let _
= v
.rsplit_array_ref
::<7>();
2446 fn slice_rsplit_array_mut_out_of_bounds() {
2447 let v
= &mut [1, 2, 3, 4, 5, 6][..];
2449 let _
= v
.rsplit_array_mut
::<7>();
2452 macro_rules
! take_tests
{
2453 (slice
: &[], $
($tts
:tt
)*) => {
2454 take_tests
!(ty
: &[()], slice
: &[], $
($tts
)*);
2456 (slice
: &mut [], $
($tts
:tt
)*) => {
2457 take_tests
!(ty
: &mut [()], slice
: &mut [], $
($tts
)*);
2459 (slice
: &$slice
:expr
, $
($tts
:tt
)*) => {
2460 take_tests
!(ty
: &[_
], slice
: &$slice
, $
($tts
)*);
2462 (slice
: &mut $slice
:expr
, $
($tts
:tt
)*) => {
2463 take_tests
!(ty
: &mut [_
], slice
: &mut $slice
, $
($tts
)*);
2465 (ty
: $ty
:ty
, slice
: $slice
:expr
, method
: $method
:ident
, $
(($test_name
:ident
, ($
($args
:expr
),*), $output
:expr
, $remaining
:expr
),)*) => {
2469 let mut slice
: $ty
= $slice
;
2470 assert_eq
!($output
, slice
.$
method($
($args
)*));
2471 let remaining
: $ty
= $remaining
;
2472 assert_eq
!(remaining
, slice
);
2479 slice
: &[0, 1, 2, 3], method
: take
,
2480 (take_in_bounds_range_to
, (..1), Some(&[0] as _
), &[1, 2, 3]),
2481 (take_in_bounds_range_to_inclusive
, (..=0), Some(&[0] as _
), &[1, 2, 3]),
2482 (take_in_bounds_range_from
, (2..), Some(&[2, 3] as _
), &[0, 1]),
2483 (take_oob_range_to
, (..5), None
, &[0, 1, 2, 3]),
2484 (take_oob_range_to_inclusive
, (..=4), None
, &[0, 1, 2, 3]),
2485 (take_oob_range_from
, (5..), None
, &[0, 1, 2, 3]),
2489 slice
: &mut [0, 1, 2, 3], method
: take_mut
,
2490 (take_mut_in_bounds_range_to
, (..1), Some(&mut [0] as _
), &mut [1, 2, 3]),
2491 (take_mut_in_bounds_range_to_inclusive
, (..=0), Some(&mut [0] as _
), &mut [1, 2, 3]),
2492 (take_mut_in_bounds_range_from
, (2..), Some(&mut [2, 3] as _
), &mut [0, 1]),
2493 (take_mut_oob_range_to
, (..5), None
, &mut [0, 1, 2, 3]),
2494 (take_mut_oob_range_to_inclusive
, (..=4), None
, &mut [0, 1, 2, 3]),
2495 (take_mut_oob_range_from
, (5..), None
, &mut [0, 1, 2, 3]),
2499 slice
: &[1, 2], method
: take_first
,
2500 (take_first_nonempty
, (), Some(&1), &[2]),
2504 slice
: &mut [1, 2], method
: take_first_mut
,
2505 (take_first_mut_nonempty
, (), Some(&mut 1), &mut [2]),
2509 slice
: &[1, 2], method
: take_last
,
2510 (take_last_nonempty
, (), Some(&2), &[1]),
2514 slice
: &mut [1, 2], method
: take_last_mut
,
2515 (take_last_mut_nonempty
, (), Some(&mut 2), &mut [1]),
2519 slice
: &[], method
: take_first
,
2520 (take_first_empty
, (), None
, &[]),
2524 slice
: &mut [], method
: take_first_mut
,
2525 (take_first_mut_empty
, (), None
, &mut []),
2529 slice
: &[], method
: take_last
,
2530 (take_last_empty
, (), None
, &[]),
2534 slice
: &mut [], method
: take_last_mut
,
2535 (take_last_mut_empty
, (), None
, &mut []),
2538 #[cfg(not(miri))] // unused in Miri
2539 const EMPTY_MAX
: &'
static [()] = &[(); usize::MAX
];
2541 // can't be a constant due to const mutability rules
2542 #[cfg(not(miri))] // unused in Miri
2543 macro_rules
! empty_max_mut
{
2545 &mut [(); usize::MAX
] as _
2549 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2551 slice
: &[(); usize::MAX
], method
: take
,
2552 (take_in_bounds_max_range_to
, (..usize::MAX
), Some(EMPTY_MAX
), &[(); 0]),
2553 (take_oob_max_range_to_inclusive
, (..=usize::MAX
), None
, EMPTY_MAX
),
2554 (take_in_bounds_max_range_from
, (usize::MAX
..), Some(&[] as _
), EMPTY_MAX
),
2557 #[cfg(not(miri))] // Comparing usize::MAX many elements takes forever in Miri (and in rustc without optimizations)
2559 slice
: &mut [(); usize::MAX
], method
: take_mut
,
2560 (take_mut_in_bounds_max_range_to
, (..usize::MAX
), Some(empty_max_mut
!()), &mut [(); 0]),
2561 (take_mut_oob_max_range_to_inclusive
, (..=usize::MAX
), None
, empty_max_mut
!()),
2562 (take_mut_in_bounds_max_range_from
, (usize::MAX
..), Some(&mut [] as _
), empty_max_mut
!()),
2566 fn test_slice_from_ptr_range() {
2567 let arr
= ["foo".to_owned(), "bar".to_owned()];
2568 let range
= arr
.as_ptr_range();
2570 assert_eq
!(slice
::from_ptr_range(range
), &arr
);
2573 let mut arr
= [1, 2, 3];
2574 let range
= arr
.as_mut_ptr_range();
2576 assert_eq
!(slice
::from_mut_ptr_range(range
), &mut [1, 2, 3]);
2579 let arr
: [Vec
<String
>; 0] = [];
2580 let range
= arr
.as_ptr_range();
2582 assert_eq
!(slice
::from_ptr_range(range
), &arr
);
2587 #[should_panic = "slice len overflow"]
2588 fn test_flatten_size_overflow() {
2589 let x
= &[[(); usize::MAX
]; 2][..];
2590 let _
= x
.flatten();
2594 #[should_panic = "slice len overflow"]
2595 fn test_flatten_mut_size_overflow() {
2596 let x
= &mut [[(); usize::MAX
]; 2][..];
2597 let _
= x
.flatten_mut();