TEST: Fix arrayvec tests for const gen

Just search/replace for syntax [T; N] -> T, N and it works.

Author: bluss

tests/tests.rs

@@ -13,7 +13,7 @@ use std::collections::HashMap;
 fn test_simple() {
     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![10]);
@@ -29,7 +29,7 @@ fn test_simple() {
 
 #[test]
 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);
     vec.push(1);
     assert_eq!(vec.remaining_capacity(), 3);
@@ -43,7 +43,7 @@ fn test_capacity_left() {
 
 #[test]
 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();
     assert_eq!(vec.len(), 3);
@@ -54,13 +54,13 @@ fn test_extend_from_slice() {
 
 #[test]
 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();
     let res = vec.try_extend_from_slice(&[0; 8]);
     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]);
     assert_matches!(res, Err(_));
 }
@@ -70,14 +70,14 @@ fn test_try_from_slice_error() {
     use arrayvec::ArrayVec;
     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(_));
 }
 
 #[test]
 fn test_u16_index() {
     const N: usize = 4096;
-    let mut vec: ArrayVec<[_; N]> = ArrayVec::new();
+    let mut vec: ArrayVec<_,  N> = ArrayVec::new();
     for _ in 0..N {
         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));
     }
@@ -123,7 +123,7 @@ fn test_drop() {
     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), Bump(flag)]);
         array.push(vec![]);
@@ -142,7 +142,7 @@ fn test_drop() {
     // test into_inner
     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));
@@ -156,7 +156,7 @@ fn test_drop() {
     // test cloning into_iter
     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));
@@ -210,7 +210,7 @@ fn test_drop_panics() {
 
     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));
@@ -226,7 +226,7 @@ fn test_drop_panics() {
 
     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));
@@ -251,22 +251,22 @@ fn test_drop_panics() {
 fn test_extend() {
     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!(range.next(), Some(5));
 
     array.extend(range.by_ref());
     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]);
     array.extend(3..5);
     assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
 }
 
 #[test]
 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 Sync;
 }
@@ -275,24 +275,24 @@ fn test_is_send_sync() {
 fn test_compact_size() {
     // Future rust will kill these drop flags!
     // 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>());
     assert!(mem::size_of::<ByteArray>() <= 8);
 
     // 1 enum tag + 1 drop flag
-    type EmptyArray = ArrayVec<[u8; 0]>;
+    type EmptyArray = ArrayVec<u8,  0>;
     println!("{}", mem::size_of::<EmptyArray>());
     assert!(mem::size_of::<EmptyArray>() <= 2);
 
     // 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>());
     assert!(mem::size_of::<QuadArray>() <= 24);
 }
 
 #[test]
 fn test_still_works_with_option_arrayvec() {
-    type RefArray = ArrayVec<[&'static i32; 2]>;
+    type RefArray = ArrayVec<&'static i32,  2>;
     let array = Some(RefArray::new());
     assert!(array.is_some());
     println!("{:?}", array);
@@ -308,7 +308,7 @@ fn test_drain() {
     v.extend(0..);
     v.drain(1..4);
     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!(&v[..], &[0, 7]);
     v.drain(..);
@@ -324,7 +324,7 @@ fn test_drain_range_inclusive() {
     v.extend(0..);
     v.drain(1..=4);
     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!(&v[..], &[0, 7]);
     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);
 }
 
@@ -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.into_iter();
 }
@@ -399,7 +399,7 @@ fn test_insert() {
     let mut v = ArrayVec::from([]);
     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(1, 1);
     //let ret1 = v.try_insert(3, 3);
@@ -428,7 +428,7 @@ fn test_into_inner_1() {
 
 #[test]
 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("b".into());
     v.push("c".into());
@@ -438,7 +438,7 @@ fn test_into_inner_2() {
 
 #[test]
 fn test_into_inner_3_() {
-    let mut v = ArrayVec::<[i32; 4]>::new();
+    let mut v = ArrayVec::<i32,  4>::new();
     v.extend(1..);
     assert_eq!(v.into_inner().unwrap(), [1, 2, 3, 4]);
 }
@@ -447,7 +447,7 @@ fn test_into_inner_3_() {
 #[test]
 fn test_write() {
     use std::io::Write;
-    let mut v = ArrayVec::<[_; 8]>::new();
+    let mut v = ArrayVec::<_,  8>::new();
     write!(&mut v, "\x01\x02\x03").unwrap();
     assert_eq!(&v[..], &[1, 2, 3]);
     let r = v.write(&[9; 16]).unwrap();
@@ -457,16 +457,16 @@ fn test_write() {
 
 #[test]
 fn array_clone_from() {
-    let mut v = ArrayVec::<[_; 4]>::new();
+    let mut v = ArrayVec::<_,  4>::new();
     v.push(vec![1, 2]);
     v.push(vec![3, 4, 5]);
     v.push(vec![6]);
     let reference = v.to_vec();
-    let mut u = ArrayVec::<[_; 4]>::new();
+    let mut u = ArrayVec::<_,  4>::new();
     u.clone_from(&v);
     assert_eq!(&u, &reference[..]);
 
-    let mut t = ArrayVec::<[_; 4]>::new();
+    let mut t = ArrayVec::<_,  4>::new();
     t.push(vec![97]);
     t.push(vec![]);
     t.push(vec![5, 6, 2]);
@@ -565,7 +565,7 @@ fn test_string_push() {
 
 #[test]
 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 result2 = v.try_insert(1, "b");
     assert!(result1.is_ok() && result2.is_ok());
@@ -575,7 +575,7 @@ fn test_insert_at_length() {
 #[should_panic]
 #[test]
 fn test_insert_out_of_bounds() {
-    let mut v = ArrayVec::<[_; 8]>::new();
+    let mut v = ArrayVec::<_,  8>::new();
     let _ = v.try_insert(1, "test");
 }
 
@@ -608,7 +608,7 @@ fn test_drop_in_insert() {
     flag.set(0);
 
     {
-        let mut array = ArrayVec::<[_; 2]>::new();
+        let mut array = ArrayVec::<_,  2>::new();
         array.push(Bump(flag));
         array.insert(0, Bump(flag));
         assert_eq!(flag.get(), 0);
@@ -623,7 +623,7 @@ fn test_drop_in_insert() {
 
 #[test]
 fn test_pop_at() {
-    let mut v = ArrayVec::<[String; 4]>::new();
+    let mut v = ArrayVec::<String,  4>::new();
     let s = String::from;
     v.push(s("a"));
     v.push(s("b"));
@@ -648,7 +648,7 @@ fn test_default() {
     use std::net;
     let s: ArrayString<[u8; 4]> = Default::default();
     // 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!(v.len(), 0);
 }
@@ -673,14 +673,14 @@ fn test_extend_zst() {
     #[derive(Copy, Clone, PartialEq, Debug)]
     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!(range.next(), Some(5));
 
     array.extend(range.by_ref().map(|_| Z));
     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]);
     array.extend((3..5).map(|_| Z));
     assert_eq!(&array[..], &[Z; 5]);