use crate::Size0Error;
#[cfg(feature = "smallvec-v1-write")]
use std::io;
use alloc::boxed::Box;
use alloc::vec::Vec;
use smallvec::*;
use smallvec_v1_ as smallvec;
pub use crate::__smallvec1_inline_macro_v1 as smallvec1_inline;
pub use crate::__smallvec1_macro_v1 as smallvec1;
use smallvec::Drain;
#[doc(hidden)]
#[macro_export]
macro_rules! __smallvec1_macro_v1 {
() => (
compile_error!("SmallVec1 needs at least 1 element")
);
($first:expr $(, $item:expr)* , ) => (
$crate::smallvec_v1::smallvec1!($first $(, $item)*)
);
($first:expr $(, $item:expr)* ) => ({
let smallvec = $crate::smallvec_v1_::smallvec!($first $(, $item)*);
$crate::smallvec_v1::SmallVec1::try_from_smallvec(smallvec).unwrap()
});
}
#[doc(hidden)]
#[macro_export]
macro_rules! __smallvec1_inline_macro_v1 {
() => (
compile_error!("SmallVec1 needs at least 1 element")
);
($first:expr $(, $item:expr)* , ) => (
$crate::smallvec_v1::smallvec1_inline!($first $(, $item)*)
);
($first:expr $(, $item:expr)* ) => ({
$crate::smallvec_v1::SmallVec1::from_array_const([$first $(, $item)*])
});
}
shared_impl! {
base_bounds_macro = A: Array,
item_ty_macro = A::Item,
pub struct SmallVec1<A>(SmallVec<A>);
}
impl<A> SmallVec1<A>
where
A: Array,
{
pub fn try_from_smallvec(wrapped: SmallVec<A>) -> Result<Self, Size0Error> {
if wrapped.is_empty() {
Err(Size0Error)
} else {
Ok(Self(wrapped))
}
}
pub fn try_from_buf(buf: A) -> Result<Self, Size0Error> {
Self::try_from_smallvec(SmallVec::from_buf(buf))
}
pub fn try_from_buf_and_len(buf: A, len: usize) -> Result<Self, Size0Error> {
Self::try_from_smallvec(SmallVec::from_buf_and_len(buf, len))
}
pub fn into_smallvec(self) -> SmallVec<A> {
self.0
}
pub fn as_smallvec(&self) -> &SmallVec<A> {
&self.0
}
pub fn into_vec(self) -> Vec<A::Item> {
self.0.into_vec()
}
pub fn into_inner(self) -> Result<A, Self> {
self.0.into_inner().map_err(SmallVec1)
}
pub fn insert_many<I: IntoIterator<Item = A::Item>>(&mut self, index: usize, iterable: I) {
self.0.insert_many(index, iterable)
}
}
impl<A> SmallVec1<A>
where
A: Array,
A::Item: Copy,
{
pub fn try_from_slice(slice: &[A::Item]) -> Result<Self, Size0Error> {
if slice.is_empty() {
Err(Size0Error)
} else {
Ok(Self(SmallVec::from_slice(slice)))
}
}
pub fn insert_from_slice(&mut self, index: usize, slice: &[A::Item]) {
self.0.insert_from_slice(index, slice)
}
}
impl<A> SmallVec1<A>
where
A: Array,
A::Item: Clone,
{
pub fn try_from_elem(element: A::Item, len: usize) -> Result<Self, Size0Error> {
if len == 0 {
Err(Size0Error)
} else {
Ok(Self(SmallVec::from_elem(element, len)))
}
}
}
impl<T, const N: usize> SmallVec1<[T; N]> {
pub const fn from_array_const(val: [T; N]) -> Self {
if N == 0 {
panic!("Empty arrays can not be used for creating a SmallVec1");
}
Self(SmallVec::from_const(val))
}
}
impl_wrapper! {
base_bounds_macro = A: Array,
impl<A> SmallVec1<A> {
fn inline_size(&self) -> usize;
fn spilled(&self) -> bool;
fn grow(&mut self, len: usize) -> ();
fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr>;
fn try_reserve_exact(&mut self, additional: usize) -> Result<(), CollectionAllocErr>;
fn try_grow(&mut self, len: usize) -> Result<(), CollectionAllocErr>;
}
}
impl<A, B> PartialEq<SmallVec1<B>> for SmallVec1<A>
where
A::Item: PartialEq<B::Item>,
A: Array,
B: Array,
{
#[inline]
fn eq(&self, other: &SmallVec1<B>) -> bool {
self.0.eq(&other.0)
}
}
impl<T, const N: usize> TryFrom<[T; N]> for SmallVec1<[T; N]> {
type Error = Size0Error;
fn try_from(vec: [T; N]) -> Result<Self, Size0Error> {
Self::try_from_buf(vec)
}
}
impl<T, const N: usize> TryFrom<SmallVec1<[T; N]>> for [T; N] {
type Error = SmallVec1<[T; N]>;
fn try_from(vec: SmallVec1<[T; N]>) -> Result<Self, SmallVec1<[T; N]>> {
vec.into_inner()
}
}
impl<A> IntoIterator for SmallVec1<A>
where
A: Array,
{
type Item = A::Item;
type IntoIter = smallvec::IntoIter<A>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
impl<A> From<SmallVec1<A>> for Vec<A::Item>
where
A: Array,
{
fn from(vec: SmallVec1<A>) -> Vec<A::Item> {
vec.into_vec()
}
}
impl<A> TryFrom<Vec<A::Item>> for SmallVec1<A>
where
A: Array,
{
type Error = Size0Error;
fn try_from(vec: Vec<A::Item>) -> Result<Self, Size0Error> {
Self::try_from_vec(vec)
}
}
impl<A> From<SmallVec1<A>> for Box<[A::Item]>
where
A: Array,
{
fn from(vec: SmallVec1<A>) -> Self {
vec.into_boxed_slice()
}
}
#[cfg(feature = "smallvec-v1-write")]
impl<A> io::Write for SmallVec1<A>
where
A: Array<Item = u8>,
{
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.0.write(buf)
}
#[inline]
fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
self.0.write_vectored(bufs)
}
#[inline]
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
self.0.write_all(buf)
}
#[inline]
fn flush(&mut self) -> io::Result<()> {
self.0.flush()
}
}
#[cfg(test)]
mod tests {
mod SmallVec1 {
#![allow(non_snake_case)]
use super::super::*;
use core::num::NonZeroUsize;
use std::{
borrow::{Borrow, BorrowMut, ToOwned},
cmp::Ordering,
collections::hash_map::DefaultHasher,
format,
hash::{Hash, Hasher},
panic::catch_unwind,
string::String,
vec,
vec::Vec,
};
#[test]
fn Clone() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3];
let b = a.clone();
assert_eq!(a, b);
}
#[test]
fn Eq() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3];
let b: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3];
let c: SmallVec1<[u8; 4]> = smallvec1![2, 2, 3];
assert_eq!(a, b);
assert_ne!(a, c);
fn cmp<A: Eq>() {}
cmp::<SmallVec1<[u8; 4]>>();
}
#[test]
fn PartialEq() {
let a: SmallVec1<[String; 4]> = smallvec1!["hy".to_owned()];
let b: SmallVec1<[&'static str; 4]> = smallvec1!["hy"];
assert_eq!(a, b);
let a: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3, 4, 5];
let b: SmallVec1<[u8; 8]> = smallvec1![1, 2, 3, 4, 5];
assert_eq!(a, b);
}
#[test]
fn Ord() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
let b: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(Ord::cmp(&a, &b), Ordering::Less);
}
#[test]
fn Hash() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
let b = vec![1u8, 3];
assert_eq!(compute_hash(&a), compute_hash(&b));
fn compute_hash<T: Hash>(value: &T) -> u64 {
let mut hasher = DefaultHasher::new();
value.hash(&mut hasher);
hasher.finish()
}
}
#[test]
fn Debug() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
assert_eq!(format!("{:?}", a), "[1, 2]");
}
#[test]
fn Default() {
let a = SmallVec1::<[u8; 4]>::default();
assert_eq!(a.as_slice(), &[0u8] as &[u8]);
}
#[test]
fn Deref() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
let _: &SmallVec<_> = a.as_smallvec();
let b: &[u8] = &*a;
assert_eq!(b, &[1u8, 2] as &[u8]);
}
#[test]
fn DerefMut() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
let b: &mut [u8] = &mut *a;
assert_eq!(b, &[1u8, 2] as &[u8]);
}
mod IntoIterator {
use super::*;
#[test]
fn owned() {
let a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
let a_ = a.clone();
let b = a.into_iter().collect::<Vec<_>>();
assert_eq!(&a_[..], &b[..]);
}
#[test]
fn by_ref() {
let a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
let a = (&a).into_iter().collect::<Vec<_>>();
assert_eq!(a, vec![&12u8, &23]);
}
#[test]
fn by_mut() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
let a = (&mut a).into_iter().collect::<Vec<_>>();
assert_eq!(a, vec![&mut 12u8, &mut 23]);
}
}
#[test]
fn AsRef() {
let a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
let _: &[u8] = a.as_ref();
let _: &SmallVec<[u8; 4]> = a.as_ref();
}
mod AsMut {
use super::{smallvec1, SmallVec1};
#[test]
fn os_slice() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
let _: &mut [u8] = a.as_mut();
}
#[test]
fn of_self() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![33u8, 123];
let v: &mut SmallVec1<[u8; 4]> = a.as_mut();
let mut expected: SmallVec1<[u8; 4]> = smallvec1![33u8, 123];
assert_eq!(v, &mut expected);
}
}
#[test]
fn Borrow() {
let a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
let _: &[u8] = a.borrow();
let _: &SmallVec<[u8; 4]> = a.borrow();
}
#[test]
fn BorrowMut() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
let _: &mut [u8] = a.borrow_mut();
}
#[test]
fn Extend() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
a.extend(vec![1u8, 2, 3].into_iter());
assert_eq!(a.as_slice(), &[12u8, 23, 1, 2, 3] as &[u8]);
}
#[test]
fn Index() {
let a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
assert_eq!(a[0], 12);
}
#[test]
fn IndexMut() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![12, 23];
a[0] = 33;
assert_eq!(a[0], 33);
}
mod TryFrom {
use super::super::super::*;
use std::{borrow::ToOwned, string::String, vec};
#[test]
fn slice() {
let a =
SmallVec1::<[String; 4]>::try_from(&["hy".to_owned()] as &[String]).unwrap();
assert_eq!(a[0], "hy");
SmallVec1::<[String; 4]>::try_from(&[] as &[String]).unwrap_err();
}
#[test]
fn misc() {
let _ = SmallVec1::<[u8; 4]>::try_from(vec![1, 2, 3]).unwrap();
let _ = SmallVec1::<[u8; 4]>::try_from(vec![]).unwrap_err();
let _ = SmallVec1::<[u8; 4]>::try_from(smallvec![1, 2, 3]).unwrap();
let _ = SmallVec1::<[u8; 4]>::try_from(smallvec![]).unwrap_err();
let _ = SmallVec1::<[u8; 4]>::try_from([1u8, 2, 3, 4]).unwrap();
let _ = SmallVec1::<[u8; 0]>::try_from([] as [u8; 0]).unwrap_err();
}
#[test]
fn array_try_from_smallvec1() {
let vec: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
<[u8; 4]>::try_from(vec).unwrap();
let vec: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2];
<[u8; 4]>::try_from(vec).unwrap_err();
}
}
#[test]
fn new() {
let a = SmallVec1::<[u8; 4]>::new(12);
let b: SmallVec1<[u8; 4]> = smallvec1![12];
assert_eq!(a, b);
}
#[test]
fn with_capacity() {
let a = SmallVec1::<[u8; 4]>::with_capacity(32, 21);
assert_eq!(a.is_empty(), false);
assert_eq!(a.capacity(), 21);
let a = SmallVec1::<[u8; 4]>::with_capacity(32, 1);
assert_eq!(a.is_empty(), false);
assert_eq!(a.capacity(), 4 );
}
#[test]
fn try_from_vec() {
let a = SmallVec1::<[u8; 4]>::try_from_vec(vec![1, 2, 3]);
assert_eq!(a, Ok(smallvec1![1, 2, 3]));
let b = SmallVec1::<[u8; 4]>::try_from_vec(vec![]);
assert_eq!(b, Err(Size0Error));
}
#[test]
fn try_from_smallvec() {
let a = SmallVec1::<[u8; 4]>::try_from_smallvec(smallvec![32, 2, 3]);
assert_eq!(a, Ok(smallvec1![32, 2, 3]));
let a = SmallVec1::<[u8; 4]>::try_from_smallvec(smallvec![]);
assert_eq!(a, Err(Size0Error));
}
#[test]
fn try_from_buf() {
let a = SmallVec1::try_from_buf([1u8, 2, 3, 4]);
assert_eq!(a, Ok(smallvec1![1, 2, 3, 4]));
let a = SmallVec1::try_from_buf([] as [u8; 0]);
assert_eq!(a, Err(Size0Error));
}
#[test]
fn try_from_buf_and_len() {
let a = SmallVec1::try_from_buf_and_len([1u8, 2, 3, 4, 0, 0, 0, 0], 4);
assert_eq!(a, Ok(smallvec1![1, 2, 3, 4]));
let a = SmallVec1::try_from_buf_and_len([1u8, 2, 3], 0);
assert_eq!(a, Err(Size0Error));
}
#[should_panic]
#[test]
fn try_from_buf_and_len_panic_if_len_gt_size() {
let _ = SmallVec1::try_from_buf_and_len([] as [u8; 0], 3);
}
#[test]
fn into_smallvec() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2];
let a = a.into_smallvec();
let b: SmallVec<[u8; 4]> = smallvec![1, 3, 2];
assert_eq!(a, b);
}
#[test]
fn into_vec() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2];
let a: Vec<u8> = a.into_vec();
assert_eq!(a, vec![1, 3, 2])
}
#[test]
fn into_inner() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
let a: [u8; 4] = a.into_inner().unwrap();
assert_eq!(a, [1, 3, 2, 4])
}
#[test]
fn into_boxed_slice() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
let a: Box<[u8]> = a.into_boxed_slice();
assert_eq!(&*a, &[1u8, 3, 2, 4] as &[u8])
}
#[test]
fn leak() {
let a: SmallVec1<[u8; 32]> = smallvec1![1u8, 3];
let s: &'static mut [u8] = a.leak();
assert_eq!(s, &[1u8, 3]);
}
#[test]
fn reduce() {
assert_eq!(smallvec1_inline![1u8, 2, 4, 3].reduce(std::cmp::max), 4);
assert_eq!(smallvec1_inline![1u8, 2, 2, 3].reduce(|a, b| a + b), 8);
}
#[test]
fn reduce_ref() {
let a = smallvec1_inline![std::cell::Cell::new(4)];
a.reduce_ref(std::cmp::max).set(44);
assert_eq!(a, smallvec1_inline![std::cell::Cell::new(44)]);
}
#[test]
fn reduce_mut() {
let mut a = smallvec1_inline![1u8, 2, 4, 3];
*a.reduce_mut(std::cmp::max) *= 2;
assert_eq!(a, smallvec1_inline![1u8, 2, 8, 3]);
}
mod From {
use super::*;
#[test]
fn boxed_slice_from_smallvec1() {
let vec: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4, 5];
let _ = Box::<[u8]>::from(vec);
}
#[test]
fn vec_from_smallvec1() {
let vec: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
let _ = Vec::<u8>::from(vec);
}
#[test]
fn smallvec_from_smallvec1() {
let vec: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
let _ = SmallVec::<[u8; 4]>::from(vec);
}
}
#[test]
fn last_first_methods_are_shadowed() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
assert_eq!(a.last(), &4);
assert_eq!(a.last_mut(), &mut 4);
assert_eq!(a.first(), &1);
assert_eq!(a.first_mut(), &mut 1);
}
#[test]
fn truncate() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
assert_eq!(a.truncate(0), Err(Size0Error));
assert_eq!(a.truncate(1), Ok(()));
assert_eq!(a.len(), 1);
}
#[test]
fn try_truncate() {
#![allow(deprecated)]
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
assert_eq!(a.try_truncate(0), Err(Size0Error));
assert_eq!(a.try_truncate(1), Ok(()));
assert_eq!(a.len(), 1);
}
#[test]
fn reserve() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
a.reserve(4);
assert!(a.capacity() >= 8);
}
#[test]
fn try_reserve() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
a.try_reserve(4).unwrap();
assert!(a.capacity() >= 8);
}
#[test]
fn reserve_exact() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
a.reserve_exact(4);
assert_eq!(a.capacity(), 8);
}
#[test]
fn try_reserve_exact() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4];
a.try_reserve_exact(4).unwrap();
assert_eq!(a.capacity(), 8);
}
#[test]
fn shrink_to_fit() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 2, 4, 5];
a.shrink_to_fit();
assert_eq!(a.capacity(), 5);
}
#[test]
fn push() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
a.push(12);
let b: SmallVec1<[u8; 4]> = smallvec1![1, 3, 12];
assert_eq!(a, b);
}
#[test]
fn insert() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
a.insert(0, 12);
let b: SmallVec1<[u8; 4]> = smallvec1![12, 1, 3];
assert_eq!(a, b);
}
#[test]
fn len() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.len(), 2);
}
#[test]
fn len_nonzero() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.len_nonzero(), NonZeroUsize::new(2).unwrap());
}
#[test]
fn capacity() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.capacity(), 4);
}
#[test]
fn as_slice() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.as_slice(), &[1u8, 3] as &[u8]);
}
#[test]
fn as_mut_slice() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
a.as_mut_slice()[0] = 10;
let b: SmallVec1<[u8; 4]> = smallvec1![10, 3];
assert_eq!(a, b);
}
#[test]
fn inline_size() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.inline_size(), 4);
}
#[test]
fn spilled() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.spilled(), false);
let a: SmallVec1<[u8; 4]> = smallvec1![1, 3, 6, 9, 2];
assert_eq!(a.spilled(), true);
}
#[test]
fn pop() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.pop(), Ok(3));
assert_eq!(a.pop(), Err(Size0Error));
}
#[test]
fn try_pop() {
#![allow(deprecated)]
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.try_pop(), Ok(3));
assert_eq!(a.try_pop(), Err(Size0Error));
}
#[test]
fn append() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
let mut b: SmallVec<[u8; 4]> = smallvec![53, 12];
a.append(&mut b);
let c: SmallVec1<[u8; 4]> = smallvec1![1, 3, 53, 12];
assert_eq!(a, c);
}
#[test]
fn grow() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
a.grow(32);
assert_eq!(a.capacity(), 32);
}
#[test]
fn try_grow() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
a.try_grow(32).unwrap();
assert_eq!(a.capacity(), 32);
}
#[test]
fn swap_remove() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.swap_remove(0), Ok(1));
assert_eq!(a.swap_remove(0), Err(Size0Error));
}
#[test]
fn try_swap_remove() {
#![allow(deprecated)]
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.try_swap_remove(0), Ok(1));
assert_eq!(a.try_swap_remove(0), Err(Size0Error));
}
#[test]
fn remove() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.remove(0), Ok(1));
assert_eq!(a.remove(0), Err(Size0Error));
catch_unwind(|| {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
let _ = a.remove(200);
})
.unwrap_err();
}
#[test]
fn try_remove() {
#![allow(deprecated)]
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
assert_eq!(a.try_remove(0), Ok(1));
assert_eq!(a.try_remove(0), Err(Size0Error));
}
#[test]
fn insert_many() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 3];
a.insert_many(1, vec![2, 4, 8]);
let b: SmallVec1<[u8; 4]> = smallvec1![1, 2, 4, 8, 3];
assert_eq!(a, b);
}
#[test]
fn dedup() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 1];
a.dedup();
assert_eq!(a.as_slice(), &[1u8] as &[u8]);
}
#[test]
fn dedup_by() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 1, 4, 4];
a.dedup_by(|a, b| a == b);
assert_eq!(a.as_slice(), &[1u8, 4] as &[u8]);
}
#[test]
fn dedup_by_key() {
let mut a: SmallVec1<[(u8, u8); 4]> = smallvec1![(1, 2), (1, 5), (4, 4), (5, 4)];
a.dedup_by_key(|a| a.0);
assert_eq!(a.as_slice(), &[(1u8, 2u8), (4, 4), (5, 4)] as &[(u8, u8)]);
}
#[test]
fn resize_with() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
assert_eq!(a.resize_with(0, Default::default), Err(Size0Error));
assert_eq!(a.resize_with(4, Default::default), Ok(()));
}
#[test]
fn try_resize_with() {
#![allow(deprecated)]
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
assert_eq!(a.try_resize_with(0, Default::default), Err(Size0Error));
assert_eq!(a.try_resize_with(4, Default::default), Ok(()));
}
#[test]
fn as_ptr() {
let a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
let pa = a.as_ptr();
let pb = a.as_slice().as_ptr();
assert_eq!(pa as usize, pb as usize);
}
#[test]
fn as_mut_ptr() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
let pa = a.as_mut_ptr();
let pb = a.as_mut_slice().as_mut_ptr();
assert_eq!(pa as usize, pb as usize);
}
#[test]
fn try_from_slice() {
let a = SmallVec1::<[u8; 4]>::try_from_slice(&[1u8, 2, 9]).unwrap();
assert_eq!(a.as_slice(), &[1u8, 2, 9] as &[u8]);
SmallVec1::<[u8; 4]>::try_from_slice(&[]).unwrap_err();
}
#[test]
fn insert_from_slice() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
a.insert_from_slice(1, &[3, 9]);
assert_eq!(a.as_slice(), &[1u8, 3, 9, 2] as &[u8]);
}
#[test]
fn extend_from_slice() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2];
a.extend_from_slice(&[3, 9]);
assert_eq!(a.as_slice(), &[1u8, 2, 3, 9] as &[u8]);
}
#[test]
fn resize() {
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3];
assert_eq!(a.resize(0, 12), Err(Size0Error));
assert_eq!(a.resize(2, 12), Ok(()));
assert_eq!(a.resize(4, 12), Ok(()));
assert_eq!(a.as_slice(), &[1u8, 2, 12, 12] as &[u8]);
}
#[test]
fn try_resize() {
#![allow(deprecated)]
let mut a: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3];
assert_eq!(a.try_resize(0, 12), Err(Size0Error));
assert_eq!(a.try_resize(2, 12), Ok(()));
assert_eq!(a.try_resize(4, 12), Ok(()));
assert_eq!(a.as_slice(), &[1u8, 2, 12, 12] as &[u8]);
}
#[test]
fn try_from_elem() {
let a = SmallVec1::<[u8; 4]>::try_from_elem(1u8, 3).unwrap();
assert_eq!(a.as_slice(), &[1u8, 1, 1] as &[u8]);
SmallVec1::<[u8; 4]>::try_from_elem(1u8, 0).unwrap_err();
}
#[test]
fn split_off_first() {
let a: SmallVec1<[u8; 4]> = smallvec1![32];
assert_eq!((32, SmallVec::<[u8; 4]>::new()), a.split_off_first());
let a: SmallVec1<[u8; 4]> = smallvec1![32, 43];
let exp: SmallVec<[u8; 4]> = smallvec![43];
assert_eq!((32, exp), a.split_off_first());
}
#[test]
fn split_off_last() {
let a: SmallVec1<[u8; 4]> = smallvec1![32];
assert_eq!((SmallVec::<[u8; 4]>::new(), 32), a.split_off_last());
let a: SmallVec1<[u8; 4]> = smallvec1![32, 43];
let exp: SmallVec<[u8; 4]> = smallvec![32];
assert_eq!((exp, 43), a.split_off_last());
}
#[test]
fn from_vec_push() {
let got: SmallVec1<[u8; 4]> = SmallVec1::from_vec_push(std::vec![], 1u8);
let expected: SmallVec1<[u8; 4]> = smallvec1![1];
assert_eq!(got, expected);
let got: SmallVec1<[u8; 4]> = SmallVec1::from_vec_push(std::vec![1, 2], 3u8);
let expected: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3];
assert_eq!(got, expected);
}
#[test]
fn from_vec_insert() {
let got: SmallVec1<[u8; 4]> = SmallVec1::from_vec_insert(std::vec![], 0, 1u8);
let expected: SmallVec1<[u8; 4]> = smallvec1![1];
assert_eq!(got, expected);
let got: SmallVec1<[u8; 4]> = SmallVec1::from_vec_insert(std::vec![1, 3], 1, 2u8);
let expected: SmallVec1<[u8; 4]> = smallvec1![1, 2, 3];
assert_eq!(got, expected);
assert!(catch_unwind(|| {
SmallVec1::<[u8; 4]>::from_vec_insert(std::vec![1, 3], 3, 2u8);
})
.is_err());
}
#[cfg(feature = "serde")]
mod serde {
use super::super::super::*;
#[test]
fn can_be_serialized_and_deserialized() {
let a: SmallVec1<[u8; 4]> = smallvec1![32, 12, 14, 18, 201];
let json_str = serde_json::to_string(&a).unwrap();
let b: SmallVec1<[u8; 4]> = serde_json::from_str(&json_str).unwrap();
assert_eq!(a, b);
}
#[test]
fn array_size_is_not_serialized() {
let a: SmallVec1<[u8; 4]> = smallvec1![32, 12, 14, 18, 201];
let json_str = serde_json::to_string(&a).unwrap();
let b: SmallVec1<[u8; 8]> = serde_json::from_str(&json_str).unwrap();
assert_eq!(a, b);
}
#[test]
fn does_not_allow_empty_deserialization() {
let a = Vec::<u8>::new();
let json_str = serde_json::to_string(&a).unwrap();
serde_json::from_str::<SmallVec1<[u8; 8]>>(&json_str).unwrap_err();
}
}
}
mod macros {
use super::super::{smallvec1, smallvec1_inline, SmallVec1};
#[test]
fn smallvec1() {
let _: SmallVec1<[u8; 2]> = smallvec1![1];
let _: SmallVec1<[u8; 2]> = smallvec1![1,];
let _: SmallVec1<[u8; 2]> = smallvec1![1, 2];
let _: SmallVec1<[u8; 2]> = smallvec1![1, 2,];
}
#[test]
fn smallvec1_inline() {
assert_eq!(smallvec1_inline![1].capacity(), 1);
assert_eq!(smallvec1_inline![1,].capacity(), 1);
assert_eq!(smallvec1_inline![1, 2].capacity(), 2);
assert_eq!(smallvec1_inline![1, 2,].capacity(), 2);
}
}
}