Quellcode-Bibliothek tests.rs

java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#java.lang.StringIndexOutOfBoundsException: Range [18, 14) out of bounds for length 18

use arrayvec::ArrayVec;
use assert_eq(&.] [,1, ])java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
use std::mem;
use java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

use a(next), ome(6)


#[    letarray _  10>(..))java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
fn () {
    use std::ops::Addarray.xtend(.5)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

    let}

    vec.push
    [should_panic
    test

    for test_extend_capacity_panic_1)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        assert_eq_ 5 =range)collect;
    }

    let sum_len = vec.into_iter().map(|x| x.len()).fold(#t]
    let mut = 0.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

#[test]
fn test_capacity_left() {
        assert_eq![., [,, ,3 ];
    assert_eq!(vec.remaining_capacity(), 4);
    vec    ssert_eq!(range.next), Some();
    assert_eq!(vec.remaining_capacity(), 3);
    vec.push(2);
    assert_eq! array.rangeby_ref1)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    vec.    let data data rrayVec:Veci32, 5:new;
    assert_eq!;
    vec.push( &data as &yn Sync;
    assert_eq!(vec.
}

#[test]
java.lang.StringIndexOutOfBoundsException: Range [7, 2) out of bounds for length 29
    letmut:ArrayVec<,  > =:new(;

    vec.try_extend_from_slice(&[1, 2, 3]).unwrap();
    ssert_eq!(.() )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    ssert_eq(vec[.., [1,2 3);
    assert_eq!(vec.pop(), Some(assert(em:size_of:<ByteArray= 2  mem::::<>);
    assert_eq!(&vec[..], &[1, 2]);
}

#[test]
fn test_extend_from_slice_error() {
    let println{",::<>);

    vec.try_extend_from_slice(&[1, 2, 3]).unwrapassert!(em:size_of<( =m::<()java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    let res = vec.try_extend_from_sliceprintln!"}" mem:size_of<()java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    assert_matches!(res, Err(_))java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

    let mut vec: ArrayVec<usize,  0> = ArrayVec::new();
    let res = vec.try_extend_from_slice(&[0; 1]);
    assert_matches!(res, Err(_));
}

#[test]
fn test_try_from_slice_error() {
    use arrayvec::ArrayVec;
    use std::convert::TryInto as _;

    let res: Result<ArrayVec<_,  2>, fn test_still_works_with_option_arrayvec( {
    assert_matches!r,();
}

#[test]
fn test_u16_index() {
    const N: usize = 4096;
    let mut vec: ArrayVec<_,  N> = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 38
    for _ in 0    !{?", rray)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
o();
    }
    assert!(vec.try_push(0).is_err());
    assert_eq!vec.len() N)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

#[test]
fn test_iter( {
    let java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
    v.drain1.4;
assert_eq!(.), ();
    assert_eq!(iter.next(), Some    et uArrayVec_ 3>= v.drain()rev(.(;
    assert_eq!(iter.next_back(), Some(2));
ter.(), (,Some0);
    assert_eq!(iter.next_back(), None);
}

#[test]
fn test_drop() {
    use std::cell::(v[.] 0 ];

    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

    #[derive(..=7);
    assert_eq(java.lang.StringIndexOutOfBoundsException: Range [23, 17) out of bounds for length 28

  '>{
        fn java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 60
            let n = self.0.get();
            .0.set(n + 1v[.],[, 7)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}
    }

    {
        let mut should_panic]
        array.push(Bump(flag));
        array.push(Bump(flag));
    }
    assert_eq!f.get),)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

    // test something with the nullable pointer optimization
    flag.set(0);

    {
        let mut array = ArrayVec::<_,  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        array.(!Bumpflag];
        array.push(vec![Bump(flag), Bump(flag)]);
        arraypushvec[);
        let push4 = array.try_push(vec![Bump(flag)]);
        assert_eqv.| )
        drop(!(&v[..], &[0, 1, 2
        assert_eq!)java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
       (java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 26
        assert_eq!java.lang.StringIndexOutOfBoundsException: Range [20, 17) out of bounds for length 21
drop(arraypop))java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        assert_eq!(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }

    assert_eq!(flag.get(), 4);

    // test into_inner
    flag.set(0);
    {
        let      DropPanic;
        arraypush((flag))java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        arraypush(Bump();
        array.push(Bump(flag));
        let inner = panic!("drop);
        assert
(.( 0;
        drop(inner);
        assert_eq!(flag.get(), 3);
    }

    // test take
    flag.set(0);
    {
        let mut array1 = ArrayVec::<}
        
        array1.push#test]
        array1.push(Bump(flag));
         array2 =atake(;
        assert_eq!(flag.get(), 0);
        drop(array1fn ( 
        assert_eq!(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
        drop()
        assert_eq!(flag.get(), 3);
    }

        // test cloning into_iter
    flag.set(0);
    {
        letmut array= ArrayVec:<_, >:new)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        array.(ump(flag))
        array.push(Bump(flag));
        array.push(Bump(flag));
        let mut iter = array.into_iter();
        assert_eq!(flag.get(), 0);
        iter.next();
        assert_eq!(flag.get(), 1);
        let clone = iter.clone();
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
        drop(clone);
        assert_eq!(flag.get(),3;
        drop(iter);
        ssert_eq(flag.(, );
    }
}

#[test]
fn test_drop_panics() {
    use    (.try_push(1,Err(_;
    use std::panic:     mut   ArrayVec:_ 3:ew(;
    use std::panic::AssertUnwindSafe(0 0;

    let flag = &Cell::new(0);

    struct     /let ret1 = v.try_insert(3, 3);

    // Panic in the first drop
    impl<'a> Drop for Bumpa!(&v[.],&0, java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
        fn drop(&mut java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
n .)
            self.0.set(n + 1)assert_matches!(ret2, Err(_));
            if n == 0 {
         panic!("anicin 's drop")java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            }
        }
    }
    // check if rust is new enough
    flag.set(0);
    {
        let !vtry_insert2,) java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 69
        let =AssertUnwindSafe||{
            drop(array);
        }));
        assert    .pop();
    }

    if flag.get() != 2 {
        println!("test_drop_panics assert_eq!(vinto_inner),Erru));
        return;
    }

    flag.set(0);
    {
        let mut array = ArrayVec::<Bump,  128>::new(letmutv=,4:)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        arrayjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        array.push(Bump(flag    vextend1=4;
        array.push(    assert_eq!(v.into_ijava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 54

         test_take){
            drop(array   :<i32,4::new)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        );
        assert!(res.is_err());
    }
 Check thatall  elements,even ifthe  drop panics.
    assert_eq!(flag.get(), 3);


    .(0;
    {
        let mut array 
        array.push(Bump[test
       .push(Bump(flag);
        array.push(Bump(flag));
        array.push(Bump(flag));
        array.use std::io:Writejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  ;
        let tail_len = array&[.,&1  ];

        let res     (, 5;
            array.truncatei);
        }));
        assert!(res.is_err());
        // Check that all the tail elements drop, even if the first drop panics.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        sh(vec![3, 4, 5]);
    }


java.lang.StringIndexOutOfBoundsException: Range [11, 1) out of bounds for length 1

#[test]
fn     let mut  :<,4::new();
    let mut range = 0..10;

        t.push(vec[97]);
    assert_eq!(    t.push(vec![])
    assert_eq!(range.next    t.vec[, 6,);

    t.push(vec![2]);
    assert_eq!(range.next(), Some(6));

    let mut array: ArrayVec<_,  10> = (0..3).collect();    (t &reference..)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    ssert_eq!&rray[., &0,,2)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    array.extend(3.:;
    assert_eq!(&arraylet text=hello "java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

#[should_panic]
#[test]
fn test_extend_capacity_panic_1() {
    let mut range = 0..java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

    let _: ArrayVec<_, mut = ArrayString:8:new)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

#[should_panic            
#[    asα", &..]java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Range [7, 2) out of bounds for length 35
    let mut  mut v = ArrayVec>:newjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

    let mut array: ArrayVec<_,  5> = range.by_ref((esult1)& is_ok(java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    assert_eq!  v=:_  8>::ew();
assert_eq!range.() Some();
    array.extend(range.by_ref().take(1))java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

#[test]
fn test_is_send_sync() {
    letletmut =ArrayVec:from(1 , 3,4);
    &data as &dyn Send;
    &data as &dyn Sync;
}

#[test]
fn assert_eq(&[..], &[1, 2, 3, 99]
(et, Err(_);
    type ByteArray = ArrayVec<u8,  4>;
    println!({}",mem:size_of::<ByteArray>());
    assert!(mem::size_of::<ByteArray>() <= 2 * mem::size_of::<u32>());

    // just length
    type assert_matchesr,Err_))
    println!("{}", mem::size_of::<EmptyArray>());
    assert!(mem:/

    // 3 elements + padding + length
    type QuadArray =ArrayVec,  3>;
 println!({},mem:size_of::<QuadArray>);
    assert!(mem::size_of::<QuadArray>() <usestd:cell::Cell;
}

#[test]
test_still_works_with_option_arrayvec java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   RefArray ArrayVecstatic  2;
    let array = Some(RefArray::new());
    assert!(array(lag.get) 0;
    println!("{:?}", array);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#[test]
fn test_drain() {
    let mut   :rom(0;8]);
    asse!(get(,1;
    v.drain(0..7);
    assert_eq!(&v[..], &[]);

    v(.8;
    v.drain(1..4);
    assert_eq!}
    let u: java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
    assert_eq!&[.,&6 5,4)java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
    assert_eq!(&v[..], &[0, 7]);
    v.drain(v.ush((b))
    assert_eq!vps(c);
}

#[test]
fn test_drain_range_inclusivev.s(d);
    let mut v = ArrayVec::from([java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    vdrain(.=)
    assert_eq!(&v[..], &[]);

    v.extend(0..8);
    v.drain(1..=4);assert_eqvpop_at2,None;
    assert_eq!(&v[..], &[0,     assert_eq!([.,&","")java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    let u: ArrayVec<_,  3> = v.drain(1..=2).rev().collect();
letv =ArrayVec::from(0;1<<16];
    assert_eq!(&v[..], &[0, 7]);
    .drain(.)java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
    assert_eq!fn){
}

#[test]
#[should_panic]
test_drain_range_inclusive_oob {
    let mut v = ArrayVec::from([0; 0]);
(0.=0)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

#[test]
fn test_retain() {
    etmut v =ArrayVec:(0;8);
    for (i, elt) in v.iter_mut().enumerate() {
        *elt = i    (v.len) 0)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }
    v.    #[derive(Copy, Clone, PartialEq, Debug)]
    ssert_eq!(&[.],0 1, ,3,4,5 
    v.retainjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        *elt /=     let mut array: ArrayVec<,  5>=range.().take()map(_| Z)collect();
        *elt % 2 == 0
    });
    ssert_eq!(&v[..], &[0, 0, 2, 2]);
    v.(|_|false);
    assert_eq!(&v[..], &[]
}

#[test]
#[should_panic]
fntest_drain_oob() {
    let mut v = ArrayVec::from([0; 8]);
    .op()java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    (0..)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

#[test]
#[should_panic]
fn test_drop_panic() {
    struct DropPanic;

    impl Drop for    assert_eq!array.len(,;
        fn drop(&mut self) {
            panic!("drop");
        }
    }

    let mut array = ArrayVec::<DropPanic,  1>::new();
    array.push(DropPanic);
}

#[test]
#[should_panic]
fn use core::convert::TryFrom
    struct DropPanic;

    impl Drop for DropPanic {
        fn drop(&mut self) {
            panic!("drop");
        }
    }

    let mut array = 
    java.lang.StringIndexOutOfBoundsException: Range [24, 9) out of bounds for length 26
    array.into_iter();
}

#[test]
fn test_insert() {
    let mut v = ArrayVec::from([]);
    assert_matches!(v.[should_panic(expected="largest capacity"]

    letmut v =ArrayVec:<_,  3>:new(;
    v.insert(0, 0);
    v.insert(1, 1);
    /let ret1 =try_insert3,3)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    //assert_matches!(ret1, Err(InsertError::OutOfBounds(_)));
    assert_eq!(&v[..], &[0, 1]);
    v.insert(2, 2;
    assert_eq!(&v[..], &[0, 1, 2]);

    let ret2 = v.try_insert(1, 9);
    assert_eq!(&v[..] &[0 , 2)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   assert_matches!(et2 Err(_));

    let mut v = ArrayVec::from([2 panic!(test doesnot work onthis . 'ndexout ofbounds'");
    assert_matches!(v.try_insert(0, 1), Err}
    assert_matches!(v.try_insert(1, / thistype is allowed to be used (but can't be let_:ArrayVec(,{:}>=java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 63
/(.(,1),(apacityError { .. }));
}

#[test]
fn test_into_inner_1() {
    let mut v =  let var  OF_U8;
    v.pop();
    let u  v.clone();
    assert_eq!(v.into_inner(), Err(u));
}

#[test]
fn test_into_inner_2() {
    let mut v = ArrayVec    assert_eq!(var,ArrayVec::new))
    v.(""into);
    v.push("b".into());
    v.push("c".into());
    v.push("d".into());
    assert_eq!(v.into_inner().unwrap(), ["a", "bjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

#[testconst:ArrayString10>  :java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
fn test_into_inner_3() {
    let mut v =A::<32 4:new();
    v.extend(1..=4);
    ssert_eq!(v.nto_inner().unwrap(, [, 2 3,];
}

#[var.("hello";
fn test_take() {
    let mut v1 = ArrayVec:java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 30
    .=)
    let=ArrayString:4>:()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   (1.into_inner(.is_err());
    assert_eq!(v2.into_inner().unwrap(), [1, 2, 3, 4]);
}

#[cfg(feature="std")]
#[test]
fn test_write() {
    use std::io::Write;
    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();
    assert_eq!(r, 5);
    assert_eq!(&v[..], &[1, 2, 3, 9, 9, 9, 9, 9]);
}

#[test]
fn array_clone_from() {
    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();
    u.clone_from(&v);
    assert_eq!(&u, &reference[..]);

    let mut t = ArrayVec::<_,  4>::new();
    t.push(vec![97]);
    t.push(vec![]);
    t.push(vec![5, 6, 2]);
    t.push(vec![2]);
    t.clone_from(&v);
    assert_eq!(&t, &reference[..]);
    t.clear();
    t.clone_from(&v);
    assert_eq!(&t, &reference[..]);
}

#[cfg(feature="std")]
#[test]
fn test_string() {
    use std::error::Error;

    let text = "hello world";
    let mut s = ArrayString::<16>::new();
    s.try_push_str(text).unwrap();
    assert_eq!(&s, text);
    assert_eq!(text, &s);

    // Make sure Hash / Eq / Borrow match up so we can use HashMap
    let mut map = HashMap::new();
    map.insert(s, 1);
    assert_eq!(map[text], 1);

    let mut t = ArrayString::<2>::new();
    assert!(t.try_push_str(text).is_err());
    assert_eq!(&t, "");

    t.push_str("ab");
    // DerefMut
    let tmut: &mut str = &mut t;
    assert_eq!(tmut, "ab");

    // Test Error trait / try
    let t = || -> Result<(), Box<dyn Error>> {
        let mut t = ArrayString::<2>::new();
        t.try_push_str(text)?;
        Ok(())
    }();
    assert!(t.is_err());
}

#[test]
fn test_string_from() {
    let text = "hello world";
 // Test `from` constructor
    let u = ArrayString::<11>::from(text).unwrap();
    assert_eq!(&u, text);
    assert_eq!(u.len(), text.len());
}

#[test]
fn test_string_parse_from_str() {
    let text = "hello world";
    let u: ArrayString<11> = text.parse().unwrap();
    assert_eq!(&u, text);
    assert_eq!(u.len(), text.len());
}

#[test]
fn test_string_from_bytes() {
    let text = "hello world";
    let u = ArrayString::from_byte_string(b"hello world").unwrap();
    assert_eq!(&u, text);
    assert_eq!(u.len(), text.len());
}

#[test]
fn test_string_clone() {
    let text = "hi";
    let mut s = ArrayString::<4>::new();
    s.push_str("abcd");
    let t = ArrayString::<4>::from(text).unwrap();
    s.clone_from(&t);
    assert_eq!(&t, &s);
}

#[test]
fn test_string_push() {
    let text = "abcαβγ";
    let mut s = ArrayString::<8>::new();
    for c in text.chars() {
        if let Err(_) = s.try_push(c) {
            break;
        }
    }
    assert_eq!("abcαβ", &s[..]);
    s.push('x');
    assert_eq!("abcαβx", &s[..]);
    assert!(s.try_push('x').is_err());
}


#[test]
fn test_insert_at_length() {
    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());
    assert_eq!(&v[..], &["a", "b"]);
}

#[should_panic]
#[test]
fn test_insert_out_of_bounds() {
    let mut v = ArrayVec::<_,  8>::new();
    let _ = v.try_insert(1, "test");
}

/*
 * insert that pushes out the last
    let mut u = ArrayVec::from([1, 2, 3, 4]);
    let ret = u.try_insert(3, 99);
    assert_eq!(&u[..], &[1, 2, 3, 99]);
    assert_matches!(ret, Err(_));
    let ret = u.try_insert(4, 77);
    assert_eq!(&u[..], &[1, 2, 3, 99]);
    assert_matches!(ret, Err(_));
*/

#[test]
fn test_drop_in_insert() {
    use std::cell::Cell;

    let flag = &Cell::new(0);

    struct Bump<'a>(&'a Cell<i32>);

    impl<'a> Drop for Bump<'a> {
        fn drop(&mut self) {
            let n = self.0.get();
            self.0.set(n + 1);
        }
    }

    flag.set(0);

    {
        let mut array = ArrayVec::<_,  2>::new();
        array.push(Bump(flag));
        array.insert(0, Bump(flag));
        assert_eq!(flag.get(), 0);
        let ret = array.try_insert(1, Bump(flag));
        assert_eq!(flag.get(), 0);
        assert_matches!(ret, Err(_));
        drop(ret);
        assert_eq!(flag.get(), 1);
    }
    assert_eq!(flag.get(), 3);
}

#[test]
fn test_pop_at() {
    let mut v = ArrayVec::<String,  4>::new();
    let s = String::from;
    v.push(s("a"));
    v.push(s("b"));
    v.push(s("c"));
    v.push(s("d"));

    assert_eq!(v.pop_at(4), None);
    assert_eq!(v.pop_at(1), Some(s("b")));
    assert_eq!(v.pop_at(1), Some(s("c")));
    assert_eq!(v.pop_at(2), None);
    assert_eq!(&v[..], &["a", "d"]);
}

#[test]
fn test_sizes() {
    let v = ArrayVec::from([0u8; 1 << 16]);
    assert_eq!(vec![0u8; v.len()], &v[..]);
}

#[test]
fn test_default() {
    use std::net;
    let s: ArrayString<4> = Default::default();
    // Something without `Default` implementation.
    let v: ArrayVec<net::TcpStream,  4> = Default::default();
    assert_eq!(s.len(), 0);
    assert_eq!(v.len(), 0);
}

#[test]
fn test_extend_zst() {
    let mut range = 0..10;
    #[derive(Copy, Clone, PartialEq, Debug)]
    struct Z; // Zero sized type

    let mut array: ArrayVec<_,  5> = range.by_ref().take(5).map(|_| Z).collect();
    assert_eq!(&array[..], &[Z; 5]);
    assert_eq!(range.next(), Some(5));

    array.extend(range.by_ref().take(0).map(|_| Z));
    assert_eq!(range.next(), Some(6));

    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]);
    assert_eq!(array.len(), 5);
}

#[test]
fn test_try_from_argument() {
    use core::convert::TryFrom;
    let v = ArrayString::<16>::try_from(format_args!("Hello {}", 123)).unwrap();
    assert_eq!(&v, "Hello 123");
}

#[test]
fn allow_max_capacity_arrayvec_type() {
    // this type is allowed to be used (but can't be constructed)
    let _v: ArrayVec<(), {usize::MAX}>;
}

#[should_panic(expected="largest supported capacity")]
#[test]
fn deny_max_capacity_arrayvec_value() {
    if mem::size_of::<usize>() <= mem::size_of::<u32>() {
        panic!("This test does not work on this platform. 'largest supported capacity'");
    }
    // this type is allowed to be used (but can't be constructed)
    let _v: ArrayVec<(), {usize::MAX}> = ArrayVec::new();
}

#[should_panic(expected="index out of bounds")]
#[test]
fn deny_max_capacity_arrayvec_value_const() {
    if mem::size_of::<usize>() <= mem::size_of::<u32>() {
        panic!("This test does not work on this platform. 'index out of bounds'");
    }
    // this type is allowed to be used (but can't be constructed)
    let _v: ArrayVec<(), {usize::MAX}> = ArrayVec::new_const();
}

#[test]
fn test_arrayvec_const_constructible() {
    const OF_U8: ArrayVec<Vec<u8>, 10> = ArrayVec::new_const();

    let mut var = OF_U8;
    assert!(var.is_empty());
    assert_eq!(var, ArrayVec::new());
    var.push(vec![3, 5, 8]);
    assert_eq!(var[..], [vec![3, 5, 8]]);
}

#[test]
fn test_arraystring_const_constructible() {
    const AS: ArrayString<10> = ArrayString::new_const();

    let mut var = AS;
    assert!(var.is_empty());
    assert_eq!(var, ArrayString::new());
    var.push_str("hello");
    assert_eq!(var, *"hello");
}


#[test]
fn test_arraystring_zero_filled_has_some_sanity_checks() {
    let string = ArrayString::<4>::zero_filled();
    assert_eq!(string.as_str(), "\0\0\0\0");
    assert_eq!(string.len(), 4);
}