#![allow(
unknown_lints,
unused_must_use,
clippy::unnecessary_operation,
clippy::op_ref,
clippy::verbose_bit_mask,
clippy::reversed_empty_ranges,
clippy::vtable_address_comparisons,
clippy::clippy::assign_op_pattern,
clippy::clippy::many_single_char_names,
clippy::clippy::redundant_closure,
clippy::unit_arg,
clippy::unnecessary_filter_map,
clippy::eq_op,
clippy::redundant_slicing,
clippy::iter_count,
clippy::assign_op_pattern,
clippy::redundant_closure
)]
extern crate minivec;
use minivec::mini_vec;
use minivec::MiniVec;
use std::fmt::Debug;
use std::mem::{size_of, swap};
use std::ops::Bound::*;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::rc::Rc;
struct DropCounter<'a> {
count: &'a mut u32,
}
impl Drop for DropCounter<'_> {
fn drop(&mut self) {
*self.count += 1;
}
}
#[test]
fn test_small_vec_struct() {
assert_eq!(size_of::<MiniVec<u8>>(), size_of::<usize>());
}
#[test]
fn test_double_drop() {
struct TwoVec<T> {
x: MiniVec<T>,
y: MiniVec<T>,
}
let (mut count_x, mut count_y) = (0, 0);
{
let mut tv = TwoVec {
x: MiniVec::new(),
y: MiniVec::new(),
};
tv.x.push(DropCounter {
count: &mut count_x,
});
tv.y.push(DropCounter {
count: &mut count_y,
});
drop(tv.x);
}
assert_eq!(count_x, 1);
assert_eq!(count_y, 1);
}
#[test]
fn test_reserve() {
let mut v = MiniVec::new();
assert_eq!(v.capacity(), 0);
v.reserve(2);
assert!(v.capacity() >= 2);
for i in 0..16 {
v.push(i);
}
assert!(v.capacity() >= 16);
v.reserve(16);
assert!(v.capacity() >= 32);
v.push(16);
v.reserve(16);
assert!(v.capacity() >= 33)
}
#[test]
fn test_indexing() {
let v: MiniVec<isize> = mini_vec![10, 20];
assert_eq!(v[0], 10);
assert_eq!(v[1], 20);
let mut x: usize = 0;
assert_eq!(v[x], 10);
assert_eq!(v[x + 1], 20);
x = x + 1;
assert_eq!(v[x], 20);
assert_eq!(v[x - 1], 10);
}
#[test]
fn test_debug_fmt() {
let vec1: MiniVec<isize> = mini_vec![];
assert_eq!("[]", format!("{:?}", vec1));
let vec2 = mini_vec![0, 1];
assert_eq!("[0, 1]", format!("{:?}", vec2));
let slice: &[isize] = &[4, 5];
assert_eq!("[4, 5]", format!("{:?}", slice));
}
#[test]
fn test_push() {
let mut v = mini_vec![];
v.push(1);
assert_eq!(v, [1]);
v.push(2);
assert_eq!(v, [1, 2]);
v.push(3);
assert_eq!(v, [1, 2, 3]);
}
#[test]
fn test_extend() {
let mut v = MiniVec::new();
let mut w = MiniVec::new();
v.extend(w.clone());
assert_eq!(v, &[]);
v.extend(0..3);
for i in 0..3 {
w.push(i);
}
assert_eq!(v, w);
v.extend(3..10);
for i in 3..10 {
w.push(i);
}
assert_eq!(v, w);
v.extend(w.clone()); assert!(v.iter().eq(w.iter().chain(w.iter())));
}
#[test]
fn test_extend_from_slice() {
let a: MiniVec<isize> = mini_vec![1, 2, 3, 4, 5];
let b: MiniVec<isize> = mini_vec![6, 7, 8, 9, 0];
let mut v: MiniVec<isize> = a;
v.extend_from_slice(&b);
assert_eq!(v, [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]);
}
#[test]
fn test_extend_ref() {
let mut v = mini_vec![1, 2];
v.extend(&[3, 4, 5]);
assert_eq!(v.len(), 5);
assert_eq!(v, [1, 2, 3, 4, 5]);
let w = mini_vec![6, 7];
v.extend(&w);
assert_eq!(v.len(), 7);
assert_eq!(v, [1, 2, 3, 4, 5, 6, 7]);
}
#[test]
fn test_slice_from_ref() {
let values = mini_vec![1, 2, 3, 4, 5];
let slice = &values[1..3];
assert_eq!(slice, [2, 3]);
}
#[test]
fn test_slice_from_mut() {
let mut values = mini_vec![1, 2, 3, 4, 5];
{
let slice = &mut values[2..];
assert!(slice == [3, 4, 5]);
for p in slice {
*p += 2;
}
}
assert!(values == [1, 2, 5, 6, 7]);
}
#[test]
fn test_slice_to_mut() {
let mut values = mini_vec![1, 2, 3, 4, 5];
{
let slice = &mut values[..2];
assert!(slice == [1, 2]);
for p in slice {
*p += 1;
}
}
assert!(values == [2, 3, 3, 4, 5]);
}
#[test]
fn test_split_at_mut() {
let mut values = mini_vec![1, 2, 3, 4, 5];
{
let (left, right) = values.split_at_mut(2);
{
let left: &[_] = left;
assert!(&left[..left.len()] == &[1, 2]);
}
for p in left {
*p += 1;
}
{
let right: &[_] = right;
assert!(&right[..right.len()] == &[3, 4, 5]);
}
for p in right {
*p += 2;
}
}
assert_eq!(values, [2, 3, 5, 6, 7]);
}
#[test]
fn test_clone() {
let v: MiniVec<i32> = mini_vec![];
let w = mini_vec![1, 2, 3];
assert_eq!(v, v.clone());
let z = w.clone();
assert_eq!(w, z);
assert!(w.as_ptr() != z.as_ptr())
}
#[test]
fn test_clone_from() {
let mut v = mini_vec![];
let three: MiniVec<Box<_>> = mini_vec![Box::new(1), Box::new(2), Box::new(3)];
let two: MiniVec<Box<_>> = mini_vec![Box::new(4), Box::new(5)];
v.clone_from(&three);
assert_eq!(v, three);
v.clone_from(&three);
assert_eq!(v, three);
v.clone_from(&two);
assert_eq!(v, two);
v.clone_from(&three);
assert_eq!(v, three)
}
#[test]
fn test_retain() {
let mut vec = mini_vec![1, 2, 3, 4];
vec.retain(|&x| x % 2 == 0);
assert_eq!(vec, [2, 4]);
}
#[test]
fn test_retain_pred_panic_with_hole() {
let v = (0..5).map(Rc::new).collect::<MiniVec<_>>();
catch_unwind(AssertUnwindSafe(|| {
let mut v = v.clone();
v.retain(|r| match **r {
0 => true,
1 => false,
2 => true,
_ => panic!(),
});
}))
.unwrap_err();
assert!(v.iter().all(|r| Rc::strong_count(r) == 1));
}
#[test]
fn test_retain_pred_panic_no_hole() {
let v = (0..5).map(Rc::new).collect::<MiniVec<_>>();
catch_unwind(AssertUnwindSafe(|| {
let mut v = v.clone();
v.retain(|r| match **r {
0 | 1 | 2 => true,
_ => panic!(),
});
}))
.unwrap_err();
assert!(v.iter().all(|r| Rc::strong_count(r) == 1));
}
#[test]
fn test_retain_drop_panic() {
struct Wrap(Rc<i32>);
impl Drop for Wrap {
fn drop(&mut self) {
if *self.0 == 3 {
panic!();
}
}
}
let v = (0..5).map(|x| Rc::new(x)).collect::<MiniVec<_>>();
catch_unwind(AssertUnwindSafe(|| {
let mut v = v.iter().map(|r| Wrap(r.clone())).collect::<MiniVec<_>>();
v.retain(|w| match *w.0 {
0 => true,
1 => false,
2 => true,
3 => false, _ => true,
});
}))
.unwrap_err();
assert!(v.iter().all(|r| Rc::strong_count(r) == 1));
}
#[test]
fn test_dedup() {
fn case(a: MiniVec<i32>, b: MiniVec<i32>) {
let mut v = a;
v.dedup();
assert_eq!(v, b);
}
case(mini_vec![], mini_vec![]);
case(mini_vec![1], mini_vec![1]);
case(mini_vec![1, 1], mini_vec![1]);
case(mini_vec![1, 2, 3], mini_vec![1, 2, 3]);
case(mini_vec![1, 1, 2, 3], mini_vec![1, 2, 3]);
case(mini_vec![1, 2, 2, 3], mini_vec![1, 2, 3]);
case(mini_vec![1, 2, 3, 3], mini_vec![1, 2, 3]);
case(mini_vec![1, 1, 2, 2, 2, 3, 3], mini_vec![1, 2, 3]);
}
#[test]
fn test_dedup_by_key() {
fn case(a: MiniVec<i32>, b: MiniVec<i32>) {
let mut v = a;
v.dedup_by_key(|i| *i / 10);
assert_eq!(v, b);
}
case(mini_vec![], mini_vec![]);
case(mini_vec![10], mini_vec![10]);
case(mini_vec![10, 11], mini_vec![10]);
case(mini_vec![10, 20, 30], mini_vec![10, 20, 30]);
case(mini_vec![10, 11, 20, 30], mini_vec![10, 20, 30]);
case(mini_vec![10, 20, 21, 30], mini_vec![10, 20, 30]);
case(mini_vec![10, 20, 30, 31], mini_vec![10, 20, 30]);
case(mini_vec![10, 11, 20, 21, 22, 30, 31], mini_vec![10, 20, 30]);
}
#[test]
fn test_dedup_by() {
let mut vec = mini_vec!["foo", "bar", "Bar", "baz", "bar"];
vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
let mut vec = mini_vec![("foo", 1), ("foo", 2), ("bar", 3), ("bar", 4), ("bar", 5)];
vec.dedup_by(|a, b| {
a.0 == b.0 && {
b.1 += a.1;
true
}
});
assert_eq!(vec, [("foo", 3), ("bar", 12)]);
}
#[test]
fn test_dedup_unique() {
let mut v0: MiniVec<Box<_>> = mini_vec![Box::new(1), Box::new(1), Box::new(2), Box::new(3)];
v0.dedup();
let mut v1: MiniVec<Box<_>> = mini_vec![Box::new(1), Box::new(2), Box::new(2), Box::new(3)];
v1.dedup();
let mut v2: MiniVec<Box<_>> = mini_vec![Box::new(1), Box::new(2), Box::new(3), Box::new(3)];
v2.dedup();
}
#[test]
fn test_partition() {
assert_eq!(
mini_vec![].into_iter().partition(|x: &i32| *x < 3),
(mini_vec![], mini_vec![])
);
assert_eq!(
mini_vec![1, 2, 3].into_iter().partition(|x| *x < 4),
(mini_vec![1, 2, 3], mini_vec![])
);
assert_eq!(
mini_vec![1, 2, 3].into_iter().partition(|x| *x < 2),
(mini_vec![1], mini_vec![2, 3])
);
assert_eq!(
mini_vec![1, 2, 3].into_iter().partition(|x| *x < 0),
(mini_vec![], mini_vec![1, 2, 3])
);
}
#[test]
fn test_zip_unzip() {
let z1 = mini_vec![(1, 4), (2, 5), (3, 6)];
let (left, right): (MiniVec<_>, MiniVec<_>) = z1.iter().cloned().unzip();
assert_eq!((1, 4), (left[0], right[0]));
assert_eq!((2, 5), (left[1], right[1]));
assert_eq!((3, 6), (left[2], right[2]));
}
#[test]
fn test_cmp() {
let x: &[isize] = &[1, 2, 3, 4, 5];
let cmp: &[isize] = &[1, 2, 3, 4, 5];
assert_eq!(&x[..], cmp);
let cmp: &[isize] = &[3, 4, 5];
assert_eq!(&x[2..], cmp);
let cmp: &[isize] = &[1, 2, 3];
assert_eq!(&x[..3], cmp);
let cmp: &[isize] = &[2, 3, 4];
assert_eq!(&x[1..4], cmp);
let x: MiniVec<isize> = mini_vec![1, 2, 3, 4, 5];
let cmp: &[isize] = &[1, 2, 3, 4, 5];
assert_eq!(&x[..], cmp);
let cmp: &[isize] = &[3, 4, 5];
assert_eq!(&x[2..], cmp);
let cmp: &[isize] = &[1, 2, 3];
assert_eq!(&x[..3], cmp);
let cmp: &[isize] = &[2, 3, 4];
assert_eq!(&x[1..4], cmp);
}
#[test]
fn test_vec_truncate_drop() {
static mut DROPS: u32 = 0;
struct Elem(i32);
impl Drop for Elem {
fn drop(&mut self) {
unsafe {
DROPS += 1;
}
}
}
let mut v = mini_vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
assert_eq!(unsafe { DROPS }, 0);
v.truncate(3);
assert_eq!(unsafe { DROPS }, 2);
v.truncate(0);
assert_eq!(unsafe { DROPS }, 5);
}
#[test]
#[should_panic]
fn test_vec_truncate_fail() {
struct BadElem(i32);
impl Drop for BadElem {
fn drop(&mut self) {
let BadElem(ref mut x) = *self;
if *x == 0xbadbeef {
panic!("BadElem panic: 0xbadbeef")
}
}
}
let mut v = mini_vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
v.truncate(0);
}
#[test]
fn test_index() {
let vec = mini_vec![1, 2, 3];
assert!(vec[1] == 2);
}
#[test]
#[should_panic]
fn test_index_out_of_bounds() {
let vec = mini_vec![1, 2, 3];
let _ = vec[3];
}
#[test]
#[should_panic]
fn test_slice_out_of_bounds_1() {
let x = mini_vec![1, 2, 3, 4, 5];
&x[!0..];
}
#[test]
#[should_panic]
fn test_slice_out_of_bounds_2() {
let x = mini_vec![1, 2, 3, 4, 5];
&x[..6];
}
#[test]
#[should_panic]
fn test_slice_out_of_bounds_3() {
let x = mini_vec![1, 2, 3, 4, 5];
&x[!0..4];
}
#[test]
#[should_panic]
fn test_slice_out_of_bounds_4() {
let x = mini_vec![1, 2, 3, 4, 5];
&x[1..6];
}
#[test]
#[should_panic]
fn test_slice_out_of_bounds_5() {
let x = mini_vec![1, 2, 3, 4, 5];
&x[3..2];
}
#[test]
#[should_panic]
fn test_swap_remove_empty() {
let mut vec = Vec::<i32>::new();
vec.swap_remove(0);
}
#[test]
fn test_move_items() {
let vec = mini_vec![1, 2, 3];
let mut vec2 = mini_vec![];
for i in vec {
vec2.push(i);
}
assert_eq!(vec2, [1, 2, 3]);
}
#[test]
fn test_move_items_reverse() {
let vec = mini_vec![1, 2, 3];
let mut vec2 = mini_vec![];
for i in vec.into_iter().rev() {
vec2.push(i);
}
assert_eq!(vec2, [3, 2, 1]);
}
#[test]
fn test_drain_empty_vec() {
let mut vec: MiniVec<i32> = mini_vec![];
let mut vec2: MiniVec<i32> = mini_vec![];
for i in vec.drain(..) {
vec2.push(i);
}
assert!(vec.is_empty());
assert!(vec2.is_empty());
}
#[test]
fn test_drain_items() {
let mut vec = mini_vec![1, 2, 3];
let mut vec2 = mini_vec![];
for i in vec.drain(..) {
vec2.push(i);
}
assert_eq!(vec, []);
assert_eq!(vec2, [1, 2, 3]);
}
#[test]
fn test_drain_items_reverse() {
let mut vec = mini_vec![1, 2, 3];
let mut vec2 = mini_vec![];
for i in vec.drain(..).rev() {
vec2.push(i);
}
assert_eq!(vec, []);
assert_eq!(vec2, [3, 2, 1]);
}
#[test]
#[should_panic]
fn test_drain_out_of_bounds() {
let mut v = mini_vec![1, 2, 3, 4, 5];
v.drain(5..6);
}
#[test]
fn test_drain_range() {
let mut v = mini_vec![1, 2, 3, 4, 5];
for _ in v.drain(4..) {}
assert_eq!(v, &[1, 2, 3, 4]);
let mut v: MiniVec<_> = (1..6).map(|x| x.to_string()).collect();
for _ in v.drain(1..4) {}
assert_eq!(v, &[1.to_string(), 5.to_string()]);
let mut v: MiniVec<_> = (1..6).map(|x| x.to_string()).collect();
for _ in v.drain(1..4).rev() {}
assert_eq!(v, &[1.to_string(), 5.to_string()]);
}
#[test]
fn test_drain_inclusive_range() {
let mut v = mini_vec!['a', 'b', 'c', 'd', 'e'];
for _ in v.drain(1..=3) {}
assert_eq!(v, &['a', 'e']);
let mut v: MiniVec<_> = (0..=5).map(|x| x.to_string()).collect();
for _ in v.drain(1..=5) {}
assert_eq!(v, &["0".to_string()]);
let mut v: MiniVec<String> = (0..=5).map(|x| x.to_string()).collect();
for _ in v.drain(0..=5) {}
assert_eq!(v, Vec::<String>::new());
let mut v: MiniVec<_> = (0..=5).map(|x| x.to_string()).collect();
for _ in v.drain(0..=3) {}
assert_eq!(v, &["4".to_string(), "5".to_string()]);
let mut v: MiniVec<_> = (0..=1).map(|x| x.to_string()).collect();
for _ in v.drain(..=0) {}
assert_eq!(v, &["1".to_string()]);
}
#[test]
#[should_panic]
fn test_drain_inclusive_out_of_bounds() {
let mut v = mini_vec![1, 2, 3, 4, 5];
v.drain(5..=5);
}
#[test]
#[should_panic]
fn test_drain_start_overflow() {
let mut v = mini_vec![1, 2, 3];
v.drain((Excluded(usize::MAX), Included(0)));
}
#[test]
#[should_panic]
fn test_drain_end_overflow() {
let mut v = mini_vec![1, 2, 3];
v.drain((Included(0), Included(usize::MAX)));
}
#[test]
fn test_drain_leak() {
static mut DROPS: i32 = 0;
#[derive(Debug, PartialEq)]
struct D(u32, bool);
impl Drop for D {
fn drop(&mut self) {
unsafe {
DROPS += 1;
}
if self.1 {
panic!("panic in `drop`");
}
}
}
let mut v = mini_vec![
D(0, false),
D(1, false),
D(2, false),
D(3, false),
D(4, true),
D(5, false),
D(6, false),
];
catch_unwind(AssertUnwindSafe(|| {
v.drain(2..=5);
}))
.ok();
assert_eq!(unsafe { DROPS }, 4);
assert_eq!(v, mini_vec![D(0, false), D(1, false), D(6, false),]);
}
#[test]
fn test_splice() {
let mut v = mini_vec![1, 2, 3, 4, 5];
let a = [10, 11, 12];
v.splice(2..4, a.iter().cloned());
assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
v.splice(1..3, Some(20));
assert_eq!(v, &[1, 20, 11, 12, 5]);
}
#[test]
fn test_splice_inclusive_range() {
let mut v = mini_vec![1, 2, 3, 4, 5];
let a = [10, 11, 12];
let t1: MiniVec<_> = v.splice(2..=3, a.iter().cloned()).collect();
assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
assert_eq!(t1, &[3, 4]);
let t2: MiniVec<_> = v.splice(1..=2, Some(20)).collect();
assert_eq!(v, &[1, 20, 11, 12, 5]);
assert_eq!(t2, &[2, 10]);
}
#[test]
#[should_panic]
fn test_splice_out_of_bounds() {
let mut v = mini_vec![1, 2, 3, 4, 5];
let a = [10, 11, 12];
v.splice(5..6, a.iter().cloned());
}
#[test]
#[should_panic]
fn test_splice_inclusive_out_of_bounds() {
let mut v = mini_vec![1, 2, 3, 4, 5];
let a = [10, 11, 12];
v.splice(5..=5, a.iter().cloned());
}
#[test]
fn test_splice_unbounded() {
let mut vec = mini_vec![1, 2, 3, 4, 5];
let t: MiniVec<_> = vec.splice(.., None).collect();
assert_eq!(vec, &[]);
assert_eq!(t, &[1, 2, 3, 4, 5]);
}
#[test]
fn test_splice_forget() {
let mut v = mini_vec![1, 2, 3, 4, 5];
let a = [10, 11, 12];
std::mem::forget(v.splice(2..4, a.iter().cloned()));
assert_eq!(v, &[1, 2]);
}
#[test]
fn test_append() {
let mut vec = mini_vec![1, 2, 3];
let mut vec2 = mini_vec![4, 5, 6];
vec.append(&mut vec2);
assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
assert_eq!(vec2, []);
}
#[test]
fn test_split_off() {
let mut vec = mini_vec![1, 2, 3, 4, 5, 6];
let orig_capacity = vec.capacity();
let vec2 = vec.split_off(4);
assert_eq!(vec, [1, 2, 3, 4]);
assert_eq!(vec2, [5, 6]);
assert_eq!(vec.capacity(), orig_capacity);
}
#[test]
fn test_split_off_take_all() {
let mut vec = mini_vec![1, 2, 3, 4, 5, 6];
let orig_ptr = vec.as_ptr();
let orig_capacity = vec.capacity();
let vec2 = vec.split_off(0);
assert_eq!(vec, []);
assert_eq!(vec2, [1, 2, 3, 4, 5, 6]);
assert_eq!(vec.capacity(), orig_capacity);
assert_eq!(vec2.as_ptr(), orig_ptr);
}
#[test]
fn test_into_iter_as_slice() {
let vec = mini_vec!['a', 'b', 'c'];
let mut into_iter = vec.into_iter();
assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
let _ = into_iter.next().unwrap();
assert_eq!(into_iter.as_slice(), &['b', 'c']);
let _ = into_iter.next().unwrap();
let _ = into_iter.next().unwrap();
assert_eq!(into_iter.as_slice(), &[]);
}
#[test]
fn test_into_iter_as_mut_slice() {
let vec = mini_vec!['a', 'b', 'c'];
let mut into_iter = vec.into_iter();
assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
into_iter.as_mut_slice()[0] = 'x';
into_iter.as_mut_slice()[1] = 'y';
assert_eq!(into_iter.next().unwrap(), 'x');
assert_eq!(into_iter.as_slice(), &['y', 'c']);
}
#[test]
fn test_into_iter_debug() {
let vec = mini_vec!['a', 'b', 'c'];
let into_iter = vec.into_iter();
let debug = format!("{:?}", into_iter);
assert_eq!(debug, "MiniVec::IntoIter(['a', 'b', 'c'])");
}
#[test]
fn test_into_iter_count() {
assert_eq!(mini_vec![1, 2, 3].into_iter().count(), 3);
}
#[test]
fn test_into_iter_clone() {
fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
let v: MiniVec<i32> = it.collect();
assert_eq!(&v[..], slice);
}
let mut it = mini_vec![1, 2, 3].into_iter();
iter_equal(it.clone(), &[1, 2, 3]);
assert_eq!(it.next(), Some(1));
let mut it = it.rev();
iter_equal(it.clone(), &[3, 2]);
assert_eq!(it.next(), Some(3));
iter_equal(it.clone(), &[2]);
assert_eq!(it.next(), Some(2));
iter_equal(it.clone(), &[]);
assert_eq!(it.next(), None);
}
#[test]
fn test_into_iter_leak() {
static mut DROPS: i32 = 0;
struct D(bool);
impl Drop for D {
fn drop(&mut self) {
unsafe {
DROPS += 1;
}
if self.0 {
panic!("panic in `drop`");
}
}
}
let v = mini_vec![D(false), D(true), D(false)];
catch_unwind(move || drop(v.into_iter())).ok();
assert_eq!(unsafe { DROPS }, 3);
}
#[test]
fn test_from_iter_specialization_panic_drop() {
let drop_count: MiniVec<_> = (0..=2).map(|_| Rc::new(())).collect();
let src: MiniVec<_> = drop_count.iter().cloned().collect();
let iter = src.into_iter();
let _ = std::panic::catch_unwind(AssertUnwindSafe(|| {
let _ = iter
.enumerate()
.filter_map(|(i, e)| {
if i == 1 {
std::panic!("aborting iteration");
}
Some(e)
})
.collect::<MiniVec<_>>();
}));
assert!(
drop_count
.iter()
.map(Rc::strong_count)
.all(|count| count == 1),
"all items were dropped once"
);
}
#[allow(dead_code)]
fn assert_covariance() {
fn drain<'new>(d: minivec::Drain<'static, &'static str>) -> minivec::Drain<'new, &'new str> {
d
}
fn into_iter<'new>(i: minivec::IntoIter<&'static str>) -> minivec::IntoIter<&'new str> {
i
}
}
#[test]
fn from_into_inner() {
let vec = mini_vec![1, 2, 3];
let vec = vec.into_iter().collect::<MiniVec<_>>();
assert_eq!(vec, [1, 2, 3]);
let ptr = &vec[1] as *const _;
let mut it = vec.into_iter();
it.next().unwrap();
let vec = it.collect::<MiniVec<_>>();
assert_eq!(vec, [2, 3]);
assert!(ptr != vec.as_ptr());
}
#[test]
fn overaligned_allocations() {
#[repr(align(256))]
struct Foo(usize);
let mut v = mini_vec![Foo(273)];
for i in 0..0x1000 {
v.reserve_exact(i);
assert!(v[0].0 == 273);
assert!(v.as_ptr() as usize & 0xff == 0);
v.shrink_to_fit();
assert!(v[0].0 == 273);
assert!(v.as_ptr() as usize & 0xff == 0);
}
}
#[test]
fn drain_filter_empty() {
let mut vec: MiniVec<i32> = mini_vec![];
{
let mut iter = vec.drain_filter(|_| true);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(iter.next(), None);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(iter.next(), None);
assert_eq!(iter.size_hint(), (0, Some(0)));
}
assert_eq!(vec.len(), 0);
assert_eq!(vec, mini_vec![]);
}
#[test]
fn drain_filter_false() {
let mut vec = mini_vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let initial_len = vec.len();
let mut count = 0;
{
let mut iter = vec.drain_filter(|_| false);
assert_eq!(iter.size_hint(), (0, Some(initial_len)));
for _ in iter.by_ref() {
count += 1;
}
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(iter.next(), None);
assert_eq!(iter.size_hint(), (0, Some(0)));
}
assert_eq!(count, 0);
assert_eq!(vec.len(), initial_len);
assert_eq!(vec, mini_vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
}
#[test]
fn drain_filter_true() {
let mut vec = mini_vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let initial_len = vec.len();
let mut count = 0;
{
let mut iter = vec.drain_filter(|_| true);
assert_eq!(iter.size_hint(), (0, Some(initial_len)));
while let Some(_) = iter.next() {
count += 1;
assert_eq!(iter.size_hint(), (0, Some(initial_len - count)));
}
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(iter.next(), None);
assert_eq!(iter.size_hint(), (0, Some(0)));
}
assert_eq!(count, initial_len);
assert_eq!(vec.len(), 0);
assert_eq!(vec, mini_vec![]);
}
#[test]
fn drain_filter_complex() {
{
let mut vec = mini_vec![
1, 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, 39,
];
let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<MiniVec<_>>();
assert_eq!(removed.len(), 10);
assert_eq!(removed, mini_vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
assert_eq!(vec.len(), 14);
assert_eq!(
vec,
mini_vec![1, 7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]
);
}
{
let mut vec = mini_vec![
2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, 39,
];
let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<MiniVec<_>>();
assert_eq!(removed.len(), 10);
assert_eq!(removed, mini_vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
assert_eq!(vec.len(), 13);
assert_eq!(
vec,
mini_vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]
);
}
{
let mut vec =
mini_vec![2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36,];
let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<MiniVec<_>>();
assert_eq!(removed.len(), 10);
assert_eq!(removed, mini_vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);
assert_eq!(vec.len(), 11);
assert_eq!(vec, mini_vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35]);
}
{
let mut vec = mini_vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19,];
let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<MiniVec<_>>();
assert_eq!(removed.len(), 10);
assert_eq!(removed, mini_vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
assert_eq!(vec.len(), 10);
assert_eq!(vec, mini_vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
}
{
let mut vec = mini_vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20,];
let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<MiniVec<_>>();
assert_eq!(removed.len(), 10);
assert_eq!(removed, mini_vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]);
assert_eq!(vec.len(), 10);
assert_eq!(vec, mini_vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]);
}
}
#[test]
#[cfg(not(target_os = "emscripten"))]
fn drain_filter_consumed_panic() {
use std::rc::Rc;
use std::sync::Mutex;
struct Check {
index: usize,
drop_counts: Rc<Mutex<MiniVec<usize>>>,
}
impl Drop for Check {
fn drop(&mut self) {
self.drop_counts.lock().unwrap()[self.index] += 1;
println!("drop: {}", self.index);
}
}
let check_count = 10;
let drop_counts = Rc::new(Mutex::new(mini_vec![0_usize; check_count]));
let mut data: MiniVec<Check> = (0..check_count)
.map(|index| Check {
index,
drop_counts: Rc::clone(&drop_counts),
})
.collect();
let _ = std::panic::catch_unwind(move || {
let filter = |c: &mut Check| {
if c.index == 2 {
panic!("panic at index: {}", c.index);
}
if c.index == 4 {
panic!("panic at index: {}", c.index);
}
c.index < 6
};
let drain = data.drain_filter(filter);
drain.for_each(drop);
});
let drop_counts = drop_counts.lock().unwrap();
assert_eq!(check_count, drop_counts.len());
for (index, count) in drop_counts.iter().cloned().enumerate() {
assert_eq!(
1, count,
"unexpected drop count at index: {} (count: {})",
index, count
);
}
}
#[test]
#[cfg(not(target_os = "emscripten"))]
fn drain_filter_unconsumed_panic() {
use std::rc::Rc;
use std::sync::Mutex;
struct Check {
index: usize,
drop_counts: Rc<Mutex<MiniVec<usize>>>,
}
impl Drop for Check {
fn drop(&mut self) {
self.drop_counts.lock().unwrap()[self.index] += 1;
println!("drop: {}", self.index);
}
}
let check_count = 10;
let drop_counts = Rc::new(Mutex::new(mini_vec![0_usize; check_count]));
let mut data: MiniVec<Check> = (0..check_count)
.map(|index| Check {
index,
drop_counts: Rc::clone(&drop_counts),
})
.collect();
let _ = std::panic::catch_unwind(move || {
let filter = |c: &mut Check| {
if c.index == 2 {
panic!("panic at index: {}", c.index);
}
if c.index == 4 {
panic!("panic at index: {}", c.index);
}
c.index < 6
};
let _drain = data.drain_filter(filter);
});
let drop_counts = drop_counts.lock().unwrap();
assert_eq!(check_count, drop_counts.len());
for (index, count) in drop_counts.iter().cloned().enumerate() {
assert_eq!(
1, count,
"unexpected drop count at index: {} (count: {})",
index, count
);
}
}
#[test]
fn drain_filter_unconsumed() {
let mut vec = mini_vec![1, 2, 3, 4];
let drain = vec.drain_filter(|&mut x| x % 2 != 0);
drop(drain);
assert_eq!(vec, [2, 4]);
}
#[test]
fn test_reserve_exact() {
let mut v = MiniVec::new();
assert_eq!(v.capacity(), 0);
v.reserve_exact(2);
assert!(v.capacity() >= 2);
for i in 0..16 {
v.push(i);
}
assert!(v.capacity() >= 16);
v.reserve_exact(16);
assert!(v.capacity() >= 32);
v.push(16);
v.reserve_exact(16);
assert!(v.capacity() >= 33)
}
#[test]
fn test_stable_pointers() {
fn next_then_drop<I: Iterator>(mut i: I) {
i.next().unwrap();
drop(i);
}
let mut v = MiniVec::with_capacity(128);
v.push(13);
let v0 = &mut v[0];
let v0 = unsafe { &mut *(v0 as *mut _) };
v.push(1);
v.push(2);
v.insert(1, 1);
assert_eq!(*v0, 13);
v.remove(1);
v.pop().unwrap();
assert_eq!(*v0, 13);
v.push(1);
v.swap_remove(1);
assert_eq!(v.len(), 2);
v.swap_remove(1); assert_eq!(*v0, 13);
v.append(&mut mini_vec![27, 19]);
assert_eq!(*v0, 13);
v.extend_from_slice(&[1, 2]);
v.extend(&[1, 2]); v.extend(mini_vec![2, 3]); v.extend(std::iter::once(3)); v.extend(std::iter::empty::<i32>()); v.extend(std::iter::once(3).filter(|_| true)); v.extend(std::iter::once(&3)); assert_eq!(*v0, 13);
v.truncate(2);
assert_eq!(*v0, 13);
v.resize_with(v.len() + 10, || 42);
assert_eq!(*v0, 13);
v.resize_with(2, || panic!());
assert_eq!(*v0, 13);
v.reserve(32);
v.reserve_exact(32);
assert_eq!(*v0, 13);
v.resize_with(10, || 42);
next_then_drop(v.drain(5..));
assert_eq!(*v0, 13);
v.resize_with(10, || 42);
next_then_drop(v.splice(5.., mini_vec![1, 2, 3, 4, 5])); assert_eq!(*v0, 13);
next_then_drop(v.splice(5..8, mini_vec![1])); assert_eq!(*v0, 13);
next_then_drop(v.splice(5..6, mini_vec![1; 10].into_iter().filter(|_| true))); assert_eq!(*v0, 13);
*v0 -= 13;
assert_eq!(v[0], 0);
}
#[test]
fn vec_macro_repeating_null_raw_fat_pointer() {
let raw_dyn = &mut (|| ()) as &mut dyn Fn() as *mut dyn Fn();
let vtable = dbg!(ptr_metadata(raw_dyn));
let null_raw_dyn = ptr_from_raw_parts(std::ptr::null_mut(), vtable);
assert!(null_raw_dyn.is_null());
let vec = mini_vec![null_raw_dyn; 1];
dbg!(ptr_metadata(vec[0]));
assert!(vec[0] == null_raw_dyn);
fn ptr_metadata(ptr: *mut dyn Fn()) -> *mut () {
unsafe { std::mem::transmute::<*mut dyn Fn(), DynRepr>(ptr).vtable }
}
fn ptr_from_raw_parts(data: *mut (), vtable: *mut ()) -> *mut dyn Fn() {
unsafe { std::mem::transmute::<DynRepr, *mut dyn Fn()>(DynRepr { data, vtable }) }
}
#[repr(C)]
struct DynRepr {
data: *mut (),
vtable: *mut (),
}
}
#[test]
fn test_push_growth_strategy() {
{
let mut v1: MiniVec<u8> = mini_vec![];
assert_eq!(v1.capacity(), 0);
for _ in 0..8 {
v1.push(0);
assert_eq!(v1.capacity(), 8);
}
for _ in 8..16 {
v1.push(0);
assert_eq!(v1.capacity(), 16);
}
for _ in 16..32 {
v1.push(0);
assert_eq!(v1.capacity(), 32);
}
for _ in 32..64 {
v1.push(0);
assert_eq!(v1.capacity(), 64);
}
}
{
let mut v2: MiniVec<u16> = mini_vec![];
let mut v1024: MiniVec<[u8; 1024]> = mini_vec![];
assert_eq!(v2.capacity(), 0);
assert_eq!(v1024.capacity(), 0);
for _ in 0..4 {
v2.push(0);
v1024.push([0; 1024]);
assert_eq!(v2.capacity(), 4);
assert_eq!(v1024.capacity(), 4);
}
for _ in 4..8 {
v2.push(0);
v1024.push([0; 1024]);
assert_eq!(v2.capacity(), 8);
assert_eq!(v1024.capacity(), 8);
}
for _ in 8..16 {
v2.push(0);
v1024.push([0; 1024]);
assert_eq!(v2.capacity(), 16);
assert_eq!(v1024.capacity(), 16);
}
for _ in 16..32 {
v2.push(0);
v1024.push([0; 1024]);
assert_eq!(v2.capacity(), 32);
assert_eq!(v1024.capacity(), 32);
}
for _ in 32..64 {
v2.push(0);
v1024.push([0; 1024]);
assert_eq!(v2.capacity(), 64);
assert_eq!(v1024.capacity(), 64);
}
}
{
let mut v1025: MiniVec<[u8; 1025]> = mini_vec![];
assert_eq!(v1025.capacity(), 0);
for _ in 0..1 {
v1025.push([0; 1025]);
assert_eq!(v1025.capacity(), 1);
}
for _ in 1..2 {
v1025.push([0; 1025]);
assert_eq!(v1025.capacity(), 2);
}
for _ in 2..4 {
v1025.push([0; 1025]);
assert_eq!(v1025.capacity(), 4);
}
for _ in 4..8 {
v1025.push([0; 1025]);
assert_eq!(v1025.capacity(), 8);
}
for _ in 8..16 {
v1025.push([0; 1025]);
assert_eq!(v1025.capacity(), 16);
}
for _ in 16..32 {
v1025.push([0; 1025]);
assert_eq!(v1025.capacity(), 32);
}
for _ in 32..64 {
v1025.push([0; 1025]);
assert_eq!(v1025.capacity(), 64);
}
}
}
macro_rules! generate_assert_eq_vec_and_prim {
($name:ident<$B:ident>($type:ty)) => {
fn $name<A: PartialEq<$B> + Debug, $B: Debug>(a: MiniVec<A>, b: $type) {
assert!(a == b);
assert_eq!(a, b);
}
};
}
generate_assert_eq_vec_and_prim! { assert_eq_vec_and_slice <B>(&[B]) }
generate_assert_eq_vec_and_prim! { assert_eq_vec_and_array_3<B>([B; 3]) }
#[test]
fn partialeq_vec_and_prim() {
assert_eq_vec_and_slice(mini_vec![1, 2, 3], &[1, 2, 3]);
assert_eq_vec_and_array_3(mini_vec![1, 2, 3], [1, 2, 3]);
}
macro_rules! assert_partial_eq_valid {
($a2:expr, $a3:expr; $b2:expr, $b3: expr) => {
assert!($a2 == $b2);
assert!($a2 != $b3);
assert!($a3 != $b2);
assert!($a3 == $b3);
assert_eq!($a2, $b2);
assert_ne!($a2, $b3);
assert_ne!($a3, $b2);
assert_eq!($a3, $b3);
};
}
#[test]
fn partialeq_vec_full() {
let vec2: MiniVec<_> = mini_vec![1, 2];
let vec3: MiniVec<_> = mini_vec![1, 2, 3];
let slice2: &[_] = &[1, 2];
let slice3: &[_] = &[1, 2, 3];
let slicemut2: &[_] = &mut [1, 2];
let slicemut3: &[_] = &mut [1, 2, 3];
let array2: [_; 2] = [1, 2];
let array3: [_; 3] = [1, 2, 3];
let arrayref2: &[_; 2] = &[1, 2];
let arrayref3: &[_; 3] = &[1, 2, 3];
assert_partial_eq_valid!(vec2,vec3; vec2,vec3);
assert_partial_eq_valid!(vec2,vec3; slice2,slice3);
assert_partial_eq_valid!(vec2,vec3; slicemut2,slicemut3);
assert_partial_eq_valid!(slice2,slice3; vec2,vec3);
assert_partial_eq_valid!(slicemut2,slicemut3; vec2,vec3);
assert_partial_eq_valid!(vec2,vec3; array2,array3);
assert_partial_eq_valid!(vec2,vec3; arrayref2,arrayref3);
assert_partial_eq_valid!(vec2,vec3; arrayref2[..],arrayref3[..]);
}
#[test]
fn test_zero_sized_vec_push() {
const N: usize = 8;
for len in 0..N {
let mut tester = Vec::with_capacity(len);
assert_eq!(tester.len(), 0);
assert!(tester.capacity() >= len);
for _ in 0..len {
tester.push(());
}
assert_eq!(tester.len(), len);
assert_eq!(tester.iter().count(), len);
tester.clear();
}
}
#[test]
fn test_vec_macro_repeat() {
assert_eq!(mini_vec![1; 3], mini_vec![1, 1, 1]);
assert_eq!(mini_vec![1; 2], mini_vec![1, 1]);
assert_eq!(mini_vec![1; 1], mini_vec![1]);
assert_eq!(mini_vec![1; 0], mini_vec![]);
let el = Box::new(1);
let n = 3;
assert_eq!(
mini_vec![el; n],
mini_vec![Box::new(1), Box::new(1), Box::new(1)]
);
}
#[test]
fn test_vec_swap() {
let mut a: MiniVec<isize> = mini_vec![0, 1, 2, 3, 4, 5, 6];
a.swap(2, 4);
assert_eq!(a[2], 4);
assert_eq!(a[4], 2);
let mut n = 42;
swap(&mut n, &mut a[0]);
assert_eq!(a[0], 42);
assert_eq!(n, 0);
}
#[test]
fn test_extend_from_within_clone() {
let mut v = mini_vec![
String::from("sssss"),
String::from("12334567890"),
String::from("c"),
];
v.extend_from_within(1..);
assert_eq!(v, ["sssss", "12334567890", "c", "12334567890", "c"]);
}
#[test]
fn test_extend_from_within_complete_rande() {
let mut v = mini_vec![0, 1, 2, 3];
v.extend_from_within(..);
assert_eq!(v, [0, 1, 2, 3, 0, 1, 2, 3]);
}
#[test]
fn test_extend_from_within_empty_rande() {
let mut v = mini_vec![0, 1, 2, 3];
v.extend_from_within(1..1);
assert_eq!(v, [0, 1, 2, 3]);
}
#[test]
#[should_panic]
fn test_extend_from_within_out_of_rande() {
let mut v = mini_vec![0, 1];
v.extend_from_within(..3);
}
#[test]
fn test_extend_from_within_empty_vec() {
let mut v = MiniVec::<i32>::new();
v.extend_from_within(..);
assert_eq!(v, []);
}
#[test]
fn test_extend_from_within() {
let mut v = mini_vec![String::from("a"), String::from("b"), String::from("c")];
v.extend_from_within(1..=2);
v.extend_from_within(..=1);
assert_eq!(v, ["a", "b", "c", "b", "c", "a", "b"]);
}