Quaternions/arrayvec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TEST: Fix arrayvec tests for const gen

Browse Source 
Just search/replace for syntax [T; N] -> T, N and it works.
This commit is contained in:
bluss
2021-03-23 17:12:28 +01:00
parent 02ab4dc796
commit 5502324b6f
2 changed files with 50 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/arrayvec.rs
+12 -12
View File
@@ -71,7 +71,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 16]>::new(); /// let mut array = ArrayVec::<_, 16>::new();
/// array.push(1); /// array.push(1);
/// array.push(2); /// array.push(2);
/// assert_eq!(&array[..], &[1, 2]); /// assert_eq!(&array[..], &[1, 2]);
@@ -131,7 +131,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 1]>::new(); /// let mut array = ArrayVec::<_, 1>::new();
/// assert!(!array.is_full()); /// assert!(!array.is_full());
/// array.push(1); /// array.push(1);
/// assert!(array.is_full()); /// assert!(array.is_full());
@@ -158,7 +158,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 2]>::new(); /// let mut array = ArrayVec::<_, 2>::new();
/// ///
/// array.push(1); /// array.push(1);
/// array.push(2); /// array.push(2);
@@ -177,7 +177,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 2]>::new(); /// let mut array = ArrayVec::<_, 2>::new();
/// ///
/// let push1 = array.try_push(1); /// let push1 = array.try_push(1);
/// let push2 = array.try_push(2); /// let push2 = array.try_push(2);
@@ -205,7 +205,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 2]>::new(); /// let mut array = ArrayVec::<_, 2>::new();
/// ///
/// if array.len() + 2 <= array.capacity() { /// if array.len() + 2 <= array.capacity() {
/// unsafe { /// unsafe {
@@ -263,7 +263,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 2]>::new(); /// let mut array = ArrayVec::<_, 2>::new();
/// ///
/// array.insert(0, "x"); /// array.insert(0, "x");
/// array.insert(0, "y"); /// array.insert(0, "y");
@@ -286,7 +286,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 2]>::new(); /// let mut array = ArrayVec::<_, 2>::new();
/// ///
/// assert!(array.try_insert(0, "x").is_ok()); /// assert!(array.try_insert(0, "x").is_ok());
/// assert!(array.try_insert(0, "y").is_ok()); /// assert!(array.try_insert(0, "y").is_ok());
@@ -327,7 +327,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut array = ArrayVec::<[_; 2]>::new(); /// let mut array = ArrayVec::<_, 2>::new();
/// ///
/// array.push(1); /// array.push(1);
/// ///
@@ -487,7 +487,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// ``` /// ```
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); /// let mut vec: ArrayVec<usize, 10> = ArrayVec::new();
/// vec.push(1); /// vec.push(1);
/// vec.try_extend_from_slice(&[2, 3]).unwrap(); /// vec.try_extend_from_slice(&[2, 3]).unwrap();
/// assert_eq!(&vec[..], &[1, 2, 3]); /// assert_eq!(&vec[..], &[1, 2, 3]);
@@ -532,7 +532,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// ///
/// let mut v = ArrayVec::from([1, 2, 3]); /// let mut v = ArrayVec::from([1, 2, 3]);
/// let u: ArrayVec<[_; 3]> = v.drain(0..2).collect(); /// let u: ArrayVec<_, 3> = v.drain(0..2).collect();
/// assert_eq!(&v[..], &[3]); /// assert_eq!(&v[..], &[3]);
/// assert_eq!(&u[..], &[1, 2]); /// assert_eq!(&u[..], &[1, 2]);
/// ``` /// ```
@@ -678,9 +678,9 @@ impl<T, const CAP: usize> From<[T; CAP]> for ArrayVec<T, CAP> {
let array = ManuallyDrop::new(array); let array = ManuallyDrop::new(array);
let mut vec = <ArrayVec<T, CAP>>::new(); let mut vec = <ArrayVec<T, CAP>>::new();
unsafe { unsafe {
(&*array as *const [T; CAP] as *const [MaybeUninit<T>; CAP]) (&*array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
.copy_to_nonoverlapping(&mut vec.xs as *mut [MaybeUninit<T>; CAP], 1); .copy_to_nonoverlapping(&mut vec.xs as *mut [MaybeUninit<T>; CAP], 1);
vec.set_len(CAP);
} }
vec vec
} }
@@ -694,7 +694,7 @@ impl<T, const CAP: usize> From<[T; CAP]> for ArrayVec<T, CAP> {
/// use arrayvec::ArrayVec; /// use arrayvec::ArrayVec;
/// use std::convert::TryInto as _; /// use std::convert::TryInto as _;
/// ///
/// let array: ArrayVec<[_; 4]> = (&[1, 2, 3] as &[_]).try_into().unwrap(); /// let array: ArrayVec<_, 4> = (&[1, 2, 3] as &[_]).try_into().unwrap();
/// assert_eq!(array.len(), 3); /// assert_eq!(array.len(), 3);
/// assert_eq!(array.capacity(), 4); /// assert_eq!(array.capacity(), 4);
/// ``` /// ```
tests/tests.rs
+38 -38
View File
@@ -13,7 +13,7 @@ use std::collections::HashMap;
fn test_simple() { fn test_simple() {
use std::ops::Add; use std::ops::Add;
let mut vec: ArrayVec<[Vec<i32>; 3]> = ArrayVec::new(); let mut vec: ArrayVec<Vec<i32>, 3> = ArrayVec::new();
vec.push(vec![1, 2, 3, 4]); vec.push(vec![1, 2, 3, 4]);
vec.push(vec![10]); vec.push(vec![10]);
@@ -29,7 +29,7 @@ fn test_simple() {
#[test] #[test]
fn test_capacity_left() { fn test_capacity_left() {
let mut vec: ArrayVec<[usize; 4]> = ArrayVec::new(); let mut vec: ArrayVec<usize, 4> = ArrayVec::new();
assert_eq!(vec.remaining_capacity(), 4); assert_eq!(vec.remaining_capacity(), 4);
vec.push(1); vec.push(1);
assert_eq!(vec.remaining_capacity(), 3); assert_eq!(vec.remaining_capacity(), 3);
@@ -43,7 +43,7 @@ fn test_capacity_left() {
#[test] #[test]
fn test_extend_from_slice() { fn test_extend_from_slice() {
let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); let mut vec: ArrayVec<usize, 10> = ArrayVec::new();
vec.try_extend_from_slice(&[1, 2, 3]).unwrap(); vec.try_extend_from_slice(&[1, 2, 3]).unwrap();
assert_eq!(vec.len(), 3); assert_eq!(vec.len(), 3);
@@ -54,13 +54,13 @@ fn test_extend_from_slice() {
#[test] #[test]
fn test_extend_from_slice_error() { fn test_extend_from_slice_error() {
let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); let mut vec: ArrayVec<usize, 10> = ArrayVec::new();
vec.try_extend_from_slice(&[1, 2, 3]).unwrap(); vec.try_extend_from_slice(&[1, 2, 3]).unwrap();
let res = vec.try_extend_from_slice(&[0; 8]); let res = vec.try_extend_from_slice(&[0; 8]);
assert_matches!(res, Err(_)); assert_matches!(res, Err(_));
let mut vec: ArrayVec<[usize; 0]> = ArrayVec::new(); let mut vec: ArrayVec<usize, 0> = ArrayVec::new();
let res = vec.try_extend_from_slice(&[0; 1]); let res = vec.try_extend_from_slice(&[0; 1]);
assert_matches!(res, Err(_)); assert_matches!(res, Err(_));
} }
@@ -70,14 +70,14 @@ fn test_try_from_slice_error() {
use arrayvec::ArrayVec; use arrayvec::ArrayVec;
use std::convert::TryInto as _; use std::convert::TryInto as _;
let res: Result<ArrayVec<[_; 2]>, _> = (&[1, 2, 3] as &[_]).try_into(); let res: Result<ArrayVec<_, 2>, _> = (&[1, 2, 3] as &[_]).try_into();
assert_matches!(res, Err(_)); assert_matches!(res, Err(_));
} }
#[test] #[test]
fn test_u16_index() { fn test_u16_index() {
const N: usize = 4096; const N: usize = 4096;
let mut vec: ArrayVec<[_; N]> = ArrayVec::new(); let mut vec: ArrayVec<_, N> = ArrayVec::new();
for _ in 0..N { for _ in 0..N {
assert!(vec.try_push(1u8).is_ok()); assert!(vec.try_push(1u8).is_ok());
} }
@@ -113,7 +113,7 @@ fn test_drop() {
} }
{ {
let mut array = ArrayVec::<[Bump; 128]>::new(); let mut array = ArrayVec::<Bump, 128>::new();
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
} }
@@ -123,7 +123,7 @@ fn test_drop() {
flag.set(0); flag.set(0);
{ {
let mut array = ArrayVec::<[_; 3]>::new(); let mut array = ArrayVec::<_, 3>::new();
array.push(vec![Bump(flag)]); array.push(vec![Bump(flag)]);
array.push(vec![Bump(flag), Bump(flag)]); array.push(vec![Bump(flag), Bump(flag)]);
array.push(vec![]); array.push(vec![]);
@@ -142,7 +142,7 @@ fn test_drop() {
// test into_inner // test into_inner
flag.set(0); flag.set(0);
{ {
let mut array = ArrayVec::<[_; 3]>::new(); let mut array = ArrayVec::<_, 3>::new();
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
@@ -156,7 +156,7 @@ fn test_drop() {
// test cloning into_iter // test cloning into_iter
flag.set(0); flag.set(0);
{ {
let mut array = ArrayVec::<[_; 3]>::new(); let mut array = ArrayVec::<_, 3>::new();
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
@@ -210,7 +210,7 @@ fn test_drop_panics() {
flag.set(0); flag.set(0);
{ {
let mut array = ArrayVec::<[Bump; 128]>::new(); let mut array = ArrayVec::<Bump, 128>::new();
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
@@ -226,7 +226,7 @@ fn test_drop_panics() {
flag.set(0); flag.set(0);
{ {
let mut array = ArrayVec::<[Bump; 16]>::new(); let mut array = ArrayVec::<Bump, 16>::new();
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
array.push(Bump(flag)); array.push(Bump(flag));
@@ -251,14 +251,14 @@ fn test_drop_panics() {
fn test_extend() { fn test_extend() {
let mut range = 0..10; let mut range = 0..10;
let mut array: ArrayVec<[_; 5]> = range.by_ref().collect(); let mut array: ArrayVec<_, 5> = range.by_ref().collect();
assert_eq!(&array[..], &[0, 1, 2, 3, 4]); assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
assert_eq!(range.next(), Some(5)); assert_eq!(range.next(), Some(5));
array.extend(range.by_ref()); array.extend(range.by_ref());
assert_eq!(range.next(), Some(6)); assert_eq!(range.next(), Some(6));
let mut array: ArrayVec<[_; 10]> = (0..3).collect(); let mut array: ArrayVec<_, 10> = (0..3).collect();
assert_eq!(&array[..], &[0, 1, 2]); assert_eq!(&array[..], &[0, 1, 2]);
array.extend(3..5); array.extend(3..5);
assert_eq!(&array[..], &[0, 1, 2, 3, 4]); assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
@@ -266,7 +266,7 @@ fn test_extend() {
#[test] #[test]
fn test_is_send_sync() { fn test_is_send_sync() {
let data = ArrayVec::<[Vec<i32>; 5]>::new(); let data = ArrayVec::<Vec<i32>, 5>::new();
&data as &dyn Send; &data as &dyn Send;
&data as &dyn Sync; &data as &dyn Sync;
} }
@@ -275,24 +275,24 @@ fn test_is_send_sync() {
fn test_compact_size() { fn test_compact_size() {
// Future rust will kill these drop flags! // Future rust will kill these drop flags!
// 4 elements size + 1 len + 1 enum tag + [1 drop flag] // 4 elements size + 1 len + 1 enum tag + [1 drop flag]
type ByteArray = ArrayVec<[u8; 4]>; type ByteArray = ArrayVec<u8, 4>;
println!("{}", mem::size_of::<ByteArray>()); println!("{}", mem::size_of::<ByteArray>());
assert!(mem::size_of::<ByteArray>() <= 8); assert!(mem::size_of::<ByteArray>() <= 8);
// 1 enum tag + 1 drop flag // 1 enum tag + 1 drop flag
type EmptyArray = ArrayVec<[u8; 0]>; type EmptyArray = ArrayVec<u8, 0>;
println!("{}", mem::size_of::<EmptyArray>()); println!("{}", mem::size_of::<EmptyArray>());
assert!(mem::size_of::<EmptyArray>() <= 2); assert!(mem::size_of::<EmptyArray>() <= 2);
// 12 element size + 1 enum tag + 3 padding + 1 len + 1 drop flag + 2 padding // 12 element size + 1 enum tag + 3 padding + 1 len + 1 drop flag + 2 padding
type QuadArray = ArrayVec<[u32; 3]>; type QuadArray = ArrayVec<u32, 3>;
println!("{}", mem::size_of::<QuadArray>()); println!("{}", mem::size_of::<QuadArray>());
assert!(mem::size_of::<QuadArray>() <= 24); assert!(mem::size_of::<QuadArray>() <= 24);
} }
#[test] #[test]
fn test_still_works_with_option_arrayvec() { fn test_still_works_with_option_arrayvec() {
type RefArray = ArrayVec<[&'static i32; 2]>; type RefArray = ArrayVec<&'static i32, 2>;
let array = Some(RefArray::new()); let array = Some(RefArray::new());
assert!(array.is_some()); assert!(array.is_some());
println!("{:?}", array); println!("{:?}", array);
@@ -308,7 +308,7 @@ fn test_drain() {
v.extend(0..); v.extend(0..);
v.drain(1..4); v.drain(1..4);
assert_eq!(&v[..], &[0, 4, 5, 6, 7]); assert_eq!(&v[..], &[0, 4, 5, 6, 7]);
let u: ArrayVec<[_; 3]> = v.drain(1..4).rev().collect(); let u: ArrayVec<_, 3> = v.drain(1..4).rev().collect();
assert_eq!(&u[..], &[6, 5, 4]); assert_eq!(&u[..], &[6, 5, 4]);
assert_eq!(&v[..], &[0, 7]); assert_eq!(&v[..], &[0, 7]);
v.drain(..); v.drain(..);
@@ -324,7 +324,7 @@ fn test_drain_range_inclusive() {
v.extend(0..); v.extend(0..);
v.drain(1..=4); v.drain(1..=4);
assert_eq!(&v[..], &[0, 5, 6, 7]); assert_eq!(&v[..], &[0, 5, 6, 7]);
let u: ArrayVec<[_; 3]> = v.drain(1..=2).rev().collect(); let u: ArrayVec<_, 3> = v.drain(1..=2).rev().collect();
assert_eq!(&u[..], &[6, 5]); assert_eq!(&u[..], &[6, 5]);
assert_eq!(&v[..], &[0, 7]); assert_eq!(&v[..], &[0, 7]);
v.drain(..); v.drain(..);
@@ -374,7 +374,7 @@ fn test_drop_panic() {
} }
} }
let mut array = ArrayVec::<[DropPanic; 1]>::new(); let mut array = ArrayVec::<DropPanic, 1>::new();
array.push(DropPanic); array.push(DropPanic);
} }
@@ -389,7 +389,7 @@ fn test_drop_panic_into_iter() {
} }
} }
let mut array = ArrayVec::<[DropPanic; 1]>::new(); let mut array = ArrayVec::<DropPanic, 1>::new();
array.push(DropPanic); array.push(DropPanic);
array.into_iter(); array.into_iter();
} }
@@ -399,7 +399,7 @@ fn test_insert() {
let mut v = ArrayVec::from([]); let mut v = ArrayVec::from([]);
assert_matches!(v.try_push(1), Err(_)); assert_matches!(v.try_push(1), Err(_));
let mut v = ArrayVec::<[_; 3]>::new(); let mut v = ArrayVec::<_, 3>::new();
v.insert(0, 0); v.insert(0, 0);
v.insert(1, 1); v.insert(1, 1);
//let ret1 = v.try_insert(3, 3); //let ret1 = v.try_insert(3, 3);
@@ -428,7 +428,7 @@ fn test_into_inner_1() {
#[test] #[test]
fn test_into_inner_2() { fn test_into_inner_2() {
let mut v = ArrayVec::<[String; 4]>::new(); let mut v = ArrayVec::<String, 4>::new();
v.push("a".into()); v.push("a".into());
v.push("b".into()); v.push("b".into());
v.push("c".into()); v.push("c".into());
@@ -438,7 +438,7 @@ fn test_into_inner_2() {
#[test] #[test]
fn test_into_inner_3_() { fn test_into_inner_3_() {
let mut v = ArrayVec::<[i32; 4]>::new(); let mut v = ArrayVec::<i32, 4>::new();
v.extend(1..); v.extend(1..);
assert_eq!(v.into_inner().unwrap(), [1, 2, 3, 4]); assert_eq!(v.into_inner().unwrap(), [1, 2, 3, 4]);
} }
@@ -447,7 +447,7 @@ fn test_into_inner_3_() {
#[test] #[test]
fn test_write() { fn test_write() {
use std::io::Write; use std::io::Write;
let mut v = ArrayVec::<[_; 8]>::new(); let mut v = ArrayVec::<_, 8>::new();
write!(&mut v, "\x01\x02\x03").unwrap(); write!(&mut v, "\x01\x02\x03").unwrap();
assert_eq!(&v[..], &[1, 2, 3]); assert_eq!(&v[..], &[1, 2, 3]);
let r = v.write(&[9; 16]).unwrap(); let r = v.write(&[9; 16]).unwrap();
@@ -457,16 +457,16 @@ fn test_write() {
#[test] #[test]
fn array_clone_from() { fn array_clone_from() {
let mut v = ArrayVec::<[_; 4]>::new(); let mut v = ArrayVec::<_, 4>::new();
v.push(vec![1, 2]); v.push(vec![1, 2]);
v.push(vec![3, 4, 5]); v.push(vec![3, 4, 5]);
v.push(vec![6]); v.push(vec![6]);
let reference = v.to_vec(); let reference = v.to_vec();
let mut u = ArrayVec::<[_; 4]>::new(); let mut u = ArrayVec::<_, 4>::new();
u.clone_from(&v); u.clone_from(&v);
assert_eq!(&u, &reference[..]); assert_eq!(&u, &reference[..]);
let mut t = ArrayVec::<[_; 4]>::new(); let mut t = ArrayVec::<_, 4>::new();
t.push(vec![97]); t.push(vec![97]);
t.push(vec![]); t.push(vec![]);
t.push(vec![5, 6, 2]); t.push(vec![5, 6, 2]);
@@ -565,7 +565,7 @@ fn test_string_push() {
#[test] #[test]
fn test_insert_at_length() { fn test_insert_at_length() {
let mut v = ArrayVec::<[_; 8]>::new(); let mut v = ArrayVec::<_, 8>::new();
let result1 = v.try_insert(0, "a"); let result1 = v.try_insert(0, "a");
let result2 = v.try_insert(1, "b"); let result2 = v.try_insert(1, "b");
assert!(result1.is_ok() && result2.is_ok()); assert!(result1.is_ok() && result2.is_ok());
@@ -575,7 +575,7 @@ fn test_insert_at_length() {
#[should_panic] #[should_panic]
#[test] #[test]
fn test_insert_out_of_bounds() { fn test_insert_out_of_bounds() {
let mut v = ArrayVec::<[_; 8]>::new(); let mut v = ArrayVec::<_, 8>::new();
let _ = v.try_insert(1, "test"); let _ = v.try_insert(1, "test");
} }
@@ -608,7 +608,7 @@ fn test_drop_in_insert() {
flag.set(0); flag.set(0);
{ {
let mut array = ArrayVec::<[_; 2]>::new(); let mut array = ArrayVec::<_, 2>::new();
array.push(Bump(flag)); array.push(Bump(flag));
array.insert(0, Bump(flag)); array.insert(0, Bump(flag));
assert_eq!(flag.get(), 0); assert_eq!(flag.get(), 0);
@@ -623,7 +623,7 @@ fn test_drop_in_insert() {
#[test] #[test]
fn test_pop_at() { fn test_pop_at() {
let mut v = ArrayVec::<[String; 4]>::new(); let mut v = ArrayVec::<String, 4>::new();
let s = String::from; let s = String::from;
v.push(s("a")); v.push(s("a"));
v.push(s("b")); v.push(s("b"));
@@ -648,7 +648,7 @@ fn test_default() {
use std::net; use std::net;
let s: ArrayString<[u8; 4]> = Default::default(); let s: ArrayString<[u8; 4]> = Default::default();
// Something without `Default` implementation. // Something without `Default` implementation.
let v: ArrayVec<[net::TcpStream; 4]> = Default::default(); let v: ArrayVec<net::TcpStream, 4> = Default::default();
assert_eq!(s.len(), 0); assert_eq!(s.len(), 0);
assert_eq!(v.len(), 0); assert_eq!(v.len(), 0);
} }
@@ -673,14 +673,14 @@ fn test_extend_zst() {
#[derive(Copy, Clone, PartialEq, Debug)] #[derive(Copy, Clone, PartialEq, Debug)]
struct Z; // Zero sized type struct Z; // Zero sized type
let mut array: ArrayVec<[_; 5]> = range.by_ref().map(|_| Z).collect(); let mut array: ArrayVec<_, 5> = range.by_ref().map(|_| Z).collect();
assert_eq!(&array[..], &[Z; 5]); assert_eq!(&array[..], &[Z; 5]);
assert_eq!(range.next(), Some(5)); assert_eq!(range.next(), Some(5));
array.extend(range.by_ref().map(|_| Z)); array.extend(range.by_ref().map(|_| Z));
assert_eq!(range.next(), Some(6)); assert_eq!(range.next(), Some(6));
let mut array: ArrayVec<[_; 10]> = (0..3).map(|_| Z).collect(); let mut array: ArrayVec<_, 10> = (0..3).map(|_| Z).collect();
assert_eq!(&array[..], &[Z; 3]); assert_eq!(&array[..], &[Z; 3]);
array.extend((3..5).map(|_| Z)); array.extend((3..5).map(|_| Z));
assert_eq!(&array[..], &[Z; 5]); assert_eq!(&array[..], &[Z; 5]);