2 use std
::cmp
::Ordering
::{self, Equal, Greater, Less}
;
6 use std
::sync
::atomic
::{Ordering::Relaxed, AtomicUsize}
;
9 use rand
::{Rng, RngCore, thread_rng}
;
10 use rand
::seq
::SliceRandom
;
11 use rand
::distributions
::Standard
;
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
);
240 assert_eq
!(v
.len(), 0);
241 assert_eq
!(e
, Some(5));
249 fn test_swap_remove() {
250 let mut v
= vec
![1, 2, 3, 4, 5];
251 let mut e
= v
.swap_remove(0);
253 assert_eq
!(v
, [5, 2, 3, 4]);
254 e
= v
.swap_remove(3);
256 assert_eq
!(v
, [5, 2, 3]);
261 #[cfg(not(miri))] // Miri does not support panics
262 fn test_swap_remove_fail() {
264 let _
= v
.swap_remove(0);
265 let _
= v
.swap_remove(0);
269 fn test_swap_remove_noncopyable() {
270 // Tests that we don't accidentally run destructors twice.
271 let mut v
: Vec
<Box
<_
>> = Vec
::new();
275 let mut _e
= v
.swap_remove(0);
276 assert_eq
!(v
.len(), 2);
277 _e
= v
.swap_remove(1);
278 assert_eq
!(v
.len(), 1);
279 _e
= v
.swap_remove(0);
280 assert_eq
!(v
.len(), 0);
285 // Test on-stack push().
288 assert_eq
!(v
.len(), 1);
291 // Test on-heap push().
293 assert_eq
!(v
.len(), 2);
300 let mut v
: Vec
<Box
<_
>> = vec
![box 6, box 5, box 4];
303 assert_eq
!(v
.len(), 1);
304 assert_eq
!(*(v
[0]), 6);
305 // If the unsafe block didn't drop things properly, we blow up here.
310 let mut v
: Vec
<Box
<_
>> = vec
![box 6, box 5, box 4];
312 assert_eq
!(v
.len(), 0);
313 // If the unsafe block didn't drop things properly, we blow up here.
318 let mut v
= vec
![1, 2, 3, 4, 5];
320 assert_eq
!(v
, [1, 3, 5]);
324 fn test_binary_search() {
325 assert_eq
!([1, 2, 3, 4, 5].binary_search(&5).ok(), Some(4));
326 assert_eq
!([1, 2, 3, 4, 5].binary_search(&4).ok(), Some(3));
327 assert_eq
!([1, 2, 3, 4, 5].binary_search(&3).ok(), Some(2));
328 assert_eq
!([1, 2, 3, 4, 5].binary_search(&2).ok(), Some(1));
329 assert_eq
!([1, 2, 3, 4, 5].binary_search(&1).ok(), Some(0));
331 assert_eq
!([2, 4, 6, 8, 10].binary_search(&1).ok(), None
);
332 assert_eq
!([2, 4, 6, 8, 10].binary_search(&5).ok(), None
);
333 assert_eq
!([2, 4, 6, 8, 10].binary_search(&4).ok(), Some(1));
334 assert_eq
!([2, 4, 6, 8, 10].binary_search(&10).ok(), Some(4));
336 assert_eq
!([2, 4, 6, 8].binary_search(&1).ok(), None
);
337 assert_eq
!([2, 4, 6, 8].binary_search(&5).ok(), None
);
338 assert_eq
!([2, 4, 6, 8].binary_search(&4).ok(), Some(1));
339 assert_eq
!([2, 4, 6, 8].binary_search(&8).ok(), Some(3));
341 assert_eq
!([2, 4, 6].binary_search(&1).ok(), None
);
342 assert_eq
!([2, 4, 6].binary_search(&5).ok(), None
);
343 assert_eq
!([2, 4, 6].binary_search(&4).ok(), Some(1));
344 assert_eq
!([2, 4, 6].binary_search(&6).ok(), Some(2));
346 assert_eq
!([2, 4].binary_search(&1).ok(), None
);
347 assert_eq
!([2, 4].binary_search(&5).ok(), None
);
348 assert_eq
!([2, 4].binary_search(&2).ok(), Some(0));
349 assert_eq
!([2, 4].binary_search(&4).ok(), Some(1));
351 assert_eq
!([2].binary_search(&1).ok(), None
);
352 assert_eq
!([2].binary_search(&5).ok(), None
);
353 assert_eq
!([2].binary_search(&2).ok(), Some(0));
355 assert_eq
!([].binary_search(&1).ok(), None
);
356 assert_eq
!([].binary_search(&5).ok(), None
);
358 assert
!([1, 1, 1, 1, 1].binary_search(&1).ok() != None
);
359 assert
!([1, 1, 1, 1, 2].binary_search(&1).ok() != None
);
360 assert
!([1, 1, 1, 2, 2].binary_search(&1).ok() != None
);
361 assert
!([1, 1, 2, 2, 2].binary_search(&1).ok() != None
);
362 assert_eq
!([1, 2, 2, 2, 2].binary_search(&1).ok(), Some(0));
364 assert_eq
!([1, 2, 3, 4, 5].binary_search(&6).ok(), None
);
365 assert_eq
!([1, 2, 3, 4, 5].binary_search(&0).ok(), None
);
370 let mut v
= vec
![10, 20];
371 assert_eq
!(v
[0], 10);
372 assert_eq
!(v
[1], 20);
374 assert_eq
!(v
[0], 20);
375 assert_eq
!(v
[1], 10);
377 let mut v3
= Vec
::<i32>::new();
379 assert
!(v3
.is_empty());
381 // check the 1-byte-types path
382 let mut v
= (-50..51i8).collect
::<Vec
<_
>>();
384 assert_eq
!(v
, (-50..51i8).rev().collect
::<Vec
<_
>>());
386 // check the 2-byte-types path
387 let mut v
= (-50..51i16).collect
::<Vec
<_
>>();
389 assert_eq
!(v
, (-50..51i16).rev().collect
::<Vec
<_
>>());
393 #[cfg(not(miri))] // Miri does not support entropy
395 let mut rng
= thread_rng();
397 for len
in (2..25).chain(500..510) {
398 for &modulus
in &[5, 10, 100, 1000] {
400 let orig
: Vec
<_
> = rng
.sample_iter
::<i32, _
>(&Standard
)
401 .map(|x
| x
% modulus
)
405 // Sort in default order.
406 let mut v
= orig
.clone();
408 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
410 // Sort in ascending order.
411 let mut v
= orig
.clone();
412 v
.sort_by(|a
, b
| a
.cmp(b
));
413 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
415 // Sort in descending order.
416 let mut v
= orig
.clone();
417 v
.sort_by(|a
, b
| b
.cmp(a
));
418 assert
!(v
.windows(2).all(|w
| w
[0] >= w
[1]));
420 // Sort in lexicographic order.
421 let mut v1
= orig
.clone();
422 let mut v2
= orig
.clone();
423 v1
.sort_by_key(|x
| x
.to_string());
424 v2
.sort_by_cached_key(|x
| x
.to_string());
425 assert
!(v1
.windows(2).all(|w
| w
[0].to_string() <= w
[1].to_string()));
428 // Sort with many pre-sorted runs.
429 let mut v
= orig
.clone();
433 let a
= rng
.gen
::<usize>() % len
;
434 let b
= rng
.gen
::<usize>() % len
;
442 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
447 // Sort using a completely random comparison function.
448 // This will reorder the elements *somehow*, but won't panic.
449 let mut v
= [0; 500];
450 for i
in 0..v
.len() {
453 v
.sort_by(|_
, _
| *[Less
, Equal
, Greater
].choose(&mut rng
).unwrap());
455 for i
in 0..v
.len() {
456 assert_eq
!(v
[i
], i
as i32);
464 let mut v
= [0xDEADBEEFu64];
466 assert
!(v
== [0xDEADBEEF]);
470 #[cfg(not(miri))] // Miri does not support entropy
471 fn test_sort_stability() {
472 for len
in (2..25).chain(500..510) {
474 let mut counts
= [0; 10];
476 // create a vector like [(6, 1), (5, 1), (6, 2), ...],
477 // where the first item of each tuple is random, but
478 // the second item represents which occurrence of that
479 // number this element is, i.e., the second elements
480 // will occur in sorted order.
481 let orig
: Vec
<_
> = (0..len
)
483 let n
= thread_rng().gen
::<usize>() % 10;
489 let mut v
= orig
.clone();
490 // Only sort on the first element, so an unstable sort
491 // may mix up the counts.
492 v
.sort_by(|&(a
, _
), &(b
, _
)| a
.cmp(&b
));
494 // This comparison includes the count (the second item
495 // of the tuple), so elements with equal first items
496 // will need to be ordered with increasing
497 // counts... i.e., exactly asserting that this sort is
499 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
501 let mut v
= orig
.clone();
502 v
.sort_by_cached_key(|&(x
, _
)| x
);
503 assert
!(v
.windows(2).all(|w
| w
[0] <= w
[1]));
509 fn test_rotate_left() {
510 let expected
: Vec
<_
> = (0..13).collect();
511 let mut v
= Vec
::new();
514 v
.clone_from(&expected
);
516 assert_eq
!(v
, expected
);
517 v
.rotate_left(expected
.len());
518 assert_eq
!(v
, expected
);
519 let mut zst_array
= [(), (), ()];
520 zst_array
.rotate_left(2);
523 v
= (5..13).chain(0..5).collect();
525 assert_eq
!(v
, expected
);
527 let expected
: Vec
<_
> = (0..1000).collect();
529 // small rotations in large slice, uses ptr::copy
530 v
= (2..1000).chain(0..2).collect();
532 assert_eq
!(v
, expected
);
533 v
= (998..1000).chain(0..998).collect();
535 assert_eq
!(v
, expected
);
537 // non-small prime rotation, has a few rounds of swapping
538 v
= (389..1000).chain(0..389).collect();
539 v
.rotate_left(1000-389);
540 assert_eq
!(v
, expected
);
544 fn test_rotate_right() {
545 let expected
: Vec
<_
> = (0..13).collect();
546 let mut v
= Vec
::new();
549 v
.clone_from(&expected
);
551 assert_eq
!(v
, expected
);
552 v
.rotate_right(expected
.len());
553 assert_eq
!(v
, expected
);
554 let mut zst_array
= [(), (), ()];
555 zst_array
.rotate_right(2);
558 v
= (5..13).chain(0..5).collect();
560 assert_eq
!(v
, expected
);
562 let expected
: Vec
<_
> = (0..1000).collect();
564 // small rotations in large slice, uses ptr::copy
565 v
= (2..1000).chain(0..2).collect();
567 assert_eq
!(v
, expected
);
568 v
= (998..1000).chain(0..998).collect();
570 assert_eq
!(v
, expected
);
572 // non-small prime rotation, has a few rounds of swapping
573 v
= (389..1000).chain(0..389).collect();
575 assert_eq
!(v
, expected
);
580 let v
: [Vec
<i32>; 0] = [];
583 let d
= [vec
![1], vec
![2, 3]].concat();
584 assert_eq
!(d
, [1, 2, 3]);
586 let v
: &[&[_
]] = &[&[1], &[2, 3]];
587 assert_eq
!(v
.join(&0), [1, 0, 2, 3]);
588 let v
: &[&[_
]] = &[&[1], &[2], &[3]];
589 assert_eq
!(v
.join(&0), [1, 0, 2, 0, 3]);
594 let v
: [Vec
<i32>; 0] = [];
595 assert_eq
!(v
.join(&0), []);
596 assert_eq
!([vec
![1], vec
![2, 3]].join(&0), [1, 0, 2, 3]);
597 assert_eq
!([vec
![1], vec
![2], vec
![3]].join(&0), [1, 0, 2, 0, 3]);
599 let v
: [&[_
]; 2] = [&[1], &[2, 3]];
600 assert_eq
!(v
.join(&0), [1, 0, 2, 3]);
601 let v
: [&[_
]; 3] = [&[1], &[2], &[3]];
602 assert_eq
!(v
.join(&0), [1, 0, 2, 0, 3]);
606 fn test_join_nocopy() {
607 let v
: [String
; 0] = [];
608 assert_eq
!(v
.join(","), "");
609 assert_eq
!(["a".to_string(), "ab".into()].join(","), "a,ab");
610 assert_eq
!(["a".to_string(), "ab".into(), "abc".into()].join(","), "a,ab,abc");
611 assert_eq
!(["a".to_string(), "ab".into(), "".into()].join(","), "a,ab,");
616 let mut a
= vec
![1, 2, 4];
618 assert_eq
!(a
, [1, 2, 3, 4]);
620 let mut a
= vec
![1, 2, 3];
622 assert_eq
!(a
, [0, 1, 2, 3]);
624 let mut a
= vec
![1, 2, 3];
626 assert_eq
!(a
, [1, 2, 3, 4]);
635 #[cfg(not(miri))] // Miri does not support panics
636 fn test_insert_oob() {
637 let mut a
= vec
![1, 2, 3];
643 let mut a
= vec
![1, 2, 3, 4];
645 assert_eq
!(a
.remove(2), 3);
646 assert_eq
!(a
, [1, 2, 4]);
648 assert_eq
!(a
.remove(2), 4);
649 assert_eq
!(a
, [1, 2]);
651 assert_eq
!(a
.remove(0), 1);
654 assert_eq
!(a
.remove(0), 2);
660 #[cfg(not(miri))] // Miri does not support panics
661 fn test_remove_fail() {
671 assert
!(v
.capacity() >= 11);
676 let v
= vec
![1, 2, 3, 4, 5];
678 assert_eq
!(v
.len(), 2);
683 macro_rules
! assert_order
{
684 (Greater
, $a
:expr
, $b
:expr
) => {
685 assert_eq
!($a
.cmp($b
), Greater
);
688 (Less
, $a
:expr
, $b
:expr
) => {
689 assert_eq
!($a
.cmp($b
), Less
);
692 (Equal
, $a
:expr
, $b
:expr
) => {
693 assert_eq
!($a
.cmp($b
), Equal
);
699 fn test_total_ord_u8() {
700 let c
= &[1u8, 2, 3];
701 assert_order
!(Greater
, &[1u8, 2, 3, 4][..], &c
[..]);
702 let c
= &[1u8, 2, 3, 4];
703 assert_order
!(Less
, &[1u8, 2, 3][..], &c
[..]);
704 let c
= &[1u8, 2, 3, 6];
705 assert_order
!(Equal
, &[1u8, 2, 3, 6][..], &c
[..]);
706 let c
= &[1u8, 2, 3, 4, 5, 6];
707 assert_order
!(Less
, &[1u8, 2, 3, 4, 5, 5, 5, 5][..], &c
[..]);
708 let c
= &[1u8, 2, 3, 4];
709 assert_order
!(Greater
, &[2u8, 2][..], &c
[..]);
714 fn test_total_ord_i32() {
716 assert_order
!(Greater
, &[1, 2, 3, 4][..], &c
[..]);
717 let c
= &[1, 2, 3, 4];
718 assert_order
!(Less
, &[1, 2, 3][..], &c
[..]);
719 let c
= &[1, 2, 3, 6];
720 assert_order
!(Equal
, &[1, 2, 3, 6][..], &c
[..]);
721 let c
= &[1, 2, 3, 4, 5, 6];
722 assert_order
!(Less
, &[1, 2, 3, 4, 5, 5, 5, 5][..], &c
[..]);
723 let c
= &[1, 2, 3, 4];
724 assert_order
!(Greater
, &[2, 2][..], &c
[..]);
729 let xs
= [1, 2, 5, 10, 11];
730 let mut it
= xs
.iter();
731 assert_eq
!(it
.size_hint(), (5, Some(5)));
732 assert_eq
!(it
.next().unwrap(), &1);
733 assert_eq
!(it
.size_hint(), (4, Some(4)));
734 assert_eq
!(it
.next().unwrap(), &2);
735 assert_eq
!(it
.size_hint(), (3, Some(3)));
736 assert_eq
!(it
.next().unwrap(), &5);
737 assert_eq
!(it
.size_hint(), (2, Some(2)));
738 assert_eq
!(it
.next().unwrap(), &10);
739 assert_eq
!(it
.size_hint(), (1, Some(1)));
740 assert_eq
!(it
.next().unwrap(), &11);
741 assert_eq
!(it
.size_hint(), (0, Some(0)));
742 assert
!(it
.next().is_none());
746 fn test_iter_size_hints() {
747 let mut xs
= [1, 2, 5, 10, 11];
748 assert_eq
!(xs
.iter().size_hint(), (5, Some(5)));
749 assert_eq
!(xs
.iter_mut().size_hint(), (5, Some(5)));
753 fn test_iter_as_slice() {
754 let xs
= [1, 2, 5, 10, 11];
755 let mut iter
= xs
.iter();
756 assert_eq
!(iter
.as_slice(), &[1, 2, 5, 10, 11]);
758 assert_eq
!(iter
.as_slice(), &[2, 5, 10, 11]);
762 fn test_iter_as_ref() {
763 let xs
= [1, 2, 5, 10, 11];
764 let mut iter
= xs
.iter();
765 assert_eq
!(iter
.as_ref(), &[1, 2, 5, 10, 11]);
767 assert_eq
!(iter
.as_ref(), &[2, 5, 10, 11]);
771 fn test_iter_clone() {
773 let mut it
= xs
.iter();
775 let mut jt
= it
.clone();
776 assert_eq
!(it
.next(), jt
.next());
777 assert_eq
!(it
.next(), jt
.next());
778 assert_eq
!(it
.next(), jt
.next());
782 fn test_iter_is_empty() {
783 let xs
= [1, 2, 5, 10, 11];
784 for i
in 0..xs
.len() {
785 for j
in i
..xs
.len() {
786 assert_eq
!(xs
[i
..j
].iter().is_empty(), xs
[i
..j
].is_empty());
792 fn test_mut_iterator() {
793 let mut xs
= [1, 2, 3, 4, 5];
797 assert
!(xs
== [2, 3, 4, 5, 6])
801 fn test_rev_iterator() {
803 let xs
= [1, 2, 5, 10, 11];
804 let ys
= [11, 10, 5, 2, 1];
806 for &x
in xs
.iter().rev() {
807 assert_eq
!(x
, ys
[i
]);
814 fn test_mut_rev_iterator() {
815 let mut xs
= [1, 2, 3, 4, 5];
816 for (i
, x
) in xs
.iter_mut().rev().enumerate() {
819 assert
!(xs
== [5, 5, 5, 5, 5])
823 fn test_move_iterator() {
824 let xs
= vec
![1, 2, 3, 4, 5];
825 assert_eq
!(xs
.into_iter().fold(0, |a
: usize, b
: usize| 10 * a
+ b
),
830 fn test_move_rev_iterator() {
831 let xs
= vec
![1, 2, 3, 4, 5];
832 assert_eq
!(xs
.into_iter().rev().fold(0, |a
: usize, b
: usize| 10 * a
+ b
),
837 fn test_splitator() {
838 let xs
= &[1, 2, 3, 4, 5];
840 let splits
: &[&[_
]] = &[&[1], &[3], &[5]];
841 assert_eq
!(xs
.split(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
842 let splits
: &[&[_
]] = &[&[], &[2, 3, 4, 5]];
843 assert_eq
!(xs
.split(|x
| *x
== 1).collect
::<Vec
<_
>>(), splits
);
844 let splits
: &[&[_
]] = &[&[1, 2, 3, 4], &[]];
845 assert_eq
!(xs
.split(|x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
846 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
847 assert_eq
!(xs
.split(|x
| *x
== 10).collect
::<Vec
<_
>>(), splits
);
848 let splits
: &[&[_
]] = &[&[], &[], &[], &[], &[], &[]];
849 assert_eq
!(xs
.split(|_
| true).collect
::<Vec
<&[i32]>>(), splits
);
851 let xs
: &[i32] = &[];
852 let splits
: &[&[i32]] = &[&[]];
853 assert_eq
!(xs
.split(|x
| *x
== 5).collect
::<Vec
<&[i32]>>(), splits
);
857 fn test_splitnator() {
858 let xs
= &[1, 2, 3, 4, 5];
860 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
861 assert_eq
!(xs
.splitn(1, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
862 let splits
: &[&[_
]] = &[&[1], &[3, 4, 5]];
863 assert_eq
!(xs
.splitn(2, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
864 let splits
: &[&[_
]] = &[&[], &[], &[], &[4, 5]];
865 assert_eq
!(xs
.splitn(4, |_
| true).collect
::<Vec
<_
>>(), splits
);
867 let xs
: &[i32] = &[];
868 let splits
: &[&[i32]] = &[&[]];
869 assert_eq
!(xs
.splitn(2, |x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
873 fn test_splitnator_mut() {
874 let xs
= &mut [1, 2, 3, 4, 5];
876 let splits
: &[&mut [_
]] = &[&mut [1, 2, 3, 4, 5]];
877 assert_eq
!(xs
.splitn_mut(1, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(),
879 let splits
: &[&mut [_
]] = &[&mut [1], &mut [3, 4, 5]];
880 assert_eq
!(xs
.splitn_mut(2, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(),
882 let splits
: &[&mut [_
]] = &[&mut [], &mut [], &mut [], &mut [4, 5]];
883 assert_eq
!(xs
.splitn_mut(4, |_
| true).collect
::<Vec
<_
>>(), splits
);
885 let xs
: &mut [i32] = &mut [];
886 let splits
: &[&mut [i32]] = &[&mut []];
887 assert_eq
!(xs
.splitn_mut(2, |x
| *x
== 5).collect
::<Vec
<_
>>(), splits
);
891 fn test_rsplitator() {
892 let xs
= &[1, 2, 3, 4, 5];
894 let splits
: &[&[_
]] = &[&[5], &[3], &[1]];
895 assert_eq
!(xs
.split(|x
| *x
% 2 == 0).rev().collect
::<Vec
<_
>>(), splits
);
896 let splits
: &[&[_
]] = &[&[2, 3, 4, 5], &[]];
897 assert_eq
!(xs
.split(|x
| *x
== 1).rev().collect
::<Vec
<_
>>(), splits
);
898 let splits
: &[&[_
]] = &[&[], &[1, 2, 3, 4]];
899 assert_eq
!(xs
.split(|x
| *x
== 5).rev().collect
::<Vec
<_
>>(), splits
);
900 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
901 assert_eq
!(xs
.split(|x
| *x
== 10).rev().collect
::<Vec
<_
>>(), splits
);
903 let xs
: &[i32] = &[];
904 let splits
: &[&[i32]] = &[&[]];
905 assert_eq
!(xs
.split(|x
| *x
== 5).rev().collect
::<Vec
<&[i32]>>(), splits
);
909 fn test_rsplitnator() {
910 let xs
= &[1, 2, 3, 4, 5];
912 let splits
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
913 assert_eq
!(xs
.rsplitn(1, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
914 let splits
: &[&[_
]] = &[&[5], &[1, 2, 3]];
915 assert_eq
!(xs
.rsplitn(2, |x
| *x
% 2 == 0).collect
::<Vec
<_
>>(), splits
);
916 let splits
: &[&[_
]] = &[&[], &[], &[], &[1, 2]];
917 assert_eq
!(xs
.rsplitn(4, |_
| true).collect
::<Vec
<_
>>(), splits
);
919 let xs
: &[i32] = &[];
920 let splits
: &[&[i32]] = &[&[]];
921 assert_eq
!(xs
.rsplitn(2, |x
| *x
== 5).collect
::<Vec
<&[i32]>>(), splits
);
922 assert
!(xs
.rsplitn(0, |x
| *x
% 2 == 0).next().is_none());
926 fn test_windowsator() {
927 let v
= &[1, 2, 3, 4];
929 let wins
: &[&[_
]] = &[&[1, 2], &[2, 3], &[3, 4]];
930 assert_eq
!(v
.windows(2).collect
::<Vec
<_
>>(), wins
);
932 let wins
: &[&[_
]] = &[&[1, 2, 3], &[2, 3, 4]];
933 assert_eq
!(v
.windows(3).collect
::<Vec
<_
>>(), wins
);
934 assert
!(v
.windows(6).next().is_none());
936 let wins
: &[&[_
]] = &[&[3, 4], &[2, 3], &[1, 2]];
937 assert_eq
!(v
.windows(2).rev().collect
::<Vec
<&[_
]>>(), wins
);
942 #[cfg(not(miri))] // Miri does not support panics
943 fn test_windowsator_0() {
944 let v
= &[1, 2, 3, 4];
945 let _it
= v
.windows(0);
949 fn test_chunksator() {
950 let v
= &[1, 2, 3, 4, 5];
952 assert_eq
!(v
.chunks(2).len(), 3);
954 let chunks
: &[&[_
]] = &[&[1, 2], &[3, 4], &[5]];
955 assert_eq
!(v
.chunks(2).collect
::<Vec
<_
>>(), chunks
);
956 let chunks
: &[&[_
]] = &[&[1, 2, 3], &[4, 5]];
957 assert_eq
!(v
.chunks(3).collect
::<Vec
<_
>>(), chunks
);
958 let chunks
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
959 assert_eq
!(v
.chunks(6).collect
::<Vec
<_
>>(), chunks
);
961 let chunks
: &[&[_
]] = &[&[5], &[3, 4], &[1, 2]];
962 assert_eq
!(v
.chunks(2).rev().collect
::<Vec
<_
>>(), chunks
);
967 #[cfg(not(miri))] // Miri does not support panics
968 fn test_chunksator_0() {
969 let v
= &[1, 2, 3, 4];
970 let _it
= v
.chunks(0);
974 fn test_chunks_exactator() {
975 let v
= &[1, 2, 3, 4, 5];
977 assert_eq
!(v
.chunks_exact(2).len(), 2);
979 let chunks
: &[&[_
]] = &[&[1, 2], &[3, 4]];
980 assert_eq
!(v
.chunks_exact(2).collect
::<Vec
<_
>>(), chunks
);
981 let chunks
: &[&[_
]] = &[&[1, 2, 3]];
982 assert_eq
!(v
.chunks_exact(3).collect
::<Vec
<_
>>(), chunks
);
983 let chunks
: &[&[_
]] = &[];
984 assert_eq
!(v
.chunks_exact(6).collect
::<Vec
<_
>>(), chunks
);
986 let chunks
: &[&[_
]] = &[&[3, 4], &[1, 2]];
987 assert_eq
!(v
.chunks_exact(2).rev().collect
::<Vec
<_
>>(), chunks
);
992 #[cfg(not(miri))] // Miri does not support panics
993 fn test_chunks_exactator_0() {
994 let v
= &[1, 2, 3, 4];
995 let _it
= v
.chunks_exact(0);
999 fn test_rchunksator() {
1000 let v
= &[1, 2, 3, 4, 5];
1002 assert_eq
!(v
.rchunks(2).len(), 3);
1004 let chunks
: &[&[_
]] = &[&[4, 5], &[2, 3], &[1]];
1005 assert_eq
!(v
.rchunks(2).collect
::<Vec
<_
>>(), chunks
);
1006 let chunks
: &[&[_
]] = &[&[3, 4, 5], &[1, 2]];
1007 assert_eq
!(v
.rchunks(3).collect
::<Vec
<_
>>(), chunks
);
1008 let chunks
: &[&[_
]] = &[&[1, 2, 3, 4, 5]];
1009 assert_eq
!(v
.rchunks(6).collect
::<Vec
<_
>>(), chunks
);
1011 let chunks
: &[&[_
]] = &[&[1], &[2, 3], &[4, 5]];
1012 assert_eq
!(v
.rchunks(2).rev().collect
::<Vec
<_
>>(), chunks
);
1017 #[cfg(not(miri))] // Miri does not support panics
1018 fn test_rchunksator_0() {
1019 let v
= &[1, 2, 3, 4];
1020 let _it
= v
.rchunks(0);
1024 fn test_rchunks_exactator() {
1025 let v
= &[1, 2, 3, 4, 5];
1027 assert_eq
!(v
.rchunks_exact(2).len(), 2);
1029 let chunks
: &[&[_
]] = &[&[4, 5], &[2, 3]];
1030 assert_eq
!(v
.rchunks_exact(2).collect
::<Vec
<_
>>(), chunks
);
1031 let chunks
: &[&[_
]] = &[&[3, 4, 5]];
1032 assert_eq
!(v
.rchunks_exact(3).collect
::<Vec
<_
>>(), chunks
);
1033 let chunks
: &[&[_
]] = &[];
1034 assert_eq
!(v
.rchunks_exact(6).collect
::<Vec
<_
>>(), chunks
);
1036 let chunks
: &[&[_
]] = &[&[2, 3], &[4, 5]];
1037 assert_eq
!(v
.rchunks_exact(2).rev().collect
::<Vec
<_
>>(), chunks
);
1042 #[cfg(not(miri))] // Miri does not support panics
1043 fn test_rchunks_exactator_0() {
1044 let v
= &[1, 2, 3, 4];
1045 let _it
= v
.rchunks_exact(0);
1049 fn test_reverse_part() {
1050 let mut values
= [1, 2, 3, 4, 5];
1051 values
[1..4].reverse();
1052 assert
!(values
== [1, 4, 3, 2, 5]);
1057 macro_rules
! test_show_vec
{
1058 ($x
:expr
, $x_str
:expr
) => ({
1059 let (x
, x_str
) = ($x
, $x_str
);
1060 assert_eq
!(format
!("{:?}", x
), x_str
);
1061 assert_eq
!(format
!("{:?}", x
), x_str
);
1064 let empty
= Vec
::<i32>::new();
1065 test_show_vec
!(empty
, "[]");
1066 test_show_vec
!(vec
![1], "[1]");
1067 test_show_vec
!(vec
![1, 2, 3], "[1, 2, 3]");
1068 test_show_vec
!(vec
![vec
![], vec
![1], vec
![1, 1]], "[[], [1], [1, 1]]");
1070 let empty_mut
: &mut [i32] = &mut [];
1071 test_show_vec
!(empty_mut
, "[]");
1073 test_show_vec
!(v
, "[1]");
1074 let v
= &mut [1, 2, 3];
1075 test_show_vec
!(v
, "[1, 2, 3]");
1076 let v
: &mut [&mut [_
]] = &mut [&mut [], &mut [1], &mut [1, 1]];
1077 test_show_vec
!(v
, "[[], [1], [1, 1]]");
1081 fn test_vec_default() {
1084 let v
: $ty
= Default
::default();
1085 assert
!(v
.is_empty());
1095 #[cfg(not(miri))] // Miri does not support panics
1096 fn test_overflow_does_not_cause_segfault() {
1098 v
.reserve_exact(!0);
1105 #[cfg(not(miri))] // Miri does not support panics
1106 fn test_overflow_does_not_cause_segfault_managed() {
1107 let mut v
= vec
![Rc
::new(1)];
1108 v
.reserve_exact(!0);
1113 fn test_mut_split_at() {
1114 let mut values
= [1, 2, 3, 4, 5];
1116 let (left
, right
) = values
.split_at_mut(2);
1118 let left
: &[_
] = left
;
1119 assert
!(left
[..left
.len()] == [1, 2]);
1126 let right
: &[_
] = right
;
1127 assert
!(right
[..right
.len()] == [3, 4, 5]);
1134 assert
!(values
== [2, 3, 5, 6, 7]);
1137 #[derive(Clone, PartialEq)]
1141 fn test_iter_zero_sized() {
1142 let mut v
= vec
![Foo
, Foo
, Foo
];
1143 assert_eq
!(v
.len(), 3);
1168 assert_eq
!(cnt
, 11);
1170 let xs
: [Foo
; 3] = [Foo
, Foo
, Foo
];
1180 fn test_shrink_to_fit() {
1181 let mut xs
= vec
![0, 1, 2, 3];
1185 assert_eq
!(xs
.capacity(), 128);
1187 assert_eq
!(xs
.capacity(), 100);
1188 assert_eq
!(xs
, (0..100).collect
::<Vec
<_
>>());
1192 fn test_starts_with() {
1193 assert
!(b
"foobar".starts_with(b
"foo"));
1194 assert
!(!b
"foobar".starts_with(b
"oob"));
1195 assert
!(!b
"foobar".starts_with(b
"bar"));
1196 assert
!(!b
"foo".starts_with(b
"foobar"));
1197 assert
!(!b
"bar".starts_with(b
"foobar"));
1198 assert
!(b
"foobar".starts_with(b
"foobar"));
1199 let empty
: &[u8] = &[];
1200 assert
!(empty
.starts_with(empty
));
1201 assert
!(!empty
.starts_with(b
"foo"));
1202 assert
!(b
"foobar".starts_with(empty
));
1206 fn test_ends_with() {
1207 assert
!(b
"foobar".ends_with(b
"bar"));
1208 assert
!(!b
"foobar".ends_with(b
"oba"));
1209 assert
!(!b
"foobar".ends_with(b
"foo"));
1210 assert
!(!b
"foo".ends_with(b
"foobar"));
1211 assert
!(!b
"bar".ends_with(b
"foobar"));
1212 assert
!(b
"foobar".ends_with(b
"foobar"));
1213 let empty
: &[u8] = &[];
1214 assert
!(empty
.ends_with(empty
));
1215 assert
!(!empty
.ends_with(b
"foo"));
1216 assert
!(b
"foobar".ends_with(empty
));
1220 fn test_mut_splitator() {
1221 let mut xs
= [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
1222 assert_eq
!(xs
.split_mut(|x
| *x
== 0).count(), 6);
1223 for slice
in xs
.split_mut(|x
| *x
== 0) {
1226 assert
!(xs
== [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]);
1228 let mut xs
= [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7];
1229 for slice
in xs
.split_mut(|x
| *x
== 0).take(5) {
1232 assert
!(xs
== [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]);
1236 fn test_mut_splitator_rev() {
1237 let mut xs
= [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
1238 for slice
in xs
.split_mut(|x
| *x
== 0).rev().take(4) {
1241 assert
!(xs
== [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]);
1246 let mut v
= [0, 1, 2];
1247 assert_eq
!(v
.get_mut(3), None
);
1248 v
.get_mut(1).map(|e
| *e
= 7);
1249 assert_eq
!(v
[1], 7);
1251 assert_eq
!(v
.get_mut(2), Some(&mut x
));
1255 fn test_mut_chunks() {
1256 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1257 assert_eq
!(v
.chunks_mut(3).len(), 3);
1258 for (i
, chunk
) in v
.chunks_mut(3).enumerate() {
1263 let result
= [0, 0, 0, 1, 1, 1, 2];
1264 assert_eq
!(v
, result
);
1268 fn test_mut_chunks_rev() {
1269 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1270 for (i
, chunk
) in v
.chunks_mut(3).rev().enumerate() {
1275 let result
= [2, 2, 2, 1, 1, 1, 0];
1276 assert_eq
!(v
, result
);
1281 #[cfg(not(miri))] // Miri does not support panics
1282 fn test_mut_chunks_0() {
1283 let mut v
= [1, 2, 3, 4];
1284 let _it
= v
.chunks_mut(0);
1288 fn test_mut_chunks_exact() {
1289 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1290 assert_eq
!(v
.chunks_exact_mut(3).len(), 2);
1291 for (i
, chunk
) in v
.chunks_exact_mut(3).enumerate() {
1296 let result
= [0, 0, 0, 1, 1, 1, 6];
1297 assert_eq
!(v
, result
);
1301 fn test_mut_chunks_exact_rev() {
1302 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1303 for (i
, chunk
) in v
.chunks_exact_mut(3).rev().enumerate() {
1308 let result
= [1, 1, 1, 0, 0, 0, 6];
1309 assert_eq
!(v
, result
);
1314 #[cfg(not(miri))] // Miri does not support panics
1315 fn test_mut_chunks_exact_0() {
1316 let mut v
= [1, 2, 3, 4];
1317 let _it
= v
.chunks_exact_mut(0);
1321 fn test_mut_rchunks() {
1322 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1323 assert_eq
!(v
.rchunks_mut(3).len(), 3);
1324 for (i
, chunk
) in v
.rchunks_mut(3).enumerate() {
1329 let result
= [2, 1, 1, 1, 0, 0, 0];
1330 assert_eq
!(v
, result
);
1334 fn test_mut_rchunks_rev() {
1335 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1336 for (i
, chunk
) in v
.rchunks_mut(3).rev().enumerate() {
1341 let result
= [0, 1, 1, 1, 2, 2, 2];
1342 assert_eq
!(v
, result
);
1347 #[cfg(not(miri))] // Miri does not support panics
1348 fn test_mut_rchunks_0() {
1349 let mut v
= [1, 2, 3, 4];
1350 let _it
= v
.rchunks_mut(0);
1354 fn test_mut_rchunks_exact() {
1355 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1356 assert_eq
!(v
.rchunks_exact_mut(3).len(), 2);
1357 for (i
, chunk
) in v
.rchunks_exact_mut(3).enumerate() {
1362 let result
= [0, 1, 1, 1, 0, 0, 0];
1363 assert_eq
!(v
, result
);
1367 fn test_mut_rchunks_exact_rev() {
1368 let mut v
= [0, 1, 2, 3, 4, 5, 6];
1369 for (i
, chunk
) in v
.rchunks_exact_mut(3).rev().enumerate() {
1374 let result
= [0, 0, 0, 0, 1, 1, 1];
1375 assert_eq
!(v
, result
);
1380 #[cfg(not(miri))] // Miri does not support panics
1381 fn test_mut_rchunks_exact_0() {
1382 let mut v
= [1, 2, 3, 4];
1383 let _it
= v
.rchunks_exact_mut(0);
1387 fn test_mut_last() {
1388 let mut x
= [1, 2, 3, 4, 5];
1389 let h
= x
.last_mut();
1390 assert_eq
!(*h
.unwrap(), 5);
1392 let y
: &mut [i32] = &mut [];
1393 assert
!(y
.last_mut().is_none());
1398 let xs
: Box
<_
> = box [1, 2, 3];
1399 let ys
= xs
.to_vec();
1400 assert_eq
!(ys
, [1, 2, 3]);
1404 fn test_box_slice_clone() {
1405 let data
= vec
![vec
![0, 1], vec
![0], vec
![1]];
1406 let data2
= data
.clone().into_boxed_slice().clone().to_vec();
1408 assert_eq
!(data
, data2
);
1412 #[allow(unused_must_use)] // here, we care about the side effects of `.clone()`
1413 #[cfg_attr(target_os = "emscripten", ignore)]
1414 #[cfg(not(miri))] // Miri does not support panics
1415 fn test_box_slice_clone_panics() {
1417 use std
::sync
::atomic
::{AtomicUsize, Ordering}
;
1418 use std
::thread
::spawn
;
1421 count
: Arc
<AtomicUsize
>,
1425 impl Drop
for Canary
{
1426 fn drop(&mut self) {
1427 self.count
.fetch_add(1, Ordering
::SeqCst
);
1431 impl Clone
for Canary
{
1432 fn clone(&self) -> Self {
1438 count
: self.count
.clone(),
1439 panics
: self.panics
,
1444 let drop_count
= Arc
::new(AtomicUsize
::new(0));
1445 let canary
= Canary
{
1446 count
: drop_count
.clone(),
1449 let panic
= Canary
{
1450 count
: drop_count
.clone(),
1455 // When xs is dropped, +5.
1456 let xs
= vec
![canary
.clone(), canary
.clone(), canary
.clone(), panic
, canary
]
1457 .into_boxed_slice();
1459 // When panic is cloned, +3.
1466 assert_eq
!(drop_count
.load(Ordering
::SeqCst
), 8);
1470 fn test_copy_from_slice() {
1471 let src
= [0, 1, 2, 3, 4, 5];
1472 let mut dst
= [0; 6];
1473 dst
.copy_from_slice(&src
);
1474 assert_eq
!(src
, dst
)
1478 #[should_panic(expected = "destination and source slices have different lengths")]
1479 #[cfg(not(miri))] // Miri does not support panics
1480 fn test_copy_from_slice_dst_longer() {
1481 let src
= [0, 1, 2, 3];
1482 let mut dst
= [0; 5];
1483 dst
.copy_from_slice(&src
);
1487 #[should_panic(expected = "destination and source slices have different lengths")]
1488 #[cfg(not(miri))] // Miri does not support panics
1489 fn test_copy_from_slice_dst_shorter() {
1490 let src
= [0, 1, 2, 3];
1491 let mut dst
= [0; 3];
1492 dst
.copy_from_slice(&src
);
1495 const MAX_LEN
: usize = 80;
1497 static DROP_COUNTS
: [AtomicUsize
; MAX_LEN
] = [
1498 // FIXME(RFC 1109): AtomicUsize is not Copy.
1499 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1500 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1501 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1502 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1503 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1504 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1505 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1506 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1507 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1508 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1509 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1510 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1511 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1512 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1513 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1514 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1515 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1516 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1517 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1518 AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0), AtomicUsize
::new(0),
1521 static VERSIONS
: AtomicUsize
= AtomicUsize
::new(0);
1523 #[derive(Clone, Eq)]
1524 struct DropCounter
{
1527 version
: Cell
<usize>,
1530 impl PartialEq
for DropCounter
{
1531 fn eq(&self, other
: &Self) -> bool
{
1532 self.partial_cmp(other
) == Some(Ordering
::Equal
)
1536 impl PartialOrd
for DropCounter
{
1537 fn partial_cmp(&self, other
: &Self) -> Option
<Ordering
> {
1538 self.version
.set(self.version
.get() + 1);
1539 other
.version
.set(other
.version
.get() + 1);
1540 VERSIONS
.fetch_add(2, Relaxed
);
1541 self.x
.partial_cmp(&other
.x
)
1545 impl Ord
for DropCounter
{
1546 fn cmp(&self, other
: &Self) -> Ordering
{
1547 self.partial_cmp(other
).unwrap()
1551 impl Drop
for DropCounter
{
1552 fn drop(&mut self) {
1553 DROP_COUNTS
[self.id
].fetch_add(1, Relaxed
);
1554 VERSIONS
.fetch_sub(self.version
.get(), Relaxed
);
1559 ($input
:ident
, $func
:ident
) => {
1560 let len
= $input
.len();
1562 // Work out the total number of comparisons required to sort
1564 let mut count
= 0usize
;
1565 $input
.to_owned().$
func(|a
, b
| { count += 1; a.cmp(b) }
);
1567 // ... and then panic on each and every single one.
1568 for panic_countdown
in 0..count
{
1569 // Refresh the counters.
1570 VERSIONS
.store(0, Relaxed
);
1572 DROP_COUNTS
[i
].store(0, Relaxed
);
1575 let v
= $input
.to_owned();
1576 let _
= thread
::spawn(move || {
1578 let mut panic_countdown
= panic_countdown
;
1580 if panic_countdown
== 0 {
1581 SILENCE_PANIC
.with(|s
| s
.set(true));
1584 panic_countdown
-= 1;
1589 // Check that the number of things dropped is exactly
1590 // what we expect (i.e., the contents of `v`).
1591 for (i
, c
) in DROP_COUNTS
.iter().enumerate().take(len
) {
1592 let count
= c
.load(Relaxed
);
1594 "found drop count == {} for i == {}, len == {}",
1598 // Check that the most recent versions of values were dropped.
1599 assert_eq
!(VERSIONS
.load(Relaxed
), 0);
1604 thread_local
!(static SILENCE_PANIC
: Cell
<bool
> = Cell
::new(false));
1607 #[cfg_attr(target_os = "emscripten", ignore)] // no threads
1608 #[cfg(not(miri))] // Miri does not support panics
1610 let prev
= panic
::take_hook();
1611 panic
::set_hook(Box
::new(move |info
| {
1612 if !SILENCE_PANIC
.with(|s
| s
.get()) {
1617 let mut rng
= thread_rng();
1619 for len
in (1..20).chain(70..MAX_LEN
) {
1620 for &modulus
in &[5, 20, 50] {
1621 for &has_runs
in &[false, true] {
1622 let mut input
= (0..len
)
1625 x
: rng
.next_u32() % modulus
,
1627 version
: Cell
::new(0),
1630 .collect
::<Vec
<_
>>();
1633 for c
in &mut input
{
1638 let a
= rng
.gen
::<usize>() % len
;
1639 let b
= rng
.gen
::<usize>() % len
;
1641 input
[a
..b
].reverse();
1648 test
!(input
, sort_by
);
1649 test
!(input
, sort_unstable_by
);
1656 fn repeat_generic_slice() {
1657 assert_eq
!([1, 2].repeat(2), vec
![1, 2, 1, 2]);
1658 assert_eq
!([1, 2, 3, 4].repeat(0), vec
![]);
1659 assert_eq
!([1, 2, 3, 4].repeat(1), vec
![1, 2, 3, 4]);
1661 [1, 2, 3, 4].repeat(3),
1662 vec
![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]