3 use std
::collections
::TryReserveError
::*;
5 use std
::iter
::InPlaceIterable
;
6 use std
::mem
::{size_of, swap}
;
7 use std
::ops
::Bound
::*;
8 use std
::panic
::{catch_unwind, AssertUnwindSafe}
;
10 use std
::sync
::atomic
::{AtomicU32, Ordering}
;
11 use std
::vec
::{Drain, IntoIter}
;
13 struct DropCounter
<'a
> {
17 impl Drop
for DropCounter
<'_
> {
24 fn test_small_vec_struct() {
25 assert_eq
!(size_of
::<Vec
<u8>>(), size_of
::<usize>() * 3);
29 fn test_double_drop() {
35 let (mut count_x
, mut count_y
) = (0, 0);
37 let mut tv
= TwoVec { x: Vec::new(), y: Vec::new() }
;
38 tv
.x
.push(DropCounter { count: &mut count_x }
);
39 tv
.y
.push(DropCounter { count: &mut count_y }
);
41 // If Vec had a drop flag, here is where it would be zeroed.
42 // Instead, it should rely on its internal state to prevent
43 // doing anything significant when dropped multiple times.
46 // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
49 assert_eq
!(count_x
, 1);
50 assert_eq
!(count_y
, 1);
55 let mut v
= Vec
::new();
56 assert_eq
!(v
.capacity(), 0);
59 assert
!(v
.capacity() >= 2);
65 assert
!(v
.capacity() >= 16);
67 assert
!(v
.capacity() >= 32);
72 assert
!(v
.capacity() >= 33)
76 fn test_zst_capacity() {
77 assert_eq
!(Vec
::<()>::new().capacity(), usize::MAX
);
82 let v
: Vec
<isize> = vec
![10, 20];
87 assert_eq
!(v
[x
+ 1], 20);
90 assert_eq
!(v
[x
- 1], 10);
95 let vec1
: Vec
<isize> = vec
![];
96 assert_eq
!("[]", format
!("{:?}", vec1
));
98 let vec2
= vec
![0, 1];
99 assert_eq
!("[0, 1]", format
!("{:?}", vec2
));
101 let slice
: &[isize] = &[4, 5];
102 assert_eq
!("[4, 5]", format
!("{:?}", slice
));
111 assert_eq
!(v
, [1, 2]);
113 assert_eq
!(v
, [1, 2, 3]);
118 let mut v
= Vec
::new();
119 let mut w
= Vec
::new();
138 v
.extend(w
.clone()); // specializes to `append`
139 assert
!(v
.iter().eq(w
.iter().chain(w
.iter())));
142 #[derive(PartialEq, Debug)]
145 let mut a
= Vec
::new();
146 let b
= vec
![Foo
, Foo
];
149 assert_eq
!(a
, &[Foo
, Foo
]);
154 let mut x
= Vec
::new();
155 let y
= vec
![DropCounter { count: &mut count_x }
];
158 assert_eq
!(count_x
, 1);
162 fn test_extend_from_slice() {
163 let a
: Vec
<isize> = vec
![1, 2, 3, 4, 5];
164 let b
: Vec
<isize> = vec
![6, 7, 8, 9, 0];
166 let mut v
: Vec
<isize> = a
;
168 v
.extend_from_slice(&b
);
170 assert_eq
!(v
, [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]);
174 fn test_extend_ref() {
175 let mut v
= vec
![1, 2];
176 v
.extend(&[3, 4, 5]);
178 assert_eq
!(v
.len(), 5);
179 assert_eq
!(v
, [1, 2, 3, 4, 5]);
184 assert_eq
!(v
.len(), 7);
185 assert_eq
!(v
, [1, 2, 3, 4, 5, 6, 7]);
189 fn test_slice_from_ref() {
190 let values
= vec
![1, 2, 3, 4, 5];
191 let slice
= &values
[1..3];
193 assert_eq
!(slice
, [2, 3]);
197 fn test_slice_from_mut() {
198 let mut values
= vec
![1, 2, 3, 4, 5];
200 let slice
= &mut values
[2..];
201 assert
!(slice
== [3, 4, 5]);
207 assert
!(values
== [1, 2, 5, 6, 7]);
211 fn test_slice_to_mut() {
212 let mut values
= vec
![1, 2, 3, 4, 5];
214 let slice
= &mut values
[..2];
215 assert
!(slice
== [1, 2]);
221 assert
!(values
== [2, 3, 3, 4, 5]);
225 fn test_split_at_mut() {
226 let mut values
= vec
![1, 2, 3, 4, 5];
228 let (left
, right
) = values
.split_at_mut(2);
230 let left
: &[_
] = left
;
231 assert
!(&left
[..left
.len()] == &[1, 2]);
238 let right
: &[_
] = right
;
239 assert
!(&right
[..right
.len()] == &[3, 4, 5]);
246 assert_eq
!(values
, [2, 3, 5, 6, 7]);
251 let v
: Vec
<i32> = vec
![];
252 let w
= vec
![1, 2, 3];
254 assert_eq
!(v
, v
.clone());
258 // they should be disjoint in memory.
259 assert
!(w
.as_ptr() != z
.as_ptr())
263 fn test_clone_from() {
265 let three
: Vec
<Box
<_
>> = vec
![box 1, box 2, box 3];
266 let two
: Vec
<Box
<_
>> = vec
![box 4, box 5];
268 v
.clone_from(&three
);
269 assert_eq
!(v
, three
);
272 v
.clone_from(&three
);
273 assert_eq
!(v
, three
);
280 v
.clone_from(&three
);
286 let mut vec
= vec
![1, 2, 3, 4];
287 vec
.retain(|&x
| x
% 2 == 0);
288 assert_eq
!(vec
, [2, 4]);
292 fn test_retain_pred_panic_with_hole() {
293 let v
= (0..5).map(Rc
::new
).collect
::<Vec
<_
>>();
294 catch_unwind(AssertUnwindSafe(|| {
295 let mut v
= v
.clone();
296 v
.retain(|r
| match **r
{
304 // Everything is dropped when predicate panicked.
305 assert
!(v
.iter().all(|r
| Rc
::strong_count(r
) == 1));
309 fn test_retain_pred_panic_no_hole() {
310 let v
= (0..5).map(Rc
::new
).collect
::<Vec
<_
>>();
311 catch_unwind(AssertUnwindSafe(|| {
312 let mut v
= v
.clone();
313 v
.retain(|r
| match **r
{
319 // Everything is dropped when predicate panicked.
320 assert
!(v
.iter().all(|r
| Rc
::strong_count(r
) == 1));
324 fn test_retain_drop_panic() {
325 struct Wrap(Rc
<i32>);
335 let v
= (0..5).map(|x
| Rc
::new(x
)).collect
::<Vec
<_
>>();
336 catch_unwind(AssertUnwindSafe(|| {
337 let mut v
= v
.iter().map(|r
| Wrap(r
.clone())).collect
::<Vec
<_
>>();
338 v
.retain(|w
| match *w
.0 {
342 3 => false, // Drop panic.
347 // Other elements are dropped when `drop` of one element panicked.
348 // The panicked wrapper also has its Rc dropped.
349 assert
!(v
.iter().all(|r
| Rc
::strong_count(r
) == 1));
354 fn case(a
: Vec
<i32>, b
: Vec
<i32>) {
359 case(vec
![], vec
![]);
360 case(vec
![1], vec
![1]);
361 case(vec
![1, 1], vec
![1]);
362 case(vec
![1, 2, 3], vec
![1, 2, 3]);
363 case(vec
![1, 1, 2, 3], vec
![1, 2, 3]);
364 case(vec
![1, 2, 2, 3], vec
![1, 2, 3]);
365 case(vec
![1, 2, 3, 3], vec
![1, 2, 3]);
366 case(vec
![1, 1, 2, 2, 2, 3, 3], vec
![1, 2, 3]);
370 fn test_dedup_by_key() {
371 fn case(a
: Vec
<i32>, b
: Vec
<i32>) {
373 v
.dedup_by_key(|i
| *i
/ 10);
376 case(vec
![], vec
![]);
377 case(vec
![10], vec
![10]);
378 case(vec
![10, 11], vec
![10]);
379 case(vec
![10, 20, 30], vec
![10, 20, 30]);
380 case(vec
![10, 11, 20, 30], vec
![10, 20, 30]);
381 case(vec
![10, 20, 21, 30], vec
![10, 20, 30]);
382 case(vec
![10, 20, 30, 31], vec
![10, 20, 30]);
383 case(vec
![10, 11, 20, 21, 22, 30, 31], vec
![10, 20, 30]);
388 let mut vec
= vec
!["foo", "bar", "Bar", "baz", "bar"];
389 vec
.dedup_by(|a
, b
| a
.eq_ignore_ascii_case(b
));
391 assert_eq
!(vec
, ["foo", "bar", "baz", "bar"]);
393 let mut vec
= vec
![("foo", 1), ("foo", 2), ("bar", 3), ("bar", 4), ("bar", 5)];
394 vec
.dedup_by(|a
, b
| {
401 assert_eq
!(vec
, [("foo", 3), ("bar", 12)]);
405 fn test_dedup_unique() {
406 let mut v0
: Vec
<Box
<_
>> = vec
![box 1, box 1, box 2, box 3];
408 let mut v1
: Vec
<Box
<_
>> = vec
![box 1, box 2, box 2, box 3];
410 let mut v2
: Vec
<Box
<_
>> = vec
![box 1, box 2, box 3, box 3];
412 // If the boxed pointers were leaked or otherwise misused, valgrind
413 // and/or rt should raise errors.
417 fn zero_sized_values() {
418 let mut v
= Vec
::new();
419 assert_eq
!(v
.len(), 0);
421 assert_eq
!(v
.len(), 1);
423 assert_eq
!(v
.len(), 2);
424 assert_eq
!(v
.pop(), Some(()));
425 assert_eq
!(v
.pop(), Some(()));
426 assert_eq
!(v
.pop(), None
);
428 assert_eq
!(v
.iter().count(), 0);
430 assert_eq
!(v
.iter().count(), 1);
432 assert_eq
!(v
.iter().count(), 2);
436 assert_eq
!(v
.iter_mut().count(), 2);
438 assert_eq
!(v
.iter_mut().count(), 3);
440 assert_eq
!(v
.iter_mut().count(), 4);
442 for &mut () in &mut v {}
446 assert_eq
!(v
.iter_mut().count(), 0);
450 fn test_partition() {
451 assert_eq
!(vec
![].into_iter().partition(|x
: &i32| *x
< 3), (vec
![], vec
![]));
452 assert_eq
!(vec
![1, 2, 3].into_iter().partition(|x
| *x
< 4), (vec
![1, 2, 3], vec
![]));
453 assert_eq
!(vec
![1, 2, 3].into_iter().partition(|x
| *x
< 2), (vec
![1], vec
![2, 3]));
454 assert_eq
!(vec
![1, 2, 3].into_iter().partition(|x
| *x
< 0), (vec
![], vec
![1, 2, 3]));
458 fn test_zip_unzip() {
459 let z1
= vec
![(1, 4), (2, 5), (3, 6)];
461 let (left
, right
): (Vec
<_
>, Vec
<_
>) = z1
.iter().cloned().unzip();
463 assert_eq
!((1, 4), (left
[0], right
[0]));
464 assert_eq
!((2, 5), (left
[1], right
[1]));
465 assert_eq
!((3, 6), (left
[2], right
[2]));
470 let x
: &[isize] = &[1, 2, 3, 4, 5];
471 let cmp
: &[isize] = &[1, 2, 3, 4, 5];
472 assert_eq
!(&x
[..], cmp
);
473 let cmp
: &[isize] = &[3, 4, 5];
474 assert_eq
!(&x
[2..], cmp
);
475 let cmp
: &[isize] = &[1, 2, 3];
476 assert_eq
!(&x
[..3], cmp
);
477 let cmp
: &[isize] = &[2, 3, 4];
478 assert_eq
!(&x
[1..4], cmp
);
480 let x
: Vec
<isize> = vec
![1, 2, 3, 4, 5];
481 let cmp
: &[isize] = &[1, 2, 3, 4, 5];
482 assert_eq
!(&x
[..], cmp
);
483 let cmp
: &[isize] = &[3, 4, 5];
484 assert_eq
!(&x
[2..], cmp
);
485 let cmp
: &[isize] = &[1, 2, 3];
486 assert_eq
!(&x
[..3], cmp
);
487 let cmp
: &[isize] = &[2, 3, 4];
488 assert_eq
!(&x
[1..4], cmp
);
492 fn test_vec_truncate_drop() {
493 static mut DROPS
: u32 = 0;
503 let mut v
= vec
![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
504 assert_eq
!(unsafe { DROPS }
, 0);
506 assert_eq
!(unsafe { DROPS }
, 2);
508 assert_eq
!(unsafe { DROPS }
, 5);
513 fn test_vec_truncate_fail() {
515 impl Drop
for BadElem
{
517 let BadElem(ref mut x
) = *self;
519 panic
!("BadElem panic: 0xbadbeef")
524 let mut v
= vec
![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
530 let vec
= vec
![1, 2, 3];
531 assert
!(vec
[1] == 2);
536 fn test_index_out_of_bounds() {
537 let vec
= vec
![1, 2, 3];
543 fn test_slice_out_of_bounds_1() {
544 let x
= vec
![1, 2, 3, 4, 5];
550 fn test_slice_out_of_bounds_2() {
551 let x
= vec
![1, 2, 3, 4, 5];
557 fn test_slice_out_of_bounds_3() {
558 let x
= vec
![1, 2, 3, 4, 5];
564 fn test_slice_out_of_bounds_4() {
565 let x
= vec
![1, 2, 3, 4, 5];
571 fn test_slice_out_of_bounds_5() {
572 let x
= vec
![1, 2, 3, 4, 5];
578 fn test_swap_remove_empty() {
579 let mut vec
= Vec
::<i32>::new();
584 fn test_move_items() {
585 let vec
= vec
![1, 2, 3];
586 let mut vec2
= vec
![];
590 assert_eq
!(vec2
, [1, 2, 3]);
594 fn test_move_items_reverse() {
595 let vec
= vec
![1, 2, 3];
596 let mut vec2
= vec
![];
597 for i
in vec
.into_iter().rev() {
600 assert_eq
!(vec2
, [3, 2, 1]);
604 fn test_move_items_zero_sized() {
605 let vec
= vec
![(), (), ()];
606 let mut vec2
= vec
![];
610 assert_eq
!(vec2
, [(), (), ()]);
614 fn test_drain_empty_vec() {
615 let mut vec
: Vec
<i32> = vec
![];
616 let mut vec2
: Vec
<i32> = vec
![];
617 for i
in vec
.drain(..) {
620 assert
!(vec
.is_empty());
621 assert
!(vec2
.is_empty());
625 fn test_drain_items() {
626 let mut vec
= vec
![1, 2, 3];
627 let mut vec2
= vec
![];
628 for i
in vec
.drain(..) {
632 assert_eq
!(vec2
, [1, 2, 3]);
636 fn test_drain_items_reverse() {
637 let mut vec
= vec
![1, 2, 3];
638 let mut vec2
= vec
![];
639 for i
in vec
.drain(..).rev() {
643 assert_eq
!(vec2
, [3, 2, 1]);
647 fn test_drain_items_zero_sized() {
648 let mut vec
= vec
![(), (), ()];
649 let mut vec2
= vec
![];
650 for i
in vec
.drain(..) {
654 assert_eq
!(vec2
, [(), (), ()]);
659 fn test_drain_out_of_bounds() {
660 let mut v
= vec
![1, 2, 3, 4, 5];
665 fn test_drain_range() {
666 let mut v
= vec
![1, 2, 3, 4, 5];
667 for _
in v
.drain(4..) {}
668 assert_eq
!(v
, &[1, 2, 3, 4]);
670 let mut v
: Vec
<_
> = (1..6).map(|x
| x
.to_string()).collect();
671 for _
in v
.drain(1..4) {}
672 assert_eq
!(v
, &[1.to_string(), 5.to_string()]);
674 let mut v
: Vec
<_
> = (1..6).map(|x
| x
.to_string()).collect();
675 for _
in v
.drain(1..4).rev() {}
676 assert_eq
!(v
, &[1.to_string(), 5.to_string()]);
678 let mut v
: Vec
<_
> = vec
![(); 5];
679 for _
in v
.drain(1..4).rev() {}
680 assert_eq
!(v
, &[(), ()]);
684 fn test_drain_inclusive_range() {
685 let mut v
= vec
!['a'
, 'b'
, 'c'
, 'd'
, 'e'
];
686 for _
in v
.drain(1..=3) {}
687 assert_eq
!(v
, &['a'
, 'e'
]);
689 let mut v
: Vec
<_
> = (0..=5).map(|x
| x
.to_string()).collect();
690 for _
in v
.drain(1..=5) {}
691 assert_eq
!(v
, &["0".to_string()]);
693 let mut v
: Vec
<String
> = (0..=5).map(|x
| x
.to_string()).collect();
694 for _
in v
.drain(0..=5) {}
695 assert_eq
!(v
, Vec
::<String
>::new());
697 let mut v
: Vec
<_
> = (0..=5).map(|x
| x
.to_string()).collect();
698 for _
in v
.drain(0..=3) {}
699 assert_eq
!(v
, &["4".to_string(), "5".to_string()]);
701 let mut v
: Vec
<_
> = (0..=1).map(|x
| x
.to_string()).collect();
702 for _
in v
.drain(..=0) {}
703 assert_eq
!(v
, &["1".to_string()]);
707 fn test_drain_max_vec_size() {
708 let mut v
= Vec
::<()>::with_capacity(usize::MAX
);
710 v
.set_len(usize::MAX
);
712 for _
in v
.drain(usize::MAX
- 1..) {}
713 assert_eq
!(v
.len(), usize::MAX
- 1);
715 let mut v
= Vec
::<()>::with_capacity(usize::MAX
);
717 v
.set_len(usize::MAX
);
719 for _
in v
.drain(usize::MAX
- 1..=usize::MAX
- 1) {}
720 assert_eq
!(v
.len(), usize::MAX
- 1);
725 fn test_drain_index_overflow() {
726 let mut v
= Vec
::<()>::with_capacity(usize::MAX
);
728 v
.set_len(usize::MAX
);
730 v
.drain(0..=usize::MAX
);
735 fn test_drain_inclusive_out_of_bounds() {
736 let mut v
= vec
![1, 2, 3, 4, 5];
742 fn test_drain_start_overflow() {
743 let mut v
= vec
![1, 2, 3];
744 v
.drain((Excluded(usize::MAX
), Included(0)));
749 fn test_drain_end_overflow() {
750 let mut v
= vec
![1, 2, 3];
751 v
.drain((Included(0), Included(usize::MAX
)));
755 fn test_drain_leak() {
756 static mut DROPS
: i32 = 0;
758 #[derive(Debug, PartialEq)]
768 panic
!("panic in `drop`");
783 catch_unwind(AssertUnwindSafe(|| {
788 assert_eq
!(unsafe { DROPS }
, 4);
789 assert_eq
!(v
, vec
![D(0, false), D(1, false), D(6, false),]);
794 let mut v
= vec
![1, 2, 3, 4, 5];
795 let a
= [10, 11, 12];
796 v
.splice(2..4, a
.iter().cloned());
797 assert_eq
!(v
, &[1, 2, 10, 11, 12, 5]);
798 v
.splice(1..3, Some(20));
799 assert_eq
!(v
, &[1, 20, 11, 12, 5]);
803 fn test_splice_inclusive_range() {
804 let mut v
= vec
![1, 2, 3, 4, 5];
805 let a
= [10, 11, 12];
806 let t1
: Vec
<_
> = v
.splice(2..=3, a
.iter().cloned()).collect();
807 assert_eq
!(v
, &[1, 2, 10, 11, 12, 5]);
808 assert_eq
!(t1
, &[3, 4]);
809 let t2
: Vec
<_
> = v
.splice(1..=2, Some(20)).collect();
810 assert_eq
!(v
, &[1, 20, 11, 12, 5]);
811 assert_eq
!(t2
, &[2, 10]);
816 fn test_splice_out_of_bounds() {
817 let mut v
= vec
![1, 2, 3, 4, 5];
818 let a
= [10, 11, 12];
819 v
.splice(5..6, a
.iter().cloned());
824 fn test_splice_inclusive_out_of_bounds() {
825 let mut v
= vec
![1, 2, 3, 4, 5];
826 let a
= [10, 11, 12];
827 v
.splice(5..=5, a
.iter().cloned());
831 fn test_splice_items_zero_sized() {
832 let mut vec
= vec
![(), (), ()];
834 let t
: Vec
<_
> = vec
.splice(1..2, vec2
.iter().cloned()).collect();
835 assert_eq
!(vec
, &[(), ()]);
836 assert_eq
!(t
, &[()]);
840 fn test_splice_unbounded() {
841 let mut vec
= vec
![1, 2, 3, 4, 5];
842 let t
: Vec
<_
> = vec
.splice(.., None
).collect();
843 assert_eq
!(vec
, &[]);
844 assert_eq
!(t
, &[1, 2, 3, 4, 5]);
848 fn test_splice_forget() {
849 let mut v
= vec
![1, 2, 3, 4, 5];
850 let a
= [10, 11, 12];
851 std
::mem
::forget(v
.splice(2..4, a
.iter().cloned()));
852 assert_eq
!(v
, &[1, 2]);
856 fn test_into_boxed_slice() {
857 let xs
= vec
![1, 2, 3];
858 let ys
= xs
.into_boxed_slice();
859 assert_eq
!(&*ys
, [1, 2, 3]);
864 let mut vec
= vec
![1, 2, 3];
865 let mut vec2
= vec
![4, 5, 6];
866 vec
.append(&mut vec2
);
867 assert_eq
!(vec
, [1, 2, 3, 4, 5, 6]);
868 assert_eq
!(vec2
, []);
872 fn test_split_off() {
873 let mut vec
= vec
![1, 2, 3, 4, 5, 6];
874 let orig_capacity
= vec
.capacity();
875 let vec2
= vec
.split_off(4);
876 assert_eq
!(vec
, [1, 2, 3, 4]);
877 assert_eq
!(vec2
, [5, 6]);
878 assert_eq
!(vec
.capacity(), orig_capacity
);
882 fn test_split_off_take_all() {
883 let mut vec
= vec
![1, 2, 3, 4, 5, 6];
884 let orig_ptr
= vec
.as_ptr();
885 let orig_capacity
= vec
.capacity();
886 let vec2
= vec
.split_off(0);
888 assert_eq
!(vec2
, [1, 2, 3, 4, 5, 6]);
889 assert_eq
!(vec
.capacity(), orig_capacity
);
890 assert_eq
!(vec2
.as_ptr(), orig_ptr
);
894 fn test_into_iter_as_slice() {
895 let vec
= vec
!['a'
, 'b'
, 'c'
];
896 let mut into_iter
= vec
.into_iter();
897 assert_eq
!(into_iter
.as_slice(), &['a'
, 'b'
, 'c'
]);
898 let _
= into_iter
.next().unwrap();
899 assert_eq
!(into_iter
.as_slice(), &['b'
, 'c'
]);
900 let _
= into_iter
.next().unwrap();
901 let _
= into_iter
.next().unwrap();
902 assert_eq
!(into_iter
.as_slice(), &[]);
906 fn test_into_iter_as_mut_slice() {
907 let vec
= vec
!['a'
, 'b'
, 'c'
];
908 let mut into_iter
= vec
.into_iter();
909 assert_eq
!(into_iter
.as_slice(), &['a'
, 'b'
, 'c'
]);
910 into_iter
.as_mut_slice()[0] = 'x'
;
911 into_iter
.as_mut_slice()[1] = 'y'
;
912 assert_eq
!(into_iter
.next().unwrap(), 'x'
);
913 assert_eq
!(into_iter
.as_slice(), &['y'
, 'c'
]);
917 fn test_into_iter_debug() {
918 let vec
= vec
!['a'
, 'b'
, 'c'
];
919 let into_iter
= vec
.into_iter();
920 let debug
= format
!("{:?}", into_iter
);
921 assert_eq
!(debug
, "IntoIter(['a', 'b', 'c'])");
925 fn test_into_iter_count() {
926 assert_eq
!(vec
![1, 2, 3].into_iter().count(), 3);
930 fn test_into_iter_clone() {
931 fn iter_equal
<I
: Iterator
<Item
= i32>>(it
: I
, slice
: &[i32]) {
932 let v
: Vec
<i32> = it
.collect();
933 assert_eq
!(&v
[..], slice
);
935 let mut it
= vec
![1, 2, 3].into_iter();
936 iter_equal(it
.clone(), &[1, 2, 3]);
937 assert_eq
!(it
.next(), Some(1));
938 let mut it
= it
.rev();
939 iter_equal(it
.clone(), &[3, 2]);
940 assert_eq
!(it
.next(), Some(3));
941 iter_equal(it
.clone(), &[2]);
942 assert_eq
!(it
.next(), Some(2));
943 iter_equal(it
.clone(), &[]);
944 assert_eq
!(it
.next(), None
);
948 fn test_into_iter_leak() {
949 static mut DROPS
: i32 = 0;
960 panic
!("panic in `drop`");
965 let v
= vec
![D(false), D(true), D(false)];
967 catch_unwind(move || drop(v
.into_iter())).ok();
969 assert_eq
!(unsafe { DROPS }
, 3);
973 fn test_from_iter_specialization() {
974 let src
: Vec
<usize> = vec
![0usize
; 1];
975 let srcptr
= src
.as_ptr();
976 let sink
= src
.into_iter().collect
::<Vec
<_
>>();
977 let sinkptr
= sink
.as_ptr();
978 assert_eq
!(srcptr
, sinkptr
);
982 fn test_from_iter_partially_drained_in_place_specialization() {
983 let src
: Vec
<usize> = vec
![0usize
; 10];
984 let srcptr
= src
.as_ptr();
985 let mut iter
= src
.into_iter();
988 let sink
= iter
.collect
::<Vec
<_
>>();
989 let sinkptr
= sink
.as_ptr();
990 assert_eq
!(srcptr
, sinkptr
);
994 fn test_from_iter_specialization_with_iterator_adapters() {
995 fn assert_in_place_trait
<T
: InPlaceIterable
>(_
: &T
) {}
996 let src
: Vec
<usize> = vec
![0usize
; 256];
997 let srcptr
= src
.as_ptr();
1002 .zip(std
::iter
::repeat(1usize
))
1003 .map(|(a
, b
)| a
+ b
)
1004 .map_while(Option
::Some
)
1007 .map(|e
| std
::num
::NonZeroUsize
::new(e
));
1008 assert_in_place_trait(&iter
);
1009 let sink
= iter
.collect
::<Vec
<_
>>();
1010 let sinkptr
= sink
.as_ptr();
1011 assert_eq
!(srcptr
, sinkptr
as *const usize);
1015 fn test_from_iter_specialization_head_tail_drop() {
1016 let drop_count
: Vec
<_
> = (0..=2).map(|_
| Rc
::new(())).collect();
1017 let src
: Vec
<_
> = drop_count
.iter().cloned().collect();
1018 let srcptr
= src
.as_ptr();
1019 let iter
= src
.into_iter();
1020 let sink
: Vec
<_
> = iter
.skip(1).take(1).collect();
1021 let sinkptr
= sink
.as_ptr();
1022 assert_eq
!(srcptr
, sinkptr
, "specialization was applied");
1023 assert_eq
!(Rc
::strong_count(&drop_count
[0]), 1, "front was dropped");
1024 assert_eq
!(Rc
::strong_count(&drop_count
[1]), 2, "one element was collected");
1025 assert_eq
!(Rc
::strong_count(&drop_count
[2]), 1, "tail was dropped");
1026 assert_eq
!(sink
.len(), 1);
1030 fn test_from_iter_specialization_panic_during_iteration_drops() {
1031 let drop_count
: Vec
<_
> = (0..=2).map(|_
| Rc
::new(())).collect();
1032 let src
: Vec
<_
> = drop_count
.iter().cloned().collect();
1033 let iter
= src
.into_iter();
1035 let _
= std
::panic
::catch_unwind(AssertUnwindSafe(|| {
1038 .filter_map(|(i
, e
)| {
1040 std
::panic
!("aborting iteration");
1044 .collect
::<Vec
<_
>>();
1048 drop_count
.iter().map(Rc
::strong_count
).all(|count
| count
== 1),
1049 "all items were dropped once"
1054 fn test_from_iter_specialization_panic_during_drop_leaks() {
1055 static mut DROP_COUNTER
: usize = 0;
1059 DroppedTwice(Box
<i32>),
1063 impl Drop
for Droppable
{
1064 fn drop(&mut self) {
1066 Droppable
::DroppedTwice(_
) => {
1070 println
!("Dropping!")
1072 Droppable
::PanicOnDrop
=> {
1073 if !std
::thread
::panicking() {
1081 let _
= std
::panic
::catch_unwind(AssertUnwindSafe(|| {
1082 let v
= vec
![Droppable
::DroppedTwice(Box
::new(123)), Droppable
::PanicOnDrop
];
1083 let _
= v
.into_iter().take(0).collect
::<Vec
<_
>>();
1086 assert_eq
!(unsafe { DROP_COUNTER }
, 1);
1090 fn test_cow_from() {
1091 let borrowed
: &[_
] = &["borrowed", "(slice)"];
1092 let owned
= vec
!["owned", "(vec)"];
1093 match (Cow
::from(owned
.clone()), Cow
::from(borrowed
)) {
1094 (Cow
::Owned(o
), Cow
::Borrowed(b
)) => assert
!(o
== owned
&& b
== borrowed
),
1095 _
=> panic
!("invalid `Cow::from`"),
1100 fn test_from_cow() {
1101 let borrowed
: &[_
] = &["borrowed", "(slice)"];
1102 let owned
= vec
!["owned", "(vec)"];
1103 assert_eq
!(Vec
::from(Cow
::Borrowed(borrowed
)), vec
!["borrowed", "(slice)"]);
1104 assert_eq
!(Vec
::from(Cow
::Owned(owned
)), vec
!["owned", "(vec)"]);
1108 fn assert_covariance() {
1109 fn drain
<'new
>(d
: Drain
<'
static, &'
static str>) -> Drain
<'new
, &'new
str> {
1112 fn into_iter
<'new
>(i
: IntoIter
<&'
static str>) -> IntoIter
<&'new
str> {
1118 fn from_into_inner() {
1119 let vec
= vec
![1, 2, 3];
1120 let ptr
= vec
.as_ptr();
1121 let vec
= vec
.into_iter().collect
::<Vec
<_
>>();
1122 assert_eq
!(vec
, [1, 2, 3]);
1123 assert_eq
!(vec
.as_ptr(), ptr
);
1125 let ptr
= &vec
[1] as *const _
;
1126 let mut it
= vec
.into_iter();
1128 let vec
= it
.collect
::<Vec
<_
>>();
1129 assert_eq
!(vec
, [2, 3]);
1130 assert
!(ptr
!= vec
.as_ptr());
1134 fn overaligned_allocations() {
1137 let mut v
= vec
![Foo(273)];
1138 for i
in 0..0x1000 {
1140 assert
!(v
[0].0 == 273);
1141 assert
!(v
.as_ptr() as usize & 0xff == 0);
1143 assert
!(v
[0].0 == 273);
1144 assert
!(v
.as_ptr() as usize & 0xff == 0);
1149 fn drain_filter_empty() {
1150 let mut vec
: Vec
<i32> = vec
![];
1153 let mut iter
= vec
.drain_filter(|_
| true);
1154 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1155 assert_eq
!(iter
.next(), None
);
1156 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1157 assert_eq
!(iter
.next(), None
);
1158 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1160 assert_eq
!(vec
.len(), 0);
1161 assert_eq
!(vec
, vec
![]);
1165 fn drain_filter_zst() {
1166 let mut vec
= vec
![(), (), (), (), ()];
1167 let initial_len
= vec
.len();
1170 let mut iter
= vec
.drain_filter(|_
| true);
1171 assert_eq
!(iter
.size_hint(), (0, Some(initial_len
)));
1172 while let Some(_
) = iter
.next() {
1174 assert_eq
!(iter
.size_hint(), (0, Some(initial_len
- count
)));
1176 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1177 assert_eq
!(iter
.next(), None
);
1178 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1181 assert_eq
!(count
, initial_len
);
1182 assert_eq
!(vec
.len(), 0);
1183 assert_eq
!(vec
, vec
![]);
1187 fn drain_filter_false() {
1188 let mut vec
= vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1190 let initial_len
= vec
.len();
1193 let mut iter
= vec
.drain_filter(|_
| false);
1194 assert_eq
!(iter
.size_hint(), (0, Some(initial_len
)));
1195 for _
in iter
.by_ref() {
1198 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1199 assert_eq
!(iter
.next(), None
);
1200 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1203 assert_eq
!(count
, 0);
1204 assert_eq
!(vec
.len(), initial_len
);
1205 assert_eq
!(vec
, vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
1209 fn drain_filter_true() {
1210 let mut vec
= vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1212 let initial_len
= vec
.len();
1215 let mut iter
= vec
.drain_filter(|_
| true);
1216 assert_eq
!(iter
.size_hint(), (0, Some(initial_len
)));
1217 while let Some(_
) = iter
.next() {
1219 assert_eq
!(iter
.size_hint(), (0, Some(initial_len
- count
)));
1221 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1222 assert_eq
!(iter
.next(), None
);
1223 assert_eq
!(iter
.size_hint(), (0, Some(0)));
1226 assert_eq
!(count
, initial_len
);
1227 assert_eq
!(vec
.len(), 0);
1228 assert_eq
!(vec
, vec
![]);
1232 fn drain_filter_complex() {
1234 // [+xxx++++++xxxxx++++x+x++]
1236 1, 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37,
1240 let removed
= vec
.drain_filter(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>();
1241 assert_eq
!(removed
.len(), 10);
1242 assert_eq
!(removed
, vec
![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
1244 assert_eq
!(vec
.len(), 14);
1245 assert_eq
!(vec
, vec
![1, 7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]);
1249 // [xxx++++++xxxxx++++x+x++]
1251 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, 39,
1254 let removed
= vec
.drain_filter(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>();
1255 assert_eq
!(removed
.len(), 10);
1256 assert_eq
!(removed
, vec
![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
1258 assert_eq
!(vec
.len(), 13);
1259 assert_eq
!(vec
, vec
![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]);
1263 // [xxx++++++xxxxx++++x+x]
1265 vec
![2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36];
1267 let removed
= vec
.drain_filter(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>();
1268 assert_eq
!(removed
.len(), 10);
1269 assert_eq
!(removed
, vec
![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
1271 assert_eq
!(vec
.len(), 11);
1272 assert_eq
!(vec
, vec
![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35]);
1276 // [xxxxxxxxxx+++++++++++]
1277 let mut vec
= vec
![2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
1279 let removed
= vec
.drain_filter(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>();
1280 assert_eq
!(removed
.len(), 10);
1281 assert_eq
!(removed
, vec
![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
1283 assert_eq
!(vec
.len(), 10);
1284 assert_eq
!(vec
, vec
![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
1288 // [+++++++++++xxxxxxxxxx]
1289 let mut vec
= vec
![1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20];
1291 let removed
= vec
.drain_filter(|x
| *x
% 2 == 0).collect
::<Vec
<_
>>();
1292 assert_eq
!(removed
.len(), 10);
1293 assert_eq
!(removed
, vec
![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
1295 assert_eq
!(vec
.len(), 10);
1296 assert_eq
!(vec
, vec
![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
1300 // FIXME: re-enable emscripten once it can unwind again
1302 #[cfg(not(target_os = "emscripten"))]
1303 fn drain_filter_consumed_panic() {
1305 use std
::sync
::Mutex
;
1309 drop_counts
: Rc
<Mutex
<Vec
<usize>>>,
1312 impl Drop
for Check
{
1313 fn drop(&mut self) {
1314 self.drop_counts
.lock().unwrap()[self.index
] += 1;
1315 println
!("drop: {}", self.index
);
1319 let check_count
= 10;
1320 let drop_counts
= Rc
::new(Mutex
::new(vec
![0_usize
; check_count
]));
1321 let mut data
: Vec
<Check
> = (0..check_count
)
1322 .map(|index
| Check { index, drop_counts: Rc::clone(&drop_counts) }
)
1325 let _
= std
::panic
::catch_unwind(move || {
1326 let filter
= |c
: &mut Check
| {
1328 panic
!("panic at index: {}", c
.index
);
1330 // Verify that if the filter could panic again on another element
1331 // that it would not cause a double panic and all elements of the
1332 // vec would still be dropped exactly once.
1334 panic
!("panic at index: {}", c
.index
);
1338 let drain
= data
.drain_filter(filter
);
1340 // NOTE: The DrainFilter is explicitly consumed
1341 drain
.for_each(drop
);
1344 let drop_counts
= drop_counts
.lock().unwrap();
1345 assert_eq
!(check_count
, drop_counts
.len());
1347 for (index
, count
) in drop_counts
.iter().cloned().enumerate() {
1348 assert_eq
!(1, count
, "unexpected drop count at index: {} (count: {})", index
, count
);
1352 // FIXME: Re-enable emscripten once it can catch panics
1354 #[cfg(not(target_os = "emscripten"))]
1355 fn drain_filter_unconsumed_panic() {
1357 use std
::sync
::Mutex
;
1361 drop_counts
: Rc
<Mutex
<Vec
<usize>>>,
1364 impl Drop
for Check
{
1365 fn drop(&mut self) {
1366 self.drop_counts
.lock().unwrap()[self.index
] += 1;
1367 println
!("drop: {}", self.index
);
1371 let check_count
= 10;
1372 let drop_counts
= Rc
::new(Mutex
::new(vec
![0_usize
; check_count
]));
1373 let mut data
: Vec
<Check
> = (0..check_count
)
1374 .map(|index
| Check { index, drop_counts: Rc::clone(&drop_counts) }
)
1377 let _
= std
::panic
::catch_unwind(move || {
1378 let filter
= |c
: &mut Check
| {
1380 panic
!("panic at index: {}", c
.index
);
1382 // Verify that if the filter could panic again on another element
1383 // that it would not cause a double panic and all elements of the
1384 // vec would still be dropped exactly once.
1386 panic
!("panic at index: {}", c
.index
);
1390 let _drain
= data
.drain_filter(filter
);
1392 // NOTE: The DrainFilter is dropped without being consumed
1395 let drop_counts
= drop_counts
.lock().unwrap();
1396 assert_eq
!(check_count
, drop_counts
.len());
1398 for (index
, count
) in drop_counts
.iter().cloned().enumerate() {
1399 assert_eq
!(1, count
, "unexpected drop count at index: {} (count: {})", index
, count
);
1404 fn drain_filter_unconsumed() {
1405 let mut vec
= vec
![1, 2, 3, 4];
1406 let drain
= vec
.drain_filter(|&mut x
| x
% 2 != 0);
1408 assert_eq
!(vec
, [2, 4]);
1412 fn test_reserve_exact() {
1413 // This is all the same as test_reserve
1415 let mut v
= Vec
::new();
1416 assert_eq
!(v
.capacity(), 0);
1419 assert
!(v
.capacity() >= 2);
1425 assert
!(v
.capacity() >= 16);
1426 v
.reserve_exact(16);
1427 assert
!(v
.capacity() >= 32);
1431 v
.reserve_exact(16);
1432 assert
!(v
.capacity() >= 33)
1436 #[cfg_attr(miri, ignore)] // Miri does not support signalling OOM
1437 #[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc
1438 fn test_try_reserve() {
1439 // These are the interesting cases:
1440 // * exactly isize::MAX should never trigger a CapacityOverflow (can be OOM)
1441 // * > isize::MAX should always fail
1442 // * On 16/32-bit should CapacityOverflow
1443 // * On 64-bit should OOM
1444 // * overflow may trigger when adding `len` to `cap` (in number of elements)
1445 // * overflow may trigger when multiplying `new_cap` by size_of::<T> (to get bytes)
1447 const MAX_CAP
: usize = isize::MAX
as usize;
1448 const MAX_USIZE
: usize = usize::MAX
;
1450 // On 16/32-bit, we check that allocations don't exceed isize::MAX,
1451 // on 64-bit, we assume the OS will give an OOM for such a ridiculous size.
1452 // Any platform that succeeds for these requests is technically broken with
1453 // ptr::offset because LLVM is the worst.
1454 let guards_against_isize
= usize::BITS
< 64;
1457 // Note: basic stuff is checked by test_reserve
1458 let mut empty_bytes
: Vec
<u8> = Vec
::new();
1460 // Check isize::MAX doesn't count as an overflow
1461 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve(MAX_CAP
) {
1462 panic
!("isize::MAX shouldn't trigger an overflow!");
1464 // Play it again, frank! (just to be sure)
1465 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve(MAX_CAP
) {
1466 panic
!("isize::MAX shouldn't trigger an overflow!");
1469 if guards_against_isize
{
1470 // Check isize::MAX + 1 does count as overflow
1471 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve(MAX_CAP
+ 1) {
1473 panic
!("isize::MAX + 1 should trigger an overflow!")
1476 // Check usize::MAX does count as overflow
1477 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve(MAX_USIZE
) {
1479 panic
!("usize::MAX should trigger an overflow!")
1482 // Check isize::MAX + 1 is an OOM
1483 if let Err(AllocError { .. }
) = empty_bytes
.try_reserve(MAX_CAP
+ 1) {
1485 panic
!("isize::MAX + 1 should trigger an OOM!")
1488 // Check usize::MAX is an OOM
1489 if let Err(AllocError { .. }
) = empty_bytes
.try_reserve(MAX_USIZE
) {
1491 panic
!("usize::MAX should trigger an OOM!")
1497 // Same basic idea, but with non-zero len
1498 let mut ten_bytes
: Vec
<u8> = vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1500 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve(MAX_CAP
- 10) {
1501 panic
!("isize::MAX shouldn't trigger an overflow!");
1503 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve(MAX_CAP
- 10) {
1504 panic
!("isize::MAX shouldn't trigger an overflow!");
1506 if guards_against_isize
{
1507 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve(MAX_CAP
- 9) {
1509 panic
!("isize::MAX + 1 should trigger an overflow!");
1512 if let Err(AllocError { .. }
) = ten_bytes
.try_reserve(MAX_CAP
- 9) {
1514 panic
!("isize::MAX + 1 should trigger an OOM!")
1517 // Should always overflow in the add-to-len
1518 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve(MAX_USIZE
) {
1520 panic
!("usize::MAX should trigger an overflow!")
1525 // Same basic idea, but with interesting type size
1526 let mut ten_u32s
: Vec
<u32> = vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1528 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve(MAX_CAP
/ 4 - 10) {
1529 panic
!("isize::MAX shouldn't trigger an overflow!");
1531 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve(MAX_CAP
/ 4 - 10) {
1532 panic
!("isize::MAX shouldn't trigger an overflow!");
1534 if guards_against_isize
{
1535 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve(MAX_CAP
/ 4 - 9) {
1537 panic
!("isize::MAX + 1 should trigger an overflow!");
1540 if let Err(AllocError { .. }
) = ten_u32s
.try_reserve(MAX_CAP
/ 4 - 9) {
1542 panic
!("isize::MAX + 1 should trigger an OOM!")
1545 // Should fail in the mul-by-size
1546 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve(MAX_USIZE
- 20) {
1548 panic
!("usize::MAX should trigger an overflow!");
1554 #[cfg_attr(miri, ignore)] // Miri does not support signalling OOM
1555 #[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc
1556 fn test_try_reserve_exact() {
1557 // This is exactly the same as test_try_reserve with the method changed.
1558 // See that test for comments.
1560 const MAX_CAP
: usize = isize::MAX
as usize;
1561 const MAX_USIZE
: usize = usize::MAX
;
1563 let guards_against_isize
= size_of
::<usize>() < 8;
1566 let mut empty_bytes
: Vec
<u8> = Vec
::new();
1568 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve_exact(MAX_CAP
) {
1569 panic
!("isize::MAX shouldn't trigger an overflow!");
1571 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve_exact(MAX_CAP
) {
1572 panic
!("isize::MAX shouldn't trigger an overflow!");
1575 if guards_against_isize
{
1576 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve_exact(MAX_CAP
+ 1) {
1578 panic
!("isize::MAX + 1 should trigger an overflow!")
1581 if let Err(CapacityOverflow
) = empty_bytes
.try_reserve_exact(MAX_USIZE
) {
1583 panic
!("usize::MAX should trigger an overflow!")
1586 if let Err(AllocError { .. }
) = empty_bytes
.try_reserve_exact(MAX_CAP
+ 1) {
1588 panic
!("isize::MAX + 1 should trigger an OOM!")
1591 if let Err(AllocError { .. }
) = empty_bytes
.try_reserve_exact(MAX_USIZE
) {
1593 panic
!("usize::MAX should trigger an OOM!")
1599 let mut ten_bytes
: Vec
<u8> = vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1601 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve_exact(MAX_CAP
- 10) {
1602 panic
!("isize::MAX shouldn't trigger an overflow!");
1604 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve_exact(MAX_CAP
- 10) {
1605 panic
!("isize::MAX shouldn't trigger an overflow!");
1607 if guards_against_isize
{
1608 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve_exact(MAX_CAP
- 9) {
1610 panic
!("isize::MAX + 1 should trigger an overflow!");
1613 if let Err(AllocError { .. }
) = ten_bytes
.try_reserve_exact(MAX_CAP
- 9) {
1615 panic
!("isize::MAX + 1 should trigger an OOM!")
1618 if let Err(CapacityOverflow
) = ten_bytes
.try_reserve_exact(MAX_USIZE
) {
1620 panic
!("usize::MAX should trigger an overflow!")
1625 let mut ten_u32s
: Vec
<u32> = vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
1627 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve_exact(MAX_CAP
/ 4 - 10) {
1628 panic
!("isize::MAX shouldn't trigger an overflow!");
1630 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve_exact(MAX_CAP
/ 4 - 10) {
1631 panic
!("isize::MAX shouldn't trigger an overflow!");
1633 if guards_against_isize
{
1634 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve_exact(MAX_CAP
/ 4 - 9) {
1636 panic
!("isize::MAX + 1 should trigger an overflow!");
1639 if let Err(AllocError { .. }
) = ten_u32s
.try_reserve_exact(MAX_CAP
/ 4 - 9) {
1641 panic
!("isize::MAX + 1 should trigger an OOM!")
1644 if let Err(CapacityOverflow
) = ten_u32s
.try_reserve_exact(MAX_USIZE
- 20) {
1646 panic
!("usize::MAX should trigger an overflow!")
1652 fn test_stable_pointers() {
1653 /// Pull an element from the iterator, then drop it.
1654 /// Useful to cover both the `next` and `drop` paths of an iterator.
1655 fn next_then_drop
<I
: Iterator
>(mut i
: I
) {
1660 // Test that, if we reserved enough space, adding and removing elements does not
1661 // invalidate references into the vector (such as `v0`). This test also
1662 // runs in Miri, which would detect such problems.
1663 // Note that this test does *not* constitute a stable guarantee that all these functions do not
1664 // reallocate! Only what is explicitly documented at
1665 // <https://doc.rust-lang.org/nightly/std/vec/struct.Vec.html#guarantees> is stably guaranteed.
1666 let mut v
= Vec
::with_capacity(128);
1669 // Laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
1671 let v0
= unsafe { &mut *(v0 as *mut _) }
;
1672 // Now do a bunch of things and occasionally use `v0` again to assert it is still valid.
1674 // Pushing/inserting and popping/removing
1678 assert_eq
!(*v0
, 13);
1681 assert_eq
!(*v0
, 13);
1684 assert_eq
!(v
.len(), 2);
1685 v
.swap_remove(1); // swap_remove the last element
1686 assert_eq
!(*v0
, 13);
1689 v
.append(&mut vec
![27, 19]);
1690 assert_eq
!(*v0
, 13);
1693 v
.extend_from_slice(&[1, 2]);
1694 v
.extend(&[1, 2]); // `slice::Iter` (with `T: Copy`) specialization
1695 v
.extend(vec
![2, 3]); // `vec::IntoIter` specialization
1696 v
.extend(std
::iter
::once(3)); // `TrustedLen` specialization
1697 v
.extend(std
::iter
::empty
::<i32>()); // `TrustedLen` specialization with empty iterator
1698 v
.extend(std
::iter
::once(3).filter(|_
| true)); // base case
1699 v
.extend(std
::iter
::once(&3)); // `cloned` specialization
1700 assert_eq
!(*v0
, 13);
1704 assert_eq
!(*v0
, 13);
1707 v
.resize_with(v
.len() + 10, || 42);
1708 assert_eq
!(*v0
, 13);
1709 v
.resize_with(2, || panic
!());
1710 assert_eq
!(*v0
, 13);
1712 // No-op reservation
1714 v
.reserve_exact(32);
1715 assert_eq
!(*v0
, 13);
1718 v
.resize_with(10, || 42);
1719 next_then_drop(v
.drain(5..));
1720 assert_eq
!(*v0
, 13);
1723 v
.resize_with(10, || 42);
1724 next_then_drop(v
.splice(5.., vec
![1, 2, 3, 4, 5])); // empty tail after range
1725 assert_eq
!(*v0
, 13);
1726 next_then_drop(v
.splice(5..8, vec
![1])); // replacement is smaller than original range
1727 assert_eq
!(*v0
, 13);
1728 next_then_drop(v
.splice(5..6, vec
![1; 10].into_iter().filter(|_
| true))); // lower bound not exact
1729 assert_eq
!(*v0
, 13);
1731 // spare_capacity_mut
1732 v
.spare_capacity_mut();
1733 assert_eq
!(*v0
, 13);
1735 // Smoke test that would fire even outside Miri if an actual relocation happened.
1737 assert_eq
!(v
[0], 0);
1740 // https://github.com/rust-lang/rust/pull/49496 introduced specialization based on:
1743 // unsafe impl<T: ?Sized> IsZero for *mut T {
1744 // fn is_zero(&self) -> bool {
1745 // (*self).is_null()
1750 // … to call `RawVec::with_capacity_zeroed` for creating `Vec<*mut T>`,
1751 // which is incorrect for fat pointers since `<*mut T>::is_null` only looks at the data component.
1752 // That is, a fat pointer can be “null” without being made entirely of zero bits.
1754 fn vec_macro_repeating_null_raw_fat_pointer() {
1755 let raw_dyn
= &mut (|| ()) as &mut dyn Fn() as *mut dyn Fn();
1756 let vtable
= dbg
!(ptr_metadata(raw_dyn
));
1757 let null_raw_dyn
= ptr_from_raw_parts(std
::ptr
::null_mut(), vtable
);
1758 assert
!(null_raw_dyn
.is_null());
1760 let vec
= vec
![null_raw_dyn
; 1];
1761 dbg
!(ptr_metadata(vec
[0]));
1762 assert
!(vec
[0] == null_raw_dyn
);
1764 // Polyfill for https://github.com/rust-lang/rfcs/pull/2580
1766 fn ptr_metadata(ptr
: *mut dyn Fn()) -> *mut () {
1767 unsafe { std::mem::transmute::<*mut dyn Fn(), DynRepr>(ptr).vtable }
1770 fn ptr_from_raw_parts(data
: *mut (), vtable
: *mut ()) -> *mut dyn Fn() {
1771 unsafe { std::mem::transmute::<DynRepr, *mut dyn Fn()>(DynRepr { data, vtable }
) }
1781 // This test will likely fail if you change the capacities used in
1782 // `RawVec::grow_amortized`.
1784 fn test_push_growth_strategy() {
1785 // If the element size is 1, we jump from 0 to 8, then double.
1787 let mut v1
: Vec
<u8> = vec
![];
1788 assert_eq
!(v1
.capacity(), 0);
1792 assert_eq
!(v1
.capacity(), 8);
1797 assert_eq
!(v1
.capacity(), 16);
1802 assert_eq
!(v1
.capacity(), 32);
1807 assert_eq
!(v1
.capacity(), 64);
1811 // If the element size is 2..=1024, we jump from 0 to 4, then double.
1813 let mut v2
: Vec
<u16> = vec
![];
1814 let mut v1024
: Vec
<[u8; 1024]> = vec
![];
1815 assert_eq
!(v2
.capacity(), 0);
1816 assert_eq
!(v1024
.capacity(), 0);
1820 v1024
.push([0; 1024]);
1821 assert_eq
!(v2
.capacity(), 4);
1822 assert_eq
!(v1024
.capacity(), 4);
1827 v1024
.push([0; 1024]);
1828 assert_eq
!(v2
.capacity(), 8);
1829 assert_eq
!(v1024
.capacity(), 8);
1834 v1024
.push([0; 1024]);
1835 assert_eq
!(v2
.capacity(), 16);
1836 assert_eq
!(v1024
.capacity(), 16);
1841 v1024
.push([0; 1024]);
1842 assert_eq
!(v2
.capacity(), 32);
1843 assert_eq
!(v1024
.capacity(), 32);
1848 v1024
.push([0; 1024]);
1849 assert_eq
!(v2
.capacity(), 64);
1850 assert_eq
!(v1024
.capacity(), 64);
1854 // If the element size is > 1024, we jump from 0 to 1, then double.
1856 let mut v1025
: Vec
<[u8; 1025]> = vec
![];
1857 assert_eq
!(v1025
.capacity(), 0);
1860 v1025
.push([0; 1025]);
1861 assert_eq
!(v1025
.capacity(), 1);
1865 v1025
.push([0; 1025]);
1866 assert_eq
!(v1025
.capacity(), 2);
1870 v1025
.push([0; 1025]);
1871 assert_eq
!(v1025
.capacity(), 4);
1875 v1025
.push([0; 1025]);
1876 assert_eq
!(v1025
.capacity(), 8);
1880 v1025
.push([0; 1025]);
1881 assert_eq
!(v1025
.capacity(), 16);
1885 v1025
.push([0; 1025]);
1886 assert_eq
!(v1025
.capacity(), 32);
1890 v1025
.push([0; 1025]);
1891 assert_eq
!(v1025
.capacity(), 64);
1896 macro_rules
! generate_assert_eq_vec_and_prim
{
1897 ($name
:ident
<$B
:ident
>($
type:ty
)) => {
1898 fn $name
<A
: PartialEq
<$B
> + Debug
, $B
: Debug
>(a
: Vec
<A
>, b
: $
type) {
1905 generate_assert_eq_vec_and_prim
! { assert_eq_vec_and_slice <B>(&[B]) }
1906 generate_assert_eq_vec_and_prim
! { assert_eq_vec_and_array_3<B>([B; 3]) }
1909 fn partialeq_vec_and_prim() {
1910 assert_eq_vec_and_slice(vec
![1, 2, 3], &[1, 2, 3]);
1911 assert_eq_vec_and_array_3(vec
![1, 2, 3], [1, 2, 3]);
1914 macro_rules
! assert_partial_eq_valid
{
1915 ($a2
:expr
, $a3
:expr
; $b2
:expr
, $b3
: expr
) => {
1916 assert
!($a2
== $b2
);
1917 assert
!($a2
!= $b3
);
1918 assert
!($a3
!= $b2
);
1919 assert
!($a3
== $b3
);
1920 assert_eq
!($a2
, $b2
);
1921 assert_ne
!($a2
, $b3
);
1922 assert_ne
!($a3
, $b2
);
1923 assert_eq
!($a3
, $b3
);
1928 fn partialeq_vec_full() {
1929 let vec2
: Vec
<_
> = vec
![1, 2];
1930 let vec3
: Vec
<_
> = vec
![1, 2, 3];
1931 let slice2
: &[_
] = &[1, 2];
1932 let slice3
: &[_
] = &[1, 2, 3];
1933 let slicemut2
: &[_
] = &mut [1, 2];
1934 let slicemut3
: &[_
] = &mut [1, 2, 3];
1935 let array2
: [_
; 2] = [1, 2];
1936 let array3
: [_
; 3] = [1, 2, 3];
1937 let arrayref2
: &[_
; 2] = &[1, 2];
1938 let arrayref3
: &[_
; 3] = &[1, 2, 3];
1940 assert_partial_eq_valid
!(vec2
,vec3
; vec2
,vec3
);
1941 assert_partial_eq_valid
!(vec2
,vec3
; slice2
,slice3
);
1942 assert_partial_eq_valid
!(vec2
,vec3
; slicemut2
,slicemut3
);
1943 assert_partial_eq_valid
!(slice2
,slice3
; vec2
,vec3
);
1944 assert_partial_eq_valid
!(slicemut2
,slicemut3
; vec2
,vec3
);
1945 assert_partial_eq_valid
!(vec2
,vec3
; array2
,array3
);
1946 assert_partial_eq_valid
!(vec2
,vec3
; arrayref2
,arrayref3
);
1947 assert_partial_eq_valid
!(vec2
,vec3
; arrayref2
[..],arrayref3
[..]);
1951 fn test_vec_cycle() {
1954 v
: Vec
<Cell
<Option
<&'a C
<'a
>>>>,
1963 let mut c1
= C
::new();
1964 let mut c2
= C
::new();
1965 let mut c3
= C
::new();
1968 c1
.v
.push(Cell
::new(None
));
1969 c1
.v
.push(Cell
::new(None
));
1971 c2
.v
.push(Cell
::new(None
));
1972 c2
.v
.push(Cell
::new(None
));
1974 c3
.v
.push(Cell
::new(None
));
1975 c3
.v
.push(Cell
::new(None
));
1978 c1
.v
[0].set(Some(&c2
));
1979 c1
.v
[1].set(Some(&c3
));
1981 c2
.v
[0].set(Some(&c2
));
1982 c2
.v
[1].set(Some(&c3
));
1984 c3
.v
[0].set(Some(&c1
));
1985 c3
.v
[1].set(Some(&c2
));
1989 fn test_vec_cycle_wrapped() {
1991 v
: Vec
<Cell
<Option
<&'a C
<'a
>>>>,
1999 fn new() -> Refs
<'a
> {
2000 Refs { v: Vec::new() }
2006 C { refs: Refs::new() }
2010 let mut c1
= C
::new();
2011 let mut c2
= C
::new();
2012 let mut c3
= C
::new();
2014 c1
.refs
.v
.push(Cell
::new(None
));
2015 c1
.refs
.v
.push(Cell
::new(None
));
2016 c2
.refs
.v
.push(Cell
::new(None
));
2017 c2
.refs
.v
.push(Cell
::new(None
));
2018 c3
.refs
.v
.push(Cell
::new(None
));
2019 c3
.refs
.v
.push(Cell
::new(None
));
2021 c1
.refs
.v
[0].set(Some(&c2
));
2022 c1
.refs
.v
[1].set(Some(&c3
));
2023 c2
.refs
.v
[0].set(Some(&c2
));
2024 c2
.refs
.v
[1].set(Some(&c3
));
2025 c3
.refs
.v
[0].set(Some(&c1
));
2026 c3
.refs
.v
[1].set(Some(&c2
));
2030 fn test_zero_sized_vec_push() {
2034 let mut tester
= Vec
::with_capacity(len
);
2035 assert_eq
!(tester
.len(), 0);
2036 assert
!(tester
.capacity() >= len
);
2040 assert_eq
!(tester
.len(), len
);
2041 assert_eq
!(tester
.iter().count(), len
);
2047 fn test_vec_macro_repeat() {
2048 assert_eq
!(vec
![1; 3], vec
![1, 1, 1]);
2049 assert_eq
!(vec
![1; 2], vec
![1, 1]);
2050 assert_eq
!(vec
![1; 1], vec
![1]);
2051 assert_eq
!(vec
![1; 0], vec
![]);
2053 // from_elem syntax (see RFC 832)
2054 let el
= Box
::new(1);
2056 assert_eq
!(vec
![el
; n
], vec
![Box
::new(1), Box
::new(1), Box
::new(1)]);
2060 fn test_vec_swap() {
2061 let mut a
: Vec
<isize> = vec
![0, 1, 2, 3, 4, 5, 6];
2063 assert_eq
!(a
[2], 4);
2064 assert_eq
!(a
[4], 2);
2066 swap(&mut n
, &mut a
[0]);
2067 assert_eq
!(a
[0], 42);
2072 fn test_extend_from_within_spec() {
2076 impl Clone
for CopyOnly
{
2077 fn clone(&self) -> Self {
2078 panic
!("extend_from_within must use specialization on copy");
2082 vec
![CopyOnly
, CopyOnly
].extend_from_within(..);
2086 fn test_extend_from_within_clone() {
2087 let mut v
= vec
![String
::from("sssss"), String
::from("12334567890"), String
::from("c")];
2088 v
.extend_from_within(1..);
2090 assert_eq
!(v
, ["sssss", "12334567890", "c", "12334567890", "c"]);
2094 fn test_extend_from_within_complete_rande() {
2095 let mut v
= vec
![0, 1, 2, 3];
2096 v
.extend_from_within(..);
2098 assert_eq
!(v
, [0, 1, 2, 3, 0, 1, 2, 3]);
2102 fn test_extend_from_within_empty_rande() {
2103 let mut v
= vec
![0, 1, 2, 3];
2104 v
.extend_from_within(1..1);
2106 assert_eq
!(v
, [0, 1, 2, 3]);
2111 fn test_extend_from_within_out_of_rande() {
2112 let mut v
= vec
![0, 1];
2113 v
.extend_from_within(..3);
2117 fn test_extend_from_within_zst() {
2118 let mut v
= vec
![(); 8];
2119 v
.extend_from_within(3..7);
2121 assert_eq
!(v
, [(); 12]);
2125 fn test_extend_from_within_empty_vec() {
2126 let mut v
= Vec
::<i32>::new();
2127 v
.extend_from_within(..);
2133 fn test_extend_from_within() {
2134 let mut v
= vec
![String
::from("a"), String
::from("b"), String
::from("c")];
2135 v
.extend_from_within(1..=2);
2136 v
.extend_from_within(..=1);
2138 assert_eq
!(v
, ["a", "b", "c", "b", "c", "a", "b"]);
2142 fn test_vec_dedup_by() {
2143 let mut vec
: Vec
<i32> = vec
![1, -1, 2, 3, 1, -5, 5, -2, 2];
2145 vec
.dedup_by(|a
, b
| a
.abs() == b
.abs());
2147 assert_eq
!(vec
, [1, 2, 3, 1, -5, -2]);
2151 fn test_vec_dedup_empty() {
2152 let mut vec
: Vec
<i32> = Vec
::new();
2156 assert_eq
!(vec
, []);
2160 fn test_vec_dedup_one() {
2161 let mut vec
= vec
![12i32];
2165 assert_eq
!(vec
, [12]);
2169 fn test_vec_dedup_multiple_ident() {
2170 let mut vec
= vec
![12, 12, 12, 12, 12, 11, 11, 11, 11, 11, 11];
2174 assert_eq
!(vec
, [12, 11]);
2178 fn test_vec_dedup_partialeq() {
2180 struct Foo(i32, i32);
2182 impl PartialEq
for Foo
{
2183 fn eq(&self, other
: &Foo
) -> bool
{
2188 let mut vec
= vec
![Foo(0, 1), Foo(0, 5), Foo(1, 7), Foo(1, 9)];
2191 assert_eq
!(vec
, [Foo(0, 1), Foo(1, 7)]);
2195 fn test_vec_dedup() {
2196 let mut vec
: Vec
<bool
> = Vec
::with_capacity(8);
2197 let mut template
= vec
.clone();
2199 for x
in 0u8..255u8 {
2203 let iter
= (0..8).map(move |bit
| (x
>> bit
) & 1 == 1);
2205 template
.extend_from_slice(&vec
);
2207 let (dedup
, _
) = template
.partition_dedup();
2210 assert_eq
!(vec
, dedup
);
2215 fn test_vec_dedup_panicking() {
2218 drop_counter
: &'
static AtomicU32
,
2223 impl PartialEq
for Panic
{
2224 fn eq(&self, other
: &Self) -> bool
{
2225 self.value
== other
.value
2229 impl Drop
for Panic
{
2230 fn drop(&mut self) {
2231 let x
= self.drop_counter
.fetch_add(1, Ordering
::SeqCst
);
2236 static DROP_COUNTER
: AtomicU32
= AtomicU32
::new(0);
2238 Panic { drop_counter: &DROP_COUNTER, value: false, index: 0 }
,
2239 Panic { drop_counter: &DROP_COUNTER, value: false, index: 5 }
,
2240 Panic { drop_counter: &DROP_COUNTER, value: true, index: 6 }
,
2241 Panic { drop_counter: &DROP_COUNTER, value: true, index: 7 }
,
2244 Panic { drop_counter: &DROP_COUNTER, value: false, index: 0 }
,
2245 // these elements get deduplicated
2246 Panic { drop_counter: &DROP_COUNTER, value: false, index: 1 }
,
2247 Panic { drop_counter: &DROP_COUNTER, value: false, index: 2 }
,
2248 Panic { drop_counter: &DROP_COUNTER, value: false, index: 3 }
,
2249 Panic { drop_counter: &DROP_COUNTER, value: false, index: 4 }
,
2251 Panic { drop_counter: &DROP_COUNTER, value: false, index: 5 }
,
2252 Panic { drop_counter: &DROP_COUNTER, value: true, index: 6 }
,
2253 Panic { drop_counter: &DROP_COUNTER, value: true, index: 7 }
,
2256 let _
= std
::panic
::catch_unwind(std
::panic
::AssertUnwindSafe(|| {
2260 let ok
= vec
.iter().zip(expected
.iter()).all(|(x
, y
)| x
.index
== y
.index
);
2263 panic
!("expected: {:?}\ngot: {:?}\n", expected
, vec
);
2267 // Regression test for issue #82533
2269 fn test_extend_from_within_panicing_clone() {
2271 drop_count
: &'dc AtomicU32
,
2275 impl Clone
for Panic
<'_
> {
2276 fn clone(&self) -> Self {
2278 panic
!("panic! at the clone");
2285 impl Drop
for Panic
<'_
> {
2286 fn drop(&mut self) {
2287 self.drop_count
.fetch_add(1, Ordering
::SeqCst
);
2291 let count
= core
::sync
::atomic
::AtomicU32
::new(0);
2293 Panic { drop_count: &count, aaaaa: false }
,
2294 Panic { drop_count: &count, aaaaa: true }
,
2295 Panic { drop_count: &count, aaaaa: false }
,
2298 // This should clone&append one Panic{..} at the end, and then panic while
2299 // cloning second Panic{..}. This means that `Panic::drop` should be called
2300 // 4 times (3 for items already in vector, 1 for just appended).
2302 // Previously just appended item was leaked, making drop_count = 3, instead of 4.
2303 std
::panic
::catch_unwind(move || vec
.extend_from_within(..)).unwrap_err();
2305 assert_eq
!(count
.load(Ordering
::SeqCst
), 4);