2 use std
::cmp
::Ordering
::{self, Equal, Greater, Less}
;
3 use std
::convert
::identity
;
7 use std
::sync
::atomic
::{AtomicUsize, Ordering::Relaxed}
;
9 use rand
::distributions
::Standard
;
10 use rand
::seq
::SliceRandom
;
11 use rand
::{thread_rng, Rng, RngCore}
;
13 fn square(n
: usize) -> usize {
17 fn is_odd(n
: &usize) -> bool
{
23 // Test on-stack from_fn.
24 let mut v
: Vec
<_
> = (0..3).map(square
).collect();
27 assert_eq
!(v
.len(), 3);
33 // Test on-heap from_fn.
34 v
= (0..5).map(square
).collect();
37 assert_eq
!(v
.len(), 5);
48 // Test on-stack from_elem.
49 let mut v
= vec
![10, 10];
52 assert_eq
!(v
.len(), 2);
57 // Test on-heap from_elem.
72 let xs
: [i32; 0] = [];
73 assert
!(xs
.is_empty());
74 assert
!(![0].is_empty());
78 fn test_len_divzero() {
82 let v2
: &[Z
] = &[[], []];
83 assert_eq
!(mem
::size_of
::<Z
>(), 0);
84 assert_eq
!(v0
.len(), 0);
85 assert_eq
!(v1
.len(), 1);
86 assert_eq
!(v2
.len(), 2);
92 assert_eq
!(a
.get(1), None
);
94 assert_eq
!(a
.get(1).unwrap(), &12);
96 assert_eq
!(a
.get(1).unwrap(), &12);
102 assert_eq
!(a
.first(), None
);
104 assert_eq
!(a
.first().unwrap(), &11);
106 assert_eq
!(a
.first().unwrap(), &11);
110 fn test_first_mut() {
112 assert_eq
!(a
.first_mut(), None
);
114 assert_eq
!(*a
.first_mut().unwrap(), 11);
116 assert_eq
!(*a
.first_mut().unwrap(), 11);
120 fn test_split_first() {
121 let mut a
= vec
![11];
123 assert
!(b
.split_first().is_none());
124 assert_eq
!(a
.split_first(), Some((&11, b
)));
126 let b
: &[i32] = &[12];
127 assert_eq
!(a
.split_first(), Some((&11, b
)));
131 fn test_split_first_mut() {
132 let mut a
= vec
![11];
133 let b
: &mut [i32] = &mut [];
134 assert
!(b
.split_first_mut().is_none());
135 assert
!(a
.split_first_mut() == Some((&mut 11, b
)));
137 let b
: &mut [_
] = &mut [12];
138 assert
!(a
.split_first_mut() == Some((&mut 11, b
)));
142 fn test_split_last() {
143 let mut a
= vec
![11];
145 assert
!(b
.split_last().is_none());
146 assert_eq
!(a
.split_last(), Some((&11, b
)));
149 assert_eq
!(a
.split_last(), Some((&12, b
)));
153 fn test_split_last_mut() {
154 let mut a
= vec
![11];
155 let b
: &mut [i32] = &mut [];
156 assert
!(b
.split_last_mut().is_none());
157 assert
!(a
.split_last_mut() == Some((&mut 11, b
)));
160 let b
: &mut [_
] = &mut [11];
161 assert
!(a
.split_last_mut() == Some((&mut 12, b
)));
167 assert_eq
!(a
.last(), None
);
169 assert_eq
!(a
.last().unwrap(), &11);
171 assert_eq
!(a
.last().unwrap(), &12);
177 assert_eq
!(a
.last_mut(), None
);
179 assert_eq
!(*a
.last_mut().unwrap(), 11);
181 assert_eq
!(*a
.last_mut().unwrap(), 12);
186 // Test fixed length vector.
187 let vec_fixed
= [1, 2, 3, 4];
188 let v_a
= vec_fixed
[1..vec_fixed
.len()].to_vec();
189 assert_eq
!(v_a
.len(), 3);
191 assert_eq
!(v_a
[0], 2);
192 assert_eq
!(v_a
[1], 3);
193 assert_eq
!(v_a
[2], 4);
196 let vec_stack
: &[_
] = &[1, 2, 3];
197 let v_b
= vec_stack
[1..3].to_vec();
198 assert_eq
!(v_b
.len(), 2);
200 assert_eq
!(v_b
[0], 2);
201 assert_eq
!(v_b
[1], 3);
204 let vec_unique
= vec
![1, 2, 3, 4, 5, 6];
205 let v_d
= vec_unique
[1..6].to_vec();
206 assert_eq
!(v_d
.len(), 5);
208 assert_eq
!(v_d
[0], 2);
209 assert_eq
!(v_d
[1], 3);
210 assert_eq
!(v_d
[2], 4);
211 assert_eq
!(v_d
[3], 5);
212 assert_eq
!(v_d
[4], 6);
216 fn test_slice_from() {
217 let vec
: &[_
] = &[1, 2, 3, 4];
218 assert_eq
!(&vec
[..], vec
);
219 let b
: &[_
] = &[3, 4];
220 assert_eq
!(&vec
[2..], b
);
222 assert_eq
!(&vec
[4..], b
);
227 let vec
: &[_
] = &[1, 2, 3, 4];
228 assert_eq
!(&vec
[..4], vec
);
229 let b
: &[_
] = &[1, 2];
230 assert_eq
!(&vec
[..2], b
);
232 assert_eq
!(&vec
[..0], b
);
239 assert_eq
!(v
.len(), 0);
240 assert_eq
!(e
, Some(5));
248 fn test_swap_remove() {
249 let mut v
= vec
![1, 2, 3, 4, 5];
250 let mut e
= v
.swap_remove(0);
252 assert_eq
!(v
, [5, 2, 3, 4]);
253 e
= v
.swap_remove(3);
255 assert_eq
!(v
, [5, 2, 3]);
260 fn test_swap_remove_fail() {
262 let _
= v
.swap_remove(0);
263 let _
= v
.swap_remove(0);
267 fn test_swap_remove_noncopyable() {
268 // Tests that we don't accidentally run destructors twice.
269 let mut v
: Vec
<Box
<_
>> = Vec
::new();
273 let mut _e
= v
.swap_remove(0);
274 assert_eq
!(v
.len(), 2);
275 _e
= v
.swap_remove(1);
276 assert_eq
!(v
.len(), 1);
277 _e
= v
.swap_remove(0);
278 assert_eq
!(v
.len(), 0);
283 // Test on-stack push().
286 assert_eq
!(v
.len(), 1);
289 // Test on-heap push().
291 assert_eq
!(v
.len(), 2);
298 let mut v
: Vec
<Box
<_
>> = vec
![box 6, box 5, box 4];
301 assert_eq
!(v
.len(), 1);
302 assert_eq
!(*(v
[0]), 6);
303 // If the unsafe block didn't drop things properly, we blow up here.
308 let mut v
: Vec
<Box
<_
>> = vec
![box 6, box 5, box 4];
310 assert_eq
!(v
.len(), 0);
311 // If the unsafe block didn't drop things properly, we blow up here.
316 let mut v
= vec
![1, 2, 3, 4, 5];
318 assert_eq
!(v
, [1, 3, 5]);
322 fn test_binary_search() {
323 assert_eq
!([1, 2, 3, 4, 5].binary_search(&5).ok(), Some(4));
324 assert_eq
!([1, 2, 3, 4, 5].binary_search(&4).ok(), Some(3));
325 assert_eq
!([1, 2, 3, 4, 5].binary_search(&3).ok(), Some(2));
326 assert_eq
!([1, 2, 3, 4, 5].binary_search(&2).ok(), Some(1));
327 assert_eq
!([1, 2, 3, 4, 5].binary_search(&1).ok(), Some(0));
329 assert_eq
!([2, 4, 6, 8, 10].binary_search(&1).ok(), None
);
330 assert_eq
!([2, 4, 6, 8, 10].binary_search(&5).ok(), None
);
331 assert_eq
!([2, 4, 6, 8, 10].binary_search(&4).ok(), Some(1));
332 assert_eq
!([2, 4, 6, 8, 10].binary_search(&10).ok(), Some(4));
334 assert_eq
!([2, 4, 6, 8].binary_search(&1).ok(), None
);
335 assert_eq
!([2, 4, 6, 8].binary_search(&5).ok(), None
);
336 assert_eq
!([2, 4, 6, 8].binary_search(&4).ok(), Some(1));
337 assert_eq
!([2, 4, 6, 8].binary_search(&8).ok(), Some(3));
339 assert_eq
!([2, 4, 6].binary_search(&1).ok(), None
);
340 assert_eq
!([2, 4, 6].binary_search(&5).ok(), None
);
341 assert_eq
!([2, 4, 6].binary_search(&4).ok(), Some(1));
342 assert_eq
!([2, 4, 6].binary_search(&6).ok(), Some(2));
344 assert_eq
!([2, 4].binary_search(&1).ok(), None
);
345 assert_eq
!([2, 4].binary_search(&5).ok(), None
);
346 assert_eq
!([2, 4].binary_search(&2).ok(), Some(0));
347 assert_eq
!([2, 4].binary_search(&4).ok(), Some(1));
349 assert_eq
!([2].binary_search(&1).ok(), None
);
350 assert_eq
!([2].binary_search(&5).ok(), None
);
351 assert_eq
!([2].binary_search(&2).ok(), Some(0));
353 assert_eq
!([].binary_search(&1).ok(), None
);
354 assert_eq
!([].binary_search(&5).ok(), None
);
356 assert
!([1, 1, 1, 1, 1].binary_search(&1).ok() != None
);
357 assert
!([1, 1, 1, 1, 2].binary_search(&1).ok() != None
);
358 assert
!([1, 1, 1, 2, 2].binary_search(&1).ok() != None
);
359 assert
!([1, 1, 2, 2, 2].binary_search(&1).ok() != None
);
360 assert_eq
!([1, 2, 2, 2, 2].binary_search(&1).ok(), Some(0));
362 assert_eq
!([1, 2, 3, 4, 5].binary_search(&6).ok(), None
);
363 assert_eq
!([1, 2, 3, 4, 5].binary_search(&0).ok(), None
);
368 let mut v
= vec
![10, 20];
369 assert_eq
!(v
[0], 10);
370 assert_eq
!(v
[1], 20);
372 assert_eq
!(v
[0], 20);
373 assert_eq
!(v
[1], 10);
375 let mut v3
= Vec
::<i32>::new();
377 assert
!(v3
.is_empty());
379 // check the 1-byte-types path
380 let mut v
= (-50..51i8).collect
::<Vec
<_
>>();
382 assert_eq
!(v
, (-50..51i8).rev().collect
::<Vec
<_
>>());
384 // check the 2-byte-types path
385 let mut v
= (-50..51i16).collect
::<Vec
<_
>>();
387 assert_eq
!(v
, (-50..51i16).rev().collect
::<Vec
<_
>>());
391 #[cfg_attr(miri, ignore)] // Miri is too slow
393 let mut rng
= thread_rng();
395 for len
in (2..25).chain(500..510) {
396 for &modulus
in &[5, 10, 100, 1000] {
399 rng
.sample_iter
::<i32, _
>(&Standard
).map(|x
| x
% modulus
).take(len
).collect();
401 // Sort in default order.
402 let mut v
= orig
.clone();
404 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
406 // Sort in ascending order.
407 let mut v
= orig
.clone();
408 v
.sort_by(|a
, b
| a
.cmp(b
));
409 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
411 // Sort in descending order.
412 let mut v
= orig
.clone();
413 v
.sort_by(|a
, b
| b
.cmp(a
));
414 assert
!(v
.windows(2).all(|w
| w
[0] >= w
[1]));
416 // Sort in lexicographic order.
417 let mut v1
= orig
.clone();
418 let mut v2
= orig
.clone();
419 v1
.sort_by_key(|x
| x
.to_string());
420 v2
.sort_by_cached_key(|x
| x
.to_string());
421 assert
!(v1
.windows(2).all(|w
| w
[0].to_string() <= w
[1].to_string()));
424 // Sort with many pre-sorted runs.
425 let mut v
= orig
.clone();
429 let a
= rng
.gen
::<usize>() % len
;
430 let b
= rng
.gen
::<usize>() % len
;
438 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
443 // Sort using a completely random comparison function.
444 // This will reorder the elements *somehow*, but won't panic.
445 let mut v
= [0; 500];
446 for i
in 0..v
.len() {
449 v
.sort_by(|_
, _
| *[Less
, Equal
, Greater
].choose(&mut rng
).unwrap());
451 for i
in 0..v
.len() {
452 assert_eq
!(v
[i
], i
as i32);
460 let mut v
= [0xDEADBEEFu64];
462 assert
!(v
== [0xDEADBEEF]);
466 fn test_sort_stability() {
468 let large_range
= if cfg
!(miri
) { 0..0 }
else { 500..510 }
;
469 let rounds
= if cfg
!(miri
) { 1 }
else { 10 }
;
471 for len
in (2..25).chain(large_range
) {
473 let mut counts
= [0; 10];
475 // create a vector like [(6, 1), (5, 1), (6, 2), ...],
476 // where the first item of each tuple is random, but
477 // the second item represents which occurrence of that
478 // number this element is, i.e., the second elements
479 // will occur in sorted order.
480 let orig
: Vec
<_
> = (0..len
)
482 let n
= thread_rng().gen
::<usize>() % 10;
488 let mut v
= orig
.clone();
489 // Only sort on the first element, so an unstable sort
490 // may mix up the counts.
491 v
.sort_by(|&(a
, _
), &(b
, _
)| a
.cmp(&b
));
493 // This comparison includes the count (the second item
494 // of the tuple), so elements with equal first items
495 // will need to be ordered with increasing
496 // counts... i.e., exactly asserting that this sort is
498 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
500 let mut v
= orig
.clone();
501 v
.sort_by_cached_key(|&(x
, _
)| x
);
502 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
508 fn test_rotate_left() {
509 let expected
: Vec
<_
> = (0..13).collect();
510 let mut v
= Vec
::new();
513 v
.clone_from(&expected
);
515 assert_eq
!(v
, expected
);
516 v
.rotate_left(expected
.len());
517 assert_eq
!(v
, expected
);
518 let mut zst_array
= [(), (), ()];
519 zst_array
.rotate_left(2);
522 v
= (5..13).chain(0..5).collect();
524 assert_eq
!(v
, expected
);
526 let expected
: Vec
<_
> = (0..1000).collect();
528 // small rotations in large slice, uses ptr::copy
529 v
= (2..1000).chain(0..2).collect();
531 assert_eq
!(v
, expected
);
532 v
= (998..1000).chain(0..998).collect();
534 assert_eq
!(v
, expected
);
536 // non-small prime rotation, has a few rounds of swapping
537 v
= (389..1000).chain(0..389).collect();
538 v
.rotate_left(1000 - 389);
539 assert_eq
!(v
, expected
);
543 fn test_rotate_right() {
544 let expected
: Vec
<_
> = (0..13).collect();
545 let mut v
= Vec
::new();
548 v
.clone_from(&expected
);
550 assert_eq
!(v
, expected
);
551 v
.rotate_right(expected
.len());
552 assert_eq
!(v
, expected
);
553 let mut zst_array
= [(), (), ()];
554 zst_array
.rotate_right(2);
557 v
= (5..13).chain(0..5).collect();
559 assert_eq
!(v
, expected
);
561 let expected
: Vec
<_
> = (0..1000).collect();
563 // small rotations in large slice, uses ptr::copy
564 v
= (2..1000).chain(0..2).collect();
566 assert_eq
!(v
, expected
);
567 v
= (998..1000).chain(0..998).collect();
569 assert_eq
!(v
, expected
);
571 // non-small prime rotation, has a few rounds of swapping
572 v
= (389..1000).chain(0..389).collect();
574 assert_eq
!(v
, expected
);
579 let v
: [Vec
<i32>; 0] = [];
582 let d
= [vec
![1], vec
![2, 3]].concat();
583 assert_eq
!(d
, [1, 2, 3]);
585 let v
: &[&[_
]] = &[&[1], &[2, 3]];
586 assert_eq
!(v
.join(&0), [1, 0, 2, 3]);
587 let v
: &[&[_
]] = &[&[1], &[2], &[3]];
588 assert_eq
!(v
.join(&0), [1, 0, 2, 0, 3]);
593 let v
: [Vec
<i32>; 0] = [];
594 assert_eq
!(v
.join(&0), []);
595 assert_eq
!([vec
![1], vec
![2, 3]].join(&0), [1, 0, 2, 3]);
596 assert_eq
!([vec
![1], vec
![2], vec
![3]].join(&0), [1, 0, 2, 0, 3]);
598 let v
: [&[_
]; 2] = [&[1], &[2, 3]];
599 assert_eq
!(v
.join(&0), [1, 0, 2, 3]);
600 let v
: [&[_
]; 3] = [&[1], &[2], &[3]];
601 assert_eq
!(v
.join(&0), [1, 0, 2, 0, 3]);
605 fn test_join_nocopy() {
606 let v
: [String
; 0] = [];
607 assert_eq
!(v
.join(","), "");
608 assert_eq
!(["a".to_string(), "ab".into()].join(","), "a,ab");
609 assert_eq
!(["a".to_string(), "ab".into(), "abc".into()].join(","), "a,ab,abc");
610 assert_eq
!(["a".to_string(), "ab".into(), "".into()].join(","), "a,ab,");
615 let mut a
= vec
![1, 2, 4];
617 assert_eq
!(a
, [1, 2, 3, 4]);
619 let mut a
= vec
![1, 2, 3];
621 assert_eq
!(a
, [0, 1, 2, 3]);
623 let mut a
= vec
![1, 2, 3];
625 assert_eq
!(a
, [1, 2, 3, 4]);
634 fn test_insert_oob() {
635 let mut a
= vec
![1, 2, 3];
641 let mut a
= vec
![1, 2, 3, 4];
643 assert_eq
!(a
.remove(2), 3);
644 assert_eq
!(a
, [1, 2, 4]);
646 assert_eq
!(a
.remove(2), 4);
647 assert_eq
!(a
, [1, 2]);
649 assert_eq
!(a
.remove(0), 1);
652 assert_eq
!(a
.remove(0), 2);
658 fn test_remove_fail() {
668 assert
!(v
.capacity() >= 11);
673 let v
= vec
![1, 2, 3, 4, 5];
675 assert_eq
!(v
.len(), 2);
680 macro_rules
! assert_order
{
681 (Greater
, $a
:expr
, $b
:expr
) => {
682 assert_eq
!($a
.cmp($b
), Greater
);
685 (Less
, $a
:expr
, $b
:expr
) => {
686 assert_eq
!($a
.cmp($b
), Less
);
689 (Equal
, $a
:expr
, $b
:expr
) => {
690 assert_eq
!($a
.cmp($b
), Equal
);
696 fn test_total_ord_u8() {
697 let c
= &[1u8, 2, 3];
698 assert_order
!(Greater
, &[1u8, 2, 3, 4][..], &c
[..]);
699 let c
= &[1u8, 2, 3, 4];
700 assert_order
!(Less
, &[1u8, 2, 3][..], &c
[..]);
701 let c
= &[1u8, 2, 3, 6];
702 assert_order
!(Equal
, &[1u8, 2, 3, 6][..], &c
[..]);
703 let c
= &[1u8, 2, 3, 4, 5, 6];
704 assert_order
!(Less
, &[1u8, 2, 3, 4, 5, 5, 5, 5][..], &c
[..]);
705 let c
= &[1u8, 2, 3, 4];
706 assert_order
!(Greater
, &[2u8, 2][..], &c
[..]);
710 fn test_total_ord_i32() {
712 assert_order
!(Greater
, &[1, 2, 3, 4][..], &c
[..]);
713 let c
= &[1, 2, 3, 4];
714 assert_order
!(Less
, &[1, 2, 3][..], &c
[..]);
715 let c
= &[1, 2, 3, 6];
716 assert_order
!(Equal
, &[1, 2, 3, 6][..], &c
[..]);
717 let c
= &[1, 2, 3, 4, 5, 6];
718 assert_order
!(Less
, &[1, 2, 3, 4, 5, 5, 5, 5][..], &c
[..]);
719 let c
= &[1, 2, 3, 4];
720 assert_order
!(Greater
, &[2, 2][..], &c
[..]);
725 let xs
= [1, 2, 5, 10, 11];
726 let mut it
= xs
.iter();
727 assert_eq
!(it
.size_hint(), (5, Some(5)));
728 assert_eq
!(it
.next().unwrap(), &1);
729 assert_eq
!(it
.size_hint(), (4, Some(4)));
730 assert_eq
!(it
.next().unwrap(), &2);
731 assert_eq
!(it
.size_hint(), (3, Some(3)));
732 assert_eq
!(it
.next().unwrap(), &5);
733 assert_eq
!(it
.size_hint(), (2, Some(2)));
734 assert_eq
!(it
.next().unwrap(), &10);
735 assert_eq
!(it
.size_hint(), (1, Some(1)));
736 assert_eq
!(it
.next().unwrap(), &11);
737 assert_eq
!(it
.size_hint(), (0, Some(0)));
738 assert
!(it
.next().is_none());
742 fn test_iter_size_hints() {
743 let mut xs
= [1, 2, 5, 10, 11];
744 assert_eq
!(xs
.iter().size_hint(), (5, Some(5)));
745 assert_eq
!(xs
.iter_mut().size_hint(), (5, Some(5)));
749 fn test_iter_as_slice() {
750 let xs
= [1, 2, 5, 10, 11];
751 let mut iter
= xs
.iter();
752 assert_eq
!(iter
.as_slice(), &[1, 2, 5, 10, 11]);
754 assert_eq
!(iter
.as_slice(), &[2, 5, 10, 11]);
758 fn test_iter_as_ref() {
759 let xs
= [1, 2, 5, 10, 11];
760 let mut iter
= xs
.iter();
761 assert_eq
!(iter
.as_ref(), &[1, 2, 5, 10, 11]);
763 assert_eq
!(iter
.as_ref(), &[2, 5, 10, 11]);
767 fn test_iter_clone() {
769 let mut it
= xs
.iter();
771 let mut jt
= it
.clone();
772 assert_eq
!(it
.next(), jt
.next());
773 assert_eq
!(it
.next(), jt
.next());
774 assert_eq
!(it
.next(), jt
.next());
778 fn test_iter_is_empty() {
779 let xs
= [1, 2, 5, 10, 11];
780 for i
in 0..xs
.len() {
781 for j
in i
..xs
.len() {
782 assert_eq
!(xs
[i
..j
].iter().is_empty(), xs
[i
..j
].is_empty());
788 fn test_mut_iterator() {
789 let mut xs
= [1, 2, 3, 4, 5];
793 assert
!(xs
== [2, 3, 4, 5, 6])
797 fn test_rev_iterator() {
798 let xs
= [1, 2, 5, 10, 11];
799 let ys
= [11, 10, 5, 2, 1];
801 for &x
in xs
.iter().rev() {
802 assert_eq
!(x
, ys
[i
]);
809 fn test_mut_rev_iterator() {
810 let mut xs
= [1, 2, 3, 4, 5];
811 for (i
, x
) in xs
.iter_mut().rev().enumerate() {
814 assert
!(xs
== [5, 5, 5, 5, 5])
818 fn test_move_iterator() {
819 let xs
= vec
![1, 2, 3, 4, 5];
820 assert_eq
!(xs
.into_iter().fold(0, |a
: usize, b
: usize| 10 * a
+ b
), 12345);
824 fn test_move_rev_iterator() {
825 let xs
= vec
![1, 2, 3, 4, 5];
826 assert_eq
!(xs
.into_iter().rev().fold(0, |a
: usize, b
: usize| 10 * a
+ b
), 54321);
830 fn test_splitator() {
831 let xs
= &[1, 2, 3, 4, 5];
833 let splits
: &[&[_
]] = &[&[1], &[3], &[5]];
834 assert_eq
!(xs
.split(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
835 let splits
: &[&[_
]] = &[&[], &[2, 3, 4, 5]];
836 assert_eq
!(xs
.split(|x
| *x
== 1).collect
::<Vec
<_
>>(), splits
);
837 let splits
: &[&[_
]] = &[&[1, 2, 3, 4], &[]];
838 assert_eq
!(xs
.split(|x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
839 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
840 assert_eq
!(xs
.split(|x
| *x
== 10).collect
::<Vec
<_
>>(), splits
);
841 let splits
: &[&[_
]] = &[&[], &[], &[], &[], &[], &[]];
842 assert_eq
!(xs
.split(|_
| true).collect
::<Vec
<&[i32]>>(), splits
);
844 let xs
: &[i32] = &[];
845 let splits
: &[&[i32]] = &[&[]];
846 assert_eq
!(xs
.split(|x
| *x
== 5).collect
::<Vec
<&[i32]>>(), splits
);
850 fn test_splitator_inclusive() {
851 let xs
= &[1, 2, 3, 4, 5];
853 let splits
: &[&[_
]] = &[&[1, 2], &[3, 4], &[5]];
854 assert_eq
!(xs
.split_inclusive(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
855 let splits
: &[&[_
]] = &[&[1], &[2, 3, 4, 5]];
856 assert_eq
!(xs
.split_inclusive(|x
| *x
== 1).collect
::<Vec
<_
>>(), splits
);
857 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
858 assert_eq
!(xs
.split_inclusive(|x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
859 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
860 assert_eq
!(xs
.split_inclusive(|x
| *x
== 10).collect
::<Vec
<_
>>(), splits
);
861 let splits
: &[&[_
]] = &[&[1], &[2], &[3], &[4], &[5]];
862 assert_eq
!(xs
.split_inclusive(|_
| true).collect
::<Vec
<&[i32]>>(), splits
);
864 let xs
: &[i32] = &[];
865 let splits
: &[&[i32]] = &[&[]];
866 assert_eq
!(xs
.split_inclusive(|x
| *x
== 5).collect
::<Vec
<&[i32]>>(), splits
);
870 fn test_splitator_inclusive_reverse() {
871 let xs
= &[1, 2, 3, 4, 5];
873 let splits
: &[&[_
]] = &[&[5], &[3, 4], &[1, 2]];
874 assert_eq
!(xs
.split_inclusive(|x
| *x
% 2 == 0).rev().collect
::<Vec
<_
>>(), splits
);
875 let splits
: &[&[_
]] = &[&[2, 3, 4, 5], &[1]];
876 assert_eq
!(xs
.split_inclusive(|x
| *x
== 1).rev().collect
::<Vec
<_
>>(), splits
);
877 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
878 assert_eq
!(xs
.split_inclusive(|x
| *x
== 5).rev().collect
::<Vec
<_
>>(), splits
);
879 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
880 assert_eq
!(xs
.split_inclusive(|x
| *x
== 10).rev().collect
::<Vec
<_
>>(), splits
);
881 let splits
: &[&[_
]] = &[&[5], &[4], &[3], &[2], &[1]];
882 assert_eq
!(xs
.split_inclusive(|_
| true).rev().collect
::<Vec
<_
>>(), splits
);
884 let xs
: &[i32] = &[];
885 let splits
: &[&[i32]] = &[&[]];
886 assert_eq
!(xs
.split_inclusive(|x
| *x
== 5).rev().collect
::<Vec
<_
>>(), splits
);
890 fn test_splitator_mut_inclusive() {
891 let xs
= &mut [1, 2, 3, 4, 5];
893 let splits
: &[&[_
]] = &[&[1, 2], &[3, 4], &[5]];
894 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
895 let splits
: &[&[_
]] = &[&[1], &[2, 3, 4, 5]];
896 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 1).collect
::<Vec
<_
>>(), splits
);
897 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
898 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
899 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
900 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 10).collect
::<Vec
<_
>>(), splits
);
901 let splits
: &[&[_
]] = &[&[1], &[2], &[3], &[4], &[5]];
902 assert_eq
!(xs
.split_inclusive_mut(|_
| true).collect
::<Vec
<_
>>(), splits
);
904 let xs
: &mut [i32] = &mut [];
905 let splits
: &[&[i32]] = &[&[]];
906 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
910 fn test_splitator_mut_inclusive_reverse() {
911 let xs
= &mut [1, 2, 3, 4, 5];
913 let splits
: &[&[_
]] = &[&[5], &[3, 4], &[1, 2]];
914 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
% 2 == 0).rev().collect
::<Vec
<_
>>(), splits
);
915 let splits
: &[&[_
]] = &[&[2, 3, 4, 5], &[1]];
916 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 1).rev().collect
::<Vec
<_
>>(), splits
);
917 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
918 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 5).rev().collect
::<Vec
<_
>>(), splits
);
919 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
920 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 10).rev().collect
::<Vec
<_
>>(), splits
);
921 let splits
: &[&[_
]] = &[&[5], &[4], &[3], &[2], &[1]];
922 assert_eq
!(xs
.split_inclusive_mut(|_
| true).rev().collect
::<Vec
<_
>>(), splits
);
924 let xs
: &mut [i32] = &mut [];
925 let splits
: &[&[i32]] = &[&[]];
926 assert_eq
!(xs
.split_inclusive_mut(|x
| *x
== 5).rev().collect
::<Vec
<_
>>(), splits
);
930 fn test_splitnator() {
931 let xs
= &[1, 2, 3, 4, 5];
933 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
934 assert_eq
!(xs
.splitn(1, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
935 let splits
: &[&[_
]] = &[&[1], &[3, 4, 5]];
936 assert_eq
!(xs
.splitn(2, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
937 let splits
: &[&[_
]] = &[&[], &[], &[], &[4, 5]];
938 assert_eq
!(xs
.splitn(4, |_
| true).collect
::<Vec
<_
>>(), splits
);
940 let xs
: &[i32] = &[];
941 let splits
: &[&[i32]] = &[&[]];
942 assert_eq
!(xs
.splitn(2, |x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
946 fn test_splitnator_mut() {
947 let xs
= &mut [1, 2, 3, 4, 5];
949 let splits
: &[&mut [_
]] = &[&mut [1, 2, 3, 4, 5]];
950 assert_eq
!(xs
.splitn_mut(1, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
951 let splits
: &[&mut [_
]] = &[&mut [1], &mut [3, 4, 5]];
952 assert_eq
!(xs
.splitn_mut(2, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
953 let splits
: &[&mut [_
]] = &[&mut [], &mut [], &mut [], &mut [4, 5]];
954 assert_eq
!(xs
.splitn_mut(4, |_
| true).collect
::<Vec
<_
>>(), splits
);
956 let xs
: &mut [i32] = &mut [];
957 let splits
: &[&mut [i32]] = &[&mut []];
958 assert_eq
!(xs
.splitn_mut(2, |x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
962 fn test_rsplitator() {
963 let xs
= &[1, 2, 3, 4, 5];
965 let splits
: &[&[_
]] = &[&[5], &[3], &[1]];
966 assert_eq
!(xs
.split(|x
| *x
% 2 == 0).rev().collect
::<Vec
<_
>>(), splits
);
967 let splits
: &[&[_
]] = &[&[2, 3, 4, 5], &[]];
968 assert_eq
!(xs
.split(|x
| *x
== 1).rev().collect
::<Vec
<_
>>(), splits
);
969 let splits
: &[&[_
]] = &[&[], &[1, 2, 3, 4]];
970 assert_eq
!(xs
.split(|x
| *x
== 5).rev().collect
::<Vec
<_
>>(), splits
);
971 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
972 assert_eq
!(xs
.split(|x
| *x
== 10).rev().collect
::<Vec
<_
>>(), splits
);
974 let xs
: &[i32] = &[];
975 let splits
: &[&[i32]] = &[&[]];
976 assert_eq
!(xs
.split(|x
| *x
== 5).rev().collect
::<Vec
<&[i32]>>(), splits
);
980 fn test_rsplitnator() {
981 let xs
= &[1, 2, 3, 4, 5];
983 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
984 assert_eq
!(xs
.rsplitn(1, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
985 let splits
: &[&[_
]] = &[&[5], &[1, 2, 3]];
986 assert_eq
!(xs
.rsplitn(2, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
987 let splits
: &[&[_
]] = &[&[], &[], &[], &[1, 2]];
988 assert_eq
!(xs
.rsplitn(4, |_
| true).collect
::<Vec
<_
>>(), splits
);
990 let xs
: &[i32] = &[];
991 let splits
: &[&[i32]] = &[&[]];
992 assert_eq
!(xs
.rsplitn(2, |x
| *x
== 5).collect
::<Vec
<&[i32]>>(), splits
);
993 assert
!(xs
.rsplitn(0, |x
| *x
% 2 == 0).next().is_none());
997 fn test_windowsator() {
998 let v
= &[1, 2, 3, 4];
1000 let wins
: &[&[_
]] = &[&[1, 2], &[2, 3], &[3, 4]];
1001 assert_eq
!(v
.windows(2).collect
::<Vec
<_
>>(), wins
);
1003 let wins
: &[&[_
]] = &[&[1, 2, 3], &[2, 3, 4]];
1004 assert_eq
!(v
.windows(3).collect
::<Vec
<_
>>(), wins
);
1005 assert
!(v
.windows(6).next().is_none());
1007 let wins
: &[&[_
]] = &[&[3, 4], &[2, 3], &[1, 2]];
1008 assert_eq
!(v
.windows(2).rev().collect
::<Vec
<&[_
]>>(), wins
);
1013 fn test_windowsator_0() {
1014 let v
= &[1, 2, 3, 4];
1015 let _it
= v
.windows(0);
1019 fn test_chunksator() {
1020 let v
= &[1, 2, 3, 4, 5];
1022 assert_eq
!(v
.chunks(2).len(), 3);
1024 let chunks
: &[&[_
]] = &[&[1, 2], &[3, 4], &[5]];
1025 assert_eq
!(v
.chunks(2).collect
::<Vec
<_
>>(), chunks
);
1026 let chunks
: &[&[_
]] = &[&[1, 2, 3], &[4, 5]];
1027 assert_eq
!(v
.chunks(3).collect
::<Vec
<_
>>(), chunks
);
1028 let chunks
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
1029 assert_eq
!(v
.chunks(6).collect
::<Vec
<_
>>(), chunks
);
1031 let chunks
: &[&[_
]] = &[&[5], &[3, 4], &[1, 2]];
1032 assert_eq
!(v
.chunks(2).rev().collect
::<Vec
<_
>>(), chunks
);
1037 fn test_chunksator_0() {
1038 let v
= &[1, 2, 3, 4];
1039 let _it
= v
.chunks(0);
1043 fn test_chunks_exactator() {
1044 let v
= &[1, 2, 3, 4, 5];
1046 assert_eq
!(v
.chunks_exact(2).len(), 2);
1048 let chunks
: &[&[_
]] = &[&[1, 2], &[3, 4]];
1049 assert_eq
!(v
.chunks_exact(2).collect
::<Vec
<_
>>(), chunks
);
1050 let chunks
: &[&[_
]] = &[&[1, 2, 3]];
1051 assert_eq
!(v
.chunks_exact(3).collect
::<Vec
<_
>>(), chunks
);
1052 let chunks
: &[&[_
]] = &[];
1053 assert_eq
!(v
.chunks_exact(6).collect
::<Vec
<_
>>(), chunks
);
1055 let chunks
: &[&[_
]] = &[&[3, 4], &[1, 2]];
1056 assert_eq
!(v
.chunks_exact(2).rev().collect
::<Vec
<_
>>(), chunks
);
1061 fn test_chunks_exactator_0() {
1062 let v
= &[1, 2, 3, 4];
1063 let _it
= v
.chunks_exact(0);
1067 fn test_rchunksator() {
1068 let v
= &[1, 2, 3, 4, 5];
1070 assert_eq
!(v
.rchunks(2).len(), 3);
1072 let chunks
: &[&[_
]] = &[&[4, 5], &[2, 3], &[1]];
1073 assert_eq
!(v
.rchunks(2).collect
::<Vec
<_
>>(), chunks
);
1074 let chunks
: &[&[_
]] = &[&[3, 4, 5], &[1, 2]];
1075 assert_eq
!(v
.rchunks(3).collect
::<Vec
<_
>>(), chunks
);
1076 let chunks
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
1077 assert_eq
!(v
.rchunks(6).collect
::<Vec
<_
>>(), chunks
);
1079 let chunks
: &[&[_
]] = &[&[1], &[2, 3], &[4, 5]];
1080 assert_eq
!(v
.rchunks(2).rev().collect
::<Vec
<_
>>(), chunks
);
1085 fn test_rchunksator_0() {
1086 let v
= &[1, 2, 3, 4];
1087 let _it
= v
.rchunks(0);
1091 fn test_rchunks_exactator() {
1092 let v
= &[1, 2, 3, 4, 5];
1094 assert_eq
!(v
.rchunks_exact(2).len(), 2);
1096 let chunks
: &[&[_
]] = &[&[4, 5], &[2, 3]];
1097 assert_eq
!(v
.rchunks_exact(2).collect
::<Vec
<_
>>(), chunks
);
1098 let chunks
: &[&[_
]] = &[&[3, 4, 5]];
1099 assert_eq
!(v
.rchunks_exact(3).collect
::<Vec
<_
>>(), chunks
);
1100 let chunks
: &[&[_
]] = &[];
1101 assert_eq
!(v
.rchunks_exact(6).collect
::<Vec
<_
>>(), chunks
);
1103 let chunks
: &[&[_
]] = &[&[2, 3], &[4, 5]];
1104 assert_eq
!(v
.rchunks_exact(2).rev().collect
::<Vec
<_
>>(), chunks
);
1109 fn test_rchunks_exactator_0() {
1110 let v
= &[1, 2, 3, 4];
1111 let _it
= v
.rchunks_exact(0);
1115 fn test_reverse_part() {
1116 let mut values
= [1, 2, 3, 4, 5];
1117 values
[1..4].reverse();
1118 assert
!(values
== [1, 4, 3, 2, 5]);
1123 macro_rules
! test_show_vec
{
1124 ($x
:expr
, $x_str
:expr
) => {{
1125 let (x
, x_str
) = ($x
, $x_str
);
1126 assert_eq
!(format
!("{:?}", x
), x_str
);
1127 assert_eq
!(format
!("{:?}", x
), x_str
);
1130 let empty
= Vec
::<i32>::new();
1131 test_show_vec
!(empty
, "[]");
1132 test_show_vec
!(vec
![1], "[1]");
1133 test_show_vec
!(vec
![1, 2, 3], "[1, 2, 3]");
1134 test_show_vec
!(vec
![vec
![], vec
![1], vec
![1, 1]], "[[], [1], [1, 1]]");
1136 let empty_mut
: &mut [i32] = &mut [];
1137 test_show_vec
!(empty_mut
, "[]");
1139 test_show_vec
!(v
, "[1]");
1140 let v
= &mut [1, 2, 3];
1141 test_show_vec
!(v
, "[1, 2, 3]");
1142 let v
: &mut [&mut [_
]] = &mut [&mut [], &mut [1], &mut [1, 1]];
1143 test_show_vec
!(v
, "[[], [1], [1, 1]]");
1147 fn test_vec_default() {
1150 let v
: $ty
= Default
::default();
1151 assert
!(v
.is_empty());
1161 fn test_overflow_does_not_cause_segfault() {
1163 v
.reserve_exact(!0);
1170 fn test_overflow_does_not_cause_segfault_managed() {
1171 let mut v
= vec
![Rc
::new(1)];
1172 v
.reserve_exact(!0);
1177 fn test_mut_split_at() {
1178 let mut values
= [1, 2, 3, 4, 5];
1180 let (left
, right
) = values
.split_at_mut(2);
1182 let left
: &[_
] = left
;
1183 assert
!(left
[..left
.len()] == [1, 2]);
1190 let right
: &[_
] = right
;
1191 assert
!(right
[..right
.len()] == [3, 4, 5]);
1198 assert
!(values
== [2, 3, 5, 6, 7]);
1201 #[derive(Clone, PartialEq)]
1205 fn test_iter_zero_sized() {
1206 let mut v
= vec
![Foo
, Foo
, Foo
];
1207 assert_eq
!(v
.len(), 3);
1232 assert_eq
!(cnt
, 11);
1234 let xs
: [Foo
; 3] = [Foo
, Foo
, Foo
];
1244 fn test_shrink_to_fit() {
1245 let mut xs
= vec
![0, 1, 2, 3];
1249 assert_eq
!(xs
.capacity(), 128);
1251 assert_eq
!(xs
.capacity(), 100);
1252 assert_eq
!(xs
, (0..100).collect
::<Vec
<_
>>());
1256 fn test_starts_with() {
1257 assert
!(b
"foobar".starts_with(b
"foo"));
1258 assert
!(!b
"foobar".starts_with(b
"oob"));
1259 assert
!(!b
"foobar".starts_with(b
"bar"));
1260 assert
!(!b
"foo".starts_with(b
"foobar"));
1261 assert
!(!b
"bar".starts_with(b
"foobar"));
1262 assert
!(b
"foobar".starts_with(b
"foobar"));
1263 let empty
: &[u8] = &[];
1264 assert
!(empty
.starts_with(empty
));
1265 assert
!(!empty
.starts_with(b
"foo"));
1266 assert
!(b
"foobar".starts_with(empty
));
1270 fn test_ends_with() {
1271 assert
!(b
"foobar".ends_with(b
"bar"));
1272 assert
!(!b
"foobar".ends_with(b
"oba"));
1273 assert
!(!b
"foobar".ends_with(b
"foo"));
1274 assert
!(!b
"foo".ends_with(b
"foobar"));
1275 assert
!(!b
"bar".ends_with(b
"foobar"));
1276 assert
!(b
"foobar".ends_with(b
"foobar"));
1277 let empty
: &[u8] = &[];
1278 assert
!(empty
.ends_with(empty
));
1279 assert
!(!empty
.ends_with(b
"foo"));
1280 assert
!(b
"foobar".ends_with(empty
));
1284 fn test_mut_splitator() {
1285 let mut xs
= [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
1286 assert_eq
!(xs
.split_mut(|x
| *x
== 0).count(), 6);
1287 for slice
in xs
.split_mut(|x
| *x
== 0) {
1290 assert
!(xs
== [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]);
1292 let mut xs
= [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7];
1293 for slice
in xs
.split_mut(|x
| *x
== 0).take(5) {
1296 assert
!(xs
== [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]);
1300 fn test_mut_splitator_rev() {
1301 let mut xs
= [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
1302 for slice
in xs
.split_mut(|x
| *x
== 0).rev().take(4) {
1305 assert
!(xs
== [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]);
1310 let mut v
= [0, 1, 2];
1311 assert_eq
!(v
.get_mut(3), None
);
1312 v
.get_mut(1).map(|e
| *e
= 7);
1313 assert_eq
!(v
[1], 7);
1315 assert_eq
!(v
.get_mut(2), Some(&mut x
));
1319 fn test_mut_chunks() {
1320 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1321 assert_eq
!(v
.chunks_mut(3).len(), 3);
1322 for (i
, chunk
) in v
.chunks_mut(3).enumerate() {
1327 let result
= [0, 0, 0, 1, 1, 1, 2];
1328 assert_eq
!(v
, result
);
1332 fn test_mut_chunks_rev() {
1333 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1334 for (i
, chunk
) in v
.chunks_mut(3).rev().enumerate() {
1339 let result
= [2, 2, 2, 1, 1, 1, 0];
1340 assert_eq
!(v
, result
);
1345 fn test_mut_chunks_0() {
1346 let mut v
= [1, 2, 3, 4];
1347 let _it
= v
.chunks_mut(0);
1351 fn test_mut_chunks_exact() {
1352 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1353 assert_eq
!(v
.chunks_exact_mut(3).len(), 2);
1354 for (i
, chunk
) in v
.chunks_exact_mut(3).enumerate() {
1359 let result
= [0, 0, 0, 1, 1, 1, 6];
1360 assert_eq
!(v
, result
);
1364 fn test_mut_chunks_exact_rev() {
1365 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1366 for (i
, chunk
) in v
.chunks_exact_mut(3).rev().enumerate() {
1371 let result
= [1, 1, 1, 0, 0, 0, 6];
1372 assert_eq
!(v
, result
);
1377 fn test_mut_chunks_exact_0() {
1378 let mut v
= [1, 2, 3, 4];
1379 let _it
= v
.chunks_exact_mut(0);
1383 fn test_mut_rchunks() {
1384 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1385 assert_eq
!(v
.rchunks_mut(3).len(), 3);
1386 for (i
, chunk
) in v
.rchunks_mut(3).enumerate() {
1391 let result
= [2, 1, 1, 1, 0, 0, 0];
1392 assert_eq
!(v
, result
);
1396 fn test_mut_rchunks_rev() {
1397 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1398 for (i
, chunk
) in v
.rchunks_mut(3).rev().enumerate() {
1403 let result
= [0, 1, 1, 1, 2, 2, 2];
1404 assert_eq
!(v
, result
);
1409 fn test_mut_rchunks_0() {
1410 let mut v
= [1, 2, 3, 4];
1411 let _it
= v
.rchunks_mut(0);
1415 fn test_mut_rchunks_exact() {
1416 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1417 assert_eq
!(v
.rchunks_exact_mut(3).len(), 2);
1418 for (i
, chunk
) in v
.rchunks_exact_mut(3).enumerate() {
1423 let result
= [0, 1, 1, 1, 0, 0, 0];
1424 assert_eq
!(v
, result
);
1428 fn test_mut_rchunks_exact_rev() {
1429 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1430 for (i
, chunk
) in v
.rchunks_exact_mut(3).rev().enumerate() {
1435 let result
= [0, 0, 0, 0, 1, 1, 1];
1436 assert_eq
!(v
, result
);
1441 fn test_mut_rchunks_exact_0() {
1442 let mut v
= [1, 2, 3, 4];
1443 let _it
= v
.rchunks_exact_mut(0);
1447 fn test_mut_last() {
1448 let mut x
= [1, 2, 3, 4, 5];
1449 let h
= x
.last_mut();
1450 assert_eq
!(*h
.unwrap(), 5);
1452 let y
: &mut [i32] = &mut [];
1453 assert
!(y
.last_mut().is_none());
1458 let xs
: Box
<_
> = box [1, 2, 3];
1459 let ys
= xs
.to_vec();
1460 assert_eq
!(ys
, [1, 2, 3]);
1464 fn test_in_place_iterator_specialization() {
1465 let src
: Box
<[usize]> = box [1, 2, 3];
1466 let src_ptr
= src
.as_ptr();
1467 let sink
: Box
<_
> = src
.into_vec().into_iter().map(std
::convert
::identity
).collect();
1468 let sink_ptr
= sink
.as_ptr();
1469 assert_eq
!(src_ptr
, sink_ptr
);
1473 fn test_box_slice_clone() {
1474 let data
= vec
![vec
![0, 1], vec
![0], vec
![1]];
1475 let data2
= data
.clone().into_boxed_slice().clone().to_vec();
1477 assert_eq
!(data
, data2
);
1481 #[allow(unused_must_use)] // here, we care about the side effects of `.clone()`
1482 #[cfg_attr(target_os = "emscripten", ignore)]
1483 fn test_box_slice_clone_panics() {
1484 use std
::sync
::atomic
::{AtomicUsize, Ordering}
;
1488 count
: Arc
<AtomicUsize
>,
1492 impl Drop
for Canary
{
1493 fn drop(&mut self) {
1494 self.count
.fetch_add(1, Ordering
::SeqCst
);
1498 impl Clone
for Canary
{
1499 fn clone(&self) -> Self {
1504 Canary { count: self.count.clone(), panics: self.panics }
1508 let drop_count
= Arc
::new(AtomicUsize
::new(0));
1509 let canary
= Canary { count: drop_count.clone(), panics: false }
;
1510 let panic
= Canary { count: drop_count.clone(), panics: true }
;
1512 std
::panic
::catch_unwind(move || {
1513 // When xs is dropped, +5.
1515 vec
![canary
.clone(), canary
.clone(), canary
.clone(), panic
, canary
].into_boxed_slice();
1517 // When panic is cloned, +3.
1523 assert_eq
!(drop_count
.load(Ordering
::SeqCst
), 8);
1527 fn test_copy_from_slice() {
1528 let src
= [0, 1, 2, 3, 4, 5];
1529 let mut dst
= [0; 6];
1530 dst
.copy_from_slice(&src
);
1531 assert_eq
!(src
, dst
)
1535 #[should_panic(expected = "source slice length (4) does not match destination slice length (5)")]
1536 fn test_copy_from_slice_dst_longer() {
1537 let src
= [0, 1, 2, 3];
1538 let mut dst
= [0; 5];
1539 dst
.copy_from_slice(&src
);
1543 #[should_panic(expected = "source slice length (4) does not match destination slice length (3)")]
1544 fn test_copy_from_slice_dst_shorter() {
1545 let src
= [0, 1, 2, 3];
1546 let mut dst
= [0; 3];
1547 dst
.copy_from_slice(&src
);
1550 const MAX_LEN
: usize = 80;
1552 static DROP_COUNTS
: [AtomicUsize
; MAX_LEN
] = [
1553 // FIXME(RFC 1109): AtomicUsize is not Copy.
1554 AtomicUsize
::new(0),
1555 AtomicUsize
::new(0),
1556 AtomicUsize
::new(0),
1557 AtomicUsize
::new(0),
1558 AtomicUsize
::new(0),
1559 AtomicUsize
::new(0),
1560 AtomicUsize
::new(0),
1561 AtomicUsize
::new(0),
1562 AtomicUsize
::new(0),
1563 AtomicUsize
::new(0),
1564 AtomicUsize
::new(0),
1565 AtomicUsize
::new(0),
1566 AtomicUsize
::new(0),
1567 AtomicUsize
::new(0),
1568 AtomicUsize
::new(0),
1569 AtomicUsize
::new(0),
1570 AtomicUsize
::new(0),
1571 AtomicUsize
::new(0),
1572 AtomicUsize
::new(0),
1573 AtomicUsize
::new(0),
1574 AtomicUsize
::new(0),
1575 AtomicUsize
::new(0),
1576 AtomicUsize
::new(0),
1577 AtomicUsize
::new(0),
1578 AtomicUsize
::new(0),
1579 AtomicUsize
::new(0),
1580 AtomicUsize
::new(0),
1581 AtomicUsize
::new(0),
1582 AtomicUsize
::new(0),
1583 AtomicUsize
::new(0),
1584 AtomicUsize
::new(0),
1585 AtomicUsize
::new(0),
1586 AtomicUsize
::new(0),
1587 AtomicUsize
::new(0),
1588 AtomicUsize
::new(0),
1589 AtomicUsize
::new(0),
1590 AtomicUsize
::new(0),
1591 AtomicUsize
::new(0),
1592 AtomicUsize
::new(0),
1593 AtomicUsize
::new(0),
1594 AtomicUsize
::new(0),
1595 AtomicUsize
::new(0),
1596 AtomicUsize
::new(0),
1597 AtomicUsize
::new(0),
1598 AtomicUsize
::new(0),
1599 AtomicUsize
::new(0),
1600 AtomicUsize
::new(0),
1601 AtomicUsize
::new(0),
1602 AtomicUsize
::new(0),
1603 AtomicUsize
::new(0),
1604 AtomicUsize
::new(0),
1605 AtomicUsize
::new(0),
1606 AtomicUsize
::new(0),
1607 AtomicUsize
::new(0),
1608 AtomicUsize
::new(0),
1609 AtomicUsize
::new(0),
1610 AtomicUsize
::new(0),
1611 AtomicUsize
::new(0),
1612 AtomicUsize
::new(0),
1613 AtomicUsize
::new(0),
1614 AtomicUsize
::new(0),
1615 AtomicUsize
::new(0),
1616 AtomicUsize
::new(0),
1617 AtomicUsize
::new(0),
1618 AtomicUsize
::new(0),
1619 AtomicUsize
::new(0),
1620 AtomicUsize
::new(0),
1621 AtomicUsize
::new(0),
1622 AtomicUsize
::new(0),
1623 AtomicUsize
::new(0),
1624 AtomicUsize
::new(0),
1625 AtomicUsize
::new(0),
1626 AtomicUsize
::new(0),
1627 AtomicUsize
::new(0),
1628 AtomicUsize
::new(0),
1629 AtomicUsize
::new(0),
1630 AtomicUsize
::new(0),
1631 AtomicUsize
::new(0),
1632 AtomicUsize
::new(0),
1633 AtomicUsize
::new(0),
1636 static VERSIONS
: AtomicUsize
= AtomicUsize
::new(0);
1638 #[derive(Clone, Eq)]
1639 struct DropCounter
{
1642 version
: Cell
<usize>,
1645 impl PartialEq
for DropCounter
{
1646 fn eq(&self, other
: &Self) -> bool
{
1647 self.partial_cmp(other
) == Some(Ordering
::Equal
)
1651 impl PartialOrd
for DropCounter
{
1652 fn partial_cmp(&self, other
: &Self) -> Option
<Ordering
> {
1653 self.version
.set(self.version
.get() + 1);
1654 other
.version
.set(other
.version
.get() + 1);
1655 VERSIONS
.fetch_add(2, Relaxed
);
1656 self.x
.partial_cmp(&other
.x
)
1660 impl Ord
for DropCounter
{
1661 fn cmp(&self, other
: &Self) -> Ordering
{
1662 self.partial_cmp(other
).unwrap()
1666 impl Drop
for DropCounter
{
1667 fn drop(&mut self) {
1668 DROP_COUNTS
[self.id
].fetch_add(1, Relaxed
);
1669 VERSIONS
.fetch_sub(self.version
.get(), Relaxed
);
1674 ($input
:ident
, $func
:ident
) => {
1675 let len
= $input
.len();
1677 // Work out the total number of comparisons required to sort
1679 let mut count
= 0usize
;
1680 $input
.to_owned().$
func(|a
, b
| {
1685 // ... and then panic on each and every single one.
1686 for panic_countdown
in 0..count
{
1687 // Refresh the counters.
1688 VERSIONS
.store(0, Relaxed
);
1690 DROP_COUNTS
[i
].store(0, Relaxed
);
1693 let v
= $input
.to_owned();
1694 let _
= std
::panic
::catch_unwind(move || {
1696 let mut panic_countdown
= panic_countdown
;
1698 if panic_countdown
== 0 {
1699 SILENCE_PANIC
.with(|s
| s
.set(true));
1702 panic_countdown
-= 1;
1707 // Check that the number of things dropped is exactly
1708 // what we expect (i.e., the contents of `v`).
1709 for (i
, c
) in DROP_COUNTS
.iter().enumerate().take(len
) {
1710 let count
= c
.load(Relaxed
);
1711 assert
!(count
== 1, "found drop count == {} for i == {}, len == {}", count
, i
, len
);
1714 // Check that the most recent versions of values were dropped.
1715 assert_eq
!(VERSIONS
.load(Relaxed
), 0);
1720 thread_local
!(static SILENCE_PANIC
: Cell
<bool
> = Cell
::new(false));
1723 #[cfg_attr(target_os = "emscripten", ignore)] // no threads
1725 let prev
= panic
::take_hook();
1726 panic
::set_hook(Box
::new(move |info
| {
1727 if !SILENCE_PANIC
.with(|s
| s
.get()) {
1732 let mut rng
= thread_rng();
1734 // Miri is too slow (but still need to `chain` to make the types match)
1735 let lens
= if cfg
!(miri
) { (1..10).chain(0..0) }
else { (1..20).chain(70..MAX_LEN) }
;
1736 let moduli
: &[u32] = if cfg
!(miri
) { &[5] }
else { &[5, 20, 50] }
;
1739 for &modulus
in moduli
{
1740 for &has_runs
in &[false, true] {
1741 let mut input
= (0..len
)
1742 .map(|id
| DropCounter
{
1743 x
: rng
.next_u32() % modulus
,
1745 version
: Cell
::new(0),
1747 .collect
::<Vec
<_
>>();
1750 for c
in &mut input
{
1755 let a
= rng
.gen
::<usize>() % len
;
1756 let b
= rng
.gen
::<usize>() % len
;
1758 input
[a
..b
].reverse();
1765 test
!(input
, sort_by
);
1766 test
!(input
, sort_unstable_by
);
1771 // Set default panic hook again.
1772 drop(panic
::take_hook());
1776 fn repeat_generic_slice() {
1777 assert_eq
!([1, 2].repeat(2), vec
![1, 2, 1, 2]);
1778 assert_eq
!([1, 2, 3, 4].repeat(0), vec
![]);
1779 assert_eq
!([1, 2, 3, 4].repeat(1), vec
![1, 2, 3, 4]);
1780 assert_eq
!([1, 2, 3, 4].repeat(3), vec
![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);
1784 #[allow(unreachable_patterns)]
1785 fn subslice_patterns() {
1786 // This test comprehensively checks the passing static and dynamic semantics
1787 // of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..`
1788 // in slice patterns `[$($pat), $(,)?]` .
1790 #[derive(PartialEq, Debug, Clone)]
1794 ($
($e
:expr
),* $
(,)?
) => {
1800 ($inp
:expr
, $typ
:ty
, $out
:expr $
(,)?
) => {
1801 assert_eq
!($out
, identity
::<$typ
>($inp
))
1806 ($e
:expr
, $p
:pat
=> $b
:expr
) => {
1816 // Matching slices using `ref` patterns:
1817 let mut v
= vec
![N(0), N(1), N(2), N(3), N(4)];
1818 let mut vc
= (0..=4).collect
::<Vec
<u8>>();
1820 let [..] = v
[..]; // Always matches.
1821 m
!(v
[..], [N(0), ref sub @
.., N(4)] => c
!(sub
, &[N
], n
![1, 2, 3]));
1822 m
!(v
[..], [N(0), ref sub @
..] => c
!(sub
, &[N
], n
![1, 2, 3, 4]));
1823 m
!(v
[..], [ref sub @
.., N(4)] => c
!(sub
, &[N
], n
![0, 1, 2, 3]));
1824 m
!(v
[..], [ref sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &[N
], &n
![] as &[N
]));
1825 m
!(v
[..], [_
, _
, _
, _
, _
, ref sub @
..] => c
!(sub
, &[N
], &n
![] as &[N
]));
1826 m
!(vc
[..], [x
, .., y
] => c
!((x
, y
), (u8, u8), (0, 4)));
1828 // Matching slices using `ref mut` patterns:
1829 let [..] = v
[..]; // Always matches.
1830 m
!(v
[..], [N(0), ref mut sub @
.., N(4)] => c
!(sub
, &mut [N
], n
![1, 2, 3]));
1831 m
!(v
[..], [N(0), ref mut sub @
..] => c
!(sub
, &mut [N
], n
![1, 2, 3, 4]));
1832 m
!(v
[..], [ref mut sub @
.., N(4)] => c
!(sub
, &mut [N
], n
![0, 1, 2, 3]));
1833 m
!(v
[..], [ref mut sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &mut [N
], &mut n
![] as &mut [N
]));
1834 m
!(v
[..], [_
, _
, _
, _
, _
, ref mut sub @
..] => c
!(sub
, &mut [N
], &mut n
![] as &mut [N
]));
1835 m
!(vc
[..], [x
, .., y
] => c
!((x
, y
), (u8, u8), (0, 4)));
1837 // Matching slices using default binding modes (&):
1838 let [..] = &v
[..]; // Always matches.
1839 m
!(&v
[..], [N(0), sub @
.., N(4)] => c
!(sub
, &[N
], n
![1, 2, 3]));
1840 m
!(&v
[..], [N(0), sub @
..] => c
!(sub
, &[N
], n
![1, 2, 3, 4]));
1841 m
!(&v
[..], [sub @
.., N(4)] => c
!(sub
, &[N
], n
![0, 1, 2, 3]));
1842 m
!(&v
[..], [sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &[N
], &n
![] as &[N
]));
1843 m
!(&v
[..], [_
, _
, _
, _
, _
, sub @
..] => c
!(sub
, &[N
], &n
![] as &[N
]));
1844 m
!(&vc
[..], [x
, .., y
] => c
!((x
, y
), (&u8, &u8), (&0, &4)));
1846 // Matching slices using default binding modes (&mut):
1847 let [..] = &mut v
[..]; // Always matches.
1848 m
!(&mut v
[..], [N(0), sub @
.., N(4)] => c
!(sub
, &mut [N
], n
![1, 2, 3]));
1849 m
!(&mut v
[..], [N(0), sub @
..] => c
!(sub
, &mut [N
], n
![1, 2, 3, 4]));
1850 m
!(&mut v
[..], [sub @
.., N(4)] => c
!(sub
, &mut [N
], n
![0, 1, 2, 3]));
1851 m
!(&mut v
[..], [sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &mut [N
], &mut n
![] as &mut [N
]));
1852 m
!(&mut v
[..], [_
, _
, _
, _
, _
, sub @
..] => c
!(sub
, &mut [N
], &mut n
![] as &mut [N
]));
1853 m
!(&mut vc
[..], [x
, .., y
] => c
!((x
, y
), (&mut u8, &mut u8), (&mut 0, &mut 4)));
1856 let mut v
= n
![0, 1, 2, 3, 4];
1857 let vc
= [0, 1, 2, 3, 4];
1859 // Matching arrays by value:
1860 m
!(v
.clone(), [N(0), sub @
.., N(4)] => c
!(sub
, [N
; 3], n
![1, 2, 3]));
1861 m
!(v
.clone(), [N(0), sub @
..] => c
!(sub
, [N
; 4], n
![1, 2, 3, 4]));
1862 m
!(v
.clone(), [sub @
.., N(4)] => c
!(sub
, [N
; 4], n
![0, 1, 2, 3]));
1863 m
!(v
.clone(), [sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, [N
; 0], n
![] as [N
; 0]));
1864 m
!(v
.clone(), [_
, _
, _
, _
, _
, sub @
..] => c
!(sub
, [N
; 0], n
![] as [N
; 0]));
1865 m
!(v
.clone(), [x
, .., y
] => c
!((x
, y
), (N
, N
), (N(0), N(4))));
1866 m
!(v
.clone(), [..] => ());
1868 // Matching arrays by ref patterns:
1869 m
!(v
, [N(0), ref sub @
.., N(4)] => c
!(sub
, &[N
; 3], &n
![1, 2, 3]));
1870 m
!(v
, [N(0), ref sub @
..] => c
!(sub
, &[N
; 4], &n
![1, 2, 3, 4]));
1871 m
!(v
, [ref sub @
.., N(4)] => c
!(sub
, &[N
; 4], &n
![0, 1, 2, 3]));
1872 m
!(v
, [ref sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &[N
; 0], &n
![] as &[N
; 0]));
1873 m
!(v
, [_
, _
, _
, _
, _
, ref sub @
..] => c
!(sub
, &[N
; 0], &n
![] as &[N
; 0]));
1874 m
!(vc
, [x
, .., y
] => c
!((x
, y
), (u8, u8), (0, 4)));
1876 // Matching arrays by ref mut patterns:
1877 m
!(v
, [N(0), ref mut sub @
.., N(4)] => c
!(sub
, &mut [N
; 3], &mut n
![1, 2, 3]));
1878 m
!(v
, [N(0), ref mut sub @
..] => c
!(sub
, &mut [N
; 4], &mut n
![1, 2, 3, 4]));
1879 m
!(v
, [ref mut sub @
.., N(4)] => c
!(sub
, &mut [N
; 4], &mut n
![0, 1, 2, 3]));
1880 m
!(v
, [ref mut sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &mut [N
; 0], &mut n
![] as &mut [N
; 0]));
1881 m
!(v
, [_
, _
, _
, _
, _
, ref mut sub @
..] => c
!(sub
, &mut [N
; 0], &mut n
![] as &mut [N
; 0]));
1883 // Matching arrays by default binding modes (&):
1884 m
!(&v
, [N(0), sub @
.., N(4)] => c
!(sub
, &[N
; 3], &n
![1, 2, 3]));
1885 m
!(&v
, [N(0), sub @
..] => c
!(sub
, &[N
; 4], &n
![1, 2, 3, 4]));
1886 m
!(&v
, [sub @
.., N(4)] => c
!(sub
, &[N
; 4], &n
![0, 1, 2, 3]));
1887 m
!(&v
, [sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &[N
; 0], &n
![] as &[N
; 0]));
1888 m
!(&v
, [_
, _
, _
, _
, _
, sub @
..] => c
!(sub
, &[N
; 0], &n
![] as &[N
; 0]));
1890 m
!(&v
, [x
, .., y
] => c
!((x
, y
), (&N
, &N
), (&N(0), &N(4))));
1892 // Matching arrays by default binding modes (&mut):
1893 m
!(&mut v
, [N(0), sub @
.., N(4)] => c
!(sub
, &mut [N
; 3], &mut n
![1, 2, 3]));
1894 m
!(&mut v
, [N(0), sub @
..] => c
!(sub
, &mut [N
; 4], &mut n
![1, 2, 3, 4]));
1895 m
!(&mut v
, [sub @
.., N(4)] => c
!(sub
, &mut [N
; 4], &mut n
![0, 1, 2, 3]));
1896 m
!(&mut v
, [sub @
.., _
, _
, _
, _
, _
] => c
!(sub
, &mut [N
; 0], &mut n
![] as &[N
; 0]));
1897 m
!(&mut v
, [_
, _
, _
, _
, _
, sub @
..] => c
!(sub
, &mut [N
; 0], &mut n
![] as &[N
; 0]));
1898 m
!(&mut v
, [..] => ());
1899 m
!(&mut v
, [x
, .., y
] => c
!((x
, y
), (&mut N
, &mut N
), (&mut N(0), &mut N(4))));
1903 fn test_group_by() {
1904 let slice
= &[1, 1, 1, 3, 3, 2, 2, 2, 1, 0];
1906 let mut iter
= slice
.group_by(|a
, b
| a
== b
);
1907 assert_eq
!(iter
.next(), Some(&[1, 1, 1][..]));
1908 assert_eq
!(iter
.next(), Some(&[3, 3][..]));
1909 assert_eq
!(iter
.next(), Some(&[2, 2, 2][..]));
1910 assert_eq
!(iter
.next(), Some(&[1][..]));
1911 assert_eq
!(iter
.next(), Some(&[0][..]));
1912 assert_eq
!(iter
.next(), None
);
1914 let mut iter
= slice
.group_by(|a
, b
| a
== b
);
1915 assert_eq
!(iter
.next_back(), Some(&[0][..]));
1916 assert_eq
!(iter
.next_back(), Some(&[1][..]));
1917 assert_eq
!(iter
.next_back(), Some(&[2, 2, 2][..]));
1918 assert_eq
!(iter
.next_back(), Some(&[3, 3][..]));
1919 assert_eq
!(iter
.next_back(), Some(&[1, 1, 1][..]));
1920 assert_eq
!(iter
.next_back(), None
);
1922 let mut iter
= slice
.group_by(|a
, b
| a
== b
);
1923 assert_eq
!(iter
.next(), Some(&[1, 1, 1][..]));
1924 assert_eq
!(iter
.next_back(), Some(&[0][..]));
1925 assert_eq
!(iter
.next(), Some(&[3, 3][..]));
1926 assert_eq
!(iter
.next_back(), Some(&[1][..]));
1927 assert_eq
!(iter
.next(), Some(&[2, 2, 2][..]));
1928 assert_eq
!(iter
.next_back(), None
);
1932 fn test_group_by_mut() {
1933 let slice
= &mut [1, 1, 1, 3, 3, 2, 2, 2, 1, 0];
1935 let mut iter
= slice
.group_by_mut(|a
, b
| a
== b
);
1936 assert_eq
!(iter
.next(), Some(&mut [1, 1, 1][..]));
1937 assert_eq
!(iter
.next(), Some(&mut [3, 3][..]));
1938 assert_eq
!(iter
.next(), Some(&mut [2, 2, 2][..]));
1939 assert_eq
!(iter
.next(), Some(&mut [1][..]));
1940 assert_eq
!(iter
.next(), Some(&mut [0][..]));
1941 assert_eq
!(iter
.next(), None
);
1943 let mut iter
= slice
.group_by_mut(|a
, b
| a
== b
);
1944 assert_eq
!(iter
.next_back(), Some(&mut [0][..]));
1945 assert_eq
!(iter
.next_back(), Some(&mut [1][..]));
1946 assert_eq
!(iter
.next_back(), Some(&mut [2, 2, 2][..]));
1947 assert_eq
!(iter
.next_back(), Some(&mut [3, 3][..]));
1948 assert_eq
!(iter
.next_back(), Some(&mut [1, 1, 1][..]));
1949 assert_eq
!(iter
.next_back(), None
);
1951 let mut iter
= slice
.group_by_mut(|a
, b
| a
== b
);
1952 assert_eq
!(iter
.next(), Some(&mut [1, 1, 1][..]));
1953 assert_eq
!(iter
.next_back(), Some(&mut [0][..]));
1954 assert_eq
!(iter
.next(), Some(&mut [3, 3][..]));
1955 assert_eq
!(iter
.next_back(), Some(&mut [1][..]));
1956 assert_eq
!(iter
.next(), Some(&mut [2, 2, 2][..]));
1957 assert_eq
!(iter
.next_back(), None
);